angular-odata 0.95.0 → 0.99.5

package/fesm2015/angular-odata.mjs

@@ -34,6 +34,7 @@ var QueryOptionNames;
     QueryOptionNames["skip"] = "skip";
     QueryOptionNames["skiptoken"] = "skiptoken";
     QueryOptionNames["format"] = "format";
+    QueryOptionNames["levels"] = "levels";
     QueryOptionNames["count"] = "count";
 })(QueryOptionNames || (QueryOptionNames = {}));
 const NONE_PARSER = {
@@ -214,7 +215,7 @@ class ODataCache {
                 return of(cached);
             }
             else {
-                return throwError('No Cached');
+                return throwError(() => new Error('No Cached'));
             }
         }
         if (policy === 'cache-first' ||
@@ -746,6 +747,7 @@ function buildExpand(expands, { aliases, escape = false }) {
                     case 'levels':
                     case 'count':
                     case 'top':
+                    case 'skip':
                         value = `${expands[key]}`;
                         break;
                     default:
@@ -1332,6 +1334,10 @@ const Objects = {
         if (typeof target != 'object' || target == null) {
             return target;
         }
+        if (Types.isObject(target) && 'clone' in target) {
+            // target is a cloneable object
+            return target.clone();
+        }
         const type = Types.rawType(target);
         let cloneTarget = null;
         if (map.get(target)) {
@@ -1438,22 +1444,57 @@ const Urls = {
     },
 };
 
-//export type Field<T> = keyof T | Funcs<keyof T>;
+class Expression {
+    constructor({ children, } = {}) {
+        this._children = children || [];
+    }
+    get [Symbol.toStringTag]() {
+        return 'Expression';
+    }
+    children() {
+        return this._children;
+    }
+    length() {
+        return this._children.length;
+    }
+    toJSON() {
+        return {
+            children: this._children.map((c) => c.toJSON()),
+        };
+    }
+}
+
 class Field$1 {
     constructor(name = '') {
         this.name = name;
     }
-    static factory() {
-        const h = new Field$1();
-        return new Proxy({ _name: '' }, h);
+    static factory(name = '') {
+        return new Proxy({ _name: name }, new Field$1());
     }
-    get(target, p) {
+    get(target, key) {
         let name = target['_name'];
-        if (p === 'render') {
+        if (key === 'render') {
             return ({ prefix }) => prefix ? `${prefix}/${name}` : name;
         }
-        name = name ? `${name}/${p}` : p;
-        return new Proxy({ _name: name }, this);
+        else if (key === 'clone') {
+            return () => Field$1.factory(name);
+        }
+        else if (key === Symbol.toStringTag) {
+            return () => 'Field';
+        }
+        else if (key === 'toJSON') {
+            return () => ({
+                $type: Types.rawType(this),
+                name: name,
+            });
+        }
+        else {
+            name = name ? `${name}/${key}` : key;
+            return new Proxy({ _name: name }, this);
+        }
+    }
+    has(target, key) {
+        return ['toJSON', 'clone', 'render'].includes(key) || key in target;
     }
 }
 function applyMixins(derivedCtor, constructors) {
@@ -1492,6 +1533,7 @@ class Function {
     }
     toJSON() {
         return {
+            $type: Types.rawType(this),
             name: this.name,
             values: this.values,
             normalize: this.normalize,
@@ -1500,12 +1542,15 @@ class Function {
     render({ aliases, escape, prefix, }) {
         let [field, ...values] = this.values;
         field = render(field, { aliases, escape, prefix });
-        let params = [
+        const params = [
             field,
             ...values.map((v) => render(v, { aliases, escape, prefix, normalize: this.normalize })),
         ];
         return `${this.name}(${params.join(', ')})`;
     }
+    clone() {
+        return new Function(this.name, this.values.map((v) => Objects.clone(v)), this.normalize, this.escape);
+    }
 }
 class StringAndCollectionFunctions {
     concat(field, value, normalize) {
@@ -1646,6 +1691,7 @@ class Operator {
     }
     toJSON() {
         return {
+            $type: Types.rawType(this),
             op: this.op,
             values: this.values,
             normalize: this.normalize,
@@ -1674,6 +1720,9 @@ class Operator {
         }
         return `${this.op}(${left})`;
     }
+    clone() {
+        return new Operator(this.op, this.values.map((v) => Objects.clone(v)), this.normalize);
+    }
 }
 class LogicalOperators {
     eq(left, right, normalize) {
@@ -1741,44 +1790,15 @@ class Grouping {
     }
     toJSON() {
         return {
+            $type: Types.rawType(this),
             group: this.group.toJSON(),
         };
     }
     render({ aliases, escape, prefix, }) {
         return `(${render(this.group, { aliases, escape, prefix })})`;
     }
-}
-/*
-export class Navigation<T, N> implements Renderable {
-  constructor(protected field: T, protected value: Field<N>) {}
-
-  get [Symbol.toStringTag]() {
-    return 'Navigation';
-  }
-
-  toJSON() {
-    return {
-      field: this.field,
-      value: this.value,
-    };
-  }
-
-  render({
-    aliases,
-    escape,
-    prefix,
-  }: {
-    aliases?: QueryCustomType[];
-    escape?: boolean;
-    prefix?: string;
-  }): string {
-    return `${this.field}/${render(this.value, { aliases, escape, prefix })}`;
-  }
-}
-*/
-class GroupingOperators {
-    grouping(value) {
-        return new Grouping(value);
+    clone() {
+        return new Grouping(Objects.clone(this.group));
     }
 }
 class Lambda {
@@ -1792,6 +1812,7 @@ class Lambda {
     }
     toJSON() {
         return {
+            $type: Types.rawType(this),
             op: this.op,
             values: this.values,
             alias: this.alias,
@@ -1807,6 +1828,9 @@ class Lambda {
             prefix: alias,
         })})`;
     }
+    clone() {
+        return new Lambda(this.op, this.values.map((v) => Objects.clone(v)), this.alias);
+    }
 }
 class LambdaOperators {
     any(field, value, alias) {
@@ -1821,7 +1845,6 @@ class ODataOperators {
 applyMixins(ODataOperators, [
     LogicalOperators,
     ArithmeticOperators,
-    GroupingOperators,
     LambdaOperators,
 ]);
 const operators = new ODataOperators();
@@ -1843,34 +1866,68 @@ class ODataSyntax {
 applyMixins(ODataSyntax, [ODataOperators, ODataFunctions]);
 const syntax = new ODataSyntax();
 
-class Expression {
+class ComputeExpression extends Expression {
+    constructor({ children, names, } = {}) {
+        super({ children });
+        this.names = names || [];
+    }
+    static e() {
+        return new ComputeExpression();
+    }
+    static s() {
+        return Field$1.factory();
+    }
+    static compute(opts, current) {
+        return opts({
+            s: ComputeExpression.s(),
+            e: ComputeExpression.e,
+        }, current);
+    }
+    render({ aliases, escape, prefix, } = {}) {
+        let children = this._children.map((n) => n.render({ aliases, escape, prefix }));
+        return this.names
+            .map((name, index) => `${children[index]} as ${name}`)
+            .join(',');
+    }
+    clone() {
+        return new ComputeExpression({
+            children: this._children.map((c) => c.clone()),
+            names: [...this.names],
+        });
+    }
+    _add(name, node) {
+        this.names.push(name);
+        this._children.push(node);
+        return this;
+    }
+    field(name, opts) {
+        const node = opts({
+            o: operators,
+            f: functions,
+        });
+        return this._add(name, node);
+    }
+}
+
+class FilterExpression extends Expression {
     constructor({ children, connector, negated, } = {}) {
-        this._children = children || [];
+        super({ children });
         this._connector = connector || 'and';
         this._negated = negated || false;
     }
-    get [Symbol.toStringTag]() {
-        return 'Expression';
-    }
     static s() {
         return Field$1.factory();
     }
     static e(connector = 'and') {
-        return new Expression({ connector });
-    }
-    static o() {
-        return operators;
+        return new FilterExpression({ connector });
     }
-    static f() {
-        return functions;
-    }
-    static filter(opts) {
+    static filter(opts, current) {
         return opts({
-            s: Expression.s(),
-            e: Expression.e,
-            o: Expression.o(),
-            f: Expression.f(),
-        });
+            s: FilterExpression.s(),
+            e: FilterExpression.e,
+            o: operators,
+            f: functions,
+        }, current);
     }
     toJSON() {
         return {
@@ -1879,18 +1936,12 @@ class Expression {
             negated: this._negated,
         };
     }
-    children() {
-        return this._children;
-    }
     connector() {
         return this._connector;
     }
     negated() {
         return this._negated;
     }
-    length() {
-        return this._children.length;
-    }
     render({ aliases, escape, prefix, } = {}) {
         let content = this._children
             .map((n) => n.render({ aliases, escape, prefix }))
@@ -1900,6 +1951,13 @@ class Expression {
         }
         return content;
     }
+    clone() {
+        return new FilterExpression({
+            children: this._children.map((c) => c.clone()),
+            connector: this._connector,
+            negated: this._negated,
+        });
+    }
     _add(node, connector) {
         if (connector !== undefined && this._connector !== connector) {
             let children = [];
@@ -1908,37 +1966,37 @@ class Expression {
                     children = [...this._children];
                 }
                 else {
-                    let exp = new Expression({
+                    let exp = new FilterExpression({
                         children: this._children,
                         connector: this._connector,
                         negated: this._negated,
                     });
                     if (exp.length() > 1) {
-                        children.push(syntax.grouping(exp));
+                        children.push(new Grouping(exp));
                     }
                     else {
                         children.push(exp);
                     }
                 }
             }
-            if (node instanceof Expression &&
+            if (node instanceof FilterExpression &&
                 (node.connector() === connector || node.length() === 1)) {
                 children = [...children, ...node.children()];
             }
             else {
-                children.push(syntax.grouping(node));
+                children.push(new Grouping(node));
             }
             this._connector = connector;
             this._children = children;
         }
-        else if (node instanceof Expression &&
+        else if (node instanceof FilterExpression &&
             !node.negated() &&
             (node.connector() === connector || node.length() === 1)) {
             this._children = [...this._children, ...node.children()];
         }
         else {
-            this._children.push(node instanceof Expression && !node.negated()
-                ? syntax.grouping(node)
+            this._children.push(node instanceof FilterExpression && !node.negated()
+                ? new Grouping(node)
                 : node);
         }
         return this;
@@ -1950,7 +2008,7 @@ class Expression {
         return this._add(exp, 'and');
     }
     not(exp) {
-        const notExp = new Expression({
+        const notExp = new FilterExpression({
             children: exp.children(),
             connector: exp.connector(),
             negated: true,
@@ -1993,14 +2051,14 @@ class Expression {
     any(left, opts, alias) {
         const exp = opts({
             s: Field$1.factory(),
-            e: Expression.e,
+            e: FilterExpression.e,
         });
         return this._add(syntax.any(left, exp, alias));
     }
     all(left, opts, alias) {
         const exp = opts({
             s: Field$1.factory(),
-            e: Expression.e,
+            e: FilterExpression.e,
         });
         return this._add(syntax.all(left, exp, alias));
     }
@@ -2008,45 +2066,336 @@ class Expression {
         return this._add(syntax.isof(left, type));
     }
 }
-/*
-export class FilterExpression<T> extends Expression<T> {
-  constructor({
-    children,
-    connector,
-    negated,
-  }: {
-    children?: Renderable[];
-    connector?: Connector;
-    negated?: boolean;
-  } = {}) {
-    super({ children, connector, negated });
-  }
-
-  get [Symbol.toStringTag]() {
-    return 'FilterExpression';
-  }
 
-  static e<T>() {
-    return new FilterExpression<T>({ connector: Connector.AND });
-  }
+class OrderByField {
+    constructor(field, order) {
+        this.field = field;
+        this.order = order;
+    }
+    get [Symbol.toStringTag]() {
+        return 'OrderByField';
+    }
+    toJSON() {
+        return {
+            field: this.field.toJSON(),
+            order: this.order,
+        };
+    }
+    render({ aliases, escape, prefix, }) {
+        return `${render(this.field, { aliases, escape, prefix })} ${this.order}`;
+    }
+    clone() {
+        return new OrderByField(this.field.clone(), this.order);
+    }
+}
+class OrderByExpression extends Expression {
+    constructor({ children, } = {}) {
+        super({ children });
+    }
+    static e() {
+        return new OrderByExpression();
+    }
+    static s() {
+        return Field$1.factory();
+    }
+    static orderBy(opts, current) {
+        return opts({
+            s: OrderByExpression.s(),
+            e: OrderByExpression.e,
+        }, current);
+    }
+    _add(node) {
+        this._children.push(node);
+        return this;
+    }
+    render({ aliases, escape, prefix, } = {}) {
+        let content = this._children
+            .map((n) => n.render({ aliases, escape, prefix }))
+            .join(`,`);
+        return content;
+    }
+    clone() {
+        return new OrderByExpression({
+            children: this._children.map((c) => c.clone()),
+        });
+    }
+    ascending(field) {
+        return this._add(new OrderByField(field, 'asc'));
+    }
+    descending(field) {
+        return this._add(new OrderByField(field, 'desc'));
+    }
+}
 
-  static and<T>() {
-    return new FilterExpression<T>({ connector: Connector.AND });
-  }
+class SearchTerm {
+    constructor(value) {
+        this.value = value;
+    }
+    get [Symbol.toStringTag]() {
+        return 'SearchTerm';
+    }
+    toJSON() {
+        return {
+            $type: Types.rawType(this),
+            value: this.value,
+        };
+    }
+    render({ aliases, escape, prefix, }) {
+        return `${render(this.value, { aliases, escape, prefix })}`;
+    }
+    clone() {
+        return new SearchTerm(this.value);
+    }
+}
+class SearchExpression extends Expression {
+    constructor({ children, connector, negated, } = {}) {
+        super({ children });
+        this._connector = connector || 'AND';
+        this._negated = negated || false;
+    }
+    static e(connector = 'AND') {
+        return new SearchExpression({ connector });
+    }
+    static search(opts, current) {
+        return opts({
+            e: SearchExpression.e,
+        }, current);
+    }
+    _add(node, connector) {
+        if (connector !== undefined && this._connector !== connector) {
+            let children = [];
+            if (this._children.length > 0) {
+                if (this._children.length === 1) {
+                    children = [...this._children];
+                }
+                else {
+                    let exp = new SearchExpression({
+                        children: this._children,
+                        connector: this._connector,
+                        negated: this._negated,
+                    });
+                    if (exp.length() > 1) {
+                        children.push(new Grouping(exp));
+                    }
+                    else {
+                        children.push(exp);
+                    }
+                }
+            }
+            if (node instanceof SearchExpression &&
+                (node.connector() === connector || node.length() === 1)) {
+                children = [...children, ...node.children()];
+            }
+            else {
+                children.push(new Grouping(node));
+            }
+            this._connector = connector;
+            this._children = children;
+        }
+        else if (node instanceof SearchExpression &&
+            !node.negated() &&
+            (node.connector() === connector || node.length() === 1)) {
+            this._children = [...this._children, ...node.children()];
+        }
+        else {
+            this._children.push(node instanceof SearchExpression && !node.negated()
+                ? new Grouping(node)
+                : node);
+        }
+        return this;
+    }
+    render({ aliases, escape, prefix, } = {}) {
+        let content = this._children
+            .map((n) => n.render({ aliases, escape, prefix }))
+            .join(` ${this._connector} `);
+        return content;
+    }
+    clone() {
+        return new SearchExpression({
+            children: this._children.map((c) => c.clone()),
+            connector: this._connector,
+            negated: this._negated,
+        });
+    }
+    toJSON() {
+        return {
+            children: this._children.map((c) => c.toJSON()),
+            connector: this._connector,
+            negated: this._negated,
+        };
+    }
+    connector() {
+        return this._connector;
+    }
+    negated() {
+        return this._negated;
+    }
+    or(exp) {
+        return this._add(exp, 'OR');
+    }
+    and(exp) {
+        return this._add(exp, 'AND');
+    }
+    not(exp) {
+        const notExp = new SearchExpression({
+            children: exp.children(),
+            connector: exp.connector(),
+            negated: true,
+        });
+        return this._add(notExp, this._connector);
+    }
+    term(value) {
+        return this._add(new SearchTerm(value));
+    }
+}
 
-  static or<T>() {
-    return new FilterExpression<T>({ connector: Connector.OR });
-  }
+class SelectExpression extends Expression {
+    constructor({ children, } = {}) {
+        super({ children });
+    }
+    static e() {
+        return new SelectExpression();
+    }
+    static s() {
+        return Field$1.factory();
+    }
+    static select(builder, current) {
+        return builder({
+            s: SelectExpression.s(),
+            e: SelectExpression.e,
+        }, current);
+    }
+    render({ aliases, escape, prefix, } = {}) {
+        return this._children
+            .map((n) => n.render({ aliases, escape, prefix }))
+            .join(',');
+    }
+    clone() {
+        return new SelectExpression({
+            children: this._children.map((c) => c.clone()),
+        });
+    }
+    _add(node) {
+        this._children.push(node);
+        return this;
+    }
+    field(field) {
+        return this._add(field);
+    }
+}
 
-  static not<T>(exp: FilterExpression<T>) {
-    return new FilterExpression<T>({
-      children: exp.children(),
-      connector: exp.connector(),
-      negated: true,
-    });
-  }
+class ExpandField {
+    constructor(field, values = {}) {
+        this.field = field;
+        this.values = values;
+    }
+    get [Symbol.toStringTag]() {
+        return 'ExpandField';
+    }
+    toJSON() {
+        return {
+            field: this.field.toJSON(),
+        };
+    }
+    render({ aliases, escape, prefix, }) {
+        const params = [
+            QueryOptionNames.select,
+            QueryOptionNames.expand,
+            QueryOptionNames.filter,
+            QueryOptionNames.search,
+            QueryOptionNames.orderBy,
+            QueryOptionNames.skip,
+            QueryOptionNames.top,
+            QueryOptionNames.levels,
+        ]
+            .filter((key) => !Types.isEmpty(this.values[key]))
+            .reduce((acc, key) => {
+            let value = this.values[key];
+            if (Types.rawType(value).endsWith('Expression')) {
+                value = value.render({ aliases, prefix, escape });
+            }
+            return Object.assign(acc, { [key]: value });
+        }, {});
+        let expand = `${render(this.field, { aliases, escape, prefix })}`;
+        if (!Types.isEmpty(params)) {
+            expand = `${expand}(${Object.keys(params)
+                .map((key) => `$${key}=${params[key]}`)
+                .join(';')})`;
+        }
+        return expand;
+    }
+    clone() {
+        const values = Object.keys(this.values).reduce((acc, key) => Object.assign(acc, { [key]: Objects.clone(this.values[key]) }), {});
+        return new ExpandField(this.field.clone(), values);
+    }
+    select(opts) {
+        return this.option(QueryOptionNames.select, SelectExpression.select(opts, this.values[QueryOptionNames.select]));
+    }
+    expand(opts) {
+        return this.option(QueryOptionNames.expand, ExpandExpression.expand(opts, this.values[QueryOptionNames.expand]));
+    }
+    filter(opts) {
+        return this.option(QueryOptionNames.filter, FilterExpression.filter(opts, this.values[QueryOptionNames.filter]));
+    }
+    search(opts) {
+        return this.option(QueryOptionNames.search, SearchExpression.search(opts, this.values[QueryOptionNames.search]));
+    }
+    orderBy(opts) {
+        return this.option(QueryOptionNames.orderBy, OrderByExpression.orderBy(opts, this.values[QueryOptionNames.orderBy]));
+    }
+    skip(n) {
+        return this.option(QueryOptionNames.skip, n);
+    }
+    top(n) {
+        return this.option(QueryOptionNames.top, n);
+    }
+    levels(n) {
+        return this.option(QueryOptionNames.levels, n);
+    }
+    // Option Handler
+    option(name, opts) {
+        if (opts !== undefined)
+            this.values[name] = opts;
+        return this.values[name];
+    }
+}
+class ExpandExpression extends Expression {
+    constructor({ children, } = {}) {
+        super({ children });
+    }
+    static e() {
+        return new ExpandExpression();
+    }
+    static s() {
+        return Field$1.factory();
+    }
+    static expand(opts, current) {
+        return opts({
+            s: ExpandExpression.s(),
+            e: ExpandExpression.e,
+        }, current);
+    }
+    render({ aliases, escape, prefix, } = {}) {
+        return this._children
+            .map((n) => n.render({ aliases, escape, prefix }))
+            .join(',');
+    }
+    clone() {
+        return new ExpandExpression({
+            children: this._children.map((c) => c.clone()),
+        });
+    }
+    _add(node) {
+        this._children.push(node);
+        return this;
+    }
+    field(field, opts) {
+        let node = new ExpandField(field);
+        if (opts !== undefined)
+            opts(node);
+        return this._add(node);
+    }
 }
-*/
 
 class ODataQueryOptionHandler {
     constructor(o, n) {
@@ -2144,16 +2493,20 @@ class ODataQueryOptionsHandler {
         return alias(value, name);
     }
     select(opts) {
+        if (Types.isFunction(opts)) {
+            return this.options.expression(QueryOptionNames.select, SelectExpression.select(opts, this.options.expression(QueryOptionNames.select)));
+        }
         return this.options.option(QueryOptionNames.select, opts);
     }
     expand(opts) {
+        if (Types.isFunction(opts)) {
+            return this.options.expression(QueryOptionNames.expand, ExpandExpression.expand(opts, this.options.expression(QueryOptionNames.expand)));
+        }
         return this.options.option(QueryOptionNames.expand, opts);
     }
     compute(opts) {
         if (Types.isFunction(opts)) {
-            return this.options.expression(QueryOptionNames.compute, opts({
-                e: () => Expression.e(),
-            }));
+            return this.options.expression(QueryOptionNames.compute, ComputeExpression.compute(opts, this.options.expression(QueryOptionNames.compute)));
         }
         return this.options.option(QueryOptionNames.compute, opts);
     }
@@ -2164,24 +2517,20 @@ class ODataQueryOptionsHandler {
         return this.options.option(QueryOptionNames.transform, opts);
     }
     search(opts) {
+        if (Types.isFunction(opts)) {
+            return this.options.expression(QueryOptionNames.search, SearchExpression.search(opts, this.options.expression(QueryOptionNames.search)));
+        }
         return this.options.option(QueryOptionNames.search, opts);
     }
     filter(opts) {
         if (Types.isFunction(opts)) {
-            return this.options.expression(QueryOptionNames.filter, opts({
-                s: Expression.s(),
-                e: Expression.e,
-                o: Expression.o(),
-                f: Expression.f(),
-            }));
+            return this.options.expression(QueryOptionNames.filter, FilterExpression.filter(opts, this.options.expression(QueryOptionNames.filter)));
         }
         return this.options.option(QueryOptionNames.filter, opts);
     }
     orderBy(opts) {
         if (Types.isFunction(opts)) {
-            return this.options.expression(QueryOptionNames.orderBy, opts({
-                e: () => Expression.e(),
-            }));
+            return this.options.option(QueryOptionNames.orderBy, OrderByExpression.orderBy(opts, this.options.expression(QueryOptionNames.orderBy)));
         }
         return this.options.option(QueryOptionNames.orderBy, opts);
     }
@@ -2209,22 +2558,22 @@ class ODataQueryOptionsHandler {
     }
     apply(query) {
         if (query.select !== undefined) {
-            this.select(query.select);
+            this.options.option(QueryOptionNames.select, query.select);
         }
         if (query.expand !== undefined) {
-            this.expand(query.expand);
+            this.options.option(QueryOptionNames.expand, query.expand);
         }
         if (query.transform !== undefined) {
-            this.transform(query.transform);
+            this.options.option(QueryOptionNames.transform, query.transform);
         }
         if (query.search !== undefined) {
-            this.search(query.search);
+            this.options.option(QueryOptionNames.search, query.search);
         }
         if (query.filter !== undefined) {
-            this.filter(query.filter);
+            this.options.option(QueryOptionNames.filter, query.filter);
         }
         if (query.orderBy !== undefined) {
-            this.orderBy(query.orderBy);
+            this.options.option(QueryOptionNames.orderBy, query.orderBy);
         }
         this.paging(query);
     }
@@ -2232,7 +2581,7 @@ class ODataQueryOptionsHandler {
 
 class ODataQueryOptions {
     constructor(options) {
-        this.options = options || {};
+        this.values = options || {};
     }
     // Params
     pathAndParams(escape = false) {
@@ -2250,11 +2599,11 @@ class ODataQueryOptions {
             QueryOptionNames.expand,
             QueryOptionNames.format,
         ]
-            .filter((key) => !Types.isEmpty(this.options[key]))
+            .filter((key) => !Types.isEmpty(this.values[key]))
             .reduce((acc, key) => {
-            let value = this.options[key];
-            if (Types.rawType(value) === 'Expression') {
-                value = value.render(aliases);
+            let value = this.values[key];
+            if (Types.rawType(value).endsWith('Expression')) {
+                value = value.render({ aliases });
             }
             return Object.assign(acc, { [key]: value });
         }, {});
@@ -2269,63 +2618,60 @@ class ODataQueryOptions {
                 .join('&'));
     }
     toJSON() {
-        return Object.keys(this.options).reduce((acc, key) => {
-            let value = this.options[key];
-            if (Types.rawType(value) === 'Expression') {
-                value = value.toJSON();
-            }
+        return Object.keys(this.values).reduce((acc, key) => {
+            let value = this.values[key];
+            value =
+                Types.isObject(value) && 'toJSON' in value ? value.toJSON() : value;
             return Object.assign(acc, { [key]: value });
         }, {});
     }
     toQueryArguments() {
         return {
-            select: this.options[QueryOptionNames.select],
-            expand: this.options[QueryOptionNames.expand],
-            transform: this.options[QueryOptionNames.transform],
-            compute: this.options[QueryOptionNames.compute],
-            search: this.options[QueryOptionNames.search],
-            filter: this.options[QueryOptionNames.filter],
-            orderBy: this.options[QueryOptionNames.orderBy],
-            top: this.options[QueryOptionNames.top],
-            skip: this.options[QueryOptionNames.skip],
-            skiptoken: this.options[QueryOptionNames.skiptoken],
+            select: this.values[QueryOptionNames.select],
+            expand: this.values[QueryOptionNames.expand],
+            transform: this.values[QueryOptionNames.transform],
+            compute: this.values[QueryOptionNames.compute],
+            search: this.values[QueryOptionNames.search],
+            filter: this.values[QueryOptionNames.filter],
+            orderBy: this.values[QueryOptionNames.orderBy],
+            top: this.values[QueryOptionNames.top],
+            skip: this.values[QueryOptionNames.skip],
+            skiptoken: this.values[QueryOptionNames.skiptoken],
         };
     }
     clone() {
-        const options = Object.keys(this.options).reduce((acc, key) => {
-            let value = this.options[key];
-            if (Types.rawType(value) !== 'Expression') {
-                value = Objects.clone(value);
-            }
-            return Object.assign(acc, { [key]: value });
-        }, {});
+        const options = Object.keys(this.values).reduce((acc, key) => Object.assign(acc, { [key]: Objects.clone(this.values[key]) }), {});
         return new ODataQueryOptions(options);
     }
-    // Set Expression
+    // Set Renderable
     expression(name, exp) {
-        return (this.options[name] = exp);
+        if (exp !== undefined)
+            this.values[name] = exp;
+        return this.values[name];
     }
     // Option Handler
     option(name, opts) {
         if (opts !== undefined)
-            this.options[name] = opts;
-        return new ODataQueryOptionHandler(this.options, name);
+            this.values[name] = opts;
+        return new ODataQueryOptionHandler(this.values, name);
     }
     // Query Options tools
     has(name) {
-        return this.options[name] !== undefined;
+        return this.values[name] !== undefined;
     }
     remove(...names) {
-        names.forEach((name) => this.option(name).clear());
+        names.forEach((name) => {
+            delete this.values[name];
+        });
     }
     keep(...names) {
-        this.options = Object.keys(this.options)
+        this.values = Object.keys(this.values)
             .filter((k) => names.indexOf(k) !== -1)
-            .reduce((acc, k) => Object.assign(acc, { [k]: this.options[k] }), {});
+            .reduce((acc, k) => Object.assign(acc, { [k]: this.values[k] }), {});
     }
     // Clear
     clear() {
-        this.options = {};
+        this.values = {};
     }
 }
 
@@ -2756,7 +3102,7 @@ class ODataSchemaElement extends ODataAnnotatable {
         return names.indexOf(type) !== -1;
     }
     /**
-     * Returns a boolean indicating if the structured type is a sub type of the given type.
+     * Returns a boolean indicating if the structured type is a subtype of the given type.
      * @param type String representation of the type
      * @returns True if the callable is type of the given type
      */
@@ -2765,6 +3111,16 @@ class ODataSchemaElement extends ODataAnnotatable {
             return true;
         return false;
     }
+    /**
+     * Returns a boolean indicating if the structured type is a supertype of the given type.
+     * @param type String representation of the type
+     * @returns True if the callable is type of the given type
+     */
+    isSupertypeOf(schema) {
+        if (this.isTypeOf(schema.type()))
+            return true;
+        return false;
+    }
 }
 
 //https://github.com/niklasvh/base64-arraybuffer
@@ -3901,6 +4257,14 @@ class ODataEnumType extends ODataSchemaElement {
     findFieldByValue(value) {
         return this.fields().find((f) => f.value === value);
     }
+    /**
+     * Find a fields by flag.
+     * @param value The value of the field
+     * @returns The fields with the given flag
+     */
+    findFieldsByValue(value) {
+        return this.fields().filter((f) => Boolean(f.value & value));
+    }
     /**
      * Map the fields of the enum type.
      * @param mapper Function that maps the value to the new value
@@ -3972,7 +4336,7 @@ class ODataStructuredType extends ODataSchemaElement {
         }
     }
     /**
-     * Returns a boolean indicating if the structured type is a sub type of the given type.
+     * Returns a boolean indicating if the structured type is a subtype of the given type.
      * @param type String representation of the type
      * @returns True if the callable is type of the given type
      */
@@ -3980,6 +4344,15 @@ class ODataStructuredType extends ODataSchemaElement {
         return (super.isSubtypeOf(schema) ||
             (this.parent !== undefined && this.parent.isSubtypeOf(schema)));
     }
+    /**
+     * Returns a boolean indicating if the structured type is a supertype of the given type.
+     * @param type String representation of the type
+     * @returns True if the callable is type of the given type
+     */
+    isSupertypeOf(schema) {
+        return (super.isSupertypeOf(schema) ||
+            this.children.some((c) => c.isSupertypeOf(schema)));
+    }
     /**
      * Returns a boolean indicating if the structured type has a simple key.
      * @returns True if the structured type has a simple key
@@ -4262,19 +4635,12 @@ class ODataResource {
             other.schema !== undefined &&
             ((_a = this.schema) === null || _a === void 0 ? void 0 : _a.isSubtypeOf(other.schema)));
     }
-    /*
-    isParentOf(other: ODataResource<any>) {
-      const [selfPath] = this.pathAndParams();
-      const [otherPath] = other.pathAndParams();
-      return otherPath !== selfPath && otherPath.startsWith(selfPath);
-    }
-  
-    isChildOf(other: ODataResource<any>) {
-      const [selfPath] = this.pathAndParams();
-      const [otherPath] = other.pathAndParams();
-      return otherPath !== selfPath && selfPath.startsWith(otherPath);
+    isSupertypeOf(other) {
+        var _a;
+        return (this.schema !== undefined &&
+            other.schema !== undefined &&
+            ((_a = this.schema) === null || _a === void 0 ? void 0 : _a.isSupertypeOf(other.schema)));
     }
-    */
     isEqualTo(other, test) {
         const [selfPath, selfParams] = this.pathAndParams();
         const [otherPath, otherParams] = other.pathAndParams();
@@ -4549,6 +4915,9 @@ class ODataActionResource extends ODataResource {
         }
         return action;
     }
+    clone() {
+        return super.clone();
+    }
     //#endregion
     returnType() {
         var _a;
@@ -5857,15 +6226,13 @@ class ODataBatchResource extends ODataResource {
         segments.add(PathSegmentNames.batch, $BATCH);
         return new ODataBatchResource(api, { segments });
     }
+    clone() {
+        const batch = super.clone();
+        batch._requests = [...this._requests];
+        return batch;
+    }
     //#endregion
-    /**
-     * Execute the batch request
-     * @param ctx The context for the request
-     * @param options The options of the batch request
-     * @returns The result of execute the context
-     */
-    exec(ctx, options) {
-        // Store original requester
+    storeRequester() {
         const current = this.api.request;
         // Switch to the batch requester
         this.api.request = (req) => {
@@ -5876,13 +6243,31 @@ class ODataBatchResource extends ODataResource {
             this._requests.push(new ODataBatchRequest(req));
             return this._requests[this._requests.length - 1];
         };
+        return current;
+    }
+    restoreRequester(handler) {
+        this.api.request = handler;
+    }
+    /**
+     * Add to batch request
+     * @param ctx The context for the request
+     * @returns The result of execute the context
+     */
+    add(ctx) {
+        // Store original requester
+        var handler = this.storeRequester();
         // Execute the context
         const obs$ = ctx(this);
         // Restore original requester
-        this.api.request = current;
+        this.restoreRequester(handler);
+        return obs$;
+    }
+    send(options) {
         if (this._requests.length >= 0) {
             const bound = Strings.uniqueId(BATCH_PREFIX);
             const requests = this._requests;
+            // Clean requests
+            this._requests = [];
             const headers = Http.mergeHttpHeaders((options && options.headers) || {}, {
                 [ODATA_VERSION]: VERSION_4_0,
                 [CONTENT_TYPE]: MULTIPART_MIXED_BOUNDARY + bound,
@@ -5903,6 +6288,16 @@ class ODataBatchResource extends ODataResource {
                 ODataBatchResource.handleResponse(requests, response);
             });
         }
+    }
+    /**
+     * Execute the batch request
+     * @param ctx The context for the request
+     * @param options The options of the batch request
+     * @returns The result of execute the context
+     */
+    exec(ctx, options) {
+        const obs$ = this.add(ctx);
+        this.send(options);
         return obs$;
     }
     body() {
@@ -6031,6 +6426,9 @@ class ODataCountResource extends ODataResource {
         query === null || query === void 0 ? void 0 : query.keep(QueryOptionNames.filter, QueryOptionNames.search);
         return new ODataCountResource(api, { segments, query });
     }
+    clone() {
+        return super.clone();
+    }
     //#endregion
     //#region Requests
     get(options) {
@@ -6083,6 +6481,9 @@ class ODataFunctionResource extends ODataResource {
         }
         return func;
     }
+    clone() {
+        return super.clone();
+    }
     //#endregion
     returnType() {
         var _a;
@@ -6174,6 +6575,9 @@ class ODataMediaResource extends ODataResource {
         segments.add(PathSegmentNames.value, $VALUE);
         return new ODataMediaResource(api, { segments, query });
     }
+    clone() {
+        return super.clone();
+    }
     //#endregion
     //#region Requests
     get(options) {
@@ -6226,6 +6630,9 @@ class ODataValueResource extends ODataResource {
         }
         return value;
     }
+    clone() {
+        return super.clone();
+    }
     //#endregion
     //#region Requests
     get(options) {
@@ -6291,6 +6698,9 @@ class ODataPropertyResource extends ODataResource {
         }
         return property;
     }
+    clone() {
+        return super.clone();
+    }
     //#endregion
     key(value) {
         const property = this.clone();
@@ -6426,6 +6836,9 @@ class ODataReferenceResource extends ODataResource {
         query === null || query === void 0 ? void 0 : query.clear();
         return new ODataReferenceResource(api, { segments, query });
     }
+    clone() {
+        return super.clone();
+    }
     //#endregion
     //#region Requests
     post(target, options) {
@@ -6554,6 +6967,9 @@ class ODataNavigationPropertyResource extends ODataResource {
         }
         return navigation;
     }
+    clone() {
+        return super.clone();
+    }
     //#endregion
     key(value) {
         const navigation = this.clone();
@@ -6725,6 +7141,9 @@ class ODataEntityResource extends ODataResource {
         query === null || query === void 0 ? void 0 : query.keep(QueryOptionNames.expand, QueryOptionNames.select, QueryOptionNames.format);
         return new ODataEntityResource(api, { segments, query, schema });
     }
+    clone() {
+        return super.clone();
+    }
     //#endregion
     key(value) {
         const entity = this.clone();
@@ -6764,7 +7183,7 @@ class ODataEntityResource extends ODataResource {
         if (castSchema !== undefined &&
             baseSchema !== undefined &&
             !castSchema.isSubtypeOf(baseSchema))
-            throw new Error(`Cannot cast to ${type}`);
+            throw new Error(`cast: Cannot cast to ${type}`);
         const segments = this.cloneSegments();
         segments.add(PathSegmentNames.type, type).type(type);
         return new ODataEntityResource(this.api, {
@@ -6805,7 +7224,7 @@ class ODataEntityResource extends ODataResource {
     }
     fetch(options) {
         if (!this.hasKey())
-            return throwError('Entity resource without key');
+            return throwError(() => new Error('fetch: Entity resource without key'));
         return this.get(options);
     }
     fetchEntity(options) {
@@ -6825,6 +7244,9 @@ class ODataEntitySetResource extends ODataResource {
             segment.type(schema.type());
         return new ODataEntitySetResource(api, { segments, query, schema });
     }
+    clone() {
+        return super.clone();
+    }
     //#endregion
     entity(key) {
         const entity = ODataEntityResource.factory(this.api, {
@@ -6911,6 +7333,9 @@ class ODataMetadataResource extends ODataResource {
         segments.add(PathSegmentNames.metadata, $METADATA);
         return new ODataMetadataResource(api, segments);
     }
+    clone() {
+        return super.clone();
+    }
     //#endregion
     //#region Requests
     get(options) {
@@ -6934,6 +7359,9 @@ class ODataSingletonResource extends ODataResource {
             segment.type(schema.type());
         return new ODataSingletonResource(api, { segments, query, schema });
     }
+    clone() {
+        return super.clone();
+    }
     //#endregion
     key(value) {
         const singleton = this.clone();
@@ -7114,6 +7542,16 @@ class ODataModelEvent {
                 : '')
             .join('');
     }
+    //Identifies the current model for the event
+    get currentModel() {
+        const link = this.chain.find(c => ODataModelOptions.isModel(c[0]));
+        return link !== undefined ? link[0] : undefined;
+    }
+    //Identifies the current collection for the event
+    get currentCollection() {
+        const link = this.chain.find(c => ODataModelOptions.isCollection(c[0]));
+        return link !== undefined ? link[0] : undefined;
+    }
 }
 const BUBBLING = [
     'change',
@@ -7415,8 +7853,8 @@ class ODataModelOptions {
     attach(self, resource) {
         if (self._resource !== null &&
             resource.type() !== self._resource.type() &&
-            !resource.isSubtypeOf(self._resource))
-            throw new Error(`Can't reattach ${resource.type()} to ${self._resource.type()}`);
+            !self._resource.isSubtypeOf(resource))
+            throw new Error(`Can't attach ${resource.type()} to ${self._resource.type()}`);
         const current = self._resource;
         if (current === null || !current.isEqualTo(resource)) {
             self._resource = resource;
@@ -7444,12 +7882,7 @@ class ODataModelOptions {
         var _a;
         let resource = undefined;
         for (let [model, field] of ODataModelOptions.chain(child)) {
-            resource =
-                resource ||
-                    model._resource ||
-                    (ODataModelOptions.isModel(model)
-                        ? model._meta.modelResourceFactory()
-                        : model._model.meta.collectionResourceFactory());
+            resource = resource || model._resource;
             if (resource === undefined)
                 break;
             if (ODataModelOptions.isModel(model)) {
@@ -7464,7 +7897,7 @@ class ODataModelOptions {
             }
             if (field === null) {
                 const query = (_a = model._resource) === null || _a === void 0 ? void 0 : _a.cloneQuery().toQueryArguments();
-                if (query !== undefined)
+                if (query !== undefined && resource !== undefined)
                     resource.query((q) => q.apply(query));
                 continue;
             }
@@ -7505,7 +7938,8 @@ class ODataModelOptions {
             self._parent = parent;
         }
         // Resource
-        resource = resource || this.modelResourceFactory();
+        if (self._parent === null && resource === undefined)
+            resource = this.modelResourceFactory();
         if (resource !== undefined) {
             this.attach(self, resource);
         }
@@ -7628,14 +8062,29 @@ class ODataModelOptions {
                     (model != undefined && model.hasChanged({ include_navigation })))));
     }
     asEntity(self, func) {
-        const parent = self._parent;
+        // Build new resource
+        const query = self.resource().cloneQuery();
+        let resource = this.modelResourceFactory(query);
+        if (resource === undefined)
+            throw new Error('Model does not have associated Entity endpoint');
+        // Store parent and resource
+        const store = { parent: self._parent, resource: self._resource };
+        // Replace parent and resource
         self._parent = null;
+        self._resource = resource;
+        // Execute function
         const result = func(self);
         if (result instanceof Observable) {
-            return result.pipe(finalize(() => (self._parent = parent)));
+            return result.pipe(finalize(() => {
+                // Restore parent and resource
+                self._parent = store.parent;
+                self._resource = store.resource;
+            }));
         }
         else {
-            self._parent = parent;
+            // Restore parent and resource
+            self._parent = store.parent;
+            self._resource = store.resource;
             return result;
         }
     }
@@ -8028,14 +8477,15 @@ class ODataCollection {
         if (model === undefined && Klass.model !== null)
             model = Klass.model;
         if (model === undefined)
-            throw new Error('Collection need model');
+            throw new Error('Collection: Collection need model');
         this._model = model;
         // Parent
         if (parent !== undefined) {
             this._parent = parent;
         }
         // Resource
-        resource = (resource || this._model.meta.collectionResourceFactory());
+        if (this._parent === null && resource === undefined)
+            resource = this._model.meta.collectionResourceFactory();
         if (resource !== undefined) {
             this.attach(resource);
         }
@@ -8064,8 +8514,8 @@ class ODataCollection {
     attach(resource) {
         if (this._resource !== null &&
             this._resource.type() !== resource.type() &&
-            !resource.isSubtypeOf(this._resource))
-            throw new Error(`Can't reattach ${resource.type()} to ${this._resource.type()}`);
+            !this._resource.isSubtypeOf(resource))
+            throw new Error(`attach: Can't reattach ${this._resource.type()} to ${resource.type()}`);
         this._entries.forEach(({ model }) => {
             const mr = this._model.meta.modelResourceFactory(resource.cloneQuery());
             model.attach(mr);
@@ -8081,14 +8531,29 @@ class ODataCollection {
         }
     }
     asEntitySet(func) {
-        const parent = this._parent;
+        // Build new resource
+        const query = this.resource().cloneQuery();
+        let resource = this._model.meta.collectionResourceFactory(query);
+        if (resource === undefined)
+            throw new Error('asEntitySet: Collection does not have associated EntitySet endpoint');
+        // Store parent and resource
+        const store = { parent: this._parent, resource: this._resource };
+        // Replace parent and resource
         this._parent = null;
+        this._resource = resource;
+        // Execute
         const result = func(this);
         if (result instanceof Observable) {
-            return result.pipe(finalize(() => (this._parent = parent)));
+            return result.pipe(finalize(() => {
+                // Restore
+                this._parent = store.parent;
+                this._resource = store.resource;
+            }));
         }
         else {
-            this._parent = parent;
+            // Restore
+            this._parent = store.parent;
+            this._resource = store.resource;
             return result;
         }
     }
@@ -8147,18 +8612,9 @@ class ODataCollection {
     fetch(_a = {}) {
         var { withCount } = _a, options = __rest(_a, ["withCount"]);
         const resource = this.resource();
-        if (resource === undefined)
-            return throwError('fetch: Resource is undefined');
-        let obs$;
-        if (resource instanceof ODataEntitySetResource) {
-            obs$ = resource.fetch(Object.assign({ withCount }, options));
-        }
-        else if (resource instanceof ODataNavigationPropertyResource) {
-            obs$ = resource.fetch(Object.assign({ responseType: 'entities', withCount }, options));
-        }
-        else {
-            obs$ = resource.fetch(Object.assign({ responseType: 'entities', withCount }, options));
-        }
+        const obs$ = resource instanceof ODataEntitySetResource
+            ? resource.fetch(Object.assign({ withCount }, options))
+            : resource.fetch(Object.assign({ responseType: 'entities', withCount }, options));
         this.events$.emit(new ODataModelEvent('request', { collection: this, value: obs$ }));
         return obs$.pipe(map(({ entities, annots }) => {
             this._annotations = annots;
@@ -8169,10 +8625,8 @@ class ODataCollection {
     }
     fetchAll(options) {
         const resource = this.resource();
-        if (resource === undefined)
-            return throwError('fetchAll: Resource is undefined');
         if (resource instanceof ODataPropertyResource)
-            return throwError('fetchAll: Resource is ODataPropertyResource');
+            return throwError(() => new Error('fetchAll: Resource is ODataPropertyResource'));
         const obs$ = resource.fetchAll(options);
         this.events$.emit(new ODataModelEvent('request', {
             collection: this,
@@ -8197,10 +8651,8 @@ class ODataCollection {
     save(_a = {}) {
         var { relModel = false, method } = _a, options = __rest(_a, ["relModel", "method"]);
         const resource = this.resource();
-        if (resource === undefined)
-            return throwError('saveAll: Resource is undefined');
         if (resource instanceof ODataPropertyResource)
-            return throwError('fetchAll: Resource is ODataPropertyResource');
+            return throwError(() => new Error('save: Resource is ODataPropertyResource'));
         let toDestroyEntity = [];
         let toRemoveReference = [];
         let toDestroyContained = [];
@@ -8568,26 +9020,26 @@ class ODataCollection {
                     return func.call(params, Object.assign({ responseType }, options));
             }
         }
-        return throwError(`Can't function without ODataEntitySetResource`);
+        return throwError(() => new Error(`callFunction: Can't function without ODataEntitySetResource`));
     }
     callAction(name, params, responseType, _a = {}) {
         var options = __rest(_a, []);
         const resource = this.resource();
-        if (resource instanceof ODataEntitySetResource) {
-            const action = resource.action(name);
-            action.query((q) => q.apply(options));
-            switch (responseType) {
-                case 'property':
-                    return action.callProperty(params, options);
-                case 'model':
-                    return action.callModel(params, options);
-                case 'collection':
-                    return action.callCollection(params, options);
-                default:
-                    return action.call(params, Object.assign({ responseType }, options));
-            }
+        if (!(resource instanceof ODataEntitySetResource)) {
+            return throwError(() => new Error(`callAction: Can't action without ODataEntitySetResource`));
+        }
+        const action = resource.action(name);
+        action.query((q) => q.apply(options));
+        switch (responseType) {
+            case 'property':
+                return action.callProperty(params, options);
+            case 'model':
+                return action.callModel(params, options);
+            case 'collection':
+                return action.callCollection(params, options);
+            default:
+                return action.call(params, Object.assign({ responseType }, options));
         }
-        return throwError(`Can't action without ODataEntitySetResource`);
     }
     _unsubscribe(entry) {
         if (entry.subscription) {
@@ -8597,7 +9049,7 @@ class ODataCollection {
     }
     _subscribe(entry) {
         if (entry.subscription) {
-            throw new Error('Subscription already exists');
+            throw new Error('Collection: Subscription already exists');
         }
         entry.subscription = entry.model.events$.subscribe((event) => {
             var _a;
@@ -8647,12 +9099,18 @@ class ODataCollection {
             },
         };
     }
-    filter(predicate) {
+    filter(predicate, thisArg) {
         return this.models().filter(predicate);
     }
-    find(predicate) {
+    map(callbackfn, thisArg) {
+        return this.models().map(callbackfn, thisArg);
+    }
+    find(predicate, thisArg) {
         return this.models().find(predicate);
     }
+    reduce(callbackfn, initialValue) {
+        return this.models().reduce(callbackfn, initialValue);
+    }
     first() {
         return this.models()[0];
     }
@@ -8760,7 +9218,7 @@ class ODataModel {
         this.events$ = new EventEmitter();
         const Klass = this.constructor;
         if (Klass.meta === undefined)
-            throw new Error(`Can't create model without metadata`);
+            throw new Error(`ODataModel: Can't create model without metadata`);
         this._meta = Klass.meta;
         this._meta.bind(this, { parent, resource, annots });
         // Client Id
@@ -8800,19 +9258,19 @@ class ODataModel {
     navigationProperty(name) {
         const field = this._meta.field(name);
         if (field === undefined || !field.navigation)
-            throw Error(`Can't find navigation property ${name}`);
+            throw Error(`navigationProperty: Can't find navigation property ${name}`);
         const resource = this.resource();
         if (!(resource instanceof ODataEntityResource) || !resource.hasKey())
-            throw Error("Can't get navigation without ODataEntityResource with key");
+            throw Error("navigationProperty: Can't get navigation without ODataEntityResource with key");
         return field.resourceFactory(resource);
     }
     property(name) {
         const field = this._meta.field(name);
         if (field === undefined || field.navigation)
-            throw Error(`Can't find property ${name}`);
+            throw Error(`property: Can't find property ${name}`);
         const resource = this.resource();
         if (!(resource instanceof ODataEntityResource) || !resource.hasKey())
-            throw Error("Can't get property without ODataEntityResource with key");
+            throw Error("property: Can't get property without ODataEntityResource with key");
         return field.resourceFactory(resource);
     }
     attach(resource) {
@@ -8958,11 +9416,11 @@ class ODataModel {
         var options = __rest(_a, []);
         let resource = this.resource();
         if (resource === undefined)
-            return throwError('fetch: Resource is undefined');
+            return throwError(() => new Error('fetch: Resource is undefined'));
         let obs$;
         if (resource instanceof ODataEntityResource) {
             if (!resource.hasKey())
-                return throwError("fetch: Can't fetch model without key");
+                return throwError(() => new Error("fetch: Can't fetch model without key"));
             obs$ = resource.fetch(options);
         }
         else if (resource instanceof ODataNavigationPropertyResource) {
@@ -8977,50 +9435,46 @@ class ODataModel {
         var { method, navigation = false, validate = true } = _a, options = __rest(_a, ["method", "navigation", "validate"]);
         let resource = this.resource();
         if (resource === undefined)
-            return throwError('save: Resource is undefined');
+            return throwError(() => new Error('save: Resource is undefined'));
         if (!(resource instanceof ODataEntityResource ||
             resource instanceof ODataNavigationPropertyResource))
-            return throwError('save: Resource type ODataEntityResource/ODataNavigationPropertyResource needed');
+            return throwError(() => new Error('save: Resource type ODataEntityResource/ODataNavigationPropertyResource needed'));
         // Resolve method and resource key
         if (method === undefined && this.schema().isCompoundKey())
-            return throwError('save: Composite key require a specific method, use create/update/modify');
+            return throwError(() => new Error('save: Composite key require a specific method, use create/update/modify'));
         method = method || (!resource.hasKey() ? 'create' : 'update');
         if (resource instanceof ODataEntityResource &&
             (method === 'update' || method === 'modify') &&
             !resource.hasKey())
-            return throwError('save: Update/Patch require entity key');
+            return throwError(() => new Error('save: Update/Patch require entity key'));
         if (resource instanceof ODataNavigationPropertyResource ||
             method === 'create')
             resource.clearKey();
-        let obs$;
-        if (!validate || this.isValid({ method, navigation })) {
-            const _entity = this.toEntity({
-                changes_only: method === 'modify',
-                field_mapping: true,
-                include_concurrency: true,
-                include_navigation: navigation,
-            });
-            obs$ = (method === 'create'
-                ? resource.create(_entity, options)
-                : method === 'modify'
-                    ? resource.modify(_entity, Object.assign({ etag: this.annots().etag }, options))
-                    : resource.update(_entity, Object.assign({ etag: this.annots().etag }, options))).pipe(map(({ entity, annots }) => ({ entity: entity || _entity, annots })));
+        if (validate && !this.isValid({ method, navigation })) {
+            return throwError(() => new Error('save: Validation errors'));
         }
-        else {
-            obs$ = throwError(this._errors);
-        }
-        return this._request(obs$);
+        const _entity = this.toEntity({
+            changes_only: method === 'modify',
+            field_mapping: true,
+            include_concurrency: true,
+            include_navigation: navigation,
+        });
+        return this._request((method === 'create'
+            ? resource.create(_entity, options)
+            : method === 'modify'
+                ? resource.modify(_entity, Object.assign({ etag: this.annots().etag }, options))
+                : resource.update(_entity, Object.assign({ etag: this.annots().etag }, options))).pipe(map(({ entity, annots }) => ({ entity: entity || _entity, annots }))));
     }
     destroy(_a = {}) {
         var options = __rest(_a, []);
         let resource = this.resource();
         if (resource === undefined)
-            return throwError('destroy: Resource is undefined');
+            return throwError(() => new Error('destroy: Resource is undefined'));
         if (!(resource instanceof ODataEntityResource ||
             resource instanceof ODataNavigationPropertyResource))
-            return throwError('destroy: Resource type ODataEntityResource/ODataNavigationPropertyResource needed');
+            return throwError(() => new Error('destroy: Resource type ODataEntityResource/ODataNavigationPropertyResource needed'));
         if (!resource.hasKey())
-            return throwError("destroy: Can't destroy model without key");
+            return throwError(() => new Error("destroy: Can't destroy model without key"));
         const _entity = this.toEntity({ field_mapping: true });
         const obs$ = resource
             .destroy(Object.assign({ etag: this.annots().etag }, options))
@@ -9054,7 +9508,7 @@ class ODataModel {
         var options = __rest(_a, []);
         const resource = this.resource();
         if (!(resource instanceof ODataEntityResource) || !resource.hasKey())
-            return throwError("Can't call function without ODataEntityResource with key");
+            return throwError(() => new Error("callFunction: Can't call function without ODataEntityResource with key"));
         const func = resource.function(name).query((q) => q.apply(options));
         switch (responseType) {
             case 'property':
@@ -9071,7 +9525,7 @@ class ODataModel {
         var options = __rest(_a, []);
         const resource = this.resource();
         if (!(resource instanceof ODataEntityResource) || !resource.hasKey())
-            return throwError("Can't call action without ODataEntityResource with key");
+            return throwError(() => new Error("callAction: Can't call action without ODataEntityResource with key"));
         const action = resource.action(name).query((q) => q.apply(options));
         switch (responseType) {
             case 'property':
@@ -9088,7 +9542,7 @@ class ODataModel {
     cast(type) {
         const resource = this.resource();
         if (!(resource instanceof ODataEntityResource))
-            throw new Error(`Can't cast to derived model without ODataEntityResource`);
+            throw new Error(`cast: Can't cast to derived model without ODataEntityResource`);
         return resource
             .cast(type)
             .asModel(this.toEntity(INCLUDE_DEEP), { annots: this.annots() });
@@ -9108,7 +9562,7 @@ class ODataModel {
     getValue(name, options) {
         const field = this._meta.field(name);
         if (field === undefined || field.navigation)
-            throw Error(`Can't find property ${name}`);
+            throw Error(`getValue: Can't find property ${name}`);
         let value = this[name];
         if (value === undefined) {
             const prop = field.resourceFactory(this.resource());
@@ -9155,7 +9609,7 @@ class ODataModel {
     getReference(name) {
         const field = this._meta.field(name);
         if (field === undefined || !field.navigation)
-            throw Error(`Can't find navigation property ${name}`);
+            throw Error(`getReference: Can't find navigation property ${name}`);
         let model = this[name];
         if (model === undefined) {
             const value = field.collection ? [] : this.referenced(field);
@@ -9962,9 +10416,9 @@ class ODataClient {
         return this.request('PUT', resource, addBody(options, body));
     }
 }
-ODataClient.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ODataClient, deps: [{ token: i1.HttpClient }, { token: ODataSettings }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
-ODataClient.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ODataClient, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ODataClient, decorators: [{
+ODataClient.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ODataClient, deps: [{ token: i1.HttpClient }, { token: ODataSettings }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+ODataClient.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ODataClient, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ODataClient, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -10077,7 +10531,7 @@ class ODataEntitySetService extends ODataEntityService {
     update(key, attrs, options) {
         const res = this.entity(key);
         if (!res.hasKey())
-            return throwError('Resource without key');
+            return throwError(() => new Error('update: Resource without key'));
         return res.update(attrs, options);
     }
     /**
@@ -10090,7 +10544,7 @@ class ODataEntitySetService extends ODataEntityService {
     modify(key, attrs, options) {
         const res = this.entity(key);
         if (!res.hasKey())
-            return throwError('Resource without key');
+            return throwError(() => new Error('modify: Resource without key'));
         return res.modify(attrs, options);
     }
     /**
@@ -10102,7 +10556,7 @@ class ODataEntitySetService extends ODataEntityService {
     destroy(key, options) {
         const res = this.entity(key);
         if (!res.hasKey())
-            return throwError('Resource without key');
+            return throwError(() => new Error('destroy: Resource without key'));
         return res.destroy(options);
     }
     //#region Shortcuts
@@ -10133,12 +10587,12 @@ class ODataEntitySetService extends ODataEntityService {
         var { etag, method } = _a, options = __rest(_a, ["etag", "method"]);
         let schema = this.structuredTypeSchema;
         if (method === undefined && schema !== undefined && schema.isCompoundKey())
-            return throwError('Composite key require a specific method, use create/update/patch');
+            return throwError(() => new Error('save: Composite key require a specific method, use create/update/patch'));
         let key = schema && schema.resolveKey(attrs);
         if (method === undefined)
             method = key !== undefined ? 'update' : 'create';
         if ((method === 'update' || method === 'modify') && key === undefined)
-            return throwError("Can't update/patch entity without key");
+            return throwError(() => new Error("save: Can't update/patch entity without key"));
         return method === 'create'
             ? this.create(attrs, options)
             : method === 'modify'
@@ -10216,9 +10670,9 @@ class ODataServiceFactory {
         })(this.client, singletonName, apiNameOrEntityType);
     }
 }
-ODataServiceFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ODataServiceFactory, deps: [{ token: ODataClient }], target: i0.ɵɵFactoryTarget.Injectable });
-ODataServiceFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ODataServiceFactory });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ODataServiceFactory, decorators: [{
+ODataServiceFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ODataServiceFactory, deps: [{ token: ODataClient }], target: i0.ɵɵFactoryTarget.Injectable });
+ODataServiceFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ODataServiceFactory });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ODataServiceFactory, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: ODataClient }]; } });
 
@@ -10242,10 +10696,10 @@ class ODataModule {
         };
     }
 }
-ODataModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ODataModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-ODataModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ODataModule, imports: [HttpClientModule] });
-ODataModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ODataModule, providers: [ODataClient, ODataServiceFactory], imports: [[HttpClientModule]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ODataModule, decorators: [{
+ODataModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ODataModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ODataModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ODataModule, imports: [HttpClientModule] });
+ODataModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ODataModule, providers: [ODataClient, ODataServiceFactory], imports: [[HttpClientModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ODataModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [HttpClientModule],