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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-postgres",
-  "version": "8.0.0-alpha.26",
+  "version": "8.0.0-alpha.27",
   "type": "module",
   "description": "PostgreSQL backing for the travetto model module, with real-time modeling support for SQL schemas.",
   "keywords": [
@@ -28,16 +28,16 @@
     "directory": "module/model-postgres"
   },
   "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",
     "@types/pg": "^8.20.0",
     "pg": "^8.22.0"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.28"
+    "@travetto/cli": "^8.0.0-alpha.29"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/connection.ts

@@ -1,14 +1,18 @@
-import { type Pool, type PoolClient, default as pg } from 'pg';
+import { type DatabaseError, type Pool, type PoolClient, default as pg } from 'pg';
 
 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, ShutdownManager } from '@travetto/runtime';
 
 import type { PostgresModelConfig } from './config.ts';
 import { PostgresDialect } from './dialect.ts';
 
+function isPgDatabaseError(error: unknown): error is DatabaseError {
+  return !!error && typeof error === 'object' && 'code' in error;
+}
+
 /**
  * PostgreSQL connection manager
  */
@@ -86,15 +90,16 @@ export class PostgresConnection extends SQLConnection<PoolClient> {
       const records: Type[] = [...result.rows].map(row => ({ ...row }));
       return { count: result.rowCount ?? 0, records };
     } catch (error) {
-      const code = error && typeof error === 'object' && 'code' in error ? castTo<Record<string, unknown>>(error).code : undefined;
-      switch (code) {
-        case '42P07':
+      if (isPgDatabaseError(error)) {
+        if (error.code === '23505') {
+          const constraint = error.constraint ?? (error.detail ? 'index' : 'query');
+          const detail = error.detail ?? query;
+          throw new UniqueError('index', constraint, { detail, query });
+        } else if (error.code === '42P07') {
           throw new ExistsError('index', query);
-        case '23505':
-          throw new ExistsError('query', query);
-        default:
-          throw error;
+        }
       }
+      throw error;
     }
   }
 }

package/src/dialect.ts

@@ -1,4 +1,4 @@
-import { AbstractANSI99Dialect, type TableContext } from '@travetto/model-sql';
+import { AbstractANSI99Dialect, type ResolvedPathContext, type TableContext } from '@travetto/model-sql';
 import { type Class, castTo, JSONUtil } from '@travetto/runtime';
 import { type SchemaFieldConfig, SchemaRegistryIndex } from '@travetto/schema';
 
@@ -74,59 +74,93 @@ export class PostgresDialect extends AbstractANSI99Dialect {
     return `$${index}`;
   }
 
