@travetto/model-sqlite 8.0.0-alpha.26 → 8.0.0-alpha.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-sqlite",
-  "version": "8.0.0-alpha.26",
+  "version": "8.0.0-alpha.28",
   "type": "module",
   "description": "SQLite backing for the travetto model module, with real-time modeling support for SQL schemas.",
   "keywords": [
@@ -27,11 +27,11 @@
     "directory": "module/model-sqlite"
   },
   "dependencies": {
-    "@travetto/config": "^8.0.0-alpha.22",
-    "@travetto/context": "^8.0.0-alpha.20",
-    "@travetto/model": "^8.0.0-alpha.23",
-    "@travetto/model-query": "^8.0.0-alpha.24",
-    "@travetto/model-sql": "^8.0.0-alpha.26"
+    "@travetto/config": "^8.0.0-alpha.23",
+    "@travetto/context": "^8.0.0-alpha.21",
+    "@travetto/model": "^8.0.0-alpha.24",
+    "@travetto/model-query": "^8.0.0-alpha.26",
+    "@travetto/model-sql": "^8.0.0-alpha.28"
   },
   "travetto": {
     "displayName": "SQLite Model Service"

package/src/connection.ts

@@ -6,7 +6,7 @@ import { createPool, type Pool } from 'generic-pool';
 
 import type { AsyncContext } from '@travetto/context';
 import { Injectable } from '@travetto/di';
-import { ExistsError } from '@travetto/model';
+import { ExistsError, UniqueError } from '@travetto/model';
 import { SQLConnection } from '@travetto/model-sql';
 import { castTo, JSONUtil, Runtime, RuntimeError, ShutdownManager, Util } from '@travetto/runtime';
 
@@ -176,13 +176,19 @@ export class SqliteConnection extends SQLConnection<DatabaseSync> {
         switch (code) {
           case 'ERR_SQLITE_ERROR': {
             if (message?.startsWith('UNIQUE')) {
-              throw new ExistsError('query', query);
+              const match = message.match(/UNIQUE constraint failed: (.*)/);
+              const key = match ? match[1] : 'query';
+              throw new UniqueError('query', key, { message, query });
             }
             break;
           }
-          case 'SQLITE_CONSTRAINT_PRIMARYKEY':
           case 'SQLITE_CONSTRAINT_UNIQUE':
-          case 'SQLITE_CONSTRAINT_INDEX':
+          case 'SQLITE_CONSTRAINT_INDEX': {
+            const match = message?.match(/UNIQUE constraint failed: (.*)/);
+            const key = match ? match[1] : 'query';
+            throw new UniqueError('query', key, { message, query });
+          }
+          case 'SQLITE_CONSTRAINT_PRIMARYKEY':
             throw new ExistsError('query', query);
         }
         if (/index.*?already exists/.test(message ?? '')) {

package/src/dialect.ts

@@ -1,6 +1,6 @@
-import { AbstractANSI99Dialect, type TableContext, type TransactionStatements } from '@travetto/model-sql';
+import { AbstractANSI99Dialect, type ResolvedPathContext, type TableContext, type TransactionStatements } from '@travetto/model-sql';
 import { type Class, castTo, JSONUtil } from '@travetto/runtime';
-import type { SchemaFieldConfig } from '@travetto/schema';
+import { type SchemaFieldConfig, SchemaRegistryIndex } from '@travetto/schema';
 
 export class SqliteDialect extends AbstractANSI99Dialect {
   returningSupport = true;
@@ -41,41 +41,126 @@ export class SqliteDialect extends AbstractANSI99Dialect {
     return `json_extract(${columnName}, '$.${jsonPath.join('.')}')`;
   }
 
-  compileArrayAll(sqlPath: string, identifier: string, value: unknown[]): { sql: string; formatted: unknown } {
+  #getSqliteArrayExpression(context: ResolvedPathContext): string {
+    if (!context.arrayPath || context.arrayPath.length === 0) {
+      return context.sqlPath;
+    }
+
+    const columnName = this.escapeIdentifier(context.arrayPath[0]);
+    return context.arrayPath.length > 1 ? `json_extract(${columnName}, '$.${context.arrayPath.slice(1).join('.')}')` : columnName;
+  }
+
+  #buildSubPathCondition(context: ResolvedPathContext, parentExpression: string, onLeaf: (leafExpression: string) => string): string {
+    if (!context.subPath || context.subPath.length === 0) {
+      return onLeaf(parentExpression);
+    }
+
+    const arraySegmentIndices: number[] = [];
+    let currentClass: Class | undefined = context.arrayField?.type;
+
+    for (let index = 0; index < context.subPath.length; index++) {
+      const segment = context.subPath[index];
+      if (currentClass) {
+        const classConfiguration = SchemaRegistryIndex.getOptional(currentClass)?.get();
+        const fieldConfiguration = classConfiguration?.fields[segment];
+        if (fieldConfiguration) {
+          if (fieldConfiguration.array) {
+            arraySegmentIndices.push(index);
+          }
+          currentClass = fieldConfiguration.type;
+        }
+      }
+    }
+
+    if (arraySegmentIndices.length === 0) {
+      const leafExpression = `json_extract(${parentExpression}, '$.${context.subPath.join('.')}')`;
+      return onLeaf(leafExpression);
+    }
+
+    const buildLevel = (levelIndex: number, currentParent: string): string => {
+      const startPathIndex = levelIndex === 0 ? 0 : arraySegmentIndices[levelIndex - 1] + 1;
+      const endPathIndex = arraySegmentIndices[levelIndex];
+      const arrayPath = context.subPath!.slice(startPathIndex, endPathIndex + 1).join('.');
+      const alias = `ing_${levelIndex}`;
+
+      const innerCondition =
+        levelIndex === arraySegmentIndices.length - 1
+          ? (() => {
+              const leafPath = context.subPath!.slice(endPathIndex + 1).join('.');
+              const leafExpression = leafPath ? `json_extract(${alias}.value, '$.${leafPath}')` : `${alias}.value`;
+              return onLeaf(leafExpression);
+            })()
+          : buildLevel(levelIndex + 1, `${alias}.value`);
+
+      return `
+EXISTS (
+  SELECT 1 
+  FROM json_each(${currentParent}, '$.${arrayPath}') AS ${alias} 
+  WHERE ${innerCondition}
+)`;
+    };
+
+    return buildLevel(0, parentExpression);
+  }
+
+  #buildArrayElementExists(context: ResolvedPathContext, onLeaf: (leafExpression: string) => string): string {
+    const jsonArrayExpression = this.#getSqliteArrayExpression(context);
+    const subPathCondition = this.#buildSubPathCondition(context, 'elem.value', onLeaf);
+    return `EXISTS (
+  SELECT 1 
+  FROM json_each(${jsonArrayExpression}) AS elem 
+  WHERE ${subPathCondition}
+)`;
+  }
+
+  compileArrayAll(context: ResolvedPathContext, identifier: string, value: unknown[]): { sql: string; formatted: unknown } {
+    const elementExists = this.#buildArrayElementExists(context, leafExpression => `${leafExpression} = req.value`);
     return {
-      sql: `NOT EXISTS (SELECT 1 FROM json_each(${identifier}) AS req WHERE req.value NOT IN (SELECT value FROM json_each(${sqlPath})))`,
+      sql: `NOT EXISTS (
+  SELECT 1 
+  FROM json_each(${identifier}) AS req 
+  WHERE NOT ${elementExists}
+)`,
       formatted: JSONUtil.toUTF8(value)
     };
   }
 
-  compileArrayEquals(sqlPath: string, identifier: string, values: unknown): { sql: string; formatted: unknown } {
+  compileArrayEquals(context: ResolvedPathContext, identifier: string, values: unknown): { sql: string; formatted: unknown } {
     if (Array.isArray(values)) {
       return {
-        sql: `NOT EXISTS (SELECT 1 FROM json_each(${identifier}) AS req WHERE req.value NOT IN (SELECT value FROM json_each(${sqlPath})))`,
+        sql: this.#buildArrayElementExists(context, leafExpression => `${leafExpression} IN (SELECT value FROM json_each(${identifier}))`),
         formatted: JSONUtil.toUTF8(values)
       };
     }
+
     if (typeof values === 'object' && values !== null) {
       return {
-        sql: `EXISTS (SELECT 1 FROM json_each(${sqlPath}) AS elem WHERE NOT EXISTS (SELECT 1 FROM json_each(${identifier}) AS req WHERE json_extract(elem.value, '$.' || req.key) IS NOT req.value))`,
+        sql: this.#buildArrayElementExists(
+          context,
+          leafExpression => `
+NOT EXISTS (
+  SELECT 1 
+  FROM json_each(${identifier}) AS req 
+  WHERE json_extract(${leafExpression}, '$.' || req.key) IS NOT req.value
+)`
+        ),
         formatted: JSONUtil.toUTF8(values)
       };
     }
+
     return {
-      sql: `EXISTS (SELECT 1 FROM json_each(${sqlPath}) WHERE json_each.value = ${identifier})`,
+      sql: this.#buildArrayElementExists(context, leafExpression => `${leafExpression} = ${identifier}`),
       formatted: values
     };
   }
 
-  compileArrayAny(sqlPath: string, identifier: string, values: unknown[]): { sql: string; formatted: unknown } {
-    return {
-      sql: `EXISTS (SELECT 1 FROM json_each(${sqlPath}) AS elem WHERE elem.value IN (SELECT value FROM json_each(${identifier})))`,
-      formatted: JSONUtil.toUTF8(values)
-    };
+  compileArrayAny(context: ResolvedPathContext, identifier: string, values: unknown[]): { sql: string; formatted: unknown } {
+    return this.compileArrayEquals(context, identifier, values);
   }
 
-  compileArrayExists(sqlPath: string): { sql: string } {
-    return { sql: `(${sqlPath} IS NOT NULL AND json_array_length(${sqlPath}) > 0)` };
+  compileArrayExists(context: ResolvedPathContext, identifier?: string): { sql: string } {
+    const jsonArrayExpression = this.#getSqliteArrayExpression(context);
+    return { sql: `(${jsonArrayExpression} IS NOT NULL AND json_array_length(${jsonArrayExpression}) > 0)` };
   }
 
   getRegexOperator(caseInsensitive: boolean): string {