@dypai-ai/workflow-core 0.1.0

package/src/registry/nodeRegistry.ts

@@ -0,0 +1,87 @@
+import { dypaiDbNode } from "./nodes/dypaiDb";
+import { dypaiEmailNode } from "./nodes/dypaiEmail";
+import { dypaiFlowNode } from "./nodes/dypaiFlow";
+import { legacyWorkflowNode } from "./nodes/legacyWorkflow";
+import type { CapabilityCatalog } from "../capabilities/types";
+import { mergeNodeRegistryDefinitions } from "../capabilities";
+import type { NodeDefinition, RegistryLookup, ResourceIR, SideEffectKind } from "../ir/types";
+import { operationKey } from "./defineNode";
+
+export class NodeRegistry {
+  private readonly nodes = new Map<string, NodeDefinition>();
+
+  constructor(definitions: NodeDefinition[] = []) {
+    for (const definition of definitions) this.register(definition);
+  }
+
+  static withCatalog(catalog?: CapabilityCatalog | null): NodeRegistry {
+    return new NodeRegistry(mergeNodeRegistryDefinitions([
+      dypaiDbNode,
+      dypaiEmailNode,
+      dypaiFlowNode,
+      legacyWorkflowNode,
+    ], catalog));
+  }
+
+  register(definition: NodeDefinition): void {
+    this.nodes.set(definition.id, definition);
+  }
+
+  getNode(nodeId: string): NodeDefinition | undefined {
+    return this.nodes.get(nodeId);
+  }
+
+  lookup(nodeId: string, operation: string, version: number): RegistryLookup | undefined {
+    const node = this.nodes.get(nodeId);
+    if (!node || node.version !== version) return undefined;
+    const op = node.operations[operation];
+    if (!op) return undefined;
+    return { node, operation: op };
+  }
+
+  has(nodeId: string, operation: string, version: number): boolean {
+    return Boolean(this.lookup(nodeId, operation, version));
+  }
+
+  listNodes(): NodeDefinition[] {
+    return [...this.nodes.values()];
+  }
+
+  listOperationKeys(): string[] {
+    const keys: string[] = [];
+    for (const node of this.nodes.values()) {
+      for (const operationName of Object.keys(node.operations)) {
+        keys.push(operationKey(node.id, operationName, node.version));
+      }
+    }
+    return keys.sort();
+  }
+
+  deriveResources(
+    nodeId: string,
+    operation: string,
+    version: number,
+    config: Record<string, unknown>,
+  ): ResourceIR[] {
+    const resolved = this.lookup(nodeId, operation, version);
+    if (!resolved?.operation.resources) return [];
+    return resolved.operation.resources(config);
+  }
+
+  deriveSideEffects(
+    nodeId: string,
+    operation: string,
+    version: number,
+  ): SideEffectKind[] {
+    const resolved = this.lookup(nodeId, operation, version);
+    if (!resolved) return [];
+    return [
+      ...(resolved.node.sideEffects ?? []),
+      ...(resolved.operation.sideEffects ?? []),
+    ];
+  }
+}
+
+export const defaultNodeRegistry = NodeRegistry.withCatalog();
+
+export { dypaiDbNode, dypaiEmailNode, dypaiFlowNode, legacyWorkflowNode };

package/src/registry/nodes/dypaiDb.ts

