@outfitter/contracts 0.4.1 → 0.5.0

package/dist/internal/safe-json.js

@@ -0,0 +1,66 @@
+// @bun
+import {
+  DEFAULT_PATTERNS,
+  DEFAULT_SENSITIVE_KEYS,
+  createRedactor
+} from "../shared/@outfitter/contracts-s15x2rs4.js";
+import {
+  formatZodIssues
+} from "../shared/@outfitter/contracts-hgh47193.js";
+import {
+  ValidationError
+} from "../shared/@outfitter/contracts-vhr2ep6b.js";
+
+// packages/contracts/src/internal/safe-json.ts
+import { Result } from "better-result";
+var defaultRedactor = createRedactor({
+  patterns: [...DEFAULT_PATTERNS],
+  keys: [...DEFAULT_SENSITIVE_KEYS]
+});
+function safeStringify(value, space) {
+  const seen = new WeakSet;
+  const replacer = (key, val) => {
+    if (typeof val === "bigint") {
+      return val.toString();
+    }
+    if (typeof val === "object" && val !== null) {
+      if (seen.has(val)) {
+        return "[Circular]";
+      }
+      seen.add(val);
+    }
+    if (key !== "" && defaultRedactor.isSensitiveKey(key) && val !== null && val !== undefined) {
+      return "[REDACTED]";
+    }
+    if (typeof val === "string") {
+      return defaultRedactor.redactString(val);
+    }
+    return val;
+  };
+  return JSON.stringify(value, replacer, space);
+}
+function safeParse(json, schema) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : "Unknown parse error";
+    return Result.err(new ValidationError({
+      message: `JSON parse error: ${errorMessage}`
+    }));
+  }
+  if (schema === undefined) {
+    return Result.ok(parsed);
+  }
+  const parseResult = schema.safeParse(parsed);
+  if (parseResult.success) {
+    return Result.ok(parseResult.data);
+  }
+  return Result.err(new ValidationError({
+    message: `Schema validation failed: ${formatZodIssues(parseResult.error.issues)}`
+  }));
+}
+export {
+  safeStringify,
+  safeParse
+};

package/dist/internal/schema-converters.d.ts

@@ -0,0 +1,26 @@
+import { JsonSchema } from "../shared/@outfitter/contracts-w7nvcwrp.js";
+import { z } from "zod";
+/**
+* Converter function type for the main dispatch function.
+*
+* This is injected to avoid circular dependencies between the converters
+* and the dispatcher in schema.ts.
+*/
+type ZodTypeConverter = (schema: z.ZodType<unknown>) => JsonSchema;
+/**
+* Convert Zod array schema.
+*/
+declare function convertArray(def: any, convertZodType: ZodTypeConverter): JsonSchema;
+/**
+* Check if a Zod field is optional by unwrapping wrapper types.
+*
+* This handles cases where optional fields are wrapped in ZodEffects
+* (refinements, transforms) or ZodPipeline, which would otherwise
+* incorrectly appear as required.
+*/
+declare function isFieldOptional(fieldDef: any): boolean;
+/**
+* Convert Zod object schema.
+*/
+declare function convertObject(def: any, convertZodType: ZodTypeConverter): JsonSchema;
+export { isFieldOptional, convertObject, convertArray, ZodTypeConverter };

package/dist/internal/schema-converters.js

@@ -0,0 +1,12 @@
+// @bun
+import {
+  convertArray,
+  convertObject,
+  isFieldOptional
+} from "../shared/@outfitter/contracts-hrepwwne.js";
+import"../shared/@outfitter/contracts-jyhqr766.js";
+export {
+  isFieldOptional,
+  convertObject,
+  convertArray
+};

package/dist/internal/schema-primitives.d.ts

@@ -0,0 +1,10 @@
+import { JsonSchema } from "../shared/@outfitter/contracts-w7nvcwrp.js";
+/**
+* Convert Zod string schema with checks.
+*/
+declare function convertString(def: any): JsonSchema;
+/**
+* Convert Zod number schema with checks.
+*/
+declare function convertNumber(def: any): JsonSchema;
+export { convertString, convertNumber };

