orcheo-canvas 0.0.1

package/src/features/workflow/pages/workflow-canvas/helpers/node-identity.ts

@@ -0,0 +1,157 @@
+import type { CanvasNode, NodeData } from "./types";
+
+const PERSISTED_NODE_FIELDS = new Set([
+  "label",
+  "description",
+  "type",
+  "isDisabled",
+]);
+
+export const DEFAULT_NODE_LABEL = "New Node";
+
+const normaliseLabelInput = (value: unknown): string => {
+  if (typeof value !== "string") {
+    return "";
+  }
+
+  return value.trim();
+};
+
+export const sanitizeLabel = (
+  value: unknown,
+  fallback = DEFAULT_NODE_LABEL,
+): string => {
+  const normalised = normaliseLabelInput(value);
+  return normalised.length > 0 ? normalised : fallback;
+};
+
+export const slugifyLabel = (label: string): string => {
+  return label
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+};
+
+export const buildExistingNameSet = (
+  nodes: CanvasNode[],
+  excludeId?: string,
+): Set<string> => {
+  const names = new Set<string>();
+  for (const node of nodes) {
+    if (excludeId && node.id === excludeId) {
+      continue;
+    }
+    const label = sanitizeLabel(
+      (node.data?.label as string) ?? node.id ?? DEFAULT_NODE_LABEL,
+    );
+    names.add(label.toLowerCase());
+  }
+  return names;
+};
+
+export const buildExistingIdSet = (
+  nodes: CanvasNode[],
+  excludeId?: string,
+): Set<string> => {
+  const ids = new Set<string>();
+  for (const node of nodes) {
+    if (excludeId && node.id === excludeId) {
+      continue;
+    }
+    ids.add(node.id);
+  }
+  return ids;
+};
+
+export const assignUniqueIdentity = (
+  desiredLabel: string,
+  nameSet: Set<string>,
+  idSet: Set<string>,
+) => {
+  const baseLabel = sanitizeLabel(desiredLabel);
+  let candidateLabel = baseLabel;
+  let attempt = 2;
+  while (nameSet.has(candidateLabel.toLowerCase())) {
+    candidateLabel = `${baseLabel} (${attempt})`;
+    attempt += 1;
+  }
+  nameSet.add(candidateLabel.toLowerCase());
+
+  const baseSlug = slugifyLabel(candidateLabel) || "node";
+  let candidateId = baseSlug;
+  attempt = 2;
+  while (idSet.has(candidateId)) {
+    candidateId = `${baseSlug}-${attempt}`;
+    attempt += 1;
+  }
+  idSet.add(candidateId);
+
+  return { id: candidateId, label: candidateLabel };
+};
+
+export const createIdentityAllocator = (
+  nodes: CanvasNode[],
+  options: { excludeId?: string } = {},
+) => {
+  const nameSet = buildExistingNameSet(nodes, options.excludeId);
+  const idSet = buildExistingIdSet(nodes, options.excludeId);
+  return (desiredLabel: string) =>
+    assignUniqueIdentity(desiredLabel, nameSet, idSet);
+};
+
+export const sanitizeNodeDataForPersist = (
+  data?: NodeData,
+): Record<string, unknown> => {
+  const sanitized: Record<string, unknown> = {
+    label:
+      typeof data?.label === "string"
+        ? data.label
+        : data?.label !== undefined
+          ? String(data.label)
+          : DEFAULT_NODE_LABEL,
+  };
+
+  if (typeof data?.description === "string") {
+    sanitized.description = data.description;
+  }
+
+  if (typeof data?.type === "string") {
+    sanitized.type = data.type;
+  }
+
+  if (typeof data?.isDisabled === "boolean") {
+    sanitized.isDisabled = data.isDisabled;
+  }
+
+  Object.entries(data ?? {}).forEach(([key, value]) => {
+    if (PERSISTED_NODE_FIELDS.has(key)) {
+      return;
+    }
+
+    if (
+      value === null ||
+      typeof value === "string" ||
+      typeof value === "number" ||
+      typeof value === "boolean"
+    ) {
+      sanitized[key] = value;
+      return;
+    }
+
+    if (Array.isArray(value)) {
+      sanitized[key] = value;
+      return;
+    }
+
+    if (
+      typeof value === "object" &&
+      value !== null &&
+      !(value as { $$typeof?: unknown }).$$typeof
+    ) {
+      sanitized[key] = value;
+    }
+  });
+
+  return sanitized;
+};

