@nordcraft/search 1.0.0

package/src/rules/urlParameters/duplicateUrlParameterRule.test.ts

@@ -0,0 +1,134 @@
+import { searchProject } from '../../searchProject'
+import { duplicateUrlParameterRule } from './duplicateUrlParameterRule'
+
+describe('duplicateUrlParameterRule', () => {
+  test('should detect duplicate URL parameters', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                path: [
+                  {
+                    type: 'param',
+                    name: 'id',
+                    testValue: '1',
+                  },
+                  {
+                    type: 'static',
+                    name: 'name',
+                  },
+                ],
+                query: {
+                  id: {
+                    name: 'id',
+                    testValue: '1',
+                  },
+                },
+              },
+            },
+          },
+        },
+        rules: [duplicateUrlParameterRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('duplicate url parameter')
+    expect(problems[0].path).toEqual([
+      'components',
+      'test',
+      'route',
+      'query',
+      'id',
+    ])
+    expect(problems[0].details).toEqual({ name: 'id' })
+  })
+  test('should detect duplicate path parameters', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                path: [
+                  {
+                    type: 'param',
+                    name: 'company',
+                    testValue: '1',
+                  },
+                  {
+                    type: 'static',
+                    name: 'company',
+                  },
+                ],
+                query: {},
+              },
+            },
+          },
+        },
+        rules: [duplicateUrlParameterRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('duplicate url parameter')
+    expect(problems[0].path).toEqual(['components', 'test', 'route', 'path', 1])
+    expect(problems[0].details).toEqual({ name: 'company' })
+  })
+  test('should not detect non-duplicate URL parameters', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                path: [
+                  {
+                    type: 'param',
+                    name: 'id',
+                    testValue: '1',
+                  },
+                  {
+                    type: 'static',
+                    name: 'name',
+                  },
+                ],
+                query: {
+                  other: {
+                    name: 'other',
+                    testValue: '1',
+                  },
+                },
+              },
+            },
+          },
+        },
+        rules: [duplicateUrlParameterRule],
+      }),
+    )
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/urlParameters/duplicateUrlParameterRule.ts

@@ -0,0 +1,30 @@
+import { isDefined } from '@nordcraft/core/dist/utils/util'
+import type { Rule } from '../../types'
+
+export const duplicateUrlParameterRule: Rule<{ name: string }> = {
+  code: 'duplicate url parameter',
+  level: 'warning',
+  category: 'Quality',
+  visit: (report, { nodeType, path, value }) => {
+    if (
+      nodeType !== 'component' ||
+      !isDefined(value.route) ||
+      !isDefined(value.route.path) ||
+      !isDefined(value.route.query)
+    ) {
+      return
+    }
+    const pathNames = new Set<string>()
+    value.route.path.forEach((p, i) => {
+      if (pathNames.has(p.name)) {
+        report([...path, 'route', 'path', i], { name: p.name })
+      }
+      pathNames.add(p.name)
+    })
+    Object.keys(value.route.query).forEach((key) => {
+      if (pathNames.has(key)) {
+        report([...path, 'route', 'query', key], { name: key })
+      }
+    })
+  },
+}

package/src/rules/urlParameters/unknownSetUrlParameterRule.test.ts

@@ -0,0 +1,162 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+import { searchProject } from '../../searchProject'
+import { unknownSetUrlParameterRule } from './unknownSetUrlParameterRule'
+import { unknownUrlParameterRule } from './unknownUrlParameterRule'
+
+describe('unknownSetUrlParameterRule', () => {
+  test('should report setting unknown URL parameters', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'SetURLParameter',
+                          parameter: 'unknown',
+                          data: valueFormula('newValue'),
+                        },
+                      ],
+                    },
+                  },
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownSetUrlParameterRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown set url parameter')
+    expect(problems[0].details).toEqual({ name: 'unknown' })
+  })
+
+  test('should report setting static path parameters', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'SetURLParameter',
+                          parameter: 'knownPath',
+                          data: valueFormula('newValue'),
+                        },
+                      ],
+                    },
+                  },
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                path: [
+                  {
+                    name: 'knownPath',
+                    type: 'static',
+                  },
+                ],
+                query: {},
+              },
+            },
+          },
+        },
+        rules: [unknownSetUrlParameterRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown set url parameter')
+    expect(problems[0].details).toEqual({ name: 'knownPath' })
+  })
+
+  test('should not report valid url updates', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'SetURLParameter',
+                          parameter: 'known-query',
+                          data: valueFormula('newValue'),
+                        },
+                        {
+                          type: 'SetURLParameter',
+                          parameter: 'known-path',
+                          data: valueFormula('newValue'),
+                        },
+                      ],
+                    },
+                  },
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                path: [{ name: 'known-path', type: 'param', testValue: 'bla' }],
+                query: {
+                  'known-query': {
+                    name: 'known-query',
+                    testValue: '',
+                  },
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownUrlParameterRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/urlParameters/unknownSetUrlParameterRule.ts

@@ -0,0 +1,34 @@
+import type { Rule } from '../../types'
+
+export const unknownSetUrlParameterRule: Rule<{
+  name: string
+}> = {
+  code: 'unknown set url parameter',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, args) => {
+    if (
+      args.nodeType !== 'action-model' ||
+      args.value.type !== 'SetURLParameter'
+    ) {
+      return
+    }
+    const parameterName = args.value.parameter
+    const component = args.component
+    if (
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      component.route?.path?.some(
+        (p) =>
+          p.name === parameterName &&
+          // It's only valid to set non-static path parameters
+          p.type === 'param',
+      ) ||
+      Object.values(component.route?.query ?? {}).some(
+        (q) => q.name === parameterName,
+      )
+    ) {
+      return
+    }
+    report(args.path, { name: parameterName })
+  },
+}

