@travetto/model-sqlite 7.0.0-rc.1 → 7.0.0-rc.3

package/README.md

@@ -37,8 +37,8 @@ import { SqliteDialect } from '@travetto/model-sqlite';
 
 export class Init {
   @InjectableFactory({ primary: true })
-  static getModelService(ctx: AsyncContext, conf: SQLModelConfig) {
-    return new SQLModelService(ctx, conf, new SqliteDialect(ctx, conf));
+  static getModelService(ctx: AsyncContext, config: SQLModelConfig) {
+    return new SQLModelService(ctx, config, new SqliteDialect(ctx, config));
   }
 }
 ```
@@ -74,9 +74,9 @@ export class SQLModelConfig<T extends {} = {}> {
    */
   database = 'app';
   /**
-   * Auto schema creation
+   * Allow storage modification at runtime
    */
-  autoCreate?: boolean;
+  modifyStorage?: boolean;
   /**
    * Db version
    */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-sqlite",
-  "version": "7.0.0-rc.1",
+  "version": "7.0.0-rc.3",
   "description": "SQLite backing for the travetto model module, with real-time modeling support for SQL schemas.",
   "keywords": [
     "sql",
@@ -26,11 +26,11 @@
     "directory": "module/model-sqlite"
   },
   "dependencies": {
-    "@travetto/config": "^7.0.0-rc.1",
-    "@travetto/context": "^7.0.0-rc.1",
-    "@travetto/model": "^7.0.0-rc.1",
-    "@travetto/model-query": "^7.0.0-rc.1",
-    "@travetto/model-sql": "^7.0.0-rc.1",
+    "@travetto/config": "^7.0.0-rc.3",
+    "@travetto/context": "^7.0.0-rc.3",
+    "@travetto/model": "^7.0.0-rc.3",
+    "@travetto/model-query": "^7.0.0-rc.3",
+    "@travetto/model-sql": "^7.0.0-rc.3",
     "@types/better-sqlite3": "^7.6.13",
     "better-sqlite3": "^12.4.6"
   },

package/src/connection.ts

@@ -4,11 +4,16 @@ import path from 'node:path';
 import sqlDb, { type Database, Options } from 'better-sqlite3';
 import { Pool, createPool } from 'generic-pool';
 
-import { ShutdownManager, Util, Runtime } from '@travetto/runtime';
+import { ShutdownManager, Util, Runtime, AppError, castTo } from '@travetto/runtime';
 import { AsyncContext, WithAsyncContext } from '@travetto/context';
 import { ExistsError } from '@travetto/model';
 import { SQLModelConfig, Connection } from '@travetto/model-sql';
 
+const RECOVERABLE_MESSAGE = /database( table| schema)? is (locked|busy)/;
+
+const isRecoverableError = (error: unknown): error is Error =>
+  error instanceof Error && RECOVERABLE_MESSAGE.test(error.message);
+
 /**
  * Connection support for Sqlite
  */
@@ -27,20 +32,20 @@ export class SqliteConnection extends Connection<Database> {
     this.#config = config;
   }
 
-  async #withRetries<T>(op: () => Promise<T>, retries = 10, delay = 250): Promise<T> {
-    for (; ;) {
+  async #withRetries<T>(operation: () => Promise<T>, retries = 10, delay = 250): Promise<T> {
+    for (; retries > 1; retries -= 1) {
       try {
-        return await op();
-      } catch (err) {
-        if (err instanceof Error && retries > 1 && err.message.includes('database is locked')) {
+        return await operation();
+      } catch (error) {
+        if (isRecoverableError(error)) {
           console.error('Failed, and waiting', retries);
           await Util.blockingTimeout(delay);
-          retries -= 1;
         } else {
-          throw err;
+          throw error;
         }
       }
     }
+    throw new AppError('Max retries exceeded');
   }
 
   async #create(): Promise<Database> {
@@ -72,23 +77,29 @@ export class SqliteConnection extends Connection<Database> {
     ShutdownManager.onGracefulShutdown(() => this.#pool.clear());
   }
 
-  async execute<T = unknown>(conn: Database, query: string, values?: unknown[]): Promise<{ count: number, records: T[] }> {
+  async execute<T = unknown>(connection: Database, query: string, values?: unknown[]): Promise<{ count: number, records: T[] }> {
     return this.#withRetries(async () => {
       console.debug('Executing query', { query });
       try {
-        const out = await conn.prepare<unknown[], T>(query)[query.trim().startsWith('SELECT') ? 'all' : 'run'](...values ?? []);
+        const out = await connection.prepare<unknown[], T>(query)[query.trim().startsWith('SELECT') ? 'all' : 'run'](...values ?? []);
         if (Array.isArray(out)) {
-          const records: T[] = out.map(v => ({ ...v }));
+          const records: T[] = out.map(item => ({ ...item }));
           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;
+      } catch (error) {
+        const code = error && typeof error === 'object' && 'code' in error ? error.code : undefined;
+        switch (code) {
+          case 'SQLITE_CONSTRAINT_PRIMARYKEY':
+          case 'SQLITE_CONSTRAINT_UNIQUE':
+          case 'SQLITE_CONSTRAINT_INDEX': throw new ExistsError('query', query);
+        };
+        const message = error instanceof Error ? error.message : '';
+        if (/index.*?already exists/.test(message)) {
+          throw new ExistsError('index', query);
         }
+        throw error;
       }
     });
   }
@@ -100,4 +111,14 @@ export class SqliteConnection extends Connection<Database> {
   async release(db: Database): Promise<void> {
     return this.#pool.release(db);
   }
+
+  async pragma<T>(query: string): Promise<T> {
+    const db = await this.acquire();
+    try {
+      const result = db.pragma(query, { simple: false });
+      return castTo<T>(result);
+    } finally {
+      await this.release(db);
+    }
+  }
 }

package/src/dialect.ts

@@ -4,7 +4,7 @@ import { AsyncContext } from '@travetto/context';
 import { WhereClause } from '@travetto/model-query';
 import { castTo } from '@travetto/runtime';
 
-import { SQLModelConfig, SQLDialect, VisitStack } from '@travetto/model-sql';
+import { SQLModelConfig, SQLDialect, VisitStack, type SQLTableDescription } from '@travetto/model-sql';
 
 import { SqliteConnection } from './connection.ts';
 
@@ -14,12 +14,12 @@ import { SqliteConnection } from './connection.ts';
 @Injectable()
 export class SqliteDialect extends SQLDialect {
 
-  conn: SqliteConnection;
+  connection: SqliteConnection;
   config: SQLModelConfig;
 
   constructor(context: AsyncContext, config: SQLModelConfig) {
     super(config.namespace);
-    this.conn = new SqliteConnection(context, config);
+    this.connection = new SqliteConnection(context, config);
     this.config = config;
 
     // Special operators
@@ -46,14 +46,64 @@ export class SqliteDialect extends SQLDialect {
     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_notnull: 1 | 0 }>(`
+      SELECT 
+        name, 
+        type, 
+        ${this.identifier('notnull')} <> 0 AS is_notnull
+      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
+    `)
+    ]);
+
+    return {
+      columns: columns.records.map(col => ({
+        ...col,
+        is_notnull: !!col.is_notnull
+      })),
+      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)
+      }))
+    };
+  }
+
   /**
    * Define column modification
    */
   getModifyColumnSQL(stack: VisitStack[]): string {
     const field: SchemaFieldConfig = castTo(stack.at(-1));
     const type = this.getColumnType(field);
-    const ident = this.ident(field.name.toString());
-    return `ALTER TABLE ${this.parentTable(stack)} ALTER COLUMN ${ident} TYPE ${type} USING (${ident}::${type});`;
+    const identifier = this.identifier(field.name);
+    return `ALTER TABLE ${this.parentTable(stack)} ALTER COLUMN ${identifier} TYPE ${type} USING (${identifier}::${type});`;
   }
 
   /**