@adrianhall/cloudflare-toolkit 0.0.1

package/dist/factory-BI5gVL_P.js

@@ -0,0 +1,220 @@
+//#region src/lib/problem-details/status.ts
+/**
+* @file Standard HTTP reason phrases and URL-safe slugs, keyed by status code.
+*/
+const STATUS_PHRASES = {
+	400: "Bad Request",
+	401: "Unauthorized",
+	402: "Payment Required",
+	403: "Forbidden",
+	404: "Not Found",
+	405: "Method Not Allowed",
+	406: "Not Acceptable",
+	407: "Proxy Authentication Required",
+	408: "Request Timeout",
+	409: "Conflict",
+	410: "Gone",
+	411: "Length Required",
+	412: "Precondition Failed",
+	413: "Content Too Large",
+	414: "URI Too Long",
+	415: "Unsupported Media Type",
+	416: "Range Not Satisfiable",
+	417: "Expectation Failed",
+	418: "I'm a Teapot",
+	421: "Misdirected Request",
+	422: "Unprocessable Content",
+	423: "Locked",
+	424: "Failed Dependency",
+	425: "Too Early",
+	426: "Upgrade Required",
+	428: "Precondition Required",
+	429: "Too Many Requests",
+	431: "Request Header Fields Too Large",
+	451: "Unavailable For Legal Reasons",
+	500: "Internal Server Error",
+	501: "Not Implemented",
+	502: "Bad Gateway",
+	503: "Service Unavailable",
+	504: "Gateway Timeout",
+	505: "HTTP Version Not Supported",
+	506: "Variant Also Negotiates",
+	507: "Insufficient Storage",
+	508: "Loop Detected",
+	510: "Not Extended",
+	511: "Network Authentication Required"
+};
+const STATUS_SLUGS = Object.fromEntries(Object.entries(STATUS_PHRASES).map(([code, phrase]) => [Number(code), phrase.toLowerCase().replace(/'/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "")]));
+/**
+* Look up the standard HTTP reason phrase for a status code (e.g. `404` → `"Not Found"`).
+*
+* @param status - The HTTP status code.
+* @returns The reason phrase, or `undefined` if the status code is not recognized.
+*/
+function statusToPhrase(status) {
+	return STATUS_PHRASES[status];
+}
+/**
+* Look up a URL-safe slug for a status code (e.g. `404` → `"not-found"`). Useful when building a
+* `type` URI from a status code.
+*
+* @param status - The HTTP status code.
+* @returns The slug, or `undefined` if the status code is not recognized.
+*/
+function statusToSlug(status) {
+	return STATUS_SLUGS[status];
+}
+//#endregion
+//#region src/lib/problem-details/utils.ts
+/**
+* @file Helper functions for sanitizing, normalizing, and serializing RFC 9457 Problem Details
+* objects into `application/problem+json` responses.
+*/
+/** RFC 9457 media type: `application/problem+json; charset=utf-8`. */
+const PROBLEM_JSON_CONTENT_TYPE = "application/problem+json; charset=utf-8";
+const DANGEROUS_KEYS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+/**
+* Strip keys that could cause prototype pollution in downstream consumers.
+*
+* @param extensions - The extension members to sanitize, or `undefined`.
+* @returns The sanitized extensions, or the original reference when nothing was stripped.
+*/
+function sanitizeExtensions(extensions) {
+	if (!extensions) return extensions;
+	let filtered;
+	for (const key of Object.keys(extensions)) if (DANGEROUS_KEYS.has(key)) {
+		filtered ??= { ...extensions };
+		delete filtered[key];
+	}
+	return filtered ?? extensions;
+}
+/**
+* Clamp an HTTP status to the 200-599 integer range.
+*
+* @param status - The status to clamp.
+* @returns `status` unchanged when it's an integer in `[200, 599]`; otherwise `500`.
+*/
+function clampHttpStatus(status) {
+	return Number.isInteger(status) && status >= 200 && status <= 599 ? status : 500;
+}
+const FALLBACK_BODY = JSON.stringify({
+	type: "about:blank",
+	status: 500,
+	title: "Internal Server Error"
+});
+/**
+* Normalize a {@link ProblemDetailsInput} to a {@link ProblemDetails}, applying defaults for
+* `type` and `title`.
+*
+* @param input - The input to normalize.
+* @returns The normalized problem details object.
+*/
+function normalizeProblemDetails(input) {
+	return {
+		type: input.type ?? "about:blank",
+		status: input.status,
+		title: input.title ?? statusToPhrase(input.status) ?? "Unknown Error",
+		detail: input.detail,
+		instance: input.instance,
+		extensions: input.extensions
+	};
+}
+/**
+* Build an RFC 9457 `application/problem+json` {@link Response} from a {@link ProblemDetails}
+* object.
+*
+* @param pd - The problem details to serialize.
+* @returns The resulting `Response`.
+*/
+function buildProblemResponse(pd) {
+	const { extensions, ...standard } = pd;
+	const { json, fallback } = safeStringify({
+		...sanitizeExtensions(extensions),
+		...standard
+	});
+	return new Response(json, {
+		status: fallback ? 500 : clampHttpStatus(pd.status),
+		headers: { "Content-Type": PROBLEM_JSON_CONTENT_TYPE }
+	});
+}
+/**
+* `JSON.stringify` with a fallback for non-serializable values (circular references, `BigInt`).
+*
+* @param body - The value to stringify.
+* @returns The JSON string and whether the fallback body was used.
+*/
+function safeStringify(body) {
+	try {
+		return {
+			json: JSON.stringify(body),
+			fallback: false
+		};
+	} catch {
+		return {
+			json: FALLBACK_BODY,
+			fallback: true
+		};
+	}
+}
+//#endregion
+//#region src/lib/problem-details/error.ts
+/**
+* Error class for RFC 9457 Problem Details.
+* Thrown by {@link problemDetails} and caught by the Hono error handler (`@adrianhall/cloudflare-toolkit/hono`)
+* to produce `application/problem+json` responses.
+*/
+var ProblemDetailsError = class extends Error {
+	/** The normalized RFC 9457 Problem Details object. */
+	problemDetails;
+	/**
+	* Create a new {@link ProblemDetailsError}.
+	*
+	* @param input - Missing `type` defaults to `"about:blank"`; missing `title` is derived from
+	*   the HTTP status code.
+	*/
+	constructor(input) {
+		const pd = normalizeProblemDetails(input);
+		super(pd.detail ?? pd.title);
+		this.name = "ProblemDetailsError";
+		this.problemDetails = pd;
+	}
+	/**
+	* Build a standalone `application/problem+json` {@link Response} without any Hono handler
+	* middleware.
+	*
+	* @returns The resulting `Response`.
+	*/
+	getResponse() {
+		return buildProblemResponse(this.problemDetails);
+	}
+};
+//#endregion
+//#region src/lib/problem-details/factory.ts
+/**
+* @file The `problemDetails()` factory function for creating a {@link ProblemDetailsError}.
+*/
+/**
+* Create a {@link ProblemDetailsError} from the given input.
+* Missing `type` defaults to `"about:blank"`; missing `title` is derived from the status code.
+*
+* @param input - The problem details input.
+* @returns A {@link ProblemDetailsError} ready to `throw`.
+* @example
+* ```ts
+* throw problemDetails({
+*   status: 404,
+*   detail: `Order ${orderId} does not exist`,
+* });
+* ```
+*/
+function problemDetails(input) {
+	return new ProblemDetailsError(input);
+}
+//#endregion
+export { statusToPhrase as a, normalizeProblemDetails as i, ProblemDetailsError as n, statusToSlug as o, buildProblemResponse as r, problemDetails as t };
+
+//# sourceMappingURL=factory-BI5gVL_P.js.map

package/dist/factory-BI5gVL_P.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory-BI5gVL_P.js","names":[],"sources":["../src/lib/problem-details/status.ts","../src/lib/problem-details/utils.ts","../src/lib/problem-details/error.ts","../src/lib/problem-details/factory.ts"],"sourcesContent":["/**\n * @file Standard HTTP reason phrases and URL-safe slugs, keyed by status code.\n */\nconst STATUS_PHRASES: Record<number, string> = {\n  400: \"Bad Request\",\n  401: \"Unauthorized\",\n  402: \"Payment Required\",\n  403: \"Forbidden\",\n  404: \"Not Found\",\n  405: \"Method Not Allowed\",\n  406: \"Not Acceptable\",\n  407: \"Proxy Authentication Required\",\n  408: \"Request Timeout\",\n  409: \"Conflict\",\n  410: \"Gone\",\n  411: \"Length Required\",\n  412: \"Precondition Failed\",\n  413: \"Content Too Large\",\n  414: \"URI Too Long\",\n  415: \"Unsupported Media Type\",\n  416: \"Range Not Satisfiable\",\n  417: \"Expectation Failed\",\n  418: \"I'm a Teapot\",\n  421: \"Misdirected Request\",\n  422: \"Unprocessable Content\",\n  423: \"Locked\",\n  424: \"Failed Dependency\",\n  425: \"Too Early\",\n  426: \"Upgrade Required\",\n  428: \"Precondition Required\",\n  429: \"Too Many Requests\",\n  431: \"Request Header Fields Too Large\",\n  451: \"Unavailable For Legal Reasons\",\n  500: \"Internal Server Error\",\n  501: \"Not Implemented\",\n  502: \"Bad Gateway\",\n  503: \"Service Unavailable\",\n  504: \"Gateway Timeout\",\n  505: \"HTTP Version Not Supported\",\n  506: \"Variant Also Negotiates\",\n  507: \"Insufficient Storage\",\n  508: \"Loop Detected\",\n  510: \"Not Extended\",\n  511: \"Network Authentication Required\"\n};\n\nconst STATUS_SLUGS: Record<number, string> = Object.fromEntries(\n  Object.entries(STATUS_PHRASES).map(([code, phrase]) => [\n    Number(code),\n    phrase\n      .toLowerCase()\n      .replace(/'/g, \"\")\n      .replace(/[^a-z0-9]+/g, \"-\")\n      .replace(/^-|-$/g, \"\")\n  ])\n);\n\n/**\n * Look up the standard HTTP reason phrase for a status code (e.g. `404` → `\"Not Found\"`).\n *\n * @param status - The HTTP status code.\n * @returns The reason phrase, or `undefined` if the status code is not recognized.\n */\nexport function statusToPhrase(status: number): string | undefined {\n  return STATUS_PHRASES[status];\n}\n\n/**\n * Look up a URL-safe slug for a status code (e.g. `404` → `\"not-found\"`). Useful when building a\n * `type` URI from a status code.\n *\n * @param status - The HTTP status code.\n * @returns The slug, or `undefined` if the status code is not recognized.\n */\nexport function statusToSlug(status: number): string | undefined {\n  return STATUS_SLUGS[status];\n}\n","/**\n * @file Helper functions for sanitizing, normalizing, and serializing RFC 9457 Problem Details\n * objects into `application/problem+json` responses.\n */\nimport { statusToPhrase } from \"./status.js\";\nimport type { ProblemDetails, ProblemDetailsInput } from \"./types.js\";\n\n/** RFC 9457 media type: `application/problem+json; charset=utf-8`. */\nexport const PROBLEM_JSON_CONTENT_TYPE = \"application/problem+json; charset=utf-8\";\n\nconst DANGEROUS_KEYS = new Set([\"__proto__\", \"constructor\", \"prototype\"]);\n\n/**\n * Strip keys that could cause prototype pollution in downstream consumers.\n *\n * @param extensions - The extension members to sanitize, or `undefined`.\n * @returns The sanitized extensions, or the original reference when nothing was stripped.\n */\nexport function sanitizeExtensions(\n  extensions: Record<string, unknown> | undefined\n): Record<string, unknown> | undefined {\n  if (!extensions) return extensions;\n  let filtered: Record<string, unknown> | undefined;\n  for (const key of Object.keys(extensions)) {\n    if (DANGEROUS_KEYS.has(key)) {\n      filtered ??= { ...extensions };\n      delete filtered[key];\n    }\n  }\n  return filtered ?? extensions;\n}\n\n/**\n * Clamp an HTTP status to the 200-599 integer range.\n *\n * @param status - The status to clamp.\n * @returns `status` unchanged when it's an integer in `[200, 599]`; otherwise `500`.\n */\nexport function clampHttpStatus(status: number): number {\n  return Number.isInteger(status) && status >= 200 && status <= 599 ? status : 500;\n}\n\nconst FALLBACK_BODY = JSON.stringify({\n  type: \"about:blank\",\n  status: 500,\n  title: \"Internal Server Error\"\n});\n\n/**\n * Normalize a {@link ProblemDetailsInput} to a {@link ProblemDetails}, applying defaults for\n * `type` and `title`.\n *\n * @param input - The input to normalize.\n * @returns The normalized problem details object.\n */\nexport function normalizeProblemDetails<T extends Record<string, unknown>>(\n  input: ProblemDetailsInput<T>\n): ProblemDetails<T> {\n  return {\n    type: input.type ?? \"about:blank\",\n    status: input.status,\n    title: input.title ?? statusToPhrase(input.status) ?? \"Unknown Error\",\n    detail: input.detail,\n    instance: input.instance,\n    extensions: input.extensions\n  };\n}\n\n/**\n * Build an RFC 9457 `application/problem+json` {@link Response} from a {@link ProblemDetails}\n * object.\n *\n * @param pd - The problem details to serialize.\n * @returns The resulting `Response`.\n */\nexport function buildProblemResponse(pd: ProblemDetails): Response {\n  const { extensions, ...standard } = pd;\n  const body = { ...sanitizeExtensions(extensions), ...standard };\n  const { json, fallback } = safeStringify(body);\n  return new Response(json, {\n    status: fallback ? 500 : clampHttpStatus(pd.status),\n    headers: { \"Content-Type\": PROBLEM_JSON_CONTENT_TYPE }\n  });\n}\n\n/**\n * `JSON.stringify` with a fallback for non-serializable values (circular references, `BigInt`).\n *\n * @param body - The value to stringify.\n * @returns The JSON string and whether the fallback body was used.\n */\nexport function safeStringify(body: unknown): { json: string; fallback: boolean } {\n  try {\n    return { json: JSON.stringify(body), fallback: false };\n  } catch {\n    return { json: FALLBACK_BODY, fallback: true };\n  }\n}\n","/**\n * @file The RFC 9457 Problem Details error class.\n */\nimport type { ProblemDetails, ProblemDetailsInput } from \"./types.js\";\nimport { buildProblemResponse, normalizeProblemDetails } from \"./utils.js\";\n\n/**\n * Error class for RFC 9457 Problem Details.\n * Thrown by {@link problemDetails} and caught by the Hono error handler (`@adrianhall/cloudflare-toolkit/hono`)\n * to produce `application/problem+json` responses.\n */\nexport class ProblemDetailsError extends Error {\n  /** The normalized RFC 9457 Problem Details object. */\n  readonly problemDetails: ProblemDetails;\n\n  /**\n   * Create a new {@link ProblemDetailsError}.\n   *\n   * @param input - Missing `type` defaults to `\"about:blank\"`; missing `title` is derived from\n   *   the HTTP status code.\n   */\n  constructor(input: ProblemDetailsInput) {\n    const pd = normalizeProblemDetails(input);\n    super(pd.detail ?? pd.title);\n    this.name = \"ProblemDetailsError\";\n    this.problemDetails = pd;\n  }\n\n  /**\n   * Build a standalone `application/problem+json` {@link Response} without any Hono handler\n   * middleware.\n   *\n   * @returns The resulting `Response`.\n   */\n  getResponse(): Response {\n    return buildProblemResponse(this.problemDetails);\n  }\n}\n","/**\n * @file The `problemDetails()` factory function for creating a {@link ProblemDetailsError}.\n */\nimport { ProblemDetailsError } from \"./error.js\";\nimport type { ProblemDetailsInput } from \"./types.js\";\n\n/**\n * Create a {@link ProblemDetailsError} from the given input.\n * Missing `type` defaults to `\"about:blank\"`; missing `title` is derived from the status code.\n *\n * @param input - The problem details input.\n * @returns A {@link ProblemDetailsError} ready to `throw`.\n * @example\n * ```ts\n * throw problemDetails({\n *   status: 404,\n *   detail: `Order ${orderId} does not exist`,\n * });\n * ```\n */\nexport function problemDetails<T extends Record<string, unknown>>(\n  input: ProblemDetailsInput<T>\n): ProblemDetailsError {\n  return new ProblemDetailsError(input);\n}\n"],"mappings":"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"}

package/dist/generators-D8WWEHa1.js

@@ -0,0 +1,165 @@
+import { t as problemDetails } from "./factory-BI5gVL_P.js";
+//#region src/lib/errors/generators.ts
+/**
+* @file One HTTP error generator per supported status code. Every generator has the signature
+* `(input?: Omit<ProblemDetailsInput, "status">) => ProblemDetailsError` — each fixes its own
+* `status` and forwards `detail`/`type`/`instance`/`extensions` untouched to `problemDetails()`;
+* `title` auto-derives from `status` unless the caller explicitly overrides it.
+*
+* These are plain functions, not framework-specific — throwing one inside a plain function, a
+* Durable Object method, or a Hono handler all work identically. Pairing one with
+* `problemDetailsErrorHandler` (`@adrianhall/cloudflare-toolkit/hono`) turns the throw into an
+* HTTP response.
+*
+* `429 Too Many Requests` is intentionally not included (a platform concern, not an
+* application-level one). `304 Not Modified`, `409 Conflict`, and `412 Precondition Failed` are
+* also not included.
+*/
+/**
+* Create a `400 Bad Request` {@link ProblemDetailsError}.
+*
+* @param input - Optional problem details fields (`detail`, `type`, `instance`, `extensions`).
+* @returns A `400`-status {@link ProblemDetailsError} ready to `throw`.
+*/
+function badRequest(input) {
+	return problemDetails({
+		...input,
+		status: 400
+	});
+}
+/**
+* Create a `401 Unauthorized` {@link ProblemDetailsError}.
+*
+* @param input - Optional problem details fields (`detail`, `type`, `instance`, `extensions`).
+* @returns A `401`-status {@link ProblemDetailsError} ready to `throw`.
+*/
+function unauthorized(input) {
+	return problemDetails({
+		...input,
+		status: 401
+	});
+}
+/**
+* Create a `403 Forbidden` {@link ProblemDetailsError}.
+*
+* @param input - Optional problem details fields (`detail`, `type`, `instance`, `extensions`).
+* @returns A `403`-status {@link ProblemDetailsError} ready to `throw`.
+*/
+function forbidden(input) {
+	return problemDetails({
+		...input,
+		status: 403
+	});
+}
+/**
+* Create a `404 Not Found` {@link ProblemDetailsError}.
+*
+* @param input - Optional problem details fields (`detail`, `type`, `instance`, `extensions`).
+* @returns A `404`-status {@link ProblemDetailsError} ready to `throw`.
+*/
+function notFound(input) {
+	return problemDetails({
+		...input,
+		status: 404
+	});
+}
+/**
+* Create a `405 Method Not Allowed` {@link ProblemDetailsError}.
+*
+* @param input - Optional problem details fields (`detail`, `type`, `instance`, `extensions`).
+* @returns A `405`-status {@link ProblemDetailsError} ready to `throw`.
+*/
+function methodNotAllowed(input) {
+	return problemDetails({
+		...input,
+		status: 405
+	});
+}
+/**
+* Create a `410 Gone` {@link ProblemDetailsError}.
+*
+* @param input - Optional problem details fields (`detail`, `type`, `instance`, `extensions`).
+* @returns A `410`-status {@link ProblemDetailsError} ready to `throw`.
+*/
+function gone(input) {
+	return problemDetails({
+		...input,
+		status: 410
+	});
+}
+/**
+* Create a `413 Content Too Large` {@link ProblemDetailsError}.
+*
+* @param input - Optional problem details fields (`detail`, `type`, `instance`, `extensions`).
+* @returns A `413`-status {@link ProblemDetailsError} ready to `throw`.
+*/
+function contentTooLarge(input) {
+	return problemDetails({
+		...input,
+		status: 413
+	});
+}
+/**
+* Create a `415 Unsupported Media Type` {@link ProblemDetailsError}.
+*
+* @param input - Optional problem details fields (`detail`, `type`, `instance`, `extensions`).
+* @returns A `415`-status {@link ProblemDetailsError} ready to `throw`.
+*/
+function unsupportedMediaType(input) {
+	return problemDetails({
+		...input,
+		status: 415
+	});
+}
+/**
+* Create a `422 Unprocessable Content` {@link ProblemDetailsError}.
+*
+* @param input - Optional problem details fields (`detail`, `type`, `instance`, `extensions`).
+* @returns A `422`-status {@link ProblemDetailsError} ready to `throw`.
+*/
+function unprocessableContent(input) {
+	return problemDetails({
+		...input,
+		status: 422
+	});
+}
+/**
+* Create a `500 Internal Server Error` {@link ProblemDetailsError}.
+*
+* @param input - Optional problem details fields (`detail`, `type`, `instance`, `extensions`).
+* @returns A `500`-status {@link ProblemDetailsError} ready to `throw`.
+*/
+function internalServerError(input) {
+	return problemDetails({
+		...input,
+		status: 500
+	});
+}
+/**
+* Create a `501 Not Implemented` {@link ProblemDetailsError}.
+*
+* @param input - Optional problem details fields (`detail`, `type`, `instance`, `extensions`).
+* @returns A `501`-status {@link ProblemDetailsError} ready to `throw`.
+*/
+function notImplemented(input) {
+	return problemDetails({
+		...input,
+		status: 501
+	});
+}
+/**
+* Create a `503 Service Unavailable` {@link ProblemDetailsError}.
+*
+* @param input - Optional problem details fields (`detail`, `type`, `instance`, `extensions`).
+* @returns A `503`-status {@link ProblemDetailsError} ready to `throw`.
+*/
+function serviceUnavailable(input) {
+	return problemDetails({
+		...input,
+		status: 503
+	});
+}
+//#endregion
+export { internalServerError as a, notImplemented as c, unprocessableContent as d, unsupportedMediaType as f, gone as i, serviceUnavailable as l, contentTooLarge as n, methodNotAllowed as o, forbidden as r, notFound as s, badRequest as t, unauthorized as u };
+
+//# sourceMappingURL=generators-D8WWEHa1.js.map

package/dist/generators-D8WWEHa1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generators-D8WWEHa1.js","names":[],"sources":["../src/lib/errors/generators.ts"],"sourcesContent":["/**\n * @file One HTTP error generator per supported status code. Every generator has the signature\n * `(input?: Omit<ProblemDetailsInput, \"status\">) => ProblemDetailsError` — each fixes its own\n * `status` and forwards `detail`/`type`/`instance`/`extensions` untouched to `problemDetails()`;\n * `title` auto-derives from `status` unless the caller explicitly overrides it.\n *\n * These are plain functions, not framework-specific — throwing one inside a plain function, a\n * Durable Object method, or a Hono handler all work identically. Pairing one with\n * `problemDetailsErrorHandler` (`@adrianhall/cloudflare-toolkit/hono`) turns the throw into an\n * HTTP response.\n *\n * `429 Too Many Requests` is intentionally not included (a platform concern, not an\n * application-level one). `304 Not Modified`, `409 Conflict`, and `412 Precondition Failed` are\n * also not included.\n */\nimport { problemDetails } from \"../problem-details/factory.js\";\nimport type { ProblemDetailsError } from \"../problem-details/error.js\";\nimport type { ProblemDetailsInput } from \"../problem-details/types.js\";\n\n/**\n * Input shared by every HTTP error generator: a {@link ProblemDetailsInput} without `status`,\n * since each generator supplies its own fixed status code.\n */\nexport type HttpErrorInput<T extends Record<string, unknown> = Record<string, unknown>> = Omit<\n  ProblemDetailsInput<T>,\n  \"status\"\n>;\n\n/**\n * Create a `400 Bad Request` {@link ProblemDetailsError}.\n *\n * @param input - Optional problem details fields (`detail`, `type`, `instance`, `extensions`).\n * @returns A `400`-status {@link ProblemDetailsError} ready to `throw`.\n */\nexport function badRequest(input?: HttpErrorInput): ProblemDetailsError {\n  return problemDetails({ ...input, status: 400 });\n}\n\n/**\n * Create a `401 Unauthorized` {@link ProblemDetailsError}.\n *\n * @param input - Optional problem details fields (`detail`, `type`, `instance`, `extensions`).\n * @returns A `401`-status {@link ProblemDetailsError} ready to `throw`.\n */\nexport function unauthorized(input?: HttpErrorInput): ProblemDetailsError {\n  return problemDetails({ ...input, status: 401 });\n}\n\n/**\n * Create a `403 Forbidden` {@link ProblemDetailsError}.\n *\n * @param input - Optional problem details fields (`detail`, `type`, `instance`, `extensions`).\n * @returns A `403`-status {@link ProblemDetailsError} ready to `throw`.\n */\nexport function forbidden(input?: HttpErrorInput): ProblemDetailsError {\n  return problemDetails({ ...input, status: 403 });\n}\n\n/**\n * Create a `404 Not Found` {@link ProblemDetailsError}.\n *\n * @param input - Optional problem details fields (`detail`, `type`, `instance`, `extensions`).\n * @returns A `404`-status {@link ProblemDetailsError} ready to `throw`.\n */\nexport function notFound(input?: HttpErrorInput): ProblemDetailsError {\n  return problemDetails({ ...input, status: 404 });\n}\n\n/**\n * Create a `405 Method Not Allowed` {@link ProblemDetailsError}.\n *\n * @param input - Optional problem details fields (`detail`, `type`, `instance`, `extensions`).\n * @returns A `405`-status {@link ProblemDetailsError} ready to `throw`.\n */\nexport function methodNotAllowed(input?: HttpErrorInput): ProblemDetailsError {\n  return problemDetails({ ...input, status: 405 });\n}\n\n/**\n * Create a `410 Gone` {@link ProblemDetailsError}.\n *\n * @param input - Optional problem details fields (`detail`, `type`, `instance`, `extensions`).\n * @returns A `410`-status {@link ProblemDetailsError} ready to `throw`.\n */\nexport function gone(input?: HttpErrorInput): ProblemDetailsError {\n  return problemDetails({ ...input, status: 410 });\n}\n\n/**\n * Create a `413 Content Too Large` {@link ProblemDetailsError}.\n *\n * @param input - Optional problem details fields (`detail`, `type`, `instance`, `extensions`).\n * @returns A `413`-status {@link ProblemDetailsError} ready to `throw`.\n */\nexport function contentTooLarge(input?: HttpErrorInput): ProblemDetailsError {\n  return problemDetails({ ...input, status: 413 });\n}\n\n/**\n * Create a `415 Unsupported Media Type` {@link ProblemDetailsError}.\n *\n * @param input - Optional problem details fields (`detail`, `type`, `instance`, `extensions`).\n * @returns A `415`-status {@link ProblemDetailsError} ready to `throw`.\n */\nexport function unsupportedMediaType(input?: HttpErrorInput): ProblemDetailsError {\n  return problemDetails({ ...input, status: 415 });\n}\n\n/**\n * Create a `422 Unprocessable Content` {@link ProblemDetailsError}.\n *\n * @param input - Optional problem details fields (`detail`, `type`, `instance`, `extensions`).\n * @returns A `422`-status {@link ProblemDetailsError} ready to `throw`.\n */\nexport function unprocessableContent(input?: HttpErrorInput): ProblemDetailsError {\n  return problemDetails({ ...input, status: 422 });\n}\n\n/**\n * Create a `500 Internal Server Error` {@link ProblemDetailsError}.\n *\n * @param input - Optional problem details fields (`detail`, `type`, `instance`, `extensions`).\n * @returns A `500`-status {@link ProblemDetailsError} ready to `throw`.\n */\nexport function internalServerError(input?: HttpErrorInput): ProblemDetailsError {\n  return problemDetails({ ...input, status: 500 });\n}\n\n/**\n * Create a `501 Not Implemented` {@link ProblemDetailsError}.\n *\n * @param input - Optional problem details fields (`detail`, `type`, `instance`, `extensions`).\n * @returns A `501`-status {@link ProblemDetailsError} ready to `throw`.\n */\nexport function notImplemented(input?: HttpErrorInput): ProblemDetailsError {\n  return problemDetails({ ...input, status: 501 });\n}\n\n/**\n * Create a `503 Service Unavailable` {@link ProblemDetailsError}.\n *\n * @param input - Optional problem details fields (`detail`, `type`, `instance`, `extensions`).\n * @returns A `503`-status {@link ProblemDetailsError} ready to `throw`.\n */\nexport function serviceUnavailable(input?: HttpErrorInput): ProblemDetailsError {\n  return problemDetails({ ...input, status: 503 });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,WAAW,OAA6C;CACtE,OAAO,eAAe;EAAE,GAAG;EAAO,QAAQ;CAAI,CAAC;AACjD;;;;;;;AAQA,SAAgB,aAAa,OAA6C;CACxE,OAAO,eAAe;EAAE,GAAG;EAAO,QAAQ;CAAI,CAAC;AACjD;;;;;;;AAQA,SAAgB,UAAU,OAA6C;CACrE,OAAO,eAAe;EAAE,GAAG;EAAO,QAAQ;CAAI,CAAC;AACjD;;;;;;;AAQA,SAAgB,SAAS,OAA6C;CACpE,OAAO,eAAe;EAAE,GAAG;EAAO,QAAQ;CAAI,CAAC;AACjD;;;;;;;AAQA,SAAgB,iBAAiB,OAA6C;CAC5E,OAAO,eAAe;EAAE,GAAG;EAAO,QAAQ;CAAI,CAAC;AACjD;;;;;;;AAQA,SAAgB,KAAK,OAA6C;CAChE,OAAO,eAAe;EAAE,GAAG;EAAO,QAAQ;CAAI,CAAC;AACjD;;;;;;;AAQA,SAAgB,gBAAgB,OAA6C;CAC3E,OAAO,eAAe;EAAE,GAAG;EAAO,QAAQ;CAAI,CAAC;AACjD;;;;;;;AAQA,SAAgB,qBAAqB,OAA6C;CAChF,OAAO,eAAe;EAAE,GAAG;EAAO,QAAQ;CAAI,CAAC;AACjD;;;;;;;AAQA,SAAgB,qBAAqB,OAA6C;CAChF,OAAO,eAAe;EAAE,GAAG;EAAO,QAAQ;CAAI,CAAC;AACjD;;;;;;;AAQA,SAAgB,oBAAoB,OAA6C;CAC/E,OAAO,eAAe;EAAE,GAAG;EAAO,QAAQ;CAAI,CAAC;AACjD;;;;;;;AAQA,SAAgB,eAAe,OAA6C;CAC1E,OAAO,eAAe;EAAE,GAAG;EAAO,QAAQ;CAAI,CAAC;AACjD;;;;;;;AAQA,SAAgB,mBAAmB,OAA6C;CAC9E,OAAO,eAAe;EAAE,GAAG;EAAO,QAAQ;CAAI,CAAC;AACjD"}

package/dist/guards/index.d.ts

@@ -0,0 +1,2 @@
+import { n as throwIfNull, r as valueOrDefault, t as sqlCount } from "../index-434HN8jN.js";
+export { sqlCount, throwIfNull, valueOrDefault };

package/dist/guards/index.js

@@ -0,0 +1,2 @@
+import { n as throwIfNull, r as valueOrDefault, t as sqlCount } from "../guards-6K1CVAr5.js";
+export { sqlCount, throwIfNull, valueOrDefault };

package/dist/guards-6K1CVAr5.js

@@ -0,0 +1,61 @@
+import { n as InvalidShapeError, t as NullError } from "./errors-Ciipq_zr.js";
+//#region src/lib/guards/guards.ts
+/**
+* @file Testable defensive guards — `throwIfNull`, `valueOrDefault`, `sqlCount` — that let call
+* sites replace inline, ad-hoc defensive branches with a single, individually-tested helper.
+*
+* Depends only on `errors` (for `NullError` and `InvalidShapeError`) — never the reverse.
+*/
+/**
+* Assert that `value` is neither `null` nor `undefined`. A genuine TypeScript assertion function:
+* once called, TypeScript narrows `value` to `NonNullable<T>` for the rest of the calling scope,
+* so callers get type narrowing for free instead of needing a separate `if`/cast.
+*
+* @param value - The value to check.
+* @param message - Human-readable explanation of what was unexpectedly null/undefined. Forwarded
+*   as-is to the thrown {@link NullError}.
+* @throws {NullError} If `value` is `null` or `undefined`.
+*/
+function throwIfNull(value, message) {
+	if (value === null || value === void 0) throw new NullError(message);
+}
+/**
+* Return `value` unless it is `null`/`undefined`, in which case return `defaultValue` instead.
+* Literally `value ?? defaultValue` — exists purely so lint rules can flag _ad hoc_ `??`
+* fallbacks used defensively while allowing this one blessed, individually-tested helper.
+*
+* @param value - The value to return if defined.
+* @param defaultValue - The fallback returned when `value` is `null`/`undefined`.
+* @returns `value`, or `defaultValue` when `value` is `null`/`undefined`.
+*/
+function valueOrDefault(value, defaultValue) {
+	return value ?? defaultValue;
+}
+/**
+* Extract a numeric count from a D1 `.first()` result for the `SELECT COUNT(*) AS count FROM t`
+* pattern. Validates that `row` is a non-null object with a numeric `countProperty`; throws
+* {@link NullError} (via {@link throwIfNull}) if `row` itself is
+* `null`/`undefined`, or {@link InvalidShapeError} if `row` is non-null but does not have the
+* expected shape (not an object, or `countProperty` on it missing/not a number) — since the whole
+* point of this guard is "this should never happen — if it does, that's a bug, not a 0".
+*
+* @param row - The value returned by D1's `.first()` — `null` when no rows match, otherwise
+*   whatever shape the query produced. Typed `unknown` because a D1 result is never trustworthy
+*   input.
+* @param countProperty - The property on `row` holding the count. Defaults to `"count"`.
+* @returns The numeric count read from `row[countProperty]`.
+* @throws {NullError} If `row` is `null` or `undefined`.
+* @throws {InvalidShapeError} If `row` is non-null but not an object, or `countProperty` on it is
+*   missing or not a number.
+*/
+function sqlCount(row, countProperty = "count") {
+	throwIfNull(row, "sqlCount: row is null or undefined (D1 .first() returned no rows)");
+	if (typeof row !== "object") throw new InvalidShapeError(`sqlCount: row is not an object (received ${typeof row})`);
+	const value = row[countProperty];
+	if (typeof value !== "number") throw new InvalidShapeError(`sqlCount: property "${countProperty}" is missing or not a number`);
+	return value;
+}
+//#endregion
+export { throwIfNull as n, valueOrDefault as r, sqlCount as t };
+
+//# sourceMappingURL=guards-6K1CVAr5.js.map

package/dist/guards-6K1CVAr5.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards-6K1CVAr5.js","names":[],"sources":["../src/lib/guards/guards.ts"],"sourcesContent":["/**\n * @file Testable defensive guards — `throwIfNull`, `valueOrDefault`, `sqlCount` — that let call\n * sites replace inline, ad-hoc defensive branches with a single, individually-tested helper.\n *\n * Depends only on `errors` (for `NullError` and `InvalidShapeError`) — never the reverse.\n */\nimport { InvalidShapeError, NullError } from \"../errors/index.js\";\n\n/**\n * Assert that `value` is neither `null` nor `undefined`. A genuine TypeScript assertion function:\n * once called, TypeScript narrows `value` to `NonNullable<T>` for the rest of the calling scope,\n * so callers get type narrowing for free instead of needing a separate `if`/cast.\n *\n * @param value - The value to check.\n * @param message - Human-readable explanation of what was unexpectedly null/undefined. Forwarded\n *   as-is to the thrown {@link NullError}.\n * @throws {NullError} If `value` is `null` or `undefined`.\n */\nexport function throwIfNull<T>(value: T, message: string): asserts value is NonNullable<T> {\n  if (value === null || value === undefined) {\n    throw new NullError(message);\n  }\n}\n\n/**\n * Return `value` unless it is `null`/`undefined`, in which case return `defaultValue` instead.\n * Literally `value ?? defaultValue` — exists purely so lint rules can flag _ad hoc_ `??`\n * fallbacks used defensively while allowing this one blessed, individually-tested helper.\n *\n * @param value - The value to return if defined.\n * @param defaultValue - The fallback returned when `value` is `null`/`undefined`.\n * @returns `value`, or `defaultValue` when `value` is `null`/`undefined`.\n */\nexport function valueOrDefault<T>(value: T | null | undefined, defaultValue: T): T {\n  return value ?? defaultValue;\n}\n\n/**\n * Extract a numeric count from a D1 `.first()` result for the `SELECT COUNT(*) AS count FROM t`\n * pattern. Validates that `row` is a non-null object with a numeric `countProperty`; throws\n * {@link NullError} (via {@link throwIfNull}) if `row` itself is\n * `null`/`undefined`, or {@link InvalidShapeError} if `row` is non-null but does not have the\n * expected shape (not an object, or `countProperty` on it missing/not a number) — since the whole\n * point of this guard is \"this should never happen — if it does, that's a bug, not a 0\".\n *\n * @param row - The value returned by D1's `.first()` — `null` when no rows match, otherwise\n *   whatever shape the query produced. Typed `unknown` because a D1 result is never trustworthy\n *   input.\n * @param countProperty - The property on `row` holding the count. Defaults to `\"count\"`.\n * @returns The numeric count read from `row[countProperty]`.\n * @throws {NullError} If `row` is `null` or `undefined`.\n * @throws {InvalidShapeError} If `row` is non-null but not an object, or `countProperty` on it is\n *   missing or not a number.\n */\nexport function sqlCount(row: unknown, countProperty = \"count\"): number {\n  throwIfNull(row, \"sqlCount: row is null or undefined (D1 .first() returned no rows)\");\n  if (typeof row !== \"object\") {\n    throw new InvalidShapeError(`sqlCount: row is not an object (received ${typeof row})`);\n  }\n  const value = (row as Record<string, unknown>)[countProperty];\n  if (typeof value !== \"number\") {\n    throw new InvalidShapeError(`sqlCount: property \"${countProperty}\" is missing or not a number`);\n  }\n  return value;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAkBA,SAAgB,YAAe,OAAU,SAAkD;CACzF,IAAI,UAAU,QAAQ,UAAU,KAAA,GAC9B,MAAM,IAAI,UAAU,OAAO;AAE/B;;;;;;;;;;AAWA,SAAgB,eAAkB,OAA6B,cAAoB;CACjF,OAAO,SAAS;AAClB;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,SAAS,KAAc,gBAAgB,SAAiB;CACtE,YAAY,KAAK,mEAAmE;CACpF,IAAI,OAAO,QAAQ,UACjB,MAAM,IAAI,kBAAkB,4CAA4C,OAAO,IAAI,EAAE;CAEvF,MAAM,QAAS,IAAgC;CAC/C,IAAI,OAAO,UAAU,UACnB,MAAM,IAAI,kBAAkB,uBAAuB,cAAc,6BAA6B;CAEhG,OAAO;AACT"}