package/src/rules/urlParameters/unknownUrlParameterRule.test.ts

@@ -0,0 +1,99 @@
+import { searchProject } from '../../searchProject'
+import { unknownUrlParameterRule } from './unknownUrlParameterRule'
+
+describe('unknownUrlParameterRule', () => {
+  test('should report reading unknown URL parameters', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {
+                    'my-class': {
+                      formula: {
+                        type: 'path',
+                        path: ['URL parameters', 'unknown'],
+                      },
+                    },
+                  },
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownUrlParameterRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown url parameter')
+    expect(problems[0].details).toEqual({ name: 'unknown' })
+  })
+
+  test('should not report url parameters that exist', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {
+                    'my-class': {
+                      formula: {
+                        type: 'path',
+                        path: ['URL parameters', 'known-path'],
+                      },
+                    },
+                    'my-other-class': {
+                      formula: {
+                        type: 'path',
+                        path: ['URL parameters', 'known-query'],
+                      },
+                    },
+                  },
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                path: [{ name: 'known-path', type: 'static' }],
+                query: {
+                  'known-query': {
+                    name: 'known-query',
+                    testValue: '',
+                  },
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownUrlParameterRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/urlParameters/unknownUrlParameterRule.ts

@@ -0,0 +1,28 @@
+import type { Rule } from '../../types'
+
+export const unknownUrlParameterRule: Rule<{
+  name: string
+}> = {
+  code: 'unknown url parameter',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (
+      nodeType !== 'formula' ||
+      value.type !== 'path' ||
+      value.path[0] !== 'URL parameters'
+    ) {
+      return
+    }
+
+    const [, componentName] = path
+    const [, parameterKey] = value.path
+    const component = files.components[componentName]
+    if (
+      !component?.route?.query?.[parameterKey] &&
+      !component?.route?.path?.some((p) => p.name === parameterKey)
+    ) {
+      report(path, { name: parameterKey })
+    }
+  },
+}

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

@@ -0,0 +1,94 @@
+import { searchProject } from '../../searchProject'
+import { noReferenceVariableRule } from './noReferenceVariableRule'
+
+describe('noReferenceVariableRule', () => {
+  test('should detect variables with no references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {
+                'my-variable': {
+                  initialValue: { type: 'value', value: null },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+            },
+          },
+        },
+        rules: [noReferenceVariableRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('no-reference variable')
+    expect(problems[0].path).toEqual([
+      'components',
+      'test',
+      'variables',
+      'my-variable',
+    ])
+  })
+
+  test('should not detect variables with references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {
+                'my-formula': {
+                  name: 'my-formula',
+                  arguments: [],
+                  formula: {
+                    type: 'apply',
+                    name: 'test',
+                    arguments: [
+                      {
+                        formula: {
+                          type: 'path',
+                          path: [
+                            'Variables',
+                            'my-variable',
+                            'some-nested-value',
+                          ],
+                        },
+                      },
+                    ],
+                  },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {
+                'my-variable': {
+                  initialValue: { type: 'value', value: null },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+            },
+          },
+        },
+        rules: [noReferenceVariableRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/variables/noReferenceVariableRule.ts

@@ -0,0 +1,36 @@
+import type { Rule } from '../../types'
+
+export const noReferenceVariableRule: Rule<void> = {
+  code: 'no-reference variable',
+  level: 'warning',
+  category: 'No References',
+  visit: (report, args) => {
+    if (args.nodeType !== 'component-variable') {
+      return
+    }
+    const { path, memo, component } = args
+
+    const [, , , variableKey] = path
+
+    const variableInComponent = memo(
+      `variableInComponent/${component.name}`,
+      () =>
+        new Set(
+          Array.from(component.formulasInComponent())
+            .filter(
+              ([, formula]) =>
+                formula.type === 'path' &&
+                formula.path[0] === 'Variables' &&
+                formula.path[1],
+            )
+            .map<string | number>(([, formula]) => (formula as any).path[1]),
+        ),
+    )
+
+    if (variableInComponent.has(variableKey)) {
+      return
+    }
+
+    report(path)
+  },
+}