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

package/README.md

@@ -13,78 +13,60 @@ 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#L32) 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:
-   *  [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 { 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 {} = {}> {
-  /**
-   * Host to connect to
-   */
-  host = '127.0.0.1';
-  /**
-   * Default port
-   */
-  port = 0;
-  /**
-   * Username
-   */
-  user = Runtime.production ? '' : 'travetto';
-  /**
-   * Password
-   */
-  password = Runtime.production ? '' : 'travetto';
+@Config('model.sqlite')
+export class SqliteModelConfig {
   /**
-   * 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/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,47 +1,42 @@
 {
   "name": "@travetto/model-sqlite",
-  "version": "8.0.0-alpha.9",
-  "type": "module",
+  "version": "8.0.1",
   "description": "SQLite backing for the travetto model module, with real-time modeling support for SQL schemas.",
   "keywords": [
-    "sql",
     "data-modeling",
-    "real-time",
     "model",
+    "real-time",
+    "sql",
     "travetto",
     "typescript"
   ],
   "homepage": "https://travetto.io",
   "license": "MIT",
   "author": {
-    "email": "travetto.framework@gmail.com",
-    "name": "Travetto Framework"
+    "name": "Travetto Framework",
+    "email": "travetto.framework@gmail.com"
+  },
+  "repository": {
+    "url": "git+https://github.com/travetto/travetto.git",
+    "directory": "module/model-sqlite"
   },
   "files": [
     "__index__.ts",
     "src"
   ],
+  "type": "module",
   "main": "__index__.ts",
-  "repository": {
-    "url": "git+https://github.com/travetto/travetto.git",
-    "directory": "module/model-sqlite"
+  "publishConfig": {
+    "access": "public"
   },
   "dependencies": {
-    "@travetto/config": "^8.0.0-alpha.9",
-    "@travetto/context": "^8.0.0-alpha.9",
-    "@travetto/model": "^8.0.0-alpha.9",
-    "@travetto/model-query": "^8.0.0-alpha.9",
-    "@travetto/model-sql": "^8.0.0-alpha.9"
+    "@travetto/config": "^8.0.1",
+    "@travetto/context": "^8.0.1",
+    "@travetto/model": "^8.0.1",
+    "@travetto/model-query": "^8.0.1",
+    "@travetto/model-sql": "^8.0.1"
   },
   "travetto": {
-    "displayName": "SQLite Model Service",
-    "build": {
-      "binaryDependencies": [
-        "better-sqlite3"
-      ]
-    }
-  },
-  "publishConfig": {
-    "access": "public"
+    "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,38 +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 { type Pool, createPool } from 'generic-pool';
+import { createPool, type Pool } from 'generic-pool';
 
-import { ShutdownManager, Util, Runtime, RuntimeError, castTo } from '@travetto/runtime';
-import { type AsyncContext, WithAsyncContext } from '@travetto/context';
-import { ExistsError } from '@travetto/model';
-import { type SQLModelConfig, Connection } from '@travetto/model-sql';
+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 isRecoverableError = (error: unknown): error is Error =>
-  error instanceof Error && RECOVERABLE_MESSAGE.test(error.message);
+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();
@@ -48,91 +61,145 @@ 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);
-    for (const q of [
-      'PRAGMA foreign_keys = ON',
-      'PRAGMA journal_mode = WAL',
-      'PRAGMA synchronous = NORMAL',
-    ]) {
+    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 targetRaw = JSON.parse(String(target));
+        const candidateRaw = 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(targetRaw, candidateRaw) ? 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>({
-      create: () => this.#withRetries(() => this.#create()),
-      destroy: async db => { db.close(); }
-    }, { max: 1 });
+    this.#pool = createPool<DatabaseSync>(
+      {
+        create: () => this.#withRetries(() => this.#create()),
+        destroy: async db => {
+          db.close();
+        }
+      },
+      { 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.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': throw new ExistsError('query', query);
-        };
+          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,123 +1,232 @@
+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 { Injectable } from '@travetto/di';
-import type { AsyncContext } from '@travetto/context';
-import type { WhereClause } from '@travetto/model-query';
-import { castTo } from '@travetto/runtime';
-
-import { type SQLModelConfig, SQLDialect, type VisitStack, type SQLTableDescription } from '@travetto/model-sql';
-
-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;'
+  };
+
+  override getUpsertSQL(
+    context: TableContext,
+    columns: string[],
+    placeholders: string[],
+    conflictTarget: string[],
+    updates: string[]
+  ): string {
+    return `INSERT INTO ${this.escapeIdentifier(context.tableName)} (${columns.join(', ')}) VALUES (${placeholders.join(', ')}) ON CONFLICT (${conflictTarget.join(', ')}) DO UPDATE SET ${updates.join(', ')} RETURNING *;`;
+  }
+
+  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}, '$.${this.formatJsonPath(jsonPath)}')`;
+  }
+
+  #getSqliteArrayExpression(context: ResolvedPathContext): string {
+    if (!context.arrayPath || context.arrayPath.length === 0) {
+      return context.sqlPath;
+    }
+
+    const columnName = this.escapeIdentifier(context.arrayPath[0]);
+    return context.arrayPath.length > 1 ? `json_extract(${columnName}, '$.${context.arrayPath.slice(1).join('.')}')` : columnName;
+  }
+
+  #buildSubPathCondition(context: ResolvedPathContext, parentExpression: string, onLeaf: (leafExpression: string) => string): string {
+    if (!context.subPath || context.subPath.length === 0) {
+      return onLeaf(parentExpression);
+    }
+
+    const subPathMetadata = this.getSchemaSubPathMetadata(context.arrayField?.type, context.subPath);
+    const arraySegmentIndices = subPathMetadata
+      .map((metadataItem, metadataIndex) => (metadataItem.isArray ? metadataIndex : -1))
+      .filter(itemIndex => itemIndex !== -1);
+
+    if (arraySegmentIndices.length === 0) {
+      const leafExpression = `json_extract(${parentExpression}, '$.${context.subPath.join('.')}')`;
+      return onLeaf(leafExpression);
+    }
+
+    const buildLevel = (levelIndex: number, currentParent: string): string => {
+      const startPathIndex = levelIndex === 0 ? 0 : arraySegmentIndices[levelIndex - 1] + 1;
+      const endPathIndex = arraySegmentIndices[levelIndex];
+      const arrayPath = context.subPath!.slice(startPathIndex, endPathIndex + 1).join('.');
+      const alias = `ing_${levelIndex}`;
+
+      const innerCondition =
+        levelIndex === arraySegmentIndices.length - 1
+          ? (() => {
+              const leafPath = context.subPath!.slice(endPathIndex + 1).join('.');
+              const leafExpression = leafPath ? `json_extract(${alias}.value, '$.${leafPath}')` : `${alias}.value`;
+              return onLeaf(leafExpression);
+            })()
+          : buildLevel(levelIndex + 1, `${alias}.value`);
+
+      return `
+EXISTS (
+  SELECT 1 
+  FROM json_each(${currentParent}, '$.${arrayPath}') AS ${alias} 
+  WHERE ${innerCondition}
+)`;
+    };
+
+    return buildLevel(0, parentExpression);
+  }
+
+  #buildArrayElementExists(context: ResolvedPathContext, onLeaf: (leafExpression: string) => string): string {
+    const jsonArrayExpression = this.#getSqliteArrayExpression(context);
+    const subPathCondition = this.#buildSubPathCondition(context, 'elem.value', onLeaf);
+    return `EXISTS (
+  SELECT 1 
+  FROM json_each(${jsonArrayExpression}) AS elem 
+  WHERE ${subPathCondition}
+)`;
+  }
+
+  compileArrayAll(context: ResolvedPathContext, identifier: string, value: unknown[]): { sql: string; formatted: unknown } {
+    const elementExists = this.#buildArrayElementExists(context, leafExpression => `${leafExpression} = req.value`);
     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: `NOT EXISTS (
+  SELECT 1 
+  FROM json_each(${identifier}) AS req 
+  WHERE NOT ${elementExists}
+)`,
+      formatted: JSONUtil.toUTF8(value)
     };
   }
 
-  /**
-   * 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});`;
+  compileArrayEquals(context: ResolvedPathContext, identifier: string, values: unknown): { sql: string; formatted: unknown } {
+    if (Array.isArray(values)) {
+      return {
+        sql: this.#buildArrayElementExists(context, leafExpression => `${leafExpression} IN (SELECT value FROM json_each(${identifier}))`),
+        formatted: JSONUtil.toUTF8(values)
+      };
+    }
+
+    if (typeof values === 'object' && values !== null) {
+      return {
+        sql: this.#buildArrayElementExists(context, leafExpression => `json_patch(${leafExpression}, ${identifier}) = ${leafExpression}`),
+        formatted: JSONUtil.toUTF8(values)
+      };
+    }
+
+    return {
+      sql: this.#buildArrayElementExists(context, leafExpression => `${leafExpression} = ${identifier}`),
+      formatted: values
+    };
+  }
+
+  compileArrayAny(context: ResolvedPathContext, identifier: string, values: unknown[]): { sql: string; formatted: unknown } {
+    return this.compileArrayEquals(context, identifier, values);
+  }
+
+  compileArrayExists(context: ResolvedPathContext, identifier?: string): { sql: string } {
+    const jsonArrayExpression = this.#getSqliteArrayExpression(context);
+    return { sql: `(${jsonArrayExpression} IS NOT NULL AND json_array_length(${jsonArrayExpression}) > 0)` };
+  }
+
+  compileArrayRegex(context: ResolvedPathContext, identifier: string, value: RegExp | string): { sql: string; formatted: unknown } {
+    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: this.#buildArrayElementExists(context, leafExpression => `${leafExpression} ${regexOp} ${identifier}`),
+      formatted: regexSource
+    };
+  }
+
+  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();
+  }
+}