package/src/features/workflow/pages/workflow-canvas/helpers/runtime-cache.ts

@@ -0,0 +1,70 @@
+const NODE_RUNTIME_CACHE_PREFIX = "orcheo:workflow-runtime-cache:";
+
+export const getRuntimeCacheStorageKey = (
+  workflowId?: string | null,
+): string => {
+  return `${NODE_RUNTIME_CACHE_PREFIX}${workflowId ?? "unsaved"}`;
+};
+
+export const readRuntimeCacheFromSession = <
+  TValue extends Record<string, unknown>,
+>(
+  key: string,
+): TValue => {
+  if (typeof window === "undefined" || !window.sessionStorage) {
+    return {} as TValue;
+  }
+
+  const raw = window.sessionStorage.getItem(key);
+  if (!raw) {
+    return {} as TValue;
+  }
+
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object") {
+      return parsed as TValue;
+    }
+  } catch (error) {
+    console.warn(
+      "Failed to parse node runtime cache from sessionStorage",
+      error,
+    );
+  }
+
+  return {} as TValue;
+};
+
+export const persistRuntimeCacheToSession = <
+  TValue extends Record<string, unknown>,
+>(
+  key: string,
+  cache: TValue,
+) => {
+  if (typeof window === "undefined" || !window.sessionStorage) {
+    return;
+  }
+
+  if (Object.keys(cache).length === 0) {
+    window.sessionStorage.removeItem(key);
+    return;
+  }
+
+  try {
+    const serialized = JSON.stringify(cache);
+    window.sessionStorage.setItem(key, serialized);
+  } catch (error) {
+    console.warn(
+      "Failed to persist node runtime cache to sessionStorage",
+      error,
+    );
+  }
+};
+
+export const clearRuntimeCacheFromSession = (key: string) => {
+  if (typeof window === "undefined" || !window.sessionStorage) {
+    return;
+  }
+
+  window.sessionStorage.removeItem(key);
+};

package/src/features/workflow/pages/workflow-canvas/helpers/sticky-notes.ts

@@ -0,0 +1,52 @@
+import type {
+  StickyNoteColor,
+  StickyNoteNodeData,
+} from "@features/workflow/components/nodes/sticky-note-node";
+
+export const STICKY_NOTE_COLORS: StickyNoteColor[] = [
+  "yellow",
+  "pink",
+  "blue",
+  "green",
+  "purple",
+];
+
+export const DEFAULT_STICKY_NOTE_COLOR: StickyNoteColor = "yellow";
+export const DEFAULT_STICKY_NOTE_CONTENT = "Leave a note for collaborators";
+export const STICKY_NOTE_MIN_WIDTH = 180;
+export const STICKY_NOTE_MIN_HEIGHT = 150;
+export const DEFAULT_STICKY_NOTE_WIDTH = 240;
+export const DEFAULT_STICKY_NOTE_HEIGHT = 200;
+
+export const isStickyNoteColor = (value: unknown): value is StickyNoteColor => {
+  return (
+    typeof value === "string" &&
+    (STICKY_NOTE_COLORS as readonly string[]).includes(value)
+  );
+};
+
+export const clampStickyDimension = (value: number, minimum: number) => {
+  if (Number.isNaN(value) || !Number.isFinite(value)) {
+    return minimum;
+  }
+
+  return Math.max(minimum, Math.round(value));
+};
+
+export const sanitizeStickyNoteDimension = (
+  value: unknown,
+  fallback: number,
+  minimum: number,
+) => {
+  if (typeof value === "number") {
+    return clampStickyDimension(value, minimum);
+  }
+
+  return clampStickyDimension(fallback, minimum);
+};
+
+export const sanitizeStickyNoteContent = (value: unknown) => {
+  return typeof value === "string" ? value : DEFAULT_STICKY_NOTE_CONTENT;
+};
+
+export type { StickyNoteColor, StickyNoteNodeData };

