@travetto/model-mysql 8.0.0-alpha.25 → 8.0.0-alpha.26

package/README.md

@@ -13,13 +13,14 @@ 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#L69) 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:
    *  [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 +31,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 { MySQLDialect } from '@travetto/model-mysql';
-import { type SQLModelConfig, SQLModelService } from '@travetto/model-sql';
+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/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-mysql",
-  "version": "8.0.0-alpha.25",
+  "version": "8.0.0-alpha.26",
   "type": "module",
   "description": "MySQL backing for the travetto model module, with real-time modeling support for SQL schemas.",
   "keywords": [
@@ -32,7 +32,7 @@
     "@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/model-sql": "^8.0.0-alpha.26",
     "mysql2": "^3.22.6"
   },
   "peerDependencies": {

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,10 +1,14 @@
 import { createPool } from 'mysql2';
-import type { OkPacket, Pool, PoolConnection, PreparedStatementInfo, ResultSetHeader, TypeCastField } from 'mysql2/promise';
+import type { OkPacket, Pool, PoolConnection, ResultSetHeader, TypeCastField } from 'mysql2/promise';
 
 import type { AsyncContext } from '@travetto/context';
-import { ExistsError } from '@travetto/model';
-import { Connection, type SQLModelConfig } from '@travetto/model-sql';
-import { castTo, JSONUtil, ShutdownManager } from '@travetto/runtime';
+import { Injectable } from '@travetto/di';
+import { ExistsError, type ModelType } 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 (
@@ -17,36 +21,48 @@ function isSimplePacket(value: unknown): value is OkPacket | 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();
@@ -64,23 +80,37 @@ 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: PreparedStatementInfo | undefined;
+  /**
+   * 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':
@@ -91,17 +121,9 @@ export class MySQLConnection extends Connection<PoolConnection> {
           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,171 +1,195 @@
-import type { AsyncContext } from '@travetto/context';
-import { Injectable } from '@travetto/di';
-import type { IndexConfig, ModelType } from '@travetto/model';
-import type { WhereClause } from '@travetto/model-query';
-import { SQLDialect, type SQLModelConfig, SQLModelUtil, type SQLTableDescription, type VisitStack } from '@travetto/model-sql';
-import { type Class, castTo } from '@travetto/runtime';
+import { AbstractANSI99Dialect, type JSONSqlPathMode, type TableContext } from '@travetto/model-sql';
+import { type Class, castTo, JSONUtil } from '@travetto/runtime';
 import type { SchemaFieldConfig } from '@travetto/schema';
 
-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 (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})`;
     }
 
-    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';
+    return 'JSON';
+  }
+
+  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;
     }
   }
 
-  /**
-   * Compute hash
-   */
-  hash(value: string): string {
-    return `SHA2('${value}', '256')`;
-  }
-
-  /**
-   * Get DROP INDEX sql
-   */
-  getDropIndexSQL<T extends ModelType>(cls: Class<T>, idx: IndexConfig | 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 OR tc.CONSTRAINT_TYPE = 'UNIQUE')
-        AND stat.COLUMN_NAME NOT IN (${IGNORE_FIELDS.join(',')})
-      GROUP BY stat.INDEX_NAME, stat.NON_UNIQUE
-    `)
-    ]);
-
-    if (!columns.count) {
-      return undefined;
+  compileArrayAll(
+    sqlPath: string,
+    identifier: string,
+    value: unknown[],
+    field: SchemaFieldConfig,
+    topLevel?: boolean
+  ): { sql: string; formatted: unknown } {
+    return { sql: `JSON_CONTAINS(${sqlPath}, ${identifier})`, formatted: JSONUtil.toUTF8(value) };
+  }
+
+  compileArrayEquals(
+    sqlPath: string,
+    identifier: string,
+    values: unknown,
+    field: SchemaFieldConfig,
+    topLevel?: boolean
+  ): { sql: string; formatted: unknown } {
+    return { sql: `JSON_CONTAINS(${sqlPath}, ${identifier})`, formatted: JSONUtil.toUTF8(values) };
+  }
+
+  compileArrayAny(
+    sqlPath: string,
+    identifier: string,
+    values: unknown[],
+    field: SchemaFieldConfig,
+    topLevel?: boolean
+  ): { sql: string; formatted: unknown } {
+    return { sql: `JSON_OVERLAPS(${sqlPath}, ${identifier})`, formatted: JSONUtil.toUTF8(values) };
+  }
+
+  compileArrayExists(sqlPath: string, identifier: string, field: SchemaFieldConfig, topLevel?: boolean): { sql: string } {
+    return { sql: `(${sqlPath} IS NOT NULL AND JSON_LENGTH(${sqlPath}) > 0)` };
+  }
+
+  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 {
+      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 {
-      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 
+  COLUMN_NAME as name, 
+  DATA_TYPE as type 
+FROM information_schema.columns 
+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};`);
+  parseExistingColumns(records: unknown[]): Map<string, string> {
+    return new Map(castTo<{ name: string; type: string }[]>(records).map(record => [record.name, record.type.toUpperCase()]));
   }
 
-  /**
-   * 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)};`;
+  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,6 +7,7 @@ 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',