@nordcraft/search 1.0.53 → 1.0.54

package/src/rules/issues/formulas/noReferenceProjectFormulaRule.test.ts

@@ -0,0 +1,326 @@
+import type { ProjectFiles } from '@nordcraft/ssr/dist/ssr.types'
+import { describe, expect, test } from 'bun:test'
+import { fixProject } from '../../../fixProject'
+import { searchProject } from '../../../searchProject'
+import { noReferenceProjectFormulaRule } from './noReferenceProjectFormulaRule'
+
+describe('find noReferenceFormulaRule', () => {
+  test('should detect unused global formulas', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {
+            'my-formula': {
+              name: 'my-formula',
+              arguments: [],
+              formula: {
+                type: 'value',
+                value: 'value',
+              },
+            },
+          },
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [noReferenceProjectFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('no-reference project formula')
+    expect(problems[0].path).toEqual(['formulas', 'my-formula'])
+  })
+
+  test('should detect 1 unused global formulas', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {
+            'my-formula-1': {
+              name: 'my-formula-1',
+              arguments: [],
+              formula: {
+                type: 'value',
+                value: 'value',
+              },
+            },
+            'my-formula-2': {
+              name: 'my-formula-2',
+              arguments: [],
+              formula: {
+                type: 'function',
+                name: 'my-formula-1',
+                arguments: [
+                  {
+                    name: 'my-formula-1',
+                    formula: {
+                      type: 'value',
+                      value: 'value',
+                    },
+                  },
+                ],
+              },
+            },
+          },
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [noReferenceProjectFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('no-reference project formula')
+    expect(problems[0].path).toEqual(['formulas', 'my-formula-2'])
+  })
+
+  test('should not detect unused global formulas', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {
+            'my-formula-1': {
+              name: 'my-formula-1',
+              arguments: [],
+              formula: {
+                type: 'value',
+                value: 'value',
+              },
+            },
+            'my-formula-2': {
+              name: 'my-formula-2',
+              arguments: [],
+              formula: {
+                type: 'value',
+                value: 'value',
+              },
+            },
+          },
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {
+                    'my-class': {
+                      formula: {
+                        type: 'function',
+                        name: 'my-formula-2',
+                        arguments: [],
+                      },
+                    },
+                  },
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {
+                'my-formula-3': {
+                  name: 'my-formula-3',
+                  arguments: [],
+                  formula: {
+                    type: 'function',
+                    name: 'my-formula-1',
+                    arguments: [
+                      {
+                        name: 'my-formula-1',
+                        formula: {
+                          type: 'value',
+                          value: 'value',
+                        },
+                      },
+                    ],
+                  },
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [noReferenceProjectFormulaRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+  test('should not detect unused global formulas used in API services', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {
+            'my-formula-1': {
+              name: 'my-formula-1',
+              arguments: [],
+              formula: {
+                type: 'value',
+                value: 'value',
+              },
+            },
+          },
+          components: {},
+          services: {
+            myService: {
+              type: 'supabase',
+              name: 'myService',
+              baseUrl: {
+                type: 'function',
+                name: 'my-formula-1',
+                arguments: [],
+              },
+            },
+          },
+        },
+        rules: [noReferenceProjectFormulaRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+  test('should not detect unused global formulas used in routes', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {
+            'my-formula-1': {
+              name: 'my-formula-1',
+              arguments: [],
+              formula: {
+                type: 'value',
+                value: 'value',
+              },
+            },
+          },
+          components: {},
+          routes: {
+            myRoute: {
+              type: 'redirect',
+              source: {
+                path: [],
+                query: {},
+              },
+              destination: {
+                path: {
+                  p1: {
+                    formula: {
+                      type: 'function',
+                      name: 'my-formula-1',
+                      arguments: [],
+                    },
+                    index: 0,
+                  },
+                },
+                '@nordcraft/metadata': {
+                  comments: null,
+                },
+              },
+            },
+          },
+        },
+        rules: [noReferenceProjectFormulaRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+
+  test('should not detect unused exported global formulas', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {
+            'my-formula': {
+              name: 'my-formula',
+              arguments: [],
+              formula: {
+                type: 'value',
+                value: 'value',
+              },
+              exported: true,
+            },
+          },
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [noReferenceProjectFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})
+
+describe('fix noReferenceFormulaRule', () => {
+  test('should remove unused global formulas', () => {
+    const projectFiles: ProjectFiles = {
+      formulas: {
+        'my-formula': {
+          name: 'my-formula',
+          arguments: [],
+          formula: {
+            type: 'value',
+            value: 'value',
+          },
+        },
+      },
+      components: {
+        test: {
+          name: 'test',
+          nodes: {},
+          formulas: {},
+          apis: {},
+          attributes: {},
+          variables: {},
+        },
+      },
+    }
+    const fixedProject = fixProject({
+      files: projectFiles,
+      rule: noReferenceProjectFormulaRule,
+      fixType: 'delete-project-formula',
+    })
+    expect(fixedProject.formulas).toEqual({})
+  })
+})

package/src/rules/issues/formulas/noReferenceProjectFormulaRule.ts

@@ -0,0 +1,125 @@
+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'
+import { removeFromPathFix } from '../../../util/removeUnused.fix'
+
+export const noReferenceProjectFormulaRule: Rule<void> = {
+  code: 'no-reference project formula',
+  level: 'warning',
+  category: 'No References',
+  visit: (report, { value, path, files, 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 { path: _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 { path: _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, undefined, ['delete-project-formula'])
+  },
+  fixes: {
+    'delete-project-formula': removeFromPathFix,
+  },
+}
+
+export type NoReferenceProjectFormulaRuleFix = 'delete-project-formula'
+
+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/issues/formulas/unknownComponentFormulaInputRule.test.ts

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