@jskit-ai/database-runtime 0.1.17 → 0.1.18

package/package.descriptor.mjs

@@ -1,7 +1,8 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/database-runtime",
-  version: "0.1.17",
+  version: "0.1.18",
+  kind: "runtime",
   dependsOn: [
     "@jskit-ai/kernel"
   ],
@@ -46,7 +47,9 @@ export default Object.freeze({
       containerTokens: {
         server: [
           "runtime.database",
-          "runtime.database.driver"
+          "runtime.database.driver",
+          "jskit.database.knex",
+          "jskit.database.transactionManager"
         ],
         client: []
       }
@@ -55,7 +58,7 @@ export default Object.freeze({
   mutations: {
     dependencies: {
       runtime: {
-        "@jskit-ai/kernel": "0.1.17",
+        "@jskit-ai/kernel": "0.1.18",
         "dotenv": "^16.4.5",
         "knex": "^3.1.0"
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/database-runtime",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -25,6 +25,6 @@
     "./shared/transactions": "./src/shared/transactions.js"
   },
   "dependencies": {
-    "@jskit-ai/kernel": "0.1.17"
+    "@jskit-ai/kernel": "0.1.18"
   }
 }

package/src/server/providers/DatabaseRuntimeServiceProvider.js

@@ -1,25 +1,18 @@
-import { KERNEL_TOKENS } from "@jskit-ai/kernel/shared/support/tokens";
 import { symlinkSafeRequire } from "@jskit-ai/kernel/server/support";
 import * as databaseRuntime from "../../shared/index.js";
 import { createTransactionManager } from "../../shared/transactionManager.js";
 import {
-  normalizeText,
   normalizeDatabaseClient,
   toKnexClientId
 } from "../../shared/databaseClient.js";
 import { resolveDatabaseConnectionFromEnvironment } from "../../shared/databaseConnection.js";
 
-const DATABASE_RUNTIME_TOKEN = "runtime.database";
-const DATABASE_DRIVER_TOKEN = "runtime.database.driver";
-const MYSQL_DRIVER_TOKEN = "runtime.database.driver.mysql";
-const POSTGRES_DRIVER_TOKEN = "runtime.database.driver.postgres";
-
 const DATABASE_RUNTIME_SERVER_API = Object.freeze({
   ...databaseRuntime
 });
 
 function resolveDatabaseEnv(scope) {
-  const envFromScope = scope?.has?.(KERNEL_TOKENS.Env) ? scope.make(KERNEL_TOKENS.Env) : {};
+  const envFromScope = scope?.has?.("jskit.env") ? scope.make("jskit.env") : {};
   const source = envFromScope && typeof envFromScope === "object" ? envFromScope : {};
   return {
     ...process.env,
@@ -94,12 +87,12 @@ function resolveRegisteredDriver(scope) {
 function resolveRegisteredDrivers(scope) {
   const drivers = [];
 
-  if (scope.has(MYSQL_DRIVER_TOKEN)) {
-    drivers.push(scope.make(MYSQL_DRIVER_TOKEN));
+  if (scope.has("runtime.database.driver.mysql")) {
+    drivers.push(scope.make("runtime.database.driver.mysql"));
   }
 
-  if (scope.has(POSTGRES_DRIVER_TOKEN)) {
-    drivers.push(scope.make(POSTGRES_DRIVER_TOKEN));
+  if (scope.has("runtime.database.driver.postgres")) {
+    drivers.push(scope.make("runtime.database.driver.postgres"));
   }
 
   return drivers;
@@ -145,26 +138,26 @@ function createKnexInstance(scope) {
 }
 
 class DatabaseRuntimeServiceProvider {
-  static id = DATABASE_RUNTIME_TOKEN;
+  static id = "runtime.database";
 
   register(app) {
     if (!app || typeof app.singleton !== "function" || typeof app.has !== "function") {
       throw new Error("DatabaseRuntimeServiceProvider requires application singleton()/has().");
     }
 
-    app.singleton(DATABASE_RUNTIME_TOKEN, () => DATABASE_RUNTIME_SERVER_API);
+    app.singleton("runtime.database", () => DATABASE_RUNTIME_SERVER_API);
 
-    if (!app.has(DATABASE_DRIVER_TOKEN)) {
-      app.singleton(DATABASE_DRIVER_TOKEN, (scope) => resolveSingleRegisteredDriver(scope));
+    if (!app.has("runtime.database.driver")) {
+      app.singleton("runtime.database.driver", (scope) => resolveSingleRegisteredDriver(scope));
     }
 
-    if (!app.has(KERNEL_TOKENS.Knex)) {
-      app.singleton(KERNEL_TOKENS.Knex, (scope) => createKnexInstance(scope));
+    if (!app.has("jskit.database.knex")) {
+      app.singleton("jskit.database.knex", (scope) => createKnexInstance(scope));
     }
 
-    if (!app.has(KERNEL_TOKENS.TransactionManager)) {
-      app.singleton(KERNEL_TOKENS.TransactionManager, (scope) => {
-        const knex = scope.make(KERNEL_TOKENS.Knex);
+    if (!app.has("jskit.database.transactionManager")) {
+      app.singleton("jskit.database.transactionManager", (scope) => {
+        const knex = scope.make("jskit.database.knex");
         return createTransactionManager({ knex });
       });
     }

package/src/shared/runtime.js

@@ -1,4 +1,3 @@
-import { KERNEL_TOKENS } from "@jskit-ai/kernel/shared/support/tokens";
 import { createTransactionManager } from "./transactionManager.js";
 import { DatabaseRuntimeError } from "./runtimeErrors.js";
 
@@ -21,24 +20,24 @@ function ensureKnexInterface(knex) {
 }
 
 function ensureKnexBinding(app, knex) {
-  if (!app.has(KERNEL_TOKENS.Knex)) {
-    app.instance(KERNEL_TOKENS.Knex, knex);
+  if (!app.has("jskit.database.knex")) {
+    app.instance("jskit.database.knex", knex);
     return;
   }
 
-  const existingKnex = app.make(KERNEL_TOKENS.Knex);
+  const existingKnex = app.make("jskit.database.knex");
   if (existingKnex !== knex) {
     throw new DatabaseRuntimeError("registerDatabaseRuntime received knex that differs from existing Knex binding.");
   }
 }
 
 function ensureTransactionManagerBinding(app) {
-  if (app.has(KERNEL_TOKENS.TransactionManager)) {
+  if (app.has("jskit.database.transactionManager")) {
     return;
   }
 
-  app.singleton(KERNEL_TOKENS.TransactionManager, (scope) => {
-    const knex = scope.make(KERNEL_TOKENS.Knex);
+  app.singleton("jskit.database.transactionManager", (scope) => {
+    const knex = scope.make("jskit.database.knex");
     return createTransactionManager({ knex });
   });
 }
@@ -51,8 +50,8 @@ function registerDatabaseRuntime(app, { knex } = {}) {
   ensureTransactionManagerBinding(app);
 
   return {
-    knex: app.make(KERNEL_TOKENS.Knex),
-    transactionManager: app.make(KERNEL_TOKENS.TransactionManager)
+    knex: app.make("jskit.database.knex"),
+    transactionManager: app.make("jskit.database.transactionManager")
   };
 }
 

package/test/providerRuntime.test.js

@@ -4,7 +4,6 @@ import path from "node:path";
 import { tmpdir } from "node:os";
 import test from "node:test";
 
-import { KERNEL_TOKENS } from "@jskit-ai/kernel/shared/support/tokens";
 import { DatabaseRuntimeServiceProvider } from "../src/server/providers/DatabaseRuntimeServiceProvider.js";
 
 function createSingletonApp() {
@@ -111,13 +110,13 @@ test("DatabaseRuntimeServiceProvider registers runtime api", () => {
 
 test("DatabaseRuntimeServiceProvider registers transaction manager when Knex is pre-bound", async () => {
   const app = createSingletonApp();
-  app.instance(KERNEL_TOKENS.Knex, createKnexStub());
+  app.instance("jskit.database.knex", createKnexStub());
 
   const provider = new DatabaseRuntimeServiceProvider();
   provider.register(app);
 
-  assert.equal(app.has(KERNEL_TOKENS.TransactionManager), true);
-  const transactionManager = app.make(KERNEL_TOKENS.TransactionManager);
+  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");
 });
@@ -156,7 +155,7 @@ test("DatabaseRuntimeServiceProvider resolves knex from app root package context
   await withAppRootKnexStub(async () => {
     const app = createSingletonApp();
     app.instance("runtime.database.driver.mysql", Object.freeze({ DIALECT_ID: "mysql2" }));
-    app.instance(KERNEL_TOKENS.Env, {
+    app.instance("jskit.env", {
       DB_HOST: "db.local",
       DB_PORT: "3307",
       DB_NAME: "appdb",
@@ -167,7 +166,7 @@ test("DatabaseRuntimeServiceProvider resolves knex from app root package context
     const provider = new DatabaseRuntimeServiceProvider();
     provider.register(app);
 
-    const knex = app.make(KERNEL_TOKENS.Knex);
+    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");
@@ -182,14 +181,14 @@ test("DatabaseRuntimeServiceProvider resolves knex config from DATABASE_URL when
   await withAppRootKnexStub(async () => {
     const app = createSingletonApp();
     app.instance("runtime.database.driver.mysql", Object.freeze({ DIALECT_ID: "mysql2" }));
-    app.instance(KERNEL_TOKENS.Env, {
+    app.instance("jskit.env", {
       DATABASE_URL: "mysql://urluser:urlpass@db.url.local:3308/url_db_name"
     });
 
     const provider = new DatabaseRuntimeServiceProvider();
     provider.register(app);
 
-    const knex = app.make(KERNEL_TOKENS.Knex);
+    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");

package/test/runtimeCore.test.js

@@ -1,7 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { KERNEL_TOKENS } from "@jskit-ai/kernel/shared/support/tokens";
 import {
   BaseRepository,
   buildPaginationMeta,
@@ -94,5 +93,5 @@ test("registerDatabaseRuntime binds knex and transaction manager tokens", () =>
   const runtime = registerDatabaseRuntime(app, { knex });
   assert.strictEqual(runtime.knex, knex);
   assert.equal(typeof runtime.transactionManager.inTransaction, "function");
-  assert.strictEqual(app.make(KERNEL_TOKENS.Knex), knex);
+  assert.strictEqual(app.make("jskit.database.knex"), knex);
 });