@pipeline-builder/api-core 3.1.0

package/lib/validation/ai-schemas.js

@@ -0,0 +1,81 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIGenerateFromUrlBodySchema = exports.PluginDeployGeneratedSchema = exports.AIGenerateBodySchema = void 0;
+const zod_1 = require("zod");
+const common_schemas_1 = require("./common-schemas");
+const MAX_PROMPT_LENGTH = parseInt(process.env.MAX_PROMPT_LENGTH || '5000', 10);
+// AI Generation Request
+/**
+ * Schema for AI generation request body.
+ * Used by both POST /pipelines/generate and POST /plugins/generate.
+ */
+exports.AIGenerateBodySchema = zod_1.z.object({
+    /** Natural language description of what to generate. */
+    prompt: zod_1.z
+        .string()
+        .min(1, 'A prompt with a natural language description is required')
+        .max(MAX_PROMPT_LENGTH, `Prompt must be ${MAX_PROMPT_LENGTH} characters or fewer`),
+    /** AI provider identifier (e.g. "anthropic", "openai", "google"). */
+    provider: zod_1.z.string().min(1, 'A provider is required (e.g., "anthropic", "openai", "google")'),
+    /** AI model identifier (e.g. "claude-sonnet-4-20250514", "gpt-4o"). */
+    model: zod_1.z.string().min(1, 'A model is required (e.g., "claude-sonnet-4-20250514", "gpt-4o")'),
+    /** Optional custom API key to override the server/org key for this request. */
+    apiKey: zod_1.z.string().min(1).optional(),
+    /** Previous pipeline config for iterative refinement. */
+    previousConfig: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+    /** Fallback AI providers if primary fails (e.g., ["openai", "google"]). */
+    fallbackProviders: zod_1.z.array(zod_1.z.string()).optional(),
+});
+// Plugin Deploy-Generated Request
+/**
+ * Schema for POST /plugins/deploy-generated request body.
+ * Validates the AI-generated plugin configuration before Docker build.
+ */
+exports.PluginDeployGeneratedSchema = zod_1.z.object({
+    /** Plugin name (lowercase, alphanumeric with hyphens). */
+    name: zod_1.z.string().min(1, 'Plugin name is required'),
+    /** Human-readable description. */
+    description: zod_1.z.string().optional(),
+    /** Semantic version (e.g. "1.0.0"). */
+    version: zod_1.z.string().min(1, 'Version is required'),
+    /** Plugin execution type. */
+    pluginType: zod_1.z.enum(['CodeBuildStep', 'ShellStep', 'ManualApprovalStep']).default('CodeBuildStep'),
+    /** AWS CodeBuild compute size. */
+    computeType: zod_1.z.enum(['SMALL', 'MEDIUM', 'LARGE', 'X2_LARGE']).default('MEDIUM'),
+    /** Keywords for categorization. */
+    keywords: zod_1.z.array(zod_1.z.string()).optional().default([]),
+    /** Primary output directory path. */
+    primaryOutputDirectory: zod_1.z.string().nullable().optional(),
+    /** Commands to install dependencies. */
+    installCommands: zod_1.z.array(zod_1.z.string()).optional().default([]),
+    /** Build/execution commands. */
+    commands: zod_1.z.array(zod_1.z.string()).min(1, 'At least one build command is required'),
+    /** Environment variables. */
+    env: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
+    /** Docker build arguments passed via --build-arg at image build time. */
+    buildArgs: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
+    /** Complete Dockerfile content for the build environment. */
+    dockerfile: zod_1.z.string().min(1, 'Dockerfile content is required'),
+    /** Access visibility. */
+    accessModifier: common_schemas_1.AccessModifierSchema.default('private'),
+});
+// AI Generate From URL Request
+/**
+ * Schema for POST /pipelines/generate/from-url/stream request body.
+ * Validates Git URL + AI provider configuration for repo-based pipeline generation.
+ */
+exports.AIGenerateFromUrlBodySchema = zod_1.z.object({
+    /** Git repository URL (HTTPS, SSH, or git@ format). */
+    gitUrl: zod_1.z.string().min(1, 'A Git repository URL is required').max(500, 'URL must be 500 characters or fewer'),
+    /** AI provider identifier (e.g. "anthropic", "openai", "google"). */
+    provider: zod_1.z.string().min(1, 'A provider is required'),
+    /** AI model identifier (e.g. "claude-sonnet-4-20250514", "gpt-4o"). */
+    model: zod_1.z.string().min(1, 'A model is required'),
+    /** Optional custom API key to override the server config. */
+    apiKey: zod_1.z.string().min(1).optional(),
+    /** Optional authentication token for accessing private repositories. */
+    repoToken: zod_1.z.string().min(1).optional(),
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ai-schemas.js","sourceRoot":"","sources":["../../src/validation/ai-schemas.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { z } from 'zod';\nimport { AccessModifierSchema } from './common-schemas';\n\nconst MAX_PROMPT_LENGTH = parseInt(process.env.MAX_PROMPT_LENGTH || '5000', 10);\n\n// AI Generation Request\n\n/**\n * Schema for AI generation request body.\n * Used by both POST /pipelines/generate and POST /plugins/generate.\n */\nexport const AIGenerateBodySchema = z.object({\n  /** Natural language description of what to generate. */\n  prompt: z\n    .string()\n    .min(1, 'A prompt with a natural language description is required')\n    .max(MAX_PROMPT_LENGTH, `Prompt must be ${MAX_PROMPT_LENGTH} characters or fewer`),\n\n  /** AI provider identifier (e.g. \"anthropic\", \"openai\", \"google\"). */\n  provider: z.string().min(1, 'A provider is required (e.g., \"anthropic\", \"openai\", \"google\")'),\n\n  /** AI model identifier (e.g. \"claude-sonnet-4-20250514\", \"gpt-4o\"). */\n  model: z.string().min(1, 'A model is required (e.g., \"claude-sonnet-4-20250514\", \"gpt-4o\")'),\n\n  /** Optional custom API key to override the server/org key for this request. */\n  apiKey: z.string().min(1).optional(),\n\n  /** Previous pipeline config for iterative refinement. */\n  previousConfig: z.record(z.string(), z.unknown()).optional(),\n\n  /** Fallback AI providers if primary fails (e.g., [\"openai\", \"google\"]). */\n  fallbackProviders: z.array(z.string()).optional(),\n});\n\n/** Validated type for AI generation request body. */\nexport type ValidatedAIGenerateBody = z.infer<typeof AIGenerateBodySchema>;\n\n// Plugin Deploy-Generated Request\n\n/**\n * Schema for POST /plugins/deploy-generated request body.\n * Validates the AI-generated plugin configuration before Docker build.\n */\nexport const PluginDeployGeneratedSchema = z.object({\n  /** Plugin name (lowercase, alphanumeric with hyphens). */\n  name: z.string().min(1, 'Plugin name is required'),\n\n  /** Human-readable description. */\n  description: z.string().optional(),\n\n  /** Semantic version (e.g. \"1.0.0\"). */\n  version: z.string().min(1, 'Version is required'),\n\n  /** Plugin execution type. */\n  pluginType: z.enum(['CodeBuildStep', 'ShellStep', 'ManualApprovalStep']).default('CodeBuildStep'),\n\n  /** AWS CodeBuild compute size. */\n  computeType: z.enum(['SMALL', 'MEDIUM', 'LARGE', 'X2_LARGE']).default('MEDIUM'),\n\n  /** Keywords for categorization. */\n  keywords: z.array(z.string()).optional().default([]),\n\n  /** Primary output directory path. */\n  primaryOutputDirectory: z.string().nullable().optional(),\n\n  /** Commands to install dependencies. */\n  installCommands: z.array(z.string()).optional().default([]),\n\n  /** Build/execution commands. */\n  commands: z.array(z.string()).min(1, 'At least one build command is required'),\n\n  /** Environment variables. */\n  env: z.record(z.string(), z.string()).optional(),\n\n  /** Docker build arguments passed via --build-arg at image build time. */\n  buildArgs: z.record(z.string(), z.string()).optional(),\n\n  /** Complete Dockerfile content for the build environment. */\n  dockerfile: z.string().min(1, 'Dockerfile content is required'),\n\n  /** Access visibility. */\n  accessModifier: AccessModifierSchema.default('private'),\n});\n\n/** Validated type for plugin deploy-generated request body. */\nexport type ValidatedPluginDeployGenerated = z.infer<typeof PluginDeployGeneratedSchema>;\n\n// AI Generate From URL Request\n\n/**\n * Schema for POST /pipelines/generate/from-url/stream request body.\n * Validates Git URL + AI provider configuration for repo-based pipeline generation.\n */\nexport const AIGenerateFromUrlBodySchema = z.object({\n  /** Git repository URL (HTTPS, SSH, or git@ format). */\n  gitUrl: z.string().min(1, 'A Git repository URL is required').max(500, 'URL must be 500 characters or fewer'),\n\n  /** AI provider identifier (e.g. \"anthropic\", \"openai\", \"google\"). */\n  provider: z.string().min(1, 'A provider is required'),\n\n  /** AI model identifier (e.g. \"claude-sonnet-4-20250514\", \"gpt-4o\"). */\n  model: z.string().min(1, 'A model is required'),\n\n  /** Optional custom API key to override the server config. */\n  apiKey: z.string().min(1).optional(),\n\n  /** Optional authentication token for accessing private repositories. */\n  repoToken: z.string().min(1).optional(),\n});\n\n/** Validated type for AI generate-from-URL request body. */\nexport type ValidatedAIGenerateFromUrlBody = z.infer<typeof AIGenerateFromUrlBodySchema>;\n"]}

package/lib/validation/common-schemas.d.ts

@@ -0,0 +1,72 @@
+import '../openapi/extend-zod';
+import { z } from 'zod';
+/**
+ * Access modifier schema
+ * Defines visibility of resources (public or private)
+ */
+export declare const AccessModifierSchema: z.ZodEnum<{
+    public: "public";
+    private: "private";
+}>;
+/**
+ * Sort order schema
+ */
+export declare const SortOrderSchema: z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+}>;
+/**
+ * Pagination parameters schema
+ */
+export declare const MAX_PAGE_LIMIT: number;
+export declare const PaginationSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    sortBy: z.ZodOptional<z.ZodString>;
+    sortOrder: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+}, z.core.$strip>;
+/**
+ * Boolean query parameter schema
+ * Handles string "true"/"false" and boolean values
+ */
+export declare const BooleanQuerySchema: z.ZodUnion<readonly [z.ZodBoolean, z.ZodPipe<z.ZodEnum<{
+    true: "true";
+    false: "false";
+}>, z.ZodTransform<boolean, "true" | "false">>, z.ZodPipe<z.ZodString, z.ZodTransform<boolean, string>>]>;
+/**
+ * UUID schema with validation
+ */
+export declare const UUIDSchema: z.ZodString;
+/**
+ * Optional UUID schema (for partial UUIDs or prefixes)
+ */
+export declare const UUIDPrefixSchema: z.ZodString;
+/**
+ * Base filter schema for entities with common fields
+ */
+export declare const BaseFilterSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodString]>>;
+    accessModifier: z.ZodOptional<z.ZodEnum<{
+        public: "public";
+        private: "private";
+    }>>;
+    isActive: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodPipe<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>, z.ZodTransform<boolean, "true" | "false">>, z.ZodPipe<z.ZodString, z.ZodTransform<boolean, string>>]>>;
+    isDefault: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodPipe<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>, z.ZodTransform<boolean, "true" | "false">>, z.ZodPipe<z.ZodString, z.ZodTransform<boolean, string>>]>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript types from schemas
+ * Note: Prefixed with "Validated" to avoid conflicts with existing type definitions
+ */
+export type ValidatedAccessModifier = z.infer<typeof AccessModifierSchema>;
+export type ValidatedSortOrder = z.infer<typeof SortOrderSchema>;
+export type ValidatedPaginationParams = z.infer<typeof PaginationSchema>;
+export type ValidatedBaseFilter = z.infer<typeof BaseFilterSchema>;

