@travetto/model-sql 8.0.0-alpha.29 → 8.0.0-alpha.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-sql",
-  "version": "8.0.0-alpha.29",
+  "version": "8.0.0-alpha.30",
   "type": "module",
   "description": "SQL backing for the travetto model module, with real-time modeling support for SQL schemas.",
   "keywords": [

package/src/dialect.ts

@@ -99,8 +99,12 @@ export abstract class AbstractANSI99Dialect {
     }
   }
 
+  formatJsonPath(jsonPath: string[]): string {
+    return jsonPath.map(segment => (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(segment) ? segment : `"${segment.replaceAll('"', '\\"')}"`)).join('.');
+  }
+
   compileIndexPath(context: TableContext, path: string[], mode: JSONSqlPathMode): string {
-    return this.buildSqlPath(context, path, mode);
+    return this.resolvePath(context, path, mode).sqlPath;
   }
 
   getCreateIndexSQL(context: TableContext, indexConfig: IndexConfig): string {
@@ -115,7 +119,8 @@ export abstract class AbstractANSI99Dialect {
 
         const path = fieldKey.split('.');
         const expression = this.compileIndexPath(context, path, 'createIndex');
-        return `${expression} ${isAscending ? 'ASC' : 'DESC'}`;
+        const formattedExpression = path.length > 1 ? `(${expression})` : expression;
+        return `${formattedExpression} ${isAscending ? 'ASC' : 'DESC'}`;
       });
 
       return `CREATE ${indexConfig.unique ? 'UNIQUE ' : ''}INDEX ${this.escapeIdentifier(indexName)} ON ${this.escapeIdentifier(context.tableName)} (${indexFields.join(', ')});`;