package/src/features/workflow/pages/workflow-canvas/helpers/subworkflow-library.ts

@@ -0,0 +1,12 @@
+import { contentQaSubworkflow } from "./subworkflows/content-qa";
+import { customerOnboardingSubworkflow } from "./subworkflows/customer-onboarding";
+import { incidentResponseSubworkflow } from "./subworkflows/incident-response";
+import type { SubworkflowStructure } from "./subworkflows/types";
+
+export const SUBWORKFLOW_LIBRARY: Record<string, SubworkflowStructure> = {
+  "subflow-customer-onboarding": customerOnboardingSubworkflow,
+  "subflow-incident-response": incidentResponseSubworkflow,
+  "subflow-content-qa": contentQaSubworkflow,
+};
+
+export type { SubworkflowStructure };

package/src/features/workflow/pages/workflow-canvas/helpers/subworkflows/content-qa.ts

@@ -0,0 +1,88 @@
+import type { SubworkflowStructure } from "./types";
+
+export const contentQaSubworkflow: SubworkflowStructure = {
+  nodes: [
+    {
+      id: "draft-ready",
+      type: "trigger",
+      position: { x: 0, y: 0 },
+      data: {
+        type: "trigger",
+        label: "Draft ready for review",
+        description: "Start QA once an AI draft is submitted.",
+        status: "idle",
+      },
+    },
+    {
+      id: "score-quality",
+      type: "ai",
+      position: { x: 260, y: 0 },
+      data: {
+        type: "ai",
+        label: "Score quality",
+        description: "Use AI rubric to score voice, tone, and accuracy.",
+        status: "idle",
+      },
+    },
+    {
+      id: "collect-feedback",
+      type: "function",
+      position: { x: 520, y: -120 },
+      data: {
+        type: "function",
+        label: "Collect revisions",
+        description: "Request edits from stakeholders when needed.",
+        status: "idle",
+      },
+    },
+    {
+      id: "schedule-publish",
+      type: "api",
+      position: { x: 520, y: 120 },
+      data: {
+        type: "api",
+        label: "Schedule publish",
+        description: "Queue approved content in the CMS calendar.",
+        status: "idle",
+      },
+    },
+    {
+      id: "final-approval",
+      type: "function",
+      position: { x: 780, y: 0 },
+      data: {
+        type: "function",
+        label: "Finalize and log",
+        description: "Capture QA notes and mark the run complete.",
+        status: "idle",
+      },
+    },
+  ],
+  edges: [
+    {
+      id: "edge-draft-score",
+      source: "draft-ready",
+      target: "score-quality",
+    },
+    {
+      id: "edge-score-feedback",
+      source: "score-quality",
+      target: "collect-feedback",
+    },
+    {
+      id: "edge-score-schedule",
+      source: "score-quality",
+      target: "schedule-publish",
+    },
+    {
+      id: "edge-feedback-final",
+      source: "collect-feedback",
+      target: "final-approval",
+    },
+    {
+      id: "edge-schedule-final",
+      source: "schedule-publish",
+      target: "final-approval",
+    },
+  ],
+};

package/src/features/workflow/pages/workflow-canvas/helpers/subworkflows/customer-onboarding.ts

