@travetto/model-postgres 8.0.0-alpha.9 → 8.0.1

package/README.md

@@ -13,78 +13,83 @@ npm install @travetto/model-postgres
 yarn add @travetto/model-postgres
 ```
 
-This module provides a [Postgres](https://postgresql.org)-based implementation for the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") module.  This source allows the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") module to read, write and query against [SQL](https://en.wikipedia.org/wiki/SQL) databases. In development mode, the [SQLModelService](https://github.com/travetto/travetto/tree/main/module/model-sql/src/service.ts#L32) will also modify the database schema in real time to minimize impact to development. 
+This module provides a [Postgres](https://postgresql.org)-based implementation for the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") module. This source allows the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") module to read, write and query against [SQL](https://en.wikipedia.org/wiki/SQL) databases. In development mode, the [PostgresModelService](https://github.com/travetto/travetto/tree/main/module/model-postgres/src/service.ts#L12) will also modify the database schema in real time to minimize impact to development. 
 
-The schema generated will not generally map to existing tables as it is attempting to produce a document store like experience on top of a [SQL](https://en.wikipedia.org/wiki/SQL) database.  Every table generated will have a `path_id` which determines it's location in the document hierarchy as well as sub tables will have a `parent_path_id` to associate records with the parent values. 
+The schema generated will not generally map to existing tables as it is attempting to produce a document store like experience on top of a [SQL](https://en.wikipedia.org/wiki/SQL) database. Every table generated maps to a model:
+   *  Simple scalar fields map directly to individual native PostgreSQL columns (e.g., `VARCHAR`, `INTEGER`, `TIMESTAMP`).
+   *  Simple scalar arrays (such as `string[]`, `number[]`, or `boolean[]`) map directly to PostgreSQL native array columns (e.g., `VARCHAR[]`, `INTEGER[]`).
+   *  Complex fields and arrays of sub-schema objects map to native `JSONB` columns.
 
 Supported features:
-   *  [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/types/crud.ts#L11)
-   *  [Bulk](https://github.com/travetto/travetto/tree/main/module/model/src/types/bulk.ts#L64)
+   *  [Bulk](https://github.com/travetto/travetto/tree/main/module/model/src/types/bulk.ts#L60)
+   *  [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/types/crud.ts#L10)
+   *  [Expiry](https://github.com/travetto/travetto/tree/main/module/model/src/types/expiry.ts#L10)
+   *  [Indexed](https://github.com/travetto/travetto/tree/main/module/model-indexed/src/types/service.ts#L21)
    *  [Query Crud](https://github.com/travetto/travetto/tree/main/module/model-query/src/types/crud.ts#L11)
    *  [Facet](https://github.com/travetto/travetto/tree/main/module/model-query/src/types/facet.ts#L14)
-   *  [Query](https://github.com/travetto/travetto/tree/main/module/model-query/src/types/query.ts#L10)
    *  [Suggest](https://github.com/travetto/travetto/tree/main/module/model-query/src/types/suggest.ts#L12)
+   *  [Query](https://github.com/travetto/travetto/tree/main/module/model-query/src/types/query.ts#L10)
 
 Out of the box, by installing the module, everything should be wired up by default.If you need to customize any aspect of the source or config, you can override and register it with the [Dependency Injection](https://github.com/travetto/travetto/tree/main/module/di#readme "Dependency registration/management and injection support.") module.
 
 **Code: Wiring up a custom Model Source**
 ```typescript
-import type { AsyncContext } from '@travetto/context';
 import { InjectableFactory } from '@travetto/di';
