@travetto/model-sql 8.0.0-alpha.26 → 8.0.0-alpha.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-sql",
-  "version": "8.0.0-alpha.26",
+  "version": "8.0.0-alpha.27",
   "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.22",
-    "@travetto/context": "^8.0.0-alpha.20",
-    "@travetto/model": "^8.0.0-alpha.23",
-    "@travetto/model-indexed": "^8.0.0-alpha.25",
-    "@travetto/model-query": "^8.0.0-alpha.24"
+    "@travetto/config": "^8.0.0-alpha.23",
+    "@travetto/context": "^8.0.0-alpha.21",
+    "@travetto/model": "^8.0.0-alpha.24",
+    "@travetto/model-indexed": "^8.0.0-alpha.26",
+    "@travetto/model-query": "^8.0.0-alpha.25"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.28",
-    "@travetto/test": "^8.0.0-alpha.21"
+    "@travetto/cli": "^8.0.0-alpha.29",
+    "@travetto/test": "^8.0.0-alpha.22"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/dialect.ts

@@ -5,7 +5,7 @@ import { isModelQueryIndex, ModelQueryUtil, type SortClause, type WhereClause }
 import { type Class, castTo, JSONUtil, RuntimeError } from '@travetto/runtime';
 import { DataUtil, type SchemaFieldConfig, SchemaRegistryIndex } from '@travetto/schema';
 
