Refactor operators/transformations and add Casting support

Author: diegomvh

projects/angular-odata/src/lib/resources/query/expressions/apply.ts

@@ -9,7 +9,6 @@ import {
   ODataFunctions,
   ODataOperators,
   operators,
-  syntax,
   transformations,
   Renderable,
   RenderableFactory,
@@ -202,7 +201,7 @@ export class ApplyExpression<T> extends Expression<T> {
   }
 
   aggregate(value: any, method: AggregateMethod, alias: string): ApplyExpression<T> {
-    return this._add(syntax.aggregate(value, method, alias));
+    return this._add(transformations.aggregate(value, method, alias));
   }
 
   //topcount
@@ -296,10 +295,10 @@ export class ApplyExpression<T> extends Expression<T> {
     props: (e: { rollup: (f: any) => any }) => any | any[],
     opts?: (e: GroupByTransformations<T>) => GroupByTransformations<T>,
   ): ApplyExpression<T> {
-    let properties = props({ rollup: (e: any) => syntax.rollup(e) });
+    let properties = props({ rollup: (e: any) => operators.rollup(e) });
     properties = Array.isArray(properties) ? properties : [properties];
-    const transformations = opts !== undefined ? opts(new GroupByTransformations()) : undefined;
-    return this._add(syntax.groupby(properties, transformations));
+    const transformation = opts !== undefined ? opts(new GroupByTransformations()) : undefined;
+    return this._add(transformations.groupby(properties, transformation));
   }
 
   //filter

projects/angular-odata/src/lib/resources/query/expressions/expand.ts

@@ -7,7 +7,7 @@ import { FilterExpression, FilterExpressionBuilder } from './filter';
 import { OrderByExpression, OrderByExpressionBuilder } from './orderby';
 import { SearchExpression, SearchExpressionBuilder } from './search';
 import { SelectExpression, SelectExpressionBuilder } from './select';
-import { FieldFactory, render, Renderable, RenderableFactory, resolve } from './syntax';
+import { FieldFactory, ODataOperators, operators, render, Renderable, RenderableFactory, resolve } from './syntax';
 
 export class ExpandField<T> implements Renderable {
   constructor(
@@ -193,6 +193,7 @@ export class ExpandField<T> implements Renderable {
 export type ExpandExpressionBuilder<T> = {
   t: Required<T>;
   e: () => ExpandExpression<T>;
+  o: ODataOperators<T>;
 };
 export class ExpandExpression<T> extends Expression<T> {
   constructor({
@@ -218,6 +219,7 @@ export class ExpandExpression<T> extends Expression<T> {
       {
         t: FieldFactory<Required<T>>(),
         e: () => new ExpandExpression<T>(),
+        o: operators as ODataOperators<T>,
       },
       current ?? new ExpandExpression<T>(),
     ) as ExpandExpression<T>;

projects/angular-odata/src/lib/resources/query/expressions/filter.ts

@@ -11,7 +11,6 @@ import {
   operators,
   Renderable,
   RenderableFactory,
-  syntax,
 } from './syntax';
 
 export type FilterConnector = 'and' | 'or';
@@ -128,7 +127,7 @@ export class FilterExpression<F> extends Expression<F> {
             negated: this._negated,
           });
           if (exp.length() > 1) {
-            children.push(syntax.group(exp));
+            children.push(operators.group(exp));
           } else {
             children.push(exp);
           }
@@ -140,7 +139,7 @@ export class FilterExpression<F> extends Expression<F> {
       ) {
         children = [...children, ...node.children()];
       } else {
-        children.push(syntax.group(node));
+        children.push(operators.group(node));
       }
       this._connector = connector;
       this._children = children;
@@ -152,7 +151,7 @@ export class FilterExpression<F> extends Expression<F> {
       this._children = [...this._children, ...node.children()];
     } else {
       this._children.push(
-        node instanceof FilterExpression && !node.negated() ? syntax.group(node) : node,
+        node instanceof FilterExpression && !node.negated() ? operators.group(node) : node,
       );
     }
     return this;
@@ -239,7 +238,7 @@ export class FilterExpression<F> extends Expression<F> {
         e: (connector: FilterConnector = 'and') => new FilterExpression<N>({ connector }),
       }) as FilterExpression<N>;
     }
-    return this._add(syntax.any(left, exp, alias));
+    return this._add(operators.any(left, exp, alias));
   }
 
   all<N>(
@@ -261,7 +260,7 @@ export class FilterExpression<F> extends Expression<F> {
         e: (connector: FilterConnector = 'and') => new FilterExpression<N>({ connector }),
       }) as FilterExpression<N>;
     }
-    return this._add(syntax.all(left, exp, alias));
+    return this._add(operators.all(left, exp, alias));
   }
 
   count<N>(
@@ -274,7 +273,7 @@ export class FilterExpression<F> extends Expression<F> {
   isof(type: string): FilterExpression<F>;
   isof(left: F, type: string): FilterExpression<F>;
   isof(left: any, type?: string): FilterExpression<F> {
-    return this._add(syntax.isof(left, type));
+    return this._add(functions.isof(left, type));
   }
 
   combine(exp: FilterExpression<F>, connector: FilterConnector = 'and'): FilterExpression<F> {

projects/angular-odata/src/lib/resources/query/expressions/orderby.ts

@@ -2,7 +2,7 @@ import { Parser, ParserOptions } from '../../../types';
 import { Types } from '../../../utils';
 import { QueryCustomType } from '../builder';
 import { Expression } from './base';
-import { render, FieldFactory, Renderable, RenderableFactory } from './syntax';
+import { render, FieldFactory, Renderable, RenderableFactory, ODataOperators, operators } from './syntax';
 
 export type OrderAttribute = 'asc' | 'desc';
 export class OrderByField implements Renderable {
@@ -60,6 +60,7 @@ export class OrderByField implements Renderable {
 export type OrderByExpressionBuilder<T> = {
   t: Required<T>;
   e: () => OrderByExpression<T>;
+  o: ODataOperators<T>;
 };
 
 export class OrderByExpression<T> extends Expression<T> {
@@ -86,6 +87,7 @@ export class OrderByExpression<T> extends Expression<T> {
       {
         t: FieldFactory<Required<T>>(),
         e: () => new OrderByExpression<T>(),
+        o: operators as ODataOperators<T>,
       },
       current ?? new OrderByExpression<T>(),
     ) as OrderByExpression<T>;

projects/angular-odata/src/lib/resources/query/expressions/search.ts

@@ -2,7 +2,7 @@ import { Parser, ParserOptions } from '../../../types';
 import { Types } from '../../../utils';
 import { QueryCustomType } from '../builder';
 import { Expression } from './base';
-import { render, syntax, Renderable, RenderableFactory } from './syntax';
+import { operators, render, Renderable, RenderableFactory } from './syntax';
 
 export type SearchConnector = 'AND' | 'OR';
 
@@ -102,7 +102,7 @@ export class SearchExpression<T> extends Expression<T> {
             negated: this._negated,
           });
           if (exp.length() > 1) {
-            children.push(syntax.group(exp));
+            children.push(operators.group(exp));
           } else {
             children.push(exp);
           }
@@ -114,7 +114,7 @@ export class SearchExpression<T> extends Expression<T> {
       ) {
         children = [...children, ...node.children()];
       } else {
-        children.push(syntax.group(node));
+        children.push(operators.group(node));
       }
       this._connector = connector;
       this._children = children;
@@ -126,7 +126,7 @@ export class SearchExpression<T> extends Expression<T> {
       this._children = [...this._children, ...node.children()];
     } else {
       this._children.push(
-        node instanceof SearchExpression && !node.negated() ? syntax.group(node) : node,
+        node instanceof SearchExpression && !node.negated() ? operators.group(node) : node,
       );
     }
     return this;

projects/angular-odata/src/lib/resources/query/expressions/select.ts

@@ -1,11 +1,12 @@
 import { Parser, ParserOptions } from '../../../types';
 import { QueryCustomType } from '../builder';
 import { Expression } from './base';
-import { FieldFactory, Renderable, RenderableFactory } from './syntax';
+import { FieldFactory, ODataOperators, operators, Renderable, RenderableFactory } from './syntax';
 
 export type SelectExpressionBuilder<T> = {
   t: Required<T>;
   e: () => SelectExpression<T>;
+  o: ODataOperators<T>;
 };
 export class SelectExpression<T> extends Expression<T> {
   constructor({
@@ -31,6 +32,7 @@ export class SelectExpression<T> extends Expression<T> {
       {
         t: FieldFactory<Required<T>>(),
         e: () => new SelectExpression<T>(),
+        o: operators as ODataOperators<T>,
       },
       current ?? new SelectExpression<T>(),
     ) as SelectExpression<T>;

projects/angular-odata/src/lib/resources/query/expressions/syntax.ts

@@ -123,6 +123,8 @@ export const RenderableFactory = (value: any): Renderable => {
         return Lambda.fromJson(value);
       case 'Type':
         return Type.fromJson(value);
+      case 'Casting':
+        return Casting.fromJson(value);
       case 'Field':
         return FieldFactory(value['names']);
       default:
@@ -145,7 +147,7 @@ function applyMixins(derivedCtor: any, constructors: any[]) {
 }
 
 export function render(
-  value: any,
+  value: any, 
   {
     aliases,
     normalize,
@@ -163,7 +165,7 @@ export function render(
   } = {},
 ): string | number | boolean | null {
   if (Types.isFunction(value)) {
-    return render(value(syntax), {
+    return render(value({o: operators, f: functions}), {
       aliases,
       normalize,
       prefix,
@@ -647,6 +649,14 @@ export class GroupingOperators<T> {
   }
 }
 
+export class CastingOperators<T> {
+  cast<N>(left: T | string, type?: string): N {
+    return FieldFactory<Required<N>>([
+      type !== undefined ? new Casting<T>(type, left) : new Casting<T>(left as string),
+    ]);
+  }
+}
+
 export type AggregateMethod = 'sum' | 'min' | 'max' | 'average' | 'countdistinct'; //, or with custom aggregation methods;
 
 export class Aggregate<T> implements Renderable {
@@ -885,6 +895,63 @@ export class Type<T> implements Renderable {
   }
 }
 
+export class Casting<T> implements Renderable {
+  constructor(
+    protected type: string,
+    protected value?: any,
+  ) {}
+  get [Symbol.toStringTag]() {
+    return 'Casting';
+  }
+
+  toJson() {
+    return {
+      $type: Types.rawType(this),
+      type: this.type,
+      value: this.value,
+    };
+  }
+
+  static fromJson<T>(json: { [name: string]: any }): Casting<T> {
+    return new Casting<T>(json['type'], RenderableFactory(json['value']));
+  }
+
+  render({
+    aliases,
+    escape,
+    prefix,
+    parser,
+    options,
+  }: {
+    aliases?: QueryCustomType[];
+    escape?: boolean;
+    prefix?: string;
+    parser?: Parser<T>;
+    options?: ParserOptions;
+  }): string {
+    let value;
+    if (this.value) {
+      parser = resolve([this.value], parser);
+      let [left, right] = encode([this.value], parser, options);
+
+      value = render(left, { aliases, escape, prefix, parser, options });
+    }
+    return value ? `${this.value}/${this.type}` : `${this.type}`;
+  }
+
+  clone() {
+    return new Type(this.type, Objects.clone(this.value));
+  }
+
+  resolve(parser: any) {
+    parser =
+      parser instanceof ODataStructuredTypeFieldParser && parser.isStructuredType()
+        ? parser.structuredType()
+        : parser;
+    return parser?.findChildParser((p: any) => p.isTypeOf(this.type));
+  }
+}
+
 export class Lambda<T> implements Renderable {
   constructor(
     protected op: string,
@@ -968,12 +1035,18 @@ export class LambdaOperators<T> {
 
 export class ODataOperators<T> {}
 export interface ODataOperators<T>
-  extends LogicalOperators<T>, ArithmeticOperators<T>, GroupingOperators<T>, LambdaOperators<T> {}
+  extends 
+    LogicalOperators<T>, 
+    ArithmeticOperators<T>, 
+    GroupingOperators<T>, 
+    CastingOperators<T>, 
+    LambdaOperators<T> {}
 
 applyMixins(ODataOperators, [
   LogicalOperators,
   ArithmeticOperators,
   GroupingOperators,
+  CastingOperators,
   LambdaOperators,
 ]);
 export const operators: ODataOperators<any> = new ODataOperators<any>();
@@ -1006,11 +1079,4 @@ export class ODataTransformations<T> {}
 export interface ODataTransformations<T> extends Transformations<T> {}
 
 applyMixins(ODataTransformations, [Transformations]);
-export const transformations: ODataTransformations<any> = new ODataTransformations<any>();
-
-export class ODataSyntax<T> {}
-export interface ODataSyntax<T>
-  extends ODataOperators<T>, ODataFunctions<T>, ODataTransformations<T> {}
-applyMixins(ODataSyntax, [ODataOperators, ODataFunctions, ODataTransformations]);
-
-export const syntax: ODataSyntax<any> = new ODataSyntax<any>();
+export const transformations: ODataTransformations<any> = new ODataTransformations<any>();