@travetto/model-sql 8.0.0-alpha.9 → 8.0.1

package/src/types.ts

@@ -1,11 +1,25 @@
-import { type Class } from '@travetto/runtime';
+import type { ModelType } from '@travetto/model';
+import type { Class } from '@travetto/runtime';
+import type { SchemaFieldConfig } from '@travetto/schema';
 
-export const TableSymbol = Symbol.for('@travetto/model-sql:table');
+export type JSONSqlPathMode = 'orderBy' | 'createIndex' | 'read';
 
-export type VisitStack = {
-  [TableSymbol]?: string;
-  array?: boolean;
-  type: Class;
-  name: string;
-  index?: number;
-};
+export interface SchemaContext<T> {
+  cls: Class<T>;
+  simpleFields: Map<string, SchemaFieldConfig>;
+  complexFields: Map<string, SchemaFieldConfig>;
+  allFields: SchemaFieldConfig[];
+}
+
+export interface TableContext<T extends ModelType = ModelType> extends SchemaContext<T> {
+  tableName: string;
+  database?: string;
+}
+
+export interface ResolvedPathContext {
+  sqlPath: string;
+  leafField?: SchemaFieldConfig;
+  arrayField?: SchemaFieldConfig;
+  arrayPath?: string[];
+  subPath?: string[];
+}

package/support/test/dialect.ts

@@ -0,0 +1,125 @@
+import assert from 'node:assert';
+
+import { Model, type ModelType, TransientField } from '@travetto/model';
+import { Registry } from '@travetto/registry';
+import type { Class } from '@travetto/runtime';
+import { DiscriminatorField, Required, Schema } from '@travetto/schema';
+import { BeforeAll, Suite, Test } from '@travetto/test';
+
+import type { AbstractANSI99Dialect } from '../../src/dialect.ts';
+import { SQLModelSchemaUtil } from '../../src/schema.ts';
+import type { TableContext } from '../../src/types.ts';
+
+@Schema()
+class ChildItem {
+  name: string;
+  age: number;
+  active: boolean;
+  createdDate: Date;
+}
+
+@Model('dialect_gap_parent')
+class ParentModel {
+  id: string;
+  title: string;
+  child: ChildItem;
+}
+
+@Schema()
+@Model('dialect_gap_simple')
+class SimpleModel {
+  id: string;
+  @Required()
+  requiredField: string;
+  optionalField?: string;
+  @TransientField()
+  transientField: string;
+}
+
+@Schema()
+@Model('dialect_gap_base_poly')
+abstract class BasePolymorphic {
+  id: string;
+  @DiscriminatorField()
+  type: string;
+  @Required()
+  sharedRequired: string;
+}
+
+@Schema()
+@Model('dialect_gap_sub_a')
+class SubTypeA extends BasePolymorphic {
+  @Required()
+  subTypeAOnlyRequired: string;
+}
+
+function getTableContext<T extends ModelType>(modelClass: Class<T>): TableContext<T> {
+  return {
+    tableName: modelClass.name.toLowerCase(),
+    ...SQLModelSchemaUtil.getSchemaContext(modelClass)
+  };
+}
+
+@Suite({ skip: true })
+export abstract class BaseSQLDialectSuite {
+  abstract dialect: AbstractANSI99Dialect;
+
+  @BeforeAll()
+  async setup() {
+    await Registry.init();
+    SQLModelSchemaUtil.SCHEMA_CACHE.clear();
+  }
+
+  @Test('Verify DDL column nullability')
+  async testDDLNullability() {
+    const dialect = this.dialect;
+    const quote = dialect.escapeIdentifier('').substring(0, 1) || '"';
+
+    const simpleContext = getTableContext(SimpleModel);
+    const simpleSQL = dialect.getCreateTableSQL(simpleContext);
+
+    const requiredLine = simpleSQL.split('\n').find(line => line.includes(`${quote}requiredField${quote}`));
+    assert(requiredLine?.includes('NOT NULL'));
+
+    const optionalLine = simpleSQL.split('\n').find(line => line.includes(`${quote}optionalField${quote}`));
+    if (optionalLine) {
+      assert(!optionalLine.includes('NOT NULL'));
+    }
+
+    const transientLine = simpleSQL.split('\n').find(line => line.includes(`${quote}transientField${quote}`));
+    if (transientLine) {
+      assert(!transientLine.includes('NOT NULL'));
+    }
+
+    const polyContext = getTableContext(BasePolymorphic);
+    const polySQL = dialect.getCreateTableSQL(polyContext);
+
+    const sharedRequiredLine = polySQL.split('\n').find(line => line.includes(`${quote}sharedRequired${quote}`));
+    assert(sharedRequiredLine?.includes('NOT NULL'));
+
+    const subTypeLine = polySQL.split('\n').find(line => line.includes(`${quote}subTypeAOnlyRequired${quote}`));
+    if (subTypeLine) {
+      assert(!subTypeLine.includes('NOT NULL'));
+    }
+  }
+
+  @Test()
+  async testFormatJsonPathEscaping() {
+    const simpleJsonPath = this.dialect.formatJsonPath(['child', 'age']);
+    assert(simpleJsonPath === 'child.age');
+
+    const complexJsonPath = this.dialect.formatJsonPath(['child', 'first name']);
+    assert(complexJsonPath === 'child."first name"');
+  }
+
+  @Test()
+  async testPartialUpdateSetsWithoutRegex() {
+    const tableContext = getTableContext(ParentModel);
+    const quote = this.dialect.escapeIdentifier('').substring(0, 1) || '"';
+    const placeholder = this.dialect.getPlaceholder(1);
+
+    const { sets, values } = this.dialect.compilePartialUpdate(tableContext, { title: 'Updated Title' });
+    assert.deepStrictEqual(sets, [`${quote}title${quote} = ${placeholder}`]);
+    assert.deepStrictEqual(values, ['Updated Title']);
+  }
+}

