@jskit-ai/storage-runtime 0.1.155 → 0.1.157

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@jskit-ai/storage-runtime",
-  "version": "0.1.155",
+  "version": "0.1.157",
   "type": "module",
   "scripts": {
     "test": "node --test"
   },
   "exports": {
     "./client": "./src/client/index.js",
-    "./server/providers/StorageRuntimeServiceProvider": "./src/server/providers/StorageRuntimeServiceProvider.js"
+    "./server/providers/StorageProvider": "./src/server/providers/StorageProvider.js"
   },
   "dependencies": {
-    "@jskit-ai/kernel": "0.1.158",
+    "@jskit-ai/kernel": "0.1.160",
     "unstorage": "^1.17.5"
   },
   "jskit": {
@@ -19,15 +19,16 @@
       "provides": [
         "runtime.storage"
       ],
-      "requires": []
+      "requires": [
+        "runtime.app-root"
+      ]
     },
     "runtime": {
       "server": {
-        "providerEntrypoint": "src/server/providers/StorageRuntimeServiceProvider.js",
         "providers": [
           {
-            "entrypoint": "src/server/providers/StorageRuntimeServiceProvider.js",
-            "export": "StorageRuntimeServiceProvider"
+            "entrypoint": "src/server/providers/StorageProvider.js",
+            "export": "StorageProvider"
           }
         ]
       },
@@ -39,37 +40,15 @@
       "apiSummary": {
         "surfaces": [
           {
-            "subpath": "./server/providers/StorageRuntimeServiceProvider",
-            "summary": "Exports storage runtime server provider."
+            "subpath": "./server/providers/StorageProvider",
+            "summary": "Provides the configured runtime.storage instance."
           },
           {
             "subpath": "./client",
             "summary": "Exports no client runtime API today (reserved client entrypoint)."
           }
-        ],
-        "containerTokens": {
-          "server": [
-            "runtime.storage",
-            "jskit.storage"
-          ],
-          "client": []
-        }
+        ]
       }
-    },
-    "mutations": {
-      "dependencies": {
-        "runtime": {
-          "@jskit-ai/kernel": "0.1.158",
-          "unstorage": "^1.17.3"
-        },
-        "dev": {}
-      },
-      "packageJson": {
-        "scripts": {}
-      },
-      "procfile": {},
-      "files": [],
-      "text": []
     }
   }
 }

package/src/server/providers/StorageProvider.js

@@ -0,0 +1,20 @@
+import { defineProvider } from "@jskit-ai/kernel/shared/capabilities";
+import { createStorageBinding } from "../storageBinding.js";
+
+const StorageProvider = defineProvider({
+  id: "runtime.storage",
+  requires: {
+    appRoot: "runtime.app-root",
+    env: "runtime.env"
+  },
+  provides: {
+    storage: "runtime.storage"
+  },
+  setup({ appRoot, env }) {
+    return {
+      storage: createStorageBinding({ env, rootDir: appRoot })
+    };
+  }
+});
+
+export { StorageProvider };

package/src/server/storageBinding.js

@@ -23,8 +23,7 @@ function resolveFsBasePath(fsBasePath, { rootDir } = {}) {
   return path.resolve(resolvedRootDir, "data", "storage");
 }
 
-function createStorageBinding(scope, { rootDir = process.cwd() } = {}) {
-  const env = scope && typeof scope.has === "function" && scope.has("jskit.env") ? scope.make("jskit.env") : {};
+function createStorageBinding({ env = {}, rootDir = process.cwd() } = {}) {
   const driver = normalizeStorageDriver(env?.[STORAGE_DRIVER_ENV_KEY]);
 
   if (driver === "memory") {

package/test/providerRuntime.test.js

@@ -1,46 +1,31 @@
-import test from "node:test";
 import assert from "node:assert/strict";
-import { StorageRuntimeServiceProvider } from "../src/server/providers/StorageRuntimeServiceProvider.js";
-
-function createSingletonApp() {
-  const singletons = new Map();
+import test from "node:test";
 
-  return {
-    has(token) {
-      return singletons.has(token);
-    },
-    singleton(token, factory) {
-      singletons.set(token, factory(this));
-    },
-    make(token) {
-      if (!singletons.has(token)) {
-        throw new Error(`Token ${String(token)} is not registered.`);
-      }
-      return singletons.get(token);
+import { createCapabilityRuntime, defineProvider } from "@jskit-ai/kernel/shared/capabilities";
+import { StorageProvider } from "../src/server/providers/StorageProvider.js";
+
+test("StorageProvider provides the configured storage instance directly", async () => {
+  let storage;
+  const consumer = defineProvider({
+    id: "test.storage.consumer",
+    requires: { value: "runtime.storage" },
+    setup({ value }) {
+      storage = value;
+      return {};
     }
-  };
-}
-
-test("StorageRuntimeServiceProvider registers runtime storage api and storage binding", async () => {
-  const app = createSingletonApp();
-  app.singleton("jskit.env", () => ({
-    JSKIT_STORAGE_DRIVER: "memory"
-  }));
-
-  const provider = new StorageRuntimeServiceProvider();
-  provider.register(app);
-
-  assert.equal(app.has("runtime.storage"), true);
-  assert.equal(app.has("jskit.storage"), true);
-
-  const runtimeStorageApi = app.make("runtime.storage");
-  assert.equal(typeof runtimeStorageApi.createStorageBinding, "function");
+  });
+  const runtime = createCapabilityRuntime({
+    inputs: {
+      "runtime.app-root": process.cwd(),
+      "runtime.env": { JSKIT_STORAGE_DRIVER: "memory" }
+    },
+    providers: [StorageProvider, consumer]
+  });
 
-  const storage = app.make("jskit.storage");
+  await runtime.start();
   assert.equal(typeof storage.setItemRaw, "function");
   assert.equal(typeof storage.getItemRaw, "function");
-
   await storage.setItemRaw("tests/storage-runtime", Buffer.from("ok"));
-  const value = await storage.getItemRaw("tests/storage-runtime");
-  assert.equal(Buffer.from(value).toString(), "ok");
+  assert.equal(Buffer.from(await storage.getItemRaw("tests/storage-runtime")).toString(), "ok");
+  await runtime.shutdown();
 });

package/src/server/providers/StorageRuntimeServiceProvider.js

@@ -1,22 +0,0 @@
-import * as storageBinding from "../storageBinding.js";
-
-const STORAGE_RUNTIME_SERVER_API = Object.freeze({
-  ...storageBinding
-});
-
-class StorageRuntimeServiceProvider {
-  static id = "runtime.storage";
-
-  register(app) {
-    if (!app || typeof app.singleton !== "function") {
-      throw new Error("StorageRuntimeServiceProvider requires application singleton().");
-    }
-
-    app.singleton("runtime.storage", () => STORAGE_RUNTIME_SERVER_API);
-    app.singleton("jskit.storage", (scope) => storageBinding.createStorageBinding(scope));
-  }
-
-  boot() {}
-}
-
-export { StorageRuntimeServiceProvider };