@nordcraft/search 1.0.0

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

@@ -0,0 +1,343 @@
+import { HeadTagTypes } from '@nordcraft/core/dist/component/component.types'
+import { searchProject } from '../../searchProject'
+import { noReferenceComponentFormulaRule } from './noReferenceComponentFormulaRule'
+
+describe('noReferenceComponentFormulaRule', () => {
+  test('should detect component formulas with no references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            page: {
+              name: 'my-page',
+              nodes: {},
+              formulas: {
+                'my-formula': {
+                  name: 'my-formula',
+                  formula: {
+                    type: 'function',
+                    name: '@toddle/number',
+                    arguments: [
+                      {
+                        name: 'Input',
+                        formula: { type: 'value', value: 5 },
+                      },
+                    ],
+                  },
+                  arguments: [],
+                  memoize: false,
+                  exposeInContext: true,
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {
+                'my-variable': {
+                  initialValue: { type: 'value', value: 5 },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              route: {
+                info: {},
+                path: [],
+                query: {},
+              },
+            },
+          },
+        },
+        rules: [noReferenceComponentFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('no-reference component formula')
+    expect(problems[0].path).toEqual([
+      'components',
+      'page',
+      'formulas',
+      'my-formula',
+    ])
+  })
+
+  test('should not detect component formulas with references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            page: {
+              name: 'my-page',
+              nodes: {},
+              formulas: {
+                'my-formula': {
+                  name: 'my-formula',
+                  formula: {
+                    type: 'function',
+                    name: '@toddle/number',
+                    arguments: [
+                      {
+                        name: 'Input',
+                        formula: { type: 'value', value: 5 },
+                      },
+                    ],
+                  },
+                  arguments: [],
+                  memoize: false,
+                  exposeInContext: true,
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+                'my-formula2': {
+                  name: 'my-formula2',
+                  formula: {
+                    type: 'function',
+                    name: '@toddle/number',
+                    arguments: [],
+                  },
+                  arguments: [],
+                  memoize: false,
+                  exposeInContext: true,
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {
+                'my-variable': {
+                  initialValue: {
+                    type: 'apply',
+                    name: 'my-formula',
+                    arguments: [],
+                  },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              route: {
+                info: {
+                  meta: {
+                    xyz: {
+                      tag: HeadTagTypes.Script,
+                      attrs: {},
+                      content: {
+                        type: 'apply',
+                        name: 'my-formula2',
+                        arguments: [],
+                      },
+                    },
+                  },
+                },
+                path: [],
+                query: {},
+              },
+            },
+          },
+        },
+        rules: [noReferenceComponentFormulaRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+
+  test('should not detect component formulas with references through context', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            page: {
+              name: 'my-page',
+              nodes: {},
+              formulas: {
+                'my-formula': {
+                  name: 'my-formula',
+                  formula: {
+                    type: 'function',
+                    name: '@toddle/number',
+                    arguments: [
+                      {
+                        name: 'Input',
+                        formula: { type: 'value', value: 5 },
+                      },
+                    ],
+                  },
+                  arguments: [],
+                  memoize: false,
+                  exposeInContext: true,
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                info: {},
+                path: [],
+                query: {},
+              },
+            },
+            'my-component': {
+              name: 'my-component',
+              nodes: {},
+
+              apis: {},
+              attributes: {},
+              variables: {
+                'my-variable': {
+                  initialValue: {
+                    type: 'path',
+                    path: ['Contexts', 'page', 'my-formula'],
+                  },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              contexts: {
+                page: {
+                  formulas: ['my-formula'],
+                  workflows: [],
+                },
+              },
+            },
+          },
+        },
+        rules: [noReferenceComponentFormulaRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+
+  test('should report when subscribed, but no usage', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            page: {
+              name: 'my-page',
+              nodes: {},
+              formulas: {
+                'my-formula': {
+                  name: 'my-formula',
+                  formula: {
+                    type: 'function',
+                    name: '@toddle/number',
+                    arguments: [
+                      {
+                        name: 'Input',
+                        formula: { type: 'value', value: 5 },
+                      },
+                    ],
+                  },
+                  arguments: [],
+                  memoize: false,
+                  exposeInContext: true,
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                info: {},
+                path: [],
+                query: {},
+              },
+            },
+            'my-component': {
+              name: 'my-component',
+              nodes: {},
+
+              apis: {},
+              attributes: {},
+              variables: {},
+              contexts: {
+                page: {
+                  formulas: ['my-formula'],
+                  workflows: [],
+                },
+              },
+            },
+          },
+        },
+        rules: [noReferenceComponentFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('no-reference component formula')
+    expect(problems[0].details).toEqual({
+      contextSubscribers: ['my-component'],
+      name: 'my-formula',
+    })
+  })
+
+  test('should detect formulas that only reference themselves', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            page: {
+              name: 'my-page',
+              nodes: {},
+              formulas: {
+                'my-formula': {
+                  name: 'my-formula',
+                  formula: {
+                    type: 'function',
+                    name: '@toddle/number',
+                    arguments: [
+                      {
+                        name: 'Input',
+                        formula: {
+                          type: 'apply',
+                          name: 'my-formula',
+                          arguments: [],
+                        },
+                      },
+                    ],
+                  },
+                  arguments: [],
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                info: {},
+                path: [],
+                query: {},
+              },
+            },
+          },
+        },
+        rules: [noReferenceComponentFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('no-reference component formula')
+    expect(problems[0].path).toEqual([
+      'components',
+      'page',
+      'formulas',
+      'my-formula',
+    ])
+  })
+})

package/src/rules/formulas/noReferenceComponentFormulaRule.ts

@@ -0,0 +1,72 @@
+import { ToddleComponent } from '@nordcraft/core/dist/component/ToddleComponent'
+import type { Rule } from '../../types'
+
+export const noReferenceComponentFormulaRule: Rule<{
+  name: string
+  contextSubscribers: string[]
+}> = {
+  code: 'no-reference component formula',
+  level: 'warning',
+  category: 'No References',
+  visit: (report, args) => {
+    if (args.nodeType !== 'component-formula') {
+      return
+    }
+
+    const { path, files, value, component } = args
+    const [, componentName, , formulaKey] = path
+    for (const [formulaPath, formula] of component.formulasInComponent()) {
+      if (
+        formula.type === 'apply' &&
+        formula.name === formulaKey &&
+        // Disregard own formula reference.
+        // Similar to typescript etc. we do not report purely circular references, only references to self:
+        // A -> B -> A is not reported as unused, as removing A would break B and vice versa. Even if they are
+        // ultimately unused, removing one and breaking the other is likely an unintended side effect.
+        !(formulaPath[0] === 'formulas' && formulaPath[1] === formulaKey)
+      ) {
+        return
+      }
+    }
+
+    // It is possible that a formula is never used, but still has subscribers
+    const contextSubscribers = []
+    if (value.exposeInContext) {
+      for (const _component of Object.values(files.components)) {
+        // Enforce that the component is not undefined since we're iterating
+        const component = _component!
+        for (const [contextKey, context] of Object.entries(
+          component.contexts ?? {},
+        )) {
+          if (
+            contextKey === componentName &&
+            context.formulas.includes(formulaKey.toString())
+          ) {
+            contextSubscribers.push(component.name)
+            const contextComponent = new ToddleComponent({
+              component,
+              getComponent: (name) => files.components[name],
+              packageName: undefined,
+              globalFormulas: {
+                formulas: files.formulas,
+                packages: files.packages,
+              },
+            })
+            for (const [, formula] of contextComponent.formulasInComponent()) {
+              if (
+                formula.type === 'path' &&
+                formula.path[0] === 'Contexts' &&
+                formula.path[1] === componentName &&
+                formula.path[2] === formulaKey
+              ) {
+                return
+              }
+            }
+          }
+        }
+      }
+    }
+
+    report(path, { contextSubscribers, name: value.name })
+  },
+}

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

@@ -0,0 +1,290 @@
+import { searchProject } from '../../searchProject'
+import { noReferenceProjectFormulaRule } from './noReferenceProjectFormulaRule'
+
+describe('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',
+                        },
+                      },
+                    ],
+                  },
+                  '@toddle/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,
+                  },
+                },
+                '@toddle/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)
+  })
+})