@@ -123,7 +128,8 @@ export abstract class AbstractANSI99Dialect {
       const allFields = [...indexConfig.keyTemplate, ...indexConfig.sortTemplate];
       const indexFields = allFields.map(({ path, value }) => {
         const expression = this.compileIndexPath(context, path, 'createIndex');
-        return `${expression} ${value === -1 ? 'DESC' : 'ASC'}`;
+        const formattedExpression = path.length > 1 ? `(${expression})` : expression;
+        return `${formattedExpression} ${value === -1 ? 'DESC' : 'ASC'}`;
       });
 
       const isUnique = 'unique' in indexConfig && indexConfig.unique;
@@ -165,15 +171,20 @@ CREATE TABLE ${this.escapeIdentifier(context.tableName)} (
     return `ALTER TABLE ${this.escapeIdentifier(context.tableName)} ADD COLUMN ${this.escapeIdentifier(columnName)} ${columnType};`;
   }
 
-  getUpsertSQL(context: TableContext, columns: string[], placeholders: string[], conflictTarget: string[], updates: string[]): string {
-    return `INSERT INTO ${this.escapeIdentifier(context.tableName)} (${columns.join(', ')}) VALUES (${placeholders.join(', ')}) ON CONFLICT (${conflictTarget.join(', ')}) DO UPDATE SET ${updates.join(', ')} RETURNING *;`;
-  }
+  abstract getUpsertSQL(
+    context: TableContext,
+    columns: string[],
+    placeholders: string[],
+    conflictTarget: string[],
+    updates: string[]
+  ): string;
 
   normalizeIndexDefinition(sql: string): string {
     return sql
       .toLowerCase()
       .replaceAll('"', '')
       .replaceAll("'", '')
+      .replaceAll('`', '')
       .replaceAll(' ', '')
       .replaceAll('asc', '')
       .replaceAll('desc', '')
@@ -190,19 +201,13 @@ CREATE TABLE ${this.escapeIdentifier(context.tableName)} (
   abstract parseExistingColumns(records: unknown[]): Map<string, string>;
   abstract getExistingIndexesQuery(context: TableContext): { sql: string; parameters?: unknown[] };
   abstract parseExistingIndexes(records: unknown[]): Map<string, string>;
-
-  getDropIndexSQL(context: TableContext, indexName: string): string {
-    return `DROP INDEX ${this.escapeIdentifier(indexName)} ON ${this.escapeIdentifier(context.tableName)};`;
-  }
+  abstract getDropIndexSQL(context: TableContext, indexName: string): string;
+  abstract getTruncateTableSQL(context: TableContext): string;
 
   getDropTableSQL(context: TableContext): string {
     return `DROP TABLE IF EXISTS ${this.escapeIdentifier(context.tableName)};`;
   }
 
-  getTruncateTableSQL(context: TableContext): string {
-    return `TRUNCATE TABLE ${this.escapeIdentifier(context.tableName)};`;
-  }
-
   getAlterColumnTypeSQL?(context: TableContext, columnName: string, columnType: string, existingType: string): string | undefined;
 
   // Query Compilation
@@ -309,6 +314,28 @@ CREATE TABLE ${this.escapeIdentifier(context.tableName)} (
     };
   }
 
+  getSchemaSubPathMetadata(
+    initialClass: Class | undefined,
+    subPath: string[]
+  ): Array<{ segment: string; fieldConfig?: SchemaFieldConfig; isArray: boolean; fieldClass?: Class }> {
+    let currentClass = initialClass;
+    return subPath.map(segment => {
+      let fieldConfig: SchemaFieldConfig | undefined;
+      let isArray = false;
+      if (currentClass) {
+        const classConfiguration = SchemaRegistryIndex.getOptional(currentClass)?.get();
+        fieldConfig = classConfiguration?.fields[segment];
+        if (fieldConfig) {
+          isArray = !!fieldConfig.array;
+          currentClass = fieldConfig.type;
+        } else {
+          currentClass = undefined;
+        }
+      }
+      return { segment, fieldConfig, isArray, fieldClass: currentClass };
+    });
+  }
+
   resolvePath<T extends ModelType>(tableContext: TableContext<T>, path: string[], mode: JSONSqlPathMode): ResolvedPathContext {
     const firstSegment = path[0];
 
@@ -670,23 +697,7 @@ CREATE TABLE ${this.escapeIdentifier(context.tableName)} (
     return { sql, values };
   }
 
-  compilePartialUpdate<T extends ModelType>(
-    tableContext: TableContext<T>,
-    preparedData: Partial<T>
-  ): { sets: string[]; values: unknown[] } {
-    const { sql, values } = this.buildPartialUpdate(tableContext, preparedData);
-    const setMatch = sql.match(/SET (.*?)(\s+WHERE|$)/);
-    const sets = setMatch ? setMatch[1].split(', ') : [];
-    return { sets, values };
-  }
-
-  buildPartialUpdate<T extends ModelType>(
-    tableContext: TableContext<T>,
-    preparedData: Partial<T>,
-    whereSQL?: string,
-    whereParameters: unknown[] = [],
-    returning = false
-  ): { sql: string; values: unknown[] } {
+  #buildUpdateSets<T extends ModelType>(tableContext: TableContext<T>, preparedData: Partial<T>): { sets: string[]; values: unknown[] } {
     const sets: string[] = [];
     const values: unknown[] = [];
 
@@ -705,6 +716,25 @@ CREATE TABLE ${this.escapeIdentifier(context.tableName)} (
       }
     }
 
+    return { sets, values };
+  }
+
+  compilePartialUpdate<T extends ModelType>(
+    tableContext: TableContext<T>,
+    preparedData: Partial<T>
+  ): { sets: string[]; values: unknown[] } {
+    return this.#buildUpdateSets(tableContext, preparedData);
+  }
+
+  buildPartialUpdate<T extends ModelType>(
+    tableContext: TableContext<T>,
+    preparedData: Partial<T>,
+    whereSQL?: string,
+    whereParameters: unknown[] = [],
+    returning = false
+  ): { sql: string; values: unknown[] } {
+    const { sets, values } = this.#buildUpdateSets(tableContext, preparedData);
+
     const shiftedWhereSQL = whereSQL && this.shiftPlaceholders ? this.shiftPlaceholders(whereSQL, values.length) : whereSQL;
     if (whereSQL) {
       values.push(...whereParameters);

package/support/test/dialect.ts

@@ -0,0 +1,157 @@
+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 } from '@travetto/schema';
+import { BeforeAll, Suite, Test } from '@travetto/test';
+
+import { MysqlDialect } from '../../../model-mysql/src/dialect.ts';
+import { PostgresDialect } from '../../../model-postgres/src/dialect.ts';
+import { SqliteDialect } from '../../../model-sqlite/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()
+class ParentModel {
+  id: string;
+  title: string;
+  child: ChildItem;
+}
+
+function getTableContext<T extends ModelType>(modelClass: Class<T>): TableContext<T> {
+  return {
+    tableName: modelClass.name.toLowerCase(),
+    ...SQLModelSchemaUtil.getSchemaContext(modelClass)
+  };
+}
+
+@Suite()
+export class SQLDialectGapsTest {
+  @BeforeAll()
+  async setup() {
+    await Registry.init();
+  }
+
+  @Test()
+  async testIndexAndQueryExpressionParity() {
+    const tableContext = getTableContext(ParentModel);
+    const mysqlDialect = new MysqlDialect();
+    const postgresDialect = new PostgresDialect();
+    const sqliteDialect = new SqliteDialect();
+
+    // Verify MySQL path resolution matches index creation
+    const mysqlAgeResolved = mysqlDialect.resolvePath(tableContext, ['child', 'age'], 'read');
+    assert(mysqlAgeResolved.sqlPath === "CAST(`child`->>'$.age' AS DECIMAL)");
+
+    const mysqlNameResolved = mysqlDialect.resolvePath(tableContext, ['child', 'name'], 'read');
+    assert(mysqlNameResolved.sqlPath === "(CAST(`child`->>'$.name' AS CHAR(255)) COLLATE utf8mb4_bin)");
+
+    // Verify Postgres path resolution matches index creation
+    const postgresAgeResolved = postgresDialect.resolvePath(tableContext, ['child', 'age'], 'read');
+    assert(postgresAgeResolved.sqlPath === '((("child"->>\'age\')))::NUMERIC');
+
+    // Verify SQLite path resolution matches index creation
+    const sqliteAgeResolved = sqliteDialect.resolvePath(tableContext, ['child', 'age'], 'read');
+    assert(sqliteAgeResolved.sqlPath === 'CAST(json_extract("child", \'$.age\') AS NUMERIC)');
+  }
+
+  @Test()
+  async testSqliteArraySubObjectPatch() {
+    const tableContext = getTableContext(ParentModel);
+    const sqliteDialect = new SqliteDialect();
+
+    const resolvedContext = sqliteDialect.resolvePath(tableContext, ['child', 'name'], 'read');
+    const { sql } = sqliteDialect.compileArrayEquals(resolvedContext, '$$1', { name: 'bob' });
+
+    assert(sql.includes('json_patch('));
+    assert(sql.includes('= elem.value'));
+  }
+
+  @Test()
+  async testCreateIndexes() {
+    const tableContext = getTableContext(ParentModel);
+    const mysqlDialect = new MysqlDialect();
+    const postgresDialect = new PostgresDialect();
+
+    // Verify create index SQL contains the resolved expressions
+    const mysqlCreateIndexSql = mysqlDialect.getCreateIndexSQL(tableContext, {
+      type: 'query',
+      name: 'child_age',
+      fields: [{ 'child.age': 1 }]
+    });
+    assert(mysqlCreateIndexSql.includes("(CAST(`child`->>'$.age' AS DECIMAL))"));
+
+    const postgresCreateIndexSql = postgresDialect.getCreateIndexSQL(tableContext, {
+      type: 'query',
+      name: 'child_age',
+      fields: [{ 'child.age': 1 }]
+    });
+    assert(postgresCreateIndexSql.includes('((("child"->>\'age\')))::NUMERIC)'));
+  }
+
+  @Test()
+  async testMysqlExistingIndexesParsing() {
+    const mysqlDialect = new MysqlDialect();
+    const existingIndexRecords = [
+      {
+        name: 'idx_parentmodel_child_age',
+        tableName: 'parentmodel',
+        nonUnique: 1,
+        indexColumns: "(CAST(`child`->>'$.age' AS DECIMAL))"
+      }
+    ];
+
+    const parsedIndexes = mysqlDialect.parseExistingIndexes(existingIndexRecords);
+    assert(parsedIndexes.size === 1);
+    assert(parsedIndexes.has('idx_parentmodel_child_age'));
+
+    const indexDefinition = parsedIndexes.get('idx_parentmodel_child_age')!;
+    assert(indexDefinition.includes('CREATE INDEX `idx_parentmodel_child_age` ON `parentmodel`'));
+    assert(indexDefinition.includes("(CAST(`child`->>'$.age' AS DECIMAL))"));
+
+    const normalizedDefinition = mysqlDialect.normalizeIndexDefinition(indexDefinition);
+    assert(normalizedDefinition.length > 0);
+  }
+
+  @Test()
+  async testMysqlAlterColumnType() {
+    const tableContext = getTableContext(ParentModel);
+    const mysqlDialect = new MysqlDialect();
+
+    const alterColumnSql = mysqlDialect.getAlterColumnTypeSQL(tableContext, 'title', 'VARCHAR(255)', 'INT');
+    assert(alterColumnSql === 'ALTER TABLE `parentmodel` MODIFY COLUMN `title` VARCHAR(255);');
+
+    const noopAlterColumnSql = mysqlDialect.getAlterColumnTypeSQL(tableContext, 'title', 'VARCHAR(255)', 'VARCHAR(255)');
+    assert(noopAlterColumnSql === undefined);
+  }
+
+  @Test()
+  async testFormatJsonPathEscaping() {
+    const mysqlDialect = new MysqlDialect();
+
+    const simpleJsonPath = mysqlDialect.formatJsonPath(['child', 'age']);
+    assert(simpleJsonPath === 'child.age');
+
+    const complexJsonPath = mysqlDialect.formatJsonPath(['child', 'first name']);
+    assert(complexJsonPath === 'child."first name"');
+  }
+
+  @Test()
+  async testPartialUpdateSetsWithoutRegex() {
+    const tableContext = getTableContext(ParentModel);
+    const sqliteDialect = new SqliteDialect();
+
+    const { sets, values } = sqliteDialect.compilePartialUpdate(tableContext, { title: 'Updated Title' });
+    assert.deepStrictEqual(sets, ['"title" = ?']);
+    assert.deepStrictEqual(values, ['Updated Title']);
+  }
+}