ref: Split resolve into resolve(Identifier) and resolveType(TypeIdentifier)

- resolve(id: Identifier) returns TypeSchema only, no nested
- resolveType(id: TypeIdentifier) returns TypeSchema | NestedTypeSchema
- nestedIndex properly typed as Record<..., NestedTypeSchema>
- Callers passing TypeIdentifier migrated to resolveType

Author: ryukzak

src/api/mustache/generator/ViewModelFactory.ts

@@ -100,7 +100,7 @@ export class ViewModelFactory {
         cache: ViewModelCache,
         nestedIn?: TypeSchema,
     ): TypeViewModel {
-        const type = this.tsIndex.resolve(typeRef);
+        const type = this.tsIndex.resolveType(typeRef);
         if (!type) {
             throw new Error(`ComplexType ${typeRef.name} not found`);
         }
@@ -113,7 +113,7 @@ export class ViewModelFactory {
     }
 
     private _createForResource(typeRef: TypeIdentifier, cache: ViewModelCache, nestedIn?: TypeSchema): TypeViewModel {
-        const type = this.tsIndex.resolve(typeRef);
+        const type = this.tsIndex.resolveType(typeRef);
         if (!type) {
             throw new Error(`Resource ${typeRef.name} not found`);
         }
@@ -126,7 +126,7 @@ export class ViewModelFactory {
     }
 
     private _createChildrenFor(typeRef: TypeIdentifier, cache: ViewModelCache, nestedIn?: TypeSchema): TypeViewModel[] {
-        const schema = this.tsIndex.resolve(typeRef);
+        const schema = this.tsIndex.resolveType(typeRef);
         if (!schema) return [];
         if (isComplexTypeTypeSchema(schema)) {
             return (schema.typeFamily?.complexTypes ?? [])
@@ -146,7 +146,7 @@ export class ViewModelFactory {
         let parentRef: TypeIdentifier | undefined = "base" in base ? base.base : undefined;
         while (parentRef) {
             parents.push(this._createFor(parentRef, cache, undefined));
-            const parent = this.tsIndex.resolve(parentRef);
+            const parent = this.tsIndex.resolveType(parentRef);
             parentRef = parent && "base" in parent ? parent.base : undefined;
         }
         return parents;

src/api/writer-generator/typescript/profile-slices.ts

@@ -22,7 +22,7 @@ import type { TypeScript } from "./writer";
 /** Collect choice declaration field names from a base type schema */
 const collectChoiceBaseNames = (tsIndex: TypeSchemaIndex, typeId: TypeIdentifier): Set<string> => {
     const names = new Set<string>();
-    const schema = tsIndex.resolve(typeId);
+    const schema = tsIndex.resolveType(typeId);
     if (schema && "fields" in schema && schema.fields) {
         for (const [name, f] of Object.entries(schema.fields)) {
             if (isChoiceDeclarationField(f)) names.add(name);

src/api/writer-generator/typescript/profile.ts

@@ -168,7 +168,7 @@ const collectBaseRequiredParams = (
     coveredNames: string[],
 ) => {
     const covered = new Set(coveredNames);
-    const baseSchema = tsIndex.resolve(flatProfile.base);
+    const baseSchema = tsIndex.resolveType(flatProfile.base);
     if (!baseSchema || !("fields" in baseSchema) || !baseSchema.fields) return;
     for (const [name, field] of Object.entries(baseSchema.fields)) {
         if (covered.has(name)) continue;

src/api/writer-generator/typescript/writer.ts

@@ -213,7 +213,7 @@ export class TypeScript extends Writer<TypeScriptOptions> {
         const typeFamilyFields: { fieldName: string; familyTypeName: string }[] = [];
         for (const [fieldName, field] of Object.entries(schema.fields ?? {})) {
             if (isChoiceDeclarationField(field) || !field.type) continue;
-            const fieldTypeSchema = tsIndex.resolve(field.type);
+            const fieldTypeSchema = tsIndex.resolveType(field.type);
             if (
                 isSpecializationTypeSchema(fieldTypeSchema) &&
                 (fieldTypeSchema.typeFamily?.resources?.length ?? 0) > 0

src/typeschema/ir/tree-shake.ts

@@ -259,6 +259,7 @@ export const treeShake = (tsIndex: TypeSchemaIndex, treeShake: TreeShakeConf): T
             if (isSpecializationTypeSchema(schema) || isProfileTypeSchema(schema)) {
                 if (!schema.dependencies) continue;
                 schema.dependencies.forEach((dep) => {
+                    if (isNestedIdentifier(dep)) return;
                     const depSchema = tsIndex.resolve(dep);
                     if (!depSchema)
                         throw new Error(

src/typeschema/utils.ts

@@ -10,11 +10,13 @@ import {
     type ComplexTypeTypeSchema,
     type ConstrainedChoiceInfo,
     type Field,
+    type Identifier,
     isChoiceDeclarationField,
     isChoiceInstanceField,
     isComplexTypeIdentifier,
     isComplexTypeTypeSchema,
     isLogicalTypeSchema,
+    isNestedIdentifier,
     isProfileTypeSchema,
     isResourceIdentifier,
     isResourceTypeSchema,
@@ -159,7 +161,8 @@ export type TypeSchemaIndex = {
     collectResources: () => ResourceTypeSchema[];
     collectLogicalModels: () => LogicalTypeSchema[];
     collectProfiles: () => ProfileTypeSchema[];
-    resolve: (id: TypeIdentifier) => TypeSchema | undefined;
+    resolve: (id: Identifier) => TypeSchema | undefined;
+    resolveType: (id: TypeIdentifier) => TypeSchema | NestedTypeSchema | undefined;
     resolveByUrl: (pkgName: PkgName, url: CanonicalUrl) => TypeSchema | undefined;
     tryHierarchy: (schema: TypeSchema) => TypeSchema[] | undefined;
     hierarchy: (schema: TypeSchema) => TypeSchema[];
@@ -223,11 +226,14 @@ export const mkTypeSchemaIndex = (
     }
     populateTypeFamily(schemas);
 
-    const resolve = (id: TypeIdentifier): TypeSchema | undefined => {
-        if (id.kind === "nested") return nestedIndex[id.url]?.[id.package] as unknown as TypeSchema | undefined;
+    const resolve = (id: Identifier): TypeSchema | undefined => {
         return index[id.url]?.[id.package];
     };
-    const resolveByUrl = (pkgName: PkgName, url: CanonicalUrl) => {
+    const resolveType = (id: TypeIdentifier): TypeSchema | NestedTypeSchema | undefined => {
+        if (isNestedIdentifier(id)) return nestedIndex[id.url]?.[id.package];
+        return index[id.url]?.[id.package];
+    };
+    const resolveByUrl = (pkgName: PkgName, url: CanonicalUrl): TypeSchema | undefined => {
         if (register) {
             const resolutionTree = register.resolutionTree();
             const resolution = resolutionTree[pkgName]?.[url]?.[0];
@@ -247,6 +253,13 @@ export const mkTypeSchemaIndex = (
                 return index[url]?.[anyPkg];
             }
         }
+        if (nestedIndex[url]) {
+            const anyPkg = Object.keys(nestedIndex[url])[0];
+            if (anyPkg) {
+                logger?.dryWarn(`Type '${url}' fallback to package ${anyPkg}`);
+                return nestedIndex[url]?.[anyPkg] as unknown as TypeSchema;
+            }
+        }
         return undefined;
     };
 
@@ -257,6 +270,7 @@ export const mkTypeSchemaIndex = (
             res.push(cur);
             const base = (cur as SpecializationTypeSchema).base;
             if (base === undefined) break;
+            if (isNestedIdentifier(base)) break;
             const resolved = resolve(base);
             if (!resolved) {
                 logger?.warn(
@@ -287,6 +301,11 @@ export const mkTypeSchemaIndex = (
     };
 
     const findLastSpecializationByIdentifier = (id: TypeIdentifier): TypeIdentifier => {
+        if (isNestedIdentifier(id)) {
+            const resolved = resolveType(id);
+            if (!resolved || !("base" in resolved) || !resolved.base) return id;
+            return findLastSpecializationByIdentifier(resolved.base);
+        }
         const schema = resolve(id);
         if (!schema) return id;
         return findLastSpecialization(schema).identifier;
@@ -461,6 +480,7 @@ export const mkTypeSchemaIndex = (
         collectLogicalModels: () => schemas.filter(isLogicalTypeSchema),
         collectProfiles: () => schemas.filter(isProfileTypeSchema),
         resolve,
+        resolveType,
         resolveByUrl,
         tryHierarchy,
         hierarchy,