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

package/README.md

@@ -13,13 +13,14 @@ npm install @travetto/model-sqlite
 yarn add @travetto/model-sqlite
 ```
 
-This module provides a [SQLite](https://www.sqlite.org/)-based implementation for the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") module. This source allows the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") module to read, write and query against [SQL](https://en.wikipedia.org/wiki/SQL) databases. In development mode, the [SQLModelService](https://github.com/travetto/travetto/tree/main/module/model-sql/src/service.ts#L69) will also modify the database schema in real time to minimize impact to development. 
+This module provides a [SQLite](https://www.sqlite.org/)-based implementation for the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") module. This source allows the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") module to read, write and query against [SQL](https://en.wikipedia.org/wiki/SQL) databases. In development mode, the [SqliteModelService](https://github.com/travetto/travetto/tree/main/module/model-sqlite/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 serialized `TEXT` 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,42 @@ 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 { type SQLModelConfig, SQLModelService } from '@travetto/model-sql';
-import { SqliteDialect } from '@travetto/model-sqlite';
+import { type SqliteConnection, SqliteModelService } from '@travetto/model-sqlite';
 
 export class Init {
   @InjectableFactory({ primary: true })
-  static getModelService(ctx: AsyncContext, config: SQLModelConfig) {
-    return new SQLModelService(ctx, config, new SqliteDialect(ctx, config));
+  static getModelService(connection: SqliteConnection) {
+    return new SqliteModelService(connection);
   }
 }
 ```
 
