@nordcraft/search 1.0.53 → 1.0.55

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

@@ -1,326 +0,0 @@
-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/formulas/noReferenceProjectFormulaRule.ts

@@ -1,125 +0,0 @@
-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/formulas/unknownComponentFormulaInputRule.test.ts

@@ -1,141 +0,0 @@
-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/formulas/unknownComponentFormulaInputRule.ts

@@ -1,38 +0,0 @@
-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 })
-    }
-  },
-}