@nordcraft/search 1.0.0

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

@@ -0,0 +1,484 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+import { searchProject } from '../../searchProject'
+import { unknownTriggerWorkflowParameterRule } from './unknownTriggerWorkflowParameterRule'
+
+describe('unknownTriggerWorkflowParameterRule', () => {
+  test('should detect unknown workflow parameters', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            myComponent: {
+              name: 'myComponent',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'TriggerWorkflow',
+                          workflow: 'my-workflow',
+                          parameters: {
+                            unknownParameter: {
+                              formula: valueFormula(4),
+                            },
+                          },
+                        },
+                      ],
+                    },
+                  },
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              workflows: {
+                ['my-workflow']: {
+                  actions: [],
+                  name: 'my-workflow',
+                  parameters: [
+                    {
+                      name: 'parameter',
+                      testValue: 4,
+                    },
+                  ],
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownTriggerWorkflowParameterRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown trigger workflow parameter')
+    expect(problems[0].details).toEqual({ parameter: 'unknownParameter' })
+  })
+  test('should not fail on valid workflow parameters', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            myComponent: {
+              name: 'myComponent',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'TriggerWorkflow',
+                          workflow: 'my-workflow',
+                          parameters: {
+                            parameter: {
+                              formula: valueFormula(4),
+                            },
+                          },
+                        },
+                      ],
+                    },
+                  },
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              workflows: {
+                ['my-workflow']: {
+                  actions: [],
+                  name: 'my-workflow',
+                  parameters: [
+                    {
+                      name: 'parameter',
+                      testValue: 4,
+                    },
+                  ],
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownTriggerWorkflowParameterRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+  test('should detect unknown workflow parameters in context workflows', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            myComponent: {
+              name: 'myComponent',
+              nodes: {
+                root: {
+                  type: 'component',
+                  name: 'consumer',
+                  attrs: {},
+                  children: [],
+                  events: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              workflows: {
+                ['my-workflow']: {
+                  actions: [],
+                  name: 'my-workflow',
+                  parameters: [
+                    {
+                      name: 'parameter',
+                      testValue: 4,
+                    },
+                  ],
+                  exposeInContext: true,
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+            },
+            consumer: {
+              name: 'consumer',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'TriggerWorkflow',
+                          workflow: 'my-workflow',
+                          contextProvider: 'bla',
+                          parameters: {
+                            unknownParameter: {
+                              formula: valueFormula(4),
+                            },
+                          },
+                        },
+                      ],
+                    },
+                  },
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              contexts: {
+                bla: {
+                  workflows: ['my-workflow'],
+                  formulas: [],
+                  componentName: 'myComponent',
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownTriggerWorkflowParameterRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown trigger workflow parameter')
+    expect(problems[0].details).toEqual({ parameter: 'unknownParameter' })
+  })
+  test('should not fail on valid context workflow parameters', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            myComponent: {
+              name: 'myComponent',
+              nodes: {
+                root: {
+                  type: 'component',
+                  name: 'consumer',
+                  attrs: {},
+                  children: [],
+                  events: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              workflows: {
+                ['my-workflow']: {
+                  actions: [],
+                  name: 'my-workflow',
+                  parameters: [
+                    {
+                      name: 'parameter',
+                      testValue: 4,
+                    },
+                  ],
+                  exposeInContext: true,
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+            },
+            consumer: {
+              name: 'consumer',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'TriggerWorkflow',
+                          workflow: 'my-workflow',
+                          contextProvider: 'bla',
+                          parameters: {
+                            parameter: {
+                              formula: valueFormula(4),
+                            },
+                          },
+                        },
+                      ],
+                    },
+                  },
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              contexts: {
+                bla: {
+                  workflows: ['my-workflow'],
+                  formulas: [],
+                  componentName: 'myComponent',
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownTriggerWorkflowParameterRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+  test('should detect unknown workflow parameters in context workflows from packages', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          packages: {
+            myPackage: {
+              manifest: {
+                commit: 'commit',
+                name: 'myPackage',
+              },
+              components: {
+                myComponent: {
+                  name: 'myComponent',
+                  nodes: {},
+                  formulas: {},
+                  apis: {},
+                  attributes: {},
+                  variables: {},
+                  workflows: {
+                    ['package-workflow']: {
+                      actions: [],
+                      name: 'package-workflow',
+                      parameters: [
+                        {
+                          name: 'parameter',
+                          testValue: 4,
+                        },
+                      ],
+                      exposeInContext: true,
+                      '@toddle/metadata': {
+                        comments: null,
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+          components: {
+            consumer: {
+              name: 'consumer',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'TriggerWorkflow',
+                          workflow: 'package-workflow',
+                          contextProvider: 'bla',
+                          parameters: {
+                            unknownParameter: {
+                              formula: valueFormula(4),
+                            },
+                          },
+                        },
+                      ],
+                    },
+                  },
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              contexts: {
+                bla: {
+                  workflows: ['package-workflow'],
+                  formulas: [],
+                  componentName: 'myComponent',
+                  package: 'myPackage',
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownTriggerWorkflowParameterRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown trigger workflow parameter')
+    expect(problems[0].details).toEqual({ parameter: 'unknownParameter' })
+  })
+  test('should not fail on valid package workflow parameters', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          packages: {
+            myPackage: {
+              manifest: {
+                commit: 'commit',
+                name: 'myPackage',
+              },
+              components: {
+                myComponent: {
+                  name: 'myComponent',
+                  nodes: {},
+                  formulas: {},
+                  apis: {},
+                  attributes: {},
+                  variables: {},
+                  workflows: {
+                    ['package-workflow']: {
+                      actions: [],
+                      name: 'package-workflow',
+                      parameters: [
+                        {
+                          name: 'parameter',
+                          testValue: 4,
+                        },
+                      ],
+                      exposeInContext: true,
+                      '@toddle/metadata': {
+                        comments: null,
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+          components: {
+            consumer: {
+              name: 'consumer',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'TriggerWorkflow',
+                          workflow: 'package-workflow',
+                          contextProvider: 'bla',
+                          parameters: {
+                            parameter: {
+                              formula: valueFormula(4),
+                            },
+                          },
+                        },
+                      ],
+                    },
+                  },
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              contexts: {
+                bla: {
+                  workflows: ['package-workflow'],
+                  formulas: [],
+                  componentName: 'myComponent',
+                  package: 'myPackage',
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownTriggerWorkflowParameterRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/workflows/unknownTriggerWorkflowParameterRule.ts

@@ -0,0 +1,54 @@
+import type { ComponentWorkflow } from '@nordcraft/core/dist/component/component.types'
+import type { Rule } from '../../types'
+
+export const unknownTriggerWorkflowParameterRule: Rule<{ parameter: string }> =
+  {
+    code: 'unknown trigger workflow parameter',
+    level: 'error',
+    category: 'Unknown Reference',
+    visit: (report, args) => {
+      const { path, files, value, nodeType } = args
+      if (
+        nodeType !== 'action-model' ||
+        value.type !== 'TriggerWorkflow' ||
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        Object.entries(value?.parameters ?? {}).length === 0
+      ) {
+        return
+      }
+
+      let workflow: ComponentWorkflow | undefined
+      if (typeof value.contextProvider === 'string') {
+        const subscription = args.component.contexts?.[value.contextProvider]
+        const isSubscribed = subscription?.workflows?.includes(value.workflow)
+        if (!isSubscribed || typeof subscription?.componentName !== 'string') {
+          return
+        }
+        workflow = subscription?.package
+          ? files.packages?.[subscription.package]?.components[
+              subscription.componentName
+            ]?.workflows?.[value.workflow]
+          : files.components[subscription.componentName]?.workflows?.[
+              value.workflow
+            ]
+        if (!workflow) {
+          return
+        }
+      } else {
+        workflow = args.component.workflows?.[value.workflow]
+      }
+      if (!workflow) {
+        return
+      }
+      const workflowParameters = new Set(
+        Object.values(workflow.parameters).map((p) => p.name),
+      )
+      Object.keys(value.parameters).forEach((parameterKey) => {
+        if (!workflowParameters.has(parameterKey)) {
+          report([...path, 'parameters', parameterKey], {
+            parameter: parameterKey,
+          })
+        }
+      })
+    },
+  }

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

@@ -0,0 +1,104 @@
+import { searchProject } from '../../searchProject'
+import { unknownTriggerWorkflowRule } from './unknownTriggerWorkflowRule'
+
+describe('unknownTriggerWorkflowRule', () => {
+  test('should detect unknown workflows', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            myComponent: {
+              name: 'myComponent',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'TriggerWorkflow',
+                          workflow: 'unknown-workflow',
+                          parameters: {},
+                        },
+                      ],
+                    },
+                  },
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              workflows: {
+                ['my-workflow']: {
+                  actions: [],
+                  name: 'my-workflow',
+                  parameters: [],
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownTriggerWorkflowRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown trigger workflow')
+  })
+  test('should not fail on valid workflow triggers', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            myComponent: {
+              name: 'myComponent',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'TriggerWorkflow',
+                          workflow: 'my-workflow',
+                          parameters: {},
+                        },
+                      ],
+                    },
+                  },
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              workflows: {
+                ['my-workflow']: {
+                  actions: [],
+                  name: 'my-workflow',
+                  parameters: [],
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownTriggerWorkflowRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/workflows/unknownTriggerWorkflowRule.ts

@@ -0,0 +1,22 @@
+import type { Rule } from '../../types'
+
+export const unknownTriggerWorkflowRule: Rule<void> = {
+  code: 'unknown trigger workflow',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, args) => {
+    const { path, value, nodeType } = args
+    if (
+      nodeType !== 'action-model' ||
+      value.type !== 'TriggerWorkflow' ||
+      typeof value.contextProvider === 'string'
+    ) {
+      return
+    }
+
+    const workflow = args.component.workflows?.[value.workflow]
+    if (!workflow) {
+      report(path)
+    }
+  },
+}