@nordcraft/search 1.0.0

package/src/rules/formulas/noReferenceProjectFormulaRule.ts

@@ -0,0 +1,120 @@
+import { ToddleComponent } from '@nordcraft/core/dist/component/ToddleComponent'
+import type { Formula } from '@nordcraft/core/dist/formula/formula'
+import { isToddleFormula } from '@nordcraft/core/dist/formula/formulaTypes'
+import { ToddleApiService } from '@nordcraft/ssr/dist/ToddleApiService'
+import { ToddleRoute } from '@nordcraft/ssr/dist/ToddleRoute'
+import type { Rule } from '../../types'
+
+export const noReferenceProjectFormulaRule: Rule<void> = {
+  code: 'no-reference project formula',
+  level: 'warning',
+  category: 'No References',
+  visit: (report, { path, files, value, nodeType, memo }) => {
+    if (nodeType !== 'project-formula' || value.exported === true) {
+      return
+    }
+
+    // Check in all API services first, since that should be quick
+    for (const apiService of Object.values(files.services ?? {})) {
+      const service = new ToddleApiService({
+        service: apiService,
+        globalFormulas: { formulas: files.formulas, packages: files.packages },
+      })
+      const formulas = service.formulasInService()
+      for (const [_formulaPath, formula] of formulas) {
+        // Check if the formula is used in the formula
+        if (checkFormula(formula, value.name)) {
+          return
+        }
+      }
+    }
+
+    // Check routes before components, since they should be quicker
+    for (const projectRoute of Object.values(files.routes ?? {})) {
+      const route = new ToddleRoute({
+        route: projectRoute,
+        globalFormulas: { formulas: files.formulas, packages: files.packages },
+      })
+      const formulas = route.formulasInRoute()
+      for (const [_formulaPath, formula] of formulas) {
+        // Check if the formula is used in the formula
+        if (checkFormula(formula, value.name)) {
+          return
+        }
+      }
+    }
+
+    const componentFormulaReferences = memo(
+      'componentFormulaReferences',
+      () => {
+        const usedFormulas = new Set<string>()
+        for (const component of Object.values(files.components)) {
+          const c = new ToddleComponent({
+            // Enforce that the component is not undefined since we're iterating
+            component: component!,
+            getComponent: (name) => files.components[name],
+            packageName: undefined,
+            globalFormulas: {
+              formulas: files.formulas,
+              packages: files.packages,
+            },
+          })
+          for (const [, formula] of c.formulasInComponent()) {
+            if (formula.type === 'function') {
+              usedFormulas.add(formula.name)
+            }
+          }
+        }
+        return usedFormulas
+      },
+    )
+
+    if (componentFormulaReferences.has(value.name)) {
+      return
+    }
+
+    // TODO: Memoize similar to above. We need have a helper class `ToddleFormula` with `ToddleFormula.normalizeFormulas()`
+    for (const f of Object.values(files.formulas ?? {})) {
+      if (f.name === value.name) {
+        continue
+      }
+
+      // Check if the formula is used in the formula
+      if (isToddleFormula(f) && checkFormula(f.formula, value.name)) {
+        return
+      }
+    }
+
+    report(path)
+  },
+}
+
+const checkArguments = (
+  args: {
+    formula: Formula
+  }[],
+  formulaName: string,
+) => {
+  args.forEach((a) => {
+    if (checkFormula(a.formula, formulaName)) {
+      return true
+    }
+  })
+  return false
+}
+
+const checkFormula = (formula: Formula, formulaName: string) => {
+  if (formula.type === 'function' && formula.name === formulaName) {
+    return true
+  }
+  if (
+    formula.type === 'object' ||
+    formula.type === 'array' ||
+    formula.type === 'or' ||
+    formula.type === 'and' ||
+    formula.type === 'apply'
+  ) {
+    checkArguments(formula.arguments ?? [], formulaName)
+  }
+  return false
+}

package/src/rules/formulas/unknownComponentFormulaInputRule.test.ts

