angular-odata 0.92.0 → 0.95.0

package/esm2020/lib/resources/types/singleton.mjs

@@ -0,0 +1,126 @@
+import { map } from 'rxjs/operators';
+import { PathSegmentNames } from '../../types';
+import { ODataPathSegments } from '../path';
+import { ODataResource } from '../resource';
+import { ODataActionResource } from './action';
+import { ODataFunctionResource } from './function';
+import { ODataNavigationPropertyResource } from './navigation-property';
+import { ODataPropertyResource } from './property';
+export class ODataSingletonResource extends ODataResource {
+    //#region Factory
+    static factory(api, { path, schema, query, }) {
+        const segments = new ODataPathSegments();
+        const segment = segments.add(PathSegmentNames.singleton, path);
+        if (schema !== undefined)
+            segment.type(schema.type());
+        return new ODataSingletonResource(api, { segments, query, schema });
+    }
+    //#endregion
+    key(value) {
+        const singleton = this.clone();
+        var key = this.resolveKey(value);
+        if (key !== undefined)
+            singleton.segment((s) => s.singleton().key(key));
+        return singleton;
+    }
+    keys(values) {
+        const singleton = this.clone();
+        const types = this.pathSegments.types({ key: true });
+        const keys = values.map((value, index) => ODataResource.resolveKey(value, this.api.findStructuredTypeForType(types[index])));
+        singleton.segment((s) => s.keys(keys));
+        return singleton;
+    }
+    navigationProperty(path) {
+        return ODataNavigationPropertyResource.fromResource(this, path);
+    }
+    property(path) {
+        return ODataPropertyResource.fromResource(this, path);
+    }
+    action(path) {
+        return ODataActionResource.fromResource(this, path);
+    }
+    function(path) {
+        return ODataFunctionResource.fromResource(this, path);
+    }
+    //#region Requests
+    post(attrs, options = {}) {
+        return super.post(attrs, { responseType: 'entity', ...options });
+    }
+    put(attrs, options = {}) {
+        return super.put(attrs, { responseType: 'entity', ...options });
+    }
+    patch(attrs, options = {}) {
+        return super.patch(attrs, { responseType: 'entity', ...options });
+    }
+    delete(options = {}) {
+        return super.delete({ responseType: 'entity', ...options });
+    }
+    get(options = {}) {
+        return super.get({ responseType: 'entity', ...options });
+    }
+    //#endregion
+    //#region Shortcuts
+    /**
+     * Creates a new entity.
+     * @param attrs The entity attributes to create.
+     * @param options The options for the request.
+     * @returns The created entity with the annotations.
+     */
+    create(attrs, options) {
+        return this.post(attrs, options);
+    }
+    /**
+     * Updates an existing entity.
+     * @param attrs The entity attributes to update.
+     * @param options The options for the request.
+     * @returns The updated entity with the annotations.
+     */
+    update(attrs, options) {
+        return this.put(attrs, options);
+    }
+    /**
+     * Modifies an existing entity.
+     * @param attrs The entity attributes to modify.
+     * @param options The options for the request.
+     * @returns The modified entity with the annotations.
+     */
+    modify(attrs, options) {
+        return this.patch(attrs, options);
+    }
+    /**
+     * Delete an existing entity.
+     * @param options The options for the request.
+     * @returns Observable of the deleted entity.
+     */
+    destroy(options) {
+        return this.delete(options);
+    }
+    /**
+     * Fetch an existing entity.
+     * @param options The options for the request.
+     * @param etag The etag to use for the request.
+     * @returns Observable of the entity with the annotations.
+     */
+    fetch(options) {
+        return this.get(options);
+    }
+    /**
+     * Fetch an existing entity.
+     * @param options The options for the request.
+     * @param etag The etag to use for the request.
+     * @returns Observable of the entity.
+     */
+    fetchEntity(options) {
+        return this.fetch(options).pipe(map(({ entity }) => entity));
+    }
+    /**
+     * Fetch an existing entity and return a model.
+     * @param options The options for the request.
+     * @param etag The etag to use for the request.
+     * @returns Observable of the entity.
+     */
+    fetchModel(options) {
+        return this.fetch(options).pipe(map(({ entity, annots }) => entity ? this.asModel(entity, { annots, reset: true }) : null));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"singleton.js","sourceRoot":"","sources":["../../../../../../projects/angular-odata/src/lib/resources/types/singleton.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { ODataApi } from '../../api';\nimport { ODataModel } from '../../models';\nimport { ODataStructuredType } from '../../schema';\nimport { PathSegmentNames, QueryOptionNames } from '../../types';\nimport { ODataPathSegments } from '../path';\nimport { ODataQueryOptions } from '../query';\nimport { ODataResource } from '../resource';\nimport { ODataEntity } from '../responses';\nimport { ODataActionResource } from './action';\nimport { ODataFunctionResource } from './function';\nimport { ODataNavigationPropertyResource } from './navigation-property';\nimport { ODataOptions } from './options';\nimport { ODataPropertyResource } from './property';\n\nexport class ODataSingletonResource<T> extends ODataResource<T> {\n  //#region Factory\n  static factory<S>(\n    api: ODataApi,\n    {\n      path,\n      schema,\n      query,\n    }: {\n      path: string;\n      schema?: ODataStructuredType<S>;\n      query?: ODataQueryOptions<S>;\n    }\n  ) {\n    const segments = new ODataPathSegments();\n    const segment = segments.add(PathSegmentNames.singleton, path);\n    if (schema !== undefined) segment.type(schema.type());\n    return new ODataSingletonResource<S>(api, { segments, query, schema });\n  }\n  //#endregion\n\n  key(value: any) {\n    const singleton = this.clone<ODataSingletonResource<T>>();\n    var key = this.resolveKey(value);\n    if (key !== undefined) singleton.segment((s) => s.singleton().key(key));\n    return singleton;\n  }\n\n  keys(values: any[]) {\n    const singleton = this.clone<ODataSingletonResource<T>>();\n    const types = this.pathSegments.types({ key: true });\n    const keys = values.map((value, index) =>\n      ODataResource.resolveKey(\n        value,\n        this.api.findStructuredTypeForType<T>(types[index])\n      )\n    );\n    singleton.segment((s) => s.keys(keys));\n    return singleton;\n  }\n\n  navigationProperty<N>(path: string) {\n    return ODataNavigationPropertyResource.fromResource<N>(this, path);\n  }\n\n  property<P>(path: string) {\n    return ODataPropertyResource.fromResource<P>(this, path);\n  }\n\n  action<P, R>(path: string) {\n    return ODataActionResource.fromResource<P, R>(this, path);\n  }\n\n  function<P, R>(path: string) {\n    return ODataFunctionResource.fromResource<P, R>(this, path);\n  }\n\n  //#region Requests\n  protected override post(\n    attrs: Partial<T>,\n    options: ODataOptions = {}\n  ): Observable<ODataEntity<T>> {\n    return super.post(attrs, { responseType: 'entity', ...options });\n  }\n\n  protected override put(\n    attrs: Partial<T>,\n    options: ODataOptions & { etag?: string } = {}\n  ): Observable<ODataEntity<T>> {\n    return super.put(attrs, { responseType: 'entity', ...options });\n  }\n\n  protected override patch(\n    attrs: Partial<T>,\n    options: ODataOptions & { etag?: string } = {}\n  ): Observable<ODataEntity<T>> {\n    return super.patch(attrs, { responseType: 'entity', ...options });\n  }\n\n  protected override delete(\n    options: ODataOptions & { etag?: string } = {}\n  ): Observable<any> {\n    return super.delete({ responseType: 'entity', ...options });\n  }\n\n  protected override get(\n    options: ODataOptions & {\n      etag?: string;\n      bodyQueryOptions?: QueryOptionNames[];\n    } = {}\n  ): Observable<ODataEntity<T>> {\n    return super.get({ responseType: 'entity', ...options });\n  }\n  //#endregion\n\n  //#region Shortcuts\n  /**\n   * Creates a new entity.\n   * @param attrs The entity attributes to create.\n   * @param options The options for the request.\n   * @returns The created entity with the annotations.\n   */\n  create(\n    attrs: Partial<T>,\n    options?: ODataOptions\n  ): Observable<ODataEntity<T>> {\n    return this.post(attrs, options);\n  }\n\n  /**\n   * Updates an existing entity.\n   * @param attrs The entity attributes to update.\n   * @param options The options for the request.\n   * @returns The updated entity with the annotations.\n   */\n  update(\n    attrs: Partial<T>,\n    options?: ODataOptions & { etag?: string }\n  ): Observable<ODataEntity<T>> {\n    return this.put(attrs, options);\n  }\n\n  /**\n   * Modifies an existing entity.\n   * @param attrs The entity attributes to modify.\n   * @param options The options for the request.\n   * @returns The modified entity with the annotations.\n   */\n  modify(\n    attrs: Partial<T>,\n    options?: ODataOptions & { etag?: string }\n  ): Observable<ODataEntity<T>> {\n    return this.patch(attrs, options);\n  }\n\n  /**\n   * Delete an existing entity.\n   * @param options The options for the request.\n   * @returns Observable of the deleted entity.\n   */\n  destroy(options?: ODataOptions & { etag?: string }): Observable<any> {\n    return this.delete(options);\n  }\n\n  /**\n   * Fetch an existing entity.\n   * @param options The options for the request.\n   * @param etag The etag to use for the request.\n   * @returns Observable of the entity with the annotations.\n   */\n  fetch(\n    options?: ODataOptions & {\n      etag?: string;\n      bodyQueryOptions?: QueryOptionNames[];\n    }\n  ): Observable<ODataEntity<T>> {\n    return this.get(options);\n  }\n\n  /**\n   * Fetch an existing entity.\n   * @param options The options for the request.\n   * @param etag The etag to use for the request.\n   * @returns Observable of the entity.\n   */\n  fetchEntity(\n    options?: ODataOptions & {\n      etag?: string;\n      bodyQueryOptions?: QueryOptionNames[];\n    }\n  ): Observable<T | null> {\n    return this.fetch(options).pipe(map(({ entity }) => entity));\n  }\n\n  /**\n   * Fetch an existing entity and return a model.\n   * @param options The options for the request.\n   * @param etag The etag to use for the request.\n   * @returns Observable of the entity.\n   */\n  fetchModel<M extends ODataModel<T>>(\n    options?: ODataOptions & {\n      etag?: string;\n      bodyQueryOptions?: QueryOptionNames[];\n    }\n  ): Observable<M | null> {\n    return this.fetch(options).pipe(\n      map(({ entity, annots }) =>\n        entity ? this.asModel<M>(entity, { annots, reset: true }) : null\n      )\n    );\n  }\n  //#endregion\n}\n"]}

package/esm2020/lib/resources/types/value.mjs

@@ -0,0 +1,41 @@
+import { $VALUE } from '../../constants';
+import { PathSegmentNames } from '../../types';
+import { ODataResource } from '../resource';
+export class ODataValueResource extends ODataResource {
+    //#region Factory
+    static factory(api, { type, schema, segments, query, }) {
+        const baseType = type;
+        const bindingType = schema?.type();
+        const segment = segments.add(PathSegmentNames.value, $VALUE);
+        if (schema !== undefined)
+            segment.type(schema.type());
+        else if (type !== undefined)
+            segment.type(type);
+        query?.clear();
+        const value = new ODataValueResource(api, { segments, query, schema });
+        // Switch entitySet to binding type if available
+        if (bindingType !== undefined && bindingType !== baseType) {
+            let entitySet = api.findEntitySetForType(bindingType);
+            if (entitySet !== undefined) {
+                value.segment((s) => s.entitySet().path(entitySet.name));
+            }
+        }
+        return value;
+    }
+    //#endregion
+    //#region Requests
+    get(options) {
+        return super.get({ responseType: 'value', ...options });
+    }
+    //#endregion
+    //#region Shortcuts
+    /**
+     * Fetch the value of the resource.
+     * @param options OData options.
+     * @returns Observable of the value.
+     */
+    fetch(options) {
+        return this.get(options);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/schema/annotation.mjs

@@ -0,0 +1,37 @@
+export class ODataAnnotation {
+    constructor(annot) {
+        this.term = annot.term;
+        Object.assign(this, annot);
+    }
+}
+export class ODataAnnotatable {
+    constructor(config) {
+        this.annotations = (config.annotations || []).map((annot) => new ODataAnnotation(annot));
+    }
+    /**
+     * Find an annotation inside the annotatable.
+     * @param predicate Function that returns true if the annotation match.
+     * @returns The annotation that matches the predicate.
+     */
+    findAnnotation(predicate) {
+        return this.annotations.find(predicate);
+    }
+    /**
+     * Find an annotation inside the annotatable and return its value.
+     * @param term The term of the annotation to find.
+     * @returns The value of the annotation.
+     */
+    annotatedValue(term) {
+        const reg = term instanceof RegExp ? term : new RegExp(`^${term}$`);
+        const annot = this.findAnnotation((a) => reg.test(a.term));
+        if (!annot) {
+            return undefined;
+        }
+        return (annot.string ||
+            annot.bool ||
+            annot.int ||
+            annot.permissions ||
+            annot.properties);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/schema/callable.mjs

@@ -0,0 +1,62 @@
+import { ODataSchemaElement } from './element';
+import { ODataCallableParser } from './parsers';
+export class ODataCallable extends ODataSchemaElement {
+    constructor(config, schema) {
+        super(config, schema);
+        this.entitySetPath = config.entitySetPath;
+        this.bound = config.bound;
+        this.composable = config.composable;
+        this.parser = new ODataCallableParser(config, schema.namespace, schema.alias);
+    }
+    path() {
+        let path;
+        if (this.entitySetPath)
+            path = this.entitySetPath;
+        else if (this.bound)
+            path = `${this.schema.namespace}.${this.name}`;
+        else
+            path = this.parser.return
+                ? this.api.findEntitySetForType(this.parser.return.type)?.name ||
+                    this.name
+                : this.name;
+        return path;
+    }
+    configure({ parserForType, }) {
+        this.parser.configure({ options: this.api.options, parserForType });
+    }
+    /**
+     * Deseialize the given value from the callable.
+     * @param value Value to deserialize
+     * @param options Options for deserialization
+     * @returns Deserialized value
+     */
+    deserialize(value, options) {
+        return this.parser.deserialize(value, options);
+    }
+    /**
+     * Serialize the given value for the callable.
+     * @param value Value to serialize
+     * @param options Options for serialization
+     * @returns Serialized value
+     */
+    serialize(value, options) {
+        return this.parser.serialize(value, options);
+    }
+    /**
+     * Encode the given value for the callable.
+     * @param value Value to encode
+     * @param options Options for encoding
+     * @returns Encoded value
+     */
+    encode(value, options) {
+        return this.parser.encode(value, options);
+    }
+    /**
+     * Returns the binding parameter of the callable.
+     * @returns The binding parameter of the callable.
+     */
+    binding() {
+        return this.parser.binding();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/schema/element.mjs

@@ -0,0 +1,51 @@
+import { Strings } from '../utils';
+import { ODataAnnotatable } from './annotation';
+export class ODataSchemaElement extends ODataAnnotatable {
+    constructor(config, schema) {
+        super(config);
+        this.schema = schema;
+        this.name = config.name;
+    }
+    get api() {
+        return this.schema.api;
+    }
+    /**
+     * Create a nicer looking title.
+     * Titleize is meant for creating pretty output.
+     * @param term The term of the annotation to find.
+     * @returns The titleized string.
+     */
+    titleize(term) {
+        return (term && this.annotatedValue(term)) || Strings.titleCase(this.name);
+    }
+    /**
+     * Returns a full type of the structured type including the namespace/alias.
+     * @param alias Use the alias of the namespace instead of the namespace.
+     * @returns The string representation of the type.
+     */
+    type({ alias = false } = {}) {
+        return `${alias ? this.schema.alias : this.schema.namespace}.${this.name}`;
+    }
+    /**
+     * Returns a boolean indicating if the structured type is of the given type.
+     * @param type String representation of the type
+     * @returns True if the callable is type of the given type
+     */
+    isTypeOf(type) {
+        var names = [`${this.schema.namespace}.${this.name}`];
+        if (this.schema.alias)
+            names.push(`${this.schema.alias}.${this.name}`);
+        return names.indexOf(type) !== -1;
+    }
+    /**
+     * Returns a boolean indicating if the structured type is a sub type of the given type.
+     * @param type String representation of the type
+     * @returns True if the callable is type of the given type
+     */
+    isSubtypeOf(schema) {
+        if (this.isTypeOf(schema.type()))
+            return true;
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWxlbWVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItb2RhdGEvc3JjL2xpYi9zY2hlbWEvZWxlbWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sVUFBVSxDQUFDO0FBQ25DLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUdoRCxNQUFNLE9BQU8sa0JBQW1CLFNBQVEsZ0JBQWdCO0lBSXRELFlBQ0UsTUFBMEQsRUFDMUQsTUFBbUI7UUFFbkIsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQ2QsSUFBSSxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUM7UUFDckIsSUFBSSxDQUFDLElBQUksR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDO0lBQzFCLENBQUM7SUFFRCxJQUFJLEdBQUc7UUFDTCxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDO0lBQ3pCLENBQUM7SUFFRDs7Ozs7T0FLRztJQUNILFFBQVEsQ0FBQyxJQUFzQjtRQUM3QixPQUFPLENBQUMsSUFBSSxJQUFJLElBQUksQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLENBQUMsSUFBSSxPQUFPLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUM3RSxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNILElBQUksQ0FBQyxFQUFFLEtBQUssR0FBRyxLQUFLLEtBQTBCLEVBQUU7UUFDOUMsT0FBTyxHQUFHLEtBQUssQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsU0FBUyxJQUFJLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUM3RSxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNILFFBQVEsQ0FBQyxJQUFZO1FBQ25CLElBQUksS0FBSyxHQUFHLENBQUMsR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLFNBQVMsSUFBSSxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQztRQUN0RCxJQUFJLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSztZQUFFLEtBQUssQ0FBQyxJQUFJLENBQUMsR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssSUFBSSxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQztRQUN2RSxPQUFPLEtBQUssQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7SUFDcEMsQ0FBQztJQUVEOzs7O09BSUc7SUFDSCxXQUFXLENBQUMsTUFBMEI7UUFDcEMsSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxJQUFJLEVBQUUsQ0FBQztZQUFFLE9BQU8sSUFBSSxDQUFDO1FBQzlDLE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQW5ub3RhdGlvbkNvbmZpZyB9IGZyb20gJy4uL3R5cGVzJztcbmltcG9ydCB7IFN0cmluZ3MgfSBmcm9tICcuLi91dGlscyc7XG5pbXBvcnQgeyBPRGF0YUFubm90YXRhYmxlIH0gZnJvbSAnLi9hbm5vdGF0aW9uJztcbmltcG9ydCB7IE9EYXRhU2NoZW1hIH0gZnJvbSAnLi9zY2hlbWEnO1xuXG5leHBvcnQgY2xhc3MgT0RhdGFTY2hlbWFFbGVtZW50IGV4dGVuZHMgT0RhdGFBbm5vdGF0YWJsZSB7XG4gIG5hbWU6IHN0cmluZztcbiAgc2NoZW1hOiBPRGF0YVNjaGVtYTtcblxuICBjb25zdHJ1Y3RvcihcbiAgICBjb25maWc6IHsgYW5ub3RhdGlvbnM/OiBBbm5vdGF0aW9uQ29uZmlnW107IG5hbWU6IHN0cmluZyB9LFxuICAgIHNjaGVtYTogT0RhdGFTY2hlbWFcbiAgKSB7XG4gICAgc3VwZXIoY29uZmlnKTtcbiAgICB0aGlzLnNjaGVtYSA9IHNjaGVtYTtcbiAgICB0aGlzLm5hbWUgPSBjb25maWcubmFtZTtcbiAgfVxuXG4gIGdldCBhcGkoKSB7XG4gICAgcmV0dXJuIHRoaXMuc2NoZW1hLmFwaTtcbiAgfVxuXG4gIC8qKlxuICAgKiBDcmVhdGUgYSBuaWNlciBsb29raW5nIHRpdGxlLlxuICAgKiBUaXRsZWl6ZSBpcyBtZWFudCBmb3IgY3JlYXRpbmcgcHJldHR5IG91dHB1dC5cbiAgICogQHBhcmFtIHRlcm0gVGhlIHRlcm0gb2YgdGhlIGFubm90YXRpb24gdG8gZmluZC5cbiAgICogQHJldHVybnMgVGhlIHRpdGxlaXplZCBzdHJpbmcuXG4gICAqL1xuICB0aXRsZWl6ZSh0ZXJtPzogc3RyaW5nIHwgUmVnRXhwKTogc3RyaW5nIHtcbiAgICByZXR1cm4gKHRlcm0gJiYgdGhpcy5hbm5vdGF0ZWRWYWx1ZSh0ZXJtKSkgfHwgU3RyaW5ncy50aXRsZUNhc2UodGhpcy5uYW1lKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBSZXR1cm5zIGEgZnVsbCB0eXBlIG9mIHRoZSBzdHJ1Y3R1cmVkIHR5cGUgaW5jbHVkaW5nIHRoZSBuYW1lc3BhY2UvYWxpYXMuXG4gICAqIEBwYXJhbSBhbGlhcyBVc2UgdGhlIGFsaWFzIG9mIHRoZSBuYW1lc3BhY2UgaW5zdGVhZCBvZiB0aGUgbmFtZXNwYWNlLlxuICAgKiBAcmV0dXJucyBUaGUgc3RyaW5nIHJlcHJlc2VudGF0aW9uIG9mIHRoZSB0eXBlLlxuICAgKi9cbiAgdHlwZSh7IGFsaWFzID0gZmFsc2UgfTogeyBhbGlhcz86IGJvb2xlYW4gfSA9IHt9KSB7XG4gICAgcmV0dXJuIGAke2FsaWFzID8gdGhpcy5zY2hlbWEuYWxpYXMgOiB0aGlzLnNjaGVtYS5uYW1lc3BhY2V9LiR7dGhpcy5uYW1lfWA7XG4gIH1cblxuICAvKipcbiAgICogUmV0dXJucyBhIGJvb2xlYW4gaW5kaWNhdGluZyBpZiB0aGUgc3RydWN0dXJlZCB0eXBlIGlzIG9mIHRoZSBnaXZlbiB0eXBlLlxuICAgKiBAcGFyYW0gdHlwZSBTdHJpbmcgcmVwcmVzZW50YXRpb24gb2YgdGhlIHR5cGVcbiAgICogQHJldHVybnMgVHJ1ZSBpZiB0aGUgY2FsbGFibGUgaXMgdHlwZSBvZiB0aGUgZ2l2ZW4gdHlwZVxuICAgKi9cbiAgaXNUeXBlT2YodHlwZTogc3RyaW5nKTogYm9vbGVhbiB7XG4gICAgdmFyIG5hbWVzID0gW2Ake3RoaXMuc2NoZW1hLm5hbWVzcGFjZX0uJHt0aGlzLm5hbWV9YF07XG4gICAgaWYgKHRoaXMuc2NoZW1hLmFsaWFzKSBuYW1lcy5wdXNoKGAke3RoaXMuc2NoZW1hLmFsaWFzfS4ke3RoaXMubmFtZX1gKTtcbiAgICByZXR1cm4gbmFtZXMuaW5kZXhPZih0eXBlKSAhPT0gLTE7XG4gIH1cblxuICAvKipcbiAgICogUmV0dXJucyBhIGJvb2xlYW4gaW5kaWNhdGluZyBpZiB0aGUgc3RydWN0dXJlZCB0eXBlIGlzIGEgc3ViIHR5cGUgb2YgdGhlIGdpdmVuIHR5cGUuXG4gICAqIEBwYXJhbSB0eXBlIFN0cmluZyByZXByZXNlbnRhdGlvbiBvZiB0aGUgdHlwZVxuICAgKiBAcmV0dXJucyBUcnVlIGlmIHRoZSBjYWxsYWJsZSBpcyB0eXBlIG9mIHRoZSBnaXZlbiB0eXBlXG4gICAqL1xuICBpc1N1YnR5cGVPZihzY2hlbWE6IE9EYXRhU2NoZW1hRWxlbWVudCk6IGJvb2xlYW4ge1xuICAgIGlmICh0aGlzLmlzVHlwZU9mKHNjaGVtYS50eXBlKCkpKSByZXR1cm4gdHJ1ZTtcbiAgICByZXR1cm4gZmFsc2U7XG4gIH1cbn1cbiJdfQ==

package/esm2020/lib/schema/entity-container.mjs

@@ -0,0 +1,9 @@
+import { ODataSchemaElement } from './element';
+import { ODataEntitySet } from './entity-set';
+export class ODataEntityContainer extends ODataSchemaElement {
+    constructor(config, schema) {
+        super(config, schema);
+        this.entitySets = (config.entitySets || []).map((config) => new ODataEntitySet(config, schema));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50aXR5LWNvbnRhaW5lci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItb2RhdGEvc3JjL2xpYi9zY2hlbWEvZW50aXR5LWNvbnRhaW5lci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFDL0MsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUc5QyxNQUFNLE9BQU8sb0JBQXFCLFNBQVEsa0JBQWtCO0lBRzFELFlBQVksTUFBNkIsRUFBRSxNQUFtQjtRQUM1RCxLQUFLLENBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBQyxDQUFDO1FBQ3RCLElBQUksQ0FBQyxVQUFVLEdBQUcsQ0FBQyxNQUFNLENBQUMsVUFBVSxJQUFJLEVBQUUsQ0FBQyxDQUFDLEdBQUcsQ0FDN0MsQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUFDLElBQUksY0FBYyxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUMsQ0FDL0MsQ0FBQztJQUNKLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVudGl0eUNvbnRhaW5lckNvbmZpZyB9IGZyb20gJy4uL3R5cGVzJztcbmltcG9ydCB7IE9EYXRhU2NoZW1hRWxlbWVudCB9IGZyb20gJy4vZWxlbWVudCc7XG5pbXBvcnQgeyBPRGF0YUVudGl0eVNldCB9IGZyb20gJy4vZW50aXR5LXNldCc7XG5pbXBvcnQgeyBPRGF0YVNjaGVtYSB9IGZyb20gJy4vc2NoZW1hJztcblxuZXhwb3J0IGNsYXNzIE9EYXRhRW50aXR5Q29udGFpbmVyIGV4dGVuZHMgT0RhdGFTY2hlbWFFbGVtZW50IHtcbiAgZW50aXR5U2V0czogT0RhdGFFbnRpdHlTZXRbXTtcblxuICBjb25zdHJ1Y3Rvcihjb25maWc6IEVudGl0eUNvbnRhaW5lckNvbmZpZywgc2NoZW1hOiBPRGF0YVNjaGVtYSkge1xuICAgIHN1cGVyKGNvbmZpZywgc2NoZW1hKTtcbiAgICB0aGlzLmVudGl0eVNldHMgPSAoY29uZmlnLmVudGl0eVNldHMgfHwgW10pLm1hcChcbiAgICAgIChjb25maWcpID0+IG5ldyBPRGF0YUVudGl0eVNldChjb25maWcsIHNjaGVtYSlcbiAgICApO1xuICB9XG59XG4iXX0=

package/esm2020/lib/schema/entity-set.mjs

@@ -0,0 +1,9 @@
+import { ODataSchemaElement } from './element';
+export class ODataEntitySet extends ODataSchemaElement {
+    constructor(config, schema) {
+        super(config, schema);
+        this.entityType = config.entityType;
+        this.service = config.service;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50aXR5LXNldC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItb2RhdGEvc3JjL2xpYi9zY2hlbWEvZW50aXR5LXNldC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFHL0MsTUFBTSxPQUFPLGNBQWUsU0FBUSxrQkFBa0I7SUFHcEQsWUFBWSxNQUF1QixFQUFFLE1BQW1CO1FBQ3RELEtBQUssQ0FBQyxNQUFNLEVBQUUsTUFBTSxDQUFDLENBQUM7UUFDdEIsSUFBSSxDQUFDLFVBQVUsR0FBRyxNQUFNLENBQUMsVUFBVSxDQUFDO1FBQ3BDLElBQUksQ0FBQyxPQUFPLEdBQUcsTUFBTSxDQUFDLE9BQU8sQ0FBQztJQUNoQyxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFbnRpdHlTZXRDb25maWcgfSBmcm9tICcuLi90eXBlcyc7XG5pbXBvcnQgeyBPRGF0YVNjaGVtYUVsZW1lbnQgfSBmcm9tICcuL2VsZW1lbnQnO1xuaW1wb3J0IHsgT0RhdGFTY2hlbWEgfSBmcm9tICcuL3NjaGVtYSc7XG5cbmV4cG9ydCBjbGFzcyBPRGF0YUVudGl0eVNldCBleHRlbmRzIE9EYXRhU2NoZW1hRWxlbWVudCB7XG4gIGVudGl0eVR5cGU6IHN0cmluZztcbiAgc2VydmljZTogeyBuZXcgKC4uLnBhcmFtczogYW55W10pOiBhbnkgfTtcbiAgY29uc3RydWN0b3IoY29uZmlnOiBFbnRpdHlTZXRDb25maWcsIHNjaGVtYTogT0RhdGFTY2hlbWEpIHtcbiAgICBzdXBlcihjb25maWcsIHNjaGVtYSk7XG4gICAgdGhpcy5lbnRpdHlUeXBlID0gY29uZmlnLmVudGl0eVR5cGU7XG4gICAgdGhpcy5zZXJ2aWNlID0gY29uZmlnLnNlcnZpY2U7XG4gIH1cbn1cbiJdfQ==

package/esm2020/lib/schema/enum-type.mjs

@@ -0,0 +1,71 @@
+import { ODataSchemaElement } from './element';
+import { ODataEnumTypeParser } from './parsers';
+export class ODataEnumType extends ODataSchemaElement {
+    constructor(config, schema) {
+        super(config, schema);
+        this.members = config.members;
+        this.parser = new ODataEnumTypeParser(config, schema.namespace, schema.alias);
+    }
+    configure() {
+        this.parser.configure({ options: this.api.options });
+    }
+    /**
+     * Returns the fields of the enum type.
+     * @returns The fields of the enum type.
+     */
+    fields() {
+        return this.parser.fields;
+    }
+    /**
+     * Find a field by name.
+     * @param name The name of the field
+     * @returns The field with the given name
+     */
+    findFieldByName(name) {
+        return this.fields().find((f) => f.name === name);
+    }
+    /**
+     * Find a field by value.
+     * @param value The value of the field
+     * @returns The field with the given value
+     */
+    findFieldByValue(value) {
+        return this.fields().find((f) => f.value === value);
+    }
+    /**
+     * Map the fields of the enum type.
+     * @param mapper Function that maps the value to the new value
+     * @returns The fields mapped by the mapper
+     */
+    mapFields(mapper) {
+        return this.fields().map(mapper);
+    }
+    /**
+     * Deseialize the given value from the enum type.
+     * @param value Value to deserialize
+     * @param options Options for deserialization
+     * @returns Deserialized value
+     */
+    deserialize(value, options) {
+        return this.parser.deserialize(value, options);
+    }
+    /**
+     * Serialize the given value for the enum type.
+     * @param value Value to serialize
+     * @param options Options for serialization
+     * @returns Serialized value
+     */
+    serialize(value, options) {
+        return this.parser.serialize(value, options);
+    }
+    /**
+     * Encode the given value for the enum type.
+     * @param value Value to encode
+     * @param options Options for encoding
+     * @returns Encoded value
+     */
+    encode(value, options) {
+        return this.parser.encode(value, options);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/schema/parsers/callable.mjs

@@ -0,0 +1,113 @@
+import { CALLABLE_BINDING_PARAMETER } from '../../constants';
+import { ODataParserOptions } from '../../options';
+import { NONE_PARSER, } from '../../types';
+import { ODataEnumTypeParser } from './enum-type';
+import { ODataStructuredTypeParser } from './structured-type';
+export class ODataParameterParser {
+    constructor(name, parameter) {
+        this.name = name;
+        this.type = parameter.type;
+        this.parser = NONE_PARSER;
+        this.nullable = parameter.nullable;
+        this.collection = parameter.collection;
+    }
+    serialize(value, options) {
+        const parserOptions = options !== undefined
+            ? new ODataParserOptions(options)
+            : this.optionsHelper;
+        return Array.isArray(value)
+            ? value.map((v) => this.parser.serialize(v, parserOptions))
+            : this.parser.serialize(value, parserOptions);
+    }
+    //Encode
+    encode(value, options) {
+        const parserOptions = options !== undefined
+            ? new ODataParserOptions(options)
+            : this.optionsHelper;
+        return Array.isArray(value)
+            ? value.map((v) => this.parser.encode(v, parserOptions))
+            : this.parser.encode(value, parserOptions);
+    }
+    configure({ parserForType, options, }) {
+        this.optionsHelper = options;
+        this.parser = parserForType(this.type);
+    }
+    isEdmType() {
+        return this.type.startsWith('Edm.');
+    }
+    isEnumType() {
+        return this.parser instanceof ODataEnumTypeParser;
+    }
+    enum() {
+        if (!this.isEnumType())
+            throw new Error('Field are not EnumType');
+        return this.parser;
+    }
+    isStructuredType() {
+        return this.parser instanceof ODataStructuredTypeParser;
+    }
+    structured() {
+        if (!this.isStructuredType())
+            throw new Error('Field are not StrucuturedType');
+        return this.parser;
+    }
+}
+export class ODataCallableParser {
+    constructor(config, namespace, alias) {
+        this.name = config.name;
+        this.namespace = namespace;
+        this.alias = alias;
+        this.return = config.return;
+        this.parser = NONE_PARSER;
+        this.parameters = Object.entries(config.parameters || []).map(([name, p]) => new ODataParameterParser(name, p));
+    }
+    isTypeOf(type) {
+        var names = [`${this.namespace}.${this.name}`];
+        if (this.alias)
+            names.push(`${this.alias}.${this.name}`);
+        return names.indexOf(type) !== -1;
+    }
+    // Deserialize
+    deserialize(value, options) {
+        const parserOptions = options !== undefined
+            ? new ODataParserOptions(options)
+            : this.optionsHelper;
+        return this.parser.deserialize(value, parserOptions);
+    }
+    // Serialize
+    serialize(params, options) {
+        const parserOptions = options !== undefined
+            ? new ODataParserOptions(options)
+            : this.optionsHelper;
+        const parameters = this.parameters
+            .filter((p) => p.name !== CALLABLE_BINDING_PARAMETER)
+            .filter((p) => p.name in params && params[p.name] !== undefined);
+        return parameters.reduce((acc, p) => ({
+            ...acc,
+            [p.name]: p.serialize(params[p.name], parserOptions),
+        }), {});
+    }
+    //Encode
+    encode(params, options) {
+        const parserOptions = options !== undefined
+            ? new ODataParserOptions(options)
+            : this.optionsHelper;
+        const parameters = this.parameters
+            .filter((p) => p.name !== CALLABLE_BINDING_PARAMETER)
+            .filter((p) => p.name in params && params[p.name] !== undefined);
+        return parameters.reduce((acc, p) => ({
+            ...acc,
+            [p.name]: p.encode(params[p.name], parserOptions),
+        }), {});
+    }
+    configure({ parserForType, options, }) {
+        this.optionsHelper = options;
+        if (this.return)
+            this.parser = parserForType(this.return.type) || NONE_PARSER;
+        this.parameters.forEach((p) => p.configure({ parserForType, options }));
+    }
+    binding() {
+        return this.parameters.find((p) => p.name === CALLABLE_BINDING_PARAMETER);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"callable.js","sourceRoot":"","sources":["../../../../../../projects/angular-odata/src/lib/schema/parsers/callable.ts"],"names":[],"mappings":"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","sourcesContent":["import { CALLABLE_BINDING_PARAMETER } from '../../constants';\nimport { ODataParserOptions } from '../../options';\nimport {\n  CallableConfig,\n  NONE_PARSER,\n  Options,\n  OptionsHelper,\n  Parameter,\n  Parser,\n} from '../../types';\nimport { ODataEnumTypeParser } from './enum-type';\nimport { ODataStructuredTypeParser } from './structured-type';\n\nexport class ODataParameterParser<T> {\n  name: string;\n  type: string;\n  private parser: Parser<T>;\n  collection?: boolean;\n  nullable?: boolean;\n  optionsHelper?: OptionsHelper;\n\n  constructor(name: string, parameter: Parameter) {\n    this.name = name;\n    this.type = parameter.type;\n    this.parser = NONE_PARSER;\n    this.nullable = parameter.nullable;\n    this.collection = parameter.collection;\n  }\n\n  serialize(value: T, options?: Options): any {\n    const parserOptions =\n      options !== undefined\n        ? new ODataParserOptions(options)\n        : this.optionsHelper;\n    return Array.isArray(value)\n      ? value.map((v) => this.parser.serialize(v, parserOptions))\n      : this.parser.serialize(value, parserOptions);\n  }\n\n  //Encode\n  encode(value: any, options?: Options): string {\n    const parserOptions =\n      options !== undefined\n        ? new ODataParserOptions(options)\n        : this.optionsHelper;\n    return Array.isArray(value)\n      ? value.map((v) => this.parser.encode(v, parserOptions))\n      : this.parser.encode(value, parserOptions);\n  }\n\n  configure({\n    parserForType,\n    options,\n  }: {\n    parserForType: (type: string) => Parser<any>;\n    options: OptionsHelper;\n  }) {\n    this.optionsHelper = options;\n    this.parser = parserForType(this.type);\n  }\n\n  isEdmType() {\n    return this.type.startsWith('Edm.');\n  }\n\n  isEnumType() {\n    return this.parser instanceof ODataEnumTypeParser;\n  }\n\n  enum() {\n    if (!this.isEnumType()) throw new Error('Field are not EnumType');\n    return this.parser as ODataEnumTypeParser<T>;\n  }\n\n  isStructuredType() {\n    return this.parser instanceof ODataStructuredTypeParser;\n  }\n\n  structured() {\n    if (!this.isStructuredType())\n      throw new Error('Field are not StrucuturedType');\n    return this.parser as ODataStructuredTypeParser<T>;\n  }\n}\n\nexport class ODataCallableParser<R> implements Parser<R> {\n  name: string;\n  namespace: string;\n  alias?: string;\n  return?: { type: string; collection?: boolean };\n  parser: Parser<any>;\n  parameters: ODataParameterParser<any>[];\n  optionsHelper?: OptionsHelper;\n\n  constructor(config: CallableConfig, namespace: string, alias?: string) {\n    this.name = config.name;\n    this.namespace = namespace;\n    this.alias = alias;\n    this.return = config.return;\n    this.parser = NONE_PARSER;\n    this.parameters = Object.entries(config.parameters || []).map(\n      ([name, p]) => new ODataParameterParser(name, p as Parameter)\n    );\n  }\n\n  isTypeOf(type: string) {\n    var names = [`${this.namespace}.${this.name}`];\n    if (this.alias) names.push(`${this.alias}.${this.name}`);\n    return names.indexOf(type) !== -1;\n  }\n\n  // Deserialize\n  deserialize(value: any, options?: Options): R {\n    const parserOptions =\n      options !== undefined\n        ? new ODataParserOptions(options)\n        : this.optionsHelper;\n    return this.parser.deserialize(value, parserOptions);\n  }\n\n  // Serialize\n  serialize(params: any, options?: Options): any {\n    const parserOptions =\n      options !== undefined\n        ? new ODataParserOptions(options)\n        : this.optionsHelper;\n    const parameters = this.parameters\n      .filter((p) => p.name !== CALLABLE_BINDING_PARAMETER)\n      .filter((p) => p.name in params && params[p.name] !== undefined);\n    return parameters.reduce(\n      (acc, p) => ({\n        ...acc,\n        [p.name]: p.serialize(params[p.name], parserOptions),\n      }),\n      {}\n    );\n  }\n\n  //Encode\n  encode(params: any, options?: Options): any {\n    const parserOptions =\n      options !== undefined\n        ? new ODataParserOptions(options)\n        : this.optionsHelper;\n    const parameters = this.parameters\n      .filter((p) => p.name !== CALLABLE_BINDING_PARAMETER)\n      .filter((p) => p.name in params && params[p.name] !== undefined);\n    return parameters.reduce(\n      (acc, p) => ({\n        ...acc,\n        [p.name]: p.encode(params[p.name], parserOptions),\n      }),\n      {}\n    );\n  }\n\n  configure({\n    parserForType,\n    options,\n  }: {\n    parserForType: (type: string) => Parser<any>;\n    options: OptionsHelper;\n  }) {\n    this.optionsHelper = options;\n    if (this.return)\n      this.parser = parserForType(this.return.type) || NONE_PARSER;\n    this.parameters.forEach((p) => p.configure({ parserForType, options }));\n  }\n\n  binding() {\n    return this.parameters.find((p) => p.name === CALLABLE_BINDING_PARAMETER);\n  }\n}\n"]}