@nordcraft/search 1.0.0

package/src/rules/workflows/noReferenceComponentWorkflowRule.ts

@@ -0,0 +1,77 @@
+import { ToddleComponent } from '@nordcraft/core/dist/component/ToddleComponent'
+import type { Rule } from '../../types'
+
+export const noReferenceComponentWorkflowRule: Rule<{
+  name: string
+  contextSubscribers: string[]
+}> = {
+  code: 'no-reference component workflow',
+  level: 'warning',
+  category: 'No References',
+  visit: (report, args) => {
+    if (args.nodeType !== 'component-workflow') {
+      return
+    }
+
+    const { path, files, value, component } = args
+
+    const [, componentName, , workflowKey] = path
+    const targetComponent = files.components[componentName]
+    if (!targetComponent) {
+      return
+    }
+
+    for (const [actionPath, action] of component.actionModelsInComponent()) {
+      if (
+        action.type === 'TriggerWorkflow' &&
+        action.workflow === workflowKey &&
+        // Disregard own workflow reference.
+        !(actionPath[0] === 'workflows' && actionPath[1] === workflowKey)
+      ) {
+        return
+      }
+    }
+
+    // It is possible that a formula is never used, but still has subscribers
+    const contextSubscribers = []
+    if (value.exposeInContext) {
+      for (const _component of Object.values(files.components)) {
+        // Enforce that the component is not undefined since we're iterating
+        const component = _component!
+        for (const [contextKey, context] of Object.entries(
+          component.contexts ?? {},
+        )) {
+          if (
+            contextKey === componentName &&
+            context.workflows.includes(workflowKey.toString())
+          ) {
+            contextSubscribers.push(component.name)
+            const contextComponent = new ToddleComponent({
+              component,
+              getComponent: (name) => files.components[name],
+              packageName: undefined,
+              globalFormulas: {
+                formulas: files.formulas,
+                packages: files.packages,
+              },
+            })
+            for (const [
+              ,
+              action,
+            ] of contextComponent.actionModelsInComponent()) {
+              if (
+                action.type === 'TriggerWorkflow' &&
+                action.contextProvider === componentName &&
+                action.workflow === workflowKey
+              ) {
+                return
+              }
+            }
+          }
+        }
+      }
+    }
+
+    report(path, { contextSubscribers, name: value.name })
+  },
+}

package/src/rules/workflows/unknownContextProviderWorkflowRule.test.ts

@@ -0,0 +1,146 @@
+import { searchProject } from '../../searchProject'
+import { unknownContextProviderWorkflowRule } from './unknownContextProviderWorkflowRule'
+
+describe('unknownContextProviderWorkflowRule', () => {
+  test('should detect invalid context provider workflow references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            known: {
+              name: 'known',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              workflows: {},
+            },
+            consumer: {
+              name: 'consumer',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              contexts: {
+                known: {
+                  formulas: ['test'],
+                  workflows: ['test'],
+                  componentName: 'known',
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownContextProviderWorkflowRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown context provider workflow')
+    expect(problems[0].details).toEqual({
+      providerName: 'known',
+      workflowName: 'test',
+    })
+  })
+  test('should detect non-exposed context provider formula references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            known: {
+              name: 'known',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              workflows: {
+                test: {
+                  actions: [],
+                  name: 'test',
+                  parameters: [],
+                  exposeInContext: false,
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+            },
+            consumer: {
+              name: 'consumer',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              contexts: {
+                known: {
+                  formulas: ['test'],
+                  workflows: ['test'],
+                  componentName: 'known',
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownContextProviderWorkflowRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown context provider workflow')
+    expect(problems[0].details).toEqual({
+      providerName: 'known',
+      workflowName: 'test',
+    })
+  })
+  test('should not detect exposed context provider formula references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            known: {
+              name: 'known',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              workflows: {
+                test: {
+                  actions: [],
+                  name: 'test',
+                  parameters: [],
+                  exposeInContext: true,
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+            },
+            consumer: {
+              name: 'consumer',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              contexts: {
+                known: {
+                  formulas: ['test'],
+                  workflows: ['test'],
+                  componentName: 'known',
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownContextProviderWorkflowRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/workflows/unknownContextProviderWorkflowRule.ts

@@ -0,0 +1,35 @@
+import type { Rule } from '../../types'
+
+export const unknownContextProviderWorkflowRule: Rule<{
+  providerName: string
+  workflowName: string
+}> = {
+  code: 'unknown context provider workflow',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (
+      nodeType !== 'component-context' ||
+      !value.componentName ||
+      (value.workflows ?? []).length === 0
+    ) {
+      return
+    }
+
+    // Lookup the target component and verify it holds the workflow
+    const component = value.package
+      ? files.packages?.[value.package]?.components[value.componentName]
+      : files.components[value.componentName]
+    if (!component) {
+      return
+    }
+    for (const workflowName of value.workflows) {
+      if (component.workflows?.[workflowName]?.exposeInContext !== true) {
+        report(path, {
+          providerName: value.componentName,
+          workflowName,
+        })
+      }
+    }
+  },
+}

package/src/rules/workflows/unknownContextWorkflowRule.test.ts

@@ -0,0 +1,92 @@
+import { searchProject } from '../../searchProject'
+import { unknownContextWorkflowRule } from './unknownContextWorkflowRule'
+
+describe('unknownContextWorkflowRule', () => {
+  test('should detect context workflows that are not subscribed', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            consumer: {
+              name: 'consumer',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              onLoad: {
+                trigger: 'onLoad',
+                actions: [
+                  {
+                    type: 'TriggerWorkflow',
+                    workflow: 'test',
+                    contextProvider: 'unknown',
+                    parameters: {},
+                  },
+                  {
+                    type: 'TriggerWorkflow',
+                    workflow: 'unknown',
+                    contextProvider: 'known',
+                    parameters: {},
+                  },
+                ],
+              },
+              contexts: {
+                known: {
+                  formulas: ['test'],
+                  workflows: ['test'],
+                  componentName: 'known',
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownContextWorkflowRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(2)
+    expect(problems[0].code).toBe('unknown context workflow')
+    expect(problems[1].code).toBe('unknown context workflow')
+  })
+
+  test('should not detect when context workflows are subscribed', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            consumer: {
+              name: 'consumer',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              onLoad: {
+                trigger: 'onLoad',
+                actions: [
+                  {
+                    type: 'TriggerWorkflow',
+                    workflow: 'test',
+                    contextProvider: 'known',
+                    parameters: {},
+                  },
+                ],
+              },
+              contexts: {
+                known: {
+                  formulas: ['test'],
+                  workflows: ['test'],
+                  componentName: 'known',
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownContextWorkflowRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/workflows/unknownContextWorkflowRule.ts

@@ -0,0 +1,30 @@
+import type { Rule } from '../../types'
+
+export const unknownContextWorkflowRule: Rule<{
+  providerName: string
+  workflowName: string
+}> = {
+  code: 'unknown context workflow',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (
+      path[0] !== 'components' ||
+      nodeType !== 'action-model' ||
+      value.type !== 'TriggerWorkflow' ||
+      !value.contextProvider
+    ) {
+      return
+    }
+
+    const contexts = files.components[path[1]]?.contexts ?? {}
+    if (contexts[value.contextProvider]?.workflows.includes(value.workflow)) {
+      return
+    }
+
+    report(path, {
+      providerName: value.contextProvider,
+      workflowName: value.workflow,
+    })
+  },
+}