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

package/tests/sql-lib/select.test.ts

@@ -0,0 +1,245 @@
+import { SelectBuilder, WithBuilder } from '../../src/sql-lib/select';
+import { toColumnRef, toColumn } from '../../src/sql-lib/column';
+import { toBinaryExpression } from '../../src/sql-lib/binary_expr';
+import { toValue, DataType } from '../../src/sql-lib/literal';
+import { From } from '../../src/sql-types';
+import {
+  IMDMColumnConfigWithParsedMeta,
+  ParseContext,
+  TColumnConfigMap,
+} from '../../src/js-lib/ParseContext';
+
+describe('SelectBuilder', () => {
+  test('should build a basic SELECT statement', () => {
+    const column1 = toColumn(toColumnRef('id', 'users'));
+    const column2 = toColumn(toColumnRef('name', 'users'));
+    const from: From[] = [{ type: 'from', db: null, table: 'users', as: null }];
+
+    const result = new SelectBuilder().addColumns([column1, column2]).addFrom(from).build();
+
+    expect(result).toEqual({
+      type: 'select',
+      with: null,
+      columns: [
+        {
+          type: 'column',
+          expr: { type: 'column_ref', table: 'users', column: 'id', collate: undefined },
+          as: null,
+        },
+        {
+          type: 'column',
+          expr: {
+            type: 'column_ref',
+            table: 'users',
+            column: 'name',
+            collate: undefined,
+          },
+          as: null,
+        },
+      ],
+      from: [{ type: 'from', db: null, table: 'users', as: null }],
+      where: null,
+      qualify: null,
+      groupby: { columns: null, modifiers: [] },
+      having: null,
+      orderby: null,
+      limit: null,
+      options: null,
+      distinct: null,
+      set_op: undefined,
+      _next: undefined,
+    });
+  });
+
+  test('should build a SELECT statement with WHERE clause', () => {
+    const column = toColumn(toColumnRef('name', 'users'));
+    const from: From[] = [{ type: 'from', db: null, table: 'users', as: null }];
+    const where = toBinaryExpression(
+      '=',
+      toColumnRef('status', 'users'),
+      toValue(DataType.STRING, 'active'),
+    );
+
+    const result = new SelectBuilder().addColumns([column]).addFrom(from).addWhere(where).build();
+
+    expect(result).toEqual({
+      type: 'select',
+      with: null,
+      columns: [
+        {
+          type: 'column',
+          expr: {
+            type: 'column_ref',
+            table: 'users',
+            column: 'name',
+            collate: undefined,
+          },
+          as: null,
+        },
+      ],
+      from: [{ type: 'from', db: null, table: 'users', as: null }],
+      where: {
+        type: 'binary_expr',
+        operator: '=',
+        left: { type: 'column_ref', table: 'users', column: 'status', collate: undefined },
+        right: { type: 'string', value: 'active' },
+        parentheses: false,
+      },
+      qualify: null,
+      groupby: { columns: null, modifiers: [] },
+      having: null,
+      orderby: null,
+      limit: null,
+      options: null,
+      distinct: null,
+      set_op: undefined,
+      _next: undefined,
+    });
+  });
+
+  test('should build a SELECT statement with GROUP BY clause', () => {
+    const column1 = toColumn(toColumnRef('department', 'employees'));
+    const column2 = toColumn(
+      {
+        type: 'function',
+        name: { name: [{ type: 'string', value: 'COUNT' }] },
+        args: { type: 'expr_list', value: [{ type: 'star', value: '*' }] },
+      },
+      'employee_count',
+    );
+
+    const from: From[] = [{ type: 'from', db: null, table: 'employees', as: null }];
+    const groupby = {
+      columns: [toColumnRef('department', 'employees')],
+      modifiers: [],
+    };
+
+    const result = new SelectBuilder()
+      .addColumns([column1, column2])
+      .addFrom(from)
+      .addGroupby(groupby)
+      .build();
+
+    expect(result).toEqual({
+      type: 'select',
+      with: null,
+      columns: [
+        {
+          type: 'column',
+          expr: {
+            type: 'column_ref',
+            table: 'employees',
+            column: 'department',
+            collate: undefined,
+          },
+          as: null,
+        },
+        {
+          type: 'column',
+          expr: {
+            type: 'function',
+            name: { name: [{ type: 'string', value: 'COUNT' }] },
+            args: { type: 'expr_list', value: [{ type: 'star', value: '*' }] },
+          },
+          as: 'employee_count',
+        },
+      ],
+      from: [{ type: 'from', db: null, table: 'employees', as: null }],
+      where: null,
+      qualify: null,
+      groupby: {
+        columns: [
+          {
+            type: 'column_ref',
+            table: 'employees',
+            column: 'department',
+            collate: undefined,
+          },
+        ],
+        modifiers: [],
+      },
+      having: null,
+      orderby: null,
+      limit: null,
+      options: null,
+      distinct: null,
+      set_op: undefined,
+      _next: undefined,
+    });
+  });
+});
+
+describe('WithBuilder', () => {
+  const mockContext = new ParseContext({
+    columnConfigMap: new Map<
+      string,
+      IMDMColumnConfigWithParsedMeta
+    >() as unknown as TColumnConfigMap,
+    currentColumnId: 'id',
+    primaryKeyColumns: ['id'],
+    tableName: 'users',
+  });
+
+  test('should build a WITH clause', () => {
+    const selectBuilder = new SelectBuilder()
+      .addColumns([toColumn(toColumnRef('id'))])
+      .addFrom([{ type: 'from', db: null, table: 'users', as: null }]);
+
+    const result = new WithBuilder(mockContext)
+      .addName('active_users')
+      .addStmt(selectBuilder.build())
+      .build();
+
+    expect(result).toEqual({
+      name: { value: 'active_users' },
+      stmt: {
+        _parentheses: true,
+        tableList: [],
+        columnList: [],
+        ast: {
+          type: 'select',
+          with: null,
+          columns: [
+            {
+              type: 'column',
+              expr: {
+                type: 'column_ref',
+                table: null,
+                column: 'id',
+                collate: undefined,
+              },
+              as: null,
+            },
+          ],
+          from: [{ type: 'from', db: null, table: 'users', as: null }],
+          where: null,
+          qualify: null,
+          groupby: { columns: null, modifiers: [] },
+          having: null,
+          orderby: null,
+          limit: null,
+          options: null,
+          distinct: null,
+          set_op: undefined,
+          _next: undefined,
+        },
+      },
+    });
+  });
+
+  test('should throw error when name is missing', () => {
+    const selectBuilder = new SelectBuilder()
+      .addColumns([toColumn(toColumnRef('id'))])
+      .addFrom([{ type: 'from', db: null, table: 'users', as: null }]);
+
+    const withBuilder = new WithBuilder(mockContext).addStmt(selectBuilder.build());
+
+    expect(() => withBuilder.build()).toThrow('name and statement are required');
+  });
+
+  test('should throw error when statement is missing', () => {
+    const withBuilder = new WithBuilder(mockContext).addName('active_users');
+
+    expect(() => withBuilder.build()).toThrow('name and statement are required');
+  });
+});