-where the [SQLModelConfig](https://github.com/travetto/travetto/tree/main/module/model-sql/src/config.ts#L8) is defined by:
+where the [SqliteModelConfig](https://github.com/travetto/travetto/tree/main/module/model-sqlite/src/config.ts#L10) is defined by:
 
-**Code: Structure of SQLModelConfig**
+**Code: Structure of SqliteModelConfig**
 ```typescript
-@Config('model.sql')
-export class SQLModelConfig<T extends {} = {}> {
+@Config('model.sqlite')
+export class SqliteModelConfig {
   /**
-   * Host to connect to
-   */
-  host = '127.0.0.1';
-  /**
-   * Default port
-   */
-  port = 0;
-  /**
-   * Username
-   */
-  user = Runtime.production ? '' : 'travetto';
-  /**
-   * Password
-   */
-  password = Runtime.production ? '' : 'travetto';
-  /**
-   * Table prefix
+   * Namespace/schema prefix for table names
    */
   namespace = '';
+
   /**
-   * Database name
-   */
-  database = 'app';
-  /**
-   * Allow storage modification at runtime
+   * Allow storage modifications (like table auto-creation and schema updates) at runtime
    */
-  modifyStorage?: boolean;
+  modifyStorage = !Runtime.production;
+
   /**
-   * Db version
+   * SQLite file location
    */
-  version = '';
+  file?: string;
+
   /**
-   * Raw client options
+   * Custom options
    */
-  options: T = asFull({});
+  options?: DatabaseSyncOptions;
 }
 ```
 

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-sqlite",
-  "version": "8.0.0-alpha.25",
+  "version": "8.0.0-alpha.27",
   "type": "module",
   "description": "SQLite backing for the travetto model module, with real-time modeling support for SQL schemas.",
   "keywords": [
@@ -27,11 +27,11 @@
     "directory": "module/model-sqlite"
   },
   "dependencies": {
-    "@travetto/config": "^8.0.0-alpha.22",
-    "@travetto/context": "^8.0.0-alpha.20",
-    "@travetto/model": "^8.0.0-alpha.23",
-    "@travetto/model-query": "^8.0.0-alpha.24",
-    "@travetto/model-sql": "^8.0.0-alpha.25"
+    "@travetto/config": "^8.0.0-alpha.23",
+    "@travetto/context": "^8.0.0-alpha.21",
+    "@travetto/model": "^8.0.0-alpha.24",
+    "@travetto/model-query": "^8.0.0-alpha.25",
+    "@travetto/model-sql": "^8.0.0-alpha.27"
   },
   "travetto": {
     "displayName": "SQLite Model Service"

package/src/config.ts

@@ -0,0 +1,30 @@
+import type { DatabaseSyncOptions } from 'node:sqlite';
+
+import { Config } from '@travetto/config';
+import { Runtime } from '@travetto/runtime';
+
+/**
+ * SQLite Model Configuration
+ */
+@Config('model.sqlite')
+export class SqliteModelConfig {
+  /**
+   * Namespace/schema prefix for table names
+   */
+  namespace = '';
+
+  /**
+   * Allow storage modifications (like table auto-creation and schema updates) at runtime
+   */
+  modifyStorage = !Runtime.production;
+
+  /**
+   * SQLite file location
+   */
+  file?: string;
+
+  /**
+   * Custom options
+   */
+  options?: DatabaseSyncOptions;
+}

package/src/connection.ts

@@ -1,33 +1,51 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { DatabaseSync, type DatabaseSyncOptions, type SQLInputValue } from 'node:sqlite';
+import { DatabaseSync, type SQLInputValue } from 'node:sqlite';
 
 import { createPool, type Pool } from 'generic-pool';
 
-import { type AsyncContext, WithAsyncContext } from '@travetto/context';
-import { ExistsError } from '@travetto/model';
-import { Connection, type SQLModelConfig } from '@travetto/model-sql';
-import { castTo, Runtime, RuntimeError, ShutdownManager, Util } from '@travetto/runtime';
+import type { AsyncContext } from '@travetto/context';
+import { Injectable } from '@travetto/di';
+import { ExistsError, UniqueError } from '@travetto/model';
+import { SQLConnection } from '@travetto/model-sql';
+import { castTo, JSONUtil, Runtime, RuntimeError, ShutdownManager, Util } from '@travetto/runtime';
 
-const RECOVERABLE_MESSAGE = /database( table| schema)? is (locked|busy)/;
+import type { SqliteModelConfig } from './config.ts';
+import { SqliteDialect } from './dialect.ts';
 
+const RECOVERABLE_MESSAGE = /database( table| schema)? is (locked|busy)/;
 const isRecoverableError = (error: unknown): error is Error => error instanceof Error && RECOVERABLE_MESSAGE.test(error.message);
 
+const normalizeParameter = (val: unknown) => {
+  if (val === null) {
+    return val;
+  } else if (val instanceof Date) {
+    return val.toISOString();
+  } else if (typeof val === 'object') {
+    return JSONUtil.toUTF8(val);
+  } else {
+    return castTo<SQLInputValue>(val);
+  }
+};
+
 /**
- * Connection support for Sqlite
+ * SQLite Connection Manager.
+ * Operates on node:sqlite DatabaseSync using a pool with max=1.
  */
-export class SqliteConnection extends Connection<DatabaseSync> {
+@Injectable()
+export class SqliteConnection extends SQLConnection<DatabaseSync> {
+  readonly dialect = new SqliteDialect();
   isolatedTransactions = false;
 
-  #config: SQLModelConfig<DatabaseSyncOptions & { file?: string }>;
   #pool: Pool<DatabaseSync>;
+  readonly config: SqliteModelConfig;
 
-  constructor(context: AsyncContext, config: SQLModelConfig<DatabaseSyncOptions & { file?: string }>) {
+  constructor(context: AsyncContext, config: SqliteModelConfig) {
     super(context);
-    this.#config = config;
+    this.config = config;
   }
 
-  async #withRetries<T>(operation: () => Promise<T>, retries = 10, delay = 250): Promise<T> {
+  async #withRetries<T>(operation: () => Promise<T>, retries = 10, delay = 300): Promise<T> {
     for (; retries > 1; retries -= 1) {
       try {
         return await operation();
@@ -43,23 +61,60 @@ export class SqliteConnection extends Connection<DatabaseSync> {
   }
 
   async #create(): Promise<DatabaseSync> {
-    const file = path.resolve(this.#config.options.file ?? Runtime.toolPath('@', 'sqlite_db'));
+    const file = path.resolve(this.config.file ?? Runtime.toolPath('@', 'sqlite_db'));
     await fs.mkdir(path.dirname(file), { recursive: true });
-    const db = new DatabaseSync(file, this.#config.options);
+    const db = new DatabaseSync(file, this.config.options ?? {});
     for (const q of ['PRAGMA foreign_keys = ON', 'PRAGMA journal_mode = WAL', 'PRAGMA synchronous = NORMAL']) {
       await this.#withRetries(async () => db.exec(q));
     }
-    db.function('regexp', (a, b) => (new RegExp(`${a}`).test(`${b}`) ? 1 : 0));
+    // Register custom regex function for SQL regex support
+    db.function('regexp', (pattern, value) => {
+      const patStr = String(pattern);
+      const valStr = String(value);
+      if (patStr.startsWith('(?i)')) {
+        return new RegExp(patStr.slice(4), 'i').test(valStr) ? 1 : 0;
+      }
+      return new RegExp(patStr).test(valStr) ? 1 : 0;
+    });
+    // Register custom json_contains function for JSON containment checks
+    db.function('json_contains', (target, candidate) => {
+      try {
+        const tgt = JSON.parse(String(target));
+        const cand = JSON.parse(String(candidate));
+
+        const matches = (t: unknown, c: unknown): boolean => {
+          if (c === null) {
+            return t === null;
+          }
+          if (typeof c === 'object') {
+            if (typeof t !== 'object' || t === null) {
+              return false;
+            }
+            if (Array.isArray(c)) {
+              if (!Array.isArray(t)) {
+                return false;
+              }
+              return c.every(cv => t.some(tv => matches(tv, cv)));
+            } else {
+              // @ts-expect-error
+              return Object.keys(c).every(k => matches(t[k], c[k]));
+            }
+          }
+          return t === c;
+        };
+
+        return matches(tgt, cand) ? 1 : 0;
+      } catch {
+        return 0;
+      }
+    });
     return db;
   }
 
   /**
-   * Initializes connection and establishes crypto extension for use with hashing
+   * Initializes the pool and sets connection pragma configuration
    */
-  @WithAsyncContext()
-  override async init(): Promise<void> {
-    this.transactionDialect = { ...this.transactionDialect, begin: 'BEGIN IMMEDIATE;' };
-
+  async init(): Promise<void> {
     await this.#create();
 
     this.#pool = createPool<DatabaseSync>(
@@ -72,64 +127,79 @@ export class SqliteConnection extends Connection<DatabaseSync> {
       { max: 1 }
     );
 
-    // Close postgres
     ShutdownManager.signal.addEventListener('abort', () => this.#pool.clear());
   }
 
-  async execute<T = unknown>(connection: DatabaseSync, query: string, values?: unknown[]): Promise<{ count: number; records: T[] }> {
-    const isSelect = query.trim().startsWith('SELECT');
-    return this.#withRetries(async () => {
-      console.debug('Executing query', { query });
+  /**
+   * Acquires a DB connection
+   */
+  acquire(): Promise<DatabaseSync> {
+    return this.#withRetries(() => this.#pool.acquire());
+  }
 
+  /**
+   * Releases a DB connection back to pool
+   */
+  release(connection: DatabaseSync): void {
+    this.#pool.release(connection);
+  }
+
+  /**
+   * Executes a query on the active client or pool directly
+   */
+  async execute<Type = unknown>(query: string, values?: unknown[]): Promise<{ count: number; records: Type[] }> {
+    const isSelect =
+      query.trim().startsWith('SELECT') ||
+      query.trim().startsWith('PRAGMA') ||
+      query.trim().startsWith('EXISTS') ||
+      query.includes('RETURNING');
+
+    const normalized = (values ?? []).map(normalizeParameter);
+
+    return this.#withRetries(async () => {
+      console.debug('Executing SQLite query', { query, values });
+      const client = this.active ?? (await this.acquire());
       try {
-        const prepared = connection.prepare(query);
+        const prepared = client.prepare(query);
         prepared.setReadBigInts(true);
         if (isSelect) {
-          const out = prepared.all(...castTo<SQLInputValue[]>(values ?? []));
-          const records: T[] = out.map(item => ({ ...castTo<T>(item) }));
+          const out = prepared.all(...normalized);
+          const records: Type[] = out.map(item => ({ ...castTo<Type>(item) }));
           return { count: out.length, records };
         } else {
-          const out = prepared.run(...castTo<SQLInputValue[]>(values ?? []));
+          const out = prepared.run(...normalized);
           return { count: typeof out.changes === 'number' ? out.changes : +out.changes.toString(), records: [] };
         }
       } catch (error) {
         const code = error && typeof error === 'object' && 'code' in error ? error.code : undefined;
-        const message = Error.isError(error) || error instanceof Error ? error.message : undefined;
+        const message = error instanceof Error ? error.message : undefined;
         switch (code) {
           case 'ERR_SQLITE_ERROR': {
             if (message?.startsWith('UNIQUE')) {
-              throw new ExistsError('query', query);
+              const match = message.match(/UNIQUE constraint failed: (.*)/);
+              const key = match ? match[1] : 'query';
+              throw new UniqueError('query', key, { message, query });
             }
             break;
           }
-          case 'SQLITE_CONSTRAINT_PRIMARYKEY':
           case 'SQLITE_CONSTRAINT_UNIQUE':
-          case 'SQLITE_CONSTRAINT_INDEX':
+          case 'SQLITE_CONSTRAINT_INDEX': {
+            const match = message?.match(/UNIQUE constraint failed: (.*)/);
+            const key = match ? match[1] : 'query';
+            throw new UniqueError('query', key, { message, query });
+          }
+          case 'SQLITE_CONSTRAINT_PRIMARYKEY':
             throw new ExistsError('query', query);
         }
         if (/index.*?already exists/.test(message ?? '')) {
           throw new ExistsError('index', query);
         }
         throw error;
+      } finally {
+        if (!this.active) {
+          this.release(client);
+        }
       }
     });
   }
-
-  async acquire(): Promise<DatabaseSync> {
-    return await this.#pool.acquire();
-  }
-
-  async release(db: DatabaseSync): Promise<void> {
-    return this.#pool.release(db);
-  }
-
-  async pragma<T>(query: string): Promise<T> {
-    const db = await this.acquire();
-    try {
-      const result = this.#withRetries(async () => db.prepare(`PRAGMA ${query}`).get());
-      return castTo<T>(result);
-    } finally {
-      await this.release(db);
-    }
-  }
 }

package/src/dialect.ts

@@ -1,122 +1,165 @@
-import type { AsyncContext } from '@travetto/context';
-import { Injectable } from '@travetto/di';
-import type { WhereClause } from '@travetto/model-query';
-import { SQLDialect, type SQLModelConfig, type SQLTableDescription, type VisitStack } from '@travetto/model-sql';
-import { castTo } from '@travetto/runtime';
+import { AbstractANSI99Dialect, type ResolvedPathContext, type TableContext, type TransactionStatements } from '@travetto/model-sql';
+import { type Class, castTo, JSONUtil } from '@travetto/runtime';
 import type { SchemaFieldConfig } from '@travetto/schema';
 
-import { SqliteConnection } from './connection.ts';
-
-/**
- * Sqlite Dialect for the SQL Model Source
- */
-@Injectable()
-export class SqliteDialect extends SQLDialect {
-  connection: SqliteConnection;
-  config: SQLModelConfig;
-
-  constructor(context: AsyncContext, config: SQLModelConfig) {
-    super(config.namespace);
-    this.connection = new SqliteConnection(context, config);
-    this.config = 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}')`;
-  }
-
-  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([
-      this.executeSQL<{ name: string; type: string; is_not_null: 1 | 0 }>(`
-      SELECT 
-        name, 
-        type, 
-        ${this.identifier('notnull')} <> 0 AS is_not_null
-      FROM PRAGMA_TABLE_INFO('${table}')
-      WHERE name NOT IN (${IGNORE_FIELDS.join(',')})
-    `),
-      this.executeSQL<{ name: string; to_table: string; from_column: string; to_column: string }>(`
-      SELECT 
-        'fk_' || '${table}' || '_' || ${this.identifier('from')} AS name, 
-        ${this.identifier('from')} as from_column, 
-        ${this.identifier('to')} as to_column, 
-        ${this.identifier('table')} as to_table
-      FROM PRAGMA_FOREIGN_KEY_LIST('${table}')
-    `),
-      this.executeSQL<{ name: string; is_unique: boolean; columns: string }>(`
-      SELECT 
-        il.name as name, 
-        il.${this.identifier('unique')} = 1 as is_unique, 
-        GROUP_CONCAT(ii.seqno || ' ' || ii.name || ' ' || ii.desc) AS columns
-      FROM PRAGMA_INDEX_LIST('${table}') il
-      JOIN PRAGMA_INDEX_XINFO(il.name) ii
-      WHERE il.name NOT LIKE 'sqlite_%'
-      GROUP BY 1, 2
-    `)
-    ]);
+export class SqliteDialect extends AbstractANSI99Dialect {
+  returningSupport = true;
+  transactionStatements: TransactionStatements = {
+    ...AbstractANSI99Dialect.TRANSACTION_STATEMENTS,
+    begin: 'BEGIN IMMEDIATE;'
+  };
 
+  getComplexColumnType(field: SchemaFieldConfig): string {
+    return 'TEXT';
+  }
+
+  getColumnType(fieldConfiguration: SchemaFieldConfig): string {
+    if (fieldConfiguration.type === castTo(BigInt)) {
+      return 'INTEGER';
+    }
+
+    if (fieldConfiguration.type === Number) {
+      return 'NUMERIC';
+    }
+
+    if (fieldConfiguration.type === Date) {
+      return 'TEXT';
+    }
+
+    if (fieldConfiguration.type === Boolean) {
+      return 'INTEGER';
+    }
+
+    if (fieldConfiguration.type === String) {
+      return 'TEXT';
+    }
+
+    return 'TEXT';
+  }
+
+  compileJsonIndexPath(columnName: string, jsonPath: string[]): string {
+    return `json_extract(${columnName}, '$.${jsonPath.join('.')}')`;
+  }
+
+  #getSqliteArrayContext(context: ResolvedPathContext): { jsonArrayExpr: string; valueExpr: string } {
+    if (!context.arrayPath || context.arrayPath.length === 0) {
+      return { jsonArrayExpr: context.sqlPath, valueExpr: 'elem.value' };
+    }
+
+    const columnName = this.escapeIdentifier(context.arrayPath[0]);
+    const jsonArrayExpr =
+      context.arrayPath.length > 1 ? `json_extract(${columnName}, '$.${context.arrayPath.slice(1).join('.')}')` : columnName;
+
+    const valueExpr =
+      context.subPath && context.subPath.length > 0 ? `json_extract(elem.value, '$.${context.subPath.join('.')}')` : 'elem.value';
+
+    return { jsonArrayExpr, valueExpr };
+  }
+
+  compileArrayAll(context: ResolvedPathContext, identifier: string, value: unknown[]): { sql: string; formatted: unknown } {
+    const { jsonArrayExpr, valueExpr } = this.#getSqliteArrayContext(context);
+    return {
+      sql: `NOT EXISTS (SELECT 1 FROM json_each(${identifier}) AS req WHERE req.value NOT IN (SELECT ${valueExpr} FROM json_each(${jsonArrayExpr}) AS elem))`,
+      formatted: JSONUtil.toUTF8(value)
+    };
+  }
+
+  compileArrayEquals(context: ResolvedPathContext, identifier: string, values: unknown): { sql: string; formatted: unknown } {
+    const { jsonArrayExpr, valueExpr } = this.#getSqliteArrayContext(context);
+    if (Array.isArray(values)) {
+      return {
+        sql: `NOT EXISTS (SELECT 1 FROM json_each(${identifier}) AS req WHERE req.value NOT IN (SELECT ${valueExpr} FROM json_each(${jsonArrayExpr}) AS elem))`,
+        formatted: JSONUtil.toUTF8(values)
+      };
+    }
+    if (typeof values === 'object' && values !== null) {
+      return {
+        sql: `EXISTS (SELECT 1 FROM json_each(${jsonArrayExpr}) AS elem WHERE NOT EXISTS (SELECT 1 FROM json_each(${identifier}) AS req WHERE json_extract(elem.value, '$.' || req.key) IS NOT req.value))`,
+        formatted: JSONUtil.toUTF8(values)
+      };
+    }
+    return {
+      sql: `EXISTS (SELECT 1 FROM json_each(${jsonArrayExpr}) AS elem WHERE ${valueExpr} = ${identifier})`,
+      formatted: values
+    };
+  }
+
+  compileArrayAny(context: ResolvedPathContext, identifier: string, values: unknown[]): { sql: string; formatted: unknown } {
+    const { jsonArrayExpr, valueExpr } = this.#getSqliteArrayContext(context);
     return {
-      columns: columns.records.map(col => ({
-        ...col,
-        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(col => col.split(' '))
-          .map(([order, name, desc]) => [+order, { name, desc: desc === '1' }] as const)
-          .sort((a, b) => a[0] - b[0])
-          .map(([, item]) => item)
-      }))
+      sql: `EXISTS (SELECT 1 FROM json_each(${jsonArrayExpr}) AS elem WHERE ${valueExpr} IN (SELECT value FROM json_each(${identifier})))`,
+      formatted: JSONUtil.toUTF8(values)
     };
   }
 
-  /**
-   * Define column modification
-   */
-  getModifyColumnSQL(stack: VisitStack[]): string {
-    const field: SchemaFieldConfig = castTo(stack.at(-1));
-    const type = this.getColumnType(field);
-    const identifier = this.identifier(field.name);
-    return `ALTER TABLE ${this.parentTable(stack)} ALTER COLUMN ${identifier} TYPE ${type} USING (${identifier}::${type});`;
+  compileArrayExists(context: ResolvedPathContext, identifier?: string): { sql: string } {
+    const { jsonArrayExpr } = this.#getSqliteArrayContext(context);
+    return { sql: `(${jsonArrayExpr} IS NOT NULL AND json_array_length(${jsonArrayExpr}) > 0)` };
+  }
+
+  getRegexOperator(caseInsensitive: boolean): string {
+    return 'REGEXP';
+  }
+
+  formatRegex(source: string, caseInsensitive: boolean): string {
+    return caseInsensitive ? `(?i)${source}` : source;
+  }
+
+  castColumn(sqlPath: string, type: Class): string {
+    if (type === Number) {
+      return `CAST(${sqlPath} AS NUMERIC)`;
+    }
+    return sqlPath;
+  }
+
+  getTableExistsQuery(context: TableContext): { sql: string; parameters?: unknown[] } {
+    return {
+      sql: `
+SELECT name 
+FROM sqlite_master 
+WHERE type='table' AND name=?;`,
+      parameters: [context.tableName]
+    };
+  }
+
+  parseTableExistsResult(records: unknown[]): boolean {
+    return records.length > 0;
+  }
+
+  getExistingColumnsQuery(context: TableContext): { sql: string; parameters?: unknown[] } {
+    return {
+      sql: `PRAGMA table_info('${this.escapeLiteral(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 name, sql 
+FROM sqlite_master 
+WHERE type='index' AND tbl_name=?;
+`,
+      parameters: [context.tableName]
+    };
   }
 
-  /**
-   * Generate truncate SQL
-   */
-  override getTruncateTableSQL(stack: VisitStack[]): string {
-    return `DELETE FROM ${this.table(stack)};`;
+  parseExistingIndexes(records: unknown[]): Map<string, string> {
+    return new Map(
+      castTo<{ name: string; sql: string }[]>(records)
+        .filter(record => record.sql && !record.name.startsWith('sqlite_'))
+        .map(record => [record.name, record.sql])
+    );
   }
 
-  override getDeleteSQL(stack: VisitStack[], where?: WhereClause<unknown>): string {
-    return super.getDeleteSQL(stack, where).replace(/_ROOT[.]?/g, '');
+  getDropIndexSQL(context: TableContext, indexName: string): string {
+    return `DROP INDEX IF EXISTS ${this.escapeIdentifier(indexName)};`;
   }
 
-  override getUpdateSQL(stack: VisitStack[], data: Record<string, unknown>, where?: WhereClause<unknown>): string {
-    return super.getUpdateSQL(stack, data, where).replace(/_ROOT[.]?/g, '');
+  getTruncateTableSQL(context: TableContext): string {
+    return `DELETE FROM ${this.escapeIdentifier(context.tableName)};`;
   }
 }

package/src/service.ts

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