@pipeline-builder/api-core 0.0.1

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

@@ -0,0 +1,160 @@
+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<{
+    high: "high";
+    normal: "normal";
+    urgent: "urgent";
+}>;
+/**
+ * Channel/inbox-bucket schema. Open-ended string up to 50 chars so we
+ * can add new channels (support, help, billing, …) without a schema
+ * migration. Constrained to a-z/0-9/dash/underscore for URL safety and
+ * to keep filter conditions trivially indexable.
+ */
+export declare const MessageChannelSchema: z.ZodString;
+/**
+ * Message filter schema for query parameters.
+ *
+ * Convention for `threadId`:
+ * - Omitted (undefined): no filter applied — returns messages regardless of thread.
+ * - `'root'` or `null`: filter for root messages only (translated to `threadId IS NULL`
+ *   by the route layer / query builder). The string sentinel `'root'` is the
+ *   wire form, since URL query params can't carry a true `null`.
+ * - A UUID: filter for messages in that specific thread.
+ *
+ * `isRead` is honored by `buildMessageConditions` in pipeline-data via a
+ * `jsonb_exists(read_by, $orgId)` check on `messages.read_by` for the requesting
+ * org (the function form, not the `?` operator, to avoid param-binding clashes).
+ */
+export declare const MessageFilterSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodString]>>;
+    visibility: z.ZodOptional<z.ZodEnum<{
+        org: "org";
+        private: "private";
+        public: "public";
+    }>>;
+    isActive: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodPipe<z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>, z.ZodTransform<boolean, "false" | "true">>, z.ZodPipe<z.ZodString, z.ZodTransform<boolean, string>>]>>;
+    isDefault: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodPipe<z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>, z.ZodTransform<boolean, "false" | "true">>, z.ZodPipe<z.ZodString, z.ZodTransform<boolean, string>>]>>;
+    ownerId: z.ZodOptional<z.ZodString>;
+    lifecycle: z.ZodOptional<z.ZodEnum<{
+        deprecated: "deprecated";
+        experimental: "experimental";
+        production: "production";
+    }>>;
+    threadId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"root">, z.ZodNull]>>;
+    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<{
+        false: "false";
+        true: "true";
+    }>, z.ZodTransform<boolean, "false" | "true">>, z.ZodPipe<z.ZodString, z.ZodTransform<boolean, string>>]>>;
+    priority: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        normal: "normal";
+        urgent: "urgent";
+    }>>;
+    channel: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Upper bounds on free-text message fields. Without these an unbounded
+ * subject/content (e.g. a 1MB announcement) is persisted AND SSE-broadcast to
+ * every org. `subject` matches the `varchar(500)` DB column so we reject rather
+ * than silently truncate; `content` is a `text` column with no DB bound, so we
+ * cap it at a sane 32 KiB at the app layer.
+ */
+export declare const MESSAGE_SUBJECT_MAX = 500;
+export declare const MESSAGE_CONTENT_MAX = 32768;
+/** Max attachments linkable to a single message/reply. */
+export declare const MESSAGE_MAX_ATTACHMENTS = 5;
+/**
+ * Max attachment size (MiB) — env-overridable. The upload route enforces this
+ * (multer `fileSize`); kept here so the bound lives with the other message
+ * limits rather than only inline in the route.
+ */
+export declare const MESSAGE_ATTACHMENT_MAX_MB: number;
+export declare const MESSAGE_ATTACHMENT_MAX_BYTES: number;
+/**
+ * Allow-list of attachment MIME types — common images + documents + zip/yaml/json.
+ * Deliberately excludes executables/scripts/HTML/SVG (stored-XSS / drive-by).
+ * zip is a download container (doesn't render in-browser); yaml/json are plain
+ * text — none carry the drive-by risk of the excluded types. Extend here.
+ */
+export declare const MESSAGE_ATTACHMENT_ALLOWED_MIME: ReadonlySet<string>;
+/**
+ * Safe filename extensions. Browsers frequently send `application/octet-stream`
+ * for archives + config files (.tar/.gz/.tgz/.yaml/…) because they have no
+ * reliable registered MIME type, so the MIME allow-list alone rejects them. These
+ * extensions are accepted as a fallback ONLY when the reported MIME is that
+ * generic type (see isAllowedAttachmentType) — so a known render/execute MIME
+ * (image/svg+xml, text/html, …) is never rescued by a spoofed extension. Still
+ * excludes .html/.svg/.js/.exe/… (never listed here).
+ */
+export declare const MESSAGE_ATTACHMENT_ALLOWED_EXT: ReadonlySet<string>;
+/**
+ * True if an attachment is accepted. Accepts by MIME allow-list, OR — when the
+ * browser reports the generic `application/octet-stream` (unknown binary) — by a
+ * safe filename extension. octet-stream is served as a download (never rendered),
+ * so the extension fallback can't turn into a stored-XSS vector.
+ */
+export declare function isAllowedAttachmentType(mimetype: string, filename: string): boolean;
+/** Attachment metadata DTO returned to clients (never exposes the storage key). */
+export interface MessageAttachmentDTO {
+    id: string;
+    filename: string;
+    contentType: string;
+    sizeBytes: number;
+}
+/**
+ * Message creation schema
+ */
+export declare const MessageCreateSchema: z.ZodObject<{
+    recipientOrgId: z.ZodString;
+    recipientUserId: z.ZodOptional<z.ZodString>;
+    messageType: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        announcement: "announcement";
+        conversation: "conversation";
+    }>>>;
+    channel: z.ZodOptional<z.ZodString>;
+    subject: z.ZodString;
+    content: z.ZodString;
+    priority: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        normal: "normal";
+        urgent: "urgent";
+    }>>>;
+    attachmentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Message reply schema
+ */
+export declare const MessageReplySchema: z.ZodObject<{
+    content: z.ZodString;
+    attachmentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Edit an already-sent message's CONTENT (author-only, enforced server-side).
+ * Only the body is editable — subject/recipient/type/attachments are immutable
+ * after send (changing them would rewrite the conversation's routing/meaning).
+ */
+export declare const MessageEditSchema: z.ZodObject<{
+    content: z.ZodString;
+}, z.core.$strip>;

package/lib/validation/message-schemas.js

@@ -0,0 +1,156 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { z } from 'zod';
+import { BaseFilterSchema, BooleanQuerySchema } from './common-schemas.js';
+/**
+ * Message type schema
+ */
+export const MessageTypeSchema = z.enum(['announcement', 'conversation']);
+/**
+ * Message priority schema
+ */
+export const MessagePrioritySchema = z.enum(['normal', 'high', 'urgent']);
+/**
+ * Channel/inbox-bucket schema. Open-ended string up to 50 chars so we
+ * can add new channels (support, help, billing, …) without a schema
+ * migration. Constrained to a-z/0-9/dash/underscore for URL safety and
+ * to keep filter conditions trivially indexable.
+ */
+export const MessageChannelSchema = z.string().min(1).max(50).regex(/^[a-z0-9_-]+$/);
+/**
+ * Message filter schema for query parameters.
+ *
+ * Convention for `threadId`:
+ * - Omitted (undefined): no filter applied — returns messages regardless of thread.
+ * - `'root'` or `null`: filter for root messages only (translated to `threadId IS NULL`
+ *   by the route layer / query builder). The string sentinel `'root'` is the
+ *   wire form, since URL query params can't carry a true `null`.
+ * - A UUID: filter for messages in that specific thread.
+ *
+ * `isRead` is honored by `buildMessageConditions` in pipeline-data via a
+ * `jsonb_exists(read_by, $orgId)` check on `messages.read_by` for the requesting
+ * org (the function form, not the `?` operator, to avoid param-binding clashes).
+ */
+export const MessageFilterSchema = BaseFilterSchema.extend({
+    threadId: z.union([z.string().uuid(), z.literal('root'), z.null()]).optional(),
+    recipientOrgId: z.string().min(1).optional(),
+    messageType: MessageTypeSchema.optional(),
+    isRead: BooleanQuerySchema.optional(),
+    priority: MessagePrioritySchema.optional(),
+    channel: MessageChannelSchema.optional(),
+    // Free-text inbox search over subject/content. Bounded so a pathological term
+    // can't blow up the LIKE; the query builder escapes wildcards + ignores blanks.
+    search: z.string().trim().min(1).max(200).optional(),
+});
+/**
+ * Upper bounds on free-text message fields. Without these an unbounded
+ * subject/content (e.g. a 1MB announcement) is persisted AND SSE-broadcast to
+ * every org. `subject` matches the `varchar(500)` DB column so we reject rather
+ * than silently truncate; `content` is a `text` column with no DB bound, so we
+ * cap it at a sane 32 KiB at the app layer.
+ */
+export const MESSAGE_SUBJECT_MAX = 500;
+export const MESSAGE_CONTENT_MAX = 32768;
+/** Max attachments linkable to a single message/reply. */
+export const MESSAGE_MAX_ATTACHMENTS = 5;
+/**
+ * Max attachment size (MiB) — env-overridable. The upload route enforces this
+ * (multer `fileSize`); kept here so the bound lives with the other message
+ * limits rather than only inline in the route.
+ */
+export const MESSAGE_ATTACHMENT_MAX_MB = Math.max(1, Number.parseInt(process.env.MESSAGE_ATTACHMENT_MAX_MB ?? '10', 10) || 10);
+export const MESSAGE_ATTACHMENT_MAX_BYTES = MESSAGE_ATTACHMENT_MAX_MB * 1024 * 1024;
+/**
+ * Allow-list of attachment MIME types — common images + documents + zip/yaml/json.
+ * Deliberately excludes executables/scripts/HTML/SVG (stored-XSS / drive-by).
+ * zip is a download container (doesn't render in-browser); yaml/json are plain
+ * text — none carry the drive-by risk of the excluded types. Extend here.
+ */
+export const MESSAGE_ATTACHMENT_ALLOWED_MIME = new Set([
+    'image/png', 'image/jpeg', 'image/gif', 'image/webp',
+    'application/pdf', 'text/plain', 'text/csv',
+    'application/msword',
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    'application/vnd.ms-excel',
+    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    // Archives (zip / gz / tar / tar.gz) — browsers report these variously by OS;
+    // cover the common variants. They download rather than render in-browser.
+    'application/zip', 'application/x-zip-compressed',
+    'application/gzip', 'application/x-gzip',
+    'application/x-tar', 'application/tar',
+    'application/x-compressed-tar',
+    // json (browsers may send application/json or text/json).
+    'application/json', 'text/json',
+    // yaml/yml — no single registered type; cover the common variants.
+    'application/x-yaml', 'application/yaml', 'text/yaml', 'text/x-yaml',
+]);
+/**
+ * Safe filename extensions. Browsers frequently send `application/octet-stream`
+ * for archives + config files (.tar/.gz/.tgz/.yaml/…) because they have no
+ * reliable registered MIME type, so the MIME allow-list alone rejects them. These
+ * extensions are accepted as a fallback ONLY when the reported MIME is that
+ * generic type (see isAllowedAttachmentType) — so a known render/execute MIME
+ * (image/svg+xml, text/html, …) is never rescued by a spoofed extension. Still
+ * excludes .html/.svg/.js/.exe/… (never listed here).
+ */
+export const MESSAGE_ATTACHMENT_ALLOWED_EXT = new Set([
+    '.png', '.jpg', '.jpeg', '.gif', '.webp',
+    '.pdf', '.txt', '.csv', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
+    '.zip', '.gz', '.tgz', '.tar', '.json', '.yaml', '.yml',
+]);
+/**
+ * True if an attachment is accepted. Accepts by MIME allow-list, OR — when the
+ * browser reports the generic `application/octet-stream` (unknown binary) — by a
+ * safe filename extension. octet-stream is served as a download (never rendered),
+ * so the extension fallback can't turn into a stored-XSS vector.
+ */
+export function isAllowedAttachmentType(mimetype, filename) {
+    if (MESSAGE_ATTACHMENT_ALLOWED_MIME.has(mimetype))
+        return true;
+    if (mimetype !== 'application/octet-stream')
+        return false;
+    const dot = (filename || '').lastIndexOf('.');
+    if (dot < 0)
+        return false;
+    return MESSAGE_ATTACHMENT_ALLOWED_EXT.has(filename.slice(dot).toLowerCase());
+}
+/**
+ * Attachment ids to link to a message. Each is the id returned by a prior
+ * POST /messages/attachments upload; the create route links only ids that belong
+ * to the caller (own org + uploader) and are still unattached.
+ */
+const AttachmentIdsSchema = z.array(z.string().uuid()).max(MESSAGE_MAX_ATTACHMENTS).optional();
+/**
+ * Message creation schema
+ */
+export const MessageCreateSchema = z.object({
+    recipientOrgId: z.string().min(1, 'Recipient organization ID is required'),
+    // Optional per-user targeting WITHIN recipientOrgId. When set, only this user
+    // sees the conversation (enforced in buildMessageConditions). Conversation-only
+    // and requires a concrete recipient org — the route rejects it on announcements
+    // and '*' broadcasts. Bounded to the recipient_user_id column width.
+    recipientUserId: z.string().min(1).max(255).optional(),
+    messageType: MessageTypeSchema.optional().default('conversation'),
+    channel: MessageChannelSchema.optional(),
+    subject: z.string().min(1, 'Subject is required').max(MESSAGE_SUBJECT_MAX, `Subject must be at most ${MESSAGE_SUBJECT_MAX} characters`),
+    content: z.string().min(1, 'Content is required').max(MESSAGE_CONTENT_MAX, `Content must be at most ${MESSAGE_CONTENT_MAX} characters`),
+    priority: MessagePrioritySchema.optional().default('normal'),
+    attachmentIds: AttachmentIdsSchema,
+});
+/**
+ * Message reply schema
+ */
+export const MessageReplySchema = z.object({
+    content: z.string().min(1, 'Content is required').max(MESSAGE_CONTENT_MAX, `Content must be at most ${MESSAGE_CONTENT_MAX} characters`),
+    attachmentIds: AttachmentIdsSchema,
+});
+/**
+ * Edit an already-sent message's CONTENT (author-only, enforced server-side).
+ * Only the body is editable — subject/recipient/type/attachments are immutable
+ * after send (changing them would rewrite the conversation's routing/meaning).
+ */
+export const MessageEditSchema = z.object({
+    content: z.string().min(1, 'Content is required').max(MESSAGE_CONTENT_MAX, `Content must be at most ${MESSAGE_CONTENT_MAX} characters`),
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"message-schemas.js","sourceRoot":"","sources":["../../src/validation/message-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 { BaseFilterSchema, BooleanQuerySchema } from './common-schemas.js';\n\n/**\n * Message type schema\n */\nexport const MessageTypeSchema = z.enum(['announcement', 'conversation']);\n\n/**\n * Message priority schema\n */\nexport const MessagePrioritySchema = z.enum(['normal', 'high', 'urgent']);\n\n/**\n * Channel/inbox-bucket schema. Open-ended string up to 50 chars so we\n * can add new channels (support, help, billing, …) without a schema\n * migration. Constrained to a-z/0-9/dash/underscore for URL safety and\n * to keep filter conditions trivially indexable.\n */\nexport const MessageChannelSchema = z.string().min(1).max(50).regex(/^[a-z0-9_-]+$/);\n\n/**\n * Message filter schema for query parameters.\n *\n * Convention for `threadId`:\n * - Omitted (undefined): no filter applied — returns messages regardless of thread.\n * - `'root'` or `null`: filter for root messages only (translated to `threadId IS NULL`\n *   by the route layer / query builder). The string sentinel `'root'` is the\n *   wire form, since URL query params can't carry a true `null`.\n * - A UUID: filter for messages in that specific thread.\n *\n * `isRead` is honored by `buildMessageConditions` in pipeline-data via a\n * `jsonb_exists(read_by, $orgId)` check on `messages.read_by` for the requesting\n * org (the function form, not the `?` operator, to avoid param-binding clashes).\n */\nexport const MessageFilterSchema = BaseFilterSchema.extend({\n  threadId: z.union([z.string().uuid(), z.literal('root'), z.null()]).optional(),\n  recipientOrgId: z.string().min(1).optional(),\n  messageType: MessageTypeSchema.optional(),\n  isRead: BooleanQuerySchema.optional(),\n  priority: MessagePrioritySchema.optional(),\n  channel: MessageChannelSchema.optional(),\n  // Free-text inbox search over subject/content. Bounded so a pathological term\n  // can't blow up the LIKE; the query builder escapes wildcards + ignores blanks.\n  search: z.string().trim().min(1).max(200).optional(),\n});\n\n/**\n * Upper bounds on free-text message fields. Without these an unbounded\n * subject/content (e.g. a 1MB announcement) is persisted AND SSE-broadcast to\n * every org. `subject` matches the `varchar(500)` DB column so we reject rather\n * than silently truncate; `content` is a `text` column with no DB bound, so we\n * cap it at a sane 32 KiB at the app layer.\n */\nexport const MESSAGE_SUBJECT_MAX = 500;\nexport const MESSAGE_CONTENT_MAX = 32768;\n\n/** Max attachments linkable to a single message/reply. */\nexport const MESSAGE_MAX_ATTACHMENTS = 5;\n\n/**\n * Max attachment size (MiB) — env-overridable. The upload route enforces this\n * (multer `fileSize`); kept here so the bound lives with the other message\n * limits rather than only inline in the route.\n */\nexport const MESSAGE_ATTACHMENT_MAX_MB = Math.max(1, Number.parseInt(process.env.MESSAGE_ATTACHMENT_MAX_MB ?? '10', 10) || 10);\nexport const MESSAGE_ATTACHMENT_MAX_BYTES = MESSAGE_ATTACHMENT_MAX_MB * 1024 * 1024;\n\n/**\n * Allow-list of attachment MIME types — common images + documents + zip/yaml/json.\n * Deliberately excludes executables/scripts/HTML/SVG (stored-XSS / drive-by).\n * zip is a download container (doesn't render in-browser); yaml/json are plain\n * text — none carry the drive-by risk of the excluded types. Extend here.\n */\nexport const MESSAGE_ATTACHMENT_ALLOWED_MIME: ReadonlySet<string> = new Set([\n  'image/png', 'image/jpeg', 'image/gif', 'image/webp',\n  'application/pdf', 'text/plain', 'text/csv',\n  'application/msword',\n  'application/vnd.openxmlformats-officedocument.wordprocessingml.document',\n  'application/vnd.ms-excel',\n  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',\n  'application/vnd.openxmlformats-officedocument.presentationml.presentation',\n  // Archives (zip / gz / tar / tar.gz) — browsers report these variously by OS;\n  // cover the common variants. They download rather than render in-browser.\n  'application/zip', 'application/x-zip-compressed',\n  'application/gzip', 'application/x-gzip',\n  'application/x-tar', 'application/tar',\n  'application/x-compressed-tar',\n  // json (browsers may send application/json or text/json).\n  'application/json', 'text/json',\n  // yaml/yml — no single registered type; cover the common variants.\n  'application/x-yaml', 'application/yaml', 'text/yaml', 'text/x-yaml',\n]);\n\n/**\n * Safe filename extensions. Browsers frequently send `application/octet-stream`\n * for archives + config files (.tar/.gz/.tgz/.yaml/…) because they have no\n * reliable registered MIME type, so the MIME allow-list alone rejects them. These\n * extensions are accepted as a fallback ONLY when the reported MIME is that\n * generic type (see isAllowedAttachmentType) — so a known render/execute MIME\n * (image/svg+xml, text/html, …) is never rescued by a spoofed extension. Still\n * excludes .html/.svg/.js/.exe/… (never listed here).\n */\nexport const MESSAGE_ATTACHMENT_ALLOWED_EXT: ReadonlySet<string> = new Set([\n  '.png', '.jpg', '.jpeg', '.gif', '.webp',\n  '.pdf', '.txt', '.csv', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',\n  '.zip', '.gz', '.tgz', '.tar', '.json', '.yaml', '.yml',\n]);\n\n/**\n * True if an attachment is accepted. Accepts by MIME allow-list, OR — when the\n * browser reports the generic `application/octet-stream` (unknown binary) — by a\n * safe filename extension. octet-stream is served as a download (never rendered),\n * so the extension fallback can't turn into a stored-XSS vector.\n */\nexport function isAllowedAttachmentType(mimetype: string, filename: string): boolean {\n  if (MESSAGE_ATTACHMENT_ALLOWED_MIME.has(mimetype)) return true;\n  if (mimetype !== 'application/octet-stream') return false;\n  const dot = (filename || '').lastIndexOf('.');\n  if (dot < 0) return false;\n  return MESSAGE_ATTACHMENT_ALLOWED_EXT.has(filename.slice(dot).toLowerCase());\n}\n\n/** Attachment metadata DTO returned to clients (never exposes the storage key). */\nexport interface MessageAttachmentDTO {\n  id: string;\n  filename: string;\n  contentType: string;\n  sizeBytes: number;\n}\n\n/**\n * Attachment ids to link to a message. Each is the id returned by a prior\n * POST /messages/attachments upload; the create route links only ids that belong\n * to the caller (own org + uploader) and are still unattached.\n */\nconst AttachmentIdsSchema = z.array(z.string().uuid()).max(MESSAGE_MAX_ATTACHMENTS).optional();\n\n/**\n * Message creation schema\n */\nexport const MessageCreateSchema = z.object({\n  recipientOrgId: z.string().min(1, 'Recipient organization ID is required'),\n  // Optional per-user targeting WITHIN recipientOrgId. When set, only this user\n  // sees the conversation (enforced in buildMessageConditions). Conversation-only\n  // and requires a concrete recipient org — the route rejects it on announcements\n  // and '*' broadcasts. Bounded to the recipient_user_id column width.\n  recipientUserId: z.string().min(1).max(255).optional(),\n  messageType: MessageTypeSchema.optional().default('conversation'),\n  channel: MessageChannelSchema.optional(),\n  subject: z.string().min(1, 'Subject is required').max(MESSAGE_SUBJECT_MAX, `Subject must be at most ${MESSAGE_SUBJECT_MAX} characters`),\n  content: z.string().min(1, 'Content is required').max(MESSAGE_CONTENT_MAX, `Content must be at most ${MESSAGE_CONTENT_MAX} characters`),\n  priority: MessagePrioritySchema.optional().default('normal'),\n  attachmentIds: AttachmentIdsSchema,\n});\n\n/**\n * Message reply schema\n */\nexport const MessageReplySchema = z.object({\n  content: z.string().min(1, 'Content is required').max(MESSAGE_CONTENT_MAX, `Content must be at most ${MESSAGE_CONTENT_MAX} characters`),\n  attachmentIds: AttachmentIdsSchema,\n});\n\n/**\n * Edit an already-sent message's CONTENT (author-only, enforced server-side).\n * Only the body is editable — subject/recipient/type/attachments are immutable\n * after send (changing them would rewrite the conversation's routing/meaning).\n */\nexport const MessageEditSchema = z.object({\n  content: z.string().min(1, 'Content is required').max(MESSAGE_CONTENT_MAX, `Content must be at most ${MESSAGE_CONTENT_MAX} characters`),\n});\n"]}

package/lib/validation/middleware.d.ts

@@ -0,0 +1,72 @@
+import type { Request } from 'express';
+import { ZodError, type ZodSchema } from 'zod';
+/**
+ * Result type for validation operations.
+ *
+ * CANONICAL validation-result shape for the api-core public surface: a boolean-
+ * discriminated union (`if (!result.ok) …`). Use THIS for anything that parses
+ * against a Zod schema — `validate` / `validateBody` / `validateQuery`. The
+ * `ok` discriminant also carries the optional `zodError` for callers that want
+ * field-level detail.
+ *
+ * Note the deliberately-lighter sibling shape in `utils/params.ts`
+ * (`{ value } | { error }`, narrowed with `'error' in result`). That one is for
+ * simple inline request-parsing guards (`validateBulkArray`, `parseDateRange`,
+ * `parseReportInterval`) — NOT schema validation. The two are kept distinct on
+ * purpose: unifying `utils/params.ts` onto `{ ok }` would touch every
+ * `'error' in result` call site across the downstream services (pipeline,
+ * plugin, reporting, compliance, …) for no behavioural gain, so the convention
+ * is documented rather than force-migrated. Rule of thumb: Zod schema →
+ * `ValidationResult` (`ok`); ad-hoc parse guard → params.ts (`'error' in`).
+ */
+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`). 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>;

package/lib/validation/middleware.js

@@ -0,0 +1,65 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { ZodError } from 'zod';
+/**
+ * Validate arbitrary data against a Zod schema.
+ *
+ * This is the core validation function used by the Express-specific helpers
+ * (`validateBody`, `validateQuery`). 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 function validate(data, schema) {
+    try {
+        return { ok: true, value: schema.parse(data) };
+    }
+    catch (error) {
+        if (error instanceof 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;
+ * ```
+ */
+export 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;
+ * ```
+ */
+export function validateBody(req, schema) {
+    return validate(req.body, schema);
+}
+//# sourceMappingURL=data:application/json;base64,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