Models and Collections from api-config

Author: diegomvh

projects/angular-odata/src/lib/api.ts

@@ -62,6 +62,8 @@ export class ODataApi {
   parsers: Map<string, Parser<any>>;
   // Schemas
   schemas: ODataSchema[];
+  models: { [type: string]: typeof ODataModel<any> } = {};
+  collections: { [type: string]: typeof ODataCollection<any, ODataModel<any>> } = {};
 
   constructor(config: ODataApiConfig) {
     this.serviceRootUrl = config.serviceRootUrl;
@@ -85,6 +87,8 @@ export class ODataApi {
     this.parsers = new Map(Object.entries(config.parsers ?? EDM_PARSERS));
 
     this.schemas = (config.schemas ?? []).map((schema) => new ODataSchema(schema, this));
+    this.models = (config.models ?? {}) as {[type: string]: typeof ODataModel<any>};
+    this.collections = (config.collections ?? {}) as {[type: string]: typeof ODataCollection<any, ODataModel<any>>};
   }
 
   configure(
@@ -458,11 +462,11 @@ export class ODataApi {
   }
   //#endregion
 
-  public findModel(type: string) {
-    return this.findStructuredType<any>(type)?.model;
+  public findModel<T>(type: string) {
+    return (this.models[type] ?? this.findStructuredType<any>(type)?.model) as typeof ODataModel<T> | undefined;
   }
 
-  public createModel(structured: ODataStructuredType<any>) {
+  public createModel<T>(structured: ODataStructuredType<T>) {
     if (structured.model !== undefined) return structured.model;
     // Build Ad-hoc model
     const Model = class extends ODataModel<any> {} as typeof ODataModel;
@@ -478,40 +482,40 @@ export class ODataApi {
     }
     // Store New Model for next time
     structured.model = Model;
-    return Model;
+    return Model as typeof ODataModel<T>;
   }
 
-  public modelForType(type: string) {
-    let Model = this.findModel(type);
+  public modelForType<T>(type: string) {
+    let Model = this.findModel<T>(type);
     if (Model === undefined) {
-      const structured = this.findStructuredType<any>(type);
+      const structured = this.findStructuredType<T>(type);
       if (structured === undefined) throw Error(`No structured type for ${type}`);
-      Model = this.createModel(structured);
+      Model = this.createModel<T>(structured);
     }
     return Model;
   }
 
-  public findCollection(type: string) {
-    return this.findStructuredType<any>(type)?.collection;
+  public findCollection<T>(type: string) {
+    return (this.collections[type] ?? this.findStructuredType<any>(type)?.collection) as typeof ODataCollection<T, ODataModel<T>> | undefined;
   }
 
-  public createCollection(structured: ODataStructuredType<any>, model?: typeof ODataModel<any>) {
+  public createCollection<T>(structured: ODataStructuredType<T>, model?: typeof ODataModel<T>) {
     if (structured.collection !== undefined) return structured.collection;
     if (model === undefined) model = this.createModel(structured);
-    const Collection = class extends ODataCollection<any, ODataModel<any>> {
+    const Collection = class extends ODataCollection<T, ODataModel<T>> {
       static override model = model!;
     } as typeof ODataCollection;
     structured.collection = Collection;
-    return Collection;
+    return Collection as typeof ODataCollection<T, ODataModel<T>>;
   }
 
-  public collectionForType(type: string) {
-    let Collection = this.findCollection(type);
+  public collectionForType<T>(type: string) {
+    let Collection = this.findCollection<T>(type);
     if (Collection === undefined) {
-      const structured = this.findStructuredType<any>(type);
+      const structured = this.findStructuredType<T>(type);
       if (structured === undefined) throw Error(`No structured type for ${type}`);
-      const Model = this.modelForType(type);
-      Collection = this.createCollection(structured, Model);
+      const Model = this.modelForType<T>(type);
+      Collection = this.createCollection<T>(structured, Model) as typeof ODataCollection<T, ODataModel<T>>;
     }
     return Collection;
   }

projects/angular-odata/src/lib/models/collection.ts

@@ -30,7 +30,7 @@ import {
 import { ODataEntitiesAnnotations, ODataEntityAnnotations } from '../annotations';
 
 export class ODataCollection<T, M extends ODataModel<T>> implements Iterable<M> {
-  static model: typeof ODataModel | null = null;
+  static model: typeof ODataModel<any> | null = null;
   _parent:
     | [ODataModel<any> | ODataCollection<any, ODataModel<any>>, ODataModelField<any> | null]
     | null = null;

projects/angular-odata/src/lib/resources/resource.ts

@@ -127,7 +127,7 @@ export class ODataResource<T> {
     }: {
       reset?: boolean;
       annots?: ODataEntityAnnotations<T>;
-      ModelType?: typeof ODataModel;
+      ModelType?: typeof ODataModel<T>;
     },
   ): M;
   asModel(
@@ -139,14 +139,14 @@ export class ODataResource<T> {
     }: {
       reset?: boolean;
       annots?: ODataEntityAnnotations<T>;
-      ModelType?: typeof ODataModel;
+      ModelType?: typeof ODataModel<any>;
     } = {},
   ) {
     reset ??= annots !== undefined;
     let resource: ODataResource<T> = this as ODataResource<T>;
     const type = annots?.type ?? this.incomingType();
     if (type === undefined) throw Error(`No type for model`);
-    if (ModelType === undefined) ModelType = this.api.modelForType(type);
+    if (ModelType === undefined) ModelType = this.api.modelForType<T>(type);
     let entitySet = annots?.entitySet;
     if (entitySet !== undefined) {
       resource = this.api.entitySet<T>(entitySet).entity(entity as Partial<T>);
@@ -182,7 +182,7 @@ export class ODataResource<T> {
     }: {
       reset?: boolean;
       annots?: ODataEntitiesAnnotations<T>;
-      CollectionType?: typeof ODataCollection;
+      CollectionType?: typeof ODataCollection<T, M>;
     },
   ): C;
   asCollection(
@@ -194,14 +194,14 @@ export class ODataResource<T> {
     }: {
       reset?: boolean;
       annots?: ODataEntitiesAnnotations<T>;
-      CollectionType?: typeof ODataCollection;
+      CollectionType?: typeof ODataCollection<any, ODataModel<any>>;
     } = {},
   ) {
     reset ??= annots !== undefined;
     let resource: ODataResource<T> = this as ODataResource<T>;
     const type = annots?.type ?? this.incomingType();
     if (type === undefined) throw Error(`No type for collection`);
-    if (CollectionType === undefined) CollectionType = this.api.collectionForType(type);
+    if (CollectionType === undefined) CollectionType = this.api.collectionForType<T>(type);
     let entitySet = annots?.entitySet;
     if (entitySet !== undefined) {
       resource = this.api.entitySet<T>(entitySet);

projects/angular-odata/src/lib/schema/structured-type.ts

@@ -17,14 +17,14 @@ export class ODataStructuredType<T> extends ODataParserSchemaElement<
   base?: string;
   parent?: ODataStructuredType<any>;
   children: ODataStructuredType<any>[] = [];
-  model?: typeof ODataModel;
-  collection?: typeof ODataCollection;
+  model?: typeof ODataModel<any>;
+  collection?: typeof ODataCollection<any, ODataModel<any>>;
 
   constructor(config: ODataStructuredTypeConfig, schema: ODataSchema) {
     super(config, schema, new ODataStructuredTypeParser(config, schema.namespace, schema.alias));
     this.base = config.base;
-    this.model = config.model as typeof ODataModel;
-    this.collection = config.collection as typeof ODataCollection;
+    this.model = config.model as typeof ODataModel<any>;
+    this.collection = config.collection as typeof ODataCollection<any, ODataModel<any>>;
   }
 
   configure({ options }: { options: ParserOptions }) {

projects/angular-odata/src/lib/types.ts

@@ -219,6 +219,8 @@ export type ODataApiConfig = {
   parsers?: { [type: string]: Parser<any> };
   schemas?: ODataSchemaConfig[];
   references?: ODataReferenceConfig[];
+  models?: {[type: string]: { new (...params: any[]): any }};
+  collections?: {[type: string]: { new (...params: any[]): any }};
 };
 export type ODataAnnotationConfig = {
   term: string;