@enbox/dwn-sql-store 0.0.10 → 0.0.11

package/src/migrations/index.ts

@@ -1,15 +1,23 @@
-import type { Migration } from '../migration-runner.js';
+import type { DwnMigrationFactory } from '../migration-provider.js';
 
 import { migration001InitialSchema } from './001-initial-schema.js';
 import { migration002ContentAddressedDatastore } from './002-content-addressed-datastore.js';
 import { migration003AddSquashColumn } from './003-add-squash-column.js';
 
 /**
- * All migrations in sequential order. The MigrationRunner applies them
- * in array order, skipping any that have already been recorded.
+ * All DWN store migrations in sequential order.
+ *
+ * Each entry is a `[name, factory]` tuple where the factory is a
+ * {@link DwnMigrationFactory} that receives the dialect and returns a
+ * standard Kysely `Migration`. The `DwnMigrationProvider` resolves these
+ * into the `Record<string, Migration>` that Kysely's `Migrator` expects.
+ *
+ * **Ordering contract:** Entries MUST be sorted by name (lexicographic).
+ * Kysely's `Migrator` sorts by key as well, but maintaining order here
+ * makes the source of truth explicit and human-readable.
  */
-export const allMigrations: Migration[] = [
-  migration001InitialSchema,
-  migration002ContentAddressedDatastore,
-  migration003AddSquashColumn,
+export const allDwnMigrations: ReadonlyArray<readonly [name: string, factory: DwnMigrationFactory]> = [
+  ['001-initial-schema', migration001InitialSchema],
+  ['002-content-addressed-datastore', migration002ContentAddressedDatastore],
+  ['003-add-squash-column', migration003AddSquashColumn],
 ];

package/src/resumable-task-store-sql.ts

@@ -4,7 +4,7 @@ import type { ManagedResumableTask, ResumableTaskStore } from '@enbox/dwn-sdk-js
 
 import { Cid } from '@enbox/dwn-sdk-js';
 import { executeWithTransaction } from './utils/transaction.js';
-import { Kysely } from 'kysely';
+import { Kysely, sql } from 'kysely';
 
 export class ResumableTaskStoreSql implements ResumableTaskStore {
   private static readonly taskTimeoutInSeconds = 60;
@@ -23,31 +23,22 @@ export class ResumableTaskStoreSql implements ResumableTaskStore {
 
     this.#db = new Kysely<DwnDatabaseType>({ dialect: this.#dialect });
 
-    // if table already exists, there is no more things todo
-    const tableName = 'resumableTasks';
-    const tableExists = await this.#dialect.hasTable(this.#db, tableName);
-    if (tableExists) {
-      return;
-    }
-
-    // else create the table and corresponding indexes
-
-    const table = this.#db.schema
-      .createTable(tableName)
-      .ifNotExists() // kept to show supported by all dialects in contrast to ifNotExists() below, though not needed due to hasTable() check above
-      .addColumn('id', 'varchar(255)', (col) => col.primaryKey())
-      .addColumn('task', 'text')
-      .addColumn('timeout', 'bigint')
-      .addColumn('retryCount', 'integer');
-
-    await table.execute();
+    // Fail fast if migrations have not been run — tables must already exist.
+    await this.#assertTablesExist();
+  }
 
-    await this.#db.schema
-      .createIndex('index_timeout')
-      // .ifNotExists() // intentionally kept commented out code to show that it is not supported by all dialects (ie. MySQL)
-      .on('resumableTasks')
-      .column('timeout')
-      .execute();
+  /**
+   * Verifies that the required tables exist by executing a zero-row SELECT.
+   * Throws a clear error directing the caller to run migrations first.
+   */
+  async #assertTablesExist(): Promise<void> {
+    try {
+      await sql`SELECT 1 FROM ${sql.table('resumableTasks')} LIMIT 0`.execute(this.#db!);
+    } catch {
+      throw new Error(
+        'ResumableTaskStoreSql: table \'resumableTasks\' does not exist. Run DWN store migrations before opening stores.'
+      );
+    }
   }
 
   async close(): Promise<void> {

package/src/state-index-sql.ts

@@ -16,9 +16,9 @@ import type { KeyValues } from '@enbox/dwn-sdk-js';
 import type { StateIndex } from '@enbox/dwn-sdk-js';
 
 import { initDefaultHashes } from '@enbox/dwn-sdk-js';
-import { Kysely } from 'kysely';
 import { SMTStoreSql } from './smt-store-sql.js';
 import { SparseMerkleTree } from '@enbox/dwn-sdk-js';
+import { Kysely, sql } from 'kysely';
 
 export class StateIndexSql implements StateIndex {
   #dialect: Dialect;
@@ -51,68 +51,24 @@ export class StateIndexSql implements StateIndex {
     // Ensure default hashes are initialized for the SMT
     await initDefaultHashes();
 
-    // ─── Create stateIndexNodes table ─────────────────────────────────────
-    const nodesTableName = 'stateIndexNodes';
-    const nodesTableExists = await this.#dialect.hasTable(this.#db, nodesTableName);
-    if (!nodesTableExists) {
-      await this.#db.schema
-        .createTable(nodesTableName)
-        .ifNotExists()
-        .addColumn('tenant', 'varchar(255)', (col) => col.notNull())
-        .addColumn('scope', 'varchar(200)', (col) => col.notNull())
-        .addColumn('nodeHash', 'varchar(64)', (col) => col.notNull())
-        .addColumn('nodeType', 'varchar(10)', (col) => col.notNull())
-        .addColumn('leftHash', 'varchar(64)')
-        .addColumn('rightHash', 'varchar(64)')
-        .addColumn('leafKeyHash', 'varchar(64)')
-        .addColumn('leafValueCid', 'varchar(60)')
-        .execute();
-
-      // Not UNIQUE because the delete-then-insert upsert pattern in SMTStoreSql
-      // can race under concurrent access, causing duplicate key violations.
-      await this.#db.schema
-        .createIndex('index_stateIndexNodes_tenant_scope_nodeHash')
-        .on(nodesTableName)
-        .columns(['tenant', 'scope', 'nodeHash'])
-        .execute();
-    }
-
-    // ─── Create stateIndexRoots table ─────────────────────────────────────
-    const rootsTableName = 'stateIndexRoots';
-    const rootsTableExists = await this.#dialect.hasTable(this.#db, rootsTableName);
-    if (!rootsTableExists) {
-      await this.#db.schema
-        .createTable(rootsTableName)
-        .ifNotExists()
-        .addColumn('tenant', 'varchar(255)', (col) => col.notNull())
-        .addColumn('scope', 'varchar(200)', (col) => col.notNull())
-        .addColumn('rootHash', 'varchar(64)', (col) => col.notNull())
-        .execute();
-
-      await this.#db.schema
-        .createIndex('index_stateIndexRoots_tenant_scope')
-        .on(rootsTableName)
-        .columns(['tenant', 'scope'])
-        .execute();
-    }
-
-    // ─── Create stateIndexMeta table ──────────────────────────────────────
-    const metaTableName = 'stateIndexMeta';
-    const metaTableExists = await this.#dialect.hasTable(this.#db, metaTableName);
-    if (!metaTableExists) {
-      await this.#db.schema
-        .createTable(metaTableName)
-        .ifNotExists()
-        .addColumn('tenant', 'varchar(255)', (col) => col.notNull())
-        .addColumn('messageCid', 'varchar(60)', (col) => col.notNull())
-        .addColumn('protocol', 'varchar(200)')
-        .execute();
+    // Fail fast if migrations have not been run — tables must already exist.
+    await this.#assertTablesExist();
+  }
 
-      await this.#db.schema
-        .createIndex('index_stateIndexMeta_tenant_messageCid')
-        .on(metaTableName)
-        .columns(['tenant', 'messageCid'])
-        .execute();
+  /**
+   * Verifies that the required tables exist by executing a zero-row SELECT.
+   * Throws a clear error directing the caller to run migrations first.
+   */
+  async #assertTablesExist(): Promise<void> {
+    const tables = ['stateIndexNodes', 'stateIndexRoots', 'stateIndexMeta'] as const;
+    for (const table of tables) {
+      try {
+        await sql`SELECT 1 FROM ${sql.table(table)} LIMIT 0`.execute(this.#db!);
+      } catch {
+        throw new Error(
+          `StateIndexSql: table '${table}' does not exist. Run DWN store migrations before opening stores.`
+        );
+      }
     }
   }