-
-import { SQLModelService, type SQLModelConfig } from '@travetto/model-sql';
-import { PostgreSQLDialect } from '@travetto/model-postgres';
+import { type PostgresConnection, PostgresModelService } from '@travetto/model-postgres';
 
 export class Init {
   @InjectableFactory({ primary: true })
-  static getModelService(ctx: AsyncContext, config: SQLModelConfig) {
-    return new SQLModelService(ctx, config, new PostgreSQLDialect(ctx, config));
+  static getModelService(connection: PostgresConnection) {
+    return new PostgresModelService(connection);
   }
 }
 ```
 
-where the [SQLModelConfig](https://github.com/travetto/travetto/tree/main/module/model-sql/src/config.ts#L8) is defined by:
+where the [PostgresModelConfig](https://github.com/travetto/travetto/tree/main/module/model-postgres/src/config.ts#L10) is defined by:
 
-**Code: Structure of SQLModelConfig**
+**Code: Structure of PostgresModelConfig**
 ```typescript
-@Config('model.sql')
-export class SQLModelConfig<T extends {} = {}> {
+@Config('model.postgres')
+export class PostgresModelConfig {
   /**
-   * Host to connect to
+   * Database host to connect to
    */
   host = '127.0.0.1';
+
   /**
-   * Default port
+   * Database port to connect to
    */
   port = 0;
+
   /**
-   * Username
+   * Database username
    */
   user = Runtime.production ? '' : 'travetto';
+
   /**
-   * Password
+   * Database password
    */
   password = Runtime.production ? '' : 'travetto';
+
   /**
-   * Table prefix
+   * Namespace/schema prefix for table names
    */
   namespace = '';
+
   /**
    * Database name
    */
   database = 'app';
+
   /**
-   * Allow storage modification at runtime
-   */
-  modifyStorage?: boolean;
-  /**
-   * Db version
+   * Allow storage modifications (like table auto-creation and schema updates) at runtime
    */
-  version = '';
+  modifyStorage = !Runtime.production;
+
   /**
-   * Raw client options
+   * Client specific overrides
    */
-  options: T = asFull({});
+  options?: PG.ClientConfig;
 }
 ```
 

package/__index__.ts

@@ -1,2 +1,3 @@
-export * from './src/dialect.ts';
-export * from './src/connection.ts';
+export * from './src/config.ts';
+export * from './src/connection.ts';
+export * from './src/service.ts';

package/package.json

@@ -1,43 +1,46 @@
 {
   "name": "@travetto/model-postgres",
-  "version": "8.0.0-alpha.9",
-  "type": "module",
+  "version": "8.0.1",
   "description": "PostgreSQL backing for the travetto model module, with real-time modeling support for SQL schemas.",
   "keywords": [
-    "sql",
     "data-modeling",
-    "real-time",
     "model",
+    "real-time",
+    "sql",
     "travetto",
     "typescript"
   ],
   "homepage": "https://travetto.io",
   "license": "MIT",
   "author": {
-    "email": "travetto.framework@gmail.com",
-    "name": "Travetto Framework"
+    "name": "Travetto Framework",
+    "email": "travetto.framework@gmail.com"
+  },
+  "repository": {
+    "url": "git+https://github.com/travetto/travetto.git",
+    "directory": "module/model-postgres"
   },
   "files": [
     "__index__.ts",
     "src",
     "support"
   ],
+  "type": "module",
   "main": "__index__.ts",
-  "repository": {
-    "url": "git+https://github.com/travetto/travetto.git",
-    "directory": "module/model-postgres"
+  "publishConfig": {
+    "access": "public"
   },
   "dependencies": {
-    "@travetto/config": "^8.0.0-alpha.9",
-    "@travetto/context": "^8.0.0-alpha.9",
-    "@travetto/model": "^8.0.0-alpha.9",
-    "@travetto/model-query": "^8.0.0-alpha.9",
-    "@travetto/model-sql": "^8.0.0-alpha.9",
-    "@types/pg": "^8.18.0",
-    "pg": "^8.20.0"
+    "@travetto/config": "^8.0.1",
+    "@travetto/context": "^8.0.1",
+    "@travetto/model": "^8.0.1",
+    "@travetto/model-query": "^8.0.1",
+    "@travetto/model-sql": "^8.0.1",
+    "@types/pg": "^8.23.1",
+    "pg": "^8.23.0"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.14"
+    "@travetto/cli": "^8.0.1"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {
@@ -46,8 +49,5 @@
   },
   "travetto": {
     "displayName": "PostgreSQL Model Service"
-  },
-  "publishConfig": {
-    "access": "public"
   }
 }

package/src/config.ts

@@ -0,0 +1,50 @@
+import type PG from 'pg';
+
+import { Config } from '@travetto/config';
+import { Runtime } from '@travetto/runtime';
+
+/**
+ * PostgreSQL Model Configuration
+ */
+@Config('model.postgres')
+export class PostgresModelConfig {
+  /**
+   * Database host to connect to
+   */
+  host = '127.0.0.1';
+
+  /**
+   * Database port to connect to
+   */
+  port = 0;
+
+  /**
+   * Database username
+   */
+  user = Runtime.production ? '' : 'travetto';
+
+  /**
+   * Database password
+   */
+  password = Runtime.production ? '' : 'travetto';
+
+  /**
+   * Namespace/schema prefix for table names
+   */
+  namespace = '';
+
+  /**
+   * Database name
+   */
+  database = 'app';
+
+  /**
+   * Allow storage modifications (like table auto-creation and schema updates) at runtime
+   */
+  modifyStorage = !Runtime.production;
+
+  /**
+   * Client specific overrides
+   */
+  options?: PG.ClientConfig;
+}

package/src/connection.ts

@@ -1,80 +1,105 @@
-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, UniqueError } from '@travetto/model';
+import { SQLConnection } from '@travetto/model-sql';
 import { castTo, ShutdownManager } from '@travetto/runtime';
-import { type AsyncContext, WithAsyncContext } from '@travetto/context';
-import { ExistsError } from '@travetto/model';
-import { type SQLModelConfig, Connection } from '@travetto/model-sql';
+
+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;
+}
 
 /**
- * Connection support for postgresql
+ * PostgreSQL connection manager
  */
-export class PostgreSQLConnection extends Connection<PoolClient> {
+@Injectable()
+export class PostgresConnection extends SQLConnection<PoolClient> {
+  pool: Pool;
 
-  #pool: Pool;
-  #config: SQLModelConfig;
+  readonly dialect = new PostgresDialect();
+  readonly config: PostgresModelConfig;
 
-  constructor(
-    context: AsyncContext,
-    config: SQLModelConfig
-  ) {
+  constructor(context: AsyncContext, config: PostgresModelConfig) {
     super(context);
-    this.#config = config;
+    this.config = config;
   }
 
   /**
-   * Initializes connection and establishes crypto extension for use with hashing
+   * Initializes the pool and creates the pgcrypto extension
    */
-  @WithAsyncContext()
   async init(): Promise<void> {
-    this.#pool = new pg.Pool({
-      user: this.#config.user,
-      password: this.#config.password,
-      database: this.#config.database,
-      host: this.#config.host,
-      port: this.#config.port,
+    this.pool = new pg.Pool({
+      user: this.config.user,
+      password: this.config.password,
+      database: this.config.database,
+      host: this.config.host,
+      port: this.config.port,
       ...castTo({
-        parseInputDatesAsUTC: true,
+        parseInputDatesAsUTC: true
       }),
-      ...(this.#config.options || {})
+      ...this.config.options
     });
 
-    await this.runWithActive(() =>
-      this.runWithTransaction('required', () =>
-        this.execute(this.active!, 'CREATE EXTENSION IF NOT EXISTS pgcrypto;').catch(error => {
-          if (!(error instanceof Error && error.message.includes('already exists'))) {
-            throw error;
-          }
-        })
-      )
-    );
-
-    // Close postgres
-    ShutdownManager.signal.addEventListener('abort', () => this.#pool.end());
-  }
-
-  async execute<T = unknown>(pool: PoolClient, query: string, values?: unknown[]): Promise<{ count: number, records: T[] }> {
-    console.debug('Executing query', { query });
     try {
-      const out = await pool.query(query, values);
-      const records: T[] = [...out.rows].map(value => ({ ...value }));
-      return { count: out.rowCount!, records };
+      await this.execute('CREATE EXTENSION IF NOT EXISTS pgcrypto;');
     } catch (error) {
-      const code = error && typeof error === 'object' && 'code' in error ? error.code : undefined;
-      switch (code) {
-        // Index already exists
-        case '42P07': throw new ExistsError('index', query);
-        // Unique violation
-        case '23505': throw new ExistsError('query', query);
-        default: throw error;
+      if (!(error instanceof Error && error.message.includes('already exists'))) {
+        throw error;
       }
     }
+
+    ShutdownManager.signal.addEventListener('abort', () => this.pool.end());
   }
 
+  /**
+   * Acquires a client from the pool
+   */
   acquire(): Promise<PoolClient> {
-    return this.#pool.connect();
+    return this.pool.connect();
+  }
+
+  /**
+   * Releases a client back to the pool
+   */
+  release(connection: PoolClient): void {
+    connection.release();
   }
 
-  release(pool: PoolClient): void {
-    pool.release();
+  /**
+   * Executes a query on the active client or pool directly
+   */
+  async execute<Type = unknown>(query: string, values?: unknown[]): Promise<{ count: number; records: Type[] }> {
+    console.debug('Executing PostgreSQL query', { query, values });
+
+    // Handle dynamically built SAVEPOINT names that cannot be parameterized in Postgres
+    if (query.includes('SAVEPOINT') || query.includes('ROLLBACK TO') || query.includes('RELEASE SAVEPOINT')) {
+      if (values && values.length > 0) {
+        query = query.replace('$1', `"${values[0]}"`);
+        values = [];
+      }
+    }
+
+    const client = this.active ?? this.pool;
+
+    try {
+      const result = await client.query(query, values);
+      const records: Type[] = [...result.rows].map(row => ({ ...row }));
+      return { count: result.rowCount ?? 0, records };
+    } catch (error) {
+      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);
+        }
+      }
+      throw error;
+    }
   }
-}
+}

package/src/dialect.ts

@@ -1,145 +1,298 @@
-import type { SchemaFieldConfig } from '@travetto/schema';
-import { Injectable } from '@travetto/di';
-import type { AsyncContext } from '@travetto/context';
-import type { ModelType } from '@travetto/model';
-import { castTo, type Class } from '@travetto/runtime';
-
-import { SQLDialect, type SQLModelConfig, SQLModelUtil, type VisitStack, type SQLTableDescription } from '@travetto/model-sql';
-
-import { PostgreSQLConnection } from './connection.ts';
-
-/**
- * Postgresql Dialect for the SQL Model Source
- */
-@Injectable()
-export class PostgreSQLDialect extends SQLDialect {
-
-  connection: PostgreSQLConnection;
-
-  constructor(context: AsyncContext, config: SQLModelConfig) {
-    super(config.namespace);
-    this.connection = new PostgreSQLConnection(context, config);
-    this.ID_AFFIX = '"';
-
-    // Special operators
-    Object.assign(this.SQL_OPS, {
-      $regex: '~',
-      $iregex: '~*'
-    });
-
-    // Special types
-    Object.assign(this.COLUMN_TYPES, {
-      JSON: 'json',
-      TIMESTAMP: 'TIMESTAMP(6) WITH TIME ZONE'
-    });
-
-    // Word boundary
-    this.regexWordBoundary = '\\y';
-  }
-
-  /**
-   * How to hash
-   */
-  hash(value: string): string {
-    return `encode(digest('${value}', 'sha1'), 'hex')`;
-  }
-
-  async describeTable(table: string): Promise<SQLTableDescription | undefined> {
-    const IGNORE_FIELDS = [this.pathField.name, this.parentPathField.name, this.idxField.name].map(field => `'${field}'`);
-
-    // 1. Columns
-    const columns = await this.executeSQL<{ name: string, type: string, is_not_null: boolean }>(`
-      SELECT
-        a.attname AS name,
-        pg_catalog.format_type(a.atttypid, a.atttypmod) AS type,
-        a.attnotnull AS is_not_null
-      FROM pg_catalog.pg_attribute a
-      JOIN pg_catalog.pg_class c ON c.oid = a.attrelid
-      JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
-      LEFT JOIN
-        pg_catalog.pg_attrdef ad ON ad.adrelid = c.oid AND ad.adnum = a.attnum
-      WHERE
-        c.relname = '${table}'
-        AND a.attnum > 0
-        AND NOT a.attisdropped
-        AND a.attname NOT IN (${IGNORE_FIELDS.join(',')})
-      ORDER BY
-        a.attnum;
-    `);
-
-    if (!columns.count) {
-      return undefined;
-    }
-
-    // 2. Foreign Keys
-    const foreignKeys = await this.executeSQL<{ name: string, from_column: string, to_column: string, to_table: string }>(`
-      SELECT
-        tc.constraint_name AS name, 
-        kcu.column_name AS from_column,
-        ccu.column_name AS to_column,
-        ccu.table_name AS to_table
-      FROM information_schema.table_constraints AS tc 
-      JOIN information_schema.key_column_usage AS kcu
-        ON tc.constraint_name = kcu.constraint_name
-      JOIN information_schema.constraint_column_usage AS ccu
-        ON ccu.constraint_name = tc.constraint_name
-      WHERE tc.constraint_type = 'FOREIGN KEY' 
-        AND tc.table_name = '${table}'
-    `);
-
-    // 3. Indices
-    const indices = await this.executeSQL<{ name: string, is_unique: boolean, columns: string[] }>(`
-      SELECT
-        i.relname AS name,
-        ix.indisunique AS is_unique,
-        ARRAY_AGG(a.attname || ' '|| CAST((o.OPTION & 1) AS VARCHAR) ORDER BY array_position(ix.indkey, a.attnum)) AS columns
-      FROM pg_class t
-      JOIN pg_index ix ON t.oid = ix.indrelid
-      JOIN pg_class i ON i.oid = ix.indexrelid
-      CROSS JOIN LATERAL UNNEST(ix.indkey)    WITH ordinality AS c (colnum, ordinality)
-      LEFT  JOIN LATERAL UNNEST(ix.indoption) WITH ordinality AS o (OPTION, ordinality) ON c.ordinality = o.ordinality 
-      LEFT JOIN pg_catalog.pg_constraint co ON co.conindid = ix.indexrelid
-      JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = c.colnum 
-      WHERE t.relname = '${table}'
-        AND NOT ix.indisprimary
-        AND co.conindid IS NULL
-      GROUP BY i.relname, ix.indisunique
-    `);
+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';
+
+/* cspell:words ILIKE regclass indexdef tablename pkey */
+
+export class PostgresDialect extends AbstractANSI99Dialect {
+  returningSupport = true;
+  suggestLikeOperator = 'ILIKE';
+
+  getComplexColumnType(field: SchemaFieldConfig): string {
+    if (field.array && !SchemaRegistryIndex.has(field.type)) {
+      const scalarType = this.getColumnType(field);
+      return `${scalarType}[]`;
+    }
+    return 'JSONB';
+  }
+
+  getComplexColumnValue(field: SchemaFieldConfig, value: unknown): unknown {
+    if (field.array && !SchemaRegistryIndex.has(field.type)) {
+      return value ?? null;
+    }
+    return super.getComplexColumnValue(field, value);
+  }
+
+  getColumnType(fieldConfiguration: SchemaFieldConfig): string {
+    if (fieldConfiguration.type === castTo(BigInt)) {
+      return 'BIGINT';
+    }
+
+    if (fieldConfiguration.type === Number) {
+      if (fieldConfiguration.precision) {
+        const [digits, decimals] = fieldConfiguration.precision;
+        if (decimals) {
+          return `DECIMAL(${digits},${decimals})`;
+        }
+        if (digits < 5) {
+          return 'SMALLINT';
+        }
+        if (digits < 10) {
+          return 'INTEGER';
+        }
+        return 'BIGINT';
+      }
+      return 'INTEGER';
+    }
+
+    if (fieldConfiguration.type === Date) {
+      return 'TIMESTAMP(6) WITH TIME ZONE';
+    }
+
+    if (fieldConfiguration.type === Boolean) {
+      return 'BOOLEAN';
+    }
+
+    if (fieldConfiguration.type === String) {
+      if (fieldConfiguration.specifiers?.includes('text')) {
+        return 'TEXT';
+      }
+      return `VARCHAR(${fieldConfiguration.maxlength?.limit ?? 1024})`;
+    }
+
+    return 'JSONB';
+  }
+
+  compileJsonIndexPath(columnName: string, jsonPath: string[]): string {
+    const jsonAccessor = jsonPath
+      .slice(0, -1)
+      .map(segment => `->'${this.escapeLiteral(segment)}'`)
+      .join('');
+    const leafSegment = jsonPath[jsonPath.length - 1];
+    return `((${columnName}${jsonAccessor}->>'${this.escapeLiteral(leafSegment)}'))`;
+  }
+
+  override getPlaceholder(index: number): string {
+    return `$${index}`;
+  }
+
+  override getUpsertSQL(
+    context: TableContext,
+    columns: string[],
+    placeholders: string[],
+    conflictTarget: string[],
+    updates: string[]
+  ): string {
+    return `INSERT INTO ${this.escapeIdentifier(context.tableName)} (${columns.join(', ')}) VALUES (${placeholders.join(', ')}) ON CONFLICT (${conflictTarget.join(', ')}) DO UPDATE SET ${updates.join(', ')} RETURNING *;`;
+  }
+
+  #buildContainmentPayload(value: unknown, context: ResolvedPathContext): unknown {
+    if (!context.subPath || context.subPath.length === 0) {
+      return Array.isArray(value) ? value : [value];
+    }
+
+    const subPathMetadata = this.getSchemaSubPathMetadata(context.arrayField?.type, context.subPath);
+    const isArraySegment = subPathMetadata.map(item => item.isArray);
+
+    const buildPayloadForValue = (item: unknown): unknown => {
+      let itemPayload: unknown = item;
+      for (let index = context.subPath!.length - 1; index >= 0; index--) {
+        const segment = context.subPath![index];
+        if (isArraySegment[index]) {
+          itemPayload = { [segment]: Array.isArray(itemPayload) ? itemPayload : [itemPayload] };
+        } else {
+          itemPayload = { [segment]: itemPayload };
+        }
+      }
+      return itemPayload;
+    };
+
+    let currentPayload: unknown;
+    if (Array.isArray(value)) {
+      currentPayload = value.map(item => buildPayloadForValue(item));
+    } else {
+      currentPayload = [buildPayloadForValue(value)];
+    }
+
+    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: `${target.sqlPath} @> ${identifier}`, formatted: values };
+      }
+      return { sql: `${identifier} = ANY(${target.sqlPath})`, formatted: values };
+    }
+    return { sql: `${target.jsonbPath} @> ${identifier}::jsonb`, formatted: JSONUtil.toUTF8(target.buildPayload(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 formatted = values.map(v => JSONUtil.toUTF8(target.buildPayload(v)));
+    return { sql: `${target.jsonbPath} @> ANY(${identifier}::jsonb[])`, formatted };
+  }
+
+  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)` };
+    }
+    return { sql: `(${target.jsonbPath} IS NOT NULL AND ${target.jsonbPath} <> '[]'::jsonb)` };
+  }
+
+  compileArrayRegex(context: ResolvedPathContext, identifier: string, value: RegExp | string): { sql: string; formatted: unknown } {
+    const target = this.#getPostgresArrayTarget(context);
+    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);
+
+    if (target.isNative) {
+      return {
+        sql: `EXISTS (SELECT 1 FROM unnest(${target.sqlPath}) AS elem WHERE elem ${regexOp} ${identifier})`,
+        formatted: regexSource
+      };
+    }
+
+    const subAccessor =
+      context.subPath && context.subPath.length > 0
+        ? `->${context.subPath.map(segment => `'${this.escapeLiteral(segment)}'`).join('->')}`
+        : '';
 
     return {
-      columns: columns.records.map(col => ({
-        ...col,
-        type: col.type.toUpperCase()
-          .replace('CHARACTER VARYING', 'VARCHAR')
-          .replace('INTEGER', 'INT'),
-        is_not_null: !!col.is_not_null
-      })),
-      foreignKeys: foreignKeys.records,
-      indices: indices.records
-        .map(idx => ({
-          name: idx.name,
-          is_unique: idx.is_unique,
-          columns: idx.columns
-            .map(column => column.split(' '))
-            .map(([name, desc]) => ({ name, desc: desc === '1' }))
-        }))
+      sql: `EXISTS (SELECT 1 FROM jsonb_array_elements_text((${target.jsonbPath})${subAccessor}) AS elem WHERE elem ${regexOp} ${identifier})`,
+      formatted: regexSource
     };
   }
 
