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

package/__index__.ts

@@ -1,4 +1,5 @@
 export * from './src/connection.ts';
 export * from './src/dialect.ts';
+export * from './src/schema.ts';
 export * from './src/service.ts';
 export * from './src/types.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-sql",
-  "version": "8.0.0-alpha.30",
+  "version": "8.0.0-alpha.32",
   "type": "module",
   "description": "SQL backing for the travetto model module, with real-time modeling support for SQL schemas.",
   "keywords": [
@@ -28,15 +28,15 @@
     "directory": "module/model-sql"
   },
   "dependencies": {
-    "@travetto/config": "^8.0.0-alpha.24",
+    "@travetto/config": "^8.0.0-alpha.25",
     "@travetto/context": "^8.0.0-alpha.22",
-    "@travetto/model": "^8.0.0-alpha.25",
-    "@travetto/model-indexed": "^8.0.0-alpha.27",
-    "@travetto/model-query": "^8.0.0-alpha.27"
+    "@travetto/model": "^8.0.0-alpha.26",
+    "@travetto/model-indexed": "^8.0.0-alpha.28",
+    "@travetto/model-query": "^8.0.0-alpha.29"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.30",
-    "@travetto/test": "^8.0.0-alpha.23"
+    "@travetto/cli": "^8.0.0-alpha.31",
+    "@travetto/test": "^8.0.0-alpha.24"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/dialect.ts

@@ -1,10 +1,11 @@
 import type { IndexConfig, ModelType } from '@travetto/model';
 import { ModelRegistryIndex } from '@travetto/model';
 import { isModelIndexedIndex } from '@travetto/model-indexed';
-import { isModelQueryIndex, ModelQueryUtil, type SortClause, type WhereClause } from '@travetto/model-query';
+import { isModelQueryIndex, ModelQueryUtil, type QueryIndexConfig, type SortClause, type WhereClause } from '@travetto/model-query';
 import { type Class, castTo, JSONUtil, RuntimeError } from '@travetto/runtime';
 import { DataUtil, type SchemaFieldConfig, SchemaRegistryIndex } from '@travetto/schema';
 
+import { SQLModelSchemaUtil } from './schema.ts';
 import type { JSONSqlPathMode, ResolvedPathContext, SchemaContext, TableContext } from './types.ts';
 
 export interface TransactionStatements {
@@ -24,6 +25,26 @@ interface QueryClause {
 
 type IdentificationPath = string;
 
+function extractQueryIndexPathAndDirection(indexField: Record<string, unknown>): { path: string[]; sortDirection: 1 | -1 | true } {
+  const path: string[] = [];
+  let current: unknown = indexField;
+  while (typeof current === 'object' && current !== null) {
+    const keys = Object.keys(current);
+    if (keys.length === 0) {
+      break;
+    }
+    const key = keys[0];
+    if (key.includes('.')) {
+      path.push(...key.split('.'));
+    } else {
+      path.push(key);
+    }
+    current = castTo<Record<string, unknown>>(current)[key];
+  }
+  const sortDirection = castTo<1 | -1 | true>(current ?? 1);
+  return { path, sortDirection };
+}
+
 /**
  * Abstract ANSI SQL-99 Dialect base implementation.
  * Pure SQL text generator and query builder (does not execute queries or hold connection state).
@@ -107,17 +128,15 @@ export abstract class AbstractANSI99Dialect {
     return this.resolvePath(context, path, mode).sqlPath;
   }
 
-  getCreateIndexSQL(context: TableContext, indexConfig: IndexConfig): string {
+  getCreateIndexSQL<T extends ModelType>(context: TableContext, indexConfig: IndexConfig<string, T> | QueryIndexConfig<T>): string {
     const { tableName, cls: modelClass } = context;
     const indexName = ['idx', tableName, indexConfig.name.toLowerCase().replaceAll('-', '_')].join('_');
 
     if (isModelQueryIndex(indexConfig)) {
       const indexFields = indexConfig.fields.map(field => {
-        const fieldKey = Object.keys(field)[0];
-        const sortDirection = castTo<Record<string, unknown>>(field)[fieldKey];
+        const { path, sortDirection } = extractQueryIndexPathAndDirection(castTo(field));
         const isAscending = typeof sortDirection === 'number' ? sortDirection === 1 : !sortDirection;
 
-        const path = fieldKey.split('.');
         const expression = this.compileIndexPath(context, path, 'createIndex');
         const formattedExpression = path.length > 1 ? `(${expression})` : expression;
         return `${formattedExpression} ${isAscending ? 'ASC' : 'DESC'}`;
@@ -148,11 +167,14 @@ export abstract class AbstractANSI99Dialect {
         continue;
       }
       const columnType = this.getColumnType(field);
-      columnDefinitions.push(`${this.escapeIdentifier(field.name)} ${columnType}`);
+      const isNotNullClause = SQLModelSchemaUtil.isColumnNotNull(context, field.name) ? ' NOT NULL' : '';
+      columnDefinitions.push(`${this.escapeIdentifier(field.name)} ${columnType}${isNotNullClause}`);
     }
 
     for (const field of context.complexFields.values()) {
-      columnDefinitions.push(`${this.escapeIdentifier(field.name)} ${this.getComplexColumnType(field)}`);
+      const columnType = this.getComplexColumnType(field);
+      const isNotNullClause = SQLModelSchemaUtil.isColumnNotNull(context, field.name) ? ' NOT NULL' : '';
+      columnDefinitions.push(`${this.escapeIdentifier(field.name)} ${columnType}${isNotNullClause}`);
     }
 
     return `

package/src/schema.ts

@@ -19,7 +19,7 @@ export class SQLModelSchemaUtil {
       throw new RuntimeError('Cannot store unregistered models', { category: 'data' });
     }
 
-    const fields = Object.values(registryConfig.fields).map(field => ({ ...field }));
+    const fields = Object.values(registryConfig.fields);
 
     const hasModel = ModelRegistryIndex.has(modelClass);
     if (hasModel && registryConfig.discriminatedBase) {
@@ -29,7 +29,7 @@ export class SQLModelSchemaUtil {
         for (const field of TypedObject.values(subclassConfig.fields)) {
           if (!fieldMap.has(field.name)) {
             fieldMap.add(field.name);
-            fields.push({ ...field, required: { active: false } });
+            fields.push(field);
           }
         }
       }
@@ -43,4 +43,19 @@ export class SQLModelSchemaUtil {
     this.SCHEMA_CACHE.set(modelClass, context);
     return context;
   }
+
+  static isColumnNotNull<T>(context: SchemaContext<T>, fieldName: string): boolean {
+    const schemaConfig = SchemaRegistryIndex.getOptional(context.cls)?.get();
+    const fieldConfig = schemaConfig?.fields[fieldName];
+    if (!fieldConfig || fieldConfig.required?.active === false || fieldConfig.accessor) {
+      return false;
+    }
+    if (ModelRegistryIndex.has(context.cls)) {
+      const modelConfig = ModelRegistryIndex.getConfig(context.cls);
+      if (modelConfig.transientFields?.includes(fieldName)) {
+        return false;
+      }
+    }
+    return true;
+  }
 }

package/support/test/dialect.ts

@@ -1,14 +1,12 @@
 import assert from 'node:assert';
 
-import { Model, type ModelType } from '@travetto/model';
+import { Model, type ModelType, TransientField } from '@travetto/model';
 import { Registry } from '@travetto/registry';
 import type { Class } from '@travetto/runtime';
-import { Schema } from '@travetto/schema';
+import { DiscriminatorField, Required, 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 type { AbstractANSI99Dialect } from '../../src/dialect.ts';
 import { SQLModelSchemaUtil } from '../../src/schema.ts';
 import type { TableContext } from '../../src/types.ts';
 
@@ -20,13 +18,41 @@ class ChildItem {
   createdDate: Date;
 }
 
-@Model()
+@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(),
@@ -34,124 +60,66 @@ function getTableContext<T extends ModelType>(modelClass: Class<T>): TableContex
   };
 }
 
-@Suite()
-export class SQLDialectGapsTest {
+@Suite({ skip: true })
+export abstract class BaseSQLDialectSuite {
+  abstract dialect: AbstractANSI99Dialect;
+
   @BeforeAll()
   async setup() {
     await Registry.init();
+    SQLModelSchemaUtil.SCHEMA_CACHE.clear();
   }
 
-  @Test()
-  async testIndexAndQueryExpressionParity() {
-    const tableContext = getTableContext(ParentModel);
-    const mysqlDialect = new MysqlDialect();
-    const postgresDialect = new PostgresDialect();
-    const sqliteDialect = new SqliteDialect();
+  @Test('Verify DDL column nullability')
+  async testDDLNullability() {
+    const dialect = this.dialect;
+    const quote = dialect.escapeIdentifier('').substring(0, 1) || '"';
 
-    // Verify MySQL path resolution matches index creation
-    const mysqlAgeResolved = mysqlDialect.resolvePath(tableContext, ['child', 'age'], 'read');
-    assert(mysqlAgeResolved.sqlPath === "CAST(`child`->>'$.age' AS DECIMAL)");
+    const simpleContext = getTableContext(SimpleModel);
+    const simpleSQL = dialect.getCreateTableSQL(simpleContext);
 
-    const mysqlNameResolved = mysqlDialect.resolvePath(tableContext, ['child', 'name'], 'read');
-    assert(mysqlNameResolved.sqlPath === "(CAST(`child`->>'$.name' AS CHAR(255)) COLLATE utf8mb4_bin)");
+    const requiredLine = simpleSQL.split('\n').find(line => line.includes(`${quote}requiredField${quote}`));
+    assert(requiredLine?.includes('NOT NULL'));
 
-    // Verify Postgres path resolution matches index creation
-    const postgresAgeResolved = postgresDialect.resolvePath(tableContext, ['child', 'age'], 'read');
-    assert(postgresAgeResolved.sqlPath === '((("child"->>\'age\')))::NUMERIC');
+    const optionalLine = simpleSQL.split('\n').find(line => line.includes(`${quote}optionalField${quote}`));
+    if (optionalLine) {
+      assert(!optionalLine.includes('NOT NULL'));
+    }
 
-    // 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)');
-  }
+    const transientLine = simpleSQL.split('\n').find(line => line.includes(`${quote}transientField${quote}`));
+    if (transientLine) {
+      assert(!transientLine.includes('NOT NULL'));
+    }
 
-  @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'));
-  }
+    const polyContext = getTableContext(BasePolymorphic);
+    const polySQL = dialect.getCreateTableSQL(polyContext);
 
-  @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)'));
-  }
+    const sharedRequiredLine = polySQL.split('\n').find(line => line.includes(`${quote}sharedRequired${quote}`));
+    assert(sharedRequiredLine?.includes('NOT NULL'));
 
-  @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);
+    const subTypeLine = polySQL.split('\n').find(line => line.includes(`${quote}subTypeAOnlyRequired${quote}`));
+    if (subTypeLine) {
+      assert(!subTypeLine.includes('NOT NULL'));
+    }
   }
 
   @Test()
   async testFormatJsonPathEscaping() {
-    const mysqlDialect = new MysqlDialect();
-
-    const simpleJsonPath = mysqlDialect.formatJsonPath(['child', 'age']);
+    const simpleJsonPath = this.dialect.formatJsonPath(['child', 'age']);
     assert(simpleJsonPath === 'child.age');
 
-    const complexJsonPath = mysqlDialect.formatJsonPath(['child', 'first name']);
+    const complexJsonPath = this.dialect.formatJsonPath(['child', 'first name']);
     assert(complexJsonPath === 'child."first name"');
   }
 
   @Test()
   async testPartialUpdateSetsWithoutRegex() {
     const tableContext = getTableContext(ParentModel);
-    const sqliteDialect = new SqliteDialect();
+    const quote = this.dialect.escapeIdentifier('').substring(0, 1) || '"';
+    const placeholder = this.dialect.getPlaceholder(1);
 
-    const { sets, values } = sqliteDialect.compilePartialUpdate(tableContext, { title: 'Updated Title' });
-    assert.deepStrictEqual(sets, ['"title" = ?']);
+    const { sets, values } = this.dialect.compilePartialUpdate(tableContext, { title: 'Updated Title' });
+    assert.deepStrictEqual(sets, [`${quote}title${quote} = ${placeholder}`]);
     assert.deepStrictEqual(values, ['Updated Title']);
   }
 }