-  compileArrayAll(
-    sqlPath: string,
-    identifier: string,
-    value: unknown[],
-    field: SchemaFieldConfig,
-    topLevel?: boolean
-  ): { sql: string; formatted: unknown } {
-    if (topLevel && !SchemaRegistryIndex.has(field.type)) {
-      return { sql: `${sqlPath} @> ${identifier}`, formatted: value };
-    }
-    const jsonbPath = topLevel ? sqlPath : `(${sqlPath})::jsonb`;
-    return { sql: `${jsonbPath} @> ${identifier}::jsonb`, formatted: JSONUtil.toUTF8(value) };
-  }
-
-  compileArrayEquals(
-    sqlPath: string,
-    identifier: string,
-    values: unknown,
-    field: SchemaFieldConfig,
-    topLevel?: boolean
-  ): { sql: string; formatted: unknown } {
-    if (topLevel && !SchemaRegistryIndex.has(field.type)) {
+  #buildContainmentPayload(value: unknown, context?: ResolvedPathContext): unknown {
+    if (!context?.subPath || context.subPath.length === 0) {
+      return Array.isArray(value) ? value : [value];
+    }
+
+    let currentPayload: unknown;
+    if (Array.isArray(value)) {
+      currentPayload = value.map(item => {
+        let itemPayload: unknown = item;
+        for (let index = context.subPath!.length - 1; index >= 0; index--) {
+          itemPayload = { [context.subPath![index]]: itemPayload };
+        }
+        return itemPayload;
+      });
+    } else {
+      currentPayload = value;
+      for (let index = context.subPath.length - 1; index >= 0; index--) {
+        currentPayload = { [context.subPath[index]]: currentPayload };
+      }
+      currentPayload = [currentPayload];
+    }
+
+    if (context.arrayPath && context.arrayPath.length > 1) {
+      for (let index = context.arrayPath.length - 1; index >= 1; index--) {
+        currentPayload = { [context.arrayPath[index]]: currentPayload };
+      }
+      return currentPayload;
+    }
+
+    return currentPayload;
+  }
+
+  #getPostgresArrayTarget(context: ResolvedPathContext): {
+    isNative: boolean;
+    sqlPath: string;
+    jsonbPath: string;
+    buildPayload: (val: unknown) => unknown;
+  } {
+    const arrayField = context.arrayField ?? context.leafField;
+    const isTopLevel = (context.arrayPath?.length ?? 1) === 1;
+    const hasSubPath = (context.subPath?.length ?? 0) > 0;
+    const isScalarArray = arrayField ? !SchemaRegistryIndex.has(arrayField.type) : true;
+    const isNative = isTopLevel && !hasSubPath && isScalarArray;
+
+    const targetPath =
+      hasSubPath && context.arrayPath && context.arrayPath.length > 0 ? this.escapeIdentifier(context.arrayPath[0]) : context.sqlPath;
+
+    const jsonbPath = isTopLevel && !hasSubPath ? targetPath : `(${targetPath})::jsonb`;
+    const buildPayload = (value: unknown): unknown => this.#buildContainmentPayload(value, context);
+
+    return { isNative, sqlPath: context.sqlPath, jsonbPath, buildPayload };
+  }
+
+  compileArrayAll(context: ResolvedPathContext, identifier: string, value: unknown[]): { sql: string; formatted: unknown } {
+    const target = this.#getPostgresArrayTarget(context);
+    if (target.isNative) {
+      return { sql: `${target.sqlPath} @> ${identifier}`, formatted: value };
+    }
+    return { sql: `${target.jsonbPath} @> ${identifier}::jsonb`, formatted: JSONUtil.toUTF8(target.buildPayload(value)) };
+  }
+
+  compileArrayEquals(context: ResolvedPathContext, identifier: string, values: unknown): { sql: string; formatted: unknown } {
+    const target = this.#getPostgresArrayTarget(context);
+    if (target.isNative) {
       if (Array.isArray(values)) {
-        return { sql: `${sqlPath} @> ${identifier}`, formatted: values };
+        return { sql: `${target.sqlPath} @> ${identifier}`, formatted: values };
       }
-      return { sql: `${identifier} = ANY(${sqlPath})`, formatted: values };
+      return { sql: `${identifier} = ANY(${target.sqlPath})`, formatted: values };
     }
-    const jsonbPath = topLevel ? sqlPath : `(${sqlPath})::jsonb`;
-    const val = Array.isArray(values) ? values : [values];
-    return { sql: `${jsonbPath} @> ${identifier}::jsonb`, formatted: JSONUtil.toUTF8(val) };
+    return { sql: `${target.jsonbPath} @> ${identifier}::jsonb`, formatted: JSONUtil.toUTF8(target.buildPayload(values)) };
   }
 
-  compileArrayAny(
-    sqlPath: string,
-    identifier: string,
-    values: unknown[],
-    field: SchemaFieldConfig,
-    topLevel?: boolean
-  ): { sql: string; formatted: unknown } {
-    if (topLevel && !SchemaRegistryIndex.has(field.type)) {
-      return { sql: `${sqlPath} && ${identifier}`, formatted: values };
+  compileArrayAny(context: ResolvedPathContext, identifier: string, values: unknown[]): { sql: string; formatted: unknown } {
+    const target = this.#getPostgresArrayTarget(context);
+    if (target.isNative) {
+      return { sql: `${target.sqlPath} && ${identifier}`, formatted: values };
     }
-    const jsonbPath = topLevel ? sqlPath : `(${sqlPath})::jsonb`;
-    const formatted = values.map(v => JSONUtil.toUTF8(Array.isArray(v) ? v : [v]));
-    return { sql: `${jsonbPath} @> ANY(${identifier}::jsonb[])`, formatted };
+    const formatted = values.map(v => JSONUtil.toUTF8(target.buildPayload(v)));
+    return { sql: `${target.jsonbPath} @> ANY(${identifier}::jsonb[])`, formatted };
   }
 
-  compileArrayExists(sqlPath: string, identifier: string, field: SchemaFieldConfig, topLevel?: boolean): { sql: string } {
-    if (topLevel && !SchemaRegistryIndex.has(field.type)) {
-      return { sql: `(${sqlPath} IS NOT NULL AND cardinality(${sqlPath}) > 0)` };
+  compileArrayExists(context: ResolvedPathContext, identifier?: string): { sql: string } {
+    const target = this.#getPostgresArrayTarget(context);
+    if (target.isNative) {
+      return { sql: `(${target.sqlPath} IS NOT NULL AND cardinality(${target.sqlPath}) > 0)` };
     }
-    const jsonbPath = topLevel ? sqlPath : `(${sqlPath})::jsonb`;
-    return { sql: `(${sqlPath} IS NOT NULL AND ${jsonbPath} <> '[]'::jsonb)` };
+    return { sql: `(${target.jsonbPath} IS NOT NULL AND ${target.jsonbPath} <> '[]'::jsonb)` };
   }
 
   getRegexOperator(caseInsensitive: boolean): string {