-  /**
-   * Define column modification
-   */
-  getModifyColumnSQL(stack: VisitStack[]): string {
-    const field: SchemaFieldConfig = castTo(stack.at(-1));
-    const type = this.getColumnType(field);
-    const identifier = this.identifier(field.name);
-    return `ALTER TABLE ${this.parentTable(stack)} ALTER COLUMN ${identifier}  TYPE ${type} USING (${identifier}::${type});`;
+  getRegexOperator(caseInsensitive: boolean): string {
+    return caseInsensitive ? '~*' : '~';
+  }
+
+  formatRegex(source: string, caseInsensitive: boolean): string {
+    return source.replaceAll('\\b', '\\y');
+  }
+
+  castColumn(sqlPath: string, type: Class): string {
+    if (type === Number) {
+      return `(${sqlPath})::NUMERIC`;
+    } else if (type === Boolean) {
+      return `(${sqlPath})::BOOLEAN`;
+    } else if (type === Date) {
+      return `(${sqlPath})::TIMESTAMP WITH TIME ZONE`;
+    } else if (type === String) {
+      return `(${sqlPath})::text`;
+    }
+    return sqlPath;
+  }
+
+  shiftPlaceholders(sql: string, offset: number): string {
+    return sql.replaceAll(/[$](\d+)/g, (_, num) => `$${Number(num) + offset}`);
+  }
+
+  getTableExistsQuery(context: TableContext): { sql: string; parameters?: unknown[] } {
+    return {
+      sql: `SELECT EXISTS (
+        SELECT FROM pg_catalog.pg_class c
+        JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relname = $1 AND c.relkind = 'r'
+      );`,
+      parameters: [context.tableName]
+    };
+  }
+
+  parseTableExistsResult(records: unknown[]): boolean {
+    return castTo<{ exists: boolean }>(records[0])?.exists ?? false;
+  }
+
+  getExistingColumnsQuery(context: TableContext): { sql: string; parameters?: unknown[] } {
+    return {
+      sql: `SELECT a.attname AS name, pg_catalog.format_type(a.atttypid, a.atttypmod) AS type
+       FROM pg_catalog.pg_attribute a
+       WHERE a.attrelid = $1::regclass AND a.attnum > 0 AND NOT a.attisdropped;`,
+      parameters: [context.tableName]
+    };
+  }
+
+  parseExistingColumns(records: unknown[]): Map<string, string> {
+    return new Map(castTo<{ name: string; type: string }[]>(records).map(record => [record.name, record.type.toUpperCase()]));
+  }
+
+  getAlterColumnTypeSQL(context: TableContext, columnName: string, columnType: string, existingType: string): string | undefined {
+    const normalizedExisting = existingType.replace('CHARACTER VARYING', 'VARCHAR').replace('INTEGER', 'INT');
+    const normalizedRequested = columnType.toUpperCase().replace('CHARACTER VARYING', 'VARCHAR').replace('INTEGER', 'INT');
+
+    if (!normalizedExisting.startsWith(normalizedRequested) && !normalizedRequested.startsWith(normalizedExisting)) {
+      return `ALTER TABLE ${this.escapeIdentifier(context.tableName)} ALTER COLUMN ${this.escapeIdentifier(columnName)} TYPE ${columnType} USING (${this.escapeIdentifier(columnName)}::${columnType});`;
+    }
+    return undefined;
+  }
+
+  getExistingIndexesQuery(context: TableContext): { sql: string; parameters?: unknown[] } {
+    return {
+      sql: `SELECT indexname, indexdef FROM pg_indexes WHERE tablename = $1;`,
+      parameters: [context.tableName]
+    };
+  }
+
+  parseExistingIndexes(records: unknown[]): Map<string, string> {
+    return new Map(
+      castTo<{ indexname: string; indexdef: string }[]>(records)
+        .filter(record => !record.indexname.endsWith('_pkey'))
+        .map(record => [record.indexname, record.indexdef])
+    );
+  }
+
+  getDropIndexSQL(context: TableContext, indexName: string): string {
+    return `DROP INDEX IF EXISTS ${this.escapeIdentifier(indexName)};`;
+  }
+
+  getDropTableSQL(context: TableContext): string {
+    return `DROP TABLE IF EXISTS ${this.escapeIdentifier(context.tableName)} CASCADE;`;
   }
 
-  /**
-   * Suppress foreign key checks
-   */
-  override getTruncateAllTablesSQL<T extends ModelType>(cls: Class<T>): string[] {
-    return [`TRUNCATE ${this.table(SQLModelUtil.classToStack(cls))} CASCADE;`];
+  getTruncateTableSQL(context: TableContext): string {
+    return `TRUNCATE TABLE ${this.escapeIdentifier(context.tableName)} CASCADE;`;
   }
-}
+}

