@teleporthq/teleport-plugin-next-workflows 0.43.30 → 0.43.32

package/src/graph-utils.ts

@@ -23,6 +23,27 @@ export const getEdgesTo = (nodeId: string, edges: UIDLWorkflowEdge[]): UIDLWorkf
   return edges.filter((e) => e.target === nodeId)
 }
 
+/**
+ * Recursively collect every workflow-context node id a config references, i.e.
+ * the ids inside `{ type: 'workflowContext', nodeId: '<id>', path: [...] }`
+ * objects embedded anywhere in a node's config (filter values, column mappings,
+ * loop collections, custom-js params, …).
+ */
+export const collectWorkflowContextNodeIds = (value: unknown, out: Set<string>): void => {
+  if (!value || typeof value !== 'object') {
+    return
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item) => collectWorkflowContextNodeIds(item, out))
+    return
+  }
+  const record = value as Record<string, unknown>
+  if (record.type === 'workflowContext' && typeof record.nodeId === 'string') {
+    out.add(record.nodeId)
+  }
+  Object.values(record).forEach((child) => collectWorkflowContextNodeIds(child, out))
+}
+
 export const getTopologicalOrder = (
   nodes: UIDLWorkflowNode[],
   edges: UIDLWorkflowEdge[]
@@ -44,6 +65,37 @@ export const getTopologicalOrder = (
     }
   })
 
