@nordcraft/search 1.0.38 → 1.0.40

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

@@ -1,8 +1,10 @@
+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('noReferenceFormulaRule', () => {
+describe('find noReferenceFormulaRule', () => {
   test('should detect unused global formulas', () => {
     const problems = Array.from(
       searchProject({
@@ -289,3 +291,36 @@ describe('noReferenceFormulaRule', () => {
     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/formulas/noReferenceProjectFormulaRule.ts

@@ -1,92 +1,106 @@
 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 { omit } from '@nordcraft/core/dist/utils/collections'
 import { ToddleApiService } from '@nordcraft/ssr/dist/ToddleApiService'
 import { ToddleRoute } from '@nordcraft/ssr/dist/ToddleRoute'
-import type { Rule } from '../../types'
+import type { NodeType, 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) {
+  visit: (report, details) => {
+    if (hasReferences(details)) {
       return
     }
+    report(details.path, undefined, ['delete-project-formula'])
+  },
+  fixes: {
+    'delete-project-formula': (data) => {
+      if (hasReferences(data)) {
+        return
+      }
+      return omit(data.files, data.path)
+    },
+  },
+}
 
-    // 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
-        }
+export type NoReferenceProjectFormulaRuleFix = 'delete-project-formula'
+
+const hasReferences = ({ value, files, nodeType, memo }: NodeType) => {
+  if (nodeType !== 'project-formula' || value.exported === true) {
+    return true
+  }
+
+  // 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 true
       }
     }
+  }
 
-    // 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
-        }
+  // 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 true
       }
     }
+  }
 
-    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)
-            }
-          }
+  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
+      }
     }
+    return usedFormulas
+  })
 
-    // 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
-      }
+  if (componentFormulaReferences.has(value.name)) {
+    return true
+  }
 
-      // Check if the formula is used in the formula
-      if (isToddleFormula(f) && checkFormula(f.formula, 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
     }
 
-    report(path)
-  },
+    // Check if the formula is used in the formula
+    if (isToddleFormula(f) && checkFormula(f.formula, value.name)) {
+      return true
+    }
+  }
+  return false
 }
 
 const checkArguments = (