@synergenius/flow-weaver 0.2.0

package/dist/deployment/core/formatters.js

@@ -0,0 +1,170 @@
+/**
+ * Response formatters for different output contexts
+ *
+ * Transforms unified WorkflowResponse into format-specific outputs.
+ */
+/**
+ * Format response for CLI consumption
+ */
+export function formatCliResponse(response, options = {}) {
+    if (options.json) {
+        return formatJsonResponse(response, options.includeTrace);
+    }
+    return formatHumanReadableResponse(response, options);
+}
+/**
+ * Format response as JSON string
+ */
+function formatJsonResponse(response, includeTrace) {
+    const output = {
+        success: response.success,
+        workflow: response.workflowId,
+        executionTime: response.executionTime,
+        requestId: response.requestId,
+    };
+    if (response.success) {
+        output.result = response.result;
+        if (includeTrace && response.trace) {
+            output.traceCount = response.trace.length;
+        }
+    }
+    else {
+        output.error = response.error;
+    }
+    return JSON.stringify(output, null, 2);
+}
+/**
+ * Format response for human-readable CLI output
+ */
+function formatHumanReadableResponse(response, options) {
+    const lines = [];
+    if (response.success) {
+        lines.push(`Workflow "${response.workflowId}" completed in ${response.executionTime}ms`);
+        lines.push('');
+        lines.push('Result:');
+        lines.push(JSON.stringify(response.result, null, 2));
+        if (options.includeTrace && response.trace && response.trace.length > 0) {
+            lines.push('');
+            lines.push('Trace:');
+            lines.push(`${response.trace.length} events captured`);
+            // Show first few trace events as summary
+            const preview = response.trace.slice(0, 5);
+            for (const event of preview) {
+                const nodeId = event.data?.nodeId || '';
+                lines.push(`  [${event.type}] ${nodeId}`);
+            }
+            if (response.trace.length > 5) {
+                lines.push(`  ... and ${response.trace.length - 5} more events`);
+            }
+        }
+    }
+    else {
+        lines.push(`Workflow "${response.workflowId}" failed`);
+        lines.push('');
+        lines.push(`Error: ${response.error?.message || 'Unknown error'}`);
+        if (response.error?.code) {
+            lines.push(`Code: ${response.error.code}`);
+        }
+        if (response.error?.stack) {
+            lines.push('');
+            lines.push('Stack trace:');
+            lines.push(response.error.stack);
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * Format response for HTTP (returns object suitable for JSON response)
+ */
+export function formatHttpResponse(response) {
+    const headers = {
+        'Content-Type': 'application/json',
+        'X-Request-Id': response.requestId,
+        'X-Execution-Time': `${response.executionTime}ms`,
+    };
+    if (response.success) {
+        return {
+            statusCode: 200,
+            body: {
+                success: true,
+                workflow: response.workflowId,
+                result: response.result,
+                executionTime: response.executionTime,
+                ...(response.trace && { trace: response.trace }),
+            },
+            headers,
+        };
+    }
+    // Determine status code based on error
+    let statusCode = 500;
+    if (response.error?.code === 'WORKFLOW_NOT_FOUND') {
+        statusCode = 404;
+    }
+    else if (response.error?.code === 'VALIDATION_ERROR') {
+        statusCode = 400;
+    }
+    else if (response.error?.code === 'TIMEOUT') {
+        statusCode = 504;
+    }
+    return {
+        statusCode,
+        body: {
+            success: false,
+            workflow: response.workflowId,
+            error: response.error,
+            executionTime: response.executionTime,
+        },
+        headers,
+    };
+}
+/**
+ * Format response for AWS Lambda (API Gateway response format)
+ */
+export function formatLambdaResponse(response) {
+    const httpResponse = formatHttpResponse(response);
+    return {
+        statusCode: httpResponse.statusCode,
+        headers: httpResponse.headers,
+        body: JSON.stringify(httpResponse.body),
+    };
+}
+/**
+ * Format response for Cloudflare Workers (returns Response object constructor args)
+ */
+export function formatCloudflareResponse(response) {
+    const httpResponse = formatHttpResponse(response);
+    return {
+        body: JSON.stringify(httpResponse.body),
+        init: {
+            status: httpResponse.statusCode,
+            headers: httpResponse.headers,
+        },
+    };
+}
+/**
+ * Format error for consistent error responses
+ */
+export function formatError(error, context = {}) {
+    const message = error instanceof Error ? error.message : String(error);
+    const stack = !context.production && error instanceof Error ? error.stack : undefined;
+    // Try to determine error code from message
+    let code = 'INTERNAL_ERROR';
+    if (message.includes('not found')) {
+        code = 'WORKFLOW_NOT_FOUND';
+    }
+    else if (message.includes('timeout')) {
+        code = 'TIMEOUT';
+    }
+    else if (message.includes('validation') || message.includes('invalid')) {
+        code = 'VALIDATION_ERROR';
+    }
+    else if (message.includes('cancelled') || message.includes('abort')) {
+        code = 'CANCELLED';
+    }
+    return {
+        message,
+        code,
+        stack,
+    };
+}
+//# sourceMappingURL=formatters.js.map

package/dist/deployment/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Flow Weaver Deployment System
+ *
+ * Unified abstractions for deploying workflows across CLI, HTTP, and serverless contexts.
+ *
+ * @module deployment
+ */
+export type { ExecutionSource, Environment, ExecutionContext, WorkflowRequest, WorkflowResponse, WorkflowError, WorkflowErrorCode, ValidationResult, ValidationError, CliInput, HttpInput, LambdaInput, VercelInput, CloudflareInput, AdapterInput, } from './types.js';
+export { UnifiedWorkflowExecutor, createExecutor, type ExecutorOptions } from './core/executor.js';
+export { type RequestAdapter, CliRequestAdapter, HttpRequestAdapter, LambdaRequestAdapter, VercelRequestAdapter, CloudflareRequestAdapter, createAdapter, } from './core/adapters.js';
+export { formatCliResponse, formatHttpResponse, formatLambdaResponse, formatCloudflareResponse, formatError, type CliOutputOptions, } from './core/formatters.js';
+export type { DeploymentConfig, ServerConfig, ExecutionConfig, SecretsConfig, CorsConfig, RetryConfig, PartialDeploymentConfig, CliConfigOverrides, } from './config/types.js';
+export { DEFAULT_CONFIG, DEFAULT_SERVER_CONFIG, DEFAULT_EXECUTION_CONFIG, getDefaultConfig, } from './config/defaults.js';
+export { loadConfig, loadConfigSync, getConfigValue } from './config/loader.js';
+export { OpenAPIGenerator, generateOpenAPIJson, generateOpenAPIYaml, type OpenAPIDocument, type OpenAPIInfo, type OpenAPIServer, type GeneratorOptions, } from './openapi/generator.js';
+export { SchemaConverter, schemaConverter, type OpenAPISchema, } from './openapi/schema-converter.js';
+export { type ExportTarget, type ExportOptions, type ExportArtifacts, type GeneratedFile, type DeployInstructions, BaseExportTarget, ExportTargetRegistry, } from './targets/base.js';
+export { LambdaTarget } from './targets/lambda.js';
+export { VercelTarget } from './targets/vercel.js';
+export { CloudflareTarget } from './targets/cloudflare.js';
+export { InngestTarget } from './targets/inngest.js';
+import { ExportTargetRegistry } from './targets/base.js';
+/**
+ * Default export target registry with all built-in targets
+ */
+export declare function createTargetRegistry(): ExportTargetRegistry;
+/**
+ * Get names of all supported export targets
+ */
+export declare function getSupportedTargetNames(): string[];
+//# sourceMappingURL=index.d.ts.map

package/dist/deployment/index.js

@@ -0,0 +1,48 @@
+/**
+ * Flow Weaver Deployment System
+ *
+ * Unified abstractions for deploying workflows across CLI, HTTP, and serverless contexts.
+ *
+ * @module deployment
+ */
+// Core - Executor
+export { UnifiedWorkflowExecutor, createExecutor } from './core/executor.js';
+// Core - Adapters
+export { CliRequestAdapter, HttpRequestAdapter, LambdaRequestAdapter, VercelRequestAdapter, CloudflareRequestAdapter, createAdapter, } from './core/adapters.js';
+// Core - Formatters
+export { formatCliResponse, formatHttpResponse, formatLambdaResponse, formatCloudflareResponse, formatError, } from './core/formatters.js';
+export { DEFAULT_CONFIG, DEFAULT_SERVER_CONFIG, DEFAULT_EXECUTION_CONFIG, getDefaultConfig, } from './config/defaults.js';
+export { loadConfig, loadConfigSync, getConfigValue } from './config/loader.js';
+// OpenAPI
+export { OpenAPIGenerator, generateOpenAPIJson, generateOpenAPIYaml, } from './openapi/generator.js';
+export { SchemaConverter, schemaConverter, } from './openapi/schema-converter.js';
+// Export Targets
+export { BaseExportTarget, ExportTargetRegistry, } from './targets/base.js';
+export { LambdaTarget } from './targets/lambda.js';
+export { VercelTarget } from './targets/vercel.js';
+export { CloudflareTarget } from './targets/cloudflare.js';
+export { InngestTarget } from './targets/inngest.js';
+// Convenience: Create a pre-configured target registry
+import { ExportTargetRegistry } from './targets/base.js';
+import { LambdaTarget } from './targets/lambda.js';
+import { VercelTarget } from './targets/vercel.js';
+import { CloudflareTarget } from './targets/cloudflare.js';
+import { InngestTarget } from './targets/inngest.js';
+/**
+ * Default export target registry with all built-in targets
+ */
+export function createTargetRegistry() {
+    const registry = new ExportTargetRegistry();
+    registry.register(new LambdaTarget());
+    registry.register(new VercelTarget());
+    registry.register(new CloudflareTarget());
+    registry.register(new InngestTarget());
+    return registry;
+}
+/**
+ * Get names of all supported export targets
+ */
+export function getSupportedTargetNames() {
+    return ['lambda', 'vercel', 'cloudflare', 'inngest'];
+}
+//# sourceMappingURL=index.js.map

package/dist/deployment/openapi/generator.d.ts

@@ -0,0 +1,146 @@
+/**
+ * OpenAPI specification generator
+ *
+ * Generates OpenAPI 3.0 specifications from workflow endpoints.
+ */
+import type { WorkflowEndpoint } from '../../server/types.js';
+import { type OpenAPISchema } from './schema-converter.js';
+/**
+ * OpenAPI 3.0 Document (simplified)
+ */
+export interface OpenAPIDocument {
+    openapi: string;
+    info: OpenAPIInfo;
+    servers?: OpenAPIServer[];
+    paths: Record<string, OpenAPIPathItem>;
+    components?: {
+        schemas?: Record<string, OpenAPISchema>;
+        responses?: Record<string, OpenAPIResponse>;
+        parameters?: Record<string, OpenAPIParameter>;
+    };
+    tags?: OpenAPITag[];
+}
+export interface OpenAPIInfo {
+    title: string;
+    description?: string;
+    version: string;
+    contact?: {
+        name?: string;
+        url?: string;
+        email?: string;
+    };
+    license?: {
+        name: string;
+        url?: string;
+    };
+}
+export interface OpenAPIServer {
+    url: string;
+    description?: string;
+}
+export interface OpenAPIPathItem {
+    get?: OpenAPIOperation;
+    post?: OpenAPIOperation;
+    put?: OpenAPIOperation;
+    delete?: OpenAPIOperation;
+    patch?: OpenAPIOperation;
+    summary?: string;
+    description?: string;
+    parameters?: OpenAPIParameter[];
+}
+export interface OpenAPIOperation {
+    operationId?: string;
+    summary?: string;
+    description?: string;
+    tags?: string[];
+    parameters?: OpenAPIParameter[];
+    requestBody?: OpenAPIRequestBody;
+    responses: Record<string, OpenAPIResponse>;
+}
+export interface OpenAPIParameter {
+    name: string;
+    in: 'query' | 'header' | 'path' | 'cookie';
+    description?: string;
+    required?: boolean;
+    schema?: OpenAPISchema;
+}
+export interface OpenAPIRequestBody {
+    description?: string;
+    required?: boolean;
+    content: Record<string, {
+        schema: OpenAPISchema;
+    }>;
+}
+export interface OpenAPIResponse {
+    description: string;
+    content?: Record<string, {
+        schema: OpenAPISchema;
+    }>;
+    headers?: Record<string, {
+        schema: OpenAPISchema;
+        description?: string;
+    }>;
+}
+export interface OpenAPITag {
+    name: string;
+    description?: string;
+}
+/**
+ * Options for generating OpenAPI specification
+ */
+export interface GeneratorOptions {
+    /** API title */
+    title: string;
+    /** API version */
+    version: string;
+    /** API description */
+    description?: string;
+    /** Server URLs */
+    servers?: OpenAPIServer[];
+    /** Contact information */
+    contact?: OpenAPIInfo['contact'];
+    /** License information */
+    license?: OpenAPIInfo['license'];
+    /** Base path for all endpoints */
+    basePath?: string;
+}
+/**
+ * OpenAPI specification generator
+ */
+export declare class OpenAPIGenerator {
+    private schemaConverter;
+    constructor();
+    /**
+     * Generate OpenAPI specification from workflow endpoints
+     */
+    generate(endpoints: WorkflowEndpoint[], options: GeneratorOptions): OpenAPIDocument;
+    /**
+     * Generate path item for a workflow endpoint
+     */
+    private generateWorkflowEndpoint;
+    /**
+     * Generate health endpoint
+     */
+    private generateHealthEndpoint;
+    /**
+     * Generate workflow list endpoint
+     */
+    private generateListEndpoint;
+    /**
+     * Generate component schemas
+     */
+    private generateComponentSchemas;
+    /**
+     * Generate standard responses
+     */
+    private generateStandardResponses;
+}
+/**
+ * Generate OpenAPI specification as JSON string
+ */
+export declare function generateOpenAPIJson(endpoints: WorkflowEndpoint[], options: GeneratorOptions): string;
+/**
+ * Generate OpenAPI specification as YAML string
+ */
+export declare function generateOpenAPIYaml(endpoints: WorkflowEndpoint[], options: GeneratorOptions): string;
+//# sourceMappingURL=generator.d.ts.map