@pipeline-builder/api-core 0.0.1

package/lib/openapi/routes/quota-routes.js

@@ -0,0 +1,62 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { registry } from '../registry.js';
+const tags = ['Quotas'];
+const auth = [{ bearerAuth: [] }];
+export function registerQuotaRoutes() {
+    registry.registerPath({
+        method: 'get',
+        path: '/quotas',
+        summary: 'Get own quotas',
+        description: 'Get quota usage and limits for the current organization (from JWT).',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Organization quota details' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/quotas/all',
+        summary: 'Get all org quotas',
+        description: 'Get quotas for all organizations. System admin only.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'All organization quotas' }, 403: { description: 'Admin required' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/quotas/{orgId}',
+        summary: 'Get org quotas',
+        description: 'Get quota usage and limits for a specific organization.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Organization quota details' }, 404: { description: 'Organization not found' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/quotas/{orgId}/{quotaType}',
+        summary: 'Get specific quota',
+        description: 'Get a specific quota type for an organization.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Quota type details' } },
+    });
+    registry.registerPath({
+        method: 'put',
+        path: '/quotas/{orgId}',
+        summary: 'Update org quotas',
+        description: 'Update quota limits for an organization. System admin only.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Quotas updated' }, 403: { description: 'Admin required' } },
+    });
+    registry.registerPath({
+        method: 'post',
+        path: '/quotas/{orgId}/reset',
+        summary: 'Reset quota usage',
+        description: 'Reset usage counters for an organization. Admin only.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Quota usage reset' }, 403: { description: 'Admin required' } },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/openapi/schema-registry.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export declare const SuccessResponseSchema: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    statusCode: z.ZodNumber;
+    data: z.ZodOptional<z.ZodUnknown>;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ErrorResponseSchema: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    statusCode: z.ZodNumber;
+    message: z.ZodString;
+    code: z.ZodOptional<z.ZodString>;
+    details: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const PaginatedResponseSchema: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    statusCode: z.ZodNumber;
+    data: z.ZodArray<z.ZodUnknown>;
+    count: z.ZodNumber;
+    limit: z.ZodNumber;
+    offset: z.ZodNumber;
+    total: z.ZodOptional<z.ZodNumber>;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function registerSchemas(): void;

package/lib/openapi/schema-registry.js

