@securitydept/client 0.3.0-beta.1 → 0.3.0-beta.11

package/dist/fetch-transport-DtnSRWAH.mjs

@@ -1,631 +0,0 @@
-//#region src/errors/types.ts
-/** Recovery actions the user might take. Aligned with server-side `UserRecovery`. */
-const UserRecovery = {
-	None: "none",
-	Retry: "retry",
-	RestartFlow: "restart_flow",
-	Reauthenticate: "reauthenticate",
-	ContactSupport: "contact_support"
-};
-const ErrorPresentationTone = {
-	Neutral: "neutral",
-	Warning: "warning",
-	Danger: "danger"
-};
-/** Machine-facing error kind discriminator. */
-const ClientErrorKind = {
-	Authorization: "authorization",
-	Transport: "transport",
-	Server: "server",
-	Protocol: "protocol",
-	Presentation: "presentation",
-	Validation: "validation",
-	Storage: "storage",
-	Scheduler: "scheduler",
-	Configuration: "configuration",
-	Unauthenticated: "unauthenticated",
-	Unauthorized: "unauthorized",
-	RedirectRequired: "redirect_required",
-	Cancelled: "cancelled",
-	Timeout: "timeout",
-	Internal: "internal"
-};
-/** Stable source vocabulary for common client error producers. */
-const ClientErrorSource = {
-	Transport: "transport",
-	Server: "server",
-	ClientRuntime: "client_runtime"
-};
-//#endregion
-//#region src/errors/client-error.ts
-function mapServerErrorKind(kind, status) {
-	switch (kind) {
-		case "unauthenticated": return ClientErrorKind.Unauthenticated;
-		case "unauthorized": return ClientErrorKind.Unauthorized;
-		case "unavailable":
-		case "internal": return ClientErrorKind.Server;
-		case "invalid_request":
-		case "conflict": return ClientErrorKind.Protocol;
-		default: return status === 401 ? ClientErrorKind.Unauthenticated : status === 403 ? ClientErrorKind.Unauthorized : status >= 500 ? ClientErrorKind.Server : ClientErrorKind.Protocol;
-	}
-}
-function readServerErrorBody(body) {
-	if (!body || typeof body !== "object") return void 0;
-	const record = body;
-	const error = record.error && typeof record.error === "object" ? record.error : record;
-	return {
-		kind: typeof error.kind === "string" ? error.kind : void 0,
-		code: typeof error.code === "string" ? error.code : void 0,
-		message: typeof error.message === "string" ? error.message : void 0,
-		recovery: typeof error.recovery === "string" ? error.recovery : void 0,
-		presentation: error.presentation && typeof error.presentation === "object" ? {
-			code: typeof error.presentation.code === "string" ? error.presentation.code : void 0,
-			message: typeof error.presentation.message === "string" ? error.presentation.message : void 0,
-			recovery: typeof error.presentation.recovery === "string" ? error.presentation.recovery : void 0
-		} : void 0
-	};
-}
-/**
-* Base client error carrying both machine-facing context and an optional
-* user-facing presentation layer.
-*
-* Top-level `code` and `recovery` provide stable machine contracts for
-* policy decisions without requiring callers to unwrap `presentation`.
-*/
-var ClientError = class ClientError extends Error {
-	kind;
-	/**
-	* Stable machine-readable error code.
-	* Matches `presentation.code` when present, otherwise a default
-	* derived from `kind`.
-	*/
-	code;
-	/** Recovery hint at the machine level. */
-	recovery;
-	/** Whether this error is safe to retry. */
-	retryable;
-	/** Structured user-facing error presentation from the server. */
-	presentation;
-	/** Source subsystem or component that produced the error. */
-	source;
-	constructor(options) {
-		super(options.message, { cause: options.cause });
-		this.name = "ClientError";
-		this.kind = options.kind;
-		this.code = options.code ?? options.presentation?.code ?? `client.${options.kind}`;
-		this.recovery = options.recovery ?? options.presentation?.recovery ?? UserRecovery.None;
-		this.retryable = options.retryable ?? this.recovery === UserRecovery.Retry;
-		this.presentation = options.presentation;
-		this.source = options.source;
-	}
-	/** Create a `ClientError` from a server error response body. */
-	static fromServerError(body, overrides) {
-		const rawPresentation = body.presentation;
-		const presentation = (rawPresentation?.code ?? body.code) && (rawPresentation?.message ?? body.message) ? {
-			code: rawPresentation?.code ?? body.code ?? "unknown_server_error",
-			message: rawPresentation?.message ?? body.message ?? "Unknown server error",
-			recovery: rawPresentation?.recovery ?? body.recovery ?? UserRecovery.None
-		} : void 0;
-		return new ClientError({
-			kind: overrides?.kind ?? mapServerErrorKind(body.kind, 400),
-			message: presentation?.message ?? body.message ?? "Unknown server error",
-			presentation,
-			source: overrides?.source
-		});
-	}
-	/**
-	* Create a `ClientError` from an HTTP response status and optional body.
-	* Used when a non-success status is unexpected.
-	*/
-	static fromHttpResponse(status, body) {
-		const serverBody = readServerErrorBody(body);
-		const kind = mapServerErrorKind(serverBody?.kind, status);
-		const source = status >= 500 ? ClientErrorSource.Server : ClientErrorSource.ClientRuntime;
-		if (serverBody?.code && serverBody?.message) return ClientError.fromServerError(serverBody, {
-			kind,
-			source
-		});
-		const recovery = kind === ClientErrorKind.Unauthenticated ? UserRecovery.Reauthenticate : status >= 500 ? UserRecovery.Retry : UserRecovery.None;
-		return new ClientError({
-			kind,
-			message: serverBody?.message ?? `HTTP ${status}`,
-			code: serverBody?.code ?? `http.${status}`,
-			recovery,
-			retryable: status >= 500,
-			source
-		});
-	}
-};
-//#endregion
-//#region src/logging/types.ts
-const LogLevel = {
-	Debug: "debug",
-	Info: "info",
-	Warn: "warn",
-	Error: "error"
-};
-const OperationTraceEventType = {
-	Started: "operation.started",
-	Event: "operation.event",
-	Error: "operation.error",
-	Ended: "operation.ended"
-};
-//#endregion
-//#region src/logging/operation-tracer.ts
-const defaultClock = { now: () => Date.now() };
-function createDefaultOperationId() {
-	return `op_${Math.random().toString(36).slice(2, 10)}`;
-}
-var DefaultOperationScope = class {
-	id;
-	_attributes;
-	_ended = false;
-	constructor(_name, _clock, _traceSink, _logger, _scope, _source, idFactory, attributes) {
-		this._name = _name;
-		this._clock = _clock;
-		this._traceSink = _traceSink;
-		this._logger = _logger;
-		this._scope = _scope;
-		this._source = _source;
-		this.id = idFactory();
-		this._attributes = { ...attributes ?? {} };
-		this._recordTrace(OperationTraceEventType.Started, {
-			operationName: this._name,
-			...this._attributes
-		});
-	}
-	addEvent(type, attributes) {
-		this._recordTrace(OperationTraceEventType.Event, {
-			operationName: this._name,
-			eventType: type,
-			...this._attributes,
-			...attributes ?? {}
-		});
-	}
-	setAttribute(key, value) {
-		this._attributes[key] = value;
-	}
-	recordError(error, attributes) {
-		const errorAttributes = describeError(error);
-		this._recordTrace(OperationTraceEventType.Error, {
-			operationName: this._name,
-			...this._attributes,
-			...errorAttributes,
-			...attributes ?? {}
-		});
-		this._logger?.log({
-			level: LogLevel.Error,
-			message: `Operation failed: ${this._name}`,
-			scope: this._scope,
-			attributes: {
-				operationId: this.id,
-				operationName: this._name,
-				...this._attributes,
-				...errorAttributes,
-				...attributes ?? {}
-			},
-			error,
-			at: this._clock.now()
-		});
-	}
-	end(attributes) {
-		if (this._ended) return;
-		this._ended = true;
-		this._recordTrace(OperationTraceEventType.Ended, {
-			operationName: this._name,
-			...this._attributes,
-			...attributes ?? {}
-		});
-	}
-	_recordTrace(type, attributes) {
-		this._traceSink?.record({
-			type,
-			at: this._clock.now(),
-			scope: this._scope,
-			source: this._source,
-			operationId: this.id,
-			attributes
-		});
-	}
-};
-function createOperationTracer(options = {}) {
-	const clock = options.clock ?? defaultClock;
-	const idFactory = options.idFactory ?? createDefaultOperationId;
-	return { startOperation(name, attributes) {
-		return new DefaultOperationScope(name, clock, options.traceSink, options.logger, options.scope, options.source, idFactory, attributes);
-	} };
-}
-function describeError(error) {
-	if (typeof error === "object" && error !== null && "name" in error && "message" in error) {
-		const genericError = error;
-		return {
-			errorName: genericError.name,
-			errorMessage: genericError.message
-		};
-	}
-	return { errorValue: String(error) };
-}
-//#endregion
-//#region src/scheduling/default-clock.ts
-/** Default clock backed by `Date.now()`. */
-function createDefaultClock() {
-	return { now() {
-		return Date.now();
-	} };
-}
-//#endregion
-//#region src/scheduling/default-scheduler.ts
-/** Default scheduler backed by platform `setTimeout`. */
-function createDefaultScheduler() {
-	return { setTimeout(delayMs, fn) {
-		const id = globalThis.setTimeout(fn, delayMs);
-		return { cancel() {
-			globalThis.clearTimeout(id);
-		} };
-	} };
-}
-//#endregion
-//#region src/runtime/create-runtime.ts
-/**
-* Create a `ClientRuntime` with non-host-specific defaults filled in for
-* convenience.
-*
-* Host-specific capabilities such as browser `fetch` should be supplied
-* explicitly or composed via adapter-specific helpers such as
-* `@securitydept/client/web`.
-*/
-function createRuntime(overrides) {
-	const clock = overrides.clock ?? createDefaultClock();
-	const traceSink = overrides.traceSink;
-	const logger = overrides.logger;
-	return {
-		transport: overrides.transport,
-		scheduler: overrides.scheduler ?? createDefaultScheduler(),
-		clock,
-		logger,
-		traceSink,
-		operationTracer: overrides.operationTracer ?? createOperationTracer({
-			clock,
-			logger,
-			traceSink
-		}),
-		persistentStore: overrides.persistentStore,
-		sessionStore: overrides.sessionStore
-	};
-}
-//#endregion
-//#region src/scheduling/helpers.ts
-const PromiseSettlementKind = {
-	Fulfilled: "fulfilled",
-	Rejected: "rejected"
-};
-/**
-* Schedule a one-shot callback after a delay.
-*
-* Returns a {@link CancelableHandle} that can cancel the pending timer.
-*
-* @example
-* ```ts
-* const handle = timer({
-*   scheduler: runtime.scheduler,
-*   delayMs: 5000,
-*   callback: () => console.log("fired"),
-* });
-* // Cancel before it fires:
-* handle.cancel();
-* ```
-*/
-function timer(options) {
-	return options.scheduler.setTimeout(options.delayMs, options.callback);
-}
-/**
-* Schedule a repeating callback at a fixed interval.
-*
-* Built on top of `Scheduler.setTimeout` so it works with deterministic
-* test schedulers. Returns a {@link CancelableHandle} to stop the interval.
-*
-* @example
-* ```ts
-* const handle = interval({
-*   scheduler: runtime.scheduler,
-*   periodMs: 30_000,
-*   callback: () => refreshTokens(),
-* });
-* // Stop:
-* handle.cancel();
-* ```
-*/
-function interval(options) {
-	let canceled = false;
-	let currentHandle = null;
-	function tick() {
-		if (canceled) return;
-		options.callback();
-		scheduleNext();
-	}
-	function scheduleNext() {
-		if (canceled) return;
-		currentHandle = options.scheduler.setTimeout(options.periodMs, tick);
-	}
-	scheduleNext();
-	return { cancel() {
-		canceled = true;
-		currentHandle?.cancel();
-		currentHandle = null;
-	} };
-}
-/**
-* Schedule a callback at a specific wall-clock time.
-*
-* Computes the delay from `clock.now()` to `atMs` and delegates to
-* `Scheduler.setTimeout`. If the target time is already in the past,
-* the callback fires on the next scheduler tick (delay 0).
-*
-* @example
-* ```ts
-* const handle = scheduleAt({
-*   scheduler: runtime.scheduler,
-*   clock: runtime.clock,
-*   atMs: tokenExpiresAtMs - 30_000,
-*   callback: () => refreshToken(),
-* });
-* ```
-*/
-function scheduleAt(options) {
-	const delay = Math.max(0, options.atMs - options.clock.now());
-	return options.scheduler.setTimeout(delay, options.callback);
-}
-/**
-* Adapt an SDK signal into the shared {@link Subscription} callback model.
-*
-* @example
-* ```ts
-* const sub = fromSignal({
-*   signal: authState,
-*   callback: (snapshot) => console.log(snapshot),
-* });
-* sub.unsubscribe();
-* ```
-*/
-function fromSignal(options) {
-	if (options.emitInitialValue) options.callback(options.signal.get());
-	const unsubscribe = options.signal.subscribe(() => {
-		options.callback(options.signal.get());
-	});
-	return { unsubscribe() {
-		unsubscribe();
-	} };
-}
-/**
-* Adapt a promise settlement into the shared {@link Subscription} callback model.
-*
-* This helper is intentionally thin: it reports one settlement and lets the
-* consumer decide how to model pending/fulfilled/error state.
-*
-* @example
-* ```ts
-* const sub = fromPromise({
-*   promise: fetchConfig(),
-*   callback: (settlement) => {
-*     if (settlement.kind === PromiseSettlementKind.Fulfilled) {
-*       console.log(settlement.value);
-*     }
-*   },
-* });
-* sub.unsubscribe();
-* ```
-*/
-function fromPromise(options) {
-	let active = true;
-	Promise.resolve(options.promise).then((value) => {
-		if (!active) return;
-		options.callback({
-			kind: PromiseSettlementKind.Fulfilled,
-			value
-		});
-	}, (reason) => {
-		if (!active) return;
-		options.callback({
-			kind: PromiseSettlementKind.Rejected,
-			reason
-		});
-	});
-	return { unsubscribe() {
-		active = false;
-	} };
-}
-/**
-* Adapt an arbitrary add/remove event pattern into a {@link Subscription}.
-*
-* This is a thin bridge between imperative event APIs (e.g. `addEventListener`
-* / `removeEventListener`) and the SDK's subscription model.
-*
-* @example
-* ```ts
-* const sub = fromEventPattern<Event>({
-*   addHandler: (h) => document.addEventListener("visibilitychange", h),
-*   removeHandler: (h) => document.removeEventListener("visibilitychange", h),
-*   callback: () => onVisibilityChange(),
-* });
-* // Cleanup:
-* sub.unsubscribe();
-* ```
-*/
-function fromEventPattern(options) {
-	const handler = (value) => {
-		options.callback(value);
-	};
-	options.addHandler(handler);
-	return { unsubscribe() {
-		options.removeHandler(handler);
-	} };
-}
-//#endregion
-//#region src/web/input-sources.ts
-/**
-* Adapt a browser AbortSignal into the shared Subscription model.
-*/
-function fromAbortSignal(options) {
-	const signal = options.signal;
-	if (!signal) return { unsubscribe() {} };
-	if (options.emitIfAborted && signal.aborted) options.callback(signal.reason);
-	return fromEventPattern({
-		addHandler: (handler) => {
-			signal.addEventListener("abort", handler);
-		},
-		removeHandler: (handler) => {
-			signal.removeEventListener("abort", handler);
-		},
-		callback: () => {
-			options.callback(signal.reason);
-		}
-	});
-}
-/**
-* Adapt browser `storage` events into the shared Subscription model.
-*/
-function fromStorageEvent(options) {
-	const target = options.target ?? globalThis;
-	return fromEventPattern({
-		addHandler: (handler) => {
-			target.addEventListener("storage", handler);
-		},
-		removeHandler: (handler) => {
-			target.removeEventListener("storage", handler);
-		},
-		callback: (event) => {
-			options.callback(event);
-		}
-	});
-}
-//#endregion
-//#region src/web/cancellation.ts
-/**
-* Bridge a web `AbortSignal` back into the foundation cancellation contract.
-*
-* This is the canonical consumer-side path for browser hosts that receive an
-* `AbortSignal` from framework/runtime APIs (for example React Query queryFns)
-* but need to call SDK surfaces that accept `CancellationTokenTrait`.
-*/
-function createCancellationTokenFromAbortSignal(signal) {
-	if (!signal) return;
-	return {
-		get isCancellationRequested() {
-			return signal.aborted;
-		},
-		get reason() {
-			return signal.reason;
-		},
-		onCancellationRequested(listener) {
-			const subscription = fromAbortSignal({
-				signal,
-				callback: listener,
-				emitIfAborted: true
-			});
-			return { dispose() {
-				subscription.unsubscribe();
-			} };
-		},
-		throwIfCancellationRequested() {
-			if (signal.aborted) throw new ClientError({
-				kind: ClientErrorKind.Cancelled,
-				message: "Request was cancelled via AbortSignal",
-				code: "client.cancelled",
-				source: ClientErrorSource.Transport,
-				cause: signal.reason
-			});
-		}
-	};
-}
-/**
-* Bridge foundation cancellation to web `AbortSignal` without exposing
-* `AbortSignal` in core contracts.
-*/
-function createAbortSignalBridge(token) {
-	if (!token) return {
-		signal: void 0,
-		dispose() {}
-	};
-	const controller = new AbortController();
-	let subscription = token.onCancellationRequested((reason) => {
-		controller.abort(reason);
-	});
-	if (token.isCancellationRequested) controller.abort(token.reason);
-	return {
-		signal: controller.signal,
-		dispose() {
-			subscription?.dispose();
-			subscription = null;
-		}
-	};
-}
-function normalizeAbortError(token, error) {
-	if (!isAbortError(error) && !token?.isCancellationRequested) return error;
-	const reason = token?.reason;
-	if (reason instanceof ClientError) return reason;
-	if (reason instanceof Error) return new ClientError({
-		kind: ClientErrorKind.Cancelled,
-		message: reason.message,
-		code: "client.cancelled",
-		source: ClientErrorSource.Transport,
-		cause: reason
-	});
-	return new ClientError({
-		kind: ClientErrorKind.Cancelled,
-		message: "HTTP request was cancelled",
-		code: "client.cancelled",
-		source: ClientErrorSource.Transport,
-		cause: reason ?? error
-	});
-}
-function isAbortError(error) {
-	return typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
-}
-//#endregion
-//#region src/transport/fetch-transport.ts
-const FetchTransportRedirectKind = {
-	Follow: "follow",
-	Manual: "manual"
-};
-/**
-* Default `HttpTransport` backed by the global `fetch` API.
-*
-* The caller is responsible for ensuring `fetch` is available in the runtime.
-* No polyfill is injected — see the polyfill strategy in the design guide.
-*/
-function createFetchTransport(options = {}) {
-	const redirect = options.redirect ?? FetchTransportRedirectKind.Manual;
-	return { async execute(request) {
-		const abortBridge = createAbortSignalBridge(request.cancellationToken);
-		const init = {
-			method: request.method,
-			headers: request.headers,
-			redirect,
-			signal: abortBridge.signal
-		};
-		if (request.body !== void 0 && request.method !== "GET" && request.method !== "HEAD") init.body = typeof request.body === "string" ? request.body : JSON.stringify(request.body);
-		try {
-			const res = await fetch(request.url, init);
-			const responseHeaders = {};
-			res.headers.forEach((value, key) => {
-				responseHeaders[key] = value;
-			});
-			let body;
-			if (res.headers.get("content-type")?.includes("application/json")) body = await res.json();
-			else if (res.status !== 302 && res.status !== 303 && res.status !== 301) body = await res.text();
-			return {
-				status: res.status,
-				headers: responseHeaders,
-				body
-			};
-		} catch (error) {
-			throw normalizeAbortError(request.cancellationToken, error);
-		} finally {
-			abortBridge.dispose();
-		}
-	} };
-}
-//#endregion
-export { ClientErrorSource as C, ClientErrorKind as S, UserRecovery as T, createDefaultClock as _, normalizeAbortError as a, OperationTraceEventType as b, PromiseSettlementKind as c, fromSignal as d, interval as f, createDefaultScheduler as g, createRuntime as h, createCancellationTokenFromAbortSignal as i, fromEventPattern as l, timer as m, createFetchTransport as n, fromAbortSignal as o, scheduleAt as p, createAbortSignalBridge as r, fromStorageEvent as s, FetchTransportRedirectKind as t, fromPromise as u, createOperationTracer as v, ErrorPresentationTone as w, ClientError as x, LogLevel as y };
-
-//# sourceMappingURL=fetch-transport-DtnSRWAH.mjs.map