angular-odata 0.92.0 → 0.95.0

package/esm2020/lib/resources/query/expressions.mjs

@@ -0,0 +1,207 @@
+import { Field, functions, operators, } from './syntax';
+import { syntax } from './syntax';
+export class Expression {
+    constructor({ children, connector, negated, } = {}) {
+        this._children = children || [];
+        this._connector = connector || 'and';
+        this._negated = negated || false;
+    }
+    get [Symbol.toStringTag]() {
+        return 'Expression';
+    }
+    static s() {
+        return Field.factory();
+    }
+    static e(connector = 'and') {
+        return new Expression({ connector });
+    }
+    static o() {
+        return operators;
+    }
+    static f() {
+        return functions;
+    }
+    static filter(opts) {
+        return opts({
+            s: Expression.s(),
+            e: Expression.e,
+            o: Expression.o(),
+            f: Expression.f(),
+        });
+    }
+    toJSON() {
+        return {
+            children: this._children.map((c) => c.toJSON()),
+            connector: this._connector,
+            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 }))
+            .join(` ${this._connector} `);
+        if (this._negated) {
+            content = `not (${content})`;
+        }
+        return content;
+    }
+    _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 Expression({
+                        children: this._children,
+                        connector: this._connector,
+                        negated: this._negated,
+                    });
+                    if (exp.length() > 1) {
+                        children.push(syntax.grouping(exp));
+                    }
+                    else {
+                        children.push(exp);
+                    }
+                }
+            }
+            if (node instanceof Expression &&
+                (node.connector() === connector || node.length() === 1)) {
+                children = [...children, ...node.children()];
+            }
+            else {
+                children.push(syntax.grouping(node));
+            }
+            this._connector = connector;
+            this._children = children;
+        }
+        else if (node instanceof Expression &&
+            !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)
+                : node);
+        }
+        return this;
+    }
+    or(exp) {
+        return this._add(exp, 'or');
+    }
+    and(exp) {
+        return this._add(exp, 'and');
+    }
+    not(exp) {
+        const notExp = new Expression({
+            children: exp.children(),
+            connector: exp.connector(),
+            negated: true,
+        });
+        return this._add(notExp, this._connector);
+    }
+    eq(left, right, normalize) {
+        return this._add(operators.eq(left, right, normalize));
+    }
+    ne(left, right, normalize) {
+        return this._add(operators.ne(left, right, normalize));
+    }
+    gt(left, right, normalize) {
+        return this._add(operators.gt(left, right, normalize));
+    }
+    ge(left, right, normalize) {
+        return this._add(operators.ge(left, right, normalize));
+    }
+    lt(left, right, normalize) {
+        return this._add(operators.lt(left, right, normalize));
+    }
+    le(left, right, normalize) {
+        return this._add(operators.le(left, right, normalize));
+    }
+    has(left, right, normalize) {
+        return this._add(operators.has(left, right, normalize));
+    }
+    in(left, right, normalize) {
+        return this._add(operators.in(left, right, normalize));
+    }
+    contains(left, right, normalize) {
+        return this._add(functions.contains(left, right, normalize));
+    }
+    startsWith(left, right, normalize) {
+        return this._add(functions.startsWith(left, right, normalize));
+    }
+    endsWith(left, right, normalize) {
+        return this._add(functions.endsWith(left, right, normalize));
+    }
+    any(left, opts, alias) {
+        const exp = opts({
+            s: Field.factory(),
+            e: Expression.e,
+        });
+        return this._add(syntax.any(left, exp, alias));
+    }
+    all(left, opts, alias) {
+        const exp = opts({
+            s: Field.factory(),
+            e: Expression.e,
+        });
+        return this._add(syntax.all(left, exp, alias));
+    }
+    isof(left, type) {
+        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 });
+  }
+
+  static and<T>() {
+    return new FilterExpression<T>({ connector: Connector.AND });
+  }
+
+  static or<T>() {
+    return new FilterExpression<T>({ connector: Connector.OR });
+  }
+
+  static not<T>(exp: FilterExpression<T>) {
+    return new FilterExpression<T>({
+      children: exp.children(),
+      connector: exp.connector(),
+      negated: true,
+    });
+  }
+}
+*/
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"expressions.js","sourceRoot":"","sources":["../../../../../../projects/angular-odata/src/lib/resources/query/expressions.ts"],"names":[],"mappings":"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","sourcesContent":["import type { QueryCustomType } from './builder';\nimport {\n  Field,\n  functions,\n  ODataFunctions,\n  ODataOperators,\n  operators,\n  Renderable,\n} from './syntax';\nimport { syntax } from './syntax';\n\nexport type Connector = 'and' | 'or';\n\nexport class Expression<T> implements Renderable {\n  private _connector: Connector;\n  private _negated: boolean;\n  private _children: Renderable[];\n  constructor({\n    children,\n    connector,\n    negated,\n  }: {\n    children?: Renderable[];\n    connector?: Connector;\n    negated?: boolean;\n  } = {}) {\n    this._children = children || [];\n    this._connector = connector || 'and';\n    this._negated = negated || false;\n  }\n\n  get [Symbol.toStringTag]() {\n    return 'Expression';\n  }\n\n  static s<T extends object>(): T {\n    return Field.factory<T>();\n  }\n\n  static e<T>(connector: Connector = 'and') {\n    return new Expression<T>({ connector });\n  }\n\n  static o<T>(): ODataOperators<T> {\n    return operators;\n  }\n\n  static f<T>(): ODataFunctions<T> {\n    return functions;\n  }\n\n  static filter<T extends object>(\n    opts: (e: {\n      s: T;\n      e: (connector?: Connector) => Expression<T>;\n      o: ODataOperators<T>;\n      f: ODataFunctions<T>;\n    }) => Expression<T>\n  ): Expression<T> {\n    return opts({\n      s: Expression.s<T>(),\n      e: Expression.e,\n      o: Expression.o<T>(),\n      f: Expression.f<T>(),\n    }) as Expression<T>;\n  }\n\n  toJSON() {\n    return {\n      children: this._children.map((c) => c.toJSON()),\n      connector: this._connector,\n      negated: this._negated,\n    };\n  }\n\n  children() {\n    return this._children;\n  }\n\n  connector() {\n    return this._connector;\n  }\n\n  negated() {\n    return this._negated;\n  }\n\n  length() {\n    return this._children.length;\n  }\n\n  render({\n    aliases,\n    escape,\n    prefix,\n  }: {\n    aliases?: QueryCustomType[];\n    escape?: boolean;\n    prefix?: string;\n  } = {}): string {\n    let content = this._children\n      .map((n) => n.render({ aliases, escape, prefix }))\n      .join(` ${this._connector} `);\n    if (this._negated) {\n      content = `not (${content})`;\n    }\n    return content;\n  }\n\n  private _add(node: Renderable, connector?: Connector): Expression<T> {\n    if (connector !== undefined && this._connector !== connector) {\n      let children: Renderable[] = [];\n      if (this._children.length > 0) {\n        if (this._children.length === 1) {\n          children = [...this._children];\n        } else {\n          let exp = new Expression<T>({\n            children: this._children,\n            connector: this._connector,\n            negated: this._negated,\n          });\n          if (exp.length() > 1) {\n            children.push(syntax.grouping(exp));\n          } else {\n            children.push(exp);\n          }\n        }\n      }\n      if (\n        node instanceof Expression &&\n        (node.connector() === connector || node.length() === 1)\n      ) {\n        children = [...children, ...node.children()];\n      } else {\n        children.push(syntax.grouping(node));\n      }\n      this._connector = connector;\n      this._children = children;\n    } else if (\n      node instanceof Expression &&\n      !node.negated() &&\n      (node.connector() === connector || node.length() === 1)\n    ) {\n      this._children = [...this._children, ...node.children()];\n    } else {\n      this._children.push(\n        node instanceof Expression && !node.negated()\n          ? syntax.grouping(node)\n          : node\n      );\n    }\n    return this;\n  }\n\n  or(exp: Expression<T>): Expression<T> {\n    return this._add(exp, 'or');\n  }\n\n  and(exp: Expression<T>): Expression<T> {\n    return this._add(exp, 'and');\n  }\n\n  not(exp: Expression<T>): Expression<T> {\n    const notExp = new Expression<T>({\n      children: exp.children(),\n      connector: exp.connector(),\n      negated: true,\n    });\n\n    return this._add(notExp, this._connector);\n  }\n\n  eq(left: any, right: any, normalize?: boolean) {\n    return this._add(operators.eq(left, right, normalize));\n  }\n\n  ne(left: any, right: any, normalize?: boolean) {\n    return this._add(operators.ne(left, right, normalize));\n  }\n\n  gt(left: any, right: any, normalize?: boolean) {\n    return this._add(operators.gt(left, right, normalize));\n  }\n\n  ge(left: any, right: any, normalize?: boolean) {\n    return this._add(operators.ge(left, right, normalize));\n  }\n\n  lt(left: any, right: any, normalize?: boolean) {\n    return this._add(operators.lt(left, right, normalize));\n  }\n\n  le(left: any, right: any, normalize?: boolean) {\n    return this._add(operators.le(left, right, normalize));\n  }\n\n  has(left: any, right: any, normalize?: boolean) {\n    return this._add(operators.has(left, right, normalize));\n  }\n\n  in(left: any, right: any, normalize?: boolean) {\n    return this._add(operators.in(left, right, normalize));\n  }\n\n  contains(left: any, right: any, normalize?: boolean) {\n    return this._add(functions.contains(left, right, normalize));\n  }\n\n  startsWith(left: any, right: any, normalize?: boolean) {\n    return this._add(functions.startsWith(left, right, normalize));\n  }\n\n  endsWith(left: any, right: any, normalize?: boolean) {\n    return this._add(functions.endsWith(left, right, normalize));\n  }\n\n  any<N extends object>(\n    left: N[],\n    opts: (e: {\n      s: N;\n      e: (connector?: Connector) => Expression<N>;\n    }) => Expression<N>,\n    alias?: string\n  ): Expression<T> {\n    const exp = opts({\n      s: Field.factory<N>(),\n      e: Expression.e,\n    }) as Expression<N>;\n    return this._add(syntax.any(left, exp, alias));\n  }\n\n  all<N extends object>(\n    left: N[],\n    opts: (e: {\n      s: N;\n      e: (connector?: Connector) => Expression<N>;\n    }) => Expression<N>,\n    alias?: string\n  ): Expression<T> {\n    const exp = opts({\n      s: Field.factory<N>(),\n      e: Expression.e,\n    }) as Expression<N>;\n    return this._add(syntax.all(left, exp, alias));\n  }\n\n  isof(type: string): Expression<T>;\n  isof(left: T, type: string): Expression<T>;\n  isof(left: any, type?: string): Expression<T> {\n    return this._add(syntax.isof(left, type));\n  }\n}\n\n/*\nexport class FilterExpression<T> extends Expression<T> {\n  constructor({\n    children,\n    connector,\n    negated,\n  }: {\n    children?: Renderable[];\n    connector?: Connector;\n    negated?: boolean;\n  } = {}) {\n    super({ children, connector, negated });\n  }\n\n  get [Symbol.toStringTag]() {\n    return 'FilterExpression';\n  }\n\n  static e<T>() {\n    return new FilterExpression<T>({ connector: Connector.AND });\n  }\n\n  static and<T>() {\n    return new FilterExpression<T>({ connector: Connector.AND });\n  }\n\n  static or<T>() {\n    return new FilterExpression<T>({ connector: Connector.OR });\n  }\n\n  static not<T>(exp: FilterExpression<T>) {\n    return new FilterExpression<T>({\n      children: exp.children(),\n      connector: exp.connector(),\n      negated: true,\n    });\n  }\n}\n*/\n"]}