@@ -0,0 +1,140 @@
+import { searchProject } from '../../searchProject'
+import { unknownComponentFormulaInputRule } from './unknownComponentFormulaInputRule'
+
+describe('unknownComponentFormulaInput', () => {
+  test('should detect invalid component formula input references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {
+                myFormula: {
+                  name: 'Test',
+                  formula: {
+                    type: 'function',
+                    name: '@toddle/concatenate',
+                    arguments: [
+                      {
+                        name: '0',
+                        formula: { type: 'path', path: ['Args', 'Unknown'] },
+                      },
+                      {
+                        name: '1',
+                        formula: { type: 'path', path: ['Args', null as any] },
+                      },
+                    ],
+                    variableArguments: true,
+                    display_name: 'Concatenate',
+                  },
+                  arguments: [{ name: 'Input', testValue: 'Input' }],
+                  memoize: false,
+                  exposeInContext: false,
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownComponentFormulaInputRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(2)
+    expect(problems[0].code).toBe('unknown component formula input')
+    expect(problems[0].details).toEqual({ name: 'Unknown' })
+    expect(problems[1].code).toBe('unknown component formula input')
+    expect(problems[1].details).toEqual({ name: null })
+  })
+  test('should not detect valid component formula input references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {
+                myFormula: {
+                  name: 'Test',
+                  formula: {
+                    type: 'function',
+                    name: '@toddle/concatenate',
+                    arguments: [
+                      {
+                        name: '0',
+                        formula: { type: 'path', path: ['Args', 'Input'] },
+                      },
+                    ],
+                    variableArguments: true,
+                    display_name: 'Concatenate',
+                  },
+                  arguments: [{ name: 'Input', testValue: 'Input' }],
+                  memoize: false,
+                  exposeInContext: false,
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownComponentFormulaInputRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+  test('should not detect @toddle.parent/item path formulas', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {
+                myFormula: {
+                  name: 'Test',
+                  formula: {
+                    type: 'function',
+                    name: '@toddle/concatenate',
+                    arguments: [
+                      {
+                        name: '0',
+                        formula: { type: 'path', path: ['Args', 'item'] },
+                      },
+                      {
+                        name: '1',
+                        formula: {
+                          type: 'path',
+                          path: ['Args', '@toddle.parent', 'test'],
+                        },
+                      },
+                    ],
+                    variableArguments: true,
+                    display_name: 'Concatenate',
+                  },
+                  arguments: [{ name: 'Input', testValue: 'Input' }],
+                  memoize: false,
+                  exposeInContext: false,
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownComponentFormulaInputRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/formulas/unknownComponentFormulaInputRule.ts

@@ -0,0 +1,38 @@
+import type { ComponentFormula } from '@nordcraft/core/dist/component/component.types'
+import { get } from '@nordcraft/core/dist/utils/collections'
+import { isDefined } from '@nordcraft/core/dist/utils/util'
+import type { Rule } from '../../types'
+
+export const unknownComponentFormulaInputRule: Rule<{
+  name?: string | null
+}> = {
+  code: 'unknown component formula input',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (
+      nodeType !== 'formula' ||
+      value.type !== 'path' ||
+      value.path?.[0] !== 'Args' ||
+      ['@toddle.parent', 'item', 'index'].includes(value.path[1]) ||
+      value.path.length < 2 ||
+      path[0] !== 'components' ||
+      path[2] !== 'formulas' ||
+      path.length < 5
+    ) {
+      return
+    }
+    const [components, componentName, formulas, formulaName] = path as string[]
+    const formula: ComponentFormula = get(files, [
+      components,
+      componentName,
+      formulas,
+      formulaName,
+    ])
+    const args = formula.arguments ?? []
+    const argName = value.path[1]
+    if (!isDefined(argName) || !args.some((arg) => arg.name === argName)) {
+      report(path, { name: argName })
+    }
+  },
+}

package/src/rules/formulas/unknownFormulaRule.test.ts

@@ -0,0 +1,98 @@
+import { searchProject } from '../../searchProject'
+import { unknownFormulaRule } from './unknownFormulaRule'
+
+describe('unknownFormula', () => {
+  test('should detect apply formulas with unknown function', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {
+                    'my-class': {
+                      formula: {
+                        type: 'apply',
+                        name: 'unknown',
+                        arguments: [],
+                      },
+                    },
+                  },
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown formula')
+    expect(problems[0].details).toEqual({ name: 'unknown' })
+  })
+
+  test('should not detect apply formulas with known function', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {
+                    'my-class': {
+                      formula: {
+                        type: 'apply',
+                        name: 'known',
+                        arguments: [],
+                      },
+                    },
+                  },
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {
+                known: {
+                  name: 'known',
+                  arguments: [],
+                  formula: {
+                    type: 'value',
+                    value: null,
+                  },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownFormulaRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/formulas/unknownFormulaRule.ts

@@ -0,0 +1,21 @@
+import { isFormulaApplyOperation } from '@nordcraft/core/dist/formula/formula'
+import type { Rule } from '../../types'
+
+export const unknownFormulaRule: Rule<{
+  name: string
+}> = {
+  code: 'unknown formula',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (nodeType !== 'formula' || !isFormulaApplyOperation(value)) {
+      return
+    }
+
+    const [, componentName] = path
+    const component = files.components[componentName]
+    if (!component?.formulas?.[value.name]) {
+      report(path, { name: value.name })
+    }
+  },
+}

package/src/rules/formulas/unknownProjectFormulaInputRule.test.ts

@@ -0,0 +1,111 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+import { searchProject } from '../../searchProject'
+import { unknownProjectFormulaInputRule } from './unknownProjectFormulaInputRule'
+
+describe('unknownProjectFormulaInput', () => {
+  test('should detect invalid project formula input references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {
+            myFormula: {
+              name: 'Test',
+              formula: {
+                type: 'function',
+                name: '@toddle/concatenate',
+                arguments: [
+                  {
+                    name: '0',
+                    formula: { type: 'path', path: ['Args', 'Unknown'] },
+                  },
+                  {
+                    name: '1',
+                    formula: { type: 'path', path: ['Args', null as any] },
+                  },
+                ],
+                variableArguments: true,
+                display_name: 'Concatenate',
+              },
+              arguments: [{ name: 'Input', formula: valueFormula(null) }],
+            },
+          },
+          components: {},
+        },
+        rules: [unknownProjectFormulaInputRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(2)
+    expect(problems[0].code).toBe('unknown project formula input')
+    expect(problems[0].details).toEqual({ name: 'Unknown' })
+    expect(problems[1].code).toBe('unknown project formula input')
+    expect(problems[1].details).toEqual({ name: null })
+  })
+  test('should not detect valid project formula input references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {
+            myFormula: {
+              name: 'Test',
+              formula: {
+                type: 'function',
+                name: '@toddle/concatenate',
+                arguments: [
+                  {
+                    name: '0',
+                    formula: { type: 'path', path: ['Args', 'Input'] },
+                  },
+                ],
+                variableArguments: true,
+                display_name: 'Concatenate',
+              },
+              arguments: [{ name: 'Input', formula: valueFormula(null) }],
+            },
+          },
+          components: {},
+        },
+        rules: [unknownProjectFormulaInputRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+  test('should not detect @toddle.parent/item path formulas', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {
+            myFormula: {
+              name: 'Test',
+              formula: {
+                type: 'function',
+                name: '@toddle/concatenate',
+                arguments: [
+                  {
+                    name: '0',
+                    formula: { type: 'path', path: ['Args', 'item'] },
+                  },
+                  {
+                    name: '0',
+                    formula: {
+                      type: 'path',
+                      path: ['Args', '@toddle.parent', 'test'],
+                    },
+                  },
+                ],
+                variableArguments: true,
+                display_name: 'Concatenate',
+              },
+              arguments: [],
+            },
+          },
+          components: {},
+        },
+        rules: [unknownProjectFormulaInputRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/formulas/unknownProjectFormulaInputRule.ts

@@ -0,0 +1,32 @@
+import type { ComponentFormula } from '@nordcraft/core/dist/component/component.types'
+import { get } from '@nordcraft/core/dist/utils/collections'
+import { isDefined } from '@nordcraft/core/dist/utils/util'
+import type { Rule } from '../../types'
+
+export const unknownProjectFormulaInputRule: Rule<{
+  name?: string | null
+}> = {
+  code: 'unknown project formula input',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (
+      nodeType !== 'formula' ||
+      value.type !== 'path' ||
+      value.path?.[0] !== 'Args' ||
+      ['@toddle.parent', 'item', 'index'].includes(value.path[1]) ||
+      value.path.length < 2 ||
+      path[0] !== 'formulas' ||
+      path.length < 2
+    ) {
+      return
+    }
+    const [formulas, formulaName] = path as string[]
+    const formula: ComponentFormula = get(files, [formulas, formulaName])
+    const args = formula.arguments ?? []
+    const argName = value.path[1]
+    if (!isDefined(argName) || !args.some((arg) => arg.name === argName)) {
+      report(path, { name: argName })
+    }
+  },
+}

package/src/rules/formulas/unknownProjectFormulaRule.test.ts

@@ -0,0 +1,125 @@
+import {
+  functionFormula,
+  valueFormula,
+} from '@nordcraft/core/dist/formula/formulaUtils'
+import { searchProject } from '../../searchProject'
+import { unknownProjectFormulaRule } from './unknownProjectFormulaRule'
+
+describe('unknownProjectFormulaRule', () => {
+  test('should find unknown project formulas', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {
+                    test: functionFormula('missing-formula'),
+                    'other-test': functionFormula('package-formula', {
+                      package: 'my-package',
+                    }),
+                  },
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownProjectFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(2)
+    expect(problems[0].code).toBe('unknown project formula')
+    expect(problems[0].path).toEqual([
+      'components',
+      'test',
+      'nodes',
+      'root',
+      'attrs',
+      'test',
+    ])
+    expect(problems[1].code).toBe('unknown project formula')
+    expect(problems[1].path).toEqual([
+      'components',
+      'test',
+      'nodes',
+      'root',
+      'attrs',
+      'other-test',
+    ])
+  })
+  test('should not report known formulas', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {
+            'known-formula': {
+              formula: valueFormula(true),
+              name: 'known-formula',
+              arguments: [],
+            },
+          },
+          packages: {
+            'my-package': {
+              components: {},
+              actions: {},
+              formulas: {
+                'package-formula': {
+                  formula: valueFormula(true),
+                  name: 'package-formula',
+                  arguments: [],
+                },
+              },
+              manifest: {
+                name: 'my-package',
+                commit: '123',
+              },
+            },
+          },
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {
+                    test: functionFormula('known-formula'),
+                    'other-test': functionFormula('package-formula', {
+                      package: 'my-package',
+                    }),
+                    time: functionFormula('@toddle/now'),
+                  },
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownProjectFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})