@nordcraft/search 1.0.52 → 1.0.54

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

@@ -1,485 +0,0 @@
-import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
-import { describe, expect, test } from 'bun:test'
-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,
-                    },
-                  ],
-                  '@nordcraft/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,
-                    },
-                  ],
-                  '@nordcraft/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,
-                  '@nordcraft/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,
-                  '@nordcraft/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,
-                      '@nordcraft/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,
-                      '@nordcraft/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

@@ -1,54 +0,0 @@
-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

@@ -1,105 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-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

@@ -1,22 +0,0 @@
-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)
-    }
-  },
-}