@jskit-ai/uploads-runtime 0.1.134 → 0.1.136

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/uploads-runtime",
-  "version": "0.1.134",
+  "version": "0.1.136",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -8,7 +8,7 @@
   "exports": {
     "./client": "./src/client/index.js",
     "./shared": "./src/shared/index.js",
-    "./server/providers/UploadsRuntimeServiceProvider": "./src/server/providers/UploadsRuntimeServiceProvider.js",
+    "./server/providers/UploadsProvider": "./src/server/providers/UploadsProvider.js",
     "./server/multipart/registerMultipartSupport": "./src/server/multipart/registerMultipartSupport.js",
     "./server/multipart/readSingleMultipartFile": "./src/server/multipart/readSingleMultipartFile.js",
     "./server/policy/uploadPolicy": "./src/server/policy/uploadPolicy.js",
@@ -16,7 +16,7 @@
   },
   "dependencies": {
     "@fastify/multipart": "^9.4.0",
-    "@jskit-ai/kernel": "0.1.159"
+    "@jskit-ai/kernel": "0.1.161"
   },
   "description": "Reusable upload runtime primitives for multipart parsing, policy validation, and blob storage.",
   "jskit": {
@@ -25,15 +25,16 @@
       "provides": [
         "runtime.uploads"
       ],
-      "requires": []
+      "requires": [
+        "runtime.fastify"
+      ]
     },
     "runtime": {
       "server": {
-        "providerEntrypoint": "src/server/providers/UploadsRuntimeServiceProvider.js",
         "providers": [
           {
-            "entrypoint": "src/server/providers/UploadsRuntimeServiceProvider.js",
-            "export": "UploadsRuntimeServiceProvider"
+            "entrypoint": "src/server/providers/UploadsProvider.js",
+            "export": "UploadsProvider"
           }
         ]
       },
@@ -45,8 +46,8 @@
       "apiSummary": {
         "surfaces": [
           {
-            "subpath": "./server/providers/UploadsRuntimeServiceProvider",
-            "summary": "Exports uploads runtime server provider."
+            "subpath": "./server/providers/UploadsProvider",
+            "summary": "Provides runtime.uploads and installs multipart support on the application Fastify instance."
           },
           {
             "subpath": "./server/multipart/registerMultipartSupport",
@@ -62,7 +63,7 @@
           },
           {
             "subpath": "./server/storage/createUploadStorageService",
-            "summary": "Exports raw upload storage helpers backed by jskit.storage."
+            "summary": "Exports raw upload storage helpers backed by runtime.storage."
           },
           {
             "subpath": "./shared",
@@ -72,29 +73,8 @@
             "subpath": "./client",
             "summary": "Exports no client runtime API today (reserved client entrypoint)."
           }
-        ],
-        "containerTokens": {
-          "server": [
-            "runtime.uploads"
-          ],
-          "client": []
-        }
+        ]
       }
-    },
-    "mutations": {
-      "dependencies": {
-        "runtime": {
-          "@fastify/multipart": "^9.4.0",
-          "@jskit-ai/kernel": "0.1.159"
-        },
-        "dev": {}
-      },
-      "packageJson": {
-        "scripts": {}
-      },
-      "procfile": {},
-      "files": [],
-      "text": []
     }
   }
 }

package/src/server/multipart/registerMultipartSupport.js

@@ -1,17 +1,8 @@
 import fastifyMultipart from "@fastify/multipart";
 
