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

package/README.md

@@ -13,78 +13,80 @@ npm install @travetto/model-mysql
 yarn add @travetto/model-mysql
 ```
 
-This module provides a [MySQL](https://www.mysql.com/)-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 [MySQL](https://www.mysql.com/)-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 [MysqlModelService](https://github.com/travetto/travetto/tree/main/module/model-mysql/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, with simple fields mapped as individual columns and complex fields/arrays mapped as native `JSON` 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 { MySQLDialect } from '@travetto/model-mysql';
+import { type MysqlConnection, MysqlModelService } from '@travetto/model-mysql';
 
 export class Init {
   @InjectableFactory({ primary: true })
-  static getModelService(ctx: AsyncContext, config: SQLModelConfig) {
-    return new SQLModelService(ctx, config, new MySQLDialect(ctx, config));
+  static getModelService(connection: MysqlConnection) {
+    return new MysqlModelService(connection);
   }
 }
 ```
 
-where the [SQLModelConfig](https://github.com/travetto/travetto/tree/main/module/model-sql/src/config.ts#L8) is defined by:
+where the [MysqlModelConfig](https://github.com/travetto/travetto/tree/main/module/model-mysql/src/config.ts#L10) is defined by:
 
-**Code: Structure of SQLModelConfig**
+**Code: Structure of MysqlModelConfig**
 ```typescript
-@Config('model.sql')
-export class SQLModelConfig<T extends {} = {}> {
+@Config('model.mysql')
+export class MysqlModelConfig {
   /**
-   * 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
+   * Extended client options
    */
-  options: T = asFull({});
+  options?: PoolOptions;
 }
 ```
 

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,42 +1,45 @@
 {
   "name": "@travetto/model-mysql",
-  "version": "8.0.0-alpha.9",
-  "type": "module",
+  "version": "8.0.1",
   "description": "MySQL 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-mysql"
   },
   "files": [
     "__index__.ts",
     "src",
     "support"
   ],
+  "type": "module",
   "main": "__index__.ts",
-  "repository": {
-    "url": "git+https://github.com/travetto/travetto.git",
-    "directory": "module/model-mysql"
+  "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",
-    "mysql2": "^3.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",
+    "mysql2": "^3.24.3"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.14"
+    "@travetto/cli": "^8.0.1"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {
@@ -45,8 +48,5 @@
   },
   "travetto": {
     "displayName": "MySQL Model Service"
-  },
-  "publishConfig": {
-    "access": "public"
   }
 }

package/src/config.ts

@@ -0,0 +1,50 @@
+import type { PoolOptions } from 'mysql2';
+
+import { Config } from '@travetto/config';
+import { Runtime } from '@travetto/runtime';
+
+/**
+ * MySQL Model Configuration
+ */
+@Config('model.mysql')
+export class MysqlModelConfig {
+  /**
+   * 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;
+
+  /**
+   * Extended client options
+   */
+  options?: PoolOptions;
+}

package/src/connection.ts

@@ -1,52 +1,68 @@
 import { createPool } from 'mysql2';
-import type { PoolConnection, Pool, OkPacket, ResultSetHeader, TypeCastField } from 'mysql2/promise';
+import type { OkPacket, Pool, PoolConnection, ResultSetHeader, TypeCastField } from 'mysql2/promise';
 
-import { castTo, JSONUtil, ShutdownManager } from '@travetto/runtime';
 import type { AsyncContext } from '@travetto/context';
-import { ExistsError } from '@travetto/model';
-import { Connection, type SQLModelConfig } from '@travetto/model-sql';
+import { Injectable } from '@travetto/di';
+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';
+
+import type { MysqlModelConfig } from './config.ts';
+import { MysqlDialect } from './dialect.ts';
 
 function isSimplePacket(value: unknown): value is OkPacket | ResultSetHeader {
-  return value !== null && value !== undefined && typeof value === 'object' && 'constructor' in value && (
-    value.constructor.name === 'OkPacket' || value.constructor.name === 'ResultSetHeader'
+  return (
+    value !== null &&
+    value !== undefined &&
+    typeof value === 'object' &&
+    'constructor' in value &&
+    (value.constructor.name === 'OkPacket' || value.constructor.name === 'ResultSetHeader')
   );
 }
 
 /**
- * Connection support for mysql
+ * MySQL Connection Manager.
+ * Operates on mysql2 promise Pool.
  */
-export class MySQLConnection extends Connection<PoolConnection> {
-
-  #pool: Pool;
-  #config: SQLModelConfig;
+@Injectable()
+export class MysqlConnection extends SQLConnection<PoolConnection> {
+  readonly dialect = new MysqlDialect();
+  pool: Pool;
+  readonly config: MysqlModelConfig;
 
-  constructor(
-    context: AsyncContext,
-    config: SQLModelConfig
-  ) {
+  constructor(context: AsyncContext, config: MysqlModelConfig) {
     super(context);
-    this.#config = config;
+    this.config = config;
   }
 
+  /**
+   * Initializes the mysql2 connection pool
+   */
   async init(): Promise<void> {
-    this.#pool = createPool({
-      user: this.#config.user,
-      password: this.#config.password,
-      database: this.#config.database,
-      host: this.#config.host,
-      port: this.#config.port,
+    this.pool = createPool({
+      user: this.config.user,
+      password: this.config.password,
+      database: this.config.database,
+      host: this.config.host,
+      port: this.config.port,
       supportBigNumbers: true,
       timezone: '+00:00',
       typeCast: this.typeCast.bind(this),
-      ...(this.#config.options || {})
+      ...this.config.options
     }).promise();
 
-    // Close mysql
-    ShutdownManager.signal.addEventListener('abort', () => this.#pool.end());
+    ShutdownManager.signal.addEventListener('abort', () => this.pool.end());
+  }
+
+  getContext<T extends ModelType>(modelClass: Class<T>): TableContext<T> {
+    return {
+      ...super.getContext(modelClass),
+      database: this.config.database
+    };
   }
 
   /**
-   * Support some basic type support for JSON data
+   * Typecasting parser for JSON and BLOB mysql columns
    */
   typeCast(field: TypeCastField, next: () => unknown): unknown {
     const result = next();
@@ -56,7 +72,7 @@ export class MySQLConnection extends Connection<PoolConnection> {
         if (typeof result === 'string' && result.charAt(0) === '{' && result.charAt(result.length - 1) === '}') {
           try {
             return JSONUtil.fromUTF8(result);
-          } catch { }
+          } catch {}
         }
         break;
       }
@@ -64,41 +80,54 @@ export class MySQLConnection extends Connection<PoolConnection> {
     return result;
   }
 
-  async execute<T = unknown>(pool: PoolConnection, query: string, values?: unknown[]): Promise<{ count: number, records: T[] }> {
-    console.debug('Executing query', { query });
-    let prepared;
+  /**
+   * Acquires a PoolConnection from the pool
+   */
+  acquire(): Promise<PoolConnection> {
+    return this.pool.getConnection();
+  }
+
+  /**
+   * Releases a PoolConnection back to the pool
+   */
+  release(connection: PoolConnection): 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 MySQL query', { query, values });
+    const client = this.active ?? (await this.acquire());
     try {
-      prepared = (values?.length ?? 0) > 0 ? await pool.prepare(query) : undefined;
-      const [results,] = await (prepared ? prepared.execute(values) : pool.query(query));
+      const [results] = await client.execute(query, castTo(values ?? []));
       if (isSimplePacket(results)) {
         return { records: [], count: results.affectedRows };
+      } else if (isSimplePacket(results[0])) {
+        return { records: [], count: results[0].affectedRows };
       } else {
-        if (isSimplePacket(results[0])) {
-          return { records: [], count: results[0].affectedRows };
-        }
-        const records: T[] = [...results].map(value => castTo({ ...value }));
+        const records: Type[] = castTo(results);
         return { records, count: records.length };
       }
     } catch (error) {
-      console.debug('Failed query', { error, query });
       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_KEYNAME': throw new ExistsError('index', query);
-        default: throw error;
+        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:
+          throw error;
       }
     } finally {
-      try {
-        await prepared?.close();
-      } catch { }
+      if (!this.active) {
+        this.release(client);
+      }
     }
   }
-
-  acquire(): Promise<PoolConnection> {
-    return this.#pool.getConnection();
-  }
-
-  release(pool: PoolConnection): void {
-    pool.release();
-  }
-}
+}

package/src/dialect.ts

@@ -1,176 +1,228 @@
+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';
-import { Injectable } from '@travetto/di';
-import type { AsyncContext } from '@travetto/context';
-import type { WhereClause } from '@travetto/model-query';
-import { castTo, type Class } from '@travetto/runtime';
-import type { ModelType, IndexConfig } from '@travetto/model';
-import { type SQLModelConfig, SQLDialect, type VisitStack, type SQLTableDescription, SQLModelUtil } from '@travetto/model-sql';
-
-import { MySQLConnection } from './connection.ts';
-
-/**
- * MYSQL Dialect for the SQL Model Source
- */
-@Injectable()
-export class MySQLDialect extends SQLDialect {
-
-  connection: MySQLConnection;
-  tablePostfix = 'COLLATE=utf8mb4_bin ENGINE=InnoDB';
-
-  constructor(context: AsyncContext, config: SQLModelConfig) {
-    super(config.namespace);
-    this.connection = new MySQLConnection(context, config);
-
-    // Custom types
-    Object.assign(this.COLUMN_TYPES, {
-      TIMESTAMP: 'DATETIME(3)',
-      JSON: 'TEXT'
-    });
-
-    /**
-     * Set string length limit based on version
-     */
-    if (/^5[.][56]/.test(config.version)) {
-      this.DEFAULT_STRING_LENGTH = 191; // Mysql limitation with utf8 and keys
-    } else {
-      this.DEFAULT_STRING_LENGTH = 3072 / 4 - 1;
+
+export class MysqlDialect extends AbstractANSI99Dialect {
+  override returningSupport = false;
+
+  override escapeIdentifier(name: string): string {
+    return `\`${name.replaceAll('`', '``')}\``;
+  }
+
+  getComplexColumnType(field: SchemaFieldConfig): string {
+    return 'JSON';
+  }
+
+  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 'INT';
+        }
+        return 'BIGINT';
+      }
+      return 'INT';
     }
 
-    if (/^5[.].*/.test(config.version)) {
-      // Customer operators
-      Object.assign(this.SQL_OPS, {
-        $regex: 'REGEXP BINARY',
-        $iregex: 'REGEXP'
-      });
-
-      this.regexWordBoundary = '([[:<:]]|[[:>:]])';
-    } else {
-      // Customer operators
-      Object.assign(this.SQL_OPS, {
-        $regex: 'REGEXP',
-      });
-      // Double escape
-      this.regexWordBoundary = '\\\\b';
+    if (fieldConfiguration.type === Date) {
+      return 'DATETIME(6)';
     }
+
+    if (fieldConfiguration.type === Boolean) {
+      return 'TINYINT(1)';
+    }
+
+    if (fieldConfiguration.type === String) {
+      if (fieldConfiguration.specifiers?.includes('text')) {
+        return 'TEXT';
+      }
+      return `VARCHAR(${fieldConfiguration.maxlength?.limit ?? 767})`;
+    }
+
+    return 'JSON';
+  }
+
+  compileJsonIndexPath(columnName: string, jsonPath: string[], mode: JSONSqlPathMode): string {
+    return `${columnName}->>'$.${this.formatJsonPath(jsonPath)}'`;
   }
 
-  /**
-   * Compute hash
-   */
-  hash(value: string): string {
-    return `SHA2('${value}', '256')`;
-  }
-
-  /**
-   * Get DROP INDEX sql
-   */
-  getDropIndexSQL<T extends ModelType>(cls: Class<T>, idx: IndexConfig<T> | string): string {
-    const constraint = typeof idx === 'string' ? idx : this.getIndexName(cls, idx);
-    return `DROP INDEX ${this.identifier(constraint)} ON ${this.table(SQLModelUtil.classToStack(cls))};`;
-  }
-
-  async describeTable(table: string): Promise<SQLTableDescription | undefined> {
-    const IGNORE_FIELDS = [this.pathField.name, this.parentPathField.name, this.idxField.name].map(field => `'${field}'`);
-    const [columns, foreignKeys, indices] = await Promise.all([
-      // 1. Columns
-      this.executeSQL<{ name: string, type: string, is_not_null: boolean }>(`
-      SELECT 
-        COLUMN_NAME AS name, 
-        COLUMN_TYPE AS type, 
-        IS_NULLABLE <> 'YES' AS is_not_null
-      FROM information_schema.COLUMNS 
-      WHERE TABLE_NAME = '${table}' 
-      AND TABLE_SCHEMA = DATABASE()
-      AND COLUMN_NAME NOT IN (${IGNORE_FIELDS.join(',')})
-      ORDER BY ORDINAL_POSITION
-    `),
-
-      // 2. Foreign Keys
-      this.executeSQL<{ name: string, from_column: string, to_column: string, to_table: string }>(`
-      SELECT 
-        CONSTRAINT_NAME AS name, 
-        COLUMN_NAME AS from_column, 
-        REFERENCED_COLUMN_NAME AS to_column, 
-        REFERENCED_TABLE_NAME AS to_table
-      FROM information_schema.KEY_COLUMN_USAGE 
-      WHERE TABLE_NAME = '${table}' 
-      AND TABLE_SCHEMA = DATABASE()
-      AND REFERENCED_TABLE_NAME IS NOT NULL
-    `),
-
-      // 3. Indices
-      this.executeSQL<{ name: string, is_unique: number, columns: string }>(`
-      SELECT 
-        stat.INDEX_NAME AS name, 
-        stat.NON_UNIQUE = 0 AS is_unique, 
-        GROUP_CONCAT(CONCAT(stat.COLUMN_NAME, ' ', stat.COLLATION, ' ') ORDER BY stat.SEQ_IN_INDEX) AS columns
-      FROM information_schema.STATISTICS stat
-      LEFT OUTER JOIN information_schema.TABLE_CONSTRAINTS AS tc
-        ON tc.CONSTRAINT_NAME = stat.INDEX_NAME
-        AND tc.TABLE_NAME = stat.TABLE_NAME
-        AND tc.TABLE_SCHEMA = stat.TABLE_SCHEMA
-      WHERE 
-        stat.TABLE_NAME = '${table}' 
-        AND stat.TABLE_SCHEMA = DATABASE()
-        AND tc.CONSTRAINT_TYPE IS NULL
-        AND stat.COLUMN_NAME NOT IN (${IGNORE_FIELDS.join(',')})
-      GROUP BY stat.INDEX_NAME, stat.NON_UNIQUE
-    `)
-    ]);
-
-    if (!columns.count) {
-      return undefined;
+  #formatSubPath(context: ResolvedPathContext): string {
+    if (!context.subPath || context.subPath.length === 0) {
+      return '';
     }
+    const subPathMetadata = this.getSchemaSubPathMetadata(context.arrayField?.type, context.subPath);
+    return subPathMetadata.map(({ segment, isArray }) => (isArray ? `${segment}[*]` : segment)).join('.');
+  }
+
+  #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 formattedSubPath = this.#formatSubPath(context);
+    const jsonPathExpr = arrayPathPart ? `$.${arrayPathPart}[*].${formattedSubPath}` : `$[*].${formattedSubPath}`;
+    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(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(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(context: ResolvedPathContext, identifier?: string): { sql: string } {
+    const targetSqlPath = this.#getArraySqlPath(context);
+    return { sql: `(${targetSqlPath} IS NOT NULL AND JSON_LENGTH(${targetSqlPath}) > 0)` };
+  }
+
+  compileArrayRegex(context: ResolvedPathContext, identifier: string, value: RegExp | string): { sql: string; formatted: unknown } {
+    const targetSqlPath = this.#getArraySqlPath(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);
 
     return {
-      columns: columns.records.map(col => ({
-        ...col,
-        type: col.type.toUpperCase(),
-        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
-          .split(',')
-          .map(column => column.split(' '))
-          .map(([name, desc]) => ({ name, desc: desc === 'D' }))
-      }))
+      sql: `EXISTS (SELECT 1 FROM JSON_TABLE(${targetSqlPath}, '$[*]' COLUMNS (val VARCHAR(255) PATH '$')) AS jt WHERE jt.val ${regexOp} ${identifier})`,
+      formatted: regexSource
     };
   }
 
-  /**
-   * Create table, adding in specific engine options
-   */
-  override getCreateTableSQL(stack: VisitStack[]): string {
-    return super.getCreateTableSQL(stack).replace(/;$/, ` ${this.tablePostfix};`);
+  compileJsonEquality(sqlPath: string, identifier: string): string {
+    return `CAST(${sqlPath} AS JSON) = CAST(${identifier} AS JSON)`;
   }
 
-  /**
-   * Define column modification
-   */
-  getModifyColumnSQL(stack: VisitStack[]): string {
-    const field: SchemaFieldConfig = castTo(stack.at(-1));
-    return `ALTER TABLE ${this.parentTable(stack)} MODIFY COLUMN ${this.getColumnDefinition(field)};`;
+  getRegexOperator(caseInsensitive: boolean): string {
+    return caseInsensitive ? 'REGEXP' : 'COLLATE utf8mb4_bin REGEXP';
   }
 
-  /**
-   * Add root alias to delete clause
-   */
-  override getDeleteSQL(stack: VisitStack[], where?: WhereClause<unknown>): string {
-    const sql = super.getDeleteSQL(stack, where);
-    return sql.replace(/\bDELETE\b/g, `DELETE ${this.rootAlias}`);
+  formatRegex(source: string, caseInsensitive: boolean): string {
+    return source;
   }
 
-  /**
-   * Suppress foreign key checks
-   */
-  override getTruncateAllTablesSQL<T extends ModelType>(cls: Class<T>): string[] {
-    return [
-      'SET FOREIGN_KEY_CHECKS = 0;',
-      ...super.getTruncateAllTablesSQL(cls),
-      'SET FOREIGN_KEY_CHECKS = 1;'
-    ];
+  castColumn(sqlPath: string, type: Class): string {
+    if (type === Number) {
+      return `CAST(${sqlPath} AS DECIMAL)`;
+    } else if (type === Boolean) {
+      return `CAST(${sqlPath} AS SIGNED)`;
+    } else if (type === Date) {
+      return `CAST(${sqlPath} AS DATETIME(6))`;
+    } else if (type === String) {
+      return `(CAST(${sqlPath} AS CHAR(255)) COLLATE utf8mb4_bin)`;
+    }
+    return sqlPath;
+  }
+
+  override getUpsertSQL(
+    context: TableContext,
+    columns: string[],
+    placeholders: string[],
+    conflictTarget: string[],
+    updates: string[]
+  ): string {
+    const mysqlUpdateStatements = updates.map(statement => statement.replaceAll(/EXCLUDED\.(.*)/g, 'new_row.$1'));
+    return `INSERT INTO ${this.escapeIdentifier(context.tableName)} (${columns.join(', ')}) VALUES (${placeholders.join(', ')}) AS new_row ON DUPLICATE KEY UPDATE ${mysqlUpdateStatements.join(', ')};`;
+  }
+
+  getTableExistsQuery(context: TableContext): { sql: string; parameters?: unknown[] } {
+    return {
+      sql: `
+SELECT 
+  COUNT(*) as total 
+FROM information_schema.tables 
+WHERE table_schema = ? AND table_name = ?;
+`,
+      parameters: [context.database, context.tableName]
+    };
+  }
+
+  parseTableExistsResult(records: unknown[]): boolean {
+    return Number(castTo<{ total: number }>(records[0])?.total ?? 0) > 0;
+  }
+
+  getExistingColumnsQuery(context: TableContext): { sql: string; parameters?: unknown[] } {
+    return {
+      sql: `
+SELECT 
+  COLUMN_NAME as name, 
+  COLUMN_TYPE as type 
+FROM information_schema.columns 
+WHERE table_schema = ? AND table_name = ?;
+`,
+      parameters: [context.database, context.tableName]
+    };
+  }
+
+  parseExistingColumns(records: unknown[]): Map<string, string> {
+    return new Map(castTo<{ name: string; type: string }[]>(records).map(record => [record.name, record.type.toUpperCase()]));
+  }
+
+  getExistingIndexesQuery(context: TableContext): { sql: string; parameters?: unknown[] } {
+    return {
+      sql: `
+SELECT 
+  INDEX_NAME as name,
+  TABLE_NAME as tableName,
+  NON_UNIQUE as nonUnique,
+  GROUP_CONCAT(COALESCE(EXPRESSION, COLUMN_NAME) ORDER BY SEQ_IN_INDEX SEPARATOR ', ') as indexColumns
+FROM information_schema.statistics 
+WHERE 
+  table_schema = ? 
+  AND table_name = ? 
+  AND INDEX_NAME != 'PRIMARY'
+GROUP BY INDEX_NAME, TABLE_NAME, NON_UNIQUE;
+`,
+      parameters: [context.database, context.tableName]
+    };
+  }
+
+  parseExistingIndexes(records: unknown[]): Map<string, string> {
+    return new Map(
+      castTo<{ name: string; tableName: string; nonUnique: number; indexColumns: string }[]>(records).map(record => {
+        const isUnique = Number(record.nonUnique) === 0;
+        const indexDefinition = `CREATE ${isUnique ? 'UNIQUE ' : ''}INDEX ${this.escapeIdentifier(record.name)} ON ${this.escapeIdentifier(record.tableName)} (${record.indexColumns});`;
+        return [record.name, indexDefinition];
+      })
+    );
+  }
+
+  override getDropIndexSQL(context: TableContext, indexName: string): string {
+    return `DROP INDEX ${this.escapeIdentifier(indexName)} ON ${this.escapeIdentifier(context.tableName)};`;
+  }
+
+  override getTruncateTableSQL(context: TableContext): string {
+    return `TRUNCATE TABLE ${this.escapeIdentifier(context.tableName)};`;
+  }
+
+  override getAlterColumnTypeSQL(context: TableContext, columnName: string, columnType: string, existingType: string): string | undefined {
+    const normalizedExisting = existingType.replaceAll('CHARACTER VARYING', 'VARCHAR').replaceAll('INTEGER', 'INT');
+    const normalizedRequested = columnType.toUpperCase().replaceAll('CHARACTER VARYING', 'VARCHAR').replaceAll('INTEGER', 'INT');
+
+    if (!normalizedExisting.startsWith(normalizedRequested) && !normalizedRequested.startsWith(normalizedExisting)) {
+      return `ALTER TABLE ${this.escapeIdentifier(context.tableName)} MODIFY COLUMN ${this.escapeIdentifier(columnName)} ${columnType};`;
+    }
+    return undefined;
   }
-}
+}

package/src/service.ts

@@ -0,0 +1,28 @@
+import type { PoolConnection } from 'mysql2/promise';
+
+import { Injectable, PostConstruct } from '@travetto/di';
+import { BaseSQLModelService } from '@travetto/model-sql';
+
+import type { MysqlConnection } from './connection.ts';
+
+/**
+ * A MySQL JSON-based document store model service
+ */
+@Injectable()
+export class MysqlModelService extends BaseSQLModelService {
+  connection: MysqlConnection;
+
+  constructor(connection: MysqlConnection) {
+    super();
+    this.connection = connection;
+  }
+
+  get client(): PoolConnection {
+    return this.connection.active!;
+  }
+
+  @PostConstruct()
+  override async initialize(): Promise<void> {
+    await super.initialize();
+  }
+}

package/support/service.mysql.ts

@@ -1,16 +1,19 @@
 import type { ServiceDescriptor } from '@travetto/cli';
 
-const version = process.env.MYSQL_VERSION || '9.6';
+const version = process.env.MYSQL_VERSION || '9.7';
+
+/* cspell:words innodb binlog */
 
 export const service: ServiceDescriptor = {
   name: 'mysql',
   version,
   image: `mysql:${version}`,
   port: 3306,
+  args: ['--skip-name-resolve', '--innodb-flush-log-at-trx-commit=0', '--sync-binlog=0'],
   env: {
     MYSQL_RANDOM_ROOT_PASSWORD: '1',
     MYSQL_PASSWORD: 'travetto',
     MYSQL_USER: 'travetto',
     MYSQL_DATABASE: 'app'
-  },
-};
+  }
+};