@@ -0,0 +1,164 @@
+import { defineNode, defineOperation } from "../defineNode";
+
+const tableNamePattern = /^[a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z_][a-zA-Z0-9_]*)?$/;
+
+function tableResource(config: Record<string, unknown>, access: "read" | "write") {
+  const table = typeof config.table === "string" ? config.table.trim() : "";
+  if (!table || !tableNamePattern.test(table)) return [];
+  return [{ type: "postgres_table", name: table, access }];
+}
+
+export const dypaiDbNode = defineNode({
+  id: "dypai.db",
+  version: 1,
+  label: "DYPAI Database",
+  category: "database",
+  docs: "Declarative and SQL database operations backed by Postgres.",
+  sideEffects: ["db.read", "db.write"],
+  operations: {
+    query: defineOperation({
+      label: "Run SQL query",
+      docs: "Execute explicit SQL against Postgres.",
+      inputSchema: {
+        type: "object",
+        required: ["sql"],
+        additionalProperties: false,
+        properties: {
+          sql: { type: "string", minLength: 1 },
+          params: { type: "object" },
+        },
+      },
+      outputSchema: {
+        type: "object",
+        properties: {
+          rows: { type: "array" },
+          row: { type: "object" },
+        },
+      },
+      sideEffects: ["db.read"],
+      resources: (config) => tableResource(config, "read"),
+      validate: (config) => {
+        const sql = typeof config.sql === "string" ? config.sql.trim() : "";
+        if (!sql) {
+          return [{
+            severity: "error",
+            rule: "db_query_missing_sql",
+            message: "dypai.db.query requires config.sql.",
+            fixHint: "Add sql with explicit SELECT/INSERT/UPDATE/DELETE SQL.",
+          }];
+        }
+        return [];
+      },
+    }),
+    insert: defineOperation({
+      label: "Insert row",
+      docs: "Insert a row into a Postgres table.",
+      inputSchema: {
+        type: "object",
+        required: ["table", "values"],
+        additionalProperties: false,
+        properties: {
+          table: { type: "string", minLength: 1 },
+          values: { type: "object", minProperties: 1 },
+          returning: {
+            type: "array",
+            items: { type: "string" },
+          },
+        },
+      },
+      outputSchema: {
+        type: "object",
+        properties: {
+          row: { type: "object" },
+        },
+      },
+      sideEffects: ["db.write"],
+      resources: (config) => tableResource(config, "write"),
+      validate: (config) => {
+        const diagnostics = [];
+        const table = typeof config.table === "string" ? config.table.trim() : "";
+        if (!table) {
+          diagnostics.push({
+            severity: "error" as const,
+            rule: "db_insert_missing_table",
+            message: "dypai.db.insert requires config.table.",
+            fixHint: 'Add table: "public.bookings" (or another schema-qualified table).',
+          });
+        }
+        if (!config.values || typeof config.values !== "object" || Array.isArray(config.values)) {
+          diagnostics.push({
+            severity: "error" as const,
+            rule: "db_insert_missing_values",
+            message: "dypai.db.insert requires config.values with at least one column.",
+            fixHint: "Map column names to literals or RefIR values.",
+          });
+        }
+        return diagnostics;
+      },
+    }),
+    update: defineOperation({
+      label: "Update rows",
+      docs: "Update rows in a Postgres table with a required where clause.",
+      inputSchema: {
+        type: "object",
+        required: ["table", "where", "set"],
+        additionalProperties: false,
+        properties: {
+          table: { type: "string", minLength: 1 },
+          where: { type: "object", minProperties: 1 },
+          set: { type: "object", minProperties: 1 },
+          returning: {
+            type: "array",
+            items: { type: "string" },
+          },
+        },
+      },
+      outputSchema: {
+        type: "object",
+        properties: {
+          row: { type: "object" },
+          rows: { type: "array" },
+        },
+      },
+      sideEffects: ["db.write"],
+      resources: (config) => tableResource(config, "write"),
+      validate: (config) => {
+        const where = config.where;
+        if (!where || typeof where !== "object" || Array.isArray(where) || !Object.keys(where).length) {
+          return [{
+            severity: "error" as const,
+            rule: "db_update_missing_where",
+            message: "dypai.db.update requires config.where with at least one filter.",
+            fixHint: "Use where: { id: { kind: 'input', path: ['id'] }, user_id: { kind: 'currentUserId' } }.",
+          }];
+        }
+        return [];
+      },
+    }),
+    list: defineOperation({
+      label: "List rows",
+      docs: "List rows from a Postgres table with optional filters and pagination.",
+      inputSchema: {
+        type: "object",
+        required: ["table"],
+        additionalProperties: false,
+        properties: {
+          table: { type: "string", minLength: 1 },
+          where: { type: "object" },
+          orderBy: { type: "string" },
+          limit: {},
+          offset: {},
+        },
+      },
+      outputSchema: {
+        type: "object",
+        required: ["rows"],
+        properties: {
+          rows: { type: "array" },
+        },
+      },
+      sideEffects: ["db.read"],
+      resources: (config) => tableResource(config, "read"),
+    }),
+  },
+});

