@nordcraft/search 1.0.52 → 1.0.54

package/src/rules/issues/actions/noReferenceProjectActionRule.test.ts

@@ -0,0 +1,164 @@
+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 { noReferenceProjectActionRule } from './noReferenceProjectActionRule'
+
+describe('find noReferenceProjectAction', () => {
+  test('should detect unused global actions', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          actions: {
+            'my-action': {
+              name: 'my-action',
+              arguments: [],
+              handler: '() => console.log("test")',
+              variableArguments: false,
+            },
+          },
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [noReferenceProjectActionRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('no-reference project action')
+    expect(problems[0].path).toEqual(['actions', 'my-action'])
+  })
+
+  test('should not detect used global actions', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          actions: {
+            'my-action': {
+              name: 'my-action',
+              arguments: [],
+              handler: '() => console.log("test")',
+              variableArguments: false,
+            },
+            'my-action2': {
+              name: 'my-action2',
+              arguments: [],
+              handler: '() => console.log("test")',
+              variableArguments: false,
+            },
+          },
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              workflows: {
+                test: {
+                  name: 'test',
+                  parameters: [],
+                  actions: [
+                    {
+                      name: 'my-action2',
+                      arguments: [],
+                    },
+                  ],
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              onLoad: {
+                trigger: 'onLoad',
+                actions: [
+                  {
+                    type: 'Custom',
+                    name: 'my-action',
+                    arguments: [],
+                  },
+                ],
+              },
+            },
+          },
+        },
+        rules: [noReferenceProjectActionRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+
+  describe('noReferenceProjectAction', () => {
+    test('should not detect exported unused global actions', () => {
+      const problems = Array.from(
+        searchProject({
+          files: {
+            actions: {
+              'my-action': {
+                name: 'my-action',
+                arguments: [],
+                handler: '() => console.log("test")',
+                variableArguments: false,
+                exported: true,
+              },
+            },
+            components: {
+              test: {
+                name: 'test',
+                nodes: {},
+                formulas: {},
+                apis: {},
+                attributes: {},
+                variables: {},
+              },
+            },
+          },
+          rules: [noReferenceProjectActionRule],
+        }),
+      )
+
+      expect(problems).toHaveLength(0)
+    })
+  })
+})
+
+describe('fix noReferenceProjectAction', () => {
+  test('should remove unused global actions', () => {
+    const files: ProjectFiles = {
+      actions: {
+        'my-action': {
+          name: 'my-action',
+          arguments: [],
+          handler: '() => console.log("test")',
+          variableArguments: false,
+        },
+      },
+      components: {
+        test: {
+          name: 'test',
+          nodes: {},
+          formulas: {},
+          apis: {},
+          attributes: {},
+          variables: {},
+        },
+      },
+    }
+    const fixedProject = fixProject({
+      files,
+      rule: noReferenceProjectActionRule,
+      fixType: 'delete-project-action',
+    })
+    expect(fixedProject.actions).toEqual({})
+  })
+})

package/src/rules/issues/actions/noReferenceProjectActionRule.ts

@@ -0,0 +1,53 @@
+import type { CustomActionModel } from '@nordcraft/core/dist/component/component.types'
+import { ToddleComponent } from '@nordcraft/core/dist/component/ToddleComponent'
+import type { Rule } from '../../../types'
+import { removeFromPathFix } from '../../../util/removeUnused.fix'
+
+export const noReferenceProjectActionRule: Rule<void> = {
+  code: 'no-reference project action',
+  level: 'warning',
+  category: 'No References',
+  visit: (report, { value, path, files, nodeType, memo }) => {
+    if (nodeType !== 'project-action' || value.exported === true) {
+      return
+    }
+
+    const projectActionReferences = memo('projectActionReferences', () => {
+      const usedActions = new Set<string>()
+      for (const component of Object.values(files.components)) {
+        const c = new ToddleComponent({
+          // Enforce that the component is not undefined since we're iterating
+          component: component!,
+          getComponent: (name, packageName) =>
+            packageName
+              ? files.packages?.[packageName]?.components[name]
+              : files.components[name],
+          packageName: undefined,
+          globalFormulas: {
+            formulas: files.formulas,
+            packages: files.packages,
+          },
+        })
+        for (const [, action] of c.actionModelsInComponent()) {
+          if (
+            action.type === 'Custom' ||
+            action.type === ('function' as any) ||
+            action.type === undefined
+          ) {
+            usedActions.add((action as CustomActionModel).name)
+          }
+        }
+      }
+      return usedActions
+    })
+
+    if (!projectActionReferences.has(value.name)) {
+      report(path, undefined, ['delete-project-action'])
+    }
+  },
+  fixes: {
+    'delete-project-action': removeFromPathFix,
+  },
+}
+
+export type NoReferenceProjectActionRuleFix = 'delete-project-action'

package/src/rules/issues/actions/unknownProjectActionRule.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, test } from 'bun:test'
+import { searchProject } from '../../../searchProject'
+import { unknownProjectActionRule } from './unknownProjectActionRule'
+
+describe('unknownProjectActionRule', () => {
+  test('should find unknown project actions', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              onLoad: {
+                trigger: 'onLoad',
+                actions: [
+                  {
+                    name: 'missing-action',
+                  },
+                  {
+                    name: 'missing-package-action',
+                    package: 'my-package',
+                  },
+                ],
+              },
+            },
+          },
+        },
+        rules: [unknownProjectActionRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(2)
+    expect(problems[0].code).toBe('unknown project action')
+    expect(problems[0].path).toEqual([
+      'components',
+      'test',
+      'onLoad',
+      'actions',
+      '0',
+    ])
+    expect(problems[1].code).toBe('unknown project action')
+    expect(problems[1].path).toEqual([
+      'components',
+      'test',
+      'onLoad',
+      'actions',
+      '1',
+    ])
+  })
+  test('should not report known actions', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          actions: {
+            'known-action': {
+              name: 'known-action',
+              handler: '',
+              arguments: [],
+              variableArguments: false,
+            },
+          },
+          packages: {
+            'my-package': {
+              components: {},
+              actions: {
+                'package-action': {
+                  name: 'package-action',
+                  handler: '',
+                  arguments: [],
+                  variableArguments: false,
+                },
+              },
+              manifest: {
+                name: 'my-package',
+                commit: '123',
+              },
+            },
+          },
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              onLoad: {
+                trigger: 'onLoad',
+                actions: [
+                  {
+                    name: 'known-action',
+                  },
+                  {
+                    name: 'package-action',
+                    package: 'my-package',
+                  },
+                  {
+                    name: '@toddle/clearLocalStorage',
+                    arguments: [],
+                  },
+                ],
+              },
+            },
+          },
+        },
+        rules: [unknownProjectActionRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/issues/actions/unknownProjectActionRule.ts

@@ -0,0 +1,23 @@
+import type { Rule } from '../../../types'
+
+export const unknownProjectActionRule: Rule<{ name: string }> = {
+  code: 'unknown project action',
+  level: 'warning',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (
+      nodeType !== 'action-model' ||
+      (value.type !== undefined && value.type !== 'Custom') ||
+      (value.name ?? '').startsWith('@toddle/')
+    ) {
+      return
+    }
+    const action = (
+      value.package ? files.packages?.[value.package]?.actions : files.actions
+    )?.[value.name]
+    if (action) {
+      return
+    }
+    report(path, { name: value.name })
+  },
+}