package/esm2020/lib/resources/query/handlers.mjs

@@ -0,0 +1,186 @@
+import { QueryOptionNames } from '../../types';
+import { Objects, Types } from '../../utils';
+import { alias } from './builder';
+import { Expression } from './expressions';
+export class ODataQueryOptionHandler {
+    constructor(o, n) {
+        this.o = o;
+        this.n = n;
+    }
+    get name() {
+        return this.n;
+    }
+    toJSON() {
+        return this.o[this.n];
+    }
+    empty() {
+        return Types.isEmpty(this.o[this.n]);
+    }
+    //#region Primitive Value
+    value(v) {
+        return (v !== undefined && (this.o[this.n] = v)) || this.o[this.n];
+    }
+    //#endregion
+    //#region Array Value
+    assertArray() {
+        if (!Types.isArray(this.o[this.n]))
+            this.o[this.n] = this.o[this.n] !== undefined ? [this.o[this.n]] : [];
+        return this.o[this.n];
+    }
+    push(value) {
+        this.assertArray().push(value);
+    }
+    remove(value) {
+        this.o[this.n] = this.assertArray().filter((v) => v !== value);
+        // If only one... down to value
+        if (this.o[this.n].length === 1)
+            this.o[this.n] = this.o[this.n][0];
+    }
+    at(index) {
+        return this.assertArray()[index];
+    }
+    //#endregion
+    //#region HashMap Value
+    assertObject(create) {
+        if (!Types.isArray(this.o[this.n]) && Types.isPlainObject(this.o[this.n])) {
+            return this.o[this.n];
+        }
+        let arr = this.assertArray();
+        let obj = arr.find((v) => Types.isPlainObject(v));
+        if (!obj && create) {
+            obj = {};
+            arr.push(obj);
+        }
+        return obj;
+    }
+    set(path, value) {
+        let obj = this.assertObject(true);
+        Objects.set(obj, path, value);
+    }
+    get(path, def) {
+        let obj = this.assertObject(false) || {};
+        return Objects.get(obj, path, def);
+    }
+    unset(path) {
+        let obj = this.assertObject(true);
+        Objects.unset(obj, path);
+        if (Types.isArray(this.o[this.n])) {
+            this.o[this.n] = this.o[this.n].filter((v) => !Types.isEmpty(v));
+            if (this.o[this.n].length === 1)
+                this.o[this.n] = this.o[this.n][0];
+        }
+    }
+    has(path) {
+        let obj = this.assertObject(false) || {};
+        return Objects.has(obj, path);
+    }
+    assign(values) {
+        let obj = this.assertObject(true);
+        return Objects.merge(obj, values);
+    }
+    //#endregion
+    clear() {
+        delete this.o[this.n];
+    }
+}
+export class ODataQueryOptionsHandler {
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Create a new odata alias parameter
+     * @link https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_ParameterAliases
+     * @param value The value of the alias
+     * @param name The name of the alias
+     * @returns The alias
+     */
+    alias(value, name) {
+        return alias(value, name);
+    }
+    select(opts) {
+        return this.options.option(QueryOptionNames.select, opts);
+    }
+    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.option(QueryOptionNames.compute, opts);
+    }
+    format(opts) {
+        return this.options.option(QueryOptionNames.format, opts);
+    }
+    transform(opts) {
+        return this.options.option(QueryOptionNames.transform, opts);
+    }
+    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.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, opts);
+    }
+    top(opts) {
+        return this.options.option(QueryOptionNames.top, opts);
+    }
+    skip(opts) {
+        return this.options.option(QueryOptionNames.skip, opts);
+    }
+    skiptoken(opts) {
+        return this.options.option(QueryOptionNames.skiptoken, opts);
+    }
+    paging({ skip, skiptoken, top, } = {}) {
+        if (skiptoken !== undefined)
+            this.skiptoken(skiptoken);
+        else if (skip !== undefined)
+            this.skip(skip);
+        if (top !== undefined)
+            this.top(top);
+    }
+    clearPaging() {
+        this.skip().clear();
+        this.top().clear();
+        this.skiptoken().clear();
+    }
+    apply(query) {
+        if (query.select !== undefined) {
+            this.select(query.select);
+        }
+        if (query.expand !== undefined) {
+            this.expand(query.expand);
+        }
+        if (query.transform !== undefined) {
+            this.transform(query.transform);
+        }
+        if (query.search !== undefined) {
+            this.search(query.search);
+        }
+        if (query.filter !== undefined) {
+            this.filter(query.filter);
+        }
+        if (query.orderBy !== undefined) {
+            this.orderBy(query.orderBy);
+        }
+        this.paging(query);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"handlers.js","sourceRoot":"","sources":["../../../../../../projects/angular-odata/src/lib/resources/query/handlers.ts"],"names":[],"mappings":"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","sourcesContent":["import { QueryOptionNames } from '../../types';\nimport { Objects, Types } from '../../utils';\nimport { alias, Expand, Filter, OrderBy, Select, Transform } from './builder';\nimport { Connector, Expression } from './expressions';\nimport type { ODataQueryArguments, ODataQueryOptions } from './options';\nimport { ODataFunctions, ODataOperators } from './syntax';\n\nexport class ODataQueryOptionHandler<T> {\n  constructor(\n    private o: { [name: string]: any },\n    private n: QueryOptionNames\n  ) {}\n\n  get name() {\n    return this.n;\n  }\n\n  toJSON() {\n    return this.o[this.n];\n  }\n\n  empty() {\n    return Types.isEmpty(this.o[this.n]);\n  }\n\n  //#region Primitive Value\n  value(v?: any) {\n    return (v !== undefined && (this.o[this.n] = v)) || this.o[this.n];\n  }\n  //#endregion\n\n  //#region Array Value\n  private assertArray(): any[] {\n    if (!Types.isArray(this.o[this.n]))\n      this.o[this.n] = this.o[this.n] !== undefined ? [this.o[this.n]] : [];\n    return this.o[this.n];\n  }\n\n  push(value: any) {\n    this.assertArray().push(value);\n  }\n\n  remove(value: any) {\n    this.o[this.n] = this.assertArray().filter((v) => v !== value);\n    // If only one... down to value\n    if (this.o[this.n].length === 1) this.o[this.n] = this.o[this.n][0];\n  }\n\n  at(index: number) {\n    return this.assertArray()[index];\n  }\n  //#endregion\n\n  //#region HashMap Value\n  private assertObject(create: boolean): { [name: string]: any } {\n    if (!Types.isArray(this.o[this.n]) && Types.isPlainObject(this.o[this.n])) {\n      return this.o[this.n];\n    }\n    let arr = this.assertArray();\n    let obj = arr.find((v) => Types.isPlainObject(v));\n    if (!obj && create) {\n      obj = {};\n      arr.push(obj);\n    }\n    return obj;\n  }\n\n  set(path: string, value: any) {\n    let obj = this.assertObject(true);\n    Objects.set(obj, path, value);\n  }\n\n  get(path: string, def?: any): any {\n    let obj = this.assertObject(false) || {};\n    return Objects.get(obj, path, def);\n  }\n\n  unset(path: string) {\n    let obj = this.assertObject(true);\n    Objects.unset(obj, path);\n\n    if (Types.isArray(this.o[this.n])) {\n      this.o[this.n] = this.o[this.n].filter((v: any) => !Types.isEmpty(v));\n      if (this.o[this.n].length === 1) this.o[this.n] = this.o[this.n][0];\n    }\n  }\n\n  has(path: string) {\n    let obj = this.assertObject(false) || {};\n    return Objects.has(obj, path);\n  }\n\n  assign(values: { [attr: string]: any }) {\n    let obj = this.assertObject(true);\n    return Objects.merge(obj, values);\n  }\n  //#endregion\n\n  clear() {\n    delete this.o[this.n];\n  }\n}\n\nexport class ODataQueryOptionsHandler<T> {\n  constructor(protected options: ODataQueryOptions<T>) {}\n\n  /**\n   * Create a new odata alias parameter\n   * @link https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_ParameterAliases\n   * @param value The value of the alias\n   * @param name The name of the alias\n   * @returns The alias\n   */\n  alias(value: any, name?: string) {\n    return alias(value, name);\n  }\n\n  select(opts: Select<T>): ODataQueryOptionHandler<T>;\n  select(): ODataQueryOptionHandler<T>;\n  select(opts?: Select<T>): any {\n    return this.options.option<Select<T>>(QueryOptionNames.select, opts);\n  }\n\n  expand(opts: Expand<T>): ODataQueryOptionHandler<T>;\n  expand(): ODataQueryOptionHandler<T>;\n  expand(opts?: Expand<T>): any {\n    return this.options.option<Expand<T>>(QueryOptionNames.expand, opts);\n  }\n\n  /**\n   * @link https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_SystemQueryOptioncompute\n   */\n  compute(opts: (e: { e: Expression<T> }) => Expression<T>): Expression<T>;\n  compute(opts: string): ODataQueryOptionHandler<T>;\n  compute(): ODataQueryOptionHandler<T>;\n  compute(opts?: any): any {\n    if (Types.isFunction(opts)) {\n      return this.options.expression(\n        QueryOptionNames.compute,\n        opts({\n          e: () => Expression.e<T>(),\n        }) as Expression<T>\n      );\n    }\n    return this.options.option<string>(QueryOptionNames.compute, opts);\n  }\n\n  /**\n   * @link https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_SystemQueryOptionformat\n   */\n  format(opts: string): ODataQueryOptionHandler<T>;\n  format(): ODataQueryOptionHandler<T>;\n  format(opts?: string): any {\n    return this.options.option<string>(QueryOptionNames.format, opts);\n  }\n\n  transform(opts: Transform<T>): ODataQueryOptionHandler<T>;\n  transform(): ODataQueryOptionHandler<T>;\n  transform(opts?: Transform<T>): any {\n    return this.options.option<Transform<T>>(QueryOptionNames.transform, opts);\n  }\n\n  search(opts: string): ODataQueryOptionHandler<T>;\n  search(): ODataQueryOptionHandler<T>;\n  search(opts?: string): any {\n    return this.options.option<string>(QueryOptionNames.search, opts);\n  }\n\n  filter(\n    opts: (e: {\n      s: T;\n      e: (connector?: Connector) => Expression<T>;\n      o: ODataOperators<T>;\n      f: ODataFunctions<T>;\n    }) => Expression<T>\n  ): Expression<T>;\n  filter(opts: Filter<T>): ODataQueryOptionHandler<T>;\n  filter(): ODataQueryOptionHandler<T>;\n  filter(opts?: any): any {\n    if (Types.isFunction(opts)) {\n      return this.options.expression(\n        QueryOptionNames.filter,\n        opts({\n          s: Expression.s<any>() as T,\n          e: Expression.e,\n          o: Expression.o<T>(),\n          f: Expression.f<T>(),\n        }) as Expression<T>\n      );\n    }\n    return this.options.option<Filter<T>>(QueryOptionNames.filter, opts);\n  }\n\n  orderBy(\n    opts: (e: {\n      e: () => Expression<T>;\n      not: (e: Expression<T>) => Expression<T>;\n    }) => Expression<T>\n  ): Expression<T>;\n  orderBy(opts: OrderBy<T>): ODataQueryOptionHandler<T>;\n  orderBy(): ODataQueryOptionHandler<T>;\n  orderBy(opts?: any): any {\n    if (Types.isFunction(opts)) {\n      return this.options.expression(\n        QueryOptionNames.orderBy,\n        opts({\n          e: () => Expression.e<T>(),\n        }) as Expression<T>\n      );\n    }\n    return this.options.option<OrderBy<T>>(QueryOptionNames.orderBy, opts);\n  }\n\n  top(opts: number): ODataQueryOptionHandler<T>;\n  top(): ODataQueryOptionHandler<T>;\n  top(opts?: number): any {\n    return this.options.option<number>(QueryOptionNames.top, opts);\n  }\n\n  skip(opts: number): ODataQueryOptionHandler<T>;\n  skip(): ODataQueryOptionHandler<T>;\n  skip(opts?: number): any {\n    return this.options.option<number>(QueryOptionNames.skip, opts);\n  }\n\n  skiptoken(opts: string): ODataQueryOptionHandler<T>;\n  skiptoken(): ODataQueryOptionHandler<T>;\n  skiptoken(opts?: string): any {\n    return this.options.option<string>(QueryOptionNames.skiptoken, opts);\n  }\n\n  paging({\n    skip,\n    skiptoken,\n    top,\n  }: { skip?: number; skiptoken?: string; top?: number } = {}) {\n    if (skiptoken !== undefined) this.skiptoken(skiptoken);\n    else if (skip !== undefined) this.skip(skip);\n    if (top !== undefined) this.top(top);\n  }\n\n  clearPaging() {\n    this.skip().clear();\n    this.top().clear();\n    this.skiptoken().clear();\n  }\n\n  apply(query: ODataQueryArguments<T>) {\n    if (query.select !== undefined) {\n      this.select(query.select);\n    }\n    if (query.expand !== undefined) {\n      this.expand(query.expand);\n    }\n    if (query.transform !== undefined) {\n      this.transform(query.transform);\n    }\n    if (query.search !== undefined) {\n      this.search(query.search);\n    }\n    if (query.filter !== undefined) {\n      this.filter(query.filter);\n    }\n    if (query.orderBy !== undefined) {\n      this.orderBy(query.orderBy);\n    }\n    this.paging(query);\n  }\n}\n"]}

