wip

Author: ryukzak

src/api/mustache/generator/SchemaLoaderFacade.ts

@@ -1,39 +1,14 @@
-import type { FilterType } from "@mustache/types";
+import type { MustacheFilter } from "@mustache/types";
 import type { TypeSchemaIndex } from "@root/typeschema/utils";
-import type { Identifier, RegularTypeSchema, TypeSchema } from "@typeschema/types";
+import { type Identifier, isComplexTypeIdentifier, isResourceIdentifier, type TypeSchema } from "@typeschema/types";
 
 export class SchemaLoaderFacade {
-    private readonly complexTypesByUri: Record<string, TypeSchema> = {};
-    private readonly resourcesByUri: Record<string, TypeSchema> = {};
+    private readonly tsIndex: TypeSchemaIndex;
+    private readonly filters: MustacheFilter;
 
-    private readonly childResourceUrisByParentUri: Record<string, string[]> = {};
-    private readonly childComplexTypeUrisByParentUri: Record<string, string[]> = {};
-
-    private complexTypeRefs: Identifier[] | undefined = undefined;
-    private resourceRefs: Identifier[] | undefined = undefined;
-
-    constructor(
-        private readonly tsIndex: TypeSchemaIndex,
-        private readonly filters: { resource?: FilterType; complexType?: FilterType },
-    ) {
-        this.tsIndex.collectComplexTypes().forEach((schema: RegularTypeSchema) => {
-            this.complexTypesByUri[schema.identifier.url] = schema;
-            if (schema.base) {
-                if (!this.childComplexTypeUrisByParentUri[schema.base.url]) {
-                    this.childComplexTypeUrisByParentUri[schema.base.url] = [];
-                }
-                this.childComplexTypeUrisByParentUri[schema.base.url]?.push(schema.identifier.url);
-            }
-        });
-        this.tsIndex.collectResources().forEach((schema: RegularTypeSchema) => {
-            this.resourcesByUri[schema.identifier.url] = schema;
-            if (schema.base) {
-                if (!this.childResourceUrisByParentUri[schema.base.url]) {
-                    this.childResourceUrisByParentUri[schema.base.url] = [];
-                }
-                this.childResourceUrisByParentUri[schema.base.url]?.push(schema.identifier.url);
-            }
-        });
+    constructor(tsIndex: TypeSchemaIndex, filters: MustacheFilter) {
+        this.tsIndex = tsIndex;
+        this.filters = filters;
     }
 
     public get(typeRef: Identifier) {
@@ -47,46 +22,40 @@ export class SchemaLoaderFacade {
     }
 
     public getComplexType(typeRef: Identifier): TypeSchema | undefined {
-        return this.complexTypesByUri[typeRef.url];
+        return this.tsIndex.resolve(typeRef);
     }
     public getResource(typeRef: Identifier): TypeSchema | undefined {
-        return this.resourcesByUri[typeRef.url];
+        return this.tsIndex.resolve(typeRef);
     }
 
     public getChildComplexTypes(parentTypeRef: Identifier): Identifier[] {
-        return (this.childComplexTypeUrisByParentUri[parentTypeRef.url] ?? [])
-            .map((uri) => this.complexTypesByUri[uri])
-            .map((t: any) => t.identifier)
-            .filter((t: any) => this._checkFilter(t))
-            .sort((a: any, b: any) => a.url.localeCompare(b.url));
+        return this.tsIndex
+            .resourceChildren(parentTypeRef)
+            .filter(isComplexTypeIdentifier)
+            .filter((i) => this._checkFilter(i))
+            .sort((a, b) => a.url.localeCompare(b.url));
     }
     public getChildResources(parentTypeRef: Identifier): Identifier[] {
-        return (this.childResourceUrisByParentUri[parentTypeRef.url] ?? [])
-            .map((uri) => this.resourcesByUri[uri])
-            .map((t: any) => t.identifier)
-            .filter((t: any) => this._checkFilter(t))
-            .sort((a: any, b: any) => a.url.localeCompare(b.url));
+        return this.tsIndex
+            .resourceChildren(parentTypeRef)
+            .filter(isResourceIdentifier)
+            .filter((i) => this._checkFilter(i))
+            .sort((a, b) => a.url.localeCompare(b.url));
     }
 
     public getComplexTypes(): Identifier[] {
-        if (this.complexTypeRefs === undefined) {
-            this.complexTypeRefs = this.tsIndex
-                .collectComplexTypes()
-                .map((t: any) => t.identifier)
-                .filter((t: any) => this._checkFilter(t))
-                .sort((a: any, b: any) => a.url.localeCompare(b.url));
-        }
-        return this.complexTypeRefs;
+        return this.tsIndex
+            .collectComplexTypes()
+            .map((i) => i.identifier)
+            .filter((i) => this._checkFilter(i))
+            .sort((a, b) => a.url.localeCompare(b.url));
     }
     public getResources(): Identifier[] {
-        if (this.resourceRefs === undefined) {
-            this.resourceRefs = this.tsIndex
-                .collectResources()
-                .map((t: any) => t.identifier)
-                .filter((t: any) => this._checkFilter(t))
-                .sort((a: any, b: any) => a.url.localeCompare(b.url));
-        }
-        return this.resourceRefs;
+        return this.tsIndex
+            .collectResources()
+            .map((i) => i.identifier)
+            .filter((i) => this._checkFilter(i))
+            .sort((a, b) => a.url.localeCompare(b.url));
     }
 
     private _checkFilter(type: Identifier): boolean {

src/api/mustache/types.ts

@@ -40,6 +40,11 @@ export type FieldViewModel = {
     isReference: boolean;
 };
 
+export type MustacheFilter = {
+    resource?: FilterType;
+    complexType?: FilterType;
+};
+
 export type FilterType = {
     whitelist?: (string | RegExp)[];
     blacklist?: (string | RegExp)[];

src/api/writer-generator/mustache.ts

@@ -14,8 +14,8 @@ import { TemplateFileCache } from "@mustache/generator/TemplateFileCache";
 import type { ViewModelCache } from "@mustache/generator/ViewModelFactory";
 import { ViewModelFactory } from "@mustache/generator/ViewModelFactory";
 import type {
-    FilterType,
     HookType,
+    MustacheFilter,
     NamedViewModel,
     PrimitiveType,
     Rendering,
@@ -37,10 +37,7 @@ export type FileBasedMustacheGeneratorOptions = {
     };
     keywords: string[];
     typeMap: Partial<Record<PrimitiveType, string>>;
-    filters: {
-        resource?: FilterType;
-        complexType?: FilterType;
-    };
+    filters: MustacheFilter;
     meta: {
         timestamp?: string;
         generator?: string;

src/typeschema/types.ts

@@ -87,6 +87,18 @@ export type Identifier =
     | ProfileIdentifier
     | LogicalIdentifier;
 
+export const isResourceIdentifier = (id: Identifier | undefined): id is ResourceIdentifier => {
+    return id?.kind === "resource";
+};
+
+export const isLogicalIdentifier = (id: Identifier | undefined): id is LogicalIdentifier => {
+    return id?.kind === "logical";
+};
+
+export const isComplexTypeIdentifier = (id: Identifier | undefined): id is ComplexTypeIdentifier => {
+    return id?.kind === "complex-type";
+};
+
 export const isPrimitiveIdentifier = (id: Identifier | undefined): id is PrimitiveIdentifier => {
     return id?.kind === "primitive-type";
 };

src/typeschema/utils.ts

@@ -119,7 +119,9 @@ interface TypeRelation {
 }
 
 const resourceRelatives = (schemas: TypeSchema[]): TypeRelation[] => {
-    const regularSchemas = schemas.filter((e) => isResourceTypeSchema(e) || isLogicalTypeSchema(e));
+    const regularSchemas = schemas.filter(
+        (e) => isResourceTypeSchema(e) || isLogicalTypeSchema(e) || isComplexTypeTypeSchema(e),
+    );
     const directPairs: TypeRelation[] = [];
 
     for (const schema of regularSchemas) {