@nordcraft/search 1.0.53 → 1.0.54

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

@@ -0,0 +1,152 @@
+import type { ApiRequest } from '@nordcraft/core/dist/api/apiTypes'
+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 { unknownApiServiceRule } from './unknownApiServiceRule'
+
+describe('find unknownApiServiceRule', () => {
+  test('should detect references to unknown services', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          services: {
+            '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',
+                },
+                'my-other-api': {
+                  name: 'my-other-api',
+                  type: 'http',
+                  version: 2,
+                  autoFetch: valueFormula(true),
+                  inputs: {},
+                  service: 'unknown-service',
+                },
+              },
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownApiServiceRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown api service')
+    expect(problems[0].path).toEqual([
+      'components',
+      'apiComponent',
+      'apis',
+      'my-other-api',
+      'service',
+    ])
+    expect(problems[0].details).toEqual({
+      apiName: 'my-other-api',
+      serviceName: 'unknown-service',
+    })
+  })
+})
+
+describe('fix unknownApiServiceRule', () => {
+  test('should remove references to unknown services', () => {
+    const project: ProjectFiles = {
+      formulas: {},
+      services: {
+        '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',
+            },
+            'my-other-api': {
+              name: 'my-api',
+              type: 'http',
+              version: 2,
+              autoFetch: valueFormula(true),
+              inputs: {},
+              service: 'unknown-service',
+            },
+          },
+          onLoad: {
+            trigger: 'onLoad',
+            actions: [],
+          },
+          attributes: {},
+          variables: {},
+        },
+      },
+    }
+    const fixedProject = fixProject({
+      files: project,
+      rule: unknownApiServiceRule,
+      fixType: 'delete-api-service-reference',
+    })
+    expect(
+      (
+        fixedProject.components['apiComponent']?.apis[
+          'my-other-api'
+        ] as ApiRequest
+      ).service,
+    ).toBeUndefined()
+    expect(fixedProject.components['apiComponent']?.apis)
+      .toMatchInlineSnapshot(`
+      {
+        "my-api": {
+          "autoFetch": {
+            "type": "value",
+            "value": true,
+          },
+          "inputs": {},
+          "name": "my-api",
+          "service": "used-service",
+          "type": "http",
+          "version": 2,
+        },
+        "my-other-api": {
+          "autoFetch": {
+            "type": "value",
+            "value": true,
+          },
+          "inputs": {},
+          "name": "my-api",
+          "type": "http",
+          "version": 2,
+        },
+      }
+    `)
+  })
+})

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

@@ -0,0 +1,33 @@
+import { isLegacyApi } from '@nordcraft/core/dist/api/api'
+import { isDefined } from '@nordcraft/core/dist/utils/util'
+import type { Rule } from '../../../types'
+import { removeFromPathFix } from '../../../util/removeUnused.fix'
+
+export const unknownApiServiceRule: Rule<{
+  apiName: string
+  serviceName: string
+}> = {
+  code: 'unknown api service',
+  level: 'warning',
+  category: 'Unknown Reference',
+  visit: (report, args) => {
+    if (
+      args.nodeType !== 'component-api' ||
+      isLegacyApi(args.value) ||
+      !isDefined(args.value.service) ||
+      isDefined(args.files.services?.[args.value.service])
+    ) {
+      return
+    }
+    report(
+      [...args.path, 'service'],
+      { apiName: args.value.name, serviceName: args.value.service },
+      ['delete-api-service-reference'],
+    )
+  },
+  fixes: {
+    'delete-api-service-reference': removeFromPathFix,
+  },
+}
+
+export type UnknownApiServiceRuleFix = 'delete-api-service-reference'

package/src/rules/issues/attributes/attributeRules.index.ts

@@ -0,0 +1,9 @@
+import { noReferenceAttributeRule } from './noReferenceAttributeRule'
+import { unknownAttributeRule } from './unknownAttributeRule'
+import { unknownComponentAttributeRule } from './unknownComponentAttributeRule'
+
+export default [
+  noReferenceAttributeRule,
+  unknownAttributeRule,
+  unknownComponentAttributeRule,
+]

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

@@ -0,0 +1,173 @@
+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 { noReferenceAttributeRule } from './noReferenceAttributeRule'
+
+describe('find 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 },
+                  '@nordcraft/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'],
+                        },
+                      },
+                    ],
+                  },
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              apis: {},
+              attributes: {
+                'my-attribute': {
+                  name: 'my-attribute',
+                  testValue: { type: 'value', value: null },
+                  '@nordcraft/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'],
+                        },
+                      },
+                    ],
+                  },
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              apis: {},
+              attributes: {
+                'my-attribute': {
+                  testValue: { type: 'value', value: null },
+                } as any,
+              },
+              variables: {},
+            },
+          },
+        },
+        rules: [noReferenceAttributeRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})
+
+describe('fix noReferenceAttributeRule', () => {
+  test('should remove attributes with no references', () => {
+    const files: ProjectFiles = {
+      formulas: {},
+      components: {
+        test: {
+          name: 'test',
+          nodes: {},
+          formulas: {},
+          apis: {},
+          attributes: {
+            'my-attribute': {
+              name: 'my-attribute-name',
+              testValue: { type: 'value', value: null },
+              '@nordcraft/metadata': {
+                comments: null,
+              },
+            },
+          },
+          variables: {},
+        },
+      },
+    }
+    const fixedFiles = fixProject({
+      files,
+      rule: noReferenceAttributeRule,
+      fixType: 'delete-attribute',
+    })
+    expect(fixedFiles.components['test']?.attributes).toEqual({})
+  })
+})

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

@@ -0,0 +1,37 @@
+import type { Rule } from '../../../types'
+import { removeFromPathFix } from '../../../util/removeUnused.fix'
+
+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(args.path, undefined, ['delete-attribute'])
+  },
+  fixes: {
+    'delete-attribute': removeFromPathFix,
+  },
+}
+
+export type NoReferenceAttributeRuleFix = 'delete-attribute'

package/src/rules/issues/attributes/unknownAttributeRule.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, test } from 'bun:test'
+import { searchProject } from '../../../searchProject'
+import { unknownAttributeRule } from './unknownAttributeRule'
+
+describe('unknownAttribute', () => {
+  test('should report reading unknown attributes', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {
+                    'my-class': {
+                      formula: {
+                        type: 'path',
+                        path: ['Attributes', 'unknown'],
+                      },
+                    },
+                  },
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownAttributeRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown attribute')
+    expect(problems[0].details).toEqual({ name: 'unknown' })
+  })
+
+  test('should not report attributes that exist', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {
+                    'my-class': {
+                      formula: {
+                        type: 'path',
+                        path: ['Attributes', 'known'],
+                      },
+                    },
+                  },
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              variables: {},
+              attributes: {
+                known: {
+                  name: 'known',
+                  testValue: { type: 'value', value: null },
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownAttributeRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/issues/attributes/unknownAttributeRule.ts

@@ -0,0 +1,25 @@
+import type { Rule } from '../../../types'
+
+export const unknownAttributeRule: Rule<{
+  name: string
+}> = {
+  code: 'unknown attribute',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (
+      nodeType !== 'formula' ||
+      value.type !== 'path' ||
+      value.path[0] !== 'Attributes'
+    ) {
+      return
+    }
+
+    const [, componentName] = path
+    const [, attributeKey] = value.path
+    const component = files.components[componentName]
+    if (!component?.attributes?.[attributeKey]) {
+      report(path, { name: attributeKey })
+    }
+  },
+}