@travetto/model-sqlite 8.0.0-alpha.27 → 8.0.0-alpha.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-sqlite",
-  "version": "8.0.0-alpha.27",
+  "version": "8.0.0-alpha.29",
   "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.23",
-    "@travetto/context": "^8.0.0-alpha.21",
-    "@travetto/model": "^8.0.0-alpha.24",
-    "@travetto/model-query": "^8.0.0-alpha.25",
-    "@travetto/model-sql": "^8.0.0-alpha.27"
+    "@travetto/config": "^8.0.0-alpha.24",
+    "@travetto/context": "^8.0.0-alpha.22",
+    "@travetto/model": "^8.0.0-alpha.25",
+    "@travetto/model-query": "^8.0.0-alpha.27",
+    "@travetto/model-sql": "^8.0.0-alpha.29"
   },
   "travetto": {
     "displayName": "SQLite Model Service"

package/src/dialect.ts

@@ -1,6 +1,6 @@
 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,60 +41,137 @@ export class SqliteDialect extends AbstractANSI99Dialect {
     return `json_extract(${columnName}, '$.${jsonPath.join('.')}')`;
   }
 
-  #getSqliteArrayContext(context: ResolvedPathContext): { jsonArrayExpr: string; valueExpr: string } {
+  #getSqliteArrayExpression(context: ResolvedPathContext): string {
     if (!context.arrayPath || context.arrayPath.length === 0) {
-      return { jsonArrayExpr: context.sqlPath, valueExpr: 'elem.value' };
+      return context.sqlPath;
     }
 
     const columnName = this.escapeIdentifier(context.arrayPath[0]);
-    const jsonArrayExpr =
-      context.arrayPath.length > 1 ? `json_extract(${columnName}, '$.${context.arrayPath.slice(1).join('.')}')` : columnName;
+    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}
+)`;
+    };
 
-    const valueExpr =
-      context.subPath && context.subPath.length > 0 ? `json_extract(elem.value, '$.${context.subPath.join('.')}')` : 'elem.value';
+    return buildLevel(0, parentExpression);
+  }
 
-    return { jsonArrayExpr, valueExpr };
+  #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 { jsonArrayExpr, valueExpr } = this.#getSqliteArrayContext(context);
+    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 ${valueExpr} FROM json_each(${jsonArrayExpr}) AS elem))`,
+      sql: `NOT EXISTS (
+  SELECT 1 
+  FROM json_each(${identifier}) AS req 
+  WHERE NOT ${elementExists}
+)`,
       formatted: JSONUtil.toUTF8(value)
     };
   }
 
   compileArrayEquals(context: ResolvedPathContext, identifier: string, values: unknown): { sql: string; formatted: unknown } {
-    const { jsonArrayExpr, valueExpr } = this.#getSqliteArrayContext(context);
     if (Array.isArray(values)) {
       return {
-        sql: `NOT EXISTS (SELECT 1 FROM json_each(${identifier}) AS req WHERE req.value NOT IN (SELECT ${valueExpr} FROM json_each(${jsonArrayExpr}) AS elem))`,
+        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(${jsonArrayExpr}) 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(${jsonArrayExpr}) AS elem WHERE ${valueExpr} = ${identifier})`,
+      sql: this.#buildArrayElementExists(context, leafExpression => `${leafExpression} = ${identifier}`),
       formatted: values
     };
   }
 
   compileArrayAny(context: ResolvedPathContext, identifier: string, values: unknown[]): { sql: string; formatted: unknown } {
-    const { jsonArrayExpr, valueExpr } = this.#getSqliteArrayContext(context);
-    return {
-      sql: `EXISTS (SELECT 1 FROM json_each(${jsonArrayExpr}) AS elem WHERE ${valueExpr} IN (SELECT value FROM json_each(${identifier})))`,
-      formatted: JSONUtil.toUTF8(values)
-    };
+    return this.compileArrayEquals(context, identifier, values);
   }
 
   compileArrayExists(context: ResolvedPathContext, identifier?: string): { sql: string } {
-    const { jsonArrayExpr } = this.#getSqliteArrayContext(context);
-    return { sql: `(${jsonArrayExpr} IS NOT NULL AND json_array_length(${jsonArrayExpr}) > 0)` };
+    const jsonArrayExpression = this.#getSqliteArrayExpression(context);
+    return { sql: `(${jsonArrayExpression} IS NOT NULL AND json_array_length(${jsonArrayExpression}) > 0)` };
+  }
+
+  compileArrayRegex(context: ResolvedPathContext, identifier: string, value: RegExp | string): { sql: string; formatted: unknown } {
+    const regex = value instanceof RegExp ? value : new RegExp(String(value));
+    const caseInsensitive = regex.flags.includes('i');
+    const regexOp = this.getRegexOperator(caseInsensitive);
+    const regexSource = this.formatRegex(regex.source, caseInsensitive);
+    return {
+      sql: this.#buildArrayElementExists(context, leafExpression => `${leafExpression} ${regexOp} ${identifier}`),
+      formatted: regexSource
+    };
   }
 
   getRegexOperator(caseInsensitive: boolean): string {