@bluelibs/runner 4.8.0 → 4.8.2

package/dist/node/resources/http-mixed-client.factory.resource.d.ts

@@ -0,0 +1,17 @@
+import type { MixedHttpClient } from "../http-mixed-client";
+export interface HttpMixedClientFactoryConfig {
+    baseUrl: string;
+    auth?: {
+        header?: string;
+        token: string;
+    };
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+    onRequest?: (ctx: {
+        url: string;
+        headers: Record<string, string>;
+    }) => void | Promise<void>;
+}
+export type HttpMixedClientFactory = (config: HttpMixedClientFactoryConfig) => MixedHttpClient;
+export declare const httpMixedClientFactory: import("..").IResource<void, Promise<HttpMixedClientFactory>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+export type { MixedHttpClient };

package/dist/node/resources/http-smart-client.factory.resource.d.ts

@@ -0,0 +1,16 @@
+import type { HttpSmartClient } from "../http-smart-client.model";
+export interface HttpSmartClientFactoryConfig {
+    baseUrl: string;
+    auth?: {
+        header?: string;
+        token: string;
+    };
+    timeoutMs?: number;
+    onRequest?: (ctx: {
+        url: string;
+        headers: Record<string, string>;
+    }) => void | Promise<void>;
+}
+export type HttpSmartClientFactory = (config: HttpSmartClientFactoryConfig) => HttpSmartClient;
+export declare const httpSmartClientFactory: import("..").IResource<void, Promise<HttpSmartClientFactory>, {}, any, any, import("..").TagType[], import("..").ResourceMiddlewareAttachmentType[]>;
+export type { HttpSmartClient };

package/dist/universal/index.cjs

@@ -362,7 +362,7 @@ var error = errorBuilder;
 
 // src/platform/adapters/node-als.ts
 async function loadAsyncLocalStorageClass() {
-  const mod = await import('async_hooks');
+  const mod = __require("async_hooks");
   return mod.AsyncLocalStorage;
 }
 __name(loadAsyncLocalStorageClass, "loadAsyncLocalStorageClass");
@@ -1248,7 +1248,7 @@ function defineAsyncContext(def) {
     map.set(ctxId, value);
     return storage.run(map, fn);
   }, "provide");
-  const serializer = getDefaultSerializer();
+  const serializer2 = getDefaultSerializer();
   const api = {
     id: ctxId,
     [symbolAsyncContext]: true,
@@ -1264,9 +1264,9 @@ function defineAsyncContext(def) {
       });
     },
     /* istanbul ignore next */
-    serialize: def.serialize || ((data) => serializer.stringify(data)),
+    serialize: def.serialize || ((data) => serializer2.stringify(data)),
     /* istanbul ignore next */
