@outfitter/contracts 0.4.1 → 0.4.2

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.js

@@ -1,7 +1,342 @@
 // @bun
-import {
-  zodToJsonSchema
-} from "./shared/@outfitter/contracts-wfht4q2b.js";
+// packages/contracts/src/schema.ts
+function zodToJsonSchema(schema) {
+  return convertZodType(schema);
+}
+function getDef(schemaOrDef) {
+  if (!schemaOrDef) {
+    return;
+  }
+  if (schemaOrDef._def) {
+    return schemaOrDef._def;
+  }
+  if (schemaOrDef.def) {
+    return schemaOrDef.def;
+  }
+  return schemaOrDef;
+}
+function getDescription(schema, def) {
+  if (typeof schema?.description === "string") {
+    return schema.description;
+  }
+  if (typeof def?.description === "string") {
+    return def.description;
+  }
+  return;
+}
+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);
+      break;
+    case "ZodObject":
+    case "object":
+      jsonSchema = convertObject(def);
+      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;
+}
+function convertString(def) {
+  const schema = { type: "string" };
+  if (def.checks) {
+    for (const check of def.checks) {
+      const normalizedCheck = check?._zod?.def ?? check?.def ?? check;
+      if (normalizedCheck?.kind) {
+        switch (normalizedCheck.kind) {
+          case "min":
+            schema.minLength = normalizedCheck.value;
+            break;
+          case "max":
+            schema.maxLength = normalizedCheck.value;
+            break;
+          case "length":
+            schema.minLength = normalizedCheck.value;
+            schema.maxLength = normalizedCheck.value;
+            break;
+          case "email":
+            schema.pattern = "^[^@]+@[^@]+\\.[^@]+$";
+            break;
+          case "url":
+            schema.pattern = "^https?://";
+            break;
+          case "uuid":
+            schema.pattern = "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$";
+            break;
+          case "regex":
+            schema.pattern = normalizedCheck.regex?.source ?? normalizedCheck.pattern?.source ?? (typeof normalizedCheck.pattern === "string" ? normalizedCheck.pattern : undefined);
+            break;
+          default:
+            break;
+        }
+        continue;
+      }
+      if (!normalizedCheck?.check) {
+        continue;
+      }
+      switch (normalizedCheck.check) {
+        case "min_length":
+          schema.minLength = normalizedCheck.minimum;
+          break;
+        case "max_length":
+          schema.maxLength = normalizedCheck.maximum;
+          break;
+        case "string_format":
+          if (normalizedCheck.pattern) {
+            schema.pattern = typeof normalizedCheck.pattern === "string" ? normalizedCheck.pattern : normalizedCheck.pattern.source;
+          }
+          if (normalizedCheck.format && normalizedCheck.format !== "regex") {
+            schema.format = normalizedCheck.format;
+          }
+          break;
+        default:
+          break;
+      }
+    }
+  }
+  return schema;
+}
+function convertNumber(def) {
+  const schema = { type: "number" };
+  if (def.checks) {
+    for (const check of def.checks) {
+      const normalizedCheck = check?._zod?.def ?? check?.def ?? check;
+      if (normalizedCheck?.kind) {
+        switch (normalizedCheck.kind) {
+          case "min":
+            schema.minimum = normalizedCheck.value;
+            break;
+          case "max":
+            schema.maximum = normalizedCheck.value;
+            break;
+          case "int":
+            schema.type = "integer";
+            break;
+          default:
+            break;
+        }
+        continue;
+      }
+      if (!normalizedCheck?.check) {
+        continue;
+      }
+      switch (normalizedCheck.check) {
+        case "greater_than":
+          if (normalizedCheck.inclusive) {
+            schema.minimum = normalizedCheck.value;
+          } else {
+            schema.exclusiveMinimum = normalizedCheck.value;
+          }
+          break;
+        case "less_than":
+          if (normalizedCheck.inclusive) {
+            schema.maximum = normalizedCheck.value;
+          } else {
+            schema.exclusiveMaximum = normalizedCheck.value;
+          }
+          break;
+        case "number_format":
+          if (normalizedCheck.format === "int" || normalizedCheck.format === "safeint") {
+            schema.type = "integer";
+          }
+          break;
+        default:
+          break;
+      }
+    }
+  }
+  return schema;
+}
+function convertArray(def) {
+  const element = def.element ?? def.type;
+  const schema = {
+    type: "array",
+    items: element ? convertZodType(element) : {}
+  };
+  return schema;
+}
+function isFieldOptional(fieldDef) {
+  if (!(fieldDef?.typeName || fieldDef?.type)) {
+    return false;
+  }
+  const typeName = fieldDef.typeName ?? fieldDef.type;
+  if (typeName === "ZodOptional" || typeName === "ZodDefault" || typeName === "optional" || typeName === "default") {
+    return true;
+  }
+  if (typeName === "ZodEffects") {
+    return isFieldOptional(getDef(fieldDef.schema));
+  }
+  if (typeName === "ZodPipeline" || typeName === "pipe") {
+    const inputOptional = isFieldOptional(getDef(fieldDef.in));
+    const outputDef = getDef(fieldDef.out);
+    const outputType = outputDef?.typeName ?? outputDef?.type;
+    if (outputType === "transform") {
+      return inputOptional;
+    }
+    const outputOptional = isFieldOptional(outputDef);
+    return inputOptional && outputOptional;
+  }
+  if (typeName === "ZodNullable" || typeName === "nullable") {
+    return isFieldOptional(getDef(fieldDef.innerType));
+  }
+  return false;
+}
+function convertObject(def) {
+  const properties = {};
+  const required = [];
+  const shape = typeof def.shape === "function" ? def.shape() : def.shape;
+  for (const [key, value] of Object.entries(shape ?? {})) {
+    properties[key] = convertZodType(value);
+    const fieldDef = getDef(value);
+    if (!isFieldOptional(fieldDef)) {
+      required.push(key);
+    }
+  }
+  const schema = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) {
+    schema.required = required;
+  }
+  return schema;
+}
 export {
   zodToJsonSchema
 };