package/src/rules/issues/apis/apiRules.index.ts

@@ -0,0 +1,22 @@
+import { invalidApiParserModeRule } from './invalidApiParserModeRule'
+import { invalidApiProxyBodySettingRule } from './invalidApiProxyBodySettingRule'
+import { invalidApiProxyCookieSettingRule } from './invalidApiProxyCookieSettingRule'
+import { legacyApiRule } from './legacyApiRule'
+import { noReferenceApiRule } from './noReferenceApiRule'
+import { noReferenceApiServiceRule } from './noReferenceApiServiceRule'
+import { unknownApiInputRule } from './unknownApiInputRule'
+import { unknownApiRule } from './unknownApiRule'
+import { unknownApiServiceRule } from './unknownApiServiceRule'
+
+export default [
+  // noReferenceApiInputRule,
+  invalidApiParserModeRule,
+  invalidApiProxyBodySettingRule,
+  invalidApiProxyCookieSettingRule,
+  legacyApiRule,
+  noReferenceApiRule,
+  noReferenceApiServiceRule,
+  unknownApiInputRule,
+  unknownApiRule,
+  unknownApiServiceRule,
+]

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

@@ -0,0 +1,90 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+import { describe, expect, test } from 'bun:test'
+import { searchProject } from '../../../searchProject'
+import { invalidApiParserModeRule } from './invalidApiParserModeRule'
+
+describe('invalidApiParserMode', () => {
+  test('should report invalid parser modes for an API with SSR enabled', () => {
+    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: {},
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                  server: {
+                    ssr: {
+                      enabled: { formula: valueFormula(true) },
+                    },
+                  },
+                  client: {
+                    parserMode: 'blob',
+                  },
+                },
+              },
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [invalidApiParserModeRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('invalid api parser mode')
+    expect(problems[0].details).toEqual({ api: 'my-api' })
+  })
+
+  test('should not report valid parser modes', () => {
+    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: {},
+                  server: {
+                    ssr: {
+                      enabled: { formula: valueFormula(true) },
+                    },
+                  },
+                  client: {
+                    parserMode: 'json',
+                  },
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [invalidApiParserModeRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

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

@@ -0,0 +1,26 @@
+import { isLegacyApi } from '@nordcraft/core/dist/api/api'
+import type { Rule } from '../../../types'
+
+export const invalidApiParserModeRule: Rule<{ api: string }> = {
+  code: 'invalid api parser mode',
+  level: 'warning',
+  category: 'Quality',
+  visit: (report, args) => {
+    if (args.nodeType !== 'component-api') {
+      return
+    }
+    const { path, value } = args
+    if (
+      isLegacyApi(value) ||
+      typeof value.client?.parserMode !== 'string' ||
+      ['json', 'text', 'auto'].includes(value.client.parserMode) ||
+      value.server?.ssr?.enabled?.formula === undefined ||
+      (value.server.ssr.enabled.formula.type === 'value' &&
+        value.server.ssr.enabled.formula.value === false)
+    ) {
+      return
+    }
+
+    report(path, { api: value.name })
+  },
+}

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

@@ -0,0 +1,80 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+import { describe, expect, test } from 'bun:test'
+import { searchProject } from '../../../searchProject'
+import { invalidApiProxyBodySettingRule } from './invalidApiProxyBodySettingRule'
+
+describe('invalidApiProxyBodySetting', () => {
+  test('should report invalid proxy body settings for an API with proxying disabled', () => {
+    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: {},
+                  server: {
+                    proxy: {
+                      enabled: { formula: valueFormula(false) },
+                      useTemplatesInBody: { formula: valueFormula(true) },
+                    },
+                  },
+                },
+              },
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [invalidApiProxyBodySettingRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('invalid api proxy body setting')
+    expect(problems[0].details).toEqual({ api: 'my-api' })
+  })
+
+  test('should not report valid body proxy settings', () => {
+    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: {},
+                  server: {
+                    proxy: {
+                      enabled: { formula: valueFormula(true) },
+                      useTemplatesInBody: { formula: valueFormula(true) },
+                    },
+                  },
+                },
+              },
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [invalidApiProxyBodySettingRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

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

@@ -0,0 +1,25 @@
+import { isLegacyApi } from '@nordcraft/core/dist/api/api'
+import type { Rule } from '../../../types'
+
+export const invalidApiProxyBodySettingRule: Rule<{ api: string }> = {
+  code: 'invalid api proxy body setting',
+  level: 'warning',
+  category: 'Quality',
+  visit: (report, args) => {
+    if (args.nodeType !== 'component-api') {
+      return
+    }
+    const { path, value } = args
+    if (
+      isLegacyApi(value) ||
+      value.server?.proxy?.useTemplatesInBody?.formula.type !== 'value' ||
+      value.server.proxy.useTemplatesInBody.formula.value === false ||
+      (value.server.proxy.enabled.formula.type === 'value' &&
+        value.server.proxy.enabled.formula.value === true)
+    ) {
+      return
+    }
+    // Report an issue if useTemplatesInBody is set to true while the API is not set to be proxied
+    report(path, { api: value.name })
+  },
+}