-async function registerMultipartSupport(app) {
-  if (!app || typeof app.has !== "function" || typeof app.make !== "function") {
-    throw new Error("registerMultipartSupport requires application has()/make().");
-  }
-
-  if (!app.has("jskit.fastify")) {
-    return;
-  }
-
-  const fastify = app.make("jskit.fastify");
+async function registerMultipartSupport(fastify) {
   if (!fastify || typeof fastify.register !== "function") {
-    throw new Error("registerMultipartSupport requires Fastify register().");
+    throw new Error("registerMultipartSupport requires Fastify.");
   }
 
   if (fastify["jskit.uploads-runtime.multipart.support"] === true) {

package/src/server/providers/{UploadsRuntimeServiceProvider.js → UploadsProvider.js}

@@ -1,3 +1,4 @@
+import { defineProvider } from "@jskit-ai/kernel/shared/capabilities";
 import { registerMultipartSupport } from "../multipart/registerMultipartSupport.js";
 import { readSingleMultipartFile } from "../multipart/readSingleMultipartFile.js";
 import {
@@ -11,8 +12,7 @@ import {
   normalizeStorageKey
 } from "../storage/createUploadStorageService.js";
 
-const UPLOADS_RUNTIME_SERVER_API = Object.freeze({
-  registerMultipartSupport,
+const uploads = Object.freeze({
   readSingleMultipartFile,
   createUploadFieldError,
   readUploadBuffer,
@@ -22,20 +22,20 @@ const UPLOADS_RUNTIME_SERVER_API = Object.freeze({
   normalizeStorageKey
 });
 
-class UploadsRuntimeServiceProvider {
-  static id = "runtime.uploads";
-
-  register(app) {
-    if (!app || typeof app.singleton !== "function") {
-      throw new Error("UploadsRuntimeServiceProvider requires application singleton().");
-    }
-
-    app.singleton("runtime.uploads", () => UPLOADS_RUNTIME_SERVER_API);
+const UploadsProvider = defineProvider({
+  id: "runtime.uploads",
+  requires: {
+    fastify: "runtime.fastify"
+  },
+  provides: {
+    uploads: "runtime.uploads"
+  },
+  setup() {
+    return { uploads };
+  },
+  async boot({ fastify }) {
+    await registerMultipartSupport(fastify);
   }
+});
 
-  async boot(app) {
-    await registerMultipartSupport(app);
-  }
-}
-
-export { UploadsRuntimeServiceProvider };
+export { UploadsProvider };

package/test/exportsContract.test.js

@@ -16,7 +16,7 @@ test("uploads-runtime exports are explicit and aligned with usage", () => {
     requiredExports: [
       "./client",
       "./shared",
-      "./server/providers/UploadsRuntimeServiceProvider",
+      "./server/providers/UploadsProvider",
       "./server/multipart/registerMultipartSupport",
       "./server/multipart/readSingleMultipartFile",
       "./server/policy/uploadPolicy",

package/test/providerRuntime.test.js

@@ -1,73 +1,37 @@
-import test from "node:test";
 import assert from "node:assert/strict";
-import { UploadsRuntimeServiceProvider } from "../src/server/providers/UploadsRuntimeServiceProvider.js";
+import test from "node:test";
 
-function createAppStub({ hasFastify = true, fastify = null } = {}) {
-  const singletons = new Map();
-  const singletonInstances = new Map();
-  const resolvedFastify =
-    fastify ||
-    {
-      register: async () => {},
-      hasContentTypeParser: () => false
-    };
+import { createCapabilityRuntime, defineProvider } from "@jskit-ai/kernel/shared/capabilities";
+import { UploadsProvider } from "../src/server/providers/UploadsProvider.js";
 
-  return {
-    has(token) {
-      if (token === "jskit.fastify") {
-        return hasFastify;
-      }
-      return singletons.has(token) || singletonInstances.has(token);
-    },
-    singleton(token, factory) {
-      singletons.set(token, factory);
+test("UploadsProvider provides upload operations and boots multipart support", async () => {
+  let registerCount = 0;
+  let uploads;
+  const fastify = {
+    async register() {
+      registerCount += 1;
     },
-    make(token) {
-      if (token === "jskit.fastify") {
-        return resolvedFastify;
-      }
-      if (singletonInstances.has(token)) {
-        return singletonInstances.get(token);
-      }
-      const factory = singletons.get(token);
-      if (!factory) {
-        throw new Error(`Unknown token ${String(token)}`);
-      }
-      const instance = factory(this);
-      singletonInstances.set(token, instance);
-      return instance;
+    hasContentTypeParser() {
+      return false;
     }
   };
-}
-
-test("UploadsRuntimeServiceProvider registers runtime uploads api", async () => {
-  const app = createAppStub();
-  const provider = new UploadsRuntimeServiceProvider();
-
-  provider.register(app);
-
-  assert.equal(app.has("runtime.uploads"), true);
-  const runtimeUploads = app.make("runtime.uploads");
-  assert.equal(typeof runtimeUploads.registerMultipartSupport, "function");
-  assert.equal(typeof runtimeUploads.readSingleMultipartFile, "function");
-  assert.equal(typeof runtimeUploads.createUploadStorageService, "function");
-});
-
-test("UploadsRuntimeServiceProvider boots multipart support once", async () => {
-  let registerCount = 0;
-  const app = createAppStub({
-    fastify: {
-      register: async () => {
-        registerCount += 1;
-      },
-      hasContentTypeParser: () => false
+  const consumer = defineProvider({
+    id: "test.uploads.consumer",
+    requires: { value: "runtime.uploads" },
+    setup({ value }) {
+      uploads = value;
+      return {};
     }
   });
+  const runtime = createCapabilityRuntime({
+    inputs: { "runtime.fastify": fastify },
+    providers: [UploadsProvider, consumer]
+  });
 
-  const provider = new UploadsRuntimeServiceProvider();
-  provider.register(app);
-  await provider.boot(app);
-  await provider.boot(app);
-
+  await runtime.start();
   assert.equal(registerCount, 1);
+  assert.equal(typeof uploads.readSingleMultipartFile, "function");
+  assert.equal(typeof uploads.createUploadStorageService, "function");
+  assert.equal(Object.hasOwn(uploads, "make"), false);
+  await runtime.shutdown();
 });

package/test/registerMultipartSupport.test.js

@@ -2,33 +2,8 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import { registerMultipartSupport } from "../src/server/multipart/registerMultipartSupport.js";
 
-function createAppStub({ hasFastify = true, fastify = null } = {}) {
-  const resolvedFastify =
-    fastify ||
-    {
-      register: async () => {},
-      hasContentTypeParser: () => false
-    };
-
-  return {
-    has(token) {
-      if (token === "jskit.fastify") {
-        return hasFastify;
-      }
-      return false;
-    },
-    make(token) {
-      if (token === "jskit.fastify") {
-        return resolvedFastify;
-      }
-      return null;
-    }
-  };
-}
-
-test("registerMultipartSupport returns early when Fastify is not available", async () => {
-  const app = createAppStub({ hasFastify: false });
-  await assert.doesNotReject(async () => registerMultipartSupport(app));
+test("registerMultipartSupport requires the explicit Fastify dependency", async () => {
+  await assert.rejects(registerMultipartSupport(null), /requires Fastify/u);
 });
 
 test("registerMultipartSupport registers multipart parser only once", async () => {
@@ -39,10 +14,8 @@ test("registerMultipartSupport registers multipart parser only once", async () =
     },
     hasContentTypeParser: () => false
   };
-  const app = createAppStub({ fastify });
-
-  await registerMultipartSupport(app);
-  await registerMultipartSupport(app);
+  await registerMultipartSupport(fastify);
+  await registerMultipartSupport(fastify);
 
   assert.equal(registerCount, 1);
 });
@@ -55,9 +28,7 @@ test("registerMultipartSupport skips registration when parser already exists", a
     },
     hasContentTypeParser: (contentType) => String(contentType || "").trim().toLowerCase() === "multipart"
   };
-  const app = createAppStub({ fastify });
-
-  await registerMultipartSupport(app);
+  await registerMultipartSupport(fastify);
 
   assert.equal(registerCount, 0);
 });