package/dist/serialization.js

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

package/dist/validation.js

@@ -1,9 +1,41 @@
 // @bun
 import {
-  createValidator,
-  validateInput
-} from "./shared/@outfitter/contracts-0snpmkdt.js";
-import"./shared/@outfitter/contracts-phjhz5q3.js";
+  ValidationError
+} from "./shared/@outfitter/contracts-phjhz5q3.js";
+
+// packages/contracts/src/validation.ts
+import { Result } from "better-result";
+function formatZodIssues(issues) {
+  return issues.map((issue) => {
+    const path = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+    return `${path}: ${issue.message}`;
+  }).join("; ");
+}
+function extractField(issues) {
+  const firstIssue = issues[0];
+  if (firstIssue && firstIssue.path.length > 0) {
+    return firstIssue.path.join(".");
+  }
+  return;
+}
+function createValidator(schema) {
+  return (input) => {
+    return validateInput(schema, input);
+  };
+}
+function validateInput(schema, input) {
+  const parseResult = schema.safeParse(input);
+  if (parseResult.success) {
+    return Result.ok(parseResult.data);
+  }
+  const message = formatZodIssues(parseResult.error.issues);
+  const field = extractField(parseResult.error.issues);
+  const errorProps = { message };
+  if (field !== undefined) {
+    errorProps.field = field;
+  }
+  return Result.err(new ValidationError(errorProps));
+}
 export {
   validateInput,
   createValidator

package/package.json

@@ -1,11 +1,25 @@
 {
   "name": "@outfitter/contracts",
+  "version": "0.4.2",
   "description": "Result/Error patterns, error taxonomy, and handler contracts for Outfitter",
-  "version": "0.4.1",
-  "type": "module",
+  "keywords": [
+    "contracts",
+    "errors",
+    "outfitter",
+    "result",
+    "typescript"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/outfitter-dev/outfitter.git",
+    "directory": "packages/contracts"
+  },
   "files": [
     "dist"
   ],
+  "type": "module",
+  "sideEffects": false,
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -119,38 +133,24 @@
       }
     }
   },
-  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "build": "cd ../.. && bunup --filter @outfitter/contracts",
-    "lint": "biome lint ./src",
-    "lint:fix": "biome lint --write ./src",
+    "lint": "oxlint ./src",
+    "lint:fix": "oxlint --fix ./src",
     "test": "bun test",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist",
     "prepublishOnly": "bun ../../scripts/check-publish-manifest.ts"
   },
   "dependencies": {
-    "better-result": "^2.5.0",
+    "better-result": "^2.5.1",
     "zod": "^4.3.5"
   },
   "devDependencies": {
-    "@types/bun": "latest",
-    "typescript": "^5.8.0"
-  },
-  "keywords": [
-    "outfitter",
-    "contracts",
-    "errors",
-    "result",
-    "typescript"
-  ],
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/outfitter-dev/outfitter.git",
-    "directory": "packages/contracts"
-  },
-  "publishConfig": {
-    "access": "public"
+    "@types/bun": "^1.3.9",
+    "typescript": "^5.9.3"
   }
 }

