dsl-to-sql 1.0.0-fabric-1p-development.1

package/src/js-lib/db/base/IdentifierVisitor.ts

@@ -0,0 +1,66 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+import { VisitorInterface } from './VisitorInterface';
+import * as acorn from 'acorn';
+import { ParseContext } from '../../ParseContext';
+import { toValue, DataType } from '../../../sql-lib/literal';
+import { toColumnRef } from '../../../sql-lib/column';
+import { ExpressionValue } from '../../../sql-types';
+import {
+  RUNTIME_LOGGEDIN_EMAIL,
+  RUNTIME_LOGGEDIN_NAME,
+  RUNTIME_CURRENT_DATE,
+  RUNTIME_CURRENT_DATETIME,
+} from '../../../runtime_var';
+import { getArgType } from '@/utils';
+
+const StaticIdentifierMap = new Map<string, (context: ParseContext) => ExpressionValue>([
+  ['COLUMN_COUNT', (context: ParseContext) => toValue(DataType.NUMBER, context.getColumnCount())],
+  ['BLANK', (context: ParseContext) => toValue(DataType.NULL, null)],
+  ['TRUE', (context: ParseContext) => toValue(DataType.BOOLEAN, true)],
+  ['FALSE', (context: ParseContext) => toValue(DataType.BOOLEAN, false)],
+  ['LOGGEDIN_EMAIL', (context: ParseContext) => toValue(DataType.STRING, RUNTIME_LOGGEDIN_EMAIL)],
+  ['LOGGEDIN_NAME', (context: ParseContext) => toValue(DataType.STRING, RUNTIME_LOGGEDIN_NAME)],
+  ['CURRENT_DATE', (context: ParseContext) => toValue(DataType.STRING, RUNTIME_CURRENT_DATE)],
+  [
+    'CURRENT_DATETIME',
+    (context: ParseContext) => toValue(DataType.STRING, RUNTIME_CURRENT_DATETIME),
+  ],
+]);
+
+export class IdentifierVisitor implements VisitorInterface<acorn.Identifier> {
+  /**
+   * visitor needs to be implemented as arrow function to avoid `this` binding issue since it will be
+   * passed to `acorn-walk` library
+   */
+  public visitor = (node: acorn.Identifier, context: ParseContext) => {
+    try {
+      const nameInUpperCase = node.name.toUpperCase();
+
+      if (StaticIdentifierMap.has(nameInUpperCase)) {
+        context.set(node, StaticIdentifierMap.get(nameInUpperCase)!(context));
+      } else if (
+        context.formulaIdColumnMap[node.name] ||
+        context.deprecatedFormulaColumnMap[node.name]
+      ) {
+        const columnName =
+          context.formulaIdColumnMap[node.name] || context.deprecatedFormulaColumnMap[node.name];
+        const formattedColumnName = context.entityNameFormatter(columnName);
+        context.set(node, toColumnRef(formattedColumnName));
+        context.addColumnDep(columnName);
+        // Validating the identifier and setting the return type
+        const returnType = getArgType(toColumnRef(formattedColumnName), context);
+        Object.assign(context, {
+          returnType,
+          isValid: true,
+          error: undefined,
+        });
+      }
+    } catch (error) {
+      Object.assign(context, {
+        isValid: false,
+        error: error,
+      });
+    }
+  };
+}

package/src/js-lib/db/base/LiteralVisitor.ts

@@ -0,0 +1,38 @@
+import { VisitorInterface } from './VisitorInterface';
+import * as acorn from 'acorn';
+import { ParseContext } from '../../ParseContext';
+import { DataType, toValue } from '../../../sql-lib/literal';
+import { getArgType } from '@/utils';
+
+export class LiteralVisitor implements VisitorInterface<acorn.Literal> {
+  /**
+   * visitor needs to be implemented as arrow function to avoid `this` binding issue since it will be
+   * passed to `acorn-walk` library
+   */
+  public visitor = (node: acorn.Literal, context: ParseContext) => {
+    try {
+      const value = node.value;
+      const literalNode = toValue(getDataType(value), value);
+      context.set(node, literalNode);
+
+      // Validating the Literal and setting the return type
+      const returnType = getArgType(literalNode, context);
+      Object.assign(context, { returnType, isValid: true, error: undefined });
+    } catch (error) {
+      Object.assign(context, { isValid: false, error });
+    }
+  };
+}
+
+function getDataType(value: unknown): DataType {
+  switch (typeof value) {
+    case 'number':
+      return DataType.NUMBER;
+    case 'string':
+      return DataType.STRING;
+    case 'boolean':
+      return DataType.BOOLEAN;
+    default:
+      return DataType.NULL;
+  }
+}

