@travetto/model-mysql 8.0.0-alpha.3 → 8.0.0-alpha.30

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

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 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;
+import { AbstractANSI99Dialect, type JSONSqlPathMode, 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 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 (fieldConfiguration.type === Date) {
+      return 'DATETIME(6)';
     }
 
-    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 === Boolean) {
+      return 'TINYINT(1)';
     }
+
+    if (fieldConfiguration.type === String) {
+      if (fieldConfiguration.specifiers?.includes('text')) {
+        return 'TEXT';
+      }
+      return `VARCHAR(${fieldConfiguration.maxlength?.limit ?? 767})`;
+    }
+
+    return 'JSON';
   }
 
-  /**
-   * 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;
+  compileJsonIndexPath(columnName: string, jsonPath: string[], mode: JSONSqlPathMode): string {
+    const result = `${columnName}->>'$.${jsonPath.join('.')}'`;
+    switch (mode) {
+      case 'createIndex':
+        return `(CAST(${result} as CHAR(255)) COLLATE utf8mb4_bin)`;
+      case 'orderBy':
+      case 'read':
+        return result;
     }
+  }
+
+  #formatSubPath(context: ResolvedPathContext): string {
+    if (!context.subPath || context.subPath.length === 0) {
+      return '';
+    }
+    let currentClass: Class | undefined = context.arrayField?.type;
+    const parts: string[] = [];
+    for (let index = 0; index < context.subPath.length; index++) {
+      const segment = context.subPath[index];
+      if (currentClass) {
+        const classConfig = SchemaRegistryIndex.getOptional(currentClass)?.get();
+        const fieldConfig = classConfig?.fields[segment];
+        if (fieldConfig) {
+          parts.push(fieldConfig.array ? `${segment}[*]` : segment);
+          currentClass = fieldConfig.type;
+          continue;
+        }
+      }
+      parts.push(segment);
+    }
+    return parts.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 {
+      sql: `EXISTS (SELECT 1 FROM JSON_TABLE(${targetSqlPath}, '$[*]' COLUMNS (val VARCHAR(255) PATH '$')) AS jt WHERE jt.val ${regexOp} ${identifier})`,
+      formatted: regexSource
+    };
+  }
+
+  compileJsonEquality(sqlPath: string, identifier: string): string {
+    return `CAST(${sqlPath} AS JSON) = CAST(${identifier} AS JSON)`;
+  }
+
+  getRegexOperator(caseInsensitive: boolean): string {
+    return caseInsensitive ? 'REGEXP' : 'COLLATE utf8mb4_bin REGEXP';
+  }
+
+  formatRegex(source: string, caseInsensitive: boolean): string {
+    return source;
+  }
+
+  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))`;
+    }
+    return sqlPath;
+  }
+
+  override getUpsertSQL(
+    context: TableContext,
+    columns: string[],
+    placeholders: string[],
+    conflictTarget: string[],
+    updates: string[]
+  ): string {
+    const mysqlUpdates = updates.map(val => val.replace(/EXCLUDED\.(.*)/g, 'VALUES($1)'));
+    return `
+INSERT INTO 
+  ${this.escapeIdentifier(context.tableName)} (${columns.join(', ')}) 
+VALUES 
+  (${placeholders.join(', ')}) 
+ON DUPLICATE KEY UPDATE ${mysqlUpdates.join(', ')};`;
+  }
+
+  getTableExistsQuery(context: TableContext): { sql: string; parameters?: unknown[] } {
     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: `
+SELECT 
+  COUNT(*) as total 
+FROM information_schema.tables 
+WHERE table_schema = ? AND table_name = ?;
+`,
+      parameters: [context.database, context.tableName]
     };
   }
 
-  /**
-   * Create table, adding in specific engine options
-   */
-  override getCreateTableSQL(stack: VisitStack[]): string {
-    return super.getCreateTableSQL(stack).replace(/;$/, ` ${this.tablePostfix};`);
+  parseTableExistsResult(records: unknown[]): boolean {
+    return Number(castTo<{ total: number }>(records[0])?.total ?? 0) > 0;
   }
 
-  /**
-   * 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)};`;
+  getExistingColumnsQuery(context: TableContext): { sql: string; parameters?: unknown[] } {
+    return {
+      sql: `
+SELECT 
+  COLUMN_NAME as name, 
+  DATA_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 DISTINCT 
+  INDEX_NAME as name 
+FROM information_schema.statistics 
+WHERE 
+  table_schema = ? 
+  AND table_name = ? 
+  AND INDEX_NAME != 'PRIMARY';
+`,
+      parameters: [context.database, context.tableName]
+    };
   }
 
-  /**
-   * 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}`);
+  parseExistingIndexes(records: unknown[]): Map<string, string> {
+    return new Map(castTo<{ name: string }[]>(records).map(record => [record.name, '']));
   }
 
-  /**
-   * 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;'
-    ];
+  override getDropIndexSQL(context: TableContext, indexName: string): string {
+    return `DROP INDEX ${this.escapeIdentifier(indexName)} ON ${this.escapeIdentifier(context.tableName)};`;
   }
-}
+}

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

@@ -7,10 +7,11 @@ export const service: ServiceDescriptor = {
   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'
-  },
-};
+  }
+};