package/dist/shared/@outfitter/contracts-0snpmkdt.js

@@ -1,40 +0,0 @@
-// @bun
-import {
-  ValidationError
-} from "./contracts-phjhz5q3.js";
-
-// packages/contracts/src/validation.ts
-import { Result } from "better-result";
-function formatZodIssues(issues) {
-  return issues.map((issue) => {
-    const path = issue.path.length > 0 ? issue.path.join(".") : "(root)";
-    return `${path}: ${issue.message}`;
-  }).join("; ");
-}
-function extractField(issues) {
-  const firstIssue = issues[0];
-  if (firstIssue && firstIssue.path.length > 0) {
-    return firstIssue.path.join(".");
-  }
-  return;
-}
-function createValidator(schema) {
-  return (input) => {
-    return validateInput(schema, input);
-  };
-}
-function validateInput(schema, input) {
-  const parseResult = schema.safeParse(input);
-  if (parseResult.success) {
-    return Result.ok(parseResult.data);
-  }
-  const message = formatZodIssues(parseResult.error.issues);
-  const field = extractField(parseResult.error.issues);
-  const errorProps = { message };
-  if (field !== undefined) {
-    errorProps.field = field;
-  }
-  return Result.err(new ValidationError(errorProps));
-}
-
-export { createValidator, validateInput };

package/dist/shared/@outfitter/contracts-37gpc56f.js

@@ -1 +0,0 @@
-// @bun

package/dist/shared/@outfitter/contracts-4zaj7ejb.js

@@ -1,52 +0,0 @@
-// @bun
-// 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 { isRecoverable, isRetryable, getBackoffDelay, shouldRetry };

package/dist/shared/@outfitter/contracts-85nd53s9.js

@@ -1,53 +0,0 @@
-// @bun
-import {
-  serializeError
-} from "./contracts-3wj7xghe.js";
-import {
-  statusCodeMap
-} from "./contracts-phjhz5q3.js";
-import {
-  generateRequestId
-} from "./contracts-agmt8915.js";
-
-// packages/contracts/src/envelope.ts
-function buildMeta(overrides) {
-  const meta = {
-    requestId: overrides?.requestId ?? generateRequestId(),
-    timestamp: new Date().toISOString()
-  };
-  if (overrides?.durationMs !== undefined) {
-    meta.durationMs = overrides.durationMs;
-  }
-  return meta;
-}
-function toEnvelope(result, meta) {
-  const envelopeMeta = buildMeta(meta);
-  if (result.isOk()) {
-    return {
-      ok: true,
-      data: result.value,
-      meta: envelopeMeta
-    };
-  }
-  return {
-    ok: false,
-    error: serializeError(result.error),
-    meta: envelopeMeta
-  };
-}
-function toHttpResponse(result) {
-  const envelope = toEnvelope(result);
-  if (envelope.ok) {
-    return {
-      status: 200,
-      body: envelope
-    };
-  }
-  const status = statusCodeMap[envelope.error.category];
-  return {
-    status,
-    body: envelope
-  };
-}
-
-export { toEnvelope, toHttpResponse };

package/dist/shared/@outfitter/contracts-cp5c6dws.js

@@ -1,32 +0,0 @@
-// @bun
-import {
-  AssertionError
-} from "./contracts-phjhz5q3.js";
-
-// packages/contracts/src/assert/index.ts
-import { Result } from "better-result";
-var isNonEmptyArray = (arr) => {
-  return arr.length > 0;
-};
-var assertDefined = (value, message) => {
-  if (value === null || value === undefined) {
-    return Result.err(new AssertionError({ message: message ?? "Value is null or undefined" }));
-  }
-  return Result.ok(value);
-};
-var assertNonEmpty = (arr, message) => {
-  if (arr.length === 0) {
-    return Result.err(new AssertionError({ message: message ?? "Array is empty" }));
-  }
-  return Result.ok(arr);
-};
-function assertMatches(value, predicate, message) {
-  if (!predicate(value)) {
-    return Result.err(new AssertionError({
-      message: message ?? "Value does not match predicate"
-    }));
-  }
-  return Result.ok(value);
-}
-
-export { isNonEmptyArray, assertDefined, assertNonEmpty, assertMatches };