-    parse: def.parse || ((data) => serializer.parse(data)),
+    parse: def.parse || ((data) => serializer2.parse(data)),
     optional() {
       return {
         inner: api,
@@ -1427,6 +1427,352 @@ var queueResource = defineResource({
   }
 });
 
+// src/globals/resources/tunnel/protocol.ts
+var TunnelError = class extends Error {
+  static {
+    __name(this, "TunnelError");
+  }
+  constructor(code, message, details, extras) {
+    super(message);
+    this.name = "TunnelError";
+    this.code = code;
+    this.details = details;
+    this.id = extras?.id;
+    this.data = extras?.data;
+  }
+};
+function toTunnelError(input, fallbackMessage) {
+  if (input instanceof Error) {
+    return new TunnelError("UNKNOWN", input.message);
+  }
+  if (input && typeof input === "object" && "code" in input && "message" in input && typeof input.message === "string" && typeof input.code === "string") {
+    const pe = input;
+    const msg = pe.message || fallbackMessage || "Tunnel error";
+    return new TunnelError(pe.code, msg, pe.details, {
+      id: pe.id,
+      data: pe.data
+    });
+  }
+  if (input && typeof input === "object" && "message" in input && typeof input.message === "string") {
+    return new TunnelError("UNKNOWN", input.message);
+  }
+  return new TunnelError(
+    "UNKNOWN",
+    typeof input === "string" && input || fallbackMessage || "Tunnel error"
+  );
+}
+__name(toTunnelError, "toTunnelError");
+function assertOkEnvelope(envelope, opts) {
+  if (!envelope || typeof envelope !== "object") {
+    throw new TunnelError(
+      "INVALID_RESPONSE",
+      opts?.fallbackMessage || "Invalid or empty response"
+    );
+  }
+  if (envelope.ok) {
+    return envelope.result;
+  }
+  if (envelope.error) {
+    return (() => {
+      throw toTunnelError(envelope.error, opts?.fallbackMessage);
+    })();
+  }
+  throw new TunnelError("UNKNOWN", opts?.fallbackMessage || "Tunnel error");
+}
+__name(assertOkEnvelope, "assertOkEnvelope");
+
+// src/http-fetch-tunnel.resource.ts
+async function postSerialized(fetchFn, url, body, headers, timeoutMs, serializer2, onRequest, contextHeaderText) {
+  const controller = timeoutMs && timeoutMs > 0 ? new AbortController() : void 0;
+  let timeout;
+  try {
+    if (controller) {
+      timeout = setTimeout(() => controller.abort(), timeoutMs);
+    }
+    const reqHeaders = {
+      "content-type": "application/json; charset=utf-8",
+      ...headers
+    };
+    if (contextHeaderText) reqHeaders["x-runner-context"] = contextHeaderText;
+    if (onRequest) await onRequest({ url, headers: reqHeaders });
+    const res = await fetchFn(url, {
+      method: "POST",
+      headers: reqHeaders,
+      body: serializer2.stringify(body),
+      signal: controller?.signal
+    });
+    const text = await res.text();
+    const json = text ? serializer2.parse(text) : void 0;
+    return json;
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+__name(postSerialized, "postSerialized");
+function createExposureFetch(cfg) {
+  const baseUrl = (cfg?.baseUrl).replace(/\/$/, "");
+  if (!baseUrl) throw new Error("createExposureFetch requires baseUrl");
+  const headerName = (cfg?.auth?.header ?? "x-runner-token").toLowerCase();
+  const buildHeaders = /* @__PURE__ */ __name(() => {
+    const headers = {};
+    if (cfg?.auth?.token) headers[headerName] = cfg.auth.token;
+    return headers;
+  }, "buildHeaders");
+  const fetchImpl = cfg.fetchImpl ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new Error(
+      "global fetch is not available; provide fetchImpl in config"
+    );
+  }
+  const buildContextHeader = /* @__PURE__ */ __name(() => {
+    if (!cfg.contexts || cfg.contexts.length === 0) return void 0;
+    const map = {};
+    for (const ctx of cfg.contexts) {
+      try {
+        const v = ctx.use();
+        map[ctx.id] = ctx.serialize(v);
+      } catch {
+      }
+    }
+    const keys = Object.keys(map);
+    if (keys.length === 0) return void 0;
+    return cfg.serializer.stringify(map);
+  }, "buildContextHeader");
+  return {
+    async task(id2, input) {
+      const url = `${baseUrl}/task/${encodeURIComponent(id2)}`;
+      const r2 = await postSerialized(
+        fetchImpl,
+        url,
+        { input },
+        buildHeaders(),
+        cfg?.timeoutMs,
+        cfg.serializer,
+        cfg?.onRequest,
+        buildContextHeader()
+      );
+      try {
+        return assertOkEnvelope(r2, { fallbackMessage: "Tunnel task error" });
+      } catch (e) {
+        const te = e;
+        if (te && cfg.errorRegistry && te.id && te.data) {
+          const helper = cfg.errorRegistry.get(String(te.id));
+          if (helper) helper.throw(te.data);
+        }
+        throw e;
+      }
+    },
+    async event(id2, payload) {
+      const url = `${baseUrl}/event/${encodeURIComponent(id2)}`;
+      const r2 = await postSerialized(
+        fetchImpl,
+        url,
+        { payload },
+        buildHeaders(),
+        cfg?.timeoutMs,
+        cfg.serializer,
+        cfg?.onRequest,
+        buildContextHeader()
+      );
+      try {
+        assertOkEnvelope(r2, { fallbackMessage: "Tunnel event error" });
+      } catch (e) {
+        const te = e;
+        if (te && cfg.errorRegistry && te.id && te.data) {
+          const helper = cfg.errorRegistry.get(String(te.id));
+          if (helper) helper.throw(te.data);
+        }
+        throw e;
+      }
+    }
+  };
+}
+__name(createExposureFetch, "createExposureFetch");
+
+// src/tunnels/buildUniversalManifest.ts
+function buildUniversalManifest(input) {
+  const nodeFiles = [];
+  const webFiles = [];
+  function visit(value) {
+    if (!value || typeof value !== "object") return value;
+    if (value.$ejson === "File" && typeof value.id === "string") {
+      const v = value;
+      const id2 = v.id;
+      const meta = v.meta;
+      const node = v._node;
+      const web = v._web;
+      if (node?.buffer) {
+        nodeFiles.push({
+          id: id2,
+          meta,
+          source: { type: "buffer", buffer: node.buffer }
+        });
+      } else if (node?.stream) {
+        nodeFiles.push({
+          id: id2,
+          meta,
+          source: { type: "stream", stream: node.stream }
+        });
+      } else if (web?.blob) {
+        webFiles.push({ id: id2, meta, blob: web.blob });
+      }
+      const copy = { $ejson: "File", id: id2, meta };
+      return copy;
+    }
+    if (Array.isArray(value)) {
+      return value.map((x) => visit(x));
+    }
+    const out = {};
+    for (const k of Object.keys(value)) {
+      out[k] = visit(value[k]);
+    }
+    return out;
+  }
+  __name(visit, "visit");
+  const cloned = visit(input);
+  return {
+    input: cloned,
+    nodeFiles,
+    webFiles
+  };
+}
+__name(buildUniversalManifest, "buildUniversalManifest");
+
+// src/http-client.ts
+function toHeaders(auth) {
+  const headers = {};
+  if (auth?.token)
+    headers[(auth.header ?? "x-runner-token").toLowerCase()] = auth.token;
+  return headers;
+}
+__name(toHeaders, "toHeaders");
+function createHttpClient(cfg) {
+  const baseUrl = cfg.baseUrl.replace(/\/$/, "");
+  if (!baseUrl) throw new Error("createHttpClient requires baseUrl");
+  const fetchClient = createExposureFetch({
+    baseUrl,
+    auth: cfg.auth,
+    timeoutMs: cfg.timeoutMs,
+    fetchImpl: cfg.fetchImpl,
+    serializer: cfg.serializer,
+    onRequest: cfg.onRequest,
+    contexts: cfg.contexts,
+    errorRegistry: cfg.errorRegistry
+  });
+  async function postMultipartBrowser(url, manifestText, files) {
+    const fd = new FormData();
+    fd.append("__manifest", manifestText);
+    for (const f of files) {
+      const filename = f.meta?.name ?? "upload";
+      fd.append(`file:${f.id}`, f.blob, filename);
+    }
+    const headers = toHeaders(cfg.auth);
+    if (cfg.contexts && cfg.contexts.length > 0) {
+      const map = {};
+      for (const ctx of cfg.contexts) {
+        try {
+          const v = ctx.use();
+          map[ctx.id] = ctx.serialize(v);
+        } catch {
+        }
+      }
+      if (Object.keys(map).length > 0) {
+        headers["x-runner-context"] = cfg.serializer.stringify(map);
+      }
+    }
+    if (cfg.onRequest) await cfg.onRequest({ url, headers });
+    const fetchImpl = cfg.fetchImpl ?? globalThis.fetch;
+    const res = await fetchImpl(url, { method: "POST", body: fd, headers });
+    const text = await res.text();
+    const json = text ? cfg.serializer.parse(text) : void 0;
+    return json;
+  }
+  __name(postMultipartBrowser, "postMultipartBrowser");
+  return {
+    async task(id2, input) {
+      const url = `${baseUrl}/task/${encodeURIComponent(id2)}`;
+      if (input && typeof input.pipe === "function") {
+        throw new Error(
+          "createHttpClient (universal) cannot send a Node stream. Use @bluelibs/runner/node createHttpSmartClient or createHttpMixedClient for duplex/streaming."
+        );
+      }
+      const manifest = buildUniversalManifest(input);
+      if (manifest.webFiles.length > 0) {
+        const manifestText = cfg.serializer.stringify({ input: manifest.input });
+        const r2 = await postMultipartBrowser(url, manifestText, manifest.webFiles);
+        try {
+          return assertOkEnvelope(r2, {
+            fallbackMessage: "Tunnel task error"
+          });
+        } catch (e) {
+          const te = e;
+          if (te && cfg.errorRegistry && te.id && te.data) {
+            const helper = cfg.errorRegistry.get(String(te.id));
+            if (helper) helper.throw(te.data);
+          }
+          throw e;
+        }
+      }
+      if (manifest.nodeFiles.length > 0) {
+        throw new Error(
+          "createHttpClient (universal) detected Node file input. Use @bluelibs/runner/node createHttpSmartClient or createHttpMixedClient for Node streaming/multipart."
+        );
+      }
+      try {
+        return await fetchClient.task(id2, input);
+      } catch (e) {
+        const te = e;
+        if (te && cfg.errorRegistry && te.id && te.data) {
+          const helper = cfg.errorRegistry.get(String(te.id));
+          if (helper) helper.throw(te.data);
+        }
+        throw e;
+      }
+    },
+    async event(id2, payload) {
+      try {
+        return await fetchClient.event(id2, payload);
+      } catch (e) {
+        const te = e;
+        if (te && cfg.errorRegistry && te.id && te.data) {
+          const helper = cfg.errorRegistry.get(String(te.id));
+          if (helper) helper.throw(te.data);
+        }
+        throw e;
+      }
+    }
+  };
+}
+__name(createHttpClient, "createHttpClient");
+
+// src/globals/resources/httpClientFactory.resource.ts
+var httpClientFactory = defineResource({
+  id: "globals.resources.httpClientFactory",
+  meta: {
+    title: "HTTP Client Factory",
+    description: "Factory for creating HTTP clients with automatic injection of serializer, error registry, and async contexts from the store."
+  },
+  // Use it as a function to avoid circular dependencies, and undefined
+  dependencies: /* @__PURE__ */ __name(() => ({
+    serializer,
+    store
+  }), "dependencies"),
+  init: /* @__PURE__ */ __name(async (_, { serializer: serializer2, store: store2 }) => {
+    const errorRegistry = /* @__PURE__ */ new Map();
+    for (const [id2, helper] of store2.errors) {
+      errorRegistry.set(id2, helper);
+    }
+    const contexts = Array.from(store2.asyncContexts.values());
+    const create = /* @__PURE__ */ __name((config) => createHttpClient({
+      ...config,
+      serializer: serializer2,
+      errorRegistry,
+      contexts
+    }), "create");
+    return create;
+  }, "init")
+});
+
 // src/globals/globalResources.ts
 var systemTag2 = globalTags.system;
 var store = defineResource({
@@ -1437,6 +1783,14 @@ var store = defineResource({
   },
   tags: [systemTag2]
 });
+var serializer = defineResource({
+  id: "globals.resources.serializer",
+  meta: {
+    title: "Serializer",
+    description: "Serializes and deserializes data. Provides EJSON-compatible stringify/parse and custom type registration via addType."
+  },
+  tags: [systemTag2]
+});
 var globalResources = {
   store,
   middlewareManager: defineResource({
@@ -1472,16 +1826,10 @@ var globalResources = {
     },
     tags: [systemTag2]
   }),
-  serializer: defineResource({
-    id: "globals.resources.serializer",
-    meta: {
-      title: "Serializer",
-      description: "Serializes and deserializes data. Provides EJSON-compatible stringify/parse and custom type registration via addType."
-    },
-    tags: [systemTag2]
-  }),
+  serializer,
   cache: cacheResource,
-  queue: queueResource
+  queue: queueResource,
+  httpClientFactory
 };
 
 // src/globals/middleware/retry.middleware.ts
@@ -4043,6 +4391,7 @@ var Store = class {
       this.middlewareManager
     );
     this.registry.storeGenericItem(globalResources.queue);
+    this.registry.storeGenericItem(globalResources.httpClientFactory);
     for (const [resource2, value] of builtInResourcesMap.entries()) {
       this.registry.storeGenericItem(resource2);
       const entry = this.resources.get(resource2.id);
@@ -4708,168 +5057,6 @@ function extractResourceAndConfig(resourceOrResourceWithConfig) {
 }
 __name(extractResourceAndConfig, "extractResourceAndConfig");
 
-// src/globals/resources/tunnel/protocol.ts
-var TunnelError = class extends Error {
-  static {
-    __name(this, "TunnelError");
-  }
-  constructor(code, message, details, extras) {
-    super(message);
-    this.name = "TunnelError";
-    this.code = code;
-    this.details = details;
-    this.id = extras?.id;
-    this.data = extras?.data;
-  }
-};
-function toTunnelError(input, fallbackMessage) {
-  if (input instanceof Error) {
-    return new TunnelError("UNKNOWN", input.message);
-  }
-  if (input && typeof input === "object" && "code" in input && "message" in input && typeof input.message === "string" && typeof input.code === "string") {
-    const pe = input;
-    const msg = pe.message || fallbackMessage || "Tunnel error";
-    return new TunnelError(pe.code, msg, pe.details, {
-      id: pe.id,
-      data: pe.data
-    });
-  }
-  if (input && typeof input === "object" && "message" in input && typeof input.message === "string") {
-    return new TunnelError("UNKNOWN", input.message);
-  }
-  return new TunnelError(
-    "UNKNOWN",
-    typeof input === "string" && input || fallbackMessage || "Tunnel error"
-  );
-}
-__name(toTunnelError, "toTunnelError");
-function assertOkEnvelope(envelope, opts) {
-  if (!envelope || typeof envelope !== "object") {
-    throw new TunnelError(
-      "INVALID_RESPONSE",
-      opts?.fallbackMessage || "Invalid or empty response"
-    );
-  }
-  if (envelope.ok) {
-    return envelope.result;
-  }
-  if (envelope.error) {
-    return (() => {
-      throw toTunnelError(envelope.error, opts?.fallbackMessage);
-    })();
-  }
-  throw new TunnelError("UNKNOWN", opts?.fallbackMessage || "Tunnel error");
-}
-__name(assertOkEnvelope, "assertOkEnvelope");
-
-// src/http-fetch-tunnel.resource.ts
-async function postSerialized(fetchFn, url, body, headers, timeoutMs, serializer, onRequest, contextHeaderText) {
-  const controller = timeoutMs && timeoutMs > 0 ? new AbortController() : void 0;
-  let timeout;
-  try {
-    if (controller) {
-      timeout = setTimeout(() => controller.abort(), timeoutMs);
-    }
-    const reqHeaders = {
-      "content-type": "application/json; charset=utf-8",
-      ...headers
-    };
-    if (contextHeaderText) reqHeaders["x-runner-context"] = contextHeaderText;
-    if (onRequest) await onRequest({ url, headers: reqHeaders });
-    const res = await fetchFn(url, {
-      method: "POST",
-      headers: reqHeaders,
-      body: serializer.stringify(body),
-      signal: controller?.signal
-    });
-    const text = await res.text();
-    const json = text ? serializer.parse(text) : void 0;
-    return json;
-  } finally {
-    if (timeout) clearTimeout(timeout);
-  }
-}
-__name(postSerialized, "postSerialized");
-function createExposureFetch(cfg) {
-  const baseUrl = (cfg?.baseUrl).replace(/\/$/, "");
-  if (!baseUrl) throw new Error("createExposureFetch requires baseUrl");
-  const headerName = (cfg?.auth?.header ?? "x-runner-token").toLowerCase();
-  const buildHeaders = /* @__PURE__ */ __name(() => {
-    const headers = {};
-    if (cfg?.auth?.token) headers[headerName] = cfg.auth.token;
-    return headers;
-  }, "buildHeaders");
-  const fetchImpl = cfg.fetchImpl ?? globalThis.fetch;
-  if (typeof fetchImpl !== "function") {
-    throw new Error(
-      "global fetch is not available; provide fetchImpl in config"
-    );
-  }
-  const buildContextHeader = /* @__PURE__ */ __name(() => {
-    if (!cfg.contexts || cfg.contexts.length === 0) return void 0;
-    const map = {};
-    for (const ctx of cfg.contexts) {
-      try {
-        const v = ctx.use();
-        map[ctx.id] = ctx.serialize(v);
-      } catch {
-      }
-    }
-    const keys = Object.keys(map);
-    if (keys.length === 0) return void 0;
-    return cfg.serializer.stringify(map);
-  }, "buildContextHeader");
-  return {
-    async task(id2, input) {
-      const url = `${baseUrl}/task/${encodeURIComponent(id2)}`;
-      const r2 = await postSerialized(
-        fetchImpl,
-        url,
-        { input },
-        buildHeaders(),
-        cfg?.timeoutMs,
-        cfg.serializer,
-        cfg?.onRequest,
-        buildContextHeader()
-      );
-      try {
-        return assertOkEnvelope(r2, { fallbackMessage: "Tunnel task error" });
-      } catch (e) {
-        const te = e;
-        if (te && cfg.errorRegistry && te.id && te.data) {
-          const helper = cfg.errorRegistry.get(String(te.id));
-          if (helper) helper.throw(te.data);
-        }
-        throw e;
-      }
-    },
-    async event(id2, payload) {
-      const url = `${baseUrl}/event/${encodeURIComponent(id2)}`;
-      const r2 = await postSerialized(
-        fetchImpl,
-        url,
-        { payload },
-        buildHeaders(),
-        cfg?.timeoutMs,
-        cfg.serializer,
-        cfg?.onRequest,
-        buildContextHeader()
-      );
-      try {
-        assertOkEnvelope(r2, { fallbackMessage: "Tunnel event error" });
-      } catch (e) {
-        const te = e;
-        if (te && cfg.errorRegistry && te.id && te.data) {
-          const helper = cfg.errorRegistry.get(String(te.id));
-          if (helper) helper.throw(te.data);
-        }
-        throw e;
-      }
-    }
-  };
-}
-__name(createExposureFetch, "createExposureFetch");
-
 // src/globals/tunnels/index.ts
 var http = Object.freeze({
   createClient(cfg) {