@nordcraft/search 1.0.0

package/src/rules/apis/noReferenceApiRule.test.ts

@@ -0,0 +1,164 @@
+import {
+  pathFormula,
+  valueFormula,
+} from '@nordcraft/core/dist/formula/formulaUtils'
+import { searchProject } from '../../searchProject'
+import { noReferenceApiRule } from './noReferenceApiRule'
+
+describe('noReferenceApiRule', () => {
+  test('should detect APIs with no references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            apiComponent: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {
+                'my-legacy-api': {
+                  name: 'my-legacy-api',
+                  type: 'REST',
+                  autoFetch: valueFormula(true),
+                  onCompleted: null,
+                  onFailed: null,
+                },
+                'my-api': {
+                  name: 'my-api',
+                  type: 'http',
+                  version: 2,
+                  autoFetch: valueFormula(true),
+                  inputs: {},
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [noReferenceApiRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(2)
+    expect(problems[0].code).toBe('no-reference api')
+    expect(problems[0].path).toEqual([
+      'components',
+      'apiComponent',
+      'apis',
+      'my-legacy-api',
+    ])
+    expect(problems[1].code).toBe('no-reference api')
+    expect(problems[1].path).toEqual([
+      'components',
+      'apiComponent',
+      'apis',
+      'my-api',
+    ])
+  })
+
+  test('should not detect APIs with references from formulas', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            apiComponent: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  tag: 'p',
+                  attrs: {},
+                  condition: pathFormula(['Apis', 'my-api', 'data', 'success']),
+                  style: {},
+                  children: [],
+                  classes: {},
+                  events: {},
+                },
+              },
+              formulas: {},
+              apis: {
+                'my-api': {
+                  name: 'my-api',
+                  type: 'http',
+                  version: 2,
+                  autoFetch: valueFormula(true),
+                  inputs: {},
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [noReferenceApiRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+  test('should not detect APIs with references from actions', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            apiComponent: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  tag: 'button',
+                  attrs: {},
+                  style: {},
+                  children: [],
+                  classes: {},
+                  events: {
+                    onClick: {
+                      trigger: 'onClick',
+                      actions: [
+                        {
+                          type: 'Fetch',
+                          api: 'my-api',
+                          inputs: {},
+                          onSuccess: { actions: [] },
+                          onError: { actions: [] },
+                        },
+                      ],
+                    },
+                  },
+                },
+              },
+              formulas: {},
+              apis: {
+                'my-api': {
+                  name: 'my-api',
+                  type: 'http',
+                  version: 2,
+                  autoFetch: valueFormula(true),
+                  inputs: {},
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [noReferenceApiRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/apis/noReferenceApiRule.ts

@@ -0,0 +1,42 @@
+import type { Rule } from '../../types'
+
+export const noReferenceApiRule: Rule<void> = {
+  code: 'no-reference api',
+  level: 'warning',
+  category: 'No References',
+  visit: (report, args) => {
+    if (args.nodeType !== 'component-api') {
+      return
+    }
+    const { path, value, memo, component } = args
+    if (!component) {
+      return
+    }
+
+    const componentApiReferences = memo(
+      `componentApiReferences/${component.name}]`,
+      () => {
+        const usedApis = new Set<string>()
+        for (const [, formula] of component.formulasInComponent()) {
+          if (
+            formula.type === 'path' &&
+            formula.path[0] === 'Apis' &&
+            typeof formula.path[1] === 'string'
+          ) {
+            usedApis.add(formula.path[1])
+          }
+        }
+        for (const [, action] of component.actionModelsInComponent()) {
+          if (action.type === 'Fetch') {
+            usedApis.add(action.api)
+          }
+        }
+        return usedApis
+      },
+    )
+    if (componentApiReferences.has(value.name)) {
+      return
+    }
+    report(path)
+  },
+}

package/src/rules/apis/unknownApiInputRule.test.ts

@@ -0,0 +1,85 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+import { searchProject } from '../../searchProject'
+import { unknownApiInputRule } from './unknownApiInputRule'
+
+describe('unknownApiInput', () => {
+  test('should report reading unknown api inputs from a formula', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {
+                'my-api': {
+                  name: 'my-api',
+                  type: 'http',
+                  version: 2,
+                  autoFetch: valueFormula(true),
+                  inputs: {},
+                  body: {
+                    type: 'path',
+                    path: ['ApiInputs', 'unknown-input'],
+                  },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownApiInputRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown api input')
+    expect(problems[0].details).toEqual({ name: 'unknown-input' })
+  })
+
+  test('should not report API inputs that exist', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {
+                'my-api': {
+                  name: 'my-api',
+                  type: 'http',
+                  version: 2,
+                  autoFetch: valueFormula(true),
+                  inputs: {
+                    'known-input': {
+                      formula: valueFormula('hello'),
+                    },
+                  },
+                  body: {
+                    type: 'path',
+                    path: ['ApiInputs', 'known-input'],
+                  },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownApiInputRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/apis/unknownApiInputRule.ts

@@ -0,0 +1,33 @@
+import type { ApiRequest } from '@nordcraft/core/dist/api/apiTypes'
+import type { Rule } from '../../types'
+
+export const unknownApiInputRule: Rule<{
+  name: string
+}> = {
+  code: 'unknown api input',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (
+      nodeType !== 'formula' ||
+      value.type !== 'path' ||
+      value.path[0] !== 'ApiInputs' ||
+      typeof value.path[1] !== 'string' ||
+      path.length < 4
+    ) {
+      return
+    }
+    const [_components, componentName, _apis, apiKey] = path
+    if (typeof apiKey !== 'string') {
+      return
+    }
+    const apiInput = (
+      files.components?.[componentName]?.apis?.[apiKey] as
+        | ApiRequest
+        | undefined
+    )?.inputs?.[value.path[1]]
+    if (!apiInput) {
+      report(path, { name: value.path[1] })
+    }
+  },
+}

package/src/rules/apis/unknownApiRule.test.ts

@@ -0,0 +1,159 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+import { searchProject } from '../../searchProject'
+import { unknownApiRule } from './unknownApiRule'
+
+describe('unknownApi', () => {
+  test('should report reading unknown apis from formula', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {
+                    'my-class': {
+                      formula: {
+                        type: 'path',
+                        path: ['Apis', 'my-api'],
+                      },
+                    },
+                  },
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownApiRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown api')
+    expect(problems[0].details).toEqual({ name: 'my-api' })
+  })
+
+  test('should report reading unknown apis from actions', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            apiComponent: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  tag: 'button',
+                  attrs: {},
+                  style: {},
+                  children: [],
+                  classes: {},
+                  events: {
+                    onClick: {
+                      trigger: 'onClick',
+                      actions: [
+                        {
+                          type: 'Fetch',
+                          api: 'unknown-api',
+                          inputs: {},
+                          onSuccess: { actions: [] },
+                          onError: { actions: [] },
+                        },
+                      ],
+                    },
+                  },
+                },
+              },
+              formulas: {},
+              apis: {
+                'my-api': {
+                  name: 'my-api',
+                  type: 'http',
+                  version: 2,
+                  autoFetch: valueFormula(true),
+                  inputs: {},
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownApiRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown api')
+    expect(problems[0].details).toEqual({ name: 'unknown-api' })
+  })
+
+  test('should not report APIs that exist', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {
+                    'my-class': {
+                      formula: {
+                        type: 'path',
+                        path: ['Apis', 'my-api', 'data'],
+                      },
+                    },
+                  },
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {
+                'my-api': {
+                  name: 'my-api',
+                  type: 'REST',
+                  onCompleted: null,
+                  onFailed: null,
+                },
+              },
+              variables: {},
+              attributes: {
+                known: {
+                  name: 'known',
+                  testValue: { type: 'value', value: null },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownApiRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/apis/unknownApiRule.ts

@@ -0,0 +1,31 @@
+import type { Rule } from '../../types'
+
+export const unknownApiRule: Rule<{
+  name: string
+}> = {
+  code: 'unknown api',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    const isApiFormula =
+      nodeType === 'formula' &&
+      value.type === 'path' &&
+      value.path[0] === 'Apis'
+    const isApiAction = nodeType === 'action-model' && value.type === 'Fetch'
+    if (!isApiFormula && !isApiAction) {
+      return
+    }
+    const [, componentName] = path
+    const component = files.components[componentName]
+    if (isApiFormula) {
+      const [, apiKey] = value.path
+      if (!component?.apis?.[apiKey]) {
+        report(path, { name: apiKey })
+      }
+    } else if (isApiAction) {
+      if (!component?.apis?.[value.api]) {
+        report(path, { name: value.api })
+      }
+    }
+  },
+}

package/src/rules/attributes/noReferenceAttributeRule.test.ts

@@ -0,0 +1,138 @@
+import { searchProject } from '../../searchProject'
+import { noReferenceAttributeRule } from './noReferenceAttributeRule'
+
+describe('noReferenceAttributeRule', () => {
+  test('should detect attributes with no references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {
+                'my-attribute': {
+                  name: 'my-attribute-name',
+                  testValue: { type: 'value', value: null },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              variables: {},
+            },
+          },
+        },
+        rules: [noReferenceAttributeRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('no-reference attribute')
+    expect(problems[0].path).toEqual([
+      'components',
+      'test',
+      'attributes',
+      'my-attribute',
+    ])
+  })
+
+  test('should not detect attributes with references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {
+                'my-formula': {
+                  name: 'my-formula',
+                  arguments: [],
+                  formula: {
+                    type: 'apply',
+                    name: 'test',
+                    arguments: [
+                      {
+                        formula: {
+                          type: 'path',
+                          path: ['Attributes', 'my-attribute'],
+                        },
+                      },
+                    ],
+                  },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              apis: {},
+              attributes: {
+                'my-attribute': {
+                  name: 'my-attribute',
+                  testValue: { type: 'value', value: null },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              variables: {},
+            },
+          },
+        },
+        rules: [noReferenceAttributeRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+
+  test('should work for legacy attributes without a `name` property', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {
+                'my-formula': {
+                  name: 'my-formula',
+                  arguments: [],
+                  formula: {
+                    type: 'apply',
+                    name: 'test',
+                    arguments: [
+                      {
+                        formula: {
+                          type: 'path',
+                          path: ['Attributes', 'my-attribute'],
+                        },
+                      },
+                    ],
+                  },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              apis: {},
+              attributes: {
+                'my-attribute': {
+                  testValue: { type: 'value', value: null },
+                } as any,
+              },
+              variables: {},
+            },
+          },
+        },
+        rules: [noReferenceAttributeRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/attributes/noReferenceAttributeRule.ts

@@ -0,0 +1,32 @@
+import type { Rule } from '../../types'
+
+export const noReferenceAttributeRule: Rule<void> = {
+  code: 'no-reference attribute',
+  level: 'warning',
+  category: 'No References',
+  visit: (report, args) => {
+    if (args.nodeType !== 'component-attribute') {
+      return
+    }
+    const { path, component, memo } = args
+    const [_components, _component, _attributes, attributeKey] = path
+    if (typeof attributeKey !== 'string') {
+      return
+    }
+    const attrs = memo(`${component.name}-attrs`, () => {
+      const attrs = new Set<string>()
+      for (const [, formula] of component.formulasInComponent()) {
+        if (formula.type === 'path' && formula.path[0] === 'Attributes') {
+          attrs.add(formula.path[1])
+        }
+      }
+
+      return attrs
+    })
+    if (attrs.has(attributeKey)) {
+      return
+    }
+
+    report(path)
+  },
+}