+  // Virtual dependency edges from IMPLICIT data dependencies: a node that
+  // consumes another node's output via a `workflowContext` reference in its
+  // config MUST run after that node, even when no explicit edge wires them.
+  // Without this, a `data-create-item` that reads a `state-get-local-state`
+  // result only through its columnMappings is treated as in-degree 0 and can be
+  // ordered (and segmented) BEFORE the state read — so on the server it writes
+  // null for that column (run 0a5f554e: `titles.type_field` NOT-NULL violation;
+  // the "Add Asset" draft rows came through as "N/A" for the same reason).
+  // Control-flow nodes (loop/if/switch/parallel) are skipped — their outputs
+  // (e.g. a loop's `currentItem`) are scoped by dedicated edge handles, not a
+  // linear data dependency. Edges are added to this LOCAL graph only (never to
+  // `workflow.edges`), so loop/branch extraction elsewhere is unaffected.
+  const nodeTypeById = new Map(nodes.map((n) => [n.id, n.type]))
+  nodes.forEach((node) => {
+    const referencedIds = new Set<string>()
+    collectWorkflowContextNodeIds(node.config, referencedIds)
+    referencedIds.forEach((refId) => {
+      if (refId === node.id || !nodeIds.has(refId)) {
+        return
+      }
+      if (isControlFlowNode(nodeTypeById.get(refId) || '')) {
+        return
+      }
+      if (adjacency[refId].includes(node.id)) {
+        return
+      }
+      adjacency[refId].push(node.id)
+      inDegree[node.id]++
+    })
+  })
+
   const queue: string[] = []
   nodeIdArr.forEach((id) => {
     if (inDegree[id] === 0) {

package/src/nodes/data/data-count.ts

@@ -6,8 +6,9 @@ async function data_count(config: any, context: any) {
   const filters = config.filters || []
   const baseUrl = (context && context.__baseUrl) || ''
 
-  // Unresolved route-param sentinel in a filter → validation error (see
-  // resolveTemplateTokenString in runtime-utils) instead of counting nothing.
+  // Unresolved route-param sentinel in a filter (see resolveTemplateTokenString
+  // in runtime-utils). DEGRADE: return count:0 WITHOUT an `error` so the executor
+  // does not throw and abort the whole workflow.
   for (let __fi = 0; __fi < filters.length; __fi++) {
     const __f: any = filters[__fi]
     if (
@@ -16,13 +17,14 @@ async function data_count(config: any, context: any) {
         __f.destination === '__TQ_UNRESOLVED_ROUTE_PARAM__')
     ) {
       const __col = __f.column || __f.source || __f.field || 'unknown'
-      return {
-        count: 0,
-        error:
-          'Filter on "' +
-          __col +
-          '" requires the page route parameter, which is not available in this context',
+      if (typeof console !== 'undefined' && console.warn) {
+        console.warn(
+          '[workflow] data-count skipped — filter on "' +
+            __col +
+            '" needs a page route param not available here; count 0 (workflow continues)'
+        )
       }
+      return { count: 0, __skippedUnavailableFilter: true }
     }
   }
 

package/src/nodes/data/data-delete-item.ts

@@ -17,16 +17,19 @@ async function data_delete_item(config: any, context: any) {
       (__f.value === '__TQ_UNRESOLVED_ROUTE_PARAM__' ||
         __f.destination === '__TQ_UNRESOLVED_ROUTE_PARAM__')
     ) {
+      // DEGRADE to a NO-OP: return deletedCount:0 WITHOUT `error` and WITHOUT
+      // success:false so the executor does not throw and abort the whole
+      // workflow. A DELETE must NEVER drop the filter and run unscoped (that
+      // would delete every row) — no-op is the only safe degrade.
       const __col = __f.column || __f.source || __f.field || 'unknown'
-      return {
-        deletedId: null,
-        success: false,
-        deletedCount: 0,
-        error:
-          'Filter on "' +
-          __col +
-          '" requires the page route parameter, which is not available in this context',
+      if (typeof console !== 'undefined' && console.warn) {
+        console.warn(
+          '[workflow] data-delete-item skipped (no-op) — filter on "' +
+            __col +
+            '" needs a page route param not available here; nothing deleted (workflow continues)'
+        )
       }
+      return { deletedId: null, success: true, deletedCount: 0, __skippedUnavailableFilter: true }
     }
   }
 

package/src/nodes/data/data-select.ts

@@ -12,8 +12,13 @@ async function data_select(config: any, context: any) {
   const baseUrl = (context && context.__baseUrl) || ''
 
   // A filter whose value is the unresolved route-param sentinel (see
-  // resolveTemplateTokenString in runtime-utils) must fail loudly instead of
-  // querying 'WHERE col = <sentinel>' and silently returning 0 rows.
+  // resolveTemplateTokenString in runtime-utils) — e.g. a select scoped to
+  // {{Current Page Entity.id}} that runs on a page with no such route param
+  // (a create page, or a mis-generated filter). DEGRADE GRACEFULLY: return an
+  // empty result WITHOUT an `error` so the executor does not throw and abort the
+  // WHOLE workflow (a single unresolvable filter must never kill the note-create
+  // submit). Never fall through to an unscoped query. Observable via the warn +
+  // the __skippedUnavailableFilter marker.
   for (let __fi = 0; __fi < filters.length; __fi++) {
     const __f: any = filters[__fi]
     if (
@@ -22,14 +27,14 @@ async function data_select(config: any, context: any) {
         __f.destination === '__TQ_UNRESOLVED_ROUTE_PARAM__')
     ) {
       const __col = __f.column || __f.source || __f.field || 'unknown'
-      return {
-        rows: [],
-        count: 0,
-        error:
-          'Filter on "' +
-          __col +
-          '" requires the page route parameter, which is not available in this context',
+      if (typeof console !== 'undefined' && console.warn) {
+        console.warn(
+          '[workflow] data-select skipped — filter on "' +
+            __col +
+            '" needs a page route param not available here; returning empty rows (workflow continues)'
+        )
       }
+      return { rows: [], count: 0, __skippedUnavailableFilter: true }
     }
   }
 

package/src/nodes/data/data-update-item.ts

@@ -9,9 +9,12 @@ async function data_update_item(config: any, context: any) {
   const __env = (globalThis as any).process && (globalThis as any).process.env
 
   // Unresolved route-param sentinel (see resolveTemplateTokenString in
-  // runtime-utils): in a filter it is a validation error — an UPDATE keyed on
-  // it would match 0 rows and report failure with no hint why. In a
-  // columnMapping it degrades to null so the write itself survives.
+  // runtime-utils): in a filter, an UPDATE keyed on it cannot identify its row.
+  // DEGRADE to a NO-OP — return updatedCount:0 WITHOUT an `error` so the executor
+  // does not throw and abort the whole workflow. CRITICAL: never drop the filter
+  // and run an UNSCOPED update (that would rewrite every row); no-op is the only
+  // safe degrade. (A columnMapping sentinel still degrades to null below so the
+  // write's VALUES survive.) Observable via the warn + __skippedUnavailableFilter.
   for (let __fi = 0; __fi < filters.length; __fi++) {
     const __f: any = filters[__fi]
     if (
@@ -20,14 +23,14 @@ async function data_update_item(config: any, context: any) {
         __f.destination === '__TQ_UNRESOLVED_ROUTE_PARAM__')
     ) {
       const __col = __f.column || __f.source || __f.field || 'unknown'
-      return {
-        id: null,
-        updatedCount: 0,
-        error:
-          'Filter on "' +
-          __col +
-          '" requires the page route parameter, which is not available in this context',
+      if (typeof console !== 'undefined' && console.warn) {
+        console.warn(
+          '[workflow] data-update-item skipped (no-op) — filter on "' +
+            __col +
+            '" needs a page route param not available here; no rows updated (workflow continues)'
+        )
       }
+      return { id: null, updatedCount: 0, success: true, __skippedUnavailableFilter: true }
     }
   }
   if (Array.isArray(columnMappings)) {