@nordcraft/search 1.0.53 → 1.0.55

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

@@ -0,0 +1,231 @@
+import {
+  pathFormula,
+  valueFormula,
+} from '@nordcraft/core/dist/formula/formulaUtils'
+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 { noReferenceApiRule } from './noReferenceApiRule'
+
+describe('find 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: {},
+                  '@nordcraft/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: {},
+                  '@nordcraft/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: {},
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [noReferenceApiRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})
+
+describe('fix noReferenceApiRule', () => {
+  test('should remove unused APIs', () => {
+    const project: ProjectFiles = {
+      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: {},
+              '@nordcraft/metadata': {
+                comments: null,
+              },
+            },
+            'used-api': {
+              name: 'used-api',
+              type: 'http',
+              version: 2,
+              autoFetch: valueFormula(true),
+              inputs: {},
+            },
+          },
+          onLoad: {
+            trigger: 'onLoad',
+            actions: [
+              {
+                type: 'Fetch',
+                api: 'used-api',
+                inputs: {},
+                onSuccess: { actions: [] },
+                onError: { actions: [] },
+              },
+            ],
+          },
+          attributes: {},
+          variables: {},
+        },
+      },
+    }
+    const fixedProject = fixProject({
+      files: project,
+      rule: noReferenceApiRule,
+      fixType: 'delete-api',
+    })
+    // 2/3 APIs should be removed
+    expect(Object.keys(fixedProject.components['apiComponent']!.apis)).toEqual([
+      'used-api',
+    ])
+  })
+})

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

@@ -0,0 +1,49 @@
+import type { Rule } from '../../../types'
+import { removeFromPathFix } from '../../../util/removeUnused.fix'
+
+export const noReferenceApiRule: Rule<void> = {
+  code: 'no-reference api',
+  level: 'warning',
+  category: 'No References',
+  visit: (report, args) => {
+    if (args.nodeType !== 'component-api') {
+      return
+    }
+    const { value, memo, component } = args
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    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(args.path, undefined, ['delete-api'])
+  },
+  fixes: {
+    'delete-api': removeFromPathFix,
+  },
+}
+
+export type NoReferenceApiRuleFix = 'delete-api'

package/src/rules/issues/apis/noReferenceApiServiceRule.test.ts

@@ -0,0 +1,103 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+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 { noReferenceApiServiceRule } from './noReferenceApiServiceRule'
+
+describe('find noReferenceApiServiceRule', () => {
+  test('should detect API services with no references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          services: {
+            'unused-service': {
+              name: 'my-service',
+              type: 'supabase',
+              meta: {},
+            },
+            'used-service': {
+              name: 'used-service',
+              type: 'supabase',
+              meta: {},
+            },
+          },
+          components: {
+            apiComponent: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {
+                'my-api': {
+                  name: 'my-api',
+                  type: 'http',
+                  version: 2,
+                  autoFetch: valueFormula(true),
+                  inputs: {},
+                  service: 'used-service',
+                },
+              },
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [noReferenceApiServiceRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('no-reference api service')
+    expect(problems[0].path).toEqual(['services', 'unused-service'])
+  })
+})
+
+describe('fix noReferenceApiServiceRule', () => {
+  test('should remove unused API services', () => {
+    const project: ProjectFiles = {
+      formulas: {},
+      services: {
+        'unused-service': {
+          name: 'my-service',
+          type: 'supabase',
+          meta: {},
+        },
+        'used-service': {
+          name: 'used-service',
+          type: 'supabase',
+          meta: {},
+        },
+      },
+      components: {
+        apiComponent: {
+          name: 'test',
+          nodes: {},
+          formulas: {},
+          apis: {
+            'my-api': {
+              name: 'my-api',
+              type: 'http',
+              version: 2,
+              autoFetch: valueFormula(true),
+              inputs: {},
+              service: 'used-service',
+            },
+          },
+          onLoad: {
+            trigger: 'onLoad',
+            actions: [],
+          },
+          attributes: {},
+          variables: {},
+        },
+      },
+    }
+    const fixedProject = fixProject({
+      files: project,
+      rule: noReferenceApiServiceRule,
+      fixType: 'delete-api-service',
+    })
+    expect(Object.keys(fixedProject.services!)).toHaveLength(1)
+  })
+})

package/src/rules/issues/apis/noReferenceApiServiceRule.ts

@@ -0,0 +1,43 @@
+import { isLegacyApi } from '@nordcraft/core/dist/api/api'
+import type { Rule } from '../../../types'
+import { removeFromPathFix } from '../../../util/removeUnused.fix'
+
+export const noReferenceApiServiceRule: Rule<{ serviceName: string }> = {
+  code: 'no-reference api service',
+  level: 'warning',
+  category: 'No References',
+  visit: (report, args) => {
+    if (args.nodeType !== 'api-service') {
+      return
+    }
+    const { value, memo, path } = args
+    const serviceName = path.at(-1)
+    if (typeof serviceName !== 'string') {
+      return
+    }
+
+    const apiServiceReferences = memo(`apiServiceReferences`, () => {
+      const usedServices = new Set<string>()
+      Object.values(args.files.components).forEach((component) => {
+        if (!component) {
+          return
+        }
+        Object.values(component.apis).forEach((api) => {
+          if (!isLegacyApi(api) && typeof api.service === 'string') {
+            usedServices.add(api.service)
+          }
+        })
+      })
+      return usedServices
+    })
+    if (apiServiceReferences.has(value.name)) {
+      return
+    }
+    report(args.path, { serviceName }, ['delete-api-service'])
+  },
+  fixes: {
+    'delete-api-service': removeFromPathFix,
+  },
+}
+
+export type NoReferenceApiServiceRuleFix = 'delete-api-service'

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

@@ -0,0 +1,86 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+import { describe, expect, test } from 'bun:test'
+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'],
+                  },
+                  '@nordcraft/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'],
+                  },
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownApiInputRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/issues/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/issues/apis/unknownApiRule.test.ts

@@ -0,0 +1,160 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+import { describe, expect, test } from 'bun:test'
+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: {},
+                  '@nordcraft/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 },
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownApiRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})