@holo-js/cache-db 0.1.9 → 0.2.1

package/dist/index.d.ts

@@ -3,6 +3,54 @@ import { HoloProjectConnectionConfig, DatabaseContext, DatabaseContextOptions, S
 
 declare const DEFAULT_CACHE_DATABASE_TABLE = "cache";
 declare const DEFAULT_CACHE_DATABASE_LOCK_TABLE = "cache_locks";
+type CacheDatabaseTableColumnKind = 'string' | 'text' | 'bigInteger';
+type CacheDatabaseTableColumnDefinition = {
+    readonly name: string;
+    readonly kind: CacheDatabaseTableColumnKind;
+    readonly nullable?: boolean;
+    readonly primaryKey?: boolean;
+};
+type CacheDatabaseTableDefinition = {
+    readonly role: 'entries' | 'locks';
+    readonly defaultName: string;
+    readonly columns: readonly CacheDatabaseTableColumnDefinition[];
+    readonly indexColumn: string;
+    readonly indexName: (tableName: string) => string;
+};
+declare const CACHE_DATABASE_TABLE_DEFINITIONS: readonly [{
+    readonly role: "entries";
+    readonly defaultName: "cache";
+    readonly columns: readonly [{
+        readonly name: "key";
+        readonly kind: "string";
+        readonly primaryKey: true;
+    }, {
+        readonly name: "payload";
+        readonly kind: "text";
+    }, {
+        readonly name: "expires_at";
+        readonly kind: "bigInteger";
+        readonly nullable: true;
+    }];
+    readonly indexColumn: "expires_at";
+    readonly indexName: (tableName: string) => string;
+}, {
+    readonly role: "locks";
+    readonly defaultName: "cache_locks";
+    readonly columns: readonly [{
+        readonly name: "name";
+        readonly kind: "string";
+        readonly primaryKey: true;
+    }, {
+        readonly name: "owner";
+        readonly kind: "string";
+    }, {
+        readonly name: "expires_at";
+        readonly kind: "bigInteger";
+    }];
+    readonly indexColumn: "expires_at";
+    readonly indexName: (tableName: string) => string;
+}];
 type DatabaseCacheDriverOptions = {
     readonly name: string;
     readonly connectionName: string;
@@ -35,7 +83,6 @@ declare function resolveDriver(connection: HoloProjectConnectionConfig | string)
 declare function createDatabaseContextOptions(connectionName: string, connection: HoloProjectConnectionConfig | string): DatabaseContextOptions;
 declare function createDatabaseConnection(connectionName: string, connection: HoloProjectConnectionConfig | string): DatabaseContext;
 declare function prepareCacheDatabaseTables(connection: DatabaseContext, tableName?: string, lockTableName?: string): Promise<void>;
-declare function renderCacheTableMigration(tableName?: string, lockTableName?: string): string;
 declare function isDatabaseCacheTableMissingError(error: unknown, tableName: string, lockTableName: string): boolean;
 declare function normalizeDatabaseCacheTableError(error: unknown, tableName: string, lockTableName: string): never;
 declare function withDatabaseCacheTableGuard<TValue>(tableName: string, lockTableName: string, callback: () => Promise<TValue>): Promise<TValue>;
@@ -51,9 +98,8 @@ declare const cacheDbInternals: {
     prepareCacheDatabaseTables: typeof prepareCacheDatabaseTables;
     readEntry: typeof readEntry;
     readLock: typeof readLock;
-    renderCacheTableMigration: typeof renderCacheTableMigration;
     resolveDriver: typeof resolveDriver;
     withDatabaseCacheTableGuard: typeof withDatabaseCacheTableGuard;
 };
 
-export { DEFAULT_CACHE_DATABASE_LOCK_TABLE, DEFAULT_CACHE_DATABASE_TABLE, type DatabaseCacheDriverOptions, cacheDbInternals, createDatabaseCacheDriver };
+export { CACHE_DATABASE_TABLE_DEFINITIONS, type CacheDatabaseTableColumnDefinition, type CacheDatabaseTableColumnKind, type CacheDatabaseTableDefinition, DEFAULT_CACHE_DATABASE_LOCK_TABLE, DEFAULT_CACHE_DATABASE_TABLE, type DatabaseCacheDriverOptions, cacheDbInternals, createDatabaseCacheDriver };

package/dist/index.mjs

@@ -15,6 +15,30 @@ import {
 } from "@holo-js/db";
 var DEFAULT_CACHE_DATABASE_TABLE = "cache";
 var DEFAULT_CACHE_DATABASE_LOCK_TABLE = "cache_locks";
+var CACHE_DATABASE_TABLE_DEFINITIONS = [
+  {
+    role: "entries",
+    defaultName: DEFAULT_CACHE_DATABASE_TABLE,
+    columns: [
+      { name: "key", kind: "string", primaryKey: true },
+      { name: "payload", kind: "text" },
+      { name: "expires_at", kind: "bigInteger", nullable: true }
+    ],
+    indexColumn: "expires_at",
+    indexName: (tableName) => `${tableName.replaceAll(".", "_")}_expires_at_index`
+  },
+  {
+    role: "locks",
+    defaultName: DEFAULT_CACHE_DATABASE_LOCK_TABLE,
+    columns: [
+      { name: "name", kind: "string", primaryKey: true },
+      { name: "owner", kind: "string" },
+      { name: "expires_at", kind: "bigInteger" }
+    ],
+    indexColumn: "expires_at",
+    indexName: (tableName) => `${tableName.replaceAll(".", "_")}_expires_at_index`
+  }
+];
 function defaultSleep(milliseconds) {
   return new Promise((resolveDelay) => {
     setTimeout(resolveDelay, milliseconds);
@@ -67,53 +91,44 @@ function createDatabaseConnection(connectionName, connection) {
     }
   }).connection(connectionName);
 }
+function applyCacheDatabaseColumnDefinition(table, columnDefinition) {
+  let columnBuilder = table[columnDefinition.kind](columnDefinition.name);
+  if (columnDefinition.primaryKey) {
+    columnBuilder = columnBuilder.primaryKey();
+  }
+  if (columnDefinition.nullable) {
+    columnBuilder.nullable();
+  }
+}
+function applyCacheDatabaseTableDefinition(table, tableName, tableDefinition) {
+  for (const columnDefinition of tableDefinition.columns) {
+    applyCacheDatabaseColumnDefinition(table, columnDefinition);
+  }
+  table.index([tableDefinition.indexColumn], tableDefinition.indexName(tableName));
+}
+function resolveCacheDatabaseTableDefinition(role) {
+  const tableDefinition = CACHE_DATABASE_TABLE_DEFINITIONS.find((definition) => definition.role === role);
+  if (!tableDefinition) {
+    throw new Error(`Missing cache database table definition for "${role}".`);
+  }
+  return tableDefinition;
+}
 async function prepareCacheDatabaseTables(connection, tableName = DEFAULT_CACHE_DATABASE_TABLE, lockTableName = DEFAULT_CACHE_DATABASE_LOCK_TABLE) {
   const schema = createSchemaService(connection);
   await connection.initialize();
+  const entryTableDefinition = resolveCacheDatabaseTableDefinition("entries");
+  const lockTableDefinition = resolveCacheDatabaseTableDefinition("locks");
   if (!await schema.hasTable(tableName)) {
     await schema.createTable(tableName, (table) => {
-      table.string("key").primaryKey();
-      table.text("payload");
-      table.bigInteger("expires_at").nullable();
-      table.index(["expires_at"], `${tableName.replaceAll(".", "_")}_expires_at_index`);
+      applyCacheDatabaseTableDefinition(table, tableName, entryTableDefinition);
     });
   }
   if (!await schema.hasTable(lockTableName)) {
     await schema.createTable(lockTableName, (table) => {
-      table.string("name").primaryKey();
-      table.string("owner");
-      table.bigInteger("expires_at");
-      table.index(["expires_at"], `${lockTableName.replaceAll(".", "_")}_expires_at_index`);
+      applyCacheDatabaseTableDefinition(table, lockTableName, lockTableDefinition);
     });
   }
 }
-function renderCacheTableMigration(tableName = DEFAULT_CACHE_DATABASE_TABLE, lockTableName = DEFAULT_CACHE_DATABASE_LOCK_TABLE) {
-  return [
-    "import { defineMigration, type MigrationContext } from '@holo-js/db'",
-    "",
-    "export default defineMigration({",
-    "  async up({ schema }: MigrationContext) {",
-    `    await schema.createTable('${tableName}', (table) => {`,
-    "      table.string('key').primaryKey()",
-    "      table.text('payload')",
-    "      table.bigInteger('expires_at').nullable()",
-    `      table.index(['expires_at'], '${tableName.replaceAll(".", "_")}_expires_at_index')`,
-    "    })",
-    `    await schema.createTable('${lockTableName}', (table) => {`,
-    "      table.string('name').primaryKey()",
-    "      table.string('owner')",
-    "      table.bigInteger('expires_at')",
-    `      table.index(['expires_at'], '${lockTableName.replaceAll(".", "_")}_expires_at_index')`,
-    "    })",
-    "  },",
-    "  async down({ schema }: MigrationContext) {",
-    `    await schema.dropTable('${lockTableName}')`,
-    `    await schema.dropTable('${tableName}')`,
-    "  },",
-    "})",
-    ""
-  ].join("\n");
-}
 function resolveExecutionResultAffectedRows(result) {
   return result.affectedRows ?? 0;
 }
@@ -366,11 +381,11 @@ var cacheDbInternals = {
   prepareCacheDatabaseTables,
   readEntry,
   readLock,
-  renderCacheTableMigration,
   resolveDriver,
   withDatabaseCacheTableGuard
 };
 export {
+  CACHE_DATABASE_TABLE_DEFINITIONS,
   DEFAULT_CACHE_DATABASE_LOCK_TABLE,
   DEFAULT_CACHE_DATABASE_TABLE,
   cacheDbInternals,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holo-js/cache-db",
-  "version": "0.1.9",
+  "version": "0.2.1",
   "description": "Holo-JS Framework - DB-backed cache driver",
   "type": "module",
   "license": "MIT",
@@ -23,15 +23,15 @@
     "test": "vitest --run"
   },
   "peerDependencies": {
-    "@holo-js/cache": "^0.1.9",
-    "@holo-js/db": "^0.1.9"
+    "@holo-js/cache": "^0.2.1",
+    "@holo-js/db": "^0.2.1"
   },
   "dependencies": {
     "tslib": "^2.8.1"
   },
   "devDependencies": {
-    "@holo-js/cache": "^0.1.9",
-    "@holo-js/db": "^0.1.9",
+    "@holo-js/cache": "^0.2.1",
+    "@holo-js/db": "^0.2.1",
     "@types/node": "^22.10.2",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",