package/lib/validation/common-schemas.js

@@ -0,0 +1,58 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseFilterSchema = exports.UUIDPrefixSchema = exports.UUIDSchema = exports.BooleanQuerySchema = exports.PaginationSchema = exports.MAX_PAGE_LIMIT = exports.SortOrderSchema = exports.AccessModifierSchema = void 0;
+// Must run before any z.* schema creation — Zod 4 requires eager extension
+require("../openapi/extend-zod");
+const zod_1 = require("zod");
+/**
+ * Access modifier schema
+ * Defines visibility of resources (public or private)
+ */
+exports.AccessModifierSchema = zod_1.z.enum(['public', 'private']);
+/**
+ * Sort order schema
+ */
+exports.SortOrderSchema = zod_1.z.enum(['asc', 'desc']);
+/**
+ * Pagination parameters schema
+ */
+exports.MAX_PAGE_LIMIT = parseInt(process.env.MAX_PAGE_LIMIT || '1000', 10);
+exports.PaginationSchema = zod_1.z.object({
+    limit: zod_1.z.coerce.number().int().min(1).max(exports.MAX_PAGE_LIMIT).optional(),
+    offset: zod_1.z.coerce.number().int().min(0).optional(),
+    sortBy: zod_1.z.string().optional(),
+    sortOrder: exports.SortOrderSchema.optional(),
+});
+/**
+ * Boolean query parameter schema
+ * Handles string "true"/"false" and boolean values
+ */
+exports.BooleanQuerySchema = zod_1.z.union([
+    zod_1.z.boolean(),
+    zod_1.z.enum(['true', 'false']).transform(val => val === 'true'),
+    zod_1.z.string().transform(val => val === 'true'),
+]);
+/**
+ * UUID schema with validation
+ */
+exports.UUIDSchema = zod_1.z.string().uuid({
+    message: 'Invalid UUID format',
+});
+/**
+ * Optional UUID schema (for partial UUIDs or prefixes)
+ */
+exports.UUIDPrefixSchema = zod_1.z.string().regex(/^[0-9a-f-]+$/i, {
+    message: 'Invalid UUID prefix format',
+});
+/**
+ * Base filter schema for entities with common fields
+ */
+exports.BaseFilterSchema = zod_1.z.object({
+    id: zod_1.z.union([exports.UUIDSchema, zod_1.z.array(exports.UUIDSchema), exports.UUIDPrefixSchema]).optional(),
+    accessModifier: exports.AccessModifierSchema.optional(),
+    isActive: exports.BooleanQuerySchema.optional(),
+    isDefault: exports.BooleanQuerySchema.optional(),
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/validation/index.d.ts

@@ -0,0 +1,6 @@
+export * from './common-schemas';
+export * from './pipeline-schemas';
+export * from './plugin-schemas';
+export * from './message-schemas';
+export * from './ai-schemas';
+export * from './middleware';

package/lib/validation/index.js

@@ -0,0 +1,25 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./common-schemas"), exports);
+__exportStar(require("./pipeline-schemas"), exports);
+__exportStar(require("./plugin-schemas"), exports);
+__exportStar(require("./message-schemas"), exports);
+__exportStar(require("./ai-schemas"), exports);
+__exportStar(require("./middleware"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdmFsaWRhdGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsK0NBQStDO0FBQy9DLHNDQUFzQzs7Ozs7Ozs7Ozs7Ozs7OztBQUV0QyxtREFBaUM7QUFDakMscURBQW1DO0FBQ25DLG1EQUFpQztBQUNqQyxvREFBa0M7QUFDbEMsK0NBQTZCO0FBQzdCLCtDQUE2QiIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG5leHBvcnQgKiBmcm9tICcuL2NvbW1vbi1zY2hlbWFzJztcbmV4cG9ydCAqIGZyb20gJy4vcGlwZWxpbmUtc2NoZW1hcyc7XG5leHBvcnQgKiBmcm9tICcuL3BsdWdpbi1zY2hlbWFzJztcbmV4cG9ydCAqIGZyb20gJy4vbWVzc2FnZS1zY2hlbWFzJztcbmV4cG9ydCAqIGZyb20gJy4vYWktc2NoZW1hcyc7XG5leHBvcnQgKiBmcm9tICcuL21pZGRsZXdhcmUnO1xuIl19

package/lib/validation/message-schemas.d.ts

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+/**
+ * Message type schema
+ */
+export declare const MessageTypeSchema: z.ZodEnum<{
+    announcement: "announcement";
+    conversation: "conversation";
+}>;
+/**
+ * Message priority schema
+ */
+export declare const MessagePrioritySchema: z.ZodEnum<{
+    normal: "normal";
+    high: "high";
+    urgent: "urgent";
+}>;
+/**
+ * Message filter schema for query parameters
+ */
+export declare const MessageFilterSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodString]>>;
+    accessModifier: z.ZodOptional<z.ZodEnum<{
+        public: "public";
+        private: "private";
+    }>>;
+    isActive: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodPipe<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>, z.ZodTransform<boolean, "true" | "false">>, z.ZodPipe<z.ZodString, z.ZodTransform<boolean, string>>]>>;
+    isDefault: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodPipe<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>, z.ZodTransform<boolean, "true" | "false">>, z.ZodPipe<z.ZodString, z.ZodTransform<boolean, string>>]>>;
+    threadId: z.ZodOptional<z.ZodString>;
+    recipientOrgId: z.ZodOptional<z.ZodString>;
+    messageType: z.ZodOptional<z.ZodEnum<{
+        announcement: "announcement";
+        conversation: "conversation";
+    }>>;
+    isRead: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodPipe<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>, z.ZodTransform<boolean, "true" | "false">>, z.ZodPipe<z.ZodString, z.ZodTransform<boolean, string>>]>>;
+    priority: z.ZodOptional<z.ZodEnum<{
+        normal: "normal";
+        high: "high";
+        urgent: "urgent";
+    }>>;
+}, z.core.$strip>;
+/**
+ * Message creation schema
+ */
+export declare const MessageCreateSchema: z.ZodObject<{
+    recipientOrgId: z.ZodString;
+    messageType: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        announcement: "announcement";
+        conversation: "conversation";
+    }>>>;
+    subject: z.ZodString;
+    content: z.ZodString;
+    priority: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        normal: "normal";
+        high: "high";
+        urgent: "urgent";
+    }>>>;
+}, z.core.$strip>;
+/**
+ * Message reply schema
+ */
+export declare const MessageReplySchema: z.ZodObject<{
+    content: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript types from schemas
+ * Note: Prefixed with "Validated" to avoid conflicts with existing type definitions
+ */
+export type ValidatedMessageFilter = z.infer<typeof MessageFilterSchema>;
+export type ValidatedMessageCreate = z.infer<typeof MessageCreateSchema>;
+export type ValidatedMessageReply = z.infer<typeof MessageReplySchema>;

package/lib/validation/message-schemas.js

@@ -0,0 +1,42 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageReplySchema = exports.MessageCreateSchema = exports.MessageFilterSchema = exports.MessagePrioritySchema = exports.MessageTypeSchema = void 0;
+const zod_1 = require("zod");
+const common_schemas_1 = require("./common-schemas");
+/**
+ * Message type schema
+ */
+exports.MessageTypeSchema = zod_1.z.enum(['announcement', 'conversation']);
+/**
+ * Message priority schema
+ */
+exports.MessagePrioritySchema = zod_1.z.enum(['normal', 'high', 'urgent']);
+/**
+ * Message filter schema for query parameters
+ */
+exports.MessageFilterSchema = common_schemas_1.BaseFilterSchema.extend({
+    threadId: zod_1.z.string().uuid().optional(),
+    recipientOrgId: zod_1.z.string().min(1).optional(),
+    messageType: exports.MessageTypeSchema.optional(),
+    isRead: common_schemas_1.BooleanQuerySchema.optional(),
+    priority: exports.MessagePrioritySchema.optional(),
+});
+/**
+ * Message creation schema
+ */
+exports.MessageCreateSchema = zod_1.z.object({
+    recipientOrgId: zod_1.z.string().min(1, 'Recipient organization ID is required'),
+    messageType: exports.MessageTypeSchema.optional().default('conversation'),
+    subject: zod_1.z.string().min(1, 'Subject is required'),
+    content: zod_1.z.string().min(1, 'Content is required'),
+    priority: exports.MessagePrioritySchema.optional().default('normal'),
+});
+/**
+ * Message reply schema
+ */
+exports.MessageReplySchema = zod_1.z.object({
+    content: zod_1.z.string().min(1, 'Content is required'),
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/validation/middleware.d.ts

@@ -0,0 +1,60 @@
+import { Request } from 'express';
+import { ZodSchema, ZodError } from 'zod';
+/**
+ * Result type for validation operations
+ */
+export type ValidationResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+    zodError?: ZodError;
+};
+/**
+ * Validate arbitrary data against a Zod schema.
+ *
+ * This is the core validation function used by the Express-specific helpers
+ * (`validateBody`, `validateQuery`, `validateParams`). It can also be called
+ * directly when validating data that doesn't come from a request object.
+ *
+ * @param data - Data to validate
+ * @param schema - Zod schema for validation
+ * @returns Validation result with parsed data or error
+ *
+ * @example
+ * ```typescript
+ * const result = validate(someData, MySchema);
+ * if (!result.ok) {
+ *   return sendBadRequest(res, result.error);
+ * }
+ * const parsed = result.value;
+ * ```
+ */
+export declare function validate<T>(data: unknown, schema: ZodSchema<T>): ValidationResult<T>;
+/**
+ * Validate request query parameters with a Zod schema.
+ *
+ * @example
+ * ```typescript
+ * const result = validateQuery(req, PipelineFilterSchema);
+ * if (!result.ok) return sendBadRequest(res, result.error);
+ * const filter = result.value;
+ * ```
+ */
+export declare function validateQuery<T>(req: Request, schema: ZodSchema<T>): ValidationResult<T>;
+/**
+ * Validate request body with a Zod schema.
+ *
+ * @example
+ * ```typescript
+ * const result = validateBody(req, PipelineCreateSchema);
+ * if (!result.ok) return sendBadRequest(res, result.error);
+ * const data = result.value;
+ * ```
+ */
+export declare function validateBody<T>(req: Request, schema: ZodSchema<T>): ValidationResult<T>;
+/**
+ * Validate request path parameters with a Zod schema.
+ */
+export declare function validateParams<T>(req: Request, schema: ZodSchema<T>): ValidationResult<T>;

package/lib/validation/middleware.js

@@ -0,0 +1,77 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = validate;
+exports.validateQuery = validateQuery;
+exports.validateBody = validateBody;
+exports.validateParams = validateParams;
+const zod_1 = require("zod");
+/**
+ * Validate arbitrary data against a Zod schema.
+ *
+ * This is the core validation function used by the Express-specific helpers
+ * (`validateBody`, `validateQuery`, `validateParams`). It can also be called
+ * directly when validating data that doesn't come from a request object.
+ *
+ * @param data - Data to validate
+ * @param schema - Zod schema for validation
+ * @returns Validation result with parsed data or error
+ *
+ * @example
+ * ```typescript
+ * const result = validate(someData, MySchema);
+ * if (!result.ok) {
+ *   return sendBadRequest(res, result.error);
+ * }
+ * const parsed = result.value;
+ * ```
+ */
+function validate(data, schema) {
+    try {
+        return { ok: true, value: schema.parse(data) };
+    }
+    catch (error) {
+        if (error instanceof zod_1.ZodError) {
+            const firstIssue = error.issues[0];
+            const message = firstIssue
+                ? `${firstIssue.path.join('.')}: ${firstIssue.message}`
+                : 'Validation failed';
+            return { ok: false, error: message, zodError: error };
+        }
+        return { ok: false, error: 'Validation failed' };
+    }
+}
+/**
+ * Validate request query parameters with a Zod schema.
+ *
+ * @example
+ * ```typescript
+ * const result = validateQuery(req, PipelineFilterSchema);
+ * if (!result.ok) return sendBadRequest(res, result.error);
+ * const filter = result.value;
+ * ```
+ */
+function validateQuery(req, schema) {
+    return validate(req.query, schema);
+}
+/**
+ * Validate request body with a Zod schema.
+ *
+ * @example
+ * ```typescript
+ * const result = validateBody(req, PipelineCreateSchema);
+ * if (!result.ok) return sendBadRequest(res, result.error);
+ * const data = result.value;
+ * ```
+ */
+function validateBody(req, schema) {
+    return validate(req.body, schema);
+}
+/**
+ * Validate request path parameters with a Zod schema.
+ */
+function validateParams(req, schema) {
+    return validate(req.params, schema);
+}
+//# sourceMappingURL=data:application/json;base64,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