@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/deployment/index.js

@@ -1,54 +1,545 @@
-/**
- * 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, createAdapter, } from './core/adapters.js';
-// Core - Formatters
-export { formatCliResponse, formatHttpResponse, 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 { generateStandaloneRuntimeModule } from '../api/inline-runtime.js';
-import * as path from 'path';
-import { pathToFileURL } from 'url';
-import { ExportTargetRegistry } from './targets/base.js';
-/**
- * Create an export target registry via marketplace discovery.
- *
- * Scans `node_modules/` for installed `flow-weaver-pack-*` packages that
- * declare `exportTargets` in their `flowweaver.manifest.json`.
- * Each target class is eagerly imported (to resolve the async import) but
- * lazily instantiated — the constructor only runs when `registry.get()` is called.
- *
- * @param projectDir — project root to scan for installed packs.
- *   When omitted, returns an empty registry (useful for tests).
- */
-export async function createTargetRegistry(projectDir) {
-    const registry = new ExportTargetRegistry();
-    if (projectDir) {
-        const { listInstalledPackages } = await import('../marketplace/registry.js');
-        const packages = await listInstalledPackages(projectDir);
-        for (const pkg of packages) {
-            for (const def of pkg.manifest.exportTargets ?? []) {
-                const filePath = path.join(pkg.path, def.file);
-                // Dynamic import is async, so we resolve the module here
-                // but defer instantiation to the lazy factory
-                const mod = await import(pathToFileURL(filePath).href);
-                const TargetClass = def.exportName ? mod[def.exportName] : mod.default;
-                registry.register(def.name, () => new TargetClass());
+import {
+  getGeneratedBranding
+} from "../chunks/chunk-AXNQRVJB.js";
+import "../chunks/chunk-SEWDMQ6Q.js";
+
+// src/deployment/targets/base.ts
+import * as path from "path";
+
+// src/deployment/targets/openapi-parts.ts
+var SCHEMA_TYPE = {
+  STRING: "string",
+  NUMBER: "number",
+  BOOLEAN: "boolean",
+  OBJECT: "object",
+  ARRAY: "array",
+  FUNCTION: "object",
+  STEP: "boolean"
+};
+function portSchema(name, port) {
+  const type = port.dataType ? SCHEMA_TYPE[port.dataType] : void 0;
+  return {
+    ...type && { type },
+    description: port.label || name,
+    ...port.tsType && { "x-ts-type": port.tsType }
+  };
+}
+function portProperties(ports) {
+  const properties = {};
+  const required = [];
+  for (const [name, port] of Object.entries(ports)) {
+    if (port.dataType === "STEP") continue;
+    properties[name] = portSchema(name, port);
+    if (!port.optional) required.push(name);
+  }
+  return { properties, required };
+}
+var jsonBody = (schema) => ({ content: { "application/json": { schema } } });
+function executeOperation(op) {
+  return {
+    post: {
+      operationId: op.operationId,
+      summary: op.summary,
+      description: op.description,
+      tags: [op.tag],
+      requestBody: { description: op.requestDescription, required: true, ...jsonBody(op.requestSchema) },
+      responses: {
+        "200": {
+          description: op.subject === "Workflow" ? "Successful workflow execution" : "Successful execution",
+          ...jsonBody({
+            type: "object",
+            properties: {
+              success: { type: "boolean" },
+              result: op.resultSchema,
+              executionTime: { type: "number" },
+              requestId: { type: "string" }
+            }
+          })
+        },
+        "404": {
+          description: `${op.subject} not found`,
+          ...jsonBody({ type: "object", properties: { error: { type: "string" } } })
+        },
+        "500": {
+          description: "Execution error",
+          ...jsonBody({
+            type: "object",
+            properties: { success: { type: "boolean" }, error: { type: "string" }, requestId: { type: "string" } }
+          })
+        }
+      }
+    }
+  };
+}
+function nodeTypeOperation(nodeType, operationId) {
+  const inputs = portProperties(nodeType.inputs);
+  const outputs = portProperties(nodeType.outputs);
+  return executeOperation({
+    operationId,
+    summary: `Execute ${nodeType.name}`,
+    description: nodeType.description || `Execute the ${nodeType.name} node type function`,
+    tag: "node-types",
+    subject: "Node type",
+    requestDescription: "Node type input parameters",
+    requestSchema: {
+      type: "object",
+      properties: inputs.properties,
+      required: inputs.required.length > 0 ? inputs.required : void 0
+    },
+    resultSchema: { type: "object", properties: outputs.properties }
+  });
+}
+function workflowOperation(workflow, operationId, parametersDescription) {
+  return executeOperation({
+    operationId,
+    summary: `Execute ${workflow.name} workflow`,
+    description: workflow.description || `Execute the ${workflow.name} workflow`,
+    tag: "workflows",
+    subject: "Workflow",
+    requestDescription: "Workflow input parameters",
+    requestSchema: { type: "object", description: parametersDescription, additionalProperties: true },
+    resultSchema: { type: "object" }
+  });
+}
+var FUNCTION_CATEGORIES = ["transform", "filter", "validate", "format", "custom"];
+function functionsEndpoint() {
+  return {
+    get: {
+      operationId: "list_functions",
+      summary: "List available functions",
+      description: "Returns all registered functions that can be used as parameters",
+      tags: ["functions"],
+      parameters: [
+        {
+          name: "category",
+          in: "query",
+          required: false,
+          schema: { type: "string", enum: FUNCTION_CATEGORIES },
+          description: "Filter by function category"
+        }
+      ],
+      responses: {
+        "200": {
+          description: "List of registered functions",
+          ...jsonBody({
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                id: { type: "string", example: "string:uppercase" },
+                name: { type: "string" },
+                description: { type: "string" },
+                category: { type: "string", enum: FUNCTION_CATEGORIES },
+                inputType: { type: "string" },
+                outputType: { type: "string" }
+              }
             }
+          })
+        }
+      }
+    }
+  };
+}
+function specEndpoint() {
+  return {
+    get: {
+      operationId: "get_openapi",
+      summary: "OpenAPI Specification",
+      description: "Returns this OpenAPI 3.0 specification",
+      tags: ["documentation"],
+      responses: { "200": { description: "OpenAPI specification", content: { "application/json": {} } } }
+    }
+  };
+}
+var FUNCTION_REFERENCE_SCHEMA = {
+  oneOf: [
+    { type: "string", description: 'Registry function ID (e.g., "string:uppercase")' },
+    {
+      type: "object",
+      properties: {
+        registryId: { type: "string", description: "Registry function ID" },
+        partialArgs: { type: "object", description: "Pre-bound arguments", additionalProperties: true }
+      },
+      required: ["registryId"]
+    }
+  ],
+  description: "Function parameter - can be a registry ID or object with partial arguments"
+};
+var TAGS = {
+  workflows: { name: "workflows", description: "Workflow execution endpoints" },
+  nodeTypes: { name: "node-types", description: "Node type execution endpoints" },
+  functions: { name: "functions", description: "Function registry endpoints" },
+  documentation: { name: "documentation", description: "API documentation" }
+};
+function openApiDocument(opts) {
+  return structuredClone({
+    openapi: "3.0.3",
+    info: { title: opts.title, version: opts.version, description: opts.description },
+    servers: [{ url: opts.baseUrl || "/", description: "Current deployment" }],
+    paths: opts.paths,
+    tags: opts.tags,
+    ...opts.components && { components: opts.components }
+  });
+}
+
+// src/deployment/targets/base.ts
+var BaseExportTarget = class {
+  /**
+   * Generate a standard package.json
+   */
+  generatePackageJson(options) {
+    const pkg = {
+      name: `fw-${options.name}`,
+      version: "1.0.0",
+      description: options.description || `Flow Weaver workflow: ${options.name}`,
+      type: "module",
+      main: options.main || "index.js",
+      scripts: options.scripts || {},
+      dependencies: options.dependencies || {},
+      devDependencies: {
+        typescript: "^5.0.0",
+        ...options.devDependencies
+      }
+    };
+    return JSON.stringify(pkg, null, 2);
+  }
+  /**
+   * Generate a standard tsconfig.json
+   */
+  generateTsConfig(options = {}) {
+    const config = {
+      compilerOptions: {
+        target: "ES2022",
+        module: options.module || "NodeNext",
+        moduleResolution: options.moduleResolution || "NodeNext",
+        outDir: options.outDir || "./dist",
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        ...options.types && { types: options.types }
+      },
+      include: ["**/*.ts"]
+    };
+    return JSON.stringify(config, null, 2);
+  }
+  /**
+   * Create a file object
+   */
+  createFile(outputDir, relativePath, content, type) {
+    return {
+      relativePath,
+      absolutePath: path.join(outputDir, relativePath),
+      content,
+      type
+    };
+  }
+  /**
+   * Generate content files for workflows and node types in a bundle.
+   * Creates files under workflows/ and node-types/ subdirectories.
+   */
+  generateBundleContentFiles(workflows, nodeTypes, outputDir, workflowDir = "workflows", nodeTypeDir = "node-types") {
+    const files = [];
+    for (const w of workflows) {
+      if (w.code) {
+        files.push(this.createFile(outputDir, `${workflowDir}/${w.name}.ts`, w.code, "workflow"));
+      }
+    }
+    for (const nt of nodeTypes) {
+      if (nt.code) {
+        files.push(this.createFile(outputDir, `${nodeTypeDir}/${nt.functionName.toLowerCase()}.ts`, nt.code, "nodeType"));
+      }
+    }
+    return files;
+  }
+  /**
+   * Generate content files for compiled workflows.
+   * Creates files under the workflows/ subdirectory.
+   */
+  generateWorkflowContentFiles(workflows, outputDir, workflowDir = "workflows") {
+    const files = [];
+    for (const w of workflows) {
+      if (w.code) {
+        files.push(this.createFile(outputDir, `${workflowDir}/${w.name}.ts`, w.code, "workflow"));
+      }
+    }
+    return files;
+  }
+  /**
+   * Generate content files for node types.
+   * Creates files under the node-types/ subdirectory.
+   */
+  generateNodeTypeContentFiles(nodeTypes, outputDir, nodeTypeDir = "node-types") {
+    const files = [];
+    for (const nt of nodeTypes) {
+      if (nt.code) {
+        files.push(this.createFile(outputDir, `${nodeTypeDir}/${nt.functionName.toLowerCase()}.ts`, nt.code, "nodeType"));
+      }
+    }
+    return files;
+  }
+  /**
+   * Get relative import path for the workflow
+   */
+  getWorkflowImport(workflowFile) {
+    const basename2 = path.basename(workflowFile, path.extname(workflowFile));
+    return `./${basename2}.js`;
+  }
+  /**
+   * The OpenAPI document of a node-type service: one POST per node type.
+   */
+  generateNodeTypeOpenAPI(nodeTypes, options) {
+    const paths = {};
+    for (const nodeType of nodeTypes) {
+      paths[`/api/${nodeType.name}`] = nodeTypeOperation(nodeType, `execute_${nodeType.functionName}`);
+    }
+    paths["/api/openapi.json"] = specEndpoint();
+    return openApiDocument({
+      ...options,
+      description: `Node type service with ${nodeTypes.length} endpoints`,
+      paths,
+      tags: [TAGS.nodeTypes, TAGS.documentation]
+    });
+  }
+  /**
+   * The OpenAPI document of a multi-workflow service: one POST per workflow,
+   * plus the function registry.
+   */
+  generateConsolidatedOpenAPI(workflows, options) {
+    const paths = {};
+    for (const workflow of workflows) {
+      paths[`/api/${workflow.name}`] = workflowOperation(
+        workflow,
+        `execute_${workflow.functionName}`,
+        "Workflow-specific parameters. Function parameters can be registry IDs."
+      );
+    }
+    paths["/api/functions"] = functionsEndpoint();
+    paths["/api/openapi.json"] = specEndpoint();
+    return openApiDocument({
+      ...options,
+      description: `Multi-workflow service with ${workflows.length} workflows`,
+      paths,
+      tags: [TAGS.workflows, TAGS.functions, TAGS.documentation],
+      components: { schemas: { FunctionReference: FUNCTION_REFERENCE_SCHEMA } }
+    });
+  }
+  /**
+   * The OpenAPI document of a bundle: a POST for each exposed workflow and
+   * node type, plus the function registry.
+   */
+  generateBundleOpenAPI(workflows, nodeTypes, options) {
+    const exposedWorkflows = workflows.filter((w) => w.expose);
+    const exposedNodeTypes = nodeTypes.filter((nt) => nt.expose);
+    const paths = {};
+    const tags = [];
+    if (exposedWorkflows.length > 0) tags.push(TAGS.workflows);
+    for (const workflow of exposedWorkflows) {
+      paths[`/api/workflows/${workflow.name}`] = workflowOperation(
+        workflow,
+        `execute_workflow_${workflow.functionName}`,
+        "Workflow-specific parameters"
+      );
+    }
+    if (exposedNodeTypes.length > 0) tags.push(TAGS.nodeTypes);
+    for (const nodeType of exposedNodeTypes) {
+      paths[`/api/nodes/${nodeType.name}`] = nodeTypeOperation(nodeType, `execute_node_${nodeType.functionName}`);
+    }
+    paths["/api/functions"] = functionsEndpoint();
+    paths["/api/openapi.json"] = specEndpoint();
+    tags.push(TAGS.functions, TAGS.documentation);
+    const count = (n, noun) => `${n} ${noun}${n !== 1 ? "s" : ""}`;
+    const exposed = [
+      ...exposedWorkflows.length > 0 ? [count(exposedWorkflows.length, "workflow")] : [],
+      ...exposedNodeTypes.length > 0 ? [count(exposedNodeTypes.length, "node type")] : []
+    ];
+    return openApiDocument({
+      ...options,
+      description: exposed.length > 0 ? `Bundle service with ${exposed.join(" and ")} exposed` : "Bundle service with no workflows or node types exposed",
+      paths,
+      tags
+    });
+  }
+  /**
+   * Generate a README.md from deploy instructions
+   */
+  generateReadme(instructions, workflowName, target) {
+    const lines = [];
+    lines.push(`# Deploy ${workflowName} to ${target}`);
+    lines.push("");
+    if (instructions.prerequisites.length > 0) {
+      lines.push("## Prerequisites");
+      lines.push("");
+      instructions.prerequisites.forEach((p) => lines.push(`- ${p}`));
+      lines.push("");
+    }
+    if (instructions.steps.length > 0) {
+      lines.push("## Deployment Steps");
+      lines.push("");
+      instructions.steps.forEach((step, i) => {
+        if (step.startsWith("  ")) {
+          lines.push(`   \`${step.trim()}\``);
+        } else {
+          lines.push(`${i + 1}. \`${step}\``);
+        }
+      });
+      lines.push("");
+    }
+    if (instructions.localTestSteps && instructions.localTestSteps.length > 0) {
+      lines.push("## Local Testing");
+      lines.push("");
+      lines.push("Test your deployment locally before pushing to production:");
+      lines.push("");
+      lines.push("```bash");
+      instructions.localTestSteps.forEach((step) => lines.push(step));
+      lines.push("```");
+      lines.push("");
+    }
+    if (instructions.links && instructions.links.length > 0) {
+      lines.push("## Useful Links");
+      lines.push("");
+      instructions.links.forEach((link) => lines.push(`- [${link.label}](${link.url})`));
+      lines.push("");
+    }
+    lines.push("---");
+    lines.push(getGeneratedBranding().markdown);
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate placeholder runtime files under `runtime/`: a function registry
+   * listing the bundled workflows and node types, a builtin-functions module
+   * that only imports it, and a trivial parameter resolver. They are not the
+   * Flow Weaver runtime; a target that needs the real one must bundle it.
+   */
+  generateRuntimeFiles(outputDir, workflows, nodeTypes) {
+    const files = [];
+    files.push(
+      this.createFile(
+        outputDir,
+        "runtime/function-registry.ts",
+        this.generateFunctionRegistryContent(workflows, nodeTypes),
+        "other"
+      )
+    );
+    files.push(
+      this.createFile(
+        outputDir,
+        "runtime/builtin-functions.ts",
+        `// Builtin functions, auto-registers known functions
+import './function-registry.js';
+`,
+        "other"
+      )
+    );
+    files.push(
+      this.createFile(
+        outputDir,
+        "runtime/parameter-resolver.ts",
+        `// Parameter resolver
+export function resolveFunction(param: unknown) { return typeof param === 'function' ? param : undefined; }
+`,
+        "other"
+      )
+    );
+    return files;
+  }
+  /**
+   * Generate function registry content with workflow/nodeType metadata.
+   * Used as fallback when real runtime source files aren't available.
+   */
+  generateFunctionRegistryContent(workflows, nodeTypes) {
+    return `// Generated function registry
+type FunctionInfo = {
+  name: string;
+  type: 'workflow' | 'nodeType';
+  exposed: boolean;
+};
+
+const functions: FunctionInfo[] = [
+${workflows.map((w) => `  { name: '${w.name}', type: 'workflow', exposed: ${w.expose} },`).join("\n")}
+${nodeTypes.map((nt) => `  { name: '${nt.name}', type: 'nodeType', exposed: ${nt.expose} },`).join("\n")}
+];
+
+// Query helpers over the function list above.
+export const functionRegistry = {
+  list(category?: 'workflow' | 'nodeType'): FunctionInfo[] {
+    return category ? functions.filter((f) => f.type === category) : functions;
+  },
+  get(name: string): FunctionInfo | undefined {
+    return functions.find((f) => f.name === name);
+  },
+};
+`;
+  }
+};
+var ExportTargetRegistry = class {
+  factories = /* @__PURE__ */ new Map();
+  instances = /* @__PURE__ */ new Map();
+  /**
+   * Register a target factory. The target is only instantiated on first use.
+   * Also accepts a pre-instantiated target.
+   */
+  register(nameOrTarget, factory) {
+    if (typeof nameOrTarget === "string") {
+      this.factories.set(nameOrTarget, factory);
+    } else {
+      const target = nameOrTarget;
+      this.instances.set(target.name, target);
+      this.factories.set(target.name, () => target);
+    }
+  }
+  get(name) {
+    if (!this.instances.has(name)) {
+      const factory = this.factories.get(name);
+      if (factory) this.instances.set(name, factory());
+    }
+    return this.instances.get(name);
+  }
+  getAll() {
+    for (const [name, factory] of this.factories) {
+      if (!this.instances.has(name)) this.instances.set(name, factory());
+    }
+    return Array.from(this.instances.values());
+  }
+  getNames() {
+    return Array.from(this.factories.keys());
+  }
+  /** Get deploy schemas from all registered targets (for validation/autocomplete) */
+  getDeploySchemas() {
+    const schemas = {};
+    for (const target of this.getAll()) {
+      if (target.deploySchema) schemas[target.name] = target.deploySchema;
+    }
+    return schemas;
+  }
+};
+
+// src/deployment/index.ts
+import * as path2 from "path";
+import { pathToFileURL } from "url";
+async function createTargetRegistry(projectDir) {
+  const registry = new ExportTargetRegistry();
+  if (projectDir) {
+    const { listInstalledPackages } = await import("../chunks/registry-K2U5KUTY.js");
+    const packages = await listInstalledPackages(projectDir);
+    for (const pkg of packages) {
+      for (const def of pkg.manifest.exportTargets ?? []) {
+        const filePath = path2.join(pkg.path, def.file);
+        const mod = await import(pathToFileURL(filePath).href);
+        const TargetClass = def.exportName ? mod[def.exportName] : mod.default;
+        if (typeof TargetClass !== "function") {
+          const what = def.exportName ? `export "${def.exportName}"` : "a default export";
+          console.warn(`Export target "${def.name}" of pack ${pkg.name} skipped: ${filePath} has no ${what} that is a class or function`);
+          continue;
         }
+        registry.register(def.name, () => new TargetClass());
+      }
     }
-    return registry;
+  }
+  return registry;
 }
-//# sourceMappingURL=index.js.map
+export {
+  BaseExportTarget,
+  ExportTargetRegistry,
+  createTargetRegistry
+};

package/dist/deployment/targets/base.d.ts

@@ -1,7 +1,7 @@
 /**
  * Base export target interface and abstract class
  *
- * Defines the contract for serverless export targets and provides
+ * Defines the contract for export targets (provided by packs) and provides
  * shared utilities for generating deployment artifacts.
  */
 /**
@@ -181,7 +181,7 @@ export interface DeploySchemaField {
     default?: unknown;
 }
 /**
- * Deploy schema — describes all @deploy keys a target accepts.
+ * Deploy schema: describes all @deploy keys a target accepts.
  * Used for validation, Studio autocomplete, and documentation.
  */
 export type DeploySchema = Record<string, DeploySchemaField>;
@@ -279,7 +279,7 @@ export declare abstract class BaseExportTarget implements ExportTarget {
      */
     protected getWorkflowImport(workflowFile: string): string;
     /**
-     * Generate OpenAPI spec for node types as HTTP endpoints
+     * The OpenAPI document of a node-type service: one POST per node type.
      */
     protected generateNodeTypeOpenAPI(nodeTypes: NodeTypeInfo[], options: {
         title: string;
@@ -287,11 +287,8 @@ export declare abstract class BaseExportTarget implements ExportTarget {
         baseUrl?: string;
     }): object;
     /**
-     * Map Flow Weaver data types to JSON Schema types
-     */
-    private mapDataTypeToJsonSchema;
-    /**
-     * Generate consolidated OpenAPI spec for multiple workflows
+     * The OpenAPI document of a multi-workflow service: one POST per workflow,
+     * plus the function registry.
      */
     protected generateConsolidatedOpenAPI(workflows: CompiledWorkflow[], options: {
         title: string;
@@ -299,8 +296,8 @@ export declare abstract class BaseExportTarget implements ExportTarget {
         baseUrl?: string;
     }): object;
     /**
-     * Generate OpenAPI spec for a unified bundle of workflows and node types.
-     * Only includes exposed items as HTTP endpoints.
+     * The OpenAPI document of a bundle: a POST for each exposed workflow and
+     * node type, plus the function registry.
      */
     protected generateBundleOpenAPI(workflows: BundleWorkflow[], nodeTypes: BundleNodeType[], options: {
         title: string;
@@ -312,9 +309,10 @@ export declare abstract class BaseExportTarget implements ExportTarget {
      */
     protected generateReadme(instructions: DeployInstructions, workflowName: string, target: string): string;
     /**
-     * Generate real runtime files from the Flow Weaver runtime source.
-     * Includes the function registry, builtin functions, and parameter resolver.
-     * These replace the placeholder files that were previously generated.
+     * Generate placeholder runtime files under `runtime/`: a function registry
+     * listing the bundled workflows and node types, a builtin-functions module
+     * that only imports it, and a trivial parameter resolver. They are not the
+     * Flow Weaver runtime; a target that needs the real one must bundle it.
      */
     protected generateRuntimeFiles(outputDir: string, workflows: BundleWorkflow[], nodeTypes: BundleNodeType[]): GeneratedFile[];
     /**