@nordcraft/search 1.0.0

package/src/rules/variables/unknownVariableRule.test.ts

@@ -0,0 +1,91 @@
+import { searchProject } from '../../searchProject'
+import { unknownVariableRule } from './unknownVariableRule'
+
+describe('unknownVariable', () => {
+  test('should report reading unknown variables', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {
+                    'my-class': {
+                      formula: {
+                        type: 'path',
+                        path: ['Variables', 'unknown'],
+                      },
+                    },
+                  },
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownVariableRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown variable')
+    expect(problems[0].details).toEqual({ name: 'unknown' })
+  })
+
+  test('should not report variables that exist', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {
+                    'my-class': {
+                      formula: {
+                        type: 'path',
+                        path: ['Variables', 'known'],
+                      },
+                    },
+                  },
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {
+                known: {
+                  initialValue: { type: 'value', value: null },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownVariableRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/variables/unknownVariableRule.ts

@@ -0,0 +1,25 @@
+import type { Rule } from '../../types'
+
+export const unknownVariableRule: Rule<{
+  name: string
+}> = {
+  code: 'unknown variable',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (
+      nodeType !== 'formula' ||
+      value.type !== 'path' ||
+      value.path[0] !== 'Variables'
+    ) {
+      return
+    }
+
+    const [, componentName] = path
+    const [, variableKey] = value.path
+    const component = files.components[componentName]
+    if (!component?.variables?.[variableKey]) {
+      report(path, { name: variableKey })
+    }
+  },
+}

package/src/rules/variables/unknownVariableSetterRule.test.ts

@@ -0,0 +1,105 @@
+import { searchProject } from '../../searchProject'
+import { unknownVariableSetterRule } from './unknownVariableSetterRule'
+
+describe('unknownVariableSetter', () => {
+  test('should report setting unknown variables', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'SetVariable',
+                          variable: 'unknown',
+                          data: {
+                            type: 'value',
+                            value: null,
+                          },
+                        },
+                      ],
+                    },
+                  },
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownVariableSetterRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown variable setter')
+    expect(problems[0].details).toEqual({ name: 'unknown' })
+  })
+
+  test('should not report setting variables that exist', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {
+                    'my-event': {
+                      trigger: 'my-event',
+                      actions: [
+                        {
+                          type: 'SetVariable',
+                          variable: 'known',
+                          data: {
+                            type: 'value',
+                            value: null,
+                          },
+                        },
+                      ],
+                    },
+                  },
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {
+                known: {
+                  initialValue: { type: 'value', value: null },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownVariableSetterRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/variables/unknownVariableSetterRule.ts

@@ -0,0 +1,20 @@
+import type { Rule } from '../../types'
+
+export const unknownVariableSetterRule: Rule<{
+  name: string
+}> = {
+  code: 'unknown variable setter',
+  level: 'warning',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (nodeType !== 'action-model' || value.type !== 'SetVariable') {
+      return
+    }
+
+    const [, componentName] = path
+    const component = files.components[componentName]
+    if (!component?.variables?.[value.variable]) {
+      report(path, { name: value.variable })
+    }
+  },
+}

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

@@ -0,0 +1,105 @@
+import { searchProject } from '../../searchProject'
+import { duplicateWorkflowParameterRule } from './duplicateWorkflowParameterRule'
+
+describe('duplicateWorkflowParameterRule', () => {
+  test('should detect duplicate workflow parameters', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                path: [],
+                query: {},
+              },
+              workflows: {
+                myWorkflow: {
+                  name: 'myWorkflow',
+                  parameters: [
+                    {
+                      name: 'myParameter',
+                      testValue: '1',
+                    },
+                    {
+                      name: 'myParameter',
+                      testValue: '1',
+                    },
+                  ],
+                  actions: [],
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+            },
+          },
+        },
+        rules: [duplicateWorkflowParameterRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('duplicate workflow parameter')
+    expect(problems[0].path).toEqual([
+      'components',
+      'test',
+      'workflows',
+      'myWorkflow',
+      'parameters',
+      1,
+    ])
+    expect(problems[0].details).toEqual({ parameter: 'myParameter' })
+  })
+  test('should not detect unique workflow parameters', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                path: [],
+                query: {},
+              },
+              workflows: {
+                myWorkflow: {
+                  name: 'myWorkflow',
+                  parameters: [
+                    {
+                      name: 'myParameter',
+                      testValue: '1',
+                    },
+                    {
+                      name: 'myOtherParameter',
+                      testValue: '1',
+                    },
+                  ],
+                  actions: [],
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+            },
+          },
+        },
+        rules: [duplicateWorkflowParameterRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/workflows/duplicateWorkflowParameterRule.ts

@@ -0,0 +1,23 @@
+import type { Rule } from '../../types'
+
+export const duplicateWorkflowParameterRule: Rule<{ parameter: string }> = {
+  code: 'duplicate workflow parameter',
+  level: 'warning',
+  category: 'Quality',
+  visit: (report, { nodeType, path, value }) => {
+    if (
+      nodeType !== 'component-workflow' ||
+      !value.parameters ||
+      (value.parameters ?? []).length === 0
+    ) {
+      return
+    }
+    const parameterNames = new Set<string>()
+    value.parameters.forEach((p, i) => {
+      if (parameterNames.has(p.name)) {
+        report([...path, 'parameters', i], { parameter: p.name })
+      }
+      parameterNames.add(p.name)
+    })
+  },
+}

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

@@ -0,0 +1,279 @@
+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: [],
+                  '@toddle/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,
+                  '@toddle/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,
+                  '@toddle/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,
+                  '@toddle/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: [],
+                  '@toddle/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',
+    ])
+  })
+})