package/support/test/query.ts

@@ -1,103 +1,146 @@
 import assert from 'node:assert';
 
+import { Model, type ModelType } from '@travetto/model';
+import { Registry } from '@travetto/registry';
+import type { Class } from '@travetto/runtime';
 import { Schema, type SchemaFieldConfig } from '@travetto/schema';
-import { Suite, Test } from '@travetto/test';
-import { castTo } from '@travetto/runtime';
-import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
+import { BeforeAll, Suite, Test } from '@travetto/test';
 
-import type { VisitStack } from '../../src/types.ts';
-import type { SQLModelService } from '../../src/service.ts';
+import { AbstractANSI99Dialect } from '../../src/dialect.ts';
+import { SQLModelSchemaUtil } from '../../src/schema.ts';
+import type { ResolvedPathContext, TableContext } from '../../src/types.ts';
 
-@Schema()
+@Model()
 class User {
   id: string;
   name: string;
 }
 
 @Schema()
-class WhereTypeAB {
-  c: number;
+class Nested {
+  value: string;
 }
 
-@Schema()
-class WhereTypeA {
-  d: number;
-  b: WhereTypeAB;
+@Model()
+class WhereType {
+  id: string;
+  name: string;
+  age: number;
+  nestedList: Nested[];
+  nestedObj: Nested;
 }
 
-@Schema()
-class WhereTypeD {
-  e: boolean;
-}
+// @ts-expect-error
+class MockDialect extends AbstractANSI99Dialect {
+  complexColumnType = 'TEXT';
 
-@Schema()
-class WhereTypeG {
-  z: string[];
+  getComplexColumnType(field: SchemaFieldConfig): string {
+    return 'TEXT';
+  }
+
+  getColumnType() {
+    return 'TEXT';
+  }
+
+  compileJsonIndexPath(columnName: string, jsonPath: string[]): string {
+    return `${columnName}->'${jsonPath.join("->'")}'`;
+  }
+
+  override getPlaceholder(index: number) {
+    return `$$${index}`;
+  }
+
+  compileArrayAll(context: ResolvedPathContext, identifier: string, value: unknown[]) {
+    return { sql: `${context.sqlPath} ALL ${identifier}`, formatted: value };
+  }
+
+  compileArrayEquals(context: ResolvedPathContext, identifier: string, values: unknown) {
+    return { sql: `${context.sqlPath} EQUALS ${identifier}`, formatted: values };
+  }
+
+  compileArrayAny(context: ResolvedPathContext, identifier: string, values: unknown[]) {
+    return { sql: `${context.sqlPath} ANY ${identifier}`, formatted: values };
+  }
+
+  compileArrayExists(context: ResolvedPathContext, identifier?: string) {
+    return { sql: `${context.sqlPath} IS NOT NULL`, formatted: undefined };
+  }
+
+  compileArrayRegex(context: ResolvedPathContext, identifier: string, value: RegExp | string) {
+    return { sql: `${context.sqlPath} REGEX ${identifier}`, formatted: value };
+  }
+
+  getRegexOperator(caseInsensitive: boolean) {
+    return caseInsensitive ? '~*' : '~';
+  }
+
+  formatRegex(source: string) {
+    return source;
+  }
+
+  castColumn(sqlPath: string, type: unknown) {
+    if (type === Number) {
+      return `CAST(${sqlPath} AS NUMERIC)`;
+    }
+    return sqlPath;
+  }
+
+  async getTableExists(): Promise<boolean> {
+    return true;
+  }
+
+  async getExistingColumns(): Promise<Map<string, string>> {
+    return new Map();
+  }
+
+  async getExistingIndexes(): Promise<Map<string, string>> {
+    return new Map();
+  }
+
+  async dropIndex(): Promise<void> {}
 }
 
-@Schema()
-class WhereType {
-  a: WhereTypeA[];
-  d: WhereTypeD;
-  g: WhereTypeG;
-  name: number;
-  age: number;
+const mockDialect = new MockDialect();
+
+function getMockContext<T extends ModelType>(modelClass: Class<T>): TableContext<T> {
+  return {
+    tableName: modelClass.name.toLowerCase(),
+    ...SQLModelSchemaUtil.getSchemaContext(modelClass)
+  };
 }
 
 @Suite()
-export abstract class BaseSQLTest extends BaseModelSuite<SQLModelService> {
-
-  get dialect() {
-    return this.service.then(s => s.client);
+export class SQLQueryCompilerTest {
+  @BeforeAll()
+  async setup() {
+    await Registry.init();
   }
 
   @Test()
-  async validateQuery() {
-    const qry = {
-      $and: [
-        { a: { b: { c: 5 } } },
-        { d: { e: true } },
-        {
-          $or: [{ name: 5 }, { age: 10 }]
-        },
-        { g: { z: { $in: ['a', 'b', 'c'] } } },
-        { a: { d: { $gt: 20 } } }
-      ]
-    };
-
-    const dct = await this.dialect;
-    dct.resolveName = (stack: VisitStack[]) => {
-      const field: SchemaFieldConfig = castTo(stack.at(-1));
-      const parent: SchemaFieldConfig = castTo(stack.at(-2));
-      return `${field.class ? field.class.name.toString() : parent.name.toString()}.${field.name.toString()}`;
-    };
-
-    const qryStr = dct.getWhereGroupingSQL(WhereType, qry);
-    assert(qryStr === "(WhereTypeAB.c = 5 AND WhereTypeD.e = TRUE AND (WhereType.name = 5 OR WhereType.age = 10) AND z.z IN ('a','b','c') AND WhereTypeA.d > 20)");
+  async testCompileSimple() {
+    const context = getMockContext(User);
+    const { whereSQL, parameters } = mockDialect.compileWhere(context, { name: 'john' });
+    assert(whereSQL === '"name" = $$1');
+    assert.deepStrictEqual(parameters, ['john']);
   }
 
   @Test()
-  async testRegEx() {
-    const dct = await this.dialect;
-    dct.resolveName = (stack: VisitStack[]) => {
-      const field: SchemaFieldConfig = castTo(stack.at(-1));
-      return `${field.class?.name}.${field.name.toString()}`;
-    };
-
-    const out = dct.getWhereGroupingSQL(User, {
-      name: {
-        $regex: /google.$/
-      }
+  async testCompileOperators() {
+    const context = getMockContext(WhereType);
+    const { whereSQL, parameters } = mockDialect.compileWhere(context, {
+      age: { $gt: 18, $lte: 100 }
     });
+    assert(whereSQL === '("age" > $$1 AND "age" <= $$2)');
+    assert.deepStrictEqual(parameters, [18, 100]);
+  }
 
-    assert(out === `User.name ${dct.SQL_OPS.$regex} 'google.$'`);
-
-    const outBoundary = dct.getWhereGroupingSQL(User, {
-      name: {
-        $regex: /\bgoogle\b/
-      }
+  @Test()
+  async testCompileNested() {
+    const context = getMockContext(WhereType);
+    const { whereSQL, parameters } = mockDialect.compileWhere(context, {
+      nestedObj: { value: 'test' }
     });
-
-    assert(outBoundary === `User.name ${dct.SQL_OPS.$regex} '${dct.regexWordBoundary}google${dct.regexWordBoundary}'`);
+    assert(whereSQL === '"nestedObj"->\'value\' = $$1');
+    assert.deepStrictEqual(parameters, ['test']);
   }
-}
+}

package/src/config.ts

@@ -1,45 +0,0 @@
-import { Config } from '@travetto/config';
-import { asFull, Runtime } from '@travetto/runtime';
-
-/**
- * SQL Model Config
- */
-@Config('model.sql')
-export class SQLModelConfig<T extends {} = {}> {
-  /**
-   * Host to connect to
-   */
-  host = '127.0.0.1';
-  /**
-   * Default port
-   */
-  port = 0;
-  /**
-   * Username
-   */
-  user = Runtime.production ? '' : 'travetto';
-  /**
-   * Password
-   */
-  password = Runtime.production ? '' : 'travetto';
-  /**
-   * Table prefix
-   */
-  namespace = '';
-  /**
-   * Database name
-   */
-  database = 'app';
-  /**
-   * Allow storage modification at runtime
-   */
-  modifyStorage?: boolean;
-  /**
-   * Db version
-   */
-  version = '';
-  /**
-   * Raw client options
-   */
-  options: T = asFull({});
-}

package/src/connection/base.ts

@@ -1,188 +0,0 @@
-import { castTo, Util } from '@travetto/runtime';
-import { type AsyncContext, AsyncContextValue } from '@travetto/context';
-
-export type TransactionType = 'required' | 'isolated' | 'force';
-
-/**
- * Connection is a common enough pattern, that it can
- * be separated out to allow for differences in connection
- * vs querying.
- */
-export abstract class Connection<C = unknown> {
-
-  isolatedTransactions = true;
-  nestedTransactions = true;
-
-  transactionDialect = {
-    begin: 'BEGIN;',
-    beginNested: 'SAVEPOINT $1;',
-    isolate: 'SET TRANSACTION ISOLATION LEVEL READ COMMITTED;',
-    rollback: 'ROLLBACK;',
-    rollbackNested: 'ROLLBACK TO $1;',
-    commit: 'COMMIT;',
-    commitNested: 'RELEASE SAVEPOINT $1;'
-  };
-
-  readonly context: AsyncContext;
-
-  #active = new AsyncContextValue<C>(this);
-  #activeTx = new AsyncContextValue<boolean>(this);
-
-  constructor(context: AsyncContext) {
-    this.context = context;
-  }
-
-  /**
-   * Get active connection
-   */
-  get active(): C | undefined {
-    return this.#active.get();
-  }
-
-  /**
-   * Get active tx state
-   */
-  get activeTx(): boolean {
-    return !!this.#activeTx.get();
-  }
-
-  /**
-   * Initialize connection source
-   */
-  init?(): Promise<void> | void;
-
-  /**
-   * Executes a query on the connection
-   * @param rawConnection
-   * @param query
-   */
-  abstract execute<T = unknown>(rawConnection: C, query: string, values?: unknown[]): Promise<{ records: T[], count: number }>;
-
-  /**
-   * Acquire new connection
-   */
-  abstract acquire(): Promise<C>;
-
-  /**
-   * Release provided connection
-   */
-  abstract release(rawConnection: C): void;
-
-  /**
-   * Run operation with active connection
-   * @param context
-   * @param operation
-   * @param args
-   */
-  async runWithActive<R>(operation: () => Promise<R>): Promise<R> {
-    if (this.active) {
-      return operation();
-    }
-
-    return this.context.run(async () => {
-      let connection;
-      try {
-        connection = await this.acquire();
-        this.#active.set(connection);
-        return await operation();
-      } finally {
-        if (connection) {
-          this.release(connection);
-        }
-      }
-    });
-  }
-
-  /**
-   * Iterate with active connection
-   * @param context
-   * @param operation
-   * @param args
-   */
-  async * iterateWithActive<R>(operation: () => AsyncIterable<R>): AsyncIterable<R> {
-    if (this.active) {
-      yield* operation();
-    }
-
-    const self = castTo<Connection>(this);
-    yield* this.context.iterate(async function* () {
-      try {
-        self.#active.set(await self.acquire());
-        yield* operation();
-      } finally {
-        if (self.active) {
-          self.release(self.active);
-        }
-      }
-    });
-  }
-
-  /**
-   * Run a function within a valid sql transaction.  Relies on @travetto/context.
-   */
-  async runWithTransaction<R>(mode: TransactionType, operation: () => Promise<R>): Promise<R> {
-    if (this.activeTx) {
-      if (mode === 'isolated' || mode === 'force') {
-        const txId = mode === 'isolated' ? `tx${Util.uuid()}` : undefined;
-        try {
-          await this.startTx(this.active!, txId);
-          const result = await operation();
-          await this.commitTx(this.active!, txId);
-          return result;
-        } catch (error) {
-          try { await this.rollbackTx(this.active!, txId); } catch { }
-          throw error;
-        }
-      } else {
-        return await operation();
-      }
-    } else {
-      return this.runWithActive(() => {
-        this.#activeTx.set(true);
-        return this.runWithTransaction('force', operation);
-      });
-    }
-  }
-
-  /**
-   * Start a transaction
-   */
-  async startTx(connection: C, transactionId?: string): Promise<void> {
-    if (transactionId) {
-      if (this.nestedTransactions) {
-        await this.execute(connection, this.transactionDialect.beginNested, [transactionId]);
-      }
-    } else {
-      if (this.isolatedTransactions) {
-        await this.execute(connection, this.transactionDialect.isolate);
-      }
-      await this.execute(connection, this.transactionDialect.begin);
-    }
-  }
-
-  /**
-   * Commit active transaction
-   */
-  async commitTx(connection: C, transactionId?: string): Promise<void> {
-    if (transactionId) {
-      if (this.nestedTransactions) {
-        await this.execute(connection, this.transactionDialect.commitNested, [transactionId]);
-      }
-    } else {
-      await this.execute(connection, this.transactionDialect.commit);
-    }
-  }
-
-  /**
-   * Rollback active transaction
-   */
-  async rollbackTx(connection: C, transactionId?: string): Promise<void> {
-    if (transactionId) {
-      if (this.isolatedTransactions) {
-        await this.execute(connection, this.transactionDialect.rollbackNested, [transactionId]);
-      }
-    } else {
-      await this.execute(connection, this.transactionDialect.rollback);
-    }
-  }
-}

package/src/connection/decorator.ts

@@ -1,54 +0,0 @@
-import type { AsyncIterableMethodDescriptor, AsyncMethodDescriptor } from '@travetto/runtime';
-import type { Connection, TransactionType } from './base.ts';
-
-/**
- * Indicating something is aware of connections
- */
-export interface ConnectionAware<C = unknown> {
-  connection: Connection<C>;
-}
-
-/**
- * Decorator to ensure a method runs with a valid connection
- * @kind decorator
- */
-export function Connected() {
-  return function <T extends { connection?: Connection }>(
-    target: T, property: string, descriptor: AsyncMethodDescriptor<T>
-  ): void {
-    const handle = descriptor.value!;
-    descriptor.value = function (...args: unknown[]): ReturnType<typeof handle> {
-      return this.connection!.runWithActive(() => handle.call(this, ...args));
-    };
-  };
-}
-
-/**
- * Decorator to ensure a method runs with a valid connection
- * @kind decorator
- */
-export function ConnectedIterator() {
-  return function <T extends { connection?: Connection }>(
-    target: T, property: string, descriptor: AsyncIterableMethodDescriptor<T>
-  ): void {
-    const handle = descriptor.value!;
-    descriptor.value = async function* (...args: unknown[]): ReturnType<typeof handle> {
-      yield* this.connection!.iterateWithActive(() => handle.call(this, ...args));
-    };
-  };
-}
-
-/**
- * Decorator to ensure a method runs with a valid transaction
- * @kind decorator
- */
-export function Transactional(mode: TransactionType = 'required') {
-  return function <T extends { connection?: Connection }>(
-    target: unknown, property: string, descriptor: AsyncMethodDescriptor<T>
-  ): void {
-    const handle = descriptor.value!;
-    descriptor.value = function (...args: unknown[]): ReturnType<typeof handle> {
-      return this.connection!.runWithTransaction(mode, () => handle.call(this, ...args));
-    };
-  };
-}