angular-odata 0.140.0 → 0.141.0

package/fesm2022/angular-odata.mjs

@@ -497,21 +497,19 @@ const SUPPORTED_EXPAND_PROPERTIES = [
 ];
 const FUNCTION_REGEX = /\((.*)\)/;
 const INDEXOF_REGEX = /(?!indexof)\((\w+)\)/;
-var StandardAggregateMethods;
-(function (StandardAggregateMethods) {
-    StandardAggregateMethods["sum"] = "sum";
-    StandardAggregateMethods["min"] = "min";
-    StandardAggregateMethods["max"] = "max";
-    StandardAggregateMethods["average"] = "average";
-    StandardAggregateMethods["countdistinct"] = "countdistinct";
-})(StandardAggregateMethods || (StandardAggregateMethods = {}));
-var QueryCustomTypes;
-(function (QueryCustomTypes) {
-    QueryCustomTypes[QueryCustomTypes["Raw"] = 0] = "Raw";
-    QueryCustomTypes[QueryCustomTypes["Alias"] = 1] = "Alias";
-    QueryCustomTypes[QueryCustomTypes["Duration"] = 2] = "Duration";
-    QueryCustomTypes[QueryCustomTypes["Binary"] = 3] = "Binary";
-})(QueryCustomTypes || (QueryCustomTypes = {}));
+const StandardAggregateMethods = {
+    sum: 'sum',
+    min: 'min',
+    max: 'max',
+    average: 'average',
+    countdistinct: 'countdistinct'
+};
+const QueryCustomTypes = {
+    Raw: 'Raw',
+    Alias: 'Alias',
+    Duration: 'Duration',
+    Binary: 'Binary'
+};
 //https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_QueryOptions
 const raw = (value) => ({
     type: QueryCustomTypes.Raw,
@@ -887,10 +885,8 @@ function buildFilter(filters = {}, { aliases, propPrefix, escape, }) {
     }
 }
 function getStringCollectionClause(lambdaParameter, value, collectionOperator, propName) {
-    let clause = '';
     const conditionOperator = collectionOperator == 'all' ? 'ne' : 'eq';
-    clause = `${propName}/${collectionOperator}(${lambdaParameter}: ${lambdaParameter} ${conditionOperator} '${value}')`;
-    return clause;
+    return `${propName}/${collectionOperator}(${lambdaParameter}: ${lambdaParameter} ${conditionOperator} '${value}')`;
 }
 function escapeIllegalChars(string) {
     string = string.replace(/%/g, '%25');
@@ -1028,27 +1024,40 @@ function buildTransforms(transforms, { aliases, escape = false }) {
     // Wrap single object an array for simplified processing
     const transformsArray = Array.isArray(transforms) ? transforms : [transforms];
     const transformsResult = transformsArray.reduce((result, transform) => {
-        const { aggregate, filter, groupBy, ...rest } = transform;
-        // TODO: support as many of the following:
-        //   topcount, topsum, toppercent,
-        //   bottomsum, bottomcount, bottompercent,
-        //   identity, concat, expand, search, compute, isdefined
-        const unsupportedKeys = Object.keys(rest);
-        if (unsupportedKeys.length) {
-            throw new Error(`Unsupported transform(s): ${unsupportedKeys}`);
-        }
-        if (aggregate) {
-            result.push(`aggregate(${buildAggregate(aggregate)})`);
-        }
-        if (filter) {
-            const builtFilter = buildFilter(filter, { aliases, escape });
-            if (builtFilter) {
-                result.push(`filter(${buildFilter(builtFilter, { aliases, escape })})`);
+        for (const key of Object.keys(transform)) {
+            switch (key) {
+                // TODO: support as many of the following:
+                //   topcount, topsum, toppercent,
+                //   bottomsum, bottomcount, bottompercent,
+                //   identity, concat, expand, search, compute, isdefined
+                case 'aggregate': {
+                    const aggregate = transform[key];
+                    if (aggregate) {
+                        result.push(`aggregate(${buildAggregate(aggregate)})`);
+                    }
+                    break;
+                }
+                case 'filter': {
+                    const filter = transform[key];
+                    if (filter) {
+                        const builtFilter = buildFilter(filter, { aliases, escape });
+                        if (builtFilter) {
+                            result.push(`filter(${builtFilter})`);
+                        }
+                    }
+                    break;
+                }
+                case 'groupBy': {
+                    const groupBy = transform[key];
+                    if (groupBy) {
+                        result.push(`groupby(${buildGroupBy(groupBy, { aliases, escape })})`);
+                    }
+                    break;
+                }
+                default:
+                    throw new Error(`Unsupported transform(s): ${key}`);
             }
         }
-        if (groupBy) {
-            result.push(`groupby(${buildGroupBy(groupBy, { aliases, escape })})`);
-        }
         return result;
     }, []);
     return transformsResult.join('/') || undefined;
@@ -2977,14 +2986,7 @@ class ODataStructuredType extends ODataParserSchemaElement {
             parserForType: (t) => this.api.parserForType(t),
         });
         if (this.model !== undefined) {
-            this.model.meta = this.api.optionsForType(this.type(), {
-                config: this.model.options,
-                structuredType: this,
-            });
-            if (this.model.meta !== undefined) {
-                // Configure
-                this.model.meta.configure({ options });
-            }
+            this.api.configureModel(this, this.model);
             if (this.collection !== undefined) {
                 this.collection.model = this.model;
             }
@@ -9177,7 +9179,7 @@ class ODataMetadataParser {
         try {
             const parser = new DOMParser();
             this.document = parser.parseFromString(xml, 'text/xml');
-            this.checkVersion(document);
+            this.checkVersion(this.document);
         }
         catch (error) {
             throw new Error('Unable to parse metadata, ' + error);
@@ -9207,9 +9209,9 @@ class ODataMetadataParser {
         ]);
         return new ODataMetadata(version, references, schemas);
     }
-    checkVersion(document) {
+    checkVersion(doc) {
         // check version
-        const attributes = document.documentElement.attributes;
+        const attributes = doc.documentElement.attributes;
         if (!attributes) {
             throw new Error('OData version is not specified in the metadata');
         }
@@ -12789,6 +12791,10 @@ class ODataApi {
     parsers;
     // Schemas
     schemas;
+    // Models
+    models = {};
+    // Collections
+    collections = {};
     constructor(config) {
         this.serviceRootUrl = config.serviceRootUrl;
         if (this.serviceRootUrl.includes('?'))
@@ -12808,6 +12814,8 @@ class ODataApi {
         this.errorHandler = config.errorHandler;
         this.parsers = new Map(Object.entries(config.parsers ?? EDM_PARSERS));
         this.schemas = (config.schemas ?? []).map((schema) => new ODataSchema(schema, this));
+        this.models = (config.models ?? {});
+        this.collections = (config.collections ?? {});
     }
     configure(settings = {}) {
         this.requester = settings.requester;
@@ -12816,6 +12824,16 @@ class ODataApi {
                 options: this.options.parserOptions,
             });
         });
+        Object.entries(this.models).forEach(([type, model]) => {
+            const structured = this.findStructuredType(type);
+            if (structured !== undefined) {
+                this.configureModel(structured, model);
+                const collection = this.collections[type];
+                if (collection !== undefined) {
+                    collection.model = model;
+                }
+            }
+        });
     }
     populate(metadata) {
         const config = metadata.toConfig();
@@ -13084,8 +13102,18 @@ class ODataApi {
         return singleton;
     }
     //#endregion
+    configureModel(structured, model) {
+        model.meta = this.optionsForType(structured.type(), {
+            config: model.options,
+            structuredType: structured,
+        });
+        if (model.meta !== undefined) {
+            // Configure
+            model.meta.configure({ options: this.options.parserOptions });
+        }
+    }
     findModel(type) {
-        return this.findStructuredType(type)?.model;
+        return (this.models[type] ?? this.findStructuredType(type)?.model);
     }
     createModel(structured) {
         if (structured.model !== undefined)
@@ -13093,17 +13121,7 @@ class ODataApi {
         // Build Ad-hoc model
         const Model = class extends ODataModel {
         };
-        // Build Meta
-        Model.meta = this.optionsForType(structured.type(), {
-            structuredType: structured,
-        });
-        if (Model.meta !== undefined) {
-            // Configure
-            Model.meta.configure({
-                options: this.options.parserOptions,
-            });
-        }
-        // Store New Model for next time
+        // Store New Model structured for next time
         structured.model = Model;
         return Model;
     }
@@ -13114,20 +13132,23 @@ class ODataApi {
             if (structured === undefined)
                 throw Error(`No structured type for ${type}`);
             Model = this.createModel(structured);
+            this.configureModel(structured, Model);
         }
         return Model;
     }
     findCollection(type) {
-        return this.findStructuredType(type)?.collection;
+        return (this.collections[type] ?? this.findStructuredType(type)?.collection);
     }
     createCollection(structured, model) {
         if (structured.collection !== undefined)
             return structured.collection;
         if (model === undefined)
             model = this.createModel(structured);
+        // Build Ad-hoc collection
         const Collection = class extends ODataCollection {
             static model = model;
         };
+        // Store New Collection structured for next time
         structured.collection = Collection;
         return Collection;
     }