@perkos/schema-validation 1.0.0

package/README.md

@@ -0,0 +1,180 @@
+# @perkos/schema-validation
+
+Zod validation schemas for AI and payment services.
+
+## Installation
+
+```bash
+npm install @perkos/schema-validation
+```
+
+## Usage
+
+### AI Validators
+
+```typescript
+import {
+  imageAnalyzeSchema,
+  imageGenerateSchema,
+  textSummarizeSchema,
+  validate,
+  safeValidate,
+} from "@perkos/schema-validation";
+
+// Or import specifically from ai subpath
+import { codeGenerateSchema } from "@perkos/schema-validation/ai";
+
+// Validate with parse (throws on error)
+const input = validate(imageAnalyzeSchema, {
+  image: "https://example.com/image.jpg",
+  question: "What is in this image?",
+});
+
+// Safe validate (returns result object)
+const result = safeValidate(imageGenerateSchema, requestBody);
+if (result.success) {
+  console.log(result.data.prompt);
+} else {
+  console.error(result.error.errors);
+}
+```
+
+### Payment Validators
+
+```typescript
+import {
+  paymentEnvelopeSchema,
+  ethereumAddressSchema,
+  networkSchema,
+} from "@perkos/schema-validation";
+
+// Or import from payment subpath
+import { paymentConfigSchema } from "@perkos/schema-validation/payment";
+
+// Validate Ethereum address
+const address = ethereumAddressSchema.parse("0x1234...");
+
+// Validate payment envelope
+const envelope = paymentEnvelopeSchema.parse({
+  payload: {
+    from: "0x...",
+    to: "0x...",
+    value: "1000000",
+    validAfter: 0,
+    validBefore: Date.now() + 3600000,
+    nonce: "abc123",
+    network: "eip155:43114",
+  },
+  signature: "0x...",
+});
+```
+
+## AI Schemas
+
+### Vision & Image
+
+- `imageAnalyzeSchema` - Image analysis requests
+- `imageGenerateSchema` - Image generation (DALL-E, SDXL)
+- `ocrExtractSchema` - OCR text extraction
+
+### Audio
+
+- `textSynthesizeSchema` - Text-to-speech
+- `audioTranscribeSchema` - Speech-to-text
+
+### Text Processing
+
+- `textSummarizeSchema` - Text summarization
+- `textTranslateSchema` - Translation
+- `sentimentAnalyzeSchema` - Sentiment analysis
+- `contentModerateSchema` - Content moderation
+- `textSimplifySchema` - Text simplification
+- `entityExtractSchema` - Named entity extraction
+
+### Content Generation
+
+- `emailGenerateSchema` - Email generation
+- `productDescriptionSchema` - Product descriptions
+- `seoOptimizeSchema` - SEO optimization
+
+### Code & Technical
+
+- `codeGenerateSchema` - Code generation
+- `codeReviewSchema` - Code review
+- `sqlQuerySchema` - SQL query generation
+- `regexGenerateSchema` - Regex generation
+- `apiDocsSchema` - API documentation
+
+### Educational
+
+- `quizGenerateSchema` - Quiz generation
+
+## Payment Schemas
+
+### Network & Chain
+
+- `networkSchema` - Supported networks enum
+- `caip2NetworkSchema` - CAIP-2 network format
+- `ethereumAddressSchema` - Ethereum address validation
+- `transactionHashSchema` - Transaction hash validation
+- `signatureSchema` - Signature format validation
+
+### Payment
+
+- `paymentEnvelopeSchema` - x402 payment envelope
+- `paymentConfigSchema` - Payment configuration
+- `paymentRequestSchema` - Payment request
+- `paymentVerificationSchema` - Payment verification
+
+### Token
+
+- `tokenInfoSchema` - ERC20 token info
+- `eip712DomainSchema` - EIP-712 domain
+
+### Settlement
+
+- `settlementRequestSchema` - Settlement request
+- `settlementResultSchema` - Settlement result
+
+## Utility Functions
+
+### `validate(schema, data)`
+
+Parse and validate data, throwing on errors.
+
+### `safeValidate(schema, data)`
+
+Safely validate, returning `{ success, data }` or `{ success, error }`.
+
+### `formatZodErrors(error)`
+
+Format Zod errors for API responses.
+
+```typescript
+import { formatZodErrors } from "@perkos/schema-validation";
+
+try {
+  schema.parse(data);
+} catch (error) {
+  if (error instanceof z.ZodError) {
+    const formatted = formatZodErrors(error);
+    // [{ path: "email", message: "Invalid email", code: "invalid_string" }]
+  }
+}
+```
+
+## Type Inference
+
+All schemas export inferred TypeScript types:
+
+```typescript
+import type {
+  ImageAnalyzeInput,
+  PaymentEnvelope,
+  Network,
+} from "@perkos/schema-validation";
+```
+
+## License
+
+MIT