package/dist/internal/schema-primitives.js

@@ -0,0 +1,9 @@
+// @bun
+import {
+  convertNumber,
+  convertString
+} from "../shared/@outfitter/contracts-3re9d4bp.js";
+export {
+  convertString,
+  convertNumber
+};

package/dist/internal/schema-types.d.ts

@@ -0,0 +1,2 @@
+import { JsonSchema, getDef, getDescription } from "../shared/@outfitter/contracts-w7nvcwrp.js";
+export { getDescription, getDef, JsonSchema };

package/dist/internal/schema-types.js

@@ -0,0 +1,9 @@
+// @bun
+import {
+  getDef,
+  getDescription
+} from "../shared/@outfitter/contracts-jyhqr766.js";
+export {
+  getDescription,
+  getDef
+};

package/dist/logging.js

@@ -1,7 +1,15 @@
 // @bun
-import {
-  createLoggerFactory
-} from "./shared/@outfitter/contracts-sm6vak1a.js";
+// packages/contracts/src/logging.ts
+function createLoggerFactory(adapter) {
+  return {
+    createLogger(config) {
+      return adapter.createLogger(config);
+    },
+    async flush() {
+      await adapter.flush?.();
+    }
+  };
+}
 export {
   createLoggerFactory
 };

package/dist/recovery.d.ts

@@ -1,3 +1,7 @@
-import { BackoffOptions, getBackoffDelay, isRecoverable, isRetryable, shouldRetry } from "./shared/@outfitter/contracts-k71jqd1m.js";
-import "./shared/@outfitter/contracts-3gswmhb1.js";
+import { BackoffOptions, getBackoffDelay, isRecoverable, isRetryable, shouldRetry } from "./shared/@outfitter/contracts-10p5q75w.js";
+import "./shared/@outfitter/contracts-7a0xmwbg.js";
+import "./shared/@outfitter/contracts-735ecmbq.js";
+import "./shared/@outfitter/contracts-mehpmvwp.js";
+import "./shared/@outfitter/contracts-qpbv29bg.js";
+import "./shared/@outfitter/contracts-njb2art4.js";
 export { shouldRetry, isRetryable, isRecoverable, getBackoffDelay, BackoffOptions };

package/dist/recovery.js

@@ -1,10 +1,53 @@
 // @bun
