@nordcraft/search 1.0.53 → 1.0.54

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

@@ -1,280 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { searchProject } from '../../searchProject'
-import { noReferenceComponentWorkflowRule } from './noReferenceComponentWorkflowRule'
-
-describe('noReferenceComponentWorkflowRule', () => {
-  test('should detect component workflows with no references', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          components: {
-            page: {
-              name: 'my-page',
-              nodes: {
-                root: {
-                  type: 'element',
-                  tag: 'div',
-                  attrs: {},
-                  children: [],
-                  classes: {},
-                  style: {},
-                  events: {},
-                },
-              },
-              workflows: {
-                'my-workflow': {
-                  actions: [],
-                  name: 'my-workflow',
-                  parameters: [],
-                  '@nordcraft/metadata': {
-                    comments: null,
-                  },
-                },
-              },
-              apis: {},
-              attributes: {},
-              variables: {},
-              route: {
-                info: {},
-                path: [],
-                query: {},
-              },
-            },
-          },
-        },
-        rules: [noReferenceComponentWorkflowRule],
-      }),
-    )
-
-    expect(problems).toHaveLength(1)
-    expect(problems[0].code).toBe('no-reference component workflow')
-    expect(problems[0].path).toEqual([
-      'components',
-      'page',
-      'workflows',
-      'my-workflow',
-    ])
-  })
-
-  test('should not detect component workflows with references', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          components: {
-            page: {
-              name: 'page',
-              nodes: {
-                root: {
-                  type: 'element',
-                  tag: 'div',
-                  attrs: {},
-                  children: [],
-                  classes: {},
-                  style: {},
-                  events: {
-                    click: {
-                      trigger: 'click',
-                      actions: [
-                        {
-                          type: 'TriggerWorkflow',
-                          workflow: 'my-workflow',
-                          parameters: {},
-                        },
-                      ],
-                    },
-                  },
-                },
-              },
-              workflows: {
-                'my-workflow': {
-                  actions: [],
-                  name: 'my-workflow',
-                  parameters: [],
-                  exposeInContext: true,
-                  '@nordcraft/metadata': {
-                    comments: null,
-                  },
-                },
-              },
-              apis: {},
-              attributes: {},
-              variables: {},
-              route: {
-                info: {},
-                path: [],
-                query: {},
-              },
-            },
-          },
-        },
-        rules: [noReferenceComponentWorkflowRule],
-      }),
-    )
-
-    expect(problems).toEqual([])
-  })
-
-  test('should not detect component workflows with references through context', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          components: {
-            page: {
-              name: 'page',
-              nodes: {},
-              workflows: {
-                'my-workflow': {
-                  actions: [],
-                  name: 'my-workflow',
-                  parameters: [],
-                  exposeInContext: true,
-                  '@nordcraft/metadata': {
-                    comments: null,
-                  },
-                },
-              },
-              apis: {},
-              attributes: {},
-              variables: {},
-              route: {
-                info: {},
-                path: [],
-                query: {},
-              },
-            },
-            'my-component': {
-              name: 'my-component',
-              nodes: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-              onLoad: {
-                trigger: 'load',
-                actions: [
-                  {
-                    type: 'TriggerWorkflow',
-                    workflow: 'my-workflow',
-                    contextProvider: 'page',
-                    parameters: {},
-                  },
-                ],
-              },
-              contexts: {
-                page: {
-                  formulas: [],
-                  workflows: ['my-workflow'],
-                },
-              },
-            },
-          },
-        },
-        rules: [noReferenceComponentWorkflowRule],
-      }),
-    )
-
-    expect(problems).toEqual([])
-  })
-
-  test('should report when subscribed, but no usage', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          components: {
-            page: {
-              name: 'my-page',
-              nodes: {},
-              workflows: {
-                'my-workflow': {
-                  actions: [],
-                  name: 'my-workflow',
-                  parameters: [],
-                  exposeInContext: true,
-                  '@nordcraft/metadata': {
-                    comments: null,
-                  },
-                },
-              },
-              apis: {},
-              attributes: {},
-              variables: {},
-              route: {
-                info: {},
-                path: [],
-                query: {},
-              },
-            },
-            'my-component': {
-              name: 'my-component',
-              nodes: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-              contexts: {
-                page: {
-                  formulas: [],
-                  workflows: ['my-workflow'],
-                },
-              },
-            },
-          },
-        },
-        rules: [noReferenceComponentWorkflowRule],
-      }),
-    )
-
-    expect(problems).toHaveLength(1)
-    expect(problems[0].code).toBe('no-reference component workflow')
-    expect(problems[0].details).toEqual({
-      contextSubscribers: ['my-component'],
-      name: 'my-workflow',
-    })
-  })
-  test('should detect component workflows with only self reference', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          components: {
-            page: {
-              name: 'my-page',
-              nodes: {},
-              workflows: {
-                'my-workflow': {
-                  actions: [
-                    {
-                      type: 'TriggerWorkflow',
-                      workflow: 'my-workflow',
-                      parameters: {},
-                    },
-                  ],
-                  name: 'my-workflow',
-                  parameters: [],
-                  '@nordcraft/metadata': {
-                    comments: null,
-                  },
-                },
-              },
-              apis: {},
-              attributes: {},
-              variables: {},
-              route: {
-                info: {},
-                path: [],
-                query: {},
-              },
-            },
-          },
-        },
-        rules: [noReferenceComponentWorkflowRule],
-      }),
-    )
-
-    expect(problems).toHaveLength(1)
-    expect(problems[0].code).toBe('no-reference component workflow')
-    expect(problems[0].path).toEqual([
-      'components',
-      'page',
-      'workflows',
-      'my-workflow',
-    ])
-  })
-})

package/src/rules/workflows/noReferenceComponentWorkflowRule.ts

@@ -1,82 +0,0 @@
-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
-      }
-    }
-
-    // Short circuit if the component is exported and the workflow is exposed in context, as it is always indirectly used
-    if (value.exposeInContext && component.exported) {
-      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

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

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

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

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