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

package/README.md

@@ -13,13 +13,17 @@ 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#L69) 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:
    *  [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)
@@ -30,61 +34,62 @@ Out of the box, by installing the module, everything should be wired up by defau
 
 **Code: Wiring up a custom Model Source**
 ```typescript
-import type { AsyncContext } from '@travetto/context';
 import { InjectableFactory } from '@travetto/di';
-import { PostgreSQLDialect } from '@travetto/model-postgres';
-import { type SQLModelConfig, SQLModelService } from '@travetto/model-sql';
+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/config.ts';
 export * from './src/connection.ts';
-export * from './src/dialect.ts';
+export * from './src/service.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-postgres",
-  "version": "8.0.0-alpha.25",
+  "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.25",
+    "@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/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,79 +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, WithAsyncContext } from '@travetto/context';
-import { ExistsError } from '@travetto/model';
-import { Connection, type SQLModelConfig } from '@travetto/model-sql';
+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 { 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> {
-  #pool: Pool;
-  #config: SQLModelConfig;
+@Injectable()
+export class PostgresConnection extends SQLConnection<PoolClient> {
+  pool: Pool;
+
+  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
       }),
-      ...(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();
   }
 
-  release(pool: PoolClient): void {
-    pool.release();
+  /**
+   * Releases a client back to the pool
+   */
+  release(connection: PoolClient): void {
+    connection.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,138 +1,255 @@
-import type { AsyncContext } from '@travetto/context';
-import { Injectable } from '@travetto/di';
-import type { ModelType } from '@travetto/model';
-import { SQLDialect, type SQLModelConfig, SQLModelUtil, type SQLTableDescription, type VisitStack } from '@travetto/model-sql';
-import { type Class, castTo } from '@travetto/runtime';
-import type { SchemaFieldConfig } from '@travetto/schema';
-
-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';
 
+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}`;
+  }
+
+  #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: `${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)` };
+  }
+
+  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 {
-      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: `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]
     };
   }
 
-  /**
-   * 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});`;
+  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();
+  }
+}