-import type { JSONSqlPathMode, SchemaContext, TableContext } from './types.ts';
+import type { JSONSqlPathMode, ResolvedPathContext, SchemaContext, TableContext } from './types.ts';
 
 export interface TransactionStatements {
   begin: string;
@@ -64,28 +64,10 @@ export abstract class AbstractANSI99Dialect {
 
   abstract getColumnType(fieldConfiguration: SchemaFieldConfig): string;
   abstract compileJsonIndexPath(columnName: string, jsonPath: string[], mode: JSONSqlPathMode): string;
-  abstract compileArrayAll(
-    sqlPath: string,
-    identifier: string,
-    value: unknown[],
-    field: SchemaFieldConfig,
-    topLevel?: boolean
-  ): { sql: string; formatted: unknown };
-  abstract compileArrayEquals(
-    sqlPath: string,
-    identifier: string,
-    values: unknown,
-    field: SchemaFieldConfig,
-    topLevel?: boolean
-  ): { sql: string; formatted: unknown };
-  abstract compileArrayAny(
-    sqlPath: string,
-    identifier: string,
-    values: unknown[],
-    field: SchemaFieldConfig,
-    topLevel?: boolean
-  ): { sql: string; formatted: unknown };
-  abstract compileArrayExists(sqlPath: string, identifier: string, field: SchemaFieldConfig, topLevel?: boolean): { sql: string };
+  abstract compileArrayAll(context: ResolvedPathContext, identifier: string, value: unknown[]): { sql: string; formatted: unknown };
+  abstract compileArrayEquals(context: ResolvedPathContext, identifier: string, values: unknown): { sql: string; formatted: unknown };
+  abstract compileArrayAny(context: ResolvedPathContext, identifier: string, values: unknown[]): { sql: string; formatted: unknown };
+  abstract compileArrayExists(context: ResolvedPathContext, identifier?: string): { sql: string };
 
   abstract getRegexOperator(caseInsensitive: boolean): string;
   abstract formatRegex(source: string, caseInsensitive: boolean): string;
@@ -94,12 +76,17 @@ export abstract class AbstractANSI99Dialect {
   compileJsonEquality?(sqlPath: string, identifier: string): string;
   shiftPlaceholders?(whereSQL: string, offset: number): string;
 
-  compileIndexPath(context: TableContext, path: string[], mode: JSONSqlPathMode): string {
+  buildSqlPath<T extends ModelType>(tableContext: TableContext<T>, path: string[], mode: JSONSqlPathMode): string {
     const firstSegment = path[0];
     const escapedFirst = this.escapeIdentifier(firstSegment);
-    if (context.simpleFields.has(firstSegment)) {
+    if (tableContext.simpleFields.has(firstSegment)) {
       if (path.length > 1) {
-        throw new RuntimeError(`Cannot create nested index under column "${firstSegment}" in table "${context.tableName}"`);
+        throw new RuntimeError(
+          `Cannot traverse nested properties under simple column "${firstSegment}" in table "${tableContext.tableName}"`,
+          {
+            category: 'data'
+          }
+        );
       }
       return escapedFirst;
     } else {
@@ -111,6 +98,10 @@ export abstract class AbstractANSI99Dialect {
     }
   }
 
+  compileIndexPath(context: TableContext, path: string[], mode: JSONSqlPathMode): string {
+    return this.buildSqlPath(context, path, mode);
+  }
+
   getCreateIndexSQL(context: TableContext, indexConfig: IndexConfig): string {
     const { tableName, cls: modelClass } = context;
     const indexName = ['idx', tableName, indexConfig.name.toLowerCase().replaceAll('-', '_')].join('_');
@@ -272,11 +263,14 @@ CREATE TABLE ${this.escapeIdentifier(context.tableName)} (
     return sortClauses.length ? `ORDER BY ${sortClauses.join(', ')}` : '';
   }
 
-  resolvePath<T extends ModelType>(
+  #resolveSchemaPath<T extends ModelType>(
     tableContext: TableContext<T>,
-    path: string[],
-    mode: JSONSqlPathMode
-  ): { sqlPath: string; leafField?: SchemaFieldConfig } {
+    path: string[]
+  ): {
+    leafField?: SchemaFieldConfig;
+    arrayField?: SchemaFieldConfig;
+    arraySegmentIndex?: number;
+  } {
     const firstSegment = path[0];
 
     if (tableContext.simpleFields.has(firstSegment)) {
@@ -288,34 +282,55 @@ CREATE TABLE ${this.escapeIdentifier(context.tableName)} (
           }
         );
       }
-      const leafField = tableContext.simpleFields.get(firstSegment);
-      return { sqlPath: this.escapeIdentifier(firstSegment), leafField };
+      return { leafField: tableContext.simpleFields.get(firstSegment) };
     }
 
     let currentField: SchemaFieldConfig | undefined = tableContext.complexFields.get(firstSegment);
+    let arrayField: SchemaFieldConfig | undefined = currentField?.array ? currentField : undefined;
+    let arraySegmentIndex: number | undefined = currentField?.array ? 0 : undefined;
     let currentClass = currentField?.type;
-    const jsonPath = path.slice(1);
 
-    for (let index = 0; index < jsonPath.length - 1; index++) {
-      const segment = jsonPath[index];
+    for (let pathIndex = 1; pathIndex < path.length; pathIndex += 1) {
+      const segment = path[pathIndex];
       const subclassConfiguration = SchemaRegistryIndex.getOptional(currentClass!)?.get();
       currentField = subclassConfiguration?.fields[segment];
+      if (currentField?.array && !arrayField) {
+        arrayField = currentField;
+        arraySegmentIndex = pathIndex;
+      }
       currentClass = currentField?.type;
     }
 
-    if (jsonPath.length > 0) {
-      const leafSegment = jsonPath[jsonPath.length - 1];
-      const subclassConfiguration = SchemaRegistryIndex.getOptional(currentClass!)?.get();
-      currentField = subclassConfiguration?.fields[leafSegment];
-    }
+    return {
+      leafField: currentField,
+      arrayField,
+      arraySegmentIndex
+    };
+  }
 
-    let compiledPath = this.compileIndexPath(tableContext, path, mode);
+  resolvePath<T extends ModelType>(tableContext: TableContext<T>, path: string[], mode: JSONSqlPathMode): ResolvedPathContext {
+    const firstSegment = path[0];
 
-    if (currentField && !currentField.array) {
-      compiledPath = this.castColumn(compiledPath, currentField.type);
+    if (tableContext.simpleFields.has(firstSegment)) {
+      const { leafField } = this.#resolveSchemaPath(tableContext, path);
+      return { sqlPath: this.buildSqlPath(tableContext, path, mode), leafField };
     }
 
-    return { sqlPath: compiledPath, leafField: currentField };
+    const { leafField, arrayField, arraySegmentIndex } = this.#resolveSchemaPath(tableContext, path);
+    const sqlPath = this.buildSqlPath(tableContext, path, mode);
+
+    const finalSqlPath = leafField && !leafField.array ? this.castColumn(sqlPath, leafField.type) : sqlPath;
+
+    const arrayPath = arraySegmentIndex !== undefined ? path.slice(0, arraySegmentIndex + 1) : undefined;
+    const subPath = arraySegmentIndex !== undefined ? path.slice(arraySegmentIndex + 1) : undefined;
+
+    return {
+      sqlPath: finalSqlPath,
+      leafField,
+      arrayField,
+      arrayPath,
+      subPath
+    };
   }
 
   #compileClause<T extends ModelType>(
@@ -349,28 +364,6 @@ CREATE TABLE ${this.escapeIdentifier(context.tableName)} (
     }
   }
 
-  #buildJsonTemplate(queryObject: Record<string, unknown>): Record<string, unknown> {
-    const template: Record<string, unknown> = {};
-    for (const [key, value] of Object.entries(queryObject)) {
-      if (DataUtil.isPlainObject(value)) {
-        const firstKey = Object.keys(value)[0];
-        const valueObject = castTo<Record<string, unknown>>(value);
-        if (firstKey === '$eq') {
-          template[key] = valueObject.$eq;
-        } else if (valueObject.$eq !== undefined) {
-          template[key] = valueObject.$eq;
-        } else if (!firstKey.startsWith('$')) {
-          template[key] = this.#buildJsonTemplate(valueObject);
-        } else {
-          throw new RuntimeError(`Unsupported operator ${firstKey} in nested array query`, { category: 'data' });
-        }
-      } else {
-        template[key] = value;
-      }
-    }
-    return template;
-  }
-
   #compileSimple<T extends ModelType>(
     tableContext: TableContext<T>,
     item: Record<string, unknown>,
@@ -389,14 +382,11 @@ CREATE TABLE ${this.escapeIdentifier(context.tableName)} (
       const isPlainObject = DataUtil.isPlainObject(value);
       const firstKey = isPlainObject ? Object.keys(value)[0] : '';
 
-      const { leafField } = this.resolvePath(tableContext, currentPath, 'read');
       const nextIdentificationPath = `${identificationPath}__${index}`;
 
       if (isPlainObject) {
         if (firstKey.startsWith('$')) {
           clauses.push(this.#compileOperator(tableContext, currentPath, value as Record<string, unknown>, nextIdentificationPath));
-        } else if (leafField?.array) {
-          clauses.push(this.#compileOperator(tableContext, currentPath, { $eq: value }, nextIdentificationPath));
         } else {
           clauses.push(this.#compileSimple(tableContext, value as Record<string, unknown>, currentPath, nextIdentificationPath));
         }
@@ -414,7 +404,9 @@ CREATE TABLE ${this.escapeIdentifier(context.tableName)} (
     operation: Record<string, unknown>,
     identificationPath: IdentificationPath = ''
   ): QueryClause {
-    const { sqlPath, leafField } = this.resolvePath(tableContext, path, 'read');
+    const resolvedContext = this.resolvePath(tableContext, path, 'read');
+    const { sqlPath, leafField, arrayField } = resolvedContext;
+    const effectiveArrayField = leafField?.array ? leafField : arrayField;
     const clauses: QueryClause[] = [];
 
     let index = 0;
@@ -432,16 +424,16 @@ CREATE TABLE ${this.escapeIdentifier(context.tableName)} (
 
       let clause: QueryClause;
 
-      if (leafField?.array) {
+      if (effectiveArrayField) {
         if (operator === '$eq' || operator === '$ne') {
-          const { sql, formatted } = this.compileArrayEquals(sqlPath, identifier, value, leafField, path.length === 1);
+          const { sql, formatted } = this.compileArrayEquals(resolvedContext, identifier, value);
           const finalSql = operator === '$ne' ? `NOT(${sql})` : sql;
           clause = { parameters: { [identifier]: formatted }, sql: finalSql };
         } else if (operator === '$in' || operator === '$nin') {
           if (!Array.isArray(value) || value.length === 0) {
             clause = operator === '$in' ? { sql: '1=0' } : {};
           } else {
-            const { sql, formatted } = this.compileArrayAny(sqlPath, identifier, value, leafField, path.length === 1);
+            const { sql, formatted } = this.compileArrayAny(resolvedContext, identifier, value);
             const finalSql = operator === '$nin' ? `NOT(${sql})` : sql;
             clause = { sql: finalSql, parameters: { [identifier]: formatted } };
           }
@@ -449,11 +441,11 @@ CREATE TABLE ${this.escapeIdentifier(context.tableName)} (
           if (!Array.isArray(value) || value.length === 0) {
             clause = { sql: '1=0' };
           } else {
-            const { sql, formatted } = this.compileArrayAll(sqlPath, identifier, value, leafField, path.length === 1);
+            const { sql, formatted } = this.compileArrayAll(resolvedContext, identifier, value);
             clause = { sql, parameters: { [identifier]: formatted } };
           }
         } else if (operator === '$exists') {
-          const { sql } = this.compileArrayExists(sqlPath, identifier, leafField, path.length === 1);
+          const { sql } = this.compileArrayExists(resolvedContext, identifier);
           const finalSql = !value ? `NOT(${sql})` : sql;
           clause = { sql: finalSql };
         } else {

package/src/service.ts

@@ -15,7 +15,8 @@ import {
   type ModelStorageSupport,
   type ModelType,
   NotFoundError,
-  type OptionalId
+  type OptionalId,
+  UniqueError
 } from '@travetto/model';
 import {
   type FullKeyedIndexBody,
@@ -207,7 +208,14 @@ export abstract class BaseSQLModelService<C = unknown>
 
     const { sql, values } = this.dialect.buildInsert(tableContext, rawItem);
 
-    await this.connection.execute(sql, values);
+    try {
+      await this.connection.execute(sql, values);
+    } catch (error) {
+      if (error instanceof UniqueError && (error.details?.type === 'query' || error.details?.type === 'index')) {
+        throw new UniqueError(modelClass, (error.details.constraint as string) ?? 'unknown', error.details);
+      }
+      throw error;
+    }
     return preppedItem;
   }
 
@@ -487,7 +495,7 @@ export abstract class BaseSQLModelService<C = unknown>
         try {
           const result = await this.connection.execute(command.sql, command.values);
           if (command.type === 'update' && result.count === 0) {
-            counts.error++;
+            counts.error += 1;
             errors.push(new NotFoundError(modelClass, command.identifier!));
           } else if (command.type === 'delete' && result.count < command.count) {
             counts.delete += result.count;

package/src/types.ts

@@ -15,3 +15,11 @@ export interface TableContext<T extends ModelType = ModelType> extends SchemaCon
   tableName: string;
   database?: string;
 }
+
+export interface ResolvedPathContext {
+  sqlPath: string;
+  leafField?: SchemaFieldConfig;
+  arrayField?: SchemaFieldConfig;
+  arrayPath?: string[];
+  subPath?: string[];
+}

package/support/test/query.ts

@@ -8,7 +8,7 @@ import { BeforeAll, Suite, Test } from '@travetto/test';
 
 import { AbstractANSI99Dialect } from '../../src/dialect.ts';
 import { SQLModelSchemaUtil } from '../../src/schema.ts';
-import type { TableContext } from '../../src/types.ts';
+import type { ResolvedPathContext, TableContext } from '../../src/types.ts';
 
 @Model()
 class User {
@@ -50,20 +50,20 @@ class MockDialect extends AbstractANSI99Dialect {
     return `$$${index}`;
   }
 
-  compileArrayAll(sqlPath: string, identifier: string, value: unknown[]) {
-    return { sql: `${sqlPath} ALL ${identifier}`, formatted: value };
+  compileArrayAll(context: ResolvedPathContext, identifier: string, value: unknown[]) {
+    return { sql: `${context.sqlPath} ALL ${identifier}`, formatted: value };
   }
 
-  compileArrayEquals(sqlPath: string, identifier: string, values: unknown) {
-    return { sql: `${sqlPath} EQUALS ${identifier}`, formatted: values };
+  compileArrayEquals(context: ResolvedPathContext, identifier: string, values: unknown) {
+    return { sql: `${context.sqlPath} EQUALS ${identifier}`, formatted: values };
   }
 
-  compileArrayAny(sqlPath: string, identifier: string, values: unknown[]) {
-    return { sql: `${sqlPath} ANY ${identifier}`, formatted: values };
+  compileArrayAny(context: ResolvedPathContext, identifier: string, values: unknown[]) {
+    return { sql: `${context.sqlPath} ANY ${identifier}`, formatted: values };
   }
 
-  compileArrayExists(sqlPath: string, identifier: string) {
-    return { sql: `${sqlPath} IS NOT NULL`, formatted: undefined };
+  compileArrayExists(context: ResolvedPathContext, identifier?: string) {
+    return { sql: `${context.sqlPath} IS NOT NULL`, formatted: undefined };
   }
 
   getRegexOperator(caseInsensitive: boolean) {