@@ -0,0 +1,91 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { z } from 'zod';
+import { registry } from './registry.js';
+import { AIGenerateBodySchema, PluginDeployGeneratedSchema, } from '../validation/ai-schemas.js';
+import { VisibilitySchema, PaginationSchema, BaseFilterSchema, } from '../validation/common-schemas.js';
+import { MessageFilterSchema, MessageCreateSchema, MessageReplySchema, } from '../validation/message-schemas.js';
+import { PipelineFilterSchema, PipelineCreateSchema, PipelineUpdateSchema, } from '../validation/pipeline-schemas.js';
+import { PluginFilterSchema, PluginCreateSchema, PluginUpdateSchema, PluginUploadBodySchema, } from '../validation/plugin-schemas.js';
+// Response schemas (exported for type usage)
+export const SuccessResponseSchema = z.object({
+    success: z.literal(true),
+    statusCode: z.number(),
+    data: z.unknown().optional(),
+    message: z.string().optional(),
+});
+export const ErrorResponseSchema = z.object({
+    success: z.literal(false),
+    statusCode: z.number(),
+    message: z.string(),
+    code: z.string().optional(),
+    details: z.unknown().optional(),
+});
+export const PaginatedResponseSchema = z.object({
+    success: z.literal(true),
+    statusCode: z.number(),
+    data: z.array(z.unknown()),
+    count: z.number(),
+    limit: z.number(),
+    offset: z.number(),
+    total: z.number().optional(),
+    message: z.string().optional(),
+});
+export function registerSchemas() {
+    // Common schemas
+    registry.register('Visibility', VisibilitySchema.openapi({
+        description: 'Sharing rung: "private" (author only), "org" (everyone in the owning organization), or "public" (the org, its teams, and — from the system org — every org)',
+        example: 'private',
+    }));
+    registry.register('PaginationParams', PaginationSchema.openapi({
+        description: 'Standard pagination and sorting parameters',
+    }));
+    registry.register('BaseFilter', BaseFilterSchema.openapi({
+        description: 'Common filter fields shared by all entity queries',
+    }));
+    // Pipeline schemas
+    registry.register('PipelineFilter', PipelineFilterSchema.openapi({
+        description: 'Query filters for listing pipelines',
+    }));
+    registry.register('PipelineCreate', PipelineCreateSchema.openapi({
+        description: 'Request body for creating a new pipeline',
+    }));
+    registry.register('PipelineUpdate', PipelineUpdateSchema.openapi({
+        description: 'Request body for updating an existing pipeline',
+    }));
+    // Plugin schemas
+    registry.register('PluginFilter', PluginFilterSchema.openapi({
+        description: 'Query filters for listing plugins',
+    }));
+    registry.register('PluginCreate', PluginCreateSchema.openapi({
+        description: 'Request body for creating a new plugin',
+    }));
+    registry.register('PluginUpdate', PluginUpdateSchema.openapi({
+        description: 'Request body for updating an existing plugin',
+    }));
+    registry.register('PluginUploadBody', PluginUploadBodySchema.openapi({
+        description: 'Metadata for plugin ZIP upload (multipart form-data)',
+    }));
+    // Message schemas
+    registry.register('MessageFilter', MessageFilterSchema.openapi({
+        description: 'Query filters for listing messages',
+    }));
+    registry.register('MessageCreate', MessageCreateSchema.openapi({
+        description: 'Request body for creating a new message or announcement',
+    }));
+    registry.register('MessageReply', MessageReplySchema.openapi({
+        description: 'Request body for replying to a message thread',
+    }));
+    // AI schemas
+    registry.register('AIGenerateBody', AIGenerateBodySchema.openapi({
+        description: 'Request body for AI-powered generation (pipeline or plugin)',
+    }));
+    registry.register('PluginDeployGenerated', PluginDeployGeneratedSchema.openapi({
+        description: 'Request body for deploying an AI-generated plugin',
+    }));
+    // Response schemas
+    registry.register('SuccessResponse', SuccessResponseSchema.openapi('SuccessResponse'));
+    registry.register('ErrorResponse', ErrorResponseSchema.openapi('ErrorResponse'));
+    registry.register('PaginatedResponse', PaginatedResponseSchema.openapi('PaginatedResponse'));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema-registry.js","sourceRoot":"","sources":["../../src/openapi/schema-registry.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';\n\nimport { registry } from './registry.js';\nimport {\n  AIGenerateBodySchema,\n  PluginDeployGeneratedSchema,\n} from '../validation/ai-schemas.js';\nimport {\n  VisibilitySchema,\n  PaginationSchema,\n  BaseFilterSchema,\n} from '../validation/common-schemas.js';\nimport {\n  MessageFilterSchema,\n  MessageCreateSchema,\n  MessageReplySchema,\n} from '../validation/message-schemas.js';\nimport {\n  PipelineFilterSchema,\n  PipelineCreateSchema,\n  PipelineUpdateSchema,\n} from '../validation/pipeline-schemas.js';\nimport {\n  PluginFilterSchema,\n  PluginCreateSchema,\n  PluginUpdateSchema,\n  PluginUploadBodySchema,\n} from '../validation/plugin-schemas.js';\n\n// Response schemas (exported for type usage)\nexport const SuccessResponseSchema = z.object({\n  success: z.literal(true),\n  statusCode: z.number(),\n  data: z.unknown().optional(),\n  message: z.string().optional(),\n});\n\nexport const ErrorResponseSchema = z.object({\n  success: z.literal(false),\n  statusCode: z.number(),\n  message: z.string(),\n  code: z.string().optional(),\n  details: z.unknown().optional(),\n});\n\nexport const PaginatedResponseSchema = z.object({\n  success: z.literal(true),\n  statusCode: z.number(),\n  data: z.array(z.unknown()),\n  count: z.number(),\n  limit: z.number(),\n  offset: z.number(),\n  total: z.number().optional(),\n  message: z.string().optional(),\n});\n\nexport function registerSchemas(): void {\n  // Common schemas\n  registry.register('Visibility', VisibilitySchema.openapi({\n    description: 'Sharing rung: \"private\" (author only), \"org\" (everyone in the owning organization), or \"public\" (the org, its teams, and — from the system org — every org)',\n    example: 'private',\n  }));\n\n  registry.register('PaginationParams', PaginationSchema.openapi({\n    description: 'Standard pagination and sorting parameters',\n  }));\n\n  registry.register('BaseFilter', BaseFilterSchema.openapi({\n    description: 'Common filter fields shared by all entity queries',\n  }));\n\n  // Pipeline schemas\n  registry.register('PipelineFilter', PipelineFilterSchema.openapi({\n    description: 'Query filters for listing pipelines',\n  }));\n\n  registry.register('PipelineCreate', PipelineCreateSchema.openapi({\n    description: 'Request body for creating a new pipeline',\n  }));\n\n  registry.register('PipelineUpdate', PipelineUpdateSchema.openapi({\n    description: 'Request body for updating an existing pipeline',\n  }));\n\n  // Plugin schemas\n  registry.register('PluginFilter', PluginFilterSchema.openapi({\n    description: 'Query filters for listing plugins',\n  }));\n\n  registry.register('PluginCreate', PluginCreateSchema.openapi({\n    description: 'Request body for creating a new plugin',\n  }));\n\n  registry.register('PluginUpdate', PluginUpdateSchema.openapi({\n    description: 'Request body for updating an existing plugin',\n  }));\n\n  registry.register('PluginUploadBody', PluginUploadBodySchema.openapi({\n    description: 'Metadata for plugin ZIP upload (multipart form-data)',\n  }));\n\n  // Message schemas\n  registry.register('MessageFilter', MessageFilterSchema.openapi({\n    description: 'Query filters for listing messages',\n  }));\n\n  registry.register('MessageCreate', MessageCreateSchema.openapi({\n    description: 'Request body for creating a new message or announcement',\n  }));\n\n  registry.register('MessageReply', MessageReplySchema.openapi({\n    description: 'Request body for replying to a message thread',\n  }));\n\n  // AI schemas\n  registry.register('AIGenerateBody', AIGenerateBodySchema.openapi({\n    description: 'Request body for AI-powered generation (pipeline or plugin)',\n  }));\n\n  registry.register('PluginDeployGenerated', PluginDeployGeneratedSchema.openapi({\n    description: 'Request body for deploying an AI-generated plugin',\n  }));\n\n  // Response schemas\n  registry.register('SuccessResponse', SuccessResponseSchema.openapi('SuccessResponse'));\n  registry.register('ErrorResponse', ErrorResponseSchema.openapi('ErrorResponse'));\n  registry.register('PaginatedResponse', PaginatedResponseSchema.openapi('PaginatedResponse'));\n}\n"]}

