brass-runtime 1.15.0 → 1.16.1

package/dist/http/testing.cjs

@@ -0,0 +1,161 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunk5EC274J5cjs = require('../chunk-5EC274J5.cjs');
+require('../chunk-L6VB5N7Q.cjs');
+require('../chunk-KZJQ723N.cjs');
+require('../chunk-SA6HUJVI.cjs');
+require('../chunk-AGR5B2BC.cjs');
+require('../chunk-JF5WGYJJ.cjs');
+require('../chunk-3LOYJFRR.cjs');
+
+
+var _chunkGLE2WY7Zcjs = require('../chunk-GLE2WY7Z.cjs');
+
+
+
+var _chunkMVGUEJ5Zcjs = require('../chunk-MVGUEJ5Z.cjs');
+require('../chunk-CZIVE6NT.cjs');
+require('../chunk-OBGZSXTJ.cjs');
+
+// src/http/testing.ts
+function makeHttpResponse(bodyText = "", init = {}) {
+  return {
+    status: _nullishCoalesce(init.status, () => ( 200)),
+    statusText: _nullishCoalesce(init.statusText, () => ( "OK")),
+    headers: _nullishCoalesce(init.headers, () => ( {})),
+    bodyText,
+    ms: _nullishCoalesce(init.ms, () => ( 0))
+  };
+}
+function makeTextHttpResponse(bodyText, init = {}) {
+  return makeHttpResponse(bodyText, init);
+}
+function makeJsonHttpResponse(body, init = {}) {
+  return makeHttpResponse(JSON.stringify(body), {
+    ...init,
+    headers: {
+      "content-type": "application/json",
+      ..._nullishCoalesce(init.headers, () => ( {}))
+    }
+  });
+}
+function makeMockHttpClient(handler = () => makeHttpResponse()) {
+  const calls = [];
+  const stats = {
+    inFlight: 0,
+    started: 0,
+    succeeded: 0,
+    failed: 0,
+    aborted: 0,
+    timedOut: 0,
+    poolRejected: 0,
+    poolTimeouts: 0
+  };
+  const run = (req) => {
+    calls.push(req);
+    stats.started++;
+    try {
+      const result = handler(req, calls.length - 1);
+      if (isAsync(result)) return result;
+      stats.succeeded++;
+      return _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, result);
+    } catch (error) {
+      stats.failed++;
+      return _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, toHttpError(error));
+    }
+  };
+  return Object.assign(_chunk5EC274J5cjs.decorate.call(void 0, run, () => ({ ...stats })), {
+    calls: () => [...calls],
+    calledTimes: () => calls.length,
+    lastRequest: () => calls.at(-1),
+    reset: () => {
+      calls.length = 0;
+      stats.inFlight = 0;
+      stats.started = 0;
+      stats.succeeded = 0;
+      stats.failed = 0;
+      stats.aborted = 0;
+      stats.timedOut = 0;
+      stats.poolRejected = 0;
+      stats.poolTimeouts = 0;
+      delete stats.lastDurationMs;
+    }
+  });
+}
+function makeSequenceHttpClient(responses, fallback = makeHttpResponse()) {
+  return makeMockHttpClient((_req, index) => _nullishCoalesce(responses[index], () => ( fallback)));
+}
+function runHttpEffect(effect, env = {}) {
+  return _chunkGLE2WY7Zcjs.toPromise.call(void 0, effect, env);
+}
+function makeFetchResponse(body = null, init = {}) {
+  assertResponseAvailable();
+  return new Response(body, init);
+}
+function makeJsonFetchResponse(body, init = {}) {
+  assertResponseAvailable();
+  return new Response(JSON.stringify(body), {
+    ...init,
+    headers: {
+      "content-type": "application/json",
+      ...init.headers
+    }
+  });
+}
+function installMockFetch(handler) {
+  const target = globalThis;
+  const original = target.fetch;
+  const calls = [];
+  const mockFetch = (async (input, init) => {
+    calls.push({ input, init });
+    return handler(input, init, calls.length - 1);
+  });
+  target.fetch = mockFetch;
+  return {
+    fetch: mockFetch,
+    calls: () => [...calls],
+    calledTimes: () => calls.length,
+    lastCall: () => calls.at(-1),
+    restore: () => {
+      if (original) target.fetch = original;
+      else Reflect.deleteProperty(target, "fetch");
+    }
+  };
+}
+async function withMockFetch(handler, run) {
+  const mock = installMockFetch(handler);
+  try {
+    return await run(mock);
+  } finally {
+    mock.restore();
+  }
+}
+function isAsync(value) {
+  return typeof value === "object" && value !== null && "_tag" in value;
+}
+function toHttpError(error) {
+  if (isHttpError(error)) return error;
+  return { _tag: "FetchError", message: error instanceof Error ? error.message : String(error) };
+}
+function isHttpError(error) {
+  if (typeof error !== "object" || error === null || !("_tag" in error)) return false;
+  const tag = error._tag;
+  return tag === "Abort" || tag === "BadUrl" || tag === "FetchError" || tag === "Timeout" || tag === "PoolRejected" || tag === "PoolTimeout" || tag === "PoolClosed" || tag === "BatchSplitError";
+}
+function assertResponseAvailable() {
+  if (typeof Response === "undefined") {
+    throw new Error("HTTP test helpers require global Response for fetch response mocks.");
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+exports.installMockFetch = installMockFetch; exports.makeFetchResponse = makeFetchResponse; exports.makeHttpResponse = makeHttpResponse; exports.makeJsonFetchResponse = makeJsonFetchResponse; exports.makeJsonHttpResponse = makeJsonHttpResponse; exports.makeMockHttpClient = makeMockHttpClient; exports.makeSequenceHttpClient = makeSequenceHttpClient; exports.makeTextHttpResponse = makeTextHttpResponse; exports.runHttpEffect = runHttpEffect; exports.withMockFetch = withMockFetch;

package/dist/http/testing.d.ts

@@ -0,0 +1,43 @@
+import { A as Async } from '../effect-DIUHZ9IN.js';
+import { H as HttpClient, a as HttpRequest, b as HttpWireResponse, c as HttpError } from '../client-CZHU674n.js';
+import '../stream-B4oK9JFP.js';
+import '../schedule-CK3Ml_7p.js';
+import '../schema/index.js';
+
+type HttpTestResponseInit = {
+    readonly status?: number;
+    readonly statusText?: string;
+    readonly headers?: Record<string, string>;
+    readonly ms?: number;
+};
+type MockHttpHandler = (req: HttpRequest, index: number) => HttpWireResponse | Async<unknown, HttpError, HttpWireResponse>;
+type MockHttpClient = HttpClient & {
+    readonly calls: () => readonly HttpRequest[];
+    readonly calledTimes: () => number;
+    readonly lastRequest: () => HttpRequest | undefined;
+    readonly reset: () => void;
+};
+type MockFetchCall = {
+    readonly input: RequestInfo | URL;
+    readonly init?: RequestInit;
+};
+type MockFetchHandler = (input: RequestInfo | URL, init: RequestInit | undefined, index: number) => Response | Promise<Response>;
+type MockFetchController = {
+    readonly fetch: typeof fetch;
+    readonly calls: () => readonly MockFetchCall[];
+    readonly calledTimes: () => number;
+    readonly lastCall: () => MockFetchCall | undefined;
+    readonly restore: () => void;
+};
+declare function makeHttpResponse(bodyText?: string, init?: HttpTestResponseInit): HttpWireResponse;
+declare function makeTextHttpResponse(bodyText: string, init?: HttpTestResponseInit): HttpWireResponse;
+declare function makeJsonHttpResponse(body: unknown, init?: HttpTestResponseInit): HttpWireResponse;
+declare function makeMockHttpClient(handler?: MockHttpHandler): MockHttpClient;
+declare function makeSequenceHttpClient(responses: readonly HttpWireResponse[], fallback?: HttpWireResponse): MockHttpClient;
+declare function runHttpEffect<E, A>(effect: Async<unknown, E, A>, env?: unknown): Promise<A>;
+declare function makeFetchResponse(body?: BodyInit | null, init?: ResponseInit): Response;
+declare function makeJsonFetchResponse(body: unknown, init?: ResponseInit): Response;
+declare function installMockFetch(handler: MockFetchHandler): MockFetchController;
+declare function withMockFetch<A>(handler: MockFetchHandler, run: (mock: MockFetchController) => Promise<A> | A): Promise<A>;
+
+export { type HttpTestResponseInit, type MockFetchCall, type MockFetchController, type MockFetchHandler, type MockHttpClient, type MockHttpHandler, installMockFetch, makeFetchResponse, makeHttpResponse, makeJsonFetchResponse, makeJsonHttpResponse, makeMockHttpClient, makeSequenceHttpClient, makeTextHttpResponse, runHttpEffect, withMockFetch };

package/dist/http/testing.js

@@ -0,0 +1,161 @@
+import {
+  decorate
+} from "../chunk-MIIYDLGM.js";
+import "../chunk-TRM4JUZQ.js";
+import "../chunk-7JIJOVCT.js";
+import "../chunk-UCUBNWM2.js";
+import "../chunk-6IXXWIUM.js";
+import "../chunk-L2SYFEBS.js";
+import "../chunk-3Y2RIUMM.js";
+import {
+  toPromise
+} from "../chunk-FH2X7BVP.js";
+import {
+  asyncFail,
+  asyncSucceed
+} from "../chunk-UB4B6OFY.js";
+import "../chunk-C3MDXTRZ.js";
+import "../chunk-3RG5ZIWI.js";
+
+// src/http/testing.ts
+function makeHttpResponse(bodyText = "", init = {}) {
+  return {
+    status: init.status ?? 200,
+    statusText: init.statusText ?? "OK",
+    headers: init.headers ?? {},
+    bodyText,
+    ms: init.ms ?? 0
+  };
+}
+function makeTextHttpResponse(bodyText, init = {}) {
+  return makeHttpResponse(bodyText, init);
+}
+function makeJsonHttpResponse(body, init = {}) {
+  return makeHttpResponse(JSON.stringify(body), {
+    ...init,
+    headers: {
+      "content-type": "application/json",
+      ...init.headers ?? {}
+    }
+  });
+}
+function makeMockHttpClient(handler = () => makeHttpResponse()) {
+  const calls = [];
+  const stats = {
+    inFlight: 0,
+    started: 0,
+    succeeded: 0,
+    failed: 0,
+    aborted: 0,
+    timedOut: 0,
+    poolRejected: 0,
+    poolTimeouts: 0
+  };
+  const run = (req) => {
+    calls.push(req);
+    stats.started++;
+    try {
+      const result = handler(req, calls.length - 1);
+      if (isAsync(result)) return result;
+      stats.succeeded++;
+      return asyncSucceed(result);
+    } catch (error) {
+      stats.failed++;
+      return asyncFail(toHttpError(error));
+    }
+  };
+  return Object.assign(decorate(run, () => ({ ...stats })), {
+    calls: () => [...calls],
+    calledTimes: () => calls.length,
+    lastRequest: () => calls.at(-1),
+    reset: () => {
+      calls.length = 0;
+      stats.inFlight = 0;
+      stats.started = 0;
+      stats.succeeded = 0;
+      stats.failed = 0;
+      stats.aborted = 0;
+      stats.timedOut = 0;
+      stats.poolRejected = 0;
+      stats.poolTimeouts = 0;
+      delete stats.lastDurationMs;
+    }
+  });
+}
+function makeSequenceHttpClient(responses, fallback = makeHttpResponse()) {
+  return makeMockHttpClient((_req, index) => responses[index] ?? fallback);
+}
+function runHttpEffect(effect, env = {}) {
+  return toPromise(effect, env);
+}
+function makeFetchResponse(body = null, init = {}) {
+  assertResponseAvailable();
+  return new Response(body, init);
+}
+function makeJsonFetchResponse(body, init = {}) {
+  assertResponseAvailable();
+  return new Response(JSON.stringify(body), {
+    ...init,
+    headers: {
+      "content-type": "application/json",
+      ...init.headers
+    }
+  });
+}
+function installMockFetch(handler) {
+  const target = globalThis;
+  const original = target.fetch;
+  const calls = [];
+  const mockFetch = (async (input, init) => {
+    calls.push({ input, init });
+    return handler(input, init, calls.length - 1);
+  });
+  target.fetch = mockFetch;
+  return {
+    fetch: mockFetch,
+    calls: () => [...calls],
+    calledTimes: () => calls.length,
+    lastCall: () => calls.at(-1),
+    restore: () => {
+      if (original) target.fetch = original;
+      else Reflect.deleteProperty(target, "fetch");
+    }
+  };
+}
+async function withMockFetch(handler, run) {
+  const mock = installMockFetch(handler);
+  try {
+    return await run(mock);
+  } finally {
+    mock.restore();
+  }
+}
+function isAsync(value) {
+  return typeof value === "object" && value !== null && "_tag" in value;
+}
+function toHttpError(error) {
+  if (isHttpError(error)) return error;
+  return { _tag: "FetchError", message: error instanceof Error ? error.message : String(error) };
+}
+function isHttpError(error) {
+  if (typeof error !== "object" || error === null || !("_tag" in error)) return false;
+  const tag = error._tag;
+  return tag === "Abort" || tag === "BadUrl" || tag === "FetchError" || tag === "Timeout" || tag === "PoolRejected" || tag === "PoolTimeout" || tag === "PoolClosed" || tag === "BatchSplitError";
+}
+function assertResponseAvailable() {
+  if (typeof Response === "undefined") {
+    throw new Error("HTTP test helpers require global Response for fetch response mocks.");
+  }
+}
+export {
+  installMockFetch,
+  makeFetchResponse,
+  makeHttpResponse,
+  makeJsonFetchResponse,
+  makeJsonHttpResponse,
+  makeMockHttpClient,
+  makeSequenceHttpClient,
+  makeTextHttpResponse,
+  runHttpEffect,
+  withMockFetch
+};

package/dist/http/testing.mjs

@@ -0,0 +1,161 @@
+import {
+  decorate
+} from "../chunk-5VRJNBLZ.mjs";
+import "../chunk-MOO4L7F4.mjs";
+import "../chunk-FHQGHPMO.mjs";
+import "../chunk-B5JD23U7.mjs";
+import "../chunk-2HQTDLHF.mjs";
+import "../chunk-A2OM6NEH.mjs";
+import "../chunk-PWC3RBQE.mjs";
+import {
+  toPromise
+} from "../chunk-GYM3LLGS.mjs";
+import {
+  asyncFail,
+  asyncSucceed
+} from "../chunk-36I3M4UC.mjs";
+import "../chunk-DNFJLJMW.mjs";
+import "../chunk-Y6FXYEAI.mjs";
+
+// src/http/testing.ts
+function makeHttpResponse(bodyText = "", init = {}) {
+  return {
+    status: init.status ?? 200,
+    statusText: init.statusText ?? "OK",
+    headers: init.headers ?? {},
+    bodyText,
+    ms: init.ms ?? 0
+  };
+}
+function makeTextHttpResponse(bodyText, init = {}) {
+  return makeHttpResponse(bodyText, init);
+}
+function makeJsonHttpResponse(body, init = {}) {
+  return makeHttpResponse(JSON.stringify(body), {
+    ...init,
+    headers: {
+      "content-type": "application/json",
+      ...init.headers ?? {}
+    }
+  });
+}
+function makeMockHttpClient(handler = () => makeHttpResponse()) {
+  const calls = [];
+  const stats = {
+    inFlight: 0,
+    started: 0,
+    succeeded: 0,
+    failed: 0,
+    aborted: 0,
+    timedOut: 0,
+    poolRejected: 0,
+    poolTimeouts: 0
+  };
+  const run = (req) => {
+    calls.push(req);
+    stats.started++;
+    try {
+      const result = handler(req, calls.length - 1);
+      if (isAsync(result)) return result;
+      stats.succeeded++;
+      return asyncSucceed(result);
+    } catch (error) {
+      stats.failed++;
+      return asyncFail(toHttpError(error));
+    }
+  };
+  return Object.assign(decorate(run, () => ({ ...stats })), {
+    calls: () => [...calls],
+    calledTimes: () => calls.length,
+    lastRequest: () => calls.at(-1),
+    reset: () => {
+      calls.length = 0;
+      stats.inFlight = 0;
+      stats.started = 0;
+      stats.succeeded = 0;
+      stats.failed = 0;
+      stats.aborted = 0;
+      stats.timedOut = 0;
+      stats.poolRejected = 0;
+      stats.poolTimeouts = 0;
+      delete stats.lastDurationMs;
+    }
+  });
+}
+function makeSequenceHttpClient(responses, fallback = makeHttpResponse()) {
+  return makeMockHttpClient((_req, index) => responses[index] ?? fallback);
+}
+function runHttpEffect(effect, env = {}) {
+  return toPromise(effect, env);
+}
+function makeFetchResponse(body = null, init = {}) {
+  assertResponseAvailable();
+  return new Response(body, init);
+}
+function makeJsonFetchResponse(body, init = {}) {
+  assertResponseAvailable();
+  return new Response(JSON.stringify(body), {
+    ...init,
+    headers: {
+      "content-type": "application/json",
+      ...init.headers
+    }
+  });
+}
+function installMockFetch(handler) {
+  const target = globalThis;
+  const original = target.fetch;
+  const calls = [];
+  const mockFetch = (async (input, init) => {
+    calls.push({ input, init });
+    return handler(input, init, calls.length - 1);
+  });
+  target.fetch = mockFetch;
+  return {
+    fetch: mockFetch,
+    calls: () => [...calls],
+    calledTimes: () => calls.length,
+    lastCall: () => calls.at(-1),
+    restore: () => {
+      if (original) target.fetch = original;
+      else Reflect.deleteProperty(target, "fetch");
+    }
+  };
+}
+async function withMockFetch(handler, run) {
+  const mock = installMockFetch(handler);
+  try {
+    return await run(mock);
+  } finally {
+    mock.restore();
+  }
+}
+function isAsync(value) {
+  return typeof value === "object" && value !== null && "_tag" in value;
+}
+function toHttpError(error) {
+  if (isHttpError(error)) return error;
+  return { _tag: "FetchError", message: error instanceof Error ? error.message : String(error) };
+}
+function isHttpError(error) {
+  if (typeof error !== "object" || error === null || !("_tag" in error)) return false;
+  const tag = error._tag;
+  return tag === "Abort" || tag === "BadUrl" || tag === "FetchError" || tag === "Timeout" || tag === "PoolRejected" || tag === "PoolTimeout" || tag === "PoolClosed" || tag === "BatchSplitError";
+}
+function assertResponseAvailable() {
+  if (typeof Response === "undefined") {
+    throw new Error("HTTP test helpers require global Response for fetch response mocks.");
+  }
+}
+export {
+  installMockFetch,
+  makeFetchResponse,
+  makeHttpResponse,
+  makeJsonFetchResponse,
+  makeJsonHttpResponse,
+  makeMockHttpClient,
+  makeSequenceHttpClient,
+  makeTextHttpResponse,
+  runHttpEffect,
+  withMockFetch
+};