@travetto/model-sql 2.2.6 → 3.0.0-rc.2

package/README.md

@@ -10,109 +10,29 @@ npm install @travetto/model-sql
 
 **Install: Specific SQL Client: mysql**
 ```bash
-npm install mysql
+npm install @travetto/model-mysql
 ```
 
 or 
 
-**Install: Specific SQL Client: postgres**
+**Install: Specific SQL Client: mysql**
 ```bash
-npm install pg
+npm install @travetto/model-postgres
 ```
 
-This module provides a [SQL](https://en.wikipedia.org/wiki/SQL)-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#L38) will also modify the database schema in real time to minimize impact to development.
+or 
 
-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.
+**Install: Specific SQL Client: mysql**
+```bash
+npm install @travetto/model-sqlite
+```
 
 The current SQL client support stands at:
    
    *  [MySQL](https://www.mysql.com/) - 5.6 and 5.7
    *  [Postgres](https://postgresql.org) - 11+
+   *  [SQLite](https://www.sqlite.org/) - (bettersqlite 7.6+)
    *  `SQL Server` - Currently unsupported
    *  `Oracle` - Currently unsupported
 
 **Note**: Wider client support will roll out as usage increases.
-
-Supported features:
-   
-   *  [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/service/crud.ts#L11)
-   *  [Bulk](https://github.com/travetto/travetto/tree/main/module/model/src/service/bulk.ts#L23)
-   *  [Query Crud](https://github.com/travetto/travetto/tree/main/module/model-query/src/service/crud.ts#L11)
-   *  [Facet](https://github.com/travetto/travetto/tree/main/module/model-query/src/service/facet.ts#L12)
-   *  [Query](https://github.com/travetto/travetto/tree/main/module/model-query/src/service/query.ts#L10)
-   *  [Suggest](https://github.com/travetto/travetto/tree/main/module/model-query/src/service/suggest.ts#L12)
-
-    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 { AsyncContext } from '@travetto/context';
-import { InjectableFactory } from '@travetto/di';
-
-import { SQLModelService, SQLModelConfig } from '@travetto/model-sql';
-import { MySQLDialect } from '@travetto/model-sql/src/dialect/mysql/dialect';
-
-export class Init {
-  @InjectableFactory({ primary: true })
-  static getModelService(ctx: AsyncContext, conf: SQLModelConfig) {
-    return new SQLModelService(ctx, conf, new MySQLDialect(ctx, conf));
-  }
-}
-```
-
-  where the [SQLModelConfig](https://github.com/travetto/travetto/tree/main/module/model-sql/src/config.ts#L7) is defined by:
-
-  
-**Code: Structure of SQLModelConfig**
-```typescript
-import { Config } from '@travetto/config';
-
-/**
- * SQL Model Config
- */
-@Config('model.sql')
-export class SQLModelConfig {
-  /**
-   * Host to connect to
-   */
-  host = '127.0.0.1';
-  /**
-   * Default port
-   */
-  port = 0;
-  /**
-   * Username
-   */
-  user = '';
-  /**
-   * Password
-   */
-  password = '';
-  /**
-   * Table prefix
-   */
-  namespace = '';
-  /**
-   * Database name
-   */
-  database = 'app';
-  /**
-   * Auto schema creation
-   */
-  autoCreate?: boolean;
-  /**
-   * Db version
-   */
-  version = '';
-  /**
-   * Raw client options
-   */
-  options = {};
-}
-```
-
-  Additionally, you can see that the class is registered with the [@Config](https://github.com/travetto/travetto/tree/main/module/config/src/decorator.ts#L9) annotation, and so these values can be overridden using the 
-  standard [Configuration](https://github.com/travetto/travetto/tree/main/module/config#readme "Environment-aware config management using yaml files")resolution paths.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@travetto/model-sql",
   "displayName": "SQL Model Service",
-  "version": "2.2.6",
+  "version": "3.0.0-rc.2",
   "description": "SQL backing for the travetto model module, with real-time modeling support for SQL schemas.",
   "keywords": [
     "sql",
@@ -20,7 +20,8 @@
   "files": [
     "index.ts",
     "src",
-    "support"
+    "support",
+    "test-support"
   ],
   "main": "index.ts",
   "repository": {
@@ -28,21 +29,16 @@
     "directory": "module/model-sql"
   },
   "dependencies": {
-    "@travetto/config": "^2.2.4",
-    "@travetto/context": "^2.2.6",
-    "@travetto/model": "^2.2.4",
-    "@travetto/model-query": "2.2.4"
+    "@travetto/config": "^3.0.0-rc.2",
+    "@travetto/context": "^3.0.0-rc.2",
+    "@travetto/model": "^3.0.0-rc.2",
+    "@travetto/model-query": "3.0.0-rc.2"
   },
   "devDependencies": {
-    "@travetto/app": "^2.2.5"
+    "@travetto/app": "^3.0.0-rc.2"
   },
-  "optionalPeerDependencies": {
-    "@types/mysql": "^2.15.21",
-    "@types/pg": "^8.6.5",
-    "mysql": "^2.18.1",
-    "pg": "^8.7.3",
-    "better-sqlite3": "^7.6.2",
-    "@types/better-sqlite3": "^7.6.0"
+  "docDependencies": {
+    "@travetto/model-mysql": 1
   },
   "publishConfig": {
     "access": "public"

package/src/internal/util.ts

@@ -230,15 +230,15 @@ export class SQLUtil {
 
     for (const [k, v] of Object.entries(select)) {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const typedKey = k as keyof typeof select;
-      if (!Util.isPlainObject(select[typedKey]) && localMap[k]) {
+      const sk = k as string;
+      if (!Util.isPlainObject(select[k]) && localMap[sk]) {
         if (!v) {
           if (toGet.size === 0) {
             toGet = new Set(SchemaRegistry.get(cls).views[AllViewⲐ].fields);
           }
-          toGet.delete(k);
+          toGet.delete(sk);
         } else {
-          toGet.add(k);
+          toGet.add(sk);
         }
       }
     }

package/test-support/query.ts

@@ -0,0 +1,102 @@
+import * as assert from 'assert';
+
+import { Schema, FieldConfig } from '@travetto/schema';
+import { Suite, Test } from '@travetto/test';
+import { BaseModelSuite } from '@travetto/model/test-support/base';
+
+import { VisitStack } from '../src/internal/util';
+import { SQLModelService } from '../src/service';
+
+@Schema()
+class User {
+  id: string;
+  name: string;
+}
+
+@Schema()
+class WhereTypeAB {
+  c: number;
+}
+
+@Schema()
+class WhereTypeA {
+  d: number;
+  b: WhereTypeAB;
+}
+
+@Schema()
+class WhereTypeD {
+  e: boolean;
+}
+
+@Schema()
+class WhereTypeG {
+  z: string[];
+}
+
+@Schema()
+class WhereType {
+  a: WhereTypeA[];
+  d: WhereTypeD;
+  g: WhereTypeG;
+  name: number;
+  age: number;
+}
+
+@Suite()
+export abstract class BaseSQLTest extends BaseModelSuite<SQLModelService> {
+
+  get dialect() {
+    return this.service.then(s => s.client);
+  }
+
+  @Test()
+  async validateQuery() {
+    const qry = {
+      $and: [
+        { a: { b: { c: 5 } } },
+        { d: { e: true } },
+        {
+          $or: [{ name: 5 }, { age: 10 }]
+        },
+        { g: { z: { $in: ['a', 'b', 'c'] } } },
+        { a: { d: { $gt: 20 } } }
+      ]
+    };
+
+    const dct = await this.dialect;
+    dct.resolveName = (stack: VisitStack[]) => {
+      const field = stack[stack.length - 1] as FieldConfig;
+      const parent = stack[stack.length - 2] as FieldConfig;
+      return `${field.owner ? field.owner.name : parent.name}.${field.name}`;
+    };
+
+    const qryStr = dct.getWhereGroupingSQL(WhereType, qry);
+    assert(qryStr === "(WhereTypeAB.c = 5 AND WhereTypeD.e = TRUE AND (WhereType.name = 5 OR WhereType.age = 10) AND z.z IN ('a','b','c') AND WhereTypeA.d > 20)");
+  }
+
+  @Test()
+  async testRegEx() {
+    const dct = await this.dialect;
+    dct.resolveName = (stack: VisitStack[]) => {
+      const field = stack[stack.length - 1] as FieldConfig;
+      return `${field.owner?.name}.${field.name}`;
+    };
+
+    const out = dct.getWhereGroupingSQL(User, {
+      name: {
+        $regex: /google.$/
+      }
+    });
+
+    assert(out === `User.name ${dct.SQL_OPS.$regex} 'google.$'`);
+
+    const outBoundary = dct.getWhereGroupingSQL(User, {
+      name: {
+        $regex: /\bgoogle\b/
+      }
+    });
+
+    assert(outBoundary === `User.name ${dct.SQL_OPS.$regex} '${dct.regexWordBoundary}google${dct.regexWordBoundary}'`);
+  }
+}

package/src/dialect/mysql/connection.ts

@@ -1,85 +0,0 @@
-// @file-if mysql
-import * as mysql from 'mysql';
-
-import { ShutdownManager } from '@travetto/base';
-import { AsyncContext } from '@travetto/context';
-import { ExistsError } from '@travetto/model/src/error/exists';
-
-import { Connection } from '../../connection/base';
-import { SQLModelConfig } from '../../config';
-
-/**
- * Connection support for mysql
- */
-export class MySQLConnection extends Connection<mysql.PoolConnection> {
-
-  #pool: mysql.Pool;
-  #config: SQLModelConfig;
-
-  constructor(
-    context: AsyncContext,
-    config: SQLModelConfig
-  ) {
-    super(context);
-    this.#config = config;
-  }
-
-  async init(): Promise<void> {
-    this.#pool = mysql.createPool({
-      user: this.#config.user,
-      password: this.#config.password,
-      database: this.#config.database,
-      host: this.#config.host,
-      port: this.#config.port,
-      timezone: 'utc',
-      typeCast: this.typeCast.bind(this),
-      ...(this.#config.options || {})
-    });
-
-    // Close mysql
-    ShutdownManager.onShutdown(this.constructor.ᚕid, () => new Promise(r => this.#pool.end(r)));
-  }
-
-  /**
-   * Support some basic type support for JSON data
-   */
-  typeCast(field: Parameters<Exclude<mysql.TypeCast, boolean>>[0], next: () => unknown): unknown {
-    const res = next();
-    if (typeof res === 'string' && (field.type === 'JSON' || field.type === 'BLOB')) {
-      if (res.charAt(0) === '{' && res.charAt(res.length - 1) === '}') {
-        try {
-          return JSON.parse(res);
-        } catch { }
-      }
-    }
-    return res;
-  }
-
-  async execute<T = unknown>(conn: mysql.Connection, query: string): Promise<{ count: number, records: T[] }> {
-    return new Promise<{ count: number, records: T[] }>((res, rej) => {
-      console.debug('Executing Query', { query });
-      conn.query(query, (err, results, fields) => {
-        if (err) {
-          console.debug('Failed query', { error: err, query });
-          if (err.message.startsWith('ER_DUP_ENTRY')) {
-            rej(new ExistsError('query', query));
-          } else {
-            rej(err);
-          }
-        } else {
-          const records: T[] = Array.isArray(results) ? [...results].map(v => ({ ...v })) : [{ ...results }];
-          res({ records, count: results.affectedRows });
-        }
-      });
-    });
-  }
-
-  acquire(): Promise<mysql.PoolConnection> {
-    return new Promise<mysql.PoolConnection>((res, rej) =>
-      this.#pool.getConnection((err, conn) => err ? rej(err) : res(conn)));
-  }
-
-  release(conn: mysql.PoolConnection): void {
-    conn.release();
-  }
-}

package/src/dialect/mysql/dialect.ts

@@ -1,100 +0,0 @@
-// @file-if mysql
-import { FieldConfig } from '@travetto/schema';
-import { Injectable } from '@travetto/di';
-import { AsyncContext } from '@travetto/context';
-import { WhereClause } from '@travetto/model-query';
-import { Class } from '@travetto/base';
-import { ModelType } from '@travetto/model';
-
-import { SQLModelConfig } from '../../config';
-import { SQLDialect } from '../base';
-import { VisitStack } from '../../internal/util';
-import { MySQLConnection } from './connection';
-
-/**
- * MYSQL Dialect for the SQL Model Source
- */
-@Injectable()
-export class MySQLDialect extends SQLDialect {
-
-  conn: MySQLConnection;
-  tablePostfix = "COLLATE='utf8mb4_unicode_ci' ENGINE=InnoDB";
-
-  constructor(context: AsyncContext, public config: SQLModelConfig) {
-    super(config.namespace);
-    this.conn = new MySQLConnection(context, config);
-
-    // Customer operators
-    Object.assign(this.SQL_OPS, {
-      $regex: 'REGEXP BINARY',
-      $iregex: 'REGEXP'
-    });
-
-    // Custom types
-    Object.assign(this.COLUMN_TYPES, {
-      TIMESTAMP: 'DATETIME(3)',
-      JSON: 'TEXT'
-    });
-
-    // Word boundary
-    this.regexWordBoundary = '([[:<:]]|[[:>:]])';
-    // Field maxlength
-    this.idField.minlength = this.idField.maxlength = { n: this.KEY_LEN };
-
-    /**
-     * Set string length limit based on version
-     */
-    if (/^5[.][56]/.test(this.config.version)) {
-      this.DEFAULT_STRING_LEN = 191; // Mysql limitation with utf8 and keys
-    }
-  }
-
-  /**
-   * Compute hash
-   */
-  hash(value: string): string {
-    return `SHA2('${value}', ${this.KEY_LEN * 4})`;
-  }
-
-  /**
-   * Build identifier
-   */
-  ident(field: FieldConfig | string): string {
-    return `\`${typeof field === 'string' ? field : field.name}\``;
-  }
-
-  /**
-   * Create table, adding in specific engine options
-   */
-  override getCreateTableSQL(stack: VisitStack[]): string {
-    return super.getCreateTableSQL(stack).replace(/;$/, ` ${this.tablePostfix};`);
-  }
-
-  /**
-   * Define column modification
-   */
-  getModifyColumnSQL(stack: VisitStack[]): string {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const field = stack[stack.length - 1] as FieldConfig;
-    return `ALTER TABLE ${this.parentTable(stack)} MODIFY COLUMN ${this.getColumnDefinition(field)};`;
-  }
-
-  /**
-   * 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}`);
-  }
-
-  /**
-   * 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;'
-    ];
-  }
-}

package/src/dialect/postgresql/connection.ts

@@ -1,74 +0,0 @@
-// @file-if pg
-import * as pg from 'pg';
-
-import { ShutdownManager } from '@travetto/base';
-import { AsyncContext, WithAsyncContext } from '@travetto/context';
-import { ExistsError } from '@travetto/model';
-
-import { Connection } from '../../connection/base';
-import { SQLModelConfig } from '../../config';
-
-/**
- * Connection support for postgresql
- */
-export class PostgreSQLConnection extends Connection<pg.PoolClient> {
-
-  #pool: pg.Pool;
-  #config: SQLModelConfig;
-
-  constructor(
-    context: AsyncContext,
-    config: SQLModelConfig
-  ) {
-    super(context);
-    this.#config = config;
-  }
-
-  /**
-   * Initializes connection and establishes crypto extension for use with hashing
-   */
-  @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,
-      parseInputDatesAsUTC: true,
-      ...(this.#config.options || {})
-    });
-
-    await this.runWithActive(() =>
-      this.runWithTransaction('required', () =>
-        this.execute(this.active, 'CREATE EXTENSION IF NOT EXISTS pgcrypto;')
-      )
-    );
-
-    // Close postgres
-    ShutdownManager.onShutdown(this.constructor.ᚕid, () => this.#pool.end());
-  }
-
-  async execute<T = unknown>(conn: pg.PoolClient, query: string): Promise<{ count: number, records: T[] }> {
-    console.debug('Executing query', { query });
-    try {
-      const out = await conn.query(query);
-      const records: T[] = [...out.rows].map(v => ({ ...v }));
-      return { count: out.rowCount, records };
-    } catch (err) {
-      if (err instanceof Error && err.message.includes('duplicate key value')) {
-        throw new ExistsError('query', query);
-      } else {
-        throw err;
-      }
-    }
-  }
-
-  acquire(): Promise<pg.PoolClient> {
-    return this.#pool.connect();
-  }
-
-  release(conn: pg.PoolClient): void {
-    conn.release();
-  }
-}

package/src/dialect/postgresql/dialect.ts

@@ -1,69 +0,0 @@
-// @file-if pg
-import { FieldConfig } from '@travetto/schema';
-import { Injectable } from '@travetto/di';
-import { AsyncContext } from '@travetto/context';
-import { ModelType } from '@travetto/model';
-import { Class } from '@travetto/base';
-
-import { SQLModelConfig } from '../../config';
-import { SQLDialect } from '../base';
-import { SQLUtil, VisitStack } from '../../internal/util';
-import { PostgreSQLConnection } from './connection';
-
-/**
- * Postgresql Dialect for the SQL Model Source
- */
-@Injectable()
-export class PostgreSQLDialect extends SQLDialect {
-
-  conn: PostgreSQLConnection;
-
-  constructor(context: AsyncContext, public config: SQLModelConfig) {
-    super(config.namespace);
-    this.conn = new PostgreSQLConnection(context, config);
-
-    // 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')`;
-  }
-
-  ident(field: FieldConfig | string): string {
-    return `"${typeof field === 'string' ? field : field.name}"`;
-  }
-
-  /**
-   * Define column modification
-   */
-  getModifyColumnSQL(stack: VisitStack[]): string {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const field = stack[stack.length - 1] as FieldConfig;
-    const type = this.getColumnType(field);
-    const ident = this.ident(field.name);
-    return `ALTER TABLE ${this.parentTable(stack)} ALTER COLUMN ${ident}  TYPE ${type} USING (${ident}::${type});`;
-  }
-
-  /**
-   * Suppress foreign key checks
-   */
-  override getTruncateAllTablesSQL<T extends ModelType>(cls: Class<T>): string[] {
-    return [`TRUNCATE ${this.table(SQLUtil.classToStack(cls))} CASCADE;`];
-  }
-}

package/src/dialect/sqlite/connection.ts

@@ -1,98 +0,0 @@
-// @file-if better-sqlite3
-import * as sqlite3 from 'better-sqlite3';
-import Db = require('better-sqlite3');
-import * as pool from 'generic-pool';
-
-import { ShutdownManager, Util } from '@travetto/base';
-import { AsyncContext, WithAsyncContext } from '@travetto/context';
-import { ExistsError } from '@travetto/model';
-import { AppCache } from '@travetto/boot';
-
-import { Connection } from '../../connection/base';
-import { SQLModelConfig } from '../../config';
-
-/**
- * Connection support for Sqlite
- */
-export class SqliteConnection extends Connection<sqlite3.Database> {
-
-  isolatedTransactions = false;
-
-  #config: SQLModelConfig;
-  #pool: pool.Pool<sqlite3.Database>;
-
-  constructor(
-    context: AsyncContext,
-    config: SQLModelConfig
-  ) {
-    super(context);
-    this.#config = config;
-  }
-
-  async #withRetries<T>(op: () => Promise<T>, retries = 10, delay = 250): Promise<T> {
-    for (; ;) {
-      try {
-        return await op();
-      } catch (err) {
-        if (err instanceof Error && retries > 1 && err.message.includes('database is locked')) {
-          console.error('Failed, and waiting', retries);
-          await Util.wait(delay);
-          retries -= 1;
-        } else {
-          throw err;
-        }
-      }
-    }
-  }
-
-  /**
-   * Initializes connection and establishes crypto extension for use with hashing
-   */
-  @WithAsyncContext()
-  override async init(): Promise<void> {
-    this.#pool = pool.createPool({
-      create: () => this.#withRetries(async () => {
-        const db = Db(AppCache.toEntryName('sqlite_db'),
-          this.#config.options
-        );
-        await db.pragma('foreign_keys = ON');
-        await db.pragma('journal_mode = WAL');
-        db.function('regexp', (a, b) => new RegExp(a).test(b) ? 1 : 0);
-        return db;
-      }),
-      destroy: async db => { db.close(); }
-    }, { max: 1 });
-
-    // Close postgres
-    ShutdownManager.onShutdown(this.constructor.ᚕid, () => this.#pool.clear());
-  }
-
-  async execute<T = unknown>(conn: sqlite3.Database, query: string): Promise<{ count: number, records: T[] }> {
-    return this.#withRetries(async () => {
-      console.debug('Executing query', { query });
-      try {
-        const out = await conn.prepare(query)[query.trim().startsWith('SELECT') ? 'all' : 'run']();
-        if (Array.isArray(out)) {
-          const records: T[] = [...out].map(v => ({ ...v }));
-          return { count: out.length, records };
-        } else {
-          return { count: out.changes, records: [] };
-        }
-      } catch (err) {
-        if (err instanceof Error && err.message.includes('UNIQUE constraint failed')) {
-          throw new ExistsError('query', query);
-        } else {
-          throw err;
-        }
-      }
-    });
-  }
-
-  async acquire(): Promise<Db.Database> {
-    return this.#pool.acquire();
-  }
-
-  async release(db: sqlite3.Database): Promise<void> {
-    return this.#pool.release(db);
-  }
-}

package/src/dialect/sqlite/dialect.ts

@@ -1,80 +0,0 @@
-// @file-if better-sqlite3
-import { FieldConfig } from '@travetto/schema';
-import { Injectable } from '@travetto/di';
-import { AsyncContext } from '@travetto/context';
-import { WhereClause } from '@travetto/model-query';
-
-import { SQLModelConfig } from '../../config';
-import { SQLDialect } from '../base';
-import { VisitStack } from '../../internal/util';
-import { SqliteConnection } from './connection';
-
-/**
- * Sqlite Dialect for the SQL Model Source
- */
-@Injectable()
-export class SqliteDialect extends SQLDialect {
-
-  conn: SqliteConnection;
-
-  constructor(context: AsyncContext, public config: SQLModelConfig) {
-    super(config.namespace);
-    this.conn = new SqliteConnection(context, config);
-
-    // Special operators
-    Object.assign(this.SQL_OPS, {
-      $regex: 'REGEXP',
-      $ilike: undefined
-    });
-
-    // Special types
-    Object.assign(this.COLUMN_TYPES, {
-      JSON: 'TEXT',
-      TIMESTAMP: 'INTEGER'
-    });
-  }
-
-  override resolveDateValue(value: Date): string {
-    return `${value.getTime()}`;
-  }
-
-  /**
-   * How to hash
-   */
-  hash(value: string): string {
-    return `hex('${value}')`;
-  }
-
-  /**
-   * Build identifier
-   */
-  ident(field: FieldConfig | string): string {
-    return `\`${typeof field === 'string' ? field : field.name}\``;
-  }
-
-  /**
-   * Define column modification
-   */
-  getModifyColumnSQL(stack: VisitStack[]): string {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const field = stack[stack.length - 1] as FieldConfig;
-    const type = this.getColumnType(field);
-    const ident = this.ident(field.name);
-    return `ALTER TABLE ${this.parentTable(stack)} ALTER COLUMN ${ident} TYPE ${type} USING (${ident}::${type});`;
-  }
-
-  /**
-   * Generate truncate SQL
-   */
-  override getTruncateTableSQL(stack: VisitStack[]): string {
-    return `DELETE FROM ${this.table(stack)};`;
-  }
-
-  override getDeleteSQL(stack: VisitStack[], where?: WhereClause<unknown>): string {
-    return super.getDeleteSQL(stack, where).replace(/_ROOT[.]?/g, '');
-  }
-
-  override getUpdateSQL(stack: VisitStack[], data: Record<string, unknown>, where?: WhereClause<unknown>): string {
-    return super.getUpdateSQL(stack, data, where).replace(/_ROOT[.]?/g, '');
-  }
-}

package/support/service.mysql.ts

@@ -1,16 +0,0 @@
-// @file-if mysql
-import { EnvUtil } from '@travetto/boot';
-import type { Service } from '@travetto/command/bin/lib/service';
-
-const version = EnvUtil.get('TRV_SERVICE_MYSQL', '5.6');
-
-export const service: Service = {
-  name: 'mysql',
-  version,
-  image: `mysql:${version}`,
-  port: 3306,
-  env: {
-    MYSQL_ROOT_PASSWORD: 'password',
-    MYSQL_DATABASE: 'app'
-  },
-};

package/support/service.postgresql.ts

@@ -1,17 +0,0 @@
-// @file-if pg
-import { EnvUtil } from '@travetto/boot';
-import type { Service } from '@travetto/command/bin/lib/service';
-
-const version = EnvUtil.get('TRV_SERVICE_POSTGRESQL', '12.2');
-
-export const service: Service = {
-  name: 'postgresql',
-  version,
-  port: 5432,
-  image: `postgres:${version}-alpine`,
-  env: {
-    POSTGRES_USER: 'root',
-    POSTGRES_PASSWORD: 'password',
-    POSTGRES_DB: 'app'
-  }
-};