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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-mysql",
-  "version": "8.0.0-alpha.26",
+  "version": "8.0.0-alpha.27",
   "type": "module",
   "description": "MySQL backing for the travetto model module, with real-time modeling support for SQL schemas.",
   "keywords": [
@@ -28,15 +28,15 @@
     "directory": "module/model-mysql"
   },
   "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.25",
+    "@travetto/model-sql": "^8.0.0-alpha.27",
     "mysql2": "^3.22.6"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.28"
+    "@travetto/cli": "^8.0.0-alpha.29"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/connection.ts

@@ -3,7 +3,7 @@ import type { OkPacket, Pool, PoolConnection, ResultSetHeader, TypeCastField } f
 
 import type { AsyncContext } from '@travetto/context';
 import { Injectable } from '@travetto/di';
-import { ExistsError, type ModelType } from '@travetto/model';
+import { ExistsError, type ModelType, UniqueError } from '@travetto/model';
 import { SQLConnection, type TableContext } from '@travetto/model-sql';
 import { type Class, castTo, JSONUtil, ShutdownManager } from '@travetto/runtime';
 
@@ -113,8 +113,12 @@ export class MysqlConnection extends SQLConnection<PoolConnection> {
     } catch (error) {
       const code = error && typeof error === 'object' && 'code' in error ? error.code : undefined;
       switch (code) {
-        case 'ER_DUP_ENTRY':
-          throw new ExistsError('query', query);
+        case 'ER_DUP_ENTRY': {
+          const message = error instanceof Error ? error.message : '';
+          const match = message.match(/for key '([^']+)'/);
+          const key = match ? match[1] : 'query';
+          throw new UniqueError('query', key, { message, query });
+        }
         case 'ER_DUP_KEYNAME':
           throw new ExistsError('index', query);
         default:

package/src/dialect.ts

@@ -1,4 +1,4 @@
-import { AbstractANSI99Dialect, type JSONSqlPathMode, type TableContext } from '@travetto/model-sql';
+import { AbstractANSI99Dialect, type JSONSqlPathMode, type ResolvedPathContext, type TableContext } from '@travetto/model-sql';
 import { type Class, castTo, JSONUtil } from '@travetto/runtime';
 import type { SchemaFieldConfig } from '@travetto/schema';
 
@@ -64,38 +64,35 @@ export class MysqlDialect extends AbstractANSI99Dialect {
     }
   }
 
-  compileArrayAll(
-    sqlPath: string,
-    identifier: string,
-    value: unknown[],
-    field: SchemaFieldConfig,
-    topLevel?: boolean
-  ): { sql: string; formatted: unknown } {
-    return { sql: `JSON_CONTAINS(${sqlPath}, ${identifier})`, formatted: JSONUtil.toUTF8(value) };
+  #getArraySqlPath(context: ResolvedPathContext): string {
+    if (!context.arrayPath || context.arrayPath.length === 0 || !context.subPath || context.subPath.length === 0) {
+      return context.sqlPath;
+    }
+    const columnName = this.escapeIdentifier(context.arrayPath[0]);
+    const arrayPathPart = context.arrayPath.length > 1 ? context.arrayPath.slice(1).join('.') : '';
+    const jsonPathExpr = arrayPathPart ? `$.${arrayPathPart}[*].${context.subPath.join('.')}` : `$[*].${context.subPath.join('.')}`;
+    return `JSON_EXTRACT(${columnName}, '${jsonPathExpr}')`;
+  }
+
+  compileArrayAll(context: ResolvedPathContext, identifier: string, value: unknown[]): { sql: string; formatted: unknown } {
+    const targetSqlPath = this.#getArraySqlPath(context);
+    return { sql: `JSON_CONTAINS(${targetSqlPath}, ${identifier})`, formatted: JSONUtil.toUTF8(value) };
   }
 
-  compileArrayEquals(
-    sqlPath: string,
-    identifier: string,
-    values: unknown,
-    field: SchemaFieldConfig,
-    topLevel?: boolean
-  ): { sql: string; formatted: unknown } {
-    return { sql: `JSON_CONTAINS(${sqlPath}, ${identifier})`, formatted: JSONUtil.toUTF8(values) };
+  compileArrayEquals(context: ResolvedPathContext, identifier: string, values: unknown): { sql: string; formatted: unknown } {
+    const targetSqlPath = this.#getArraySqlPath(context);
+    const val = context.subPath?.length && !Array.isArray(values) ? [values] : values;
+    return { sql: `JSON_CONTAINS(${targetSqlPath}, ${identifier})`, formatted: JSONUtil.toUTF8(val) };
   }
 
-  compileArrayAny(
-    sqlPath: string,
-    identifier: string,
-    values: unknown[],
-    field: SchemaFieldConfig,
-    topLevel?: boolean
-  ): { sql: string; formatted: unknown } {
-    return { sql: `JSON_OVERLAPS(${sqlPath}, ${identifier})`, formatted: JSONUtil.toUTF8(values) };
+  compileArrayAny(context: ResolvedPathContext, identifier: string, values: unknown[]): { sql: string; formatted: unknown } {
+    const targetSqlPath = this.#getArraySqlPath(context);
+    return { sql: `JSON_OVERLAPS(${targetSqlPath}, ${identifier})`, formatted: JSONUtil.toUTF8(values) };
   }
 
-  compileArrayExists(sqlPath: string, identifier: string, field: SchemaFieldConfig, topLevel?: boolean): { sql: string } {
-    return { sql: `(${sqlPath} IS NOT NULL AND JSON_LENGTH(${sqlPath}) > 0)` };
+  compileArrayExists(context: ResolvedPathContext, identifier?: string): { sql: string } {
+    const targetSqlPath = this.#getArraySqlPath(context);
+    return { sql: `(${targetSqlPath} IS NOT NULL AND JSON_LENGTH(${targetSqlPath}) > 0)` };
   }
 
   compileJsonEquality(sqlPath: string, identifier: string): string {