package/src/registry/nodes/dypaiEmail.ts

@@ -0,0 +1,57 @@
+import { defineNode, defineOperation } from "../defineNode";
+
+export const dypaiEmailNode = defineNode({
+  id: "dypai.email",
+  version: 1,
+  label: "DYPAI Email",
+  category: "communications",
+  docs: "Send transactional email through configured DYPAI email providers.",
+  operations: {
+    send: defineOperation({
+      label: "Send email",
+      docs: "Send an email using a template or explicit subject/body.",
+      inputSchema: {
+        type: "object",
+        required: ["to"],
+        additionalProperties: false,
+        properties: {
+          to: {},
+          subject: { type: "string" },
+          body: { type: "string" },
+          template: { type: "string" },
+          variables: { type: "object" },
+        },
+      },
+      outputSchema: {
+        type: "object",
+        properties: {
+          messageId: { type: "string" },
+          ok: { type: "boolean" },
+        },
+      },
+      sideEffects: ["email.send"],
+      validate: (config) => {
+        const diagnostics = [];
+        if (config.to === undefined || config.to === null) {
+          diagnostics.push({
+            severity: "error" as const,
+            rule: "email_send_missing_to",
+            message: "dypai.email.send requires config.to.",
+            fixHint: "Use to: { kind: 'input', path: ['email'] } or a literal email address.",
+          });
+        }
+        const hasTemplate = typeof config.template === "string" && config.template.trim().length > 0;
+        const hasBody = typeof config.body === "string" && config.body.trim().length > 0;
+        if (!hasTemplate && !hasBody) {
+          diagnostics.push({
+            severity: "error" as const,
+            rule: "email_send_missing_content",
+            message: "dypai.email.send requires config.template or config.body.",
+            fixHint: "Provide template: 'welcome' or body/subject for a direct email.",
+          });
+        }
+        return diagnostics;
+      },
+    }),
+  },
+});

package/src/registry/nodes/dypaiFlow.ts

@@ -0,0 +1,25 @@
+import { defineNode, defineOperation } from "../defineNode";
+
+export const dypaiFlowNode = defineNode({
+  id: "dypai.flow",
+  version: 1,
+  label: "DYPAI Flow",
+  category: "flow",
+  docs: "Flow control helpers for building endpoint responses.",
+  operations: {
+    return: defineOperation({
+      label: "Return HTTP response",
+      docs: "Marks the public response mapping for the workflow.",
+      inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {},
+      },
+      outputSchema: {
+        type: "object",
+        additionalProperties: true,
+      },
+      sideEffects: ["http.response"],
+    }),
+  },
+});

package/src/registry/nodes/legacyWorkflow.ts

@@ -0,0 +1,27 @@
+import { defineNode, defineOperation } from "../defineNode";
+
+export const legacyWorkflowNode = defineNode({
+  id: "legacy.workflow",
+  version: 1,
+  label: "Legacy Workflow Node",
+  category: "legacy",
+  docs: "Compatibility wrapper for legacy engine nodes not yet represented in Node Registry v2.",
+  operations: {
+    node: defineOperation({
+      label: "Legacy engine node",
+      docs: "Preserves the original legacy node shape for adapter compatibility.",
+      inputSchema: {
+        type: "object",
+        required: ["legacyNode"],
+        properties: {
+          legacyNode: { type: "object" },
+        },
+      },
+      outputSchema: {
+        type: "object",
+        additionalProperties: true,
+      },
+      sideEffects: [],
+    }),
+  },
+});

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "types": ["bun"]
+  },
+  "include": ["src/**/*.ts"]
+}