@outfitter/contracts 0.3.0 → 0.4.1

package/dist/shared/@outfitter/contracts-t79engf9.d.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+/**
+* JSON Schema representation.
+*/
+interface JsonSchema {
+	$defs?: Record<string, JsonSchema>;
+	$ref?: string;
+	$schema?: string;
+	additionalProperties?: boolean | JsonSchema;
+	allOf?: JsonSchema[];
+	anyOf?: JsonSchema[];
+	const?: unknown;
+	default?: unknown;
+	definitions?: Record<string, JsonSchema>;
+	description?: string;
+	enum?: unknown[];
+	exclusiveMaximum?: number;
+	exclusiveMinimum?: number;
+	format?: string;
+	items?: JsonSchema | JsonSchema[];
+	maximum?: number;
+	maxLength?: number;
+	minimum?: number;
+	minLength?: number;
+	not?: JsonSchema | Record<string, never>;
+	oneOf?: JsonSchema[];
+	pattern?: string;
+	properties?: Record<string, JsonSchema>;
+	required?: string[];
+	type?: string;
+}
+/**
+* Convert a Zod schema to JSON Schema format.
+*
+* This is a simplified converter that handles common Zod types.
+* For complex schemas, consider using a full zod-to-json-schema library.
+*
+* @param schema - Zod schema to convert
+* @returns JSON Schema representation
+*
+* @example
+* ```typescript
+* const zodSchema = z.object({
+*   name: z.string(),
+*   age: z.number().optional(),
+* });
+*
+* const jsonSchema = zodToJsonSchema(zodSchema);
+* // {
+* //   type: "object",
+* //   properties: {
+* //     name: { type: "string" },
+* //     age: { type: "number" },
+* //   },
+* //   required: ["name"],
+* // }
+* ```
+*/
+declare function zodToJsonSchema(schema: z.ZodType<unknown>): JsonSchema;
+export { JsonSchema, zodToJsonSchema };

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

@@ -0,0 +1,341 @@
+// @bun
+// 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/validation.d.ts

@@ -1,3 +1,3 @@
-import { createValidator, validateInput } from "./shared/@outfitter/contracts-6j6z9dsd";
-import "./shared/@outfitter/contracts-r35bn9p6";
+import { createValidator, validateInput } from "./shared/@outfitter/contracts-9wtm5nsw.js";
+import "./shared/@outfitter/contracts-3gswmhb1.js";
 export { validateInput, createValidator };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@outfitter/contracts",
   "description": "Result/Error patterns, error taxonomy, and handler contracts for Outfitter",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "type": "module",
   "files": [
     "dist"
@@ -100,6 +100,12 @@
         "default": "./dist/result/utilities.js"
       }
     },
