@gadmin2n/schematics 0.0.96 → 0.0.98

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/workflow-dsl-validate.spec.ts

@@ -0,0 +1,220 @@
+import {
+  validateDslHandles,
+  type NodeOutputsMap,
+  type WorkflowDsl,
+} from './workflow-dsl-validate';
+
+// Test fixture: a small NodeOutputsMap mirroring the live DB seed for the
+// node types we exercise here. Mirrors NODE_TYPE_META used in the worker test.
+const OUTPUTS_MAP: NodeOutputsMap = {
+  if_else: ['true', 'false'],
+  switch: null,
+  cron_trigger: [],
+  manual_trigger: [],
+  webhook_trigger: [],
+  http_request: [],
+};
+
+// ─── helpers ─────────────────────────────────────────────────────────────────
+
+function makeNode(
+  id: string,
+  type: string,
+  config: Record<string, any> = {},
+): WorkflowDsl['nodes'][number] {
+  return { id, type, config };
+}
+
+function makeEdge(
+  id: string,
+  source: string,
+  target: string,
+  sourceHandle?: string,
+): WorkflowDsl['edges'][number] {
+  return sourceHandle === undefined
+    ? { id, source, target }
+    : { id, source, target, sourceHandle };
+}
+
+// ─── if_else (enumerated outputs) ────────────────────────────────────────────
+
+describe('validateDslHandles — if_else', () => {
+  it('accepts sourceHandle "true"', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [makeNode('a', 'if_else'), makeNode('b', 'http_request')],
+      edges: [makeEdge('e1', 'a', 'b', 'true')],
+    };
+    expect(validateDslHandles(dsl, OUTPUTS_MAP)).toEqual([]);
+  });
+
+  it('accepts sourceHandle "false"', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [makeNode('a', 'if_else'), makeNode('b', 'http_request')],
+      edges: [makeEdge('e1', 'a', 'b', 'false')],
+    };
+    expect(validateDslHandles(dsl, OUTPUTS_MAP)).toEqual([]);
+  });
+
+  it('rejects unknown sourceHandle "maybe"', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [makeNode('a', 'if_else'), makeNode('b', 'http_request')],
+      edges: [makeEdge('e1', 'a', 'b', 'maybe')],
+    };
+    const errors = validateDslHandles(dsl, OUTPUTS_MAP);
+    expect(errors).toHaveLength(1);
+    expect(errors[0].edgeId).toBe('e1');
+    expect(errors[0].code).toBe('UNKNOWN_HANDLE');
+    expect(errors[0].reason).toMatch(/not in declared outputs/);
+  });
+
+  it('rejects missing sourceHandle', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [makeNode('a', 'if_else'), makeNode('b', 'http_request')],
+      edges: [makeEdge('e1', 'a', 'b')],
+    };
+    const errors = validateDslHandles(dsl, OUTPUTS_MAP);
+    expect(errors).toHaveLength(1);
+    expect(errors[0].edgeId).toBe('e1');
+    expect(errors[0].code).toBe('MISSING_HANDLE');
+    expect(errors[0].reason).toMatch(/requires a sourceHandle/);
+  });
+
+  it('rejects empty-string sourceHandle as missing', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [makeNode('a', 'if_else'), makeNode('b', 'http_request')],
+      edges: [makeEdge('e1', 'a', 'b', '')],
+    };
+    const errors = validateDslHandles(dsl, OUTPUTS_MAP);
+    expect(errors).toHaveLength(1);
+    expect(errors[0].edgeId).toBe('e1');
+    expect(errors[0].code).toBe('MISSING_HANDLE');
+  });
+});
+
+// ─── cron_trigger (no named outputs) ─────────────────────────────────────────
+
+describe('validateDslHandles — cron_trigger (no named outputs)', () => {
+  it('rejects sourceHandle "foo" on a node with no named handles', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [makeNode('t', 'cron_trigger'), makeNode('a', 'http_request')],
+      edges: [makeEdge('e1', 't', 'a', 'foo')],
+    };
+    const errors = validateDslHandles(dsl, OUTPUTS_MAP);
+    expect(errors).toHaveLength(1);
+    expect(errors[0].edgeId).toBe('e1');
+    expect(errors[0].code).toBe('EXTRA_HANDLE');
+    expect(errors[0].reason).toMatch(/no named output handles/);
+  });
+
+  it('accepts no sourceHandle', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [makeNode('t', 'cron_trigger'), makeNode('a', 'http_request')],
+      edges: [makeEdge('e1', 't', 'a')],
+    };
+    expect(validateDslHandles(dsl, OUTPUTS_MAP)).toEqual([]);
+  });
+
+  it('accepts empty-string sourceHandle (treated as absent for [] nodes)', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [makeNode('t', 'cron_trigger'), makeNode('a', 'http_request')],
+      edges: [makeEdge('e1', 't', 'a', '')],
+    };
+    expect(validateDslHandles(dsl, OUTPUTS_MAP)).toEqual([]);
+  });
+});
+
+// ─── switch (dynamic outputs) ────────────────────────────────────────────────
+
+describe('validateDslHandles — switch (dynamic outputs)', () => {
+  it('accepts sourceHandle matching a case value', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [
+        makeNode('s', 'switch', { cases: [{ value: 'a' }, { value: 'b' }] }),
+        makeNode('x', 'http_request'),
+      ],
+      edges: [makeEdge('e1', 's', 'x', 'a')],
+    };
+    expect(validateDslHandles(dsl, OUTPUTS_MAP)).toEqual([]);
+  });
+
+  it('rejects sourceHandle not in case values', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [
+        makeNode('s', 'switch', { cases: [{ value: 'a' }] }),
+        makeNode('x', 'http_request'),
+      ],
+      edges: [makeEdge('e1', 's', 'x', 'c')],
+    };
+    const errors = validateDslHandles(dsl, OUTPUTS_MAP);
+    expect(errors).toHaveLength(1);
+    expect(errors[0].edgeId).toBe('e1');
+    expect(errors[0].code).toBe('UNKNOWN_HANDLE');
+  });
+
+  it('skips validation when switch config has no cases (in-progress editor)', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [makeNode('s', 'switch'), makeNode('x', 'http_request')],
+      edges: [makeEdge('e1', 's', 'x', 'anything')],
+    };
+    expect(validateDslHandles(dsl, OUTPUTS_MAP)).toEqual([]);
+  });
+});
+
+// ─── out-of-scope (orphan / unknown) ────────────────────────────────────────
+
+describe('validateDslHandles — out-of-scope', () => {
+  it('ignores edge referencing missing source node', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [makeNode('b', 'http_request')],
+      edges: [makeEdge('e1', 'ghost', 'b', 'true')],
+    };
+    expect(validateDslHandles(dsl, OUTPUTS_MAP)).toEqual([]);
+  });
+
+  it('ignores edges from unknown node types', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [
+        makeNode('u', 'wholly_made_up_type'),
+        makeNode('b', 'http_request'),
+      ],
+      edges: [makeEdge('e1', 'u', 'b', 'whatever')],
+    };
+    expect(validateDslHandles(dsl, OUTPUTS_MAP)).toEqual([]);
+  });
+});
+
+// ─── multiple errors collected ──────────────────────────────────────────────
+
+describe('validateDslHandles — multiple errors', () => {
+  it('collects every error in one pass', () => {
+    const dsl: WorkflowDsl = {
+      nodes: [
+        makeNode('if', 'if_else'),
+        makeNode('cron', 'cron_trigger'),
+        makeNode('sw', 'switch', { cases: [{ value: 'a' }] }),
+        makeNode('x', 'http_request'),
+      ],
+      edges: [
+        makeEdge('e1', 'if', 'x', 'maybe'), // bad enumerated
+        makeEdge('e2', 'if', 'x'), // missing required
+        makeEdge('e3', 'cron', 'x', 'foo'), // forbidden handle
+        makeEdge('e4', 'sw', 'x', 'c'), // bad dynamic
+      ],
+    };
+    const errors = validateDslHandles(dsl, OUTPUTS_MAP);
+    expect(errors).toHaveLength(4);
+    expect(errors.map((e) => e.edgeId).sort()).toEqual([
+      'e1',
+      'e2',
+      'e3',
+      'e4',
+    ]);
+    const byEdge = Object.fromEntries(errors.map((e) => [e.edgeId, e.code]));
+    expect(byEdge).toEqual({
+      e1: 'UNKNOWN_HANDLE',
+      e2: 'MISSING_HANDLE',
+      e3: 'EXTRA_HANDLE',
+      e4: 'UNKNOWN_HANDLE',
+    });
+  });
+});

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/workflow-dsl-validate.ts

