@nordcraft/search 1.0.0

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

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

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

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

@@ -0,0 +1,96 @@
+import { ApiMethod } from '@nordcraft/core/dist/api/apiTypes'
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+import { searchProject } from '../../searchProject'
+import { legacyApiRule } from './legacyApiRule'
+
+describe('legacyApi', () => {
+  test('should detect legacy APIs', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              apis: {
+                'my-api': {
+                  url: valueFormula('https://legacy.com'),
+                  method: 'GET',
+                  headers: {},
+                  path: [],
+                  queryParams: {},
+                  name: 'my-api',
+                  type: 'REST',
+                  onCompleted: null,
+                  onFailed: null,
+                },
+              },
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [legacyApiRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('legacy api')
+    expect(problems[0].details).toEqual({ name: 'my-api' })
+  })
+
+  test('should not detect new APIs', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              apis: {
+                'my-api': {
+                  url: valueFormula('https://legacy.com'),
+                  version: 2,
+                  name: 'my-api',
+                  type: 'http',
+                  inputs: {},
+                  method: ApiMethod.GET,
+                  headers: {},
+                  path: {},
+                  queryParams: {},
+                },
+              },
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [legacyApiRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/apis/legacyApiRule.ts

@@ -0,0 +1,16 @@
+import { isLegacyApi } from '@nordcraft/core/dist/api/api'
+import type { Rule } from '../../types'
+
+export const legacyApiRule: Rule<{
+  name: string
+}> = {
+  code: 'legacy api',
+  level: 'warning',
+  category: 'Deprecation',
+  visit: (report, { path, value, nodeType }) => {
+    if (nodeType !== 'component-api' || !isLegacyApi(value)) {
+      return
+    }
+    report(path, { name: value.name })
+  },
+}

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

@@ -0,0 +1,159 @@
+import {
+  pathFormula,
+  valueFormula,
+} from '@nordcraft/core/dist/formula/formulaUtils'
+import { searchProject } from '../../searchProject'
+import { noReferenceApiInputRule } from './noReferenceApiInputRule'
+
+describe('noReferenceApiInputRule', () => {
+  test('should detect API inputs with no references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            apiComponent: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {
+                'my-api': {
+                  name: 'my-api',
+                  type: 'http',
+                  version: 2,
+                  autoFetch: valueFormula(true),
+                  inputs: {
+                    first: { formula: valueFormula('hello') },
+                    second: { formula: valueFormula('world') },
+                  },
+                  body: {
+                    type: 'path',
+                    path: ['Args', 'first'],
+                  },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [noReferenceApiInputRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('no-reference api input')
+    expect(problems[0].path).toEqual([
+      'components',
+      'apiComponent',
+      'apis',
+      'my-api',
+      'inputs',
+      'second',
+    ])
+  })
+
+  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: [noReferenceApiInputRule],
+      }),
+    )
+
+    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: [noReferenceApiInputRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/apis/noReferenceApiInputRule.ts

@@ -0,0 +1,42 @@
+import { ToddleApiV2 } from '@nordcraft/core/dist/api/ToddleApiV2'
+import type { Rule } from '../../types'
+
+export const noReferenceApiInputRule: Rule<{ inputName: string }> = {
+  code: 'no-reference api input',
+  level: 'warning',
+  category: 'No References',
+  visit: (report, args) => {
+    if (args.nodeType !== 'component-api-input') {
+      return
+    }
+    const { path, memo, component, api } = args
+    if (!component) {
+      return
+    }
+    const [_components, _componentName, _apis, apiKey, _inputs, inputKey] = path
+    if (typeof apiKey !== 'string' || typeof inputKey !== 'string') {
+      return
+    }
+    const apiV2 = new ToddleApiV2(api, apiKey, {
+      formulas: args.files.formulas,
+      packages: args.files.packages,
+    })
+    const referencedApiInputs = memo(
+      `apiInputReferences/${component.name}/${apiKey}`,
+      () => {
+        const apiFormulaReferences = apiV2.formulasInApi()
+        const referencedApiInputs = new Set<string>()
+        for (const [, formula] of apiFormulaReferences) {
+          if (formula.type === 'path' && formula.path[0] === 'Args') {
+            referencedApiInputs.add(formula.path[1])
+          }
+        }
+        return referencedApiInputs
+      },
+    )
+    if (referencedApiInputs.has(inputKey)) {
+      return
+    }
+    report(path, { inputName: inputKey })
+  },
+}