-import {
-  getBackoffDelay,
-  isRecoverable,
-  isRetryable,
-  shouldRetry
-} from "./shared/@outfitter/contracts-4zaj7ejb.js";
+// packages/contracts/src/recovery.ts
+var RECOVERABLE_CATEGORIES = [
+  "network",
+  "timeout",
+  "rate_limit",
+  "conflict"
+];
+var RETRYABLE_CATEGORIES = ["network", "timeout"];
+var isRecoverable = (error) => {
+  return RECOVERABLE_CATEGORIES.includes(error.category);
+};
+var isRetryable = (error) => {
+  return RETRYABLE_CATEGORIES.includes(error.category);
+};
+var getBackoffDelay = (attempt, options = {}) => {
+  const {
+    baseDelayMs = 100,
+    maxDelayMs = 30000,
+    strategy = "exponential",
+    useJitter = true
+  } = options;
+  let delay;
+  switch (strategy) {
+    case "constant": {
+      delay = baseDelayMs;
+      break;
+    }
+    case "linear": {
+      delay = baseDelayMs * (attempt + 1);
+      break;
+    }
+    default: {
+      delay = baseDelayMs * 2 ** attempt;
+    }
+  }
+  delay = Math.min(delay, maxDelayMs);
+  if (useJitter) {
+    const jitterFactor = 0.1;
+    const jitter = delay * jitterFactor * (Math.random() * 2 - 1);
+    delay = Math.round(delay + jitter);
+  }
+  return Math.min(delay, maxDelayMs);
+};
+var shouldRetry = (error, attempt, maxAttempts = 3) => {
+  if (attempt >= maxAttempts) {
+    return false;
+  }
+  return isRetryable(error);
+};
 export {
   shouldRetry,
   isRetryable,

package/dist/resilience.d.ts

@@ -1,3 +1,7 @@
-import { RetryOptions, TimeoutOptions, retry, withTimeout } from "./shared/@outfitter/contracts-95cc3y06.js";
-import "./shared/@outfitter/contracts-3gswmhb1.js";
+import { RetryOptions, TimeoutOptions, retry, withTimeout } from "./shared/@outfitter/contracts-mt027fqj.js";
+import "./shared/@outfitter/contracts-7a0xmwbg.js";
+import "./shared/@outfitter/contracts-735ecmbq.js";
+import "./shared/@outfitter/contracts-mehpmvwp.js";
+import "./shared/@outfitter/contracts-qpbv29bg.js";
+import "./shared/@outfitter/contracts-njb2art4.js";
 export { withTimeout, retry, TimeoutOptions, RetryOptions };

package/dist/resilience.js

@@ -1,9 +1,85 @@
 // @bun
 import {
-  retry,
-  withTimeout
-} from "./shared/@outfitter/contracts-r21yet6j.js";
-import"./shared/@outfitter/contracts-phjhz5q3.js";
+  InternalError,
+  TimeoutError
+} from "./shared/@outfitter/contracts-vhr2ep6b.js";
+
+// packages/contracts/src/resilience.ts
+import { Result } from "better-result";
+function defaultIsRetryable(error) {
+  return error.category === "network" || error.category === "timeout" || error.category === "rate_limit";
+}
+function calculateDelay(attempt, initialDelayMs, maxDelayMs, backoffMultiplier, jitter) {
+  const baseDelay = initialDelayMs * backoffMultiplier ** (attempt - 1);
+  const cappedDelay = Math.min(baseDelay, maxDelayMs);
+  if (jitter) {
+    const jitterFactor = 0.5 + Math.random();
+    return Math.floor(cappedDelay * jitterFactor);
+  }
+  return cappedDelay;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retry(fn, options) {
+  const maxAttempts = options?.maxAttempts ?? 3;
+  if (!(maxAttempts >= 1)) {
+    return Result.err(InternalError.create("maxAttempts must be >= 1", { maxAttempts }));
+  }
+  const initialDelayMs = options?.initialDelayMs ?? 1000;
+  const maxDelayMs = options?.maxDelayMs ?? 30000;
+  const backoffMultiplier = options?.backoffMultiplier ?? 2;
+  const jitter = options?.jitter ?? true;
+  const isRetryable = options?.isRetryable ?? defaultIsRetryable;
+  const onRetry = options?.onRetry;
+  const signal = options?.signal;
+  let lastError;
+  let attempt = 0;
+  while (attempt < maxAttempts) {
+    attempt++;
+    if (signal?.aborted) {
+      return Result.err(lastError ?? new TimeoutError({
+        message: "Operation cancelled",
+        operation: "retry",
+        timeoutMs: 0
+      }));
+    }
+    const result = await fn();
+    if (result.isOk()) {
+      return result;
+    }
+    lastError = result.error;
+    if (attempt >= maxAttempts || !isRetryable(lastError)) {
+      return result;
+    }
+    const delayMs = calculateDelay(attempt, initialDelayMs, maxDelayMs, backoffMultiplier, jitter);
+    if (onRetry) {
+      onRetry(attempt, lastError, delayMs);
+    }
+    await sleep(delayMs);
+  }
+  return Result.err(InternalError.create("Unexpected: retry loop completed without returning a result"));
+}
+async function withTimeout(fn, options) {
+  const { timeoutMs, operation = "operation" } = options;
+  let timeoutId;
+  const timeoutPromise = new Promise((resolve) => {
+    timeoutId = setTimeout(() => {
+      resolve(Result.err(new TimeoutError({
+        message: `${operation} timed out after ${timeoutMs}ms`,
+        operation,
+        timeoutMs
+      })));
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([fn(), timeoutPromise]);
+  } finally {
+    if (timeoutId !== undefined) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
 export {
   withTimeout,
   retry

package/dist/result/index.js

@@ -1,16 +1 @@
-// @bun
-import"../shared/@outfitter/contracts-37gpc56f.js";
-import {
-  combine2,
-  combine3,
-  expect,
-  orElse,
-  unwrapOrElse
-} from "../shared/@outfitter/contracts-zx72gyh1.js";
-export {
-  unwrapOrElse,
-  orElse,
-  expect,
-  combine3,
-  combine2
-};
+export { combine2, combine3, expect, orElse, unwrapOrElse } from "./utilities.js";

package/dist/result/utilities.js

@@ -1,11 +1,33 @@
 // @bun
-import {
-  combine2,
-  combine3,
-  expect,
-  orElse,
-  unwrapOrElse
-} from "../shared/@outfitter/contracts-zx72gyh1.js";
+// packages/contracts/src/result/utilities.ts
+import { Result } from "better-result";
+var unwrapOrElse = (result, defaultFn) => {
+  return result.isOk() ? result.value : defaultFn(result.error);
+};
+var orElse = (result, fallback) => {
+  return result.isOk() ? result : fallback;
+};
+var combine2 = (r1, r2) => {
+  if (r1.isErr())
+    return r1;
+  if (r2.isErr())
+    return r2;
+  return Result.ok([r1.value, r2.value]);
+};
+var combine3 = (r1, r2, r3) => {
+  if (r1.isErr())
+    return r1;
+  if (r2.isErr())
+    return r2;
+  if (r3.isErr())
+    return r3;
+  return Result.ok([r1.value, r2.value, r3.value]);
+};
+var expect = (result, message) => {
+  if (result.isOk())
+    return result.value;
+  throw new Error(`${message}: ${String(result.error)}`);
+};
 export {
   unwrapOrElse,
   orElse,

package/dist/schema.d.ts

@@ -1,2 +1,3 @@
-import { JsonSchema, zodToJsonSchema } from "./shared/@outfitter/contracts-t79engf9.js";
+import { zodToJsonSchema } from "./shared/@outfitter/contracts-8cmkh2db.js";
+import { JsonSchema } from "./shared/@outfitter/contracts-w7nvcwrp.js";
 export { zodToJsonSchema, JsonSchema };

package/dist/schema.js

@@ -1,7 +1,170 @@
 // @bun
 import {
-  zodToJsonSchema
-} from "./shared/@outfitter/contracts-wfht4q2b.js";
+  convertNumber,
+  convertString
+} from "./shared/@outfitter/contracts-3re9d4bp.js";
+import {
+  convertArray,
+  convertObject
+} from "./shared/@outfitter/contracts-hrepwwne.js";
+import {
+  getDef,
+  getDescription
+} from "./shared/@outfitter/contracts-jyhqr766.js";
+
+// packages/contracts/src/schema.ts
+function zodToJsonSchema(schema) {
+  return convertZodType(schema);
+}
+function convertZodType(schema) {
+  const def = getDef(schema);
+  if (!def) {
+    return {};
+  }
+  const typeName = def.typeName ?? def.type;
+  let jsonSchema;
+  switch (typeName) {
+    case "ZodString":
+    case "string":
+      jsonSchema = convertString(def);
+      break;
+    case "ZodNumber":
+    case "number":
+      jsonSchema = convertNumber(def);
+      break;
+    case "ZodBoolean":
+    case "boolean":
+      jsonSchema = { type: "boolean" };
+      break;
+    case "ZodNull":
+    case "null":
+      jsonSchema = { type: "null" };
+      break;
+    case "ZodUndefined":
+    case "undefined":
+      jsonSchema = {};
+      break;
+    case "ZodArray":
+    case "array":
+      jsonSchema = convertArray(def, convertZodType);
+      break;
+    case "ZodObject":
+    case "object":
+      jsonSchema = convertObject(def, convertZodType);
+      break;
+    case "ZodOptional":
+    case "optional":
+      jsonSchema = convertZodType(def.innerType);
+      break;
+    case "ZodNullable":
+    case "nullable":
+      jsonSchema = {
+        anyOf: [convertZodType(def.innerType), { type: "null" }]
+      };
+      break;
+    case "ZodDefault":
+    case "default": {
+      const defaultValue = typeof def.defaultValue === "function" ? def.defaultValue() : def.defaultValue;
+      jsonSchema = {
+        ...convertZodType(def.innerType),
+        default: defaultValue
+      };
+      break;
+    }
+    case "ZodEnum":
+    case "enum": {
+      const values = def.values ?? Object.values(def.entries ?? {});
+      jsonSchema = {
+        type: "string",
+        enum: values
+      };
+      break;
+    }
+    case "ZodNativeEnum":
+      jsonSchema = {
+        enum: Object.values(def.values ?? def.entries ?? {})
+      };
+      break;
+    case "ZodLiteral":
+    case "literal": {
+      const literalValues = Array.isArray(def.values) ? def.values : [def.value].filter((value) => value !== undefined);
+      if (literalValues.length > 1) {
+        jsonSchema = {
+          enum: literalValues
+        };
+        break;
+      }
+      jsonSchema = literalValues.length ? {
+        const: literalValues[0]
+      } : {};
+      break;
+    }
+    case "ZodUnion":
+    case "union":
+      jsonSchema = {
+        anyOf: def.options.map(convertZodType)
+      };
+      break;
+    case "ZodIntersection":
+    case "intersection":
+      jsonSchema = {
+        allOf: [convertZodType(def.left), convertZodType(def.right)]
+      };
+      break;
+    case "ZodRecord":
+    case "record":
+      jsonSchema = {
+        type: "object",
+        additionalProperties: def.valueType ? convertZodType(def.valueType) : {}
+      };
+      break;
+    case "ZodTuple":
+    case "tuple":
+      jsonSchema = {
+        type: "array",
+        items: def.items.map(convertZodType)
+      };
+      break;
+    case "ZodAny":
+    case "any":
+      jsonSchema = {};
+      break;
+    case "ZodUnknown":
+    case "unknown":
+      jsonSchema = {};
+      break;
+    case "ZodVoid":
+    case "void":
+      jsonSchema = {};
+      break;
+    case "ZodNever":
+    case "never":
+      jsonSchema = { not: {} };
+      break;
+    case "ZodEffects":
+      jsonSchema = convertZodType(def.schema);
+      break;
+    case "ZodPipeline":
+    case "pipe": {
+      const outputDef = getDef(def.out);
+      const outputType = outputDef?.typeName ?? outputDef?.type;
+      jsonSchema = outputType === "transform" ? convertZodType(def.in) : convertZodType(def.out);
+      break;
+    }
+    case "ZodLazy":
+    case "lazy":
+      jsonSchema = {};
+      break;
+    default:
+      jsonSchema = {};
+      break;
+  }
+  const description = getDescription(schema, def);
+  if (description && !jsonSchema.description) {
+    jsonSchema.description = description;
+  }
+  return jsonSchema;
+}
 export {
   zodToJsonSchema
 };

package/dist/serialization.d.ts

@@ -1,3 +1,9 @@
-import { SerializeErrorOptions, deserializeError, safeParse, safeStringify, serializeError } from "./shared/@outfitter/contracts-31penhwa.js";
-import "./shared/@outfitter/contracts-3gswmhb1.js";
+import "./shared/@outfitter/contracts-f6fnz6h9.js";
+import { SerializeErrorOptions, deserializeError, serializeError } from "./shared/@outfitter/contracts-p77yjs4g.js";
+import { safeParse, safeStringify } from "./shared/@outfitter/contracts-1zzcpfyg.js";
+import "./shared/@outfitter/contracts-7a0xmwbg.js";
+import "./shared/@outfitter/contracts-735ecmbq.js";
+import "./shared/@outfitter/contracts-mehpmvwp.js";
+import "./shared/@outfitter/contracts-qpbv29bg.js";
+import "./shared/@outfitter/contracts-njb2art4.js";
 export { serializeError, safeStringify, safeParse, deserializeError, SerializeErrorOptions };

package/dist/serialization.js

@@ -4,9 +4,7 @@ import {
   safeParse,
   safeStringify,
   serializeError
-} from "./shared/@outfitter/contracts-3wj7xghe.js";
-import"./shared/@outfitter/contracts-s15x2rs4.js";
-import"./shared/@outfitter/contracts-phjhz5q3.js";
+} from "./shared/@outfitter/contracts-jtt6dnmg.js";
 export {
   serializeError,
   safeStringify,

package/dist/shared/@outfitter/{contracts-k71jqd1m.d.ts → contracts-10p5q75w.d.ts}

@@ -1,4 +1,4 @@
-import { ErrorCategory } from "./contracts-3gswmhb1.js";
+import { ErrorCategory } from "./contracts-njb2art4.js";
 /**
 * Backoff strategy configuration options
 */

package/dist/shared/@outfitter/contracts-1zzcpfyg.d.ts

@@ -0,0 +1,40 @@
+import { ValidationError } from "./contracts-mehpmvwp.js";
+import { Result } from "better-result";
+import { z } from "zod";
+/**
+* Safely stringify any value to JSON.
+*
+* Handles circular references, BigInt, and other non-JSON-safe values.
+* Applies redaction to sensitive values.
+*
+* @param value - Value to stringify
+* @param space - Indentation (default: undefined for compact)
+* @returns JSON string
+*
+* @example
+* ```typescript
+* const json = safeStringify({ apiKey: "sk-secret", data: "safe" });
+* // '{"apiKey":"[REDACTED]","data":"safe"}'
+* ```
+*/
+declare function safeStringify(value: unknown, space?: number): string;
+/**
+* Safely parse JSON string with optional schema validation.
+*
+* Returns Result instead of throwing on invalid JSON.
+*
+* @typeParam T - Expected parsed type (or unknown if no schema)
+* @param json - JSON string to parse
+* @param schema - Optional Zod schema for validation
+* @returns Result with parsed value or ValidationError
+*
+* @example
+* ```typescript
+* const result = safeParse<Config>('{"port": 3000}', ConfigSchema);
+* if (result.isOk()) {
+*   const config = result.unwrap();
+* }
+* ```
+*/
+declare function safeParse<T = unknown>(json: string, schema?: z.ZodType<T>): Result<T, ValidationError>;
+export { safeStringify, safeParse };

package/dist/shared/@outfitter/contracts-3f5k5tg5.d.ts

@@ -0,0 +1,28 @@
+import { OutfitterError } from "./contracts-7a0xmwbg.js";
+import { Result } from "better-result";
+/**
+* Convert an HTTP {@link Response} into a `Result<Response, OutfitterError>`.
+*
+* - **2xx** status codes return `Ok` with the original Response.
+* - Known error codes map to specific categories per the taxonomy using
+*   {@link statusCodeMap} plus {@link HTTP_STATUS_ALIASES} for 408 and 503.
+* - Unmapped 4xx → validation, unmapped 5xx → internal.
+* - All other codes (1xx, 3xx) → internal.
+*
+* @param response - The HTTP Response to inspect
+* @returns `Result.ok(response)` for 2xx, `Result.err(OutfitterError)` otherwise
+*
+* @example
+* ```typescript
+* const response = await fetch("https://api.example.com/data");
+* const result = fromFetch(response);
+*
+* if (result.isOk()) {
+*   const data = await result.value.json();
+* } else {
+*   console.error(result.error.category, result.error.message);
+* }
+* ```
+*/
+declare function fromFetch(response: Response): Result<Response, OutfitterError>;
+export { fromFetch };