Refactor: Add async initialization with metadata population and reference support

Author: Diego van Haaster

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

@@ -1,5 +1,5 @@
 import { HttpEvent, HttpEventType } from '@angular/common/http';
-import { NEVER, Observable, of, throwError } from 'rxjs';
+import { firstValueFrom, NEVER, Observable, of, throwError } from 'rxjs';
 import { catchError, map, startWith, tap } from 'rxjs/operators';
 import { DEFAULT_VERSION } from './constants';
 import {
@@ -54,6 +54,7 @@ import {
 } from './types';
 import type { ODataMetadata } from './metadata/metadata';
 import { ODataEntityAnnotations } from './annotations';
+import { ODataReference } from './schema/reference';
 
 const RESERVED_FIELD_NAMES = Object.getOwnPropertyNames(ODataModel.prototype);
 
@@ -76,8 +77,12 @@ export class ODataApi {
   errorHandler?: (error: any, caught: Observable<any>) => Observable<never>;
   // Base Parsers
   parsers: Map<string, Parser<any>>;
+  // Populate from Metadata 
+  populateFromMetadata: boolean;
   // Schemas
   schemas: ODataSchema[];
+  // References
+  references: ODataReference[];
   // Models
   models: { [type: string]: typeof ODataModel<any> } = {};
   // Collections
@@ -104,19 +109,17 @@ export class ODataApi {
     this.errorHandler = config.errorHandler;
     this.parsers = new Map(Object.entries(config.parsers ?? EDM_PARSERS));
 
+    this.populateFromMetadata = config.populateFromMetadata ?? false;
     this.schemas = (config.schemas ?? []).map((schema) => new ODataSchema(schema, this));
+    this.references = (config.references ?? []).map((reference) => new ODataReference(reference, this));
     this.models = (config.models ?? {}) as { [type: string]: typeof ODataModel<any> };
     this.collections = (config.collections ?? {}) as {
       [type: string]: typeof ODataCollection<any, ODataModel<any>>;
     };
   }
 
-  configure(
-    settings: {
-      requester?: (request: ODataRequest<any>) => Observable<any>;
-    } = {},
-  ) {
-    this.requester = settings.requester;
+  initialize(requester: (request: ODataRequest<any>) => Observable<any>) {
+    this.requester = requester;
     this.schemas.forEach((schema) => {
       schema.configure({
         options: this.options.parserOptions,
@@ -132,6 +135,9 @@ export class ODataApi {
         }
       }
     });
+    return (this.populateFromMetadata) ?
+      firstValueFrom(this.metadata().fetch().pipe(map(metadata => this.populate(metadata)))) :
+      Promise.resolve(true);
   }
 
   populate(metadata: ODataMetadata) {
@@ -144,6 +150,7 @@ export class ODataApi {
         options: this.options.parserOptions,
       });
     });
+    return true;
   }
 
   fromJson<P, R>(json: {

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

@@ -47,11 +47,12 @@ export class ODataClient {
   constructor(private loader: ODataLoader) {}
 
   initialize() {
-    return this.loader.load().then(({configs, requester}) => {
+    return this.loader.load()
+    .then(({configs, requester}) => {
       this.settings = new ODataSettings(configs);
-      this.settings.configure({requester});
-      return true;
-    });
+      return this.settings.initialize(requester);
+    })
+    .then(results => results.every(v => v));
   }
 
   //#region Resolve Building Blocks

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

@@ -46,9 +46,7 @@ export function provideODataClient(passedConfig: PassedInitialConfig): Environme
     // Make the ODATA_CONFIG available through injection
     { provide: ODATA_CONFIG, useValue: passedConfig.config ?? [] },
     // Register the startup task
-    provideAppInitializer(() => {
-      return inject(ODataClient).initialize();
-    }),
+    provideAppInitializer(() => inject(ODataClient).initialize()),
     ODataClient,
     ODataServiceFactory,
   ];
@@ -76,9 +74,7 @@ export class ODataModule {
       // Make the ODATA_CONFIG available through injection
       { provide: ODATA_CONFIG, useValue: passedConfig.config ?? []},
       // Register the startup task
-      provideAppInitializer(() => {
-        return inject(ODataClient).initialize();
-      }),
+      provideAppInitializer(() => inject(ODataClient).initialize()),
       ODataClient,
       ODataServiceFactory,
     ];

projects/angular-odata/src/lib/schema/reference.ts

@@ -0,0 +1,55 @@
+import { ODataApi } from '../api';
+import { ParserOptions, ODataReferenceConfig } from '../types';
+import { ODataAnnotatable } from './annotation';
+
+export class ODataInclude {
+  namespace: string;
+  alias?: string;
+  reference: ODataReference;
+  constructor(config: {namespace: string, alias?: string}, reference: ODataReference) {
+    this.namespace = config.namespace;
+    this.alias = config.alias;
+    this.reference = reference;
+  }
+
+  configure({ options }: { options: ParserOptions }) {
+  }
+}
+
+export class ODataIncludeAnnotation {
+  termNamespace: string;
+  qualifier?: string;
+  targetNamespace?: string;
+  reference: ODataReference;
+  constructor(config: {termNamespace: string, qualifier?: string, targetNamespace?: string}, reference: ODataReference) {
+    this.termNamespace = config.termNamespace; 
+    this.qualifier = config.qualifier;
+    this.targetNamespace = config.targetNamespace;
+    this.reference = reference;
+  }
+
+  configure({ options }: { options: ParserOptions }) {
+  }
+}
+
+export class ODataReference extends ODataAnnotatable {
+  api: ODataApi;
+  uri: string;
+  includes: ODataInclude[]
+  includeAnnotations: ODataIncludeAnnotation[]
+
+  constructor(config: ODataReferenceConfig, api: ODataApi) {
+    super(config);
+    this.api = api;
+    this.uri = config.uri;
+    this.includes = (config.includes ?? []).map((config) => new ODataInclude(config, this));
+    this.includeAnnotations = (config.includeAnnotations ?? []).map((config) => new ODataIncludeAnnotation(config, this));
+  }
+
+  configure({ options }: { options: ParserOptions }) {
+    // Configure Includes
+    this.includes.forEach((include) => include.configure({ options }));
+    // Configure IncludeAnnotations
+    this.includeAnnotations.forEach((includeAnnotation) => includeAnnotation.configure({ options }));
+  }
+}

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

@@ -19,8 +19,10 @@ export class ODataSettings {
     if (this.apis.every((c) => !c.default)) this.apis[0].default = true;
   }
 
-  configure(settings: { requester?: (request: ODataRequest<any>) => Observable<any> }) {
-    this.apis.forEach((api) => api.configure(settings));
+  initialize(requester: (request: ODataRequest<any>) => Observable<any>) {
+    return Promise.all(
+      this.apis.map((api) => api.initialize(requester))
+    );
   }
 
   public defaultApi() {

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

@@ -1,7 +1,6 @@
 import type { JSONSchema7 } from 'json-schema';
 import type { Observable } from 'rxjs';
-import type { ODataModel, ODataModelOptions } from './models';
-import type { EntityKey, ODataRequest, ODataResponse } from './resources';
+import type { ODataRequest, ODataResponse } from './resources';
 
 export type ODataVersion = '2.0' | '3.0' | '4.0';
 export type FetchPolicy =
@@ -242,6 +241,7 @@ export type ODataApiConfig = {
   errorHandler?: (error: any, caught: Observable<any>) => Observable<never>;
   options?: ODataApiConfigOptions;
   parsers?: { [type: string]: Parser<any> };
+  populateFromMetadata?: boolean;
   schemas?: ODataSchemaConfig[];
   references?: ODataReferenceConfig[];
   models?: { [type: string]: { new (...params: any[]): any } };
@@ -257,12 +257,13 @@ export type ODataAnnotationConfig = {
 };
 export type ODataReferenceConfig = {
   uri: string;
-  includes?: string;
   annotations?: ODataAnnotationConfig[];
-  enums?: ODataEnumTypeConfig[];
-  entities?: ODataStructuredTypeConfig[];
-  callables?: ODataCallableConfig[];
-  containers?: ODataEntityContainerConfig[];
+  includes?: { namespace: string; alias?: string; }[];
+  includeAnnotations?: {
+    termNamespace: string; 
+    qualifier?: string;
+    targetNamespace?: string; 
+  }[] 
 };
 export type ODataSchemaConfig = {
   namespace: string;