package/tests/sql-lib/unary_expr.test.ts

@@ -0,0 +1,32 @@
+import { toUnaryExpression } from '../../src/sql-lib/unary_expr';
+import { toValue, DataType } from '../../src/sql-lib/literal';
+import { toColumnRef } from '../../src/sql-lib/column';
+
+describe('toUnaryExpression', () => {
+  test('should create a unary NOT expression for boolean literal', () => {
+    const expr = toValue(DataType.BOOLEAN, true);
+    const result = toUnaryExpression('NOT', expr);
+
+    expect(result).toEqual({
+      type: 'unary_expr',
+      operator: 'NOT',
+      expr: { type: 'boolean', value: true },
+    });
+  });
+
+  test('should create a unary NOT expression for column reference', () => {
+    const expr = toColumnRef('IsInStock', 'products');
+    const result = toUnaryExpression('NOT', expr);
+
+    expect(result).toEqual({
+      type: 'unary_expr',
+      operator: 'NOT',
+      expr: {
+        type: 'column_ref',
+        table: 'products',
+        column: 'IsInStock',
+        collate: undefined,
+      },
+    });
+  });
+});

package/tests/utils.test.ts

@@ -0,0 +1,13 @@
+import { resolveRuntimeVariables } from '../src/utils';
+
+describe('utils', () => {
+  test('should resolve runtime variables', () => {
+    const runtimeVariables = {
+      $RUNTIME_LOGGEDIN_EMAIL: 'test@mdm.com',
+      $RUNTIME_LOGGEDIN_NAME: 'Test User',
+    };
+    const expr = `CONCAT('Name: ', '$RUNTIME_LOGGEDIN_NAME', ', Email: ', '$RUNTIME_LOGGEDIN_EMAIL')`;
+    const resolvedExpr = resolveRuntimeVariables(expr, runtimeVariables);
+    expect(resolvedExpr).toBe(`CONCAT('Name: ', 'Test User', ', Email: ', 'test@mdm.com')`);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "extends": "@repo/typescript-config/base.json",
+  "compilerOptions": {
+    "lib": ["ES2021"],
+    "outDir": "./dist",
+    "target": "es2021",
+    "module": "preserve",
+    "moduleResolution": "bundler",
+    "strictNullChecks": false,
+    "strict": false,
+    "experimentalDecorators": true,
+    "baseUrl": "./",
+    "sourceMap": false,
+    "declaration": true,
+    "emitDecoratorMetadata": true,
+    "paths": {
+      "@type/*": ["src/@types/*"],
+      "@epm-query-builder/*": ["src/epm-query-builder/*"],
+      "@/*": ["src/*"]
+    }
+  },
+  "exclude": ["node_modules"],
+  "include": ["src", "tests"]
+}

package/tsdown.config.ts

@@ -0,0 +1,23 @@
+import { defineConfig } from 'tsdown';
+
+const isWatchMode = process.argv.includes('--watch');
+
+export default defineConfig([
+  {
+    entry: {
+      index: 'src/index.ts',
+    },
+    outDir: 'dist',
+    format: ['cjs', 'esm'],
+    platform: 'neutral',
+    sourcemap: isWatchMode,
+    clean: true,
+    dts: true,
+    minify: false,
+    tsconfig: './tsconfig.json',
+    logLevel: isWatchMode ? 'info' : 'warn',
+    outputOptions: {
+      keepNames: true,
+    },
+  },
+]);