+    "./schema": {
+      "import": {
+        "types": "./dist/schema.d.ts",
+        "default": "./dist/schema.js"
+      }
+    },
     "./serialization": {
       "import": {
         "types": "./dist/serialization.d.ts",
@@ -120,7 +126,8 @@
     "lint:fix": "biome lint --write ./src",
     "test": "bun test",
     "typecheck": "tsc --noEmit",
-    "clean": "rm -rf dist"
+    "clean": "rm -rf dist",
+    "prepublishOnly": "bun ../../scripts/check-publish-manifest.ts"
   },
   "dependencies": {
     "better-result": "^2.5.0",

package/dist/shared/@outfitter/{contracts-r35bn9p6.d.ts → contracts-3gswmhb1.d.ts}

@@ -90,17 +90,17 @@ type ErrorCode = (typeof ERROR_CODES)[keyof typeof ERROR_CODES][keyof (typeof ER
 interface SerializedError {
 	_tag: string;
 	category: ErrorCategory;
-	message: string;
 	context?: Record<string, unknown>;
+	message: string;
 }
 /**
 * Base interface for OutfitterError properties.
 * All concrete error classes must include these fields.
 */
 interface KitErrorProps {
-	message: string;
 	category: ErrorCategory;
 	context?: Record<string, unknown>;
+	message: string;
 }
 /**
 * Get CLI exit code for an error category.

package/dist/shared/@outfitter/{contracts-5k6q4n48.js → contracts-3wj7xghe.js}

@@ -1,4 +1,9 @@
 // @bun
+import {
+  DEFAULT_PATTERNS,
+  DEFAULT_SENSITIVE_KEYS,
+  createRedactor
+} from "./contracts-s15x2rs4.js";
 import {
   AlreadyExistsError,
   AmbiguousError,
@@ -14,11 +19,6 @@ import {
   TimeoutError,
   ValidationError
 } from "./contracts-phjhz5q3.js";
-import {
-  DEFAULT_PATTERNS,
-  DEFAULT_SENSITIVE_KEYS,
-  createRedactor
-} from "./contracts-s15x2rs4.js";
 
 // packages/contracts/src/serialization.ts
 import { Result } from "better-result";

package/dist/shared/@outfitter/{contracts-e70qdasg.d.ts → contracts-9yd4vrjg.d.ts}

@@ -2,25 +2,25 @@
 * Configuration for creating a redactor.
 */
 interface RedactorConfig {
-	/** Regex patterns to match and redact */
-	patterns: RegExp[];
+	/** Whether to redact recursively in nested objects (default: true) */
+	deep?: boolean;
 	/** Object keys whose values should always be redacted */
 	keys: string[];
+	/** Regex patterns to match and redact */
+	patterns: RegExp[];
 	/** Replacement string (default: "[REDACTED]") */
 	replacement?: string;
-	/** Whether to redact recursively in nested objects (default: true) */
-	deep?: boolean;
 }
 /**
 * Redaction event for audit logging.
 */
 interface RedactionEvent {
-	/** Type of redaction applied */
-	redactedBy: "pattern" | "key";
 	/** Identifier of the pattern/key that matched */
 	matcher: string;
 	/** Location in the object path (e.g., "config.auth.apiKey") */
 	path: string;
+	/** Type of redaction applied */
+	redactedBy: "pattern" | "key";
 }
 /**
 * Callback for redaction events.
@@ -49,16 +49,16 @@ type RedactionCallback = (event: RedactionEvent) => void;
 * ```
 */
 interface Redactor {
-	/** Redact sensitive values from an object (deep) */
-	redact<T>(value: T): T;
-	/** Redact sensitive values from a string */
-	redactString(value: string): string;
-	/** Check if a key name is sensitive */
-	isSensitiveKey(key: string): boolean;
 	/** Add a pattern at runtime */
 	addPattern(pattern: RegExp): void;
 	/** Add a sensitive key at runtime */
 	addSensitiveKey(key: string): void;
+	/** Check if a key name is sensitive */
+	isSensitiveKey(key: string): boolean;
+	/** Redact sensitive values from an object (deep) */
+	redact<T>(value: T): T;
+	/** Redact sensitive values from a string */
+	redactString(value: string): string;
 }
 /**
 * Default patterns for common secrets.

package/dist/shared/@outfitter/{contracts-93dx53mt.d.ts → contracts-c2cfj172.d.ts}

@@ -6,39 +6,39 @@ import { Result } from "better-result";
 /** Error during indexing operations */
 interface IndexError {
 	readonly _tag: "IndexError";
-	readonly message: string;
 	readonly cause?: unknown;
+	readonly message: string;
 }
 /** Error during cache operations */
 interface CacheError {
 	readonly _tag: "CacheError";
-	readonly message: string;
 	readonly cause?: unknown;
+	readonly message: string;
 }
 /** Error during auth/credential operations */
 interface AdapterAuthError {
 	readonly _tag: "AdapterAuthError";
-	readonly message: string;
 	readonly cause?: unknown;
+	readonly message: string;
 }
 /** Error during storage operations */
 interface StorageError {
 	readonly _tag: "StorageError";
-	readonly message: string;
 	readonly cause?: unknown;
+	readonly message: string;
 }
 /**
 * Search options for index adapter.
 */
 interface SearchOptions {
+	/** Fields to boost in relevance scoring */
+	boostFields?: string[];
+	/** Field-specific filters */
+	filters?: Record<string, unknown>;
 	/** Maximum results to return */
 	limit?: number;
 	/** Offset for pagination */
 	offset?: number;
-	/** Field-specific filters */
-	filters?: Record<string, unknown>;
-	/** Fields to boost in relevance scoring */
-	boostFields?: string[];
 }
 /**
 * Search result from index adapter.
@@ -50,10 +50,10 @@ interface SearchResult<T> {
 		score: number;
 		highlights?: Record<string, string[]>;
 	}>;
-	/** Total number of matches (for pagination) */
-	total: number;
 	/** Search execution time in milliseconds */
 	took: number;
+	/** Total number of matches (for pagination) */
+	total: number;
 }
 /**
 * Index statistics.
@@ -61,10 +61,10 @@ interface SearchResult<T> {
 interface IndexStats {
 	/** Total documents indexed */
 	documentCount: number;
-	/** Index size in bytes (if available) */
-	sizeBytes?: number;
 	/** Last update timestamp */
 	lastUpdated: Date | null;
+	/** Index size in bytes (if available) */
+	sizeBytes?: number;
 }
 /**
 * Index adapter - pluggable full-text search backends.
@@ -86,14 +86,14 @@ interface IndexStats {
 * ```
 */
 interface IndexAdapter<T> {
+	/** Clear all indexed documents */
+	clear(): Promise<Result<void, IndexError>>;
 	/** Add or update documents in the index */
 	index(items: T[]): Promise<Result<void, IndexError>>;
-	/** Full-text search with optional filters */
-	search(query: string, options?: SearchOptions): Promise<Result<SearchResult<T>, IndexError>>;
 	/** Remove documents by ID */
 	remove(ids: string[]): Promise<Result<void, IndexError>>;
-	/** Clear all indexed documents */
-	clear(): Promise<Result<void, IndexError>>;
+	/** Full-text search with optional filters */
+	search(query: string, options?: SearchOptions): Promise<Result<SearchResult<T>, IndexError>>;
 	/** Get index statistics */
 	stats(): Promise<Result<IndexStats, IndexError>>;
 }
@@ -113,18 +113,18 @@ interface IndexAdapter<T> {
 * ```
 */
 interface CacheAdapter<T> {
-	/** Get cached value, null if not found or expired */
-	get(key: string): Promise<Result<T | null, CacheError>>;
-	/** Set value with optional TTL in seconds */
-	set(key: string, value: T, ttlSeconds?: number): Promise<Result<void, CacheError>>;
-	/** Delete cached value, returns true if existed */
-	delete(key: string): Promise<Result<boolean, CacheError>>;
 	/** Clear all cached values */
 	clear(): Promise<Result<void, CacheError>>;
-	/** Check if key exists (without retrieving value) */
-	has(key: string): Promise<Result<boolean, CacheError>>;
+	/** Delete cached value, returns true if existed */
+	delete(key: string): Promise<Result<boolean, CacheError>>;
+	/** Get cached value, null if not found or expired */
+	get(key: string): Promise<Result<T | null, CacheError>>;
 	/** Get multiple values at once */
 	getMany(keys: string[]): Promise<Result<Map<string, T>, CacheError>>;
+	/** Check if key exists (without retrieving value) */
+	has(key: string): Promise<Result<boolean, CacheError>>;
+	/** Set value with optional TTL in seconds */
+	set(key: string, value: T, ttlSeconds?: number): Promise<Result<void, CacheError>>;
 }
 /**
 * Auth adapter - pluggable credential storage.
@@ -140,14 +140,14 @@ interface CacheAdapter<T> {
 * ```
 */
 interface AuthAdapter {
-	/** Retrieve credential by key */
-	get(key: string): Promise<Result<string | null, AdapterAuthError>>;
-	/** Store credential */
-	set(key: string, value: string): Promise<Result<void, AdapterAuthError>>;
 	/** Remove credential */
 	delete(key: string): Promise<Result<boolean, AdapterAuthError>>;
+	/** Retrieve credential by key */
+	get(key: string): Promise<Result<string | null, AdapterAuthError>>;
 	/** List available credential keys (not values) */
 	list(): Promise<Result<string[], AdapterAuthError>>;
+	/** Store credential */
+	set(key: string, value: string): Promise<Result<void, AdapterAuthError>>;
 }
 /**
 * Storage adapter - pluggable blob/file storage.
@@ -163,20 +163,20 @@ interface AuthAdapter {
 * ```
 */
 interface StorageAdapter {
-	/** Read file contents */
-	read(path: string): Promise<Result<Uint8Array, StorageError>>;
-	/** Write file contents */
-	write(path: string, data: Uint8Array): Promise<Result<void, StorageError>>;
 	/** Delete file */
 	delete(path: string): Promise<Result<boolean, StorageError>>;
 	/** Check if file exists */
 	exists(path: string): Promise<Result<boolean, StorageError>>;
 	/** List files in directory */
 	list(prefix: string): Promise<Result<string[], StorageError>>;
+	/** Read file contents */
+	read(path: string): Promise<Result<Uint8Array, StorageError>>;
 	/** Get file metadata (size, modified time) */
 	stat(path: string): Promise<Result<{
 		size: number;
 		modifiedAt: Date;
 	} | null, StorageError>>;
+	/** Write file contents */
+	write(path: string, data: Uint8Array): Promise<Result<void, StorageError>>;
 }
 export { IndexError, CacheError, AdapterAuthError, StorageError, SearchOptions, SearchResult, IndexStats, IndexAdapter, CacheAdapter, AuthAdapter, StorageAdapter };