package/src/service.ts

@@ -0,0 +1,28 @@
+import type { default as pg } from 'pg';
+
+import { Injectable, PostConstruct } from '@travetto/di';
+import { BaseSQLModelService } from '@travetto/model-sql';
+
+import type { PostgresConnection } from './connection.ts';
+
+/**
+ * A PostgreSQL JSON-based document store model service
+ */
+@Injectable()
+export class PostgresModelService extends BaseSQLModelService {
+  connection: PostgresConnection;
+
+  constructor(connection: PostgresConnection) {
+    super();
+    this.connection = connection;
+  }
+
+  get client(): pg.Pool {
+    return this.connection.pool;
+  }
+
+  @PostConstruct()
+  override async initialize(): Promise<void> {
+    await super.initialize();
+  }
+}

package/support/service.postgresql.ts

@@ -1,6 +1,6 @@
 import type { ServiceDescriptor } from '@travetto/cli';
 
-const version = process.env.POSTGRESQL_VERSION || '18.1';
+const version = process.env.POSTGRESQL_VERSION || '18.6';
 
 export const service: ServiceDescriptor = {
   name: 'postgresql',
@@ -12,4 +12,4 @@ export const service: ServiceDescriptor = {
     POSTGRES_PASSWORD: 'travetto',
     POSTGRES_DB: 'app'
   }
-};
+};