@nordcraft/search 1.0.53 → 1.0.54

package/src/rules/apis/unknownApiRule.ts

@@ -1,31 +0,0 @@
-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/apis/unknownApiServiceRule.test.ts

@@ -1,152 +0,0 @@
-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/apis/unknownApiServiceRule.ts

@@ -1,33 +0,0 @@
-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/attributes/noReferenceAttributeRule.test.ts

@@ -1,173 +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 { 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/attributes/noReferenceAttributeRule.ts

@@ -1,37 +0,0 @@
-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/attributes/unknownAttributeRule.test.ts

@@ -1,93 +0,0 @@
-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/attributes/unknownAttributeRule.ts

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

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

@@ -1,159 +0,0 @@
-import type { ComponentNodeModel } from '@nordcraft/core/dist/component/component.types'
-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 { unknownComponentAttributeRule } from './unknownComponentAttributeRule'
-
-describe('find unknownComponentAttribute', () => {
-  test('should report unknown component attributes', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          components: {
-            referenced: {
-              name: 'referenced',
-              nodes: {},
-              attributes: {
-                first: {
-                  name: 'first',
-                  testValue: valueFormula(null),
-                },
-                second: {
-                  name: 'second',
-                  testValue: valueFormula(null),
-                },
-              },
-              apis: {},
-              formulas: {},
-              variables: {},
-            },
-            test: {
-              name: 'test',
-              nodes: {
-                root: {
-                  type: 'component',
-                  name: 'referenced',
-                  events: {},
-                  children: [],
-                  style: {},
-                  attrs: {
-                    first: valueFormula('exists'),
-                    third: valueFormula('does not exist'),
-                  },
-                },
-              },
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-            },
-          },
-        },
-        rules: [unknownComponentAttributeRule],
-      }),
-    )
-
-    expect(problems).toHaveLength(1)
-    expect(problems[0].code).toBe('unknown component attribute')
-    expect(problems[0].details).toEqual({
-      name: 'third',
-      componentName: 'referenced',
-    })
-  })
-
-  test('should not report component attributes that exist', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          components: {
-            test: {
-              name: 'test',
-              nodes: {
-                root: {
-                  type: 'element',
-                  attrs: {
-                    known: valueFormula('exists'),
-                  },
-                  classes: {},
-                  events: {},
-                  tag: 'div',
-                  children: [],
-                  style: {},
-                },
-              },
-              formulas: {},
-              apis: {},
-              variables: {},
-              attributes: {
-                known: {
-                  name: 'known',
-                  testValue: { type: 'value', value: null },
-                },
-              },
-            },
-          },
-        },
-        rules: [unknownComponentAttributeRule],
-      }),
-    )
-    expect(problems).toEqual([])
-  })
-})
-
-describe('fix unknownComponentAttribute', () => {
-  test('should remove unknown component attributes', () => {
-    const files: ProjectFiles = {
-      components: {
-        referenced: {
-          name: 'referenced',
-          nodes: {},
-          attributes: {
-            first: {
-              name: 'first',
-              testValue: valueFormula(null),
-            },
-            second: {
-              name: 'second',
-              testValue: valueFormula(null),
-            },
-          },
-          apis: {},
-          formulas: {},
-          variables: {},
-        },
-        test: {
-          name: 'test',
-          nodes: {
-            root: {
-              type: 'component',
-              name: 'referenced',
-              events: {},
-              children: [],
-              style: {},
-              attrs: {
-                first: valueFormula('exists'),
-                third: valueFormula('does not exist'),
-              },
-            },
-          },
-          formulas: {},
-          apis: {},
-          attributes: {},
-          variables: {},
-        },
-      },
-    }
-    const fixedProject = fixProject({
-      files,
-      rule: unknownComponentAttributeRule,
-      fixType: 'delete-component-attribute',
-    })
-    expect(
-      (fixedProject.components.test!.nodes.root as ComponentNodeModel).attrs,
-    ).toEqual({
-      first: valueFormula('exists'),
-    })
-  })
-})