package/esm2020/lib/resources/query/options.mjs

@@ -0,0 +1,103 @@
+import { QueryOptionNames } from '../../types';
+import { Objects, Types } from '../../utils';
+import { buildPathAndQuery, } from './builder';
+import { ODataQueryOptionHandler } from './handlers';
+export class ODataQueryOptions {
+    constructor(options) {
+        this.options = options || {};
+    }
+    // Params
+    pathAndParams(escape = false) {
+        let aliases = [];
+        let options = [
+            QueryOptionNames.select,
+            QueryOptionNames.filter,
+            QueryOptionNames.search,
+            QueryOptionNames.compute,
+            QueryOptionNames.transform,
+            QueryOptionNames.orderBy,
+            QueryOptionNames.top,
+            QueryOptionNames.skip,
+            QueryOptionNames.skiptoken,
+            QueryOptionNames.expand,
+            QueryOptionNames.format,
+        ]
+            .filter((key) => !Types.isEmpty(this.options[key]))
+            .reduce((acc, key) => {
+            let value = this.options[key];
+            if (Types.rawType(value) === 'Expression') {
+                value = value.render(aliases);
+            }
+            return Object.assign(acc, { [key]: value });
+        }, {});
+        return buildPathAndQuery({ ...options, aliases, escape });
+    }
+    toString() {
+        const [path, params] = this.pathAndParams();
+        return (path +
+            Object.entries(params)
+                .filter(([, value]) => !Types.isEmpty(value))
+                .map(([key, value]) => `${key}=${value}`)
+                .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.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],
+        };
+    }
+    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 });
+        }, {});
+        return new ODataQueryOptions(options);
+    }
+    // Set Expression
+    expression(name, exp) {
+        return (this.options[name] = exp);
+    }
+    // Option Handler
+    option(name, opts) {
+        if (opts !== undefined)
+            this.options[name] = opts;
+        return new ODataQueryOptionHandler(this.options, name);
+    }
+    // Query Options tools
+    has(name) {
+        return this.options[name] !== undefined;
+    }
+    remove(...names) {
+        names.forEach((name) => this.option(name).clear());
+    }
+    keep(...names) {
+        this.options = Object.keys(this.options)
+            .filter((k) => names.indexOf(k) !== -1)
+            .reduce((acc, k) => Object.assign(acc, { [k]: this.options[k] }), {});
+    }
+    // Clear
+    clear() {
+        this.options = {};
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"options.js","sourceRoot":"","sources":["../../../../../../projects/angular-odata/src/lib/resources/query/options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EACL,iBAAiB,GAOlB,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAgBrD,MAAM,OAAO,iBAAiB;IAG5B,YAAY,OAAiC;QAC3C,IAAI,CAAC,OAAO,GAAG,OAAO,IAAI,EAAE,CAAC;IAC/B,CAAC;IAED,SAAS;IACT,aAAa,CAAC,SAAkB,KAAK;QACnC,IAAI,OAAO,GAAsB,EAAE,CAAC;QACpC,IAAI,OAAO,GAAG;YACZ,gBAAgB,CAAC,MAAM;YACvB,gBAAgB,CAAC,MAAM;YACvB,gBAAgB,CAAC,MAAM;YACvB,gBAAgB,CAAC,OAAO;YACxB,gBAAgB,CAAC,SAAS;YAC1B,gBAAgB,CAAC,OAAO;YACxB,gBAAgB,CAAC,GAAG;YACpB,gBAAgB,CAAC,IAAI;YACrB,gBAAgB,CAAC,SAAS;YAC1B,gBAAgB,CAAC,MAAM;YACvB,gBAAgB,CAAC,MAAM;SACxB;aACE,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;aAClD,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE;YACnB,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YAC9B,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,YAAY,EAAE;gBACzC,KAAK,GAAG,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;aAC/B;YACD,OAAO,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;QAC9C,CAAC,EAAE,EAAE,CAAC,CAAC;QAET,OAAO,iBAAiB,CAAM,EAAE,GAAG,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;IACjE,CAAC;IAED,QAAQ;QACN,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;QAC5C,OAAO,CACL,IAAI;YACJ,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;iBACnB,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;iBAC5C,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,KAAK,EAAE,CAAC;iBACxC,IAAI,CAAC,GAAG,CAAC,CACb,CAAC;IACJ,CAAC;IAED,MAAM;QACJ,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE;YACnD,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YAC9B,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,YAAY,EAAE;gBACzC,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;aACxB;YACD,OAAO,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;QAC9C,CAAC,EAAE,EAAE,CAAC,CAAC;IACT,CAAC;IAED,gBAAgB;QACd,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,MAAM,CAAC;YAC7C,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,MAAM,CAAC;YAC7C,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,SAAS,CAAC;YACnD,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,OAAO,CAAC;YAC/C,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,MAAM,CAAC;YAC7C,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,MAAM,CAAC;YAC7C,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,OAAO,CAAC;YAC/C,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,GAAG,CAAC;YACvC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,IAAI,CAAC;YACzC,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,SAAS,CAAC;SAC1B,CAAC;IAC9B,CAAC;IAED,KAAK;QACH,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE;YAC5D,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YAC9B,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,YAAY,EAAE;gBACzC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;aAC9B;YACD,OAAO,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;QAC9C,CAAC,EAAE,EAAE,CAAC,CAAC;QACP,OAAO,IAAI,iBAAiB,CAAI,OAAO,CAAC,CAAC;IAC3C,CAAC;IAED,iBAAiB;IACjB,UAAU,CAAC,IAAsB,EAAE,GAAkB;QACnD,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC;IACpC,CAAC;IAED,iBAAiB;IACjB,MAAM,CAAI,IAAsB,EAAE,IAAQ;QACxC,IAAI,IAAI,KAAK,SAAS;YAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;QAClD,OAAO,IAAI,uBAAuB,CAAI,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAC5D,CAAC;IAED,sBAAsB;IACtB,GAAG,CAAC,IAAsB;QACxB,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,SAAS,CAAC;IAC1C,CAAC;IAED,MAAM,CAAC,GAAG,KAAyB;QACjC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC;IACrD,CAAC;IAED,IAAI,CAAC,GAAG,KAAyB;QAC/B,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC;aACrC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,CAAqB,CAAC,KAAK,CAAC,CAAC,CAAC;aAC1D,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;IAC1E,CAAC;IAED,QAAQ;IACR,KAAK;QACH,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;IACpB,CAAC;CACF","sourcesContent":["import { QueryOptionNames } from '../../types';\nimport { Objects, Types } from '../../utils';\nimport {\n  buildPathAndQuery,\n  Expand,\n  Filter,\n  OrderBy,\n  QueryCustomType,\n  Select,\n  Transform,\n} from './builder';\nimport { Expression } from './expressions';\nimport { ODataQueryOptionHandler } from './handlers';\n\nexport type ODataQueryArguments<T> = {\n  [QueryOptionNames.select]?: Select<T>;\n  [QueryOptionNames.filter]?: Filter<T>;\n  [QueryOptionNames.search]?: string;\n  [QueryOptionNames.compute]?: string;\n  [QueryOptionNames.transform]?: Transform<T>;\n  [QueryOptionNames.orderBy]?: OrderBy<T>;\n  [QueryOptionNames.top]?: number;\n  [QueryOptionNames.skip]?: number;\n  [QueryOptionNames.skiptoken]?: string;\n  [QueryOptionNames.expand]?: Expand<T>;\n  [QueryOptionNames.format]?: string;\n};\n\nexport class ODataQueryOptions<T> {\n  options: { [name: string]: any };\n\n  constructor(options?: { [name: string]: any }) {\n    this.options = options || {};\n  }\n\n  // Params\n  pathAndParams(escape: boolean = false): [string, { [name: string]: any }] {\n    let aliases: QueryCustomType[] = [];\n    let options = [\n      QueryOptionNames.select,\n      QueryOptionNames.filter,\n      QueryOptionNames.search,\n      QueryOptionNames.compute,\n      QueryOptionNames.transform,\n      QueryOptionNames.orderBy,\n      QueryOptionNames.top,\n      QueryOptionNames.skip,\n      QueryOptionNames.skiptoken,\n      QueryOptionNames.expand,\n      QueryOptionNames.format,\n    ]\n      .filter((key) => !Types.isEmpty(this.options[key]))\n      .reduce((acc, key) => {\n        let value = this.options[key];\n        if (Types.rawType(value) === 'Expression') {\n          value = value.render(aliases);\n        }\n        return Object.assign(acc, { [key]: value });\n      }, {});\n\n    return buildPathAndQuery<any>({ ...options, aliases, escape });\n  }\n\n  toString(): string {\n    const [path, params] = this.pathAndParams();\n    return (\n      path +\n      Object.entries(params)\n        .filter(([, value]) => !Types.isEmpty(value))\n        .map(([key, value]) => `${key}=${value}`)\n        .join('&')\n    );\n  }\n\n  toJSON() {\n    return Object.keys(this.options).reduce((acc, key) => {\n      let value = this.options[key];\n      if (Types.rawType(value) === 'Expression') {\n        value = value.toJSON();\n      }\n      return Object.assign(acc, { [key]: value });\n    }, {});\n  }\n\n  toQueryArguments(): ODataQueryArguments<T> {\n    return {\n      select: this.options[QueryOptionNames.select],\n      expand: this.options[QueryOptionNames.expand],\n      transform: this.options[QueryOptionNames.transform],\n      compute: this.options[QueryOptionNames.compute],\n      search: this.options[QueryOptionNames.search],\n      filter: this.options[QueryOptionNames.filter],\n      orderBy: this.options[QueryOptionNames.orderBy],\n      top: this.options[QueryOptionNames.top],\n      skip: this.options[QueryOptionNames.skip],\n      skiptoken: this.options[QueryOptionNames.skiptoken],\n    } as ODataQueryArguments<T>;\n  }\n\n  clone<O>() {\n    const options = Object.keys(this.options).reduce((acc, key) => {\n      let value = this.options[key];\n      if (Types.rawType(value) !== 'Expression') {\n        value = Objects.clone(value);\n      }\n      return Object.assign(acc, { [key]: value });\n    }, {});\n    return new ODataQueryOptions<O>(options);\n  }\n\n  // Set Expression\n  expression(name: QueryOptionNames, exp: Expression<T>) {\n    return (this.options[name] = exp);\n  }\n\n  // Option Handler\n  option<O>(name: QueryOptionNames, opts?: O) {\n    if (opts !== undefined) this.options[name] = opts;\n    return new ODataQueryOptionHandler<O>(this.options, name);\n  }\n\n  // Query Options tools\n  has(name: QueryOptionNames) {\n    return this.options[name] !== undefined;\n  }\n\n  remove(...names: QueryOptionNames[]) {\n    names.forEach((name) => this.option(name).clear());\n  }\n\n  keep(...names: QueryOptionNames[]) {\n    this.options = Object.keys(this.options)\n      .filter((k) => names.indexOf(k as QueryOptionNames) !== -1)\n      .reduce((acc, k) => Object.assign(acc, { [k]: this.options[k] }), {});\n  }\n\n  // Clear\n  clear() {\n    this.options = {};\n  }\n}\n"]}