package/lib/routes/health.d.ts

@@ -0,0 +1,41 @@
+import { Router, type Request, type Response } from 'express';
+/**
+ * Options for health check endpoint.
+ */
+export interface HealthCheckOptions {
+    /** Service name */
+    serviceName: string;
+    /** Service version (optional) */
+    version?: string;
+    /** Custom health check function for dependencies */
+    checkDependencies?: () => Promise<Record<string, 'connected' | 'disconnected' | 'unknown'>>;
+}
+/**
+ * Liveness handler — returns 200 as long as the process is alive enough to
+ * respond. Dependency status is reported in the body as informational, but a
+ * disconnected dependency does NOT fail the probe (use /ready for that).
+ *
+ * Use as the Kubernetes / ECS LIVENESS probe — it should only fail when the
+ * process is genuinely stuck and needs to be restarted.
+ */
+export declare function createHealthCheck(options: HealthCheckOptions): (_req: Request, res: Response) => Promise<void>;
+/**
+ * Readiness handler — returns 503 if any dependency is `disconnected` (or
+ * the dependency check itself threw). Returns 200 only when the service is
+ * fully ready to serve traffic.
+ *
+ * Use as the Kubernetes / ECS READINESS probe — when this fails, the
+ * orchestrator stops routing traffic to this pod but does NOT restart it.
+ */
+export declare function createReadinessCheck(options: HealthCheckOptions): (_req: Request, res: Response) => Promise<void>;
+/**
+ * Create a health/readiness router exposing:
+ * - GET /health — liveness (always 200 unless process is dead)
+ * - GET /ready  — readiness (503 if dependencies are disconnected)
+ *
+ * @example
+ * ```typescript
+ * app.use(createHealthRouter({ serviceName: 'plugin' }));
+ * ```
+ */
+export declare function createHealthRouter(options: HealthCheckOptions): Router;

