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

package/README.md

@@ -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.2",
+  "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.2",
-    "@travetto/context": "^7.0.0-rc.2",
-    "@travetto/model": "^7.0.0-rc.2",
-    "@travetto/model-query": "^7.0.0-rc.2",
-    "@travetto/model-sql": "^7.0.0-rc.2",
+    "@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
  */
@@ -28,19 +33,19 @@ export class SqliteConnection extends Connection<Database> {
   }
 
   async #withRetries<T>(operation: () => Promise<T>, retries = 10, delay = 250): Promise<T> {
-    for (; ;) {
+    for (; retries > 1; retries -= 1) {
       try {
         return await operation();
       } catch (error) {
-        if (error instanceof Error && retries > 1 && error.message.includes('database is locked')) {
+        if (isRecoverableError(error)) {
           console.error('Failed, and waiting', retries);
           await Util.blockingTimeout(delay);
-          retries -= 1;
         } else {
           throw error;
         }
       }
     }
+    throw new AppError('Max retries exceeded');
   }
 
   async #create(): Promise<Database> {
@@ -84,11 +89,17 @@ export class SqliteConnection extends Connection<Database> {
           return { count: out.changes, records: [] };
         }
       } catch (error) {
-        if (error instanceof Error && error.message.includes('UNIQUE constraint failed')) {
-          throw new ExistsError('query', query);
-        } else {
-          throw 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';
 
@@ -46,6 +46,56 @@ 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
    */