@jskit-ai/database-runtime 0.1.159 → 0.1.161

package/test/packageMetadata.test.js

@@ -1,51 +1,16 @@
 import assert from "node:assert/strict";
-import { readFile } from "node:fs/promises";
-import path from "node:path";
 import test from "node:test";
-import { fileURLToPath } from "node:url";
 import packageJson from "../package.json" with { type: "json" };
 
-const packageMetadata = packageJson.jskit;
-
-const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-
-test("database-runtime db migrate scripts sync JSKIT-managed migrations before Knex reads them", () => {
-  const scripts = packageMetadata.mutations.packageJson.scripts;
-
-  assert.equal(scripts["db:migrations:sync"], "jskit migrations sync");
-  assert.equal(
-    scripts["db:migrate"],
-    "npm run db:migrations:sync && knex --knexfile ./knexfile.js migrate:latest"
-  );
-  assert.equal(
-    scripts["db:migrate:status"],
-    "npm run db:migrations:sync && knex --knexfile ./knexfile.js migrate:list"
-  );
-  assert.equal(
-    scripts["db:migrate:rollback"],
-    "knex --knexfile ./knexfile.js migrate:rollback"
-  );
-  assert.deepEqual(packageMetadata.ci.steps, [
-    {
-      id: "database-migrations",
-      phase: "before-verify",
-      label: "Apply database migrations",
-      command: "npm run db:migrate"
-    }
-  ]);
-});
-
-test("database-runtime runs deferred constraints after all ordinary migrations", async () => {
-  const knexfile = await readFile(path.join(PACKAGE_ROOT, "templates/knexfile.js"), "utf8");
-  const deferredDirectoryMutation = packageMetadata.mutations.files.find(
-    (mutation) => mutation.id === "database-runtime-constraint-migrations-dir"
-  );
-
-  assert.match(
-    knexfile,
-    /directory:\s*\[migrationsDirectory,\s*deferredConstraintsDirectory\]/
-  );
-  assert.match(knexfile, /sortDirsSeparately:\s*true/);
-  assert.match(knexfile, /path\.join\(migrationsDirectory,\s*"constraints"\)/);
-  assert.equal(deferredDirectoryMutation?.to, "migrations/constraints/.gitkeep");
+test("database-runtime exposes migration configuration without authoring mutations", () => {
+  assert.equal(packageJson.exports?.["./server/knexMigrationConfig"], "./src/server/knexMigrationConfig.js");
+  assert.equal(packageJson.exports?.["./server/databaseSetup"], "./src/server/databaseSetup.js");
+  assert.equal(Object.hasOwn(packageJson.jskit, "mutations"), false);
+  assert.equal(Object.hasOwn(packageJson.jskit, "ci"), false);
+  assert.equal(Object.hasOwn(packageJson.jskit, "options"), false);
+  assert.equal(Object.hasOwn(packageJson.jskit.metadata.apiSummary, "containerTokens"), false);
+  assert.deepEqual(packageJson.jskit.capabilities, {
+    provides: ["runtime.database"],
+    requires: ["runtime.database.driver"]
+  });
 });

package/test/providerRuntime.test.js

@@ -1,63 +1,36 @@
 import assert from "node:assert/strict";
-import { mkdtemp, mkdir, writeFile } from "node:fs/promises";
-import path from "node:path";
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
+import path from "node:path";
 import test from "node:test";
 
-import { DatabaseRuntimeServiceProvider } from "../src/server/providers/DatabaseRuntimeServiceProvider.js";
-
-function createSingletonApp() {
-  const singletons = new Map();
-  const instances = new Map();
-
-  return {
-    has(token) {
-      return singletons.has(token) || instances.has(token);
-    },
-    singleton(token, factory) {
-      if (this.has(token)) {
-        throw new Error(`Token ${String(token)} is already registered.`);
-      }
-      singletons.set(token, {
-        factory,
-        resolved: false,
-        value: undefined
-      });
-    },
-    instance(token, value) {
-      if (this.has(token)) {
-        throw new Error(`Token ${String(token)} is already registered.`);
-      }
-      instances.set(token, value);
-    },
-    make(token) {
-      if (instances.has(token)) {
-        return instances.get(token);
-      }
-      if (!singletons.has(token)) {
-        throw new Error(`Token ${String(token)} is not registered.`);
-      }
-      const entry = singletons.get(token);
-      if (!entry.resolved) {
-        entry.value = entry.factory(this);
-        entry.resolved = true;
-        instances.set(token, entry.value);
-      }
-      return entry.value;
+import { defineProvider, createCapabilityRuntime } from "@jskit-ai/kernel/shared/capabilities";
+import { DatabaseProvider } from "../src/server/providers/DatabaseProvider.js";
+
+function driverProvider(dialectId = "mysql2") {
+  return defineProvider({
+    id: `test.database.driver.${dialectId}`,
+    provides: { driver: "runtime.database.driver" },
+    setup() {
+      return {
+        driver: Object.freeze({
+          DIALECT_ID: dialectId,
+          getDialectId: () => dialectId
+        })
+      };
     }
-  };
+  });
 }
 
-function createKnexStub() {
-  return {
-    destroyCalls: 0,
-    async transaction(callback) {
-      return callback({ trxId: "trx-1" });
-    },
-    async destroy() {
-      this.destroyCalls += 1;
+function databaseConsumer(onDatabase) {
+  return defineProvider({
+    id: "test.database.consumer",
+    requires: { database: "runtime.database" },
+    setup({ database }) {
+      onDatabase(database);
+      return {};
     }
-  };
+  });
 }
 
 async function withAppRootKnexStub(callback) {
@@ -67,12 +40,7 @@ async function withAppRootKnexStub(callback) {
   await writeFile(path.join(appRoot, "package.json"), JSON.stringify({ name: "runtime-app", private: true }), "utf8");
   await writeFile(
     path.join(knexPackageDir, "package.json"),
-    JSON.stringify({
-      name: "knex",
-      version: "0.0.0-test",
-      main: "index.js",
-      type: "commonjs"
-    }),
+    JSON.stringify({ name: "knex", version: "0.0.0-test", main: "index.js", type: "commonjs" }),
     "utf8"
   );
   await writeFile(
@@ -82,9 +50,11 @@ async function withAppRootKnexStub(callback) {
       "  return {",
       "    __source: 'app-root-knex',",
       "    __config: config,",
+      "    destroyCalls: 0,",
       "    transaction: async function transaction(callback) {",
       "      return callback({ trxId: 'trx-app-root' });",
-      "    }",
+      "    },",
+      "    destroy: async function destroy() { this.destroyCalls += 1; }",
       "  };",
       "};",
       ""
@@ -101,120 +71,92 @@ async function withAppRootKnexStub(callback) {
   }
 }
 
-test("DatabaseRuntimeServiceProvider registers runtime api", () => {
-  const app = createSingletonApp();
-  const provider = new DatabaseRuntimeServiceProvider();
-  provider.register(app);
-
-  assert.equal(app.has("runtime.database"), true);
-  const api = app.make("runtime.database");
-  assert.equal(typeof api.createTransactionManager, "function");
-  assert.equal(typeof api.resolveRepoClient, "function");
-});
-
-test("DatabaseRuntimeServiceProvider registers transaction manager when Knex is pre-bound", async () => {
-  const app = createSingletonApp();
-  app.instance("jskit.database.knex", createKnexStub());
-
-  const provider = new DatabaseRuntimeServiceProvider();
-  provider.register(app);
-
-  assert.equal(app.has("jskit.database.transactionManager"), true);
-  const transactionManager = app.make("jskit.database.transactionManager");
-  const result = await transactionManager.inTransaction(async (trx) => trx.trxId);
-  assert.equal(result, "trx-1");
-});
-
-test("DatabaseRuntimeServiceProvider driver token resolves to registered mysql driver", () => {
-  const app = createSingletonApp();
-  app.instance("runtime.database.driver.mysql", Object.freeze({ DIALECT_ID: "mysql2" }));
-
-  const provider = new DatabaseRuntimeServiceProvider();
-  provider.register(app);
-
-  const driver = app.make("runtime.database.driver");
-  assert.deepEqual(driver, { DIALECT_ID: "mysql2" });
-});
-
-test("DatabaseRuntimeServiceProvider driver token throws when no driver registered", () => {
-  const app = createSingletonApp();
-  const provider = new DatabaseRuntimeServiceProvider();
-  provider.register(app);
-
-  assert.throws(() => app.make("runtime.database.driver"), /No database driver is registered\./);
-});
-
-test("DatabaseRuntimeServiceProvider driver token throws when multiple drivers are registered", () => {
-  const app = createSingletonApp();
-  app.instance("runtime.database.driver.mysql", Object.freeze({ DIALECT_ID: "mysql2" }));
-  app.instance("runtime.database.driver.postgres", Object.freeze({ DIALECT_ID: "pg" }));
-
-  const provider = new DatabaseRuntimeServiceProvider();
-  provider.register(app);
-
-  assert.throws(() => app.make("runtime.database.driver"), /Multiple database drivers are registered\./);
-});
-
-test("DatabaseRuntimeServiceProvider resolves knex from app root package context", async () => {
+test("DatabaseProvider exposes one cohesive database capability", async () => {
   await withAppRootKnexStub(async () => {
-    const app = createSingletonApp();
-    app.instance("runtime.database.driver.mysql", Object.freeze({ DIALECT_ID: "mysql2" }));
-    app.instance("jskit.env", {
-      DB_HOST: "db.local",
-      DB_PORT: "3307",
-      DB_NAME: "appdb",
-      DB_USER: "appuser",
-      DB_PASSWORD: "apppass"
+    let database;
+    const runtime = createCapabilityRuntime({
+      inputs: {
+        "runtime.env": {
+          DB_HOST: "db.local",
+          DB_PORT: "3307",
+          DB_NAME: "appdb",
+          DB_USER: "appuser",
+          DB_PASSWORD: "apppass"
+        }
+      },
+      providers: [
+        driverProvider(),
+        DatabaseProvider,
+        databaseConsumer((value) => {
+          database = value;
+        })
+      ]
     });
 
-    const provider = new DatabaseRuntimeServiceProvider();
-    provider.register(app);
+    await runtime.start();
+
+    assert.equal(database.driver.DIALECT_ID, "mysql2");
+    assert.equal(database.knex.__source, "app-root-knex");
+    assert.equal(database.knex.__config.client, "mysql2");
+    assert.deepEqual(database.knex.__config.connection, {
+      host: "db.local",
+      port: 3307,
+      database: "appdb",
+      user: "appuser",
+      password: "apppass",
+      supportBigNumbers: true,
+      bigNumberStrings: true,
+      dateStrings: ["DATE"],
+      timezone: "Z"
+    });
+    assert.equal(typeof database.transactionManager.inTransaction, "function");
+    assert.equal(typeof database.resolveRepoClient, "function");
 
-    const knex = app.make("jskit.database.knex");
-    assert.equal(knex.__source, "app-root-knex");
-    assert.equal(knex.__config.client, "mysql2");
-    assert.equal(knex.__config.connection.host, "db.local");
-    assert.equal(knex.__config.connection.port, 3307);
-    assert.equal(knex.__config.connection.database, "appdb");
-    assert.equal(knex.__config.connection.user, "appuser");
-    assert.equal(knex.__config.connection.password, "apppass");
-    assert.deepEqual(knex.__config.connection.dateStrings, ["DATE"]);
+    await runtime.shutdown();
+    assert.equal(database.knex.destroyCalls, 1);
+    assert.deepEqual(await runtime.shutdown(), []);
+    assert.equal(database.knex.destroyCalls, 1);
   });
 });
 
-test("DatabaseRuntimeServiceProvider resolves knex config from DATABASE_URL when DB_* vars are omitted", async () => {
+test("DatabaseProvider accepts DATABASE_URL without redundant DB_CLIENT", async () => {
   await withAppRootKnexStub(async () => {
-    const app = createSingletonApp();
-    app.instance("runtime.database.driver.mysql", Object.freeze({ DIALECT_ID: "mysql2" }));
-    app.instance("jskit.env", {
-      DATABASE_URL: "mysql://urluser:urlpass@db.url.local:3308/url_db_name"
+    let database;
+    const runtime = createCapabilityRuntime({
+      inputs: {
+        "runtime.env": {
+          DATABASE_URL: "mysql://urluser:urlpass@db.url.local:3308/url_db_name"
+        }
+      },
+      providers: [driverProvider(), DatabaseProvider, databaseConsumer((value) => { database = value; })]
     });
 
-    const provider = new DatabaseRuntimeServiceProvider();
-    provider.register(app);
-
-    const knex = app.make("jskit.database.knex");
-    assert.equal(knex.__source, "app-root-knex");
-    assert.equal(knex.__config.client, "mysql2");
-    assert.equal(knex.__config.connection.host, "db.url.local");
-    assert.equal(knex.__config.connection.port, 3308);
-    assert.equal(knex.__config.connection.database, "url_db_name");
-    assert.equal(knex.__config.connection.user, "urluser");
-    assert.equal(knex.__config.connection.password, "urlpass");
+    await runtime.start();
+    assert.equal(database.knex.__config.connection.host, "db.url.local");
+    assert.equal(database.knex.__config.connection.port, 3308);
+    assert.equal(database.knex.__config.connection.database, "url_db_name");
+    assert.equal(database.knex.__config.connection.user, "urluser");
+    assert.equal(database.knex.__config.connection.password, "urlpass");
+    await runtime.shutdown();
   });
 });
 
-test("DatabaseRuntimeServiceProvider destroys resolved knex during shutdown", async () => {
-  const app = createSingletonApp();
-  const knex = createKnexStub();
-  app.instance("jskit.database.knex", knex);
-
-  const provider = new DatabaseRuntimeServiceProvider();
-  provider.register(app);
-
-  await provider.shutdown(app);
-  assert.equal(knex.destroyCalls, 1);
+test("DatabaseProvider rejects environment dialect mismatch", async () => {
+  await withAppRootKnexStub(async () => {
+    const runtime = createCapabilityRuntime({
+      inputs: {
+        "runtime.env": {
+          DB_CLIENT: "pg",
+          DB_NAME: "appdb",
+          DB_USER: "appuser"
+        }
+      },
+      providers: [driverProvider(), DatabaseProvider]
+    });
 
-  await provider.shutdown(app);
-  assert.equal(knex.destroyCalls, 1);
+    await assert.rejects(
+      runtime.start(),
+      /DB_CLIENT="pg" does not match installed database driver "mysql2"\./
+    );
+  });
 });

package/test/repositoryOptions.test.js

@@ -1,12 +1,29 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import {
+  lockScopedRecordId,
   normalizeDbRecordId,
   parseMetadataJson,
   resolveInsertedRecordId,
   stringifyMetadataJson
 } from "../src/shared/repositoryOptions.js";
 
+function fakeLockTransaction(row = null) {
+  const calls = [];
+  const query = {
+    select(value) { calls.push(["select", value]); return this; },
+    where(key, value) { calls.push(["where", key, value]); return this; },
+    andWhere(key, value) { calls.push(["andWhere", key, value]); return this; },
+    forUpdate() { calls.push(["forUpdate"]); return this; },
+    async first() { calls.push(["first"]); return row; }
+  };
+  const trx = (table) => {
+    calls.push(["table", table]);
+    return query;
+  };
+  return { calls, trx };
+}
+
 test("parseMetadataJson parses object-like metadata payloads", () => {
   assert.deepEqual(parseMetadataJson(""), {});
   assert.deepEqual(parseMetadataJson("{"), {});
@@ -40,3 +57,33 @@ test("resolveInsertedRecordId normalizes insert ids without accepting unsafe JS
   assert.equal(resolveInsertedRecordId([42]), "42");
   assert.equal(resolveInsertedRecordId([unsafeNumericId]), null);
 });
+
+test("lockScopedRecordId locks an exact record inside its owner scope", async () => {
+  const { calls, trx } = fakeLockTransaction({ id: "42" });
+  assert.equal(await lockScopedRecordId({
+    trx,
+    tableName: "daycare_events",
+    recordId: 42,
+    scopeId: 7
+  }), "42");
+  assert.deepEqual(calls, [
+    ["table", "daycare_events"],
+    ["select", "id"],
+    ["where", "id", "42"],
+    ["andWhere", "workspace_id", "7"],
+    ["forUpdate"],
+    ["first"]
+  ]);
+});
+
+test("lockScopedRecordId rejects missing transactions and unsafe identifiers", async () => {
+  await assert.rejects(
+    () => lockScopedRecordId({ tableName: "records", recordId: 1, scopeId: 1 }),
+    /requires a transaction/u
+  );
+  const { trx } = fakeLockTransaction();
+  await assert.rejects(
+    () => lockScopedRecordId({ trx, tableName: "records; drop table", recordId: 1, scopeId: 1 }),
+    /safe SQL identifier/u
+  );
+});

package/test/runtimeCore.test.js

@@ -5,8 +5,7 @@ import {
   BaseRepository,
   buildPaginationMeta,
   createTransactionManager,
-  createWithTransaction,
-  registerDatabaseRuntime,
+  createWithTransaction
 } from "../src/shared/index.js";
 
 function createKnexStub() {
@@ -17,48 +16,6 @@ function createKnexStub() {
   };
 }
 
-function createSingletonApp() {
-  const singletons = new Map();
-  const instances = new Map();
-
-  return {
-    has(token) {
-      return singletons.has(token) || instances.has(token);
-    },
-    instance(token, value) {
-      if (this.has(token)) {
-        throw new Error(`Token ${String(token)} is already registered.`);
-      }
-      instances.set(token, value);
-    },
-    singleton(token, factory) {
-      if (this.has(token)) {
-        throw new Error(`Token ${String(token)} is already registered.`);
-      }
-      singletons.set(token, {
-        factory,
-        resolved: false,
-        value: undefined
-      });
-    },
-    make(token) {
-      if (instances.has(token)) {
-        return instances.get(token);
-      }
-      if (!singletons.has(token)) {
-        throw new Error(`Token ${String(token)} is not registered.`);
-      }
-      const entry = singletons.get(token);
-      if (!entry.resolved) {
-        entry.value = entry.factory(this);
-        entry.resolved = true;
-        instances.set(token, entry.value);
-      }
-      return entry.value;
-    }
-  };
-}
-
 test("transaction manager wraps callback in knex transaction", async () => {
   const manager = createTransactionManager({ knex: createKnexStub() });
   const result = await manager.inTransaction(async (trx) => ({ ok: true, trx }));
@@ -95,13 +52,3 @@ test("pagination helpers generate stable metadata", () => {
     hasNext: true
   });
 });
-
-test("registerDatabaseRuntime binds knex and transaction manager tokens", () => {
-  const app = createSingletonApp();
-  const knex = createKnexStub();
-
-  const runtime = registerDatabaseRuntime(app, { knex });
-  assert.strictEqual(runtime.knex, knex);
-  assert.equal(typeof runtime.transactionManager.inTransaction, "function");
-  assert.strictEqual(app.make("jskit.database.knex"), knex);
-});