angular-odata 0.95.0 → 0.99.0

package/fesm2020/angular-odata.mjs

@@ -1437,7 +1437,26 @@ 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;
@@ -1747,39 +1766,6 @@ class Grouping {
         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);
-    }
-}
 class Lambda {
     constructor(op, values, alias) {
         this.op = op;
@@ -1820,7 +1806,6 @@ class ODataOperators {
 applyMixins(ODataOperators, [
     LogicalOperators,
     ArithmeticOperators,
-    GroupingOperators,
     LambdaOperators,
 ]);
 const operators = new ODataOperators();
@@ -1842,33 +1827,60 @@ 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) {
+        return opts({
+            s: ComputeExpression.s(),
+            e: ComputeExpression.e,
+        });
+    }
+    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(',');
+    }
+    _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;
-    }
-    static f() {
-        return functions;
+        return new FilterExpression({ connector });
     }
     static filter(opts) {
         return opts({
-            s: Expression.s(),
-            e: Expression.e,
-            o: Expression.o(),
-            f: Expression.f(),
+            s: FilterExpression.s(),
+            e: FilterExpression.e,
+            o: operators,
+            f: functions,
         });
     }
     toJSON() {
@@ -1878,18 +1890,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 }))
@@ -1907,37 +1913,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;
@@ -1949,7 +1955,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,
@@ -1992,14 +1998,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));
     }
@@ -2007,45 +2013,254 @@ 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}`;
+    }
+}
+class OrderByExpression extends Expression {
+    constructor({ children, } = {}) {
+        super({ children });
+    }
+    static e() {
+        return new OrderByExpression();
+    }
+    static s() {
+        return Field$1.factory();
+    }
+    static orderBy(opts) {
+        return opts({
+            s: OrderByExpression.s(),
+            e: OrderByExpression.e,
+        });
+    }
+    _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;
+    }
+    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 {
+            value: this.value,
+        };
+    }
+    render({ aliases, escape, prefix, }) {
+        return `${render(this.value, { aliases, escape, prefix })}`;
+    }
+}
+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) {
+        return opts({
+            e: SearchExpression.e,
+        });
+    }
+    _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;
+    }
+    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 ExpandField {
+    constructor(field) {
+        this.field = field;
+    }
+    get [Symbol.toStringTag]() {
+        return 'ExpandField';
+    }
+    toJSON() {
+        return {
+            field: this.field.toJSON(),
+        };
+    }
+    render({ aliases, escape, prefix, }) {
+        return `${render(this.field, { aliases, escape, prefix })}`;
+    }
+    select() { }
+    filter() { }
+    levels() { }
+    orderBy() { }
+    top() { }
+    skip() { }
+}
+class ExpandExpression extends Expression {
+    constructor({ children, } = {}) {
+        super({ children });
+    }
+    static e() {
+        return new ExpandExpression();
+    }
+    static s() {
+        return Field$1.factory();
+    }
+    static expand(opts) {
+        return opts({
+            s: ExpandExpression.s(),
+            e: ExpandExpression.e,
+        });
+    }
+    render({ aliases, escape, prefix, } = {}) {
+        return this._children
+            .map((n) => n.render({ aliases, escape, prefix }))
+            .join(',');
+    }
+    _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);
+    }
+}
 
-  static not<T>(exp: FilterExpression<T>) {
-    return new FilterExpression<T>({
-      children: exp.children(),
-      connector: exp.connector(),
-      negated: true,
-    });
-  }
+class SelectExpression extends Expression {
+    constructor({ children, } = {}) {
+        super({ children });
+    }
+    static e() {
+        return new SelectExpression();
+    }
+    static s() {
+        return Field$1.factory();
+    }
+    static select(opts) {
+        return opts({
+            s: SelectExpression.s(),
+            e: SelectExpression.e,
+        });
+    }
+    render({ aliases, escape, prefix, } = {}) {
+        return this._children
+            .map((n) => n.render({ aliases, escape, prefix }))
+            .join(',');
+    }
+    _add(node) {
+        this._children.push(node);
+        return this;
+    }
+    field(field) {
+        return this._add(field);
+    }
 }
-*/
 
 class ODataQueryOptionHandler {
     constructor(o, n) {
@@ -2143,16 +2358,20 @@ class ODataQueryOptionsHandler {
         return alias(value, name);
     }
     select(opts) {
+        if (Types.isFunction(opts)) {
+            return this.options.expression(QueryOptionNames.select, SelectExpression.select(opts));
+        }
         return this.options.option(QueryOptionNames.select, opts);
     }
     expand(opts) {
+        if (Types.isFunction(opts)) {
+            return this.options.expression(QueryOptionNames.expand, ExpandExpression.expand(opts));
+        }
         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));
         }
         return this.options.option(QueryOptionNames.compute, opts);
     }
@@ -2163,24 +2382,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));
+        }
         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));
         }
         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.expression(QueryOptionNames.orderBy, OrderByExpression.orderBy(opts));
         }
         return this.options.option(QueryOptionNames.orderBy, opts);
     }
@@ -2300,7 +2515,7 @@ class ODataQueryOptions {
         }, {});
         return new ODataQueryOptions(options);
     }
-    // Set Expression
+    // Set Renderable
     expression(name, exp) {
         return (this.options[name] = exp);
     }
@@ -5869,14 +6084,7 @@ class ODataBatchResource extends ODataResource {
         return new ODataBatchResource(api, { segments });
     }
     //#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) => {
@@ -5887,13 +6095,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,
@@ -5914,6 +6140,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() {