package/src/js-lib/db/base/MemberExpressionVisitor.ts

@@ -0,0 +1,36 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+import { VisitorInterface } from './VisitorInterface';
+import * as acorn from 'acorn';
+import { ParseContext } from '../../ParseContext';
+import { BaseObject } from '../../objects/BaseObject';
+import { DateObject } from '../../objects/DateObject';
+
+const OBJECT_MAP = new Map<string, (context: ParseContext) => BaseObject>([
+  ['DATE', (context: ParseContext) => new DateObject()],
+]);
+
+export class MemberExpressionVisitor implements VisitorInterface<acorn.MemberExpression> {
+  /**
+   * visitor needs to be implemented as arrow function to avoid `this` binding issue since it will be
+   * passed to `acorn-walk` library
+   */
+  public visitor = (node: acorn.MemberExpression, context: ParseContext) => {
+    const objectName = (node.object as acorn.Identifier).name.toUpperCase();
+    const property = (node.property as acorn.Identifier).name.toUpperCase();
+    const object = OBJECT_MAP.get(objectName)?.(context);
+    if (!object) {
+      throw new Error(`Unsupported object: ${objectName}`);
+    }
+
+    context.set(node, object);
+    const isFn = object.fnMap.has(property);
+    const isProp = !isFn && object.propertyMap.has(property);
+    if (!isFn && !isProp) {
+      throw new Error(`Unsupported property: ${property}`);
+    } else if (isProp) {
+      context.set(node, object.propertyMap.get(property)?.(context));
+    }
+    // otherwise ignore. It will be resolved later in call expression
+  };
+}

package/src/js-lib/db/base/ProgramVisitor.ts

@@ -0,0 +1,18 @@
+import { VisitorInterface } from './VisitorInterface';
+import * as acorn from 'acorn';
+import { ParseContext } from '../../ParseContext';
+import { BaseObject } from '../../objects/BaseObject';
+
+export class ProgramVisitor implements VisitorInterface<acorn.Program> {
+  /**
+   * visitor needs to be implemented as arrow function to avoid `this` binding issue since it will be
+   * passed to `acorn-walk` library
+   */
+  public visitor = (node: acorn.Program, context: ParseContext) => {
+    let result = context.get(node.body[node.body.length - 1]);
+    if (result instanceof BaseObject) {
+      result = result.resolve();
+    }
+    context.set(node, result);
+  };
+}

package/src/js-lib/db/base/UnaryExpressionVisitor.ts

@@ -0,0 +1,32 @@
+import { VisitorInterface } from './VisitorInterface';
+import * as acorn from 'acorn';
+import { ParseContext } from '../../ParseContext';
+import { ExpressionValue, Value } from '../../../sql-types';
+
+export class UnaryExpressionVisitor implements VisitorInterface<acorn.UnaryExpression> {
+  /**
+   * visitor needs to be implemented as arrow function to avoid `this` binding issue since it will be
+   * passed to `acorn-walk` library
+   */
+  public visitor = (node: acorn.UnaryExpression, context: ParseContext) => {
+    const expr = context.get(node.argument);
+    const op = node.operator;
+    if (node.argument.type === 'Literal') {
+      context.set(node, resolveLiteral(op, expr as Value));
+      return;
+    }
+
+    throw new Error(`Unsupported unary operator: ${op}`);
+  };
+}
+
+function resolveLiteral(op: string, arg: Value): ExpressionValue {
+  switch (op) {
+    case '-':
+      return { type: 'number', value: -arg.value };
+    case '+':
+      return arg;
+    default:
+      throw new Error(`Unsupported unary operator: ${op}`);
+  }
+}

package/src/js-lib/db/base/VisitorInterface.ts

@@ -0,0 +1,6 @@
+import { ParseContext } from '../../ParseContext';
+import * as acorn from 'acorn';
+export type Node = acorn.Node;
+export interface VisitorInterface<T extends Node> {
+  visitor: (node: T, context: ParseContext) => void;
+}