@@ -0,0 +1,129 @@
+/**
+ * DSL handle validator (server-side).
+ *
+ * Mirrors temporal/worker/src/dsl/validate.ts but is independent:
+ * - reads node-type outputs from a passed-in map (caller fetches from DB)
+ * - returns the same DslValidationCode discriminator for FE compatibility
+ *
+ * Why duplicated rather than imported from worker: server and worker are
+ * separate projects without a shared package; cross-project imports would
+ * break tsc paths and Docker build.
+ */
+
+export type DslValidationCode =
+  | 'EXTRA_HANDLE' // node has [] outputs, but edge set sourceHandle
+  | 'MISSING_HANDLE' // node has named outputs, but edge has no sourceHandle (or empty string)
+  | 'UNKNOWN_HANDLE'; // edge sourceHandle is set but ∉ declared outputs
+
+export interface DslValidationError {
+  edgeId: string;
+  source: string;
+  target: string;
+  code: DslValidationCode;
+  reason: string;
+}
+
+export interface DslNode {
+  id: string;
+  type: string;
+  config?: Record<string, any>;
+}
+
+export interface DslEdge {
+  id: string;
+  source: string;
+  target: string;
+  sourceHandle?: string;
+}
+
+export interface WorkflowDsl {
+  nodes: DslNode[];
+  edges: DslEdge[];
+}
+
+/**
+ * Map from node type name -> outputs declaration.
+ *
+ *  - null:        dynamic (e.g. switch — derived from node.config)
+ *  - []:          single anonymous output, no sourceHandle allowed
+ *  - ['a','b',…]: enumerated named outputs; sourceHandle MUST be one of them
+ *  - undefined:   unknown type; validator skips edges from such nodes
+ */
+export type NodeOutputsMap = Record<string, string[] | null>;
+
+/**
+ * Validate every edge's sourceHandle against the source node's outputs metadata.
+ * Returns an array of errors (empty if DSL is valid).
+ */
+export function validateDslHandles(
+  dsl: WorkflowDsl,
+  outputsMap: NodeOutputsMap,
+): DslValidationError[] {
+  const errors: DslValidationError[] = [];
+  const nodeMap = new Map<string, DslNode>(dsl.nodes.map((n) => [n.id, n]));
+
+  for (const edge of dsl.edges) {
+    const src = nodeMap.get(edge.source);
+    if (!src) continue; // separate concern: orphan edge — not this validator's job
+    if (!(src.type in outputsMap)) continue; // unknown node type — out of scope
+
+    const declared = outputsMap[src.type];
+    const handles =
+      declared === null ? deriveDynamicOutputs(src) : declared;
+
+    // Empty named-handle list AND declared-non-null => no sourceHandle allowed
+    if (declared !== null && handles.length === 0) {
+      if (edge.sourceHandle != null && edge.sourceHandle !== '') {
+        errors.push({
+          edgeId: edge.id,
+          source: edge.source,
+          target: edge.target,
+          code: 'EXTRA_HANDLE',
+          reason: `Node "${src.type}" has no named output handles; edge must not set sourceHandle (got "${edge.sourceHandle}").`,
+        });
+      }
+      continue;
+    }
+
+    // Dynamic + still-empty (e.g. switch with no cases): in-progress, skip
+    if (handles.length === 0) continue;
+
+    if (edge.sourceHandle == null || edge.sourceHandle === '') {
+      errors.push({
+        edgeId: edge.id,
+        source: edge.source,
+        target: edge.target,
+        code: 'MISSING_HANDLE',
+        reason: `Node "${src.type}" requires a sourceHandle; choose one of: ${handles.join(', ')}.`,
+      });
+      continue;
+    }
+
+    if (!handles.includes(edge.sourceHandle)) {
+      errors.push({
+        edgeId: edge.id,
+        source: edge.source,
+        target: edge.target,
+        code: 'UNKNOWN_HANDLE',
+        reason: `Node "${src.type}" sourceHandle "${edge.sourceHandle}" is not in declared outputs: ${handles.join(', ')}.`,
+      });
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * For dynamic-output nodes (currently just `switch`), derive the list of
+ * handle ids from the node's config.
+ */
+function deriveDynamicOutputs(node: DslNode): string[] {
+  if (node.type === 'switch') {
+    const cases = node.config?.cases as Array<{ value?: string }> | undefined;
+    if (!Array.isArray(cases)) return [];
+    return cases
+      .map((c) => c?.value)
+      .filter((v): v is string => typeof v === 'string' && v.length > 0);
+  }
+  return [];
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/workflow-export.dto.ts

@@ -33,6 +33,7 @@ export interface ExportPayload {
     configSchema: any;
     inputSchema: any;
     outputSchema: any;
+    outputs: any;
     isBuiltin: boolean;
   }>;
 }

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/workflow-export.service.ts

@@ -129,6 +129,7 @@ export class WorkflowExportService {
         configSchema: nt.configSchema as any,
         inputSchema: nt.inputSchema as any,
         outputSchema: nt.outputSchema as any,
+        outputs: nt.outputs as any,
         isBuiltin: nt.isBuiltin,
       })),
     };
@@ -193,6 +194,7 @@ export class WorkflowExportService {
             configSchema: nt.configSchema as any,
             inputSchema: nt.inputSchema as any,
             outputSchema: nt.outputSchema as any,
+            outputs: nt.outputs as any,
             isBuiltin: nt.isBuiltin,
           })),
         }
@@ -224,6 +226,7 @@ export class WorkflowExportService {
             configSchema: nt.configSchema,
             inputSchema: nt.inputSchema,
             outputSchema: nt.outputSchema,
+            outputs: nt.outputs,
             isBuiltin: nt.isBuiltin,
             creator,
           },
@@ -235,6 +238,7 @@ export class WorkflowExportService {
             configSchema: nt.configSchema,
             inputSchema: nt.inputSchema,
             outputSchema: nt.outputSchema,
+            outputs: nt.outputs,
           },
         });
       }

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/workflow.service.spec.ts

@@ -22,6 +22,16 @@ describe('WorkflowService — cron lifecycle hooks', () => {
         findFirst: jest.fn(),
         create: jest.fn(),
       },
+      workflowNodeType: {
+        findMany: jest.fn().mockResolvedValue([
+          { type: 'cron_trigger', outputs: [] },
+          { type: 'manual_trigger', outputs: [] },
+          { type: 'webhook_trigger', outputs: [] },
+          { type: 'http_request', outputs: [] },
+          { type: 'if_else', outputs: ['true', 'false'] },
+          { type: 'switch', outputs: null },
+        ]),
+      },
       $transaction: jest.fn(async (cb: any) =>
         cb({
           workflowVersion: {
@@ -197,6 +207,42 @@ describe('WorkflowService — cron lifecycle hooks', () => {
         service.publish(ID, { changeSummary: 'init' }, 'tester'),
       ).resolves.toBeDefined();
     });
+
+    it('rejects with 400 BadRequestException when DSL has invalid sourceHandle', async () => {
+      // if_else node has enumerated outputs ['true','false']; sending 'maybe'
+      // must trigger the new sourceHandle validator and produce a 400 with a
+      // structured error payload the frontend can use to highlight bad edges.
+      const dsl = {
+        nodes: [
+          { id: 't1', type: 'manual_trigger', config: {} },
+          { id: 'if1', type: 'if_else', config: {} },
+          { id: 'h1', type: 'http_request', config: {} },
+        ],
+        edges: [
+          { id: 'e1', source: 't1', target: 'if1' },
+          { id: 'e2', source: 'if1', target: 'h1', sourceHandle: 'maybe' },
+        ],
+      };
+      prisma.workflow.findUnique.mockResolvedValueOnce(mkWorkflow(dsl));
+
+      await expect(
+        service.publish(ID, { changeSummary: 'init' }, 'tester'),
+      ).rejects.toMatchObject({
+        status: 400,
+        response: expect.objectContaining({
+          code: 'DSL_HANDLE_VALIDATION',
+          errors: expect.arrayContaining([
+            expect.objectContaining({
+              edgeId: 'e2',
+              code: 'UNKNOWN_HANDLE',
+            }),
+          ]),
+        }),
+      });
+
+      // Status flip must NOT have happened
+      expect(prisma.workflow.update).not.toHaveBeenCalled();
+    });
   });
 
   describe('toggleEnabled', () => {

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/workflow.service.ts

@@ -10,6 +10,10 @@ import { PrismaService } from 'nestjs-prisma';
 import { validateDslGraph } from './dsl-validate.util';
 import { TemporalService } from './temporal.service';
 import { verifyWebhookSignature } from './webhook-signature.util';
+import {
+  validateDslHandles,
+  type NodeOutputsMap,
+} from './workflow-dsl-validate';
 
 @Injectable()
 export class WorkflowService {
@@ -285,6 +289,29 @@ export class WorkflowService {
       throw new BadRequestException(`Invalid DSL: ${err?.message ?? err}`);
     }
 
+    // Per-edge sourceHandle validation against node-type outputs declared in the
+    // database (t_workflow_node_type.outputs). Hard-fail with a structured error
+    // list so the frontend can highlight invalid edges.
+    const nodeTypes = await this.prisma.workflowNodeType.findMany({
+      select: { type: true, outputs: true },
+    });
+    const outputsMap: NodeOutputsMap = {};
+    for (const nt of nodeTypes) {
+      // Pass through: null = dynamic, [] = single anonymous, [..] = enumerated
+      outputsMap[nt.type] =
+        nt.outputs === undefined
+          ? []
+          : (nt.outputs as unknown as string[] | null);
+    }
+    const handleErrors = validateDslHandles(dslToPublish as any, outputsMap);
+    if (handleErrors.length > 0) {
+      throw new BadRequestException({
+        message: 'DSL validation failed: invalid edge sourceHandle(s)',
+        code: 'DSL_HANDLE_VALIDATION',
+        errors: handleErrors,
+      });
+    }
+
     // Validate webhook path collisions across other published workflows
     const webhookConfigs = this.extractWebhookConfigs(dslToPublish);
     if (webhookConfigs.length > 0) {

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflowNodeType/workflowNodeType.service.spec.ts

@@ -78,6 +78,7 @@ describe('WorkflowNodeTypeService', () => {
           configSchema: {},
           inputSchema: {},
           outputSchema: {},
+          outputs: [],
           description: 'test_description',
           isBuiltin: true,
         },
@@ -103,6 +104,7 @@ describe('WorkflowNodeTypeService', () => {
           configSchema: {},
           inputSchema: {},
           outputSchema: {},
+          outputs: [],
           description: 'test_description',
           isBuiltin: true,
         },
@@ -128,6 +130,7 @@ describe('WorkflowNodeTypeService', () => {
           configSchema: {},
           inputSchema: {},
           outputSchema: {},
+          outputs: [],
           description: 'test_description',
           isBuiltin: true,
         },
@@ -139,6 +142,7 @@ describe('WorkflowNodeTypeService', () => {
           configSchema: {},
           inputSchema: {},
           outputSchema: {},
+          outputs: [],
           description: 'test_description',
           isBuiltin: true,
         },
@@ -230,6 +234,7 @@ describe('WorkflowNodeTypeService', () => {
         configSchema: {},
         inputSchema: {},
         outputSchema: {},
+        outputs: [],
         description: 'test_description',
         isBuiltin: true,
       } as any;
@@ -259,6 +264,7 @@ describe('WorkflowNodeTypeService', () => {
           configSchema: {},
           inputSchema: {},
           outputSchema: {},
+          outputs: [],
           description: 'test_description',
           isBuiltin: true,
         },

package/dist/lib/application/files/gadmin2-game-angle-demo/temporal/worker/src/dsl/node-types.ts

@@ -1,9 +1,27 @@
 /**
- * Canonical list of all workflow node types.
+ * Node type metadata. Source of truth for which node types exist and
+ * what handle ids each one declares.
  *
- * This is the SINGLE SOURCE OF TRUTH for node type strings.
- * When you add a new type here, TypeScript will force you to handle it
- * in the executeNode() switch — otherwise the build fails.
+ * outputs semantics:
+ *   null      = dynamic (handles derived from config at render/validate time, e.g. switch)
+ *   []        = single anonymous source (no named sourceHandle on outgoing edges)
+ *   ['a','b'] = enumerated named handles (each outgoing edge MUST have sourceHandle ∈ outputs)
+ *
+ * MUST stay in sync with server/seed/workflow-node-types.ts and the
+ * t_workflow_node_type.outputs column. Validators read this map.
+ */
+export interface NodeTypeMeta {
+  outputs: string[] | null;
+}
+
+/**
+ * Canonical tuple of all workflow node types.
+ *
+ * Preserved as an `as const` tuple (in addition to NODE_TYPE_META below)
+ * so that consumers like DslNode.type and the executeNode switch keep
+ * compile-time literal-union types and exhaustiveness checks.
+ *
+ * The order and contents MUST match the keys of NODE_TYPE_META.
  */
 export const ALL_NODE_TYPES = [
   // TRIGGER
@@ -36,6 +54,27 @@ export const ALL_NODE_TYPES = [
 /** Union of all supported node type strings. */
 export type NodeType = (typeof ALL_NODE_TYPES)[number];
 
+export const NODE_TYPE_META: Record<NodeType, NodeTypeMeta> = {
+  cron_trigger:      { outputs: [] },
+  webhook_trigger:   { outputs: [] },
+  event_trigger:     { outputs: [] },
+  manual_trigger:    { outputs: [] },
+  http_request:      { outputs: [] },
+  db_query:          { outputs: [] },
+  db_execute:        { outputs: [] },
+  send_notification: { outputs: [] },
+  code:              { outputs: [] },
+  set_variable:      { outputs: [] },
+  if_else:           { outputs: ['true', 'false'] },
+  switch:            { outputs: null },
+  for_each:          { outputs: [] },
+  delay:             { outputs: [] },
+  parallel:          { outputs: [] },
+  error_handler:     { outputs: [] },
+  approval:          { outputs: [] },
+  sub_workflow:      { outputs: [] },
+};
+
 /** Node types that require a Temporal activity call. */
 export const ACTIVITY_NODE_TYPES = [
   'http_request',