package/dist/ai.d.mts

@@ -0,0 +1,307 @@
+import { z } from 'zod';
+
+/**
+ * @perkos/validators/ai
+ * AI endpoint request validators using Zod
+ */
+
+declare const imageAnalyzeSchema: z.ZodObject<{
+    image: z.ZodString;
+    question: z.ZodOptional<z.ZodString>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    image: string;
+    question?: string | undefined;
+    maxTokens?: number | undefined;
+}, {
+    image: string;
+    question?: string | undefined;
+    maxTokens?: number | undefined;
+}>;
+declare const imageGenerateSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    size: z.ZodDefault<z.ZodOptional<z.ZodEnum<["1024x1024", "1792x1024", "1024x1792"]>>>;
+    quality: z.ZodDefault<z.ZodOptional<z.ZodEnum<["standard", "hd"]>>>;
+    style: z.ZodDefault<z.ZodOptional<z.ZodEnum<["vivid", "natural"]>>>;
+    n: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    size: "1024x1024" | "1792x1024" | "1024x1792";
+    quality: "standard" | "hd";
+    style: "vivid" | "natural";
+    n: number;
+}, {
+    prompt: string;
+    size?: "1024x1024" | "1792x1024" | "1024x1792" | undefined;
+    quality?: "standard" | "hd" | undefined;
+    style?: "vivid" | "natural" | undefined;
+    n?: number | undefined;
+}>;
+declare const ocrExtractSchema: z.ZodObject<{
+    image: z.ZodString;
+    language: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    image: string;
+    language?: string | undefined;
+}, {
+    image: string;
+    language?: string | undefined;
+}>;
+declare const textSynthesizeSchema: z.ZodObject<{
+    text: z.ZodString;
+    voice: z.ZodDefault<z.ZodOptional<z.ZodEnum<["alloy", "echo", "fable", "onyx", "nova", "shimmer"]>>>;
+    speed: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    voice: "alloy" | "echo" | "fable" | "onyx" | "nova" | "shimmer";
+    speed: number;
+}, {
+    text: string;
+    voice?: "alloy" | "echo" | "fable" | "onyx" | "nova" | "shimmer" | undefined;
+    speed?: number | undefined;
+}>;
+declare const audioTranscribeSchema: z.ZodObject<{
+    audio: z.ZodString;
+    language: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    audio: string;
+    prompt?: string | undefined;
+    language?: string | undefined;
+}, {
+    audio: string;
+    prompt?: string | undefined;
+    language?: string | undefined;
+}>;
+declare const textSummarizeSchema: z.ZodObject<{
+    text: z.ZodString;
+    length: z.ZodDefault<z.ZodOptional<z.ZodEnum<["short", "medium", "long"]>>>;
+    format: z.ZodDefault<z.ZodOptional<z.ZodEnum<["paragraph", "bullets"]>>>;
+}, "strip", z.ZodTypeAny, {
+    length: "short" | "medium" | "long";
+    text: string;
+    format: "paragraph" | "bullets";
+}, {
+    text: string;
+    length?: "short" | "medium" | "long" | undefined;
+    format?: "paragraph" | "bullets" | undefined;
+}>;
+declare const textTranslateSchema: z.ZodObject<{
+    text: z.ZodString;
+    sourceLang: z.ZodString;
+    targetLang: z.ZodString;
+    formality: z.ZodOptional<z.ZodEnum<["formal", "informal", "neutral"]>>;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    sourceLang: string;
+    targetLang: string;
+    formality?: "formal" | "informal" | "neutral" | undefined;
+}, {
+    text: string;
+    sourceLang: string;
+    targetLang: string;
+    formality?: "formal" | "informal" | "neutral" | undefined;
+}>;
+declare const sentimentAnalyzeSchema: z.ZodObject<{
+    text: z.ZodString;
+    detailed: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    detailed: boolean;
+}, {
+    text: string;
+    detailed?: boolean | undefined;
+}>;
+declare const contentModerateSchema: z.ZodObject<{
+    content: z.ZodString;
+    categories: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    categories?: string[] | undefined;
+}, {
+    content: string;
+    categories?: string[] | undefined;
+}>;
+declare const textSimplifySchema: z.ZodObject<{
+    text: z.ZodString;
+    targetLevel: z.ZodDefault<z.ZodOptional<z.ZodEnum<["elementary", "middle", "high", "college"]>>>;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    targetLevel: "elementary" | "middle" | "high" | "college";
+}, {
+    text: string;
+    targetLevel?: "elementary" | "middle" | "high" | "college" | undefined;
+}>;
+declare const entityExtractSchema: z.ZodObject<{
+    text: z.ZodString;
+    types: z.ZodOptional<z.ZodArray<z.ZodEnum<["person", "organization", "location", "date", "money", "product"]>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    types?: ("date" | "person" | "organization" | "location" | "money" | "product")[] | undefined;
+}, {
+    text: string;
+    types?: ("date" | "person" | "organization" | "location" | "money" | "product")[] | undefined;
+}>;
+declare const emailGenerateSchema: z.ZodObject<{
+    context: z.ZodString;
+    tone: z.ZodDefault<z.ZodOptional<z.ZodEnum<["professional", "friendly", "formal", "casual"]>>>;
+    length: z.ZodDefault<z.ZodOptional<z.ZodEnum<["short", "medium", "long"]>>>;
+}, "strip", z.ZodTypeAny, {
+    length: "short" | "medium" | "long";
+    context: string;
+    tone: "formal" | "professional" | "friendly" | "casual";
+}, {
+    context: string;
+    length?: "short" | "medium" | "long" | undefined;
+    tone?: "formal" | "professional" | "friendly" | "casual" | undefined;
+}>;
+declare const productDescriptionSchema: z.ZodObject<{
+    product: z.ZodString;
+    features: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    audience: z.ZodOptional<z.ZodString>;
+    tone: z.ZodDefault<z.ZodOptional<z.ZodEnum<["professional", "casual", "luxury", "technical"]>>>;
+}, "strip", z.ZodTypeAny, {
+    product: string;
+    tone: "professional" | "casual" | "luxury" | "technical";
+    features?: string[] | undefined;
+    audience?: string | undefined;
+}, {
+    product: string;
+    tone?: "professional" | "casual" | "luxury" | "technical" | undefined;
+    features?: string[] | undefined;
+    audience?: string | undefined;
+}>;
+declare const seoOptimizeSchema: z.ZodObject<{
+    content: z.ZodString;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    targetUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    keywords?: string[] | undefined;
+    targetUrl?: string | undefined;
+}, {
+    content: string;
+    keywords?: string[] | undefined;
+    targetUrl?: string | undefined;
+}>;
+declare const codeGenerateSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    language: z.ZodString;
+    framework: z.ZodOptional<z.ZodString>;
+    style: z.ZodDefault<z.ZodOptional<z.ZodEnum<["concise", "documented", "verbose"]>>>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    style: "concise" | "documented" | "verbose";
+    language: string;
+    framework?: string | undefined;
+}, {
+    prompt: string;
+    language: string;
+    style?: "concise" | "documented" | "verbose" | undefined;
+    framework?: string | undefined;
+}>;
+declare const codeReviewSchema: z.ZodObject<{
+    code: z.ZodString;
+    language: z.ZodOptional<z.ZodString>;
+    focus: z.ZodOptional<z.ZodArray<z.ZodEnum<["security", "performance", "readability", "bugs", "best-practices"]>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    language?: string | undefined;
+    focus?: ("security" | "performance" | "readability" | "bugs" | "best-practices")[] | undefined;
+}, {
+    code: string;
+    language?: string | undefined;
+    focus?: ("security" | "performance" | "readability" | "bugs" | "best-practices")[] | undefined;
+}>;
+declare const sqlQuerySchema: z.ZodObject<{
+    description: z.ZodString;
+    schema: z.ZodOptional<z.ZodString>;
+    dialect: z.ZodDefault<z.ZodOptional<z.ZodEnum<["postgresql", "mysql", "sqlite", "mssql"]>>>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    dialect: "postgresql" | "mysql" | "sqlite" | "mssql";
+    schema?: string | undefined;
+}, {
+    description: string;
+    schema?: string | undefined;
+    dialect?: "postgresql" | "mysql" | "sqlite" | "mssql" | undefined;
+}>;
+declare const regexGenerateSchema: z.ZodObject<{
+    description: z.ZodString;
+    examples: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        input: z.ZodString;
+        shouldMatch: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        input: string;
+        shouldMatch: boolean;
+    }, {
+        input: string;
+        shouldMatch: boolean;
+    }>, "many">>;
+    flavor: z.ZodDefault<z.ZodOptional<z.ZodEnum<["javascript", "python", "pcre"]>>>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    flavor: "javascript" | "python" | "pcre";
+    examples?: {
+        input: string;
+        shouldMatch: boolean;
+    }[] | undefined;
+}, {
+    description: string;
+    examples?: {
+        input: string;
+        shouldMatch: boolean;
+    }[] | undefined;
+    flavor?: "javascript" | "python" | "pcre" | undefined;
+}>;
+declare const apiDocsSchema: z.ZodObject<{
+    code: z.ZodString;
+    format: z.ZodDefault<z.ZodOptional<z.ZodEnum<["openapi", "markdown", "jsdoc"]>>>;
+    includeExamples: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    format: "openapi" | "markdown" | "jsdoc";
+    includeExamples: boolean;
+}, {
+    code: string;
+    format?: "openapi" | "markdown" | "jsdoc" | undefined;
+    includeExamples?: boolean | undefined;
+}>;
+declare const quizGenerateSchema: z.ZodObject<{
+    topic: z.ZodString;
+    questionCount: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    difficulty: z.ZodDefault<z.ZodOptional<z.ZodEnum<["easy", "medium", "hard"]>>>;
+    type: z.ZodDefault<z.ZodOptional<z.ZodEnum<["multiple-choice", "true-false", "mixed"]>>>;
+}, "strip", z.ZodTypeAny, {
+    type: "multiple-choice" | "true-false" | "mixed";
+    topic: string;
+    questionCount: number;
+    difficulty: "medium" | "easy" | "hard";
+}, {
+    topic: string;
+    type?: "multiple-choice" | "true-false" | "mixed" | undefined;
+    questionCount?: number | undefined;
+    difficulty?: "medium" | "easy" | "hard" | undefined;
+}>;
+type ImageAnalyzeInput = z.infer<typeof imageAnalyzeSchema>;
+type ImageGenerateInput = z.infer<typeof imageGenerateSchema>;
+type OCRExtractInput = z.infer<typeof ocrExtractSchema>;
+type TextSynthesizeInput = z.infer<typeof textSynthesizeSchema>;
+type AudioTranscribeInput = z.infer<typeof audioTranscribeSchema>;
+type TextSummarizeInput = z.infer<typeof textSummarizeSchema>;
+type TextTranslateInput = z.infer<typeof textTranslateSchema>;
+type SentimentAnalyzeInput = z.infer<typeof sentimentAnalyzeSchema>;
+type ContentModerateInput = z.infer<typeof contentModerateSchema>;
+type TextSimplifyInput = z.infer<typeof textSimplifySchema>;
+type EntityExtractInput = z.infer<typeof entityExtractSchema>;
+type EmailGenerateInput = z.infer<typeof emailGenerateSchema>;
+type ProductDescriptionInput = z.infer<typeof productDescriptionSchema>;
+type SEOOptimizeInput = z.infer<typeof seoOptimizeSchema>;
+type CodeGenerateInput = z.infer<typeof codeGenerateSchema>;
+type CodeReviewInput = z.infer<typeof codeReviewSchema>;
+type SQLQueryInput = z.infer<typeof sqlQuerySchema>;
+type RegexGenerateInput = z.infer<typeof regexGenerateSchema>;
+type APIDocsInput = z.infer<typeof apiDocsSchema>;
+type QuizGenerateInput = z.infer<typeof quizGenerateSchema>;
+
+export { type APIDocsInput, type AudioTranscribeInput, type CodeGenerateInput, type CodeReviewInput, type ContentModerateInput, type EmailGenerateInput, type EntityExtractInput, type ImageAnalyzeInput, type ImageGenerateInput, type OCRExtractInput, type ProductDescriptionInput, type QuizGenerateInput, type RegexGenerateInput, type SEOOptimizeInput, type SQLQueryInput, type SentimentAnalyzeInput, type TextSimplifyInput, type TextSummarizeInput, type TextSynthesizeInput, type TextTranslateInput, apiDocsSchema, audioTranscribeSchema, codeGenerateSchema, codeReviewSchema, contentModerateSchema, emailGenerateSchema, entityExtractSchema, imageAnalyzeSchema, imageGenerateSchema, ocrExtractSchema, productDescriptionSchema, quizGenerateSchema, regexGenerateSchema, sentimentAnalyzeSchema, seoOptimizeSchema, sqlQuerySchema, textSimplifySchema, textSummarizeSchema, textSynthesizeSchema, textTranslateSchema };