@@ -0,0 +1,67 @@
+import type { SubworkflowStructure } from "./types";
+
+export const customerOnboardingSubworkflow: SubworkflowStructure = {
+  nodes: [
+    {
+      id: "capture-intake",
+      type: "trigger",
+      position: { x: 0, y: 0 },
+      data: {
+        type: "trigger",
+        label: "Capture intake request",
+        description: "Webhook triggered when a signup is submitted.",
+        status: "idle",
+      },
+    },
+    {
+      id: "enrich-profile",
+      type: "function",
+      position: { x: 260, y: 0 },
+      data: {
+        type: "function",
+        label: "Enrich CRM profile",
+        description: "Collect firmographic data for the new customer.",
+        status: "idle",
+      },
+    },
+    {
+      id: "provision-access",
+      type: "api",
+      position: { x: 520, y: 0 },
+      data: {
+        type: "api",
+        label: "Provision access",
+        description: "Create accounts across internal and SaaS tools.",
+        status: "idle",
+      },
+    },
+    {
+      id: "send-welcome",
+      type: "api",
+      position: { x: 780, y: 0 },
+      data: {
+        type: "api",
+        label: "Send welcome sequence",
+        description: "Kick off emails, docs, and success team handoff.",
+        status: "idle",
+      },
+    },
+  ],
+  edges: [
+    {
+      id: "edge-capture-enrich",
+      source: "capture-intake",
+      target: "enrich-profile",
+    },
+    {
+      id: "edge-enrich-provision",
+      source: "enrich-profile",
+      target: "provision-access",
+    },
+    {
+      id: "edge-provision-welcome",
+      source: "provision-access",
+      target: "send-welcome",
+    },
+  ],
+};

package/src/features/workflow/pages/workflow-canvas/helpers/subworkflows/incident-response.ts

@@ -0,0 +1,88 @@
+import type { SubworkflowStructure } from "./types";
+
+export const incidentResponseSubworkflow: SubworkflowStructure = {
+  nodes: [
+    {
+      id: "incident-raised",
+      type: "trigger",
+      position: { x: 0, y: 0 },
+      data: {
+        type: "trigger",
+        label: "PagerDuty incident raised",
+        description: "Triggered when a Sev1 alert fires.",
+        status: "idle",
+      },
+    },
+    {
+      id: "triage-severity",
+      type: "function",
+      position: { x: 260, y: 0 },
+      data: {
+        type: "function",
+        label: "Triage severity",
+        description: "Evaluate runbooks and required responders.",
+        status: "idle",
+      },
+    },
+    {
+      id: "notify-oncall",
+      type: "api",
+      position: { x: 520, y: -120 },
+      data: {
+        type: "api",
+        label: "Notify on-call",
+        description: "Post critical details into the on-call channel.",
+        status: "idle",
+      },
+    },
+    {
+      id: "escalate-leads",
+      type: "api",
+      position: { x: 520, y: 120 },
+      data: {
+        type: "api",
+        label: "Escalate to leads",
+        description: "Escalate if no acknowledgement within SLA.",
+        status: "idle",
+      },
+    },
+    {
+      id: "update-status",
+      type: "function",
+      position: { x: 780, y: 0 },
+      data: {
+        type: "function",
+        label: "Update status page",
+        description: "Publish current impact for stakeholders.",
+        status: "idle",
+      },
+    },
+  ],
+  edges: [
+    {
+      id: "edge-raised-triage",
+      source: "incident-raised",
+      target: "triage-severity",
+    },
+    {
+      id: "edge-triage-notify",
+      source: "triage-severity",
+      target: "notify-oncall",
+    },
+    {
+      id: "edge-triage-escalate",
+      source: "triage-severity",
+      target: "escalate-leads",
+    },
+    {
+      id: "edge-notify-update",
+      source: "notify-oncall",
+      target: "update-status",
+    },
+    {
+      id: "edge-escalate-update",
+      source: "escalate-leads",
+      target: "update-status",
+    },
+  ],
+};

package/src/features/workflow/pages/workflow-canvas/helpers/subworkflows/types.ts

@@ -0,0 +1,9 @@
+import type {
+  WorkflowEdge as PersistedWorkflowEdge,
+  WorkflowNode as PersistedWorkflowNode,
+} from "@features/workflow/data/workflow-data";
+
+export type SubworkflowStructure = {
+  nodes: PersistedWorkflowNode[];
+  edges: PersistedWorkflowEdge[];
+};