package/lib/routes/health.js

@@ -0,0 +1,82 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Router } from 'express';
+import { sendSuccess, sendError } from '../utils/response.js';
+const startTime = Date.now();
+/**
+ * Build a HealthCheckResponse + collect dependency status.
+ * Shared between /health (liveness) and /ready (readiness).
+ */
+async function buildHealthResponse(options) {
+    const { serviceName, version, checkDependencies } = options;
+    const response = {
+        status: 'healthy',
+        service: serviceName,
+        timestamp: new Date().toISOString(),
+        uptime: Math.floor((Date.now() - startTime) / 1000),
+    };
+    if (version)
+        response.version = version;
+    if (!checkDependencies) {
+        return { response, hasDisconnected: false, checkFailed: false };
+    }
+    try {
+        response.dependencies = await checkDependencies();
+        const hasDisconnected = Object.values(response.dependencies).some((status) => status === 'disconnected');
+        return { response, hasDisconnected, checkFailed: false };
+    }
+    catch {
+        response.dependencies = { check: 'disconnected' };
+        return { response, hasDisconnected: true, checkFailed: true };
+    }
+}
+/**
+ * Liveness handler — returns 200 as long as the process is alive enough to
+ * respond. Dependency status is reported in the body as informational, but a
+ * disconnected dependency does NOT fail the probe (use /ready for that).
+ *
+ * Use as the Kubernetes / ECS LIVENESS probe — it should only fail when the
+ * process is genuinely stuck and needs to be restarted.
+ */
+export function createHealthCheck(options) {
+    return async (_req, res) => {
+        const { response } = await buildHealthResponse(options);
+        sendSuccess(res, 200, response);
+    };
+}
+/**
+ * Readiness handler — returns 503 if any dependency is `disconnected` (or
+ * the dependency check itself threw). Returns 200 only when the service is
+ * fully ready to serve traffic.
+ *
+ * Use as the Kubernetes / ECS READINESS probe — when this fails, the
+ * orchestrator stops routing traffic to this pod but does NOT restart it.
+ */
+export function createReadinessCheck(options) {
+    return async (_req, res) => {
+        const { response, hasDisconnected } = await buildHealthResponse(options);
+        if (hasDisconnected) {
+            response.status = 'unhealthy';
+            sendError(res, 503, 'Service not ready', undefined, response);
+            return;
+        }
+        sendSuccess(res, 200, response);
+    };
+}
+/**
+ * Create a health/readiness router exposing:
+ * - GET /health — liveness (always 200 unless process is dead)
+ * - GET /ready  — readiness (503 if dependencies are disconnected)
+ *
+ * @example
+ * ```typescript
+ * app.use(createHealthRouter({ serviceName: 'plugin' }));
+ * ```
+ */
+export function createHealthRouter(options) {
+    const router = Router();
+    router.get('/health', createHealthCheck(options));
+    router.get('/ready', createReadinessCheck(options));
+    return router;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/routes/index.d.ts

@@ -0,0 +1 @@
+export * from './health.js';

package/lib/routes/index.js

@@ -0,0 +1,4 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+export * from './health.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcm91dGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLCtDQUErQztBQUMvQyxzQ0FBc0M7QUFFdEMsY0FBYyxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuZXhwb3J0ICogZnJvbSAnLi9oZWFsdGguanMnO1xuIl19

package/lib/services/audit-spool.d.ts

@@ -0,0 +1,80 @@
+import type { RemoteAuditEvent } from './remote-audit-client.js';
+/** A buffered emission: the event plus which service must re-deliver it. */
+export interface AuditSpoolEntry {
+    event: RemoteAuditEvent;
+    serviceName: string;
+}
+/**
+ * Durable buffer for audit events that failed LIVE delivery to the platform
+ * (retries exhausted during a sustained outage). Without this, the audit trail —
+ * a security log — is silently lost the moment the platform is down for longer
+ * than the client's small retry budget.
+ *
+ * Contract:
+ * - BOUNDED. A security log must degrade to "dropped the oldest, loudly" (a
+ *   metric) rather than grow without limit and OOM the emitter.
+ * - FAIL-SAFE. Every method swallows its own errors — a broken/unreachable spool
+ *   must never break or block the audit emission path (which is itself
+ *   fire-and-forget). A spool problem degrades to the pre-spool behavior.
+ * - Ordering is best-effort. Re-delivered events chain at re-delivery time
+ *   (that's when the platform inserts them), so each event also carries an
+ *   `occurredAt` stamped at emission for reviewers — see RemoteAuditEvent.
+ */
+export interface AuditSpool {
+    /** Buffer an event that failed live delivery. */
+    enqueue(entry: AuditSpoolEntry): Promise<void>;
+    /**
+     * Atomically MOVE up to `max` buffered entries onto an in-progress list and
+     * return them. Because the entries are moved (not popped-and-dropped), a crash
+     * mid-drain leaves them recoverable on the in-progress list — see `recover`.
+     * Each taken entry MUST be resolved with exactly one of `ack` (delivered) or
+     * `requeue` (still failing), or it lingers on the in-progress list until the
+     * next `recover`.
+     */
+    take(max: number): Promise<AuditSpoolEntry[]>;
+    /** Acknowledge successfully re-delivered entries — removes them from the
+     *  in-progress list so they are not recovered again. */
+    ack(entries: AuditSpoolEntry[]): Promise<void>;
+    /** Return entries whose re-delivery failed to the HEAD of the buffer (retried
+     *  first) and clear them from the in-progress list. Best-effort. */
+    requeue(entries: AuditSpoolEntry[]): Promise<void>;
+    /** Reclaim any entries stranded on the in-progress list by a prior crash,
+     *  moving them back to the head of the main buffer. Call once at startup.
+     *  Returns the number reclaimed. */
+    recover(): Promise<number>;
+    /** Approximate current depth (for metrics / drain decisions). */
+    depth(): Promise<number>;
+}
+/** Minimal Redis LIST surface the spool needs (a subset of ioredis). */
+interface RedisListClient {
+    rpush(key: string, ...values: string[]): Promise<number>;
+    lpush(key: string, ...values: string[]): Promise<number>;
+    lpop(key: string, count: number): Promise<string[] | null>;
+    ltrim(key: string, start: number, stop: number): Promise<unknown>;
+    llen(key: string): Promise<number>;
+    /** Atomically pop from one list end and push to another (Redis ≥ 6.2). */
+    lmove(source: string, destination: string, from: 'LEFT' | 'RIGHT', to: 'LEFT' | 'RIGHT'): Promise<string | null>;
+    /** Remove `count` occurrences of `value` from a list. */
+    lrem(key: string, count: number, value: string): Promise<number>;
+}
+/**
+ * Redis-LIST-backed spool. Durable across process restarts (unlike an in-memory
+ * or per-pod-disk buffer), shared by all replicas of a service, and bounded via
+ * a trim-to-tail on overflow (drops the OLDEST, emitting `audit_spool_dropped_total`).
+ */
+export declare function createRedisAuditSpool(redis: RedisListClient, opts?: {
+    maxDepth?: number;
+    key?: string;
+}): AuditSpool;
+/**
+ * Build a Redis-backed audit spool from the ambient `REDIS_URL` / `REDIS_HOST`
+ * env via the shared `createEnvRedisClient`. Returns `null` when Redis is not
+ * configured or the client can't be constructed — the caller then runs without a
+ * spool (pre-spool best-effort behavior), never crashing. The shared helper loads
+ * ioredis via `createRequire`, so this stays importable where Redis isn't present.
+ */
+export declare function createEnvRedisAuditSpool(opts?: {
+    maxDepth?: number;
+    key?: string;
+}): AuditSpool | null;
+export {};