@nordcraft/search 1.0.53 → 1.0.54

package/src/rules/issues/miscellaneous/unknownCookieRule.ts

@@ -0,0 +1,34 @@
+import { isDefined } from '@nordcraft/core/dist/utils/util'
+import type { Rule } from '../../../types'
+
+export const unknownCookieRule: Rule<{
+  name: string
+}> = {
+  code: 'unknown cookie',
+  level: 'info',
+  category: 'Unknown Reference',
+  visit: (report, { path, value, nodeType }, state) => {
+    if (
+      nodeType !== 'formula' ||
+      value.type !== 'function' ||
+      value.name !== '@toddle/getHttpOnlyCookie' ||
+      value.arguments.length !== 1 ||
+      !state ||
+      state.isBrowserExtensionAvailable !== true
+    ) {
+      return
+    }
+    const formula = value.arguments[0]?.formula
+    if (
+      !isDefined(formula) ||
+      formula.type !== 'value' ||
+      typeof formula.value !== 'string'
+    ) {
+      return
+    }
+    const cookie = state.cookiesAvailable?.find((c) => c.name === formula.value)
+    if (!cookie) {
+      report(path, { name: formula.value })
+    }
+  },
+}

package/src/rules/issues/routing/duplicateRouteRule.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, test } from 'bun:test'
+import { searchProject } from '../../../searchProject'
+import { duplicateRouteRule } from './duplicateRouteRule'
+
+describe('duplicateRouteRule', () => {
+  test('should detect duplicate route declarations', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            home: {
+              name: 'home',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                path: [],
+                query: {},
+              },
+            },
+            home2: {
+              name: 'home2',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                path: [],
+                query: {},
+              },
+            },
+          },
+          routes: {},
+        },
+        rules: [duplicateRouteRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(2)
+    expect(problems[0].code).toBe('duplicate route')
+    expect(problems[0].details.name).toEqual('home')
+    expect(problems[0].details.type).toEqual('page')
+    expect(problems[0].details.duplicates).toEqual([
+      { name: 'home2', type: 'page' },
+    ])
+    expect(problems[0].path).toEqual(['components', 'home', 'route', 'path'])
+  })
+  test('should detect non-basic duplicate route declarations', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            home: {
+              name: 'home',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                path: [
+                  { type: 'static', name: 'blog' },
+                  { type: 'param', name: 'slug', testValue: 'my-blog' },
+                ],
+                query: {},
+              },
+            },
+            home2: {
+              name: 'home2',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                path: [
+                  { type: 'static', name: 'blog' },
+                  { type: 'param', name: 'param', testValue: 'my-blog' },
+                ],
+                query: {},
+              },
+            },
+          },
+        },
+        rules: [duplicateRouteRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(2)
+    expect(problems[0].code).toBe('duplicate route')
+    expect(problems[0].details.name).toEqual('home')
+    expect(problems[0].details.type).toEqual('page')
+    expect(problems[0].details.duplicates).toEqual([
+      { name: 'home2', type: 'page' },
+    ])
+    expect(problems[0].path).toEqual(['components', 'home', 'route', 'path'])
+  })
+  test('should not detect unique route declarations', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            home: {
+              name: 'home',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                path: [],
+                query: {},
+              },
+            },
+            home2: {
+              name: 'home2',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                path: [
+                  {
+                    name: 'blogs',
+                    type: 'static',
+                  },
+                ],
+                query: {},
+              },
+            },
+          },
+          routes: {},
+        },
+        rules: [duplicateRouteRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/issues/routing/duplicateRouteRule.ts

@@ -0,0 +1,52 @@
+import type { RouteDeclaration } from '@nordcraft/core/dist/component/component.types'
+import { isPageComponent } from '@nordcraft/core/dist/component/isPageComponent'
+import type { Rule } from '../../../types'
+
+export const duplicateRouteRule: Rule<{
+  name: string
+  type: 'route' | 'page'
+  duplicates: Array<{ name: string; type: 'route' | 'page' }>
+}> = {
+  code: 'duplicate route',
+  level: 'warning',
+  category: 'Quality',
+  visit: (report, args) => {
+    const { nodeType, value, files, memo, path } = args
+    if (nodeType !== 'component' || !isPageComponent(value)) {
+      return
+    }
+    const getRouteKey = (route: RouteDeclaration['path']) =>
+      route.reduce(
+        (acc, part) => `${acc}/${part.type === 'static' ? part.name : '*'}`,
+        '/',
+      )
+    const allRoutes = memo('allRoutes', () => {
+      const routes = new Map<string, string[]>()
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      Object.entries(files.components ?? {}).map(
+        ([component, componentValue]) => {
+          if (componentValue && isPageComponent(componentValue)) {
+            const key = getRouteKey(componentValue.route.path)
+            const existing = routes.get(key)
+            if (existing) {
+              existing.push(component)
+            } else {
+              routes.set(key, [component])
+            }
+          }
+        },
+      )
+      return routes
+    })
+    const match = allRoutes.get(getRouteKey(value.route?.path))
+    if (match && match.length > 1) {
+      report([...path, 'route', 'path'], {
+        name: value.name,
+        type: 'page',
+        duplicates: match
+          .filter((m) => m !== value.name)
+          .map((name) => ({ name, type: 'page' })),
+      })
+    }
+  },
+}

package/src/rules/issues/routing/duplicateUrlParameterRule.test.ts

@@ -0,0 +1,135 @@
+import { describe, expect, test } from 'bun:test'
+import { searchProject } from '../../../searchProject'
+import { duplicateUrlParameterRule } from './duplicateUrlParameterRule'
+
+describe('duplicateUrlParameterRule', () => {
+  test('should detect duplicate URL parameters', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                path: [
+                  {
+                    type: 'param',
+                    name: 'id',
+                    testValue: '1',
+                  },
+                  {
+                    type: 'static',
+                    name: 'name',
+                  },
+                ],
+                query: {
+                  id: {
+                    name: 'id',
+                    testValue: '1',
+                  },
+                },
+              },
+            },
+          },
+        },
+        rules: [duplicateUrlParameterRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('duplicate url parameter')
+    expect(problems[0].path).toEqual([
+      'components',
+      'test',
+      'route',
+      'query',
+      'id',
+    ])
+    expect(problems[0].details).toEqual({ name: 'id' })
+  })
+  test('should detect duplicate path parameters', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                path: [
+                  {
+                    type: 'param',
+                    name: 'company',
+                    testValue: '1',
+                  },
+                  {
+                    type: 'static',
+                    name: 'company',
+                  },
+                ],
+                query: {},
+              },
+            },
+          },
+        },
+        rules: [duplicateUrlParameterRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('duplicate url parameter')
+    expect(problems[0].path).toEqual(['components', 'test', 'route', 'path', 1])
+    expect(problems[0].details).toEqual({ name: 'company' })
+  })
+  test('should not detect non-duplicate URL parameters', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                path: [
+                  {
+                    type: 'param',
+                    name: 'id',
+                    testValue: '1',
+                  },
+                  {
+                    type: 'static',
+                    name: 'name',
+                  },
+                ],
+                query: {
+                  other: {
+                    name: 'other',
+                    testValue: '1',
+                  },
+                },
+              },
+            },
+          },
+        },
+        rules: [duplicateUrlParameterRule],
+      }),
+    )
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/issues/routing/duplicateUrlParameterRule.ts

@@ -0,0 +1,30 @@
+import { isDefined } from '@nordcraft/core/dist/utils/util'
+import type { Rule } from '../../../types'
+
+export const duplicateUrlParameterRule: Rule<{ name: string }> = {
+  code: 'duplicate url parameter',
+  level: 'warning',
+  category: 'Quality',
+  visit: (report, { nodeType, path, value }) => {
+    if (
+      nodeType !== 'component' ||
+      !isDefined(value.route) ||
+      !isDefined(value.route.path) ||
+      !isDefined(value.route.query)
+    ) {
+      return
+    }
+    const pathNames = new Set<string>()
+    value.route.path.forEach((p, i) => {
+      if (pathNames.has(p.name)) {
+        report([...path, 'route', 'path', i], { name: p.name })
+      }
+      pathNames.add(p.name)
+    })
+    Object.keys(value.route.query).forEach((key) => {
+      if (pathNames.has(key)) {
+        report([...path, 'route', 'query', key], { name: key })
+      }
+    })
+  },
+}

package/src/rules/issues/routing/routingRules.index.ts

@@ -0,0 +1,11 @@
+import { duplicateRouteRule } from './duplicateRouteRule'
+import { duplicateUrlParameterRule } from './duplicateUrlParameterRule'
+import { unknownSetUrlParameterRule } from './unknownSetUrlParameterRule'
+import { unknownUrlParameterRule } from './unknownUrlParameterRule'
+
+export default [
+  duplicateUrlParameterRule,
+  duplicateRouteRule,
+  unknownSetUrlParameterRule,
+  unknownUrlParameterRule,
+]

package/src/rules/issues/routing/unknownSetUrlParameterRule.test.ts

@@ -0,0 +1,162 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+import { describe, expect, test } from 'bun:test'
+import { searchProject } from '../../../searchProject'
+import { unknownSetUrlParameterRule } from './unknownSetUrlParameterRule'
+
+describe('unknownSetUrlParameterRule', () => {
+  test('should report setting unknown URL parameters', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'SetURLParameter',
+                          parameter: 'unknown',
+                          data: valueFormula('newValue'),
+                        },
+                      ],
+                    },
+                  },
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownSetUrlParameterRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown set url parameter')
+    expect(problems[0].details).toEqual({ name: 'unknown' })
+  })
+
+  test('should report setting static path parameters', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'SetURLParameter',
+                          parameter: 'knownPath',
+                          data: valueFormula('newValue'),
+                        },
+                      ],
+                    },
+                  },
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                path: [
+                  {
+                    name: 'knownPath',
+                    type: 'static',
+                  },
+                ],
+                query: {},
+              },
+            },
+          },
+        },
+        rules: [unknownSetUrlParameterRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown set url parameter')
+    expect(problems[0].details).toEqual({ name: 'knownPath' })
+  })
+
+  test('should not report valid url updates', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'SetURLParameter',
+                          parameter: 'known-query',
+                          data: valueFormula('newValue'),
+                        },
+                        {
+                          type: 'SetURLParameter',
+                          parameter: 'known-path',
+                          data: valueFormula('newValue'),
+                        },
+                      ],
+                    },
+                  },
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                path: [{ name: 'known-path', type: 'param', testValue: 'bla' }],
+                query: {
+                  'known-query': {
+                    name: 'known-query',
+                    testValue: '',
+                  },
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownSetUrlParameterRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/issues/routing/unknownSetUrlParameterRule.ts

@@ -0,0 +1,33 @@
+import type { Rule } from '../../../types'
+
+export const unknownSetUrlParameterRule: Rule<{
+  name: string
+}> = {
+  code: 'unknown set url parameter',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, args) => {
+    if (
+      args.nodeType !== 'action-model' ||
+      args.value.type !== 'SetURLParameter'
+    ) {
+      return
+    }
+    const isValidParameter = (parameterName: string) =>
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      args.component.route?.path?.some(
+        (p) =>
+          p.name === parameterName &&
+          // It's only valid to set non-static path parameters
+          p.type === 'param',
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+      ) ||
+      Object.values(args.component.route?.query ?? {}).some(
+        (q) => q.name === parameterName,
+      )
+    const parameterName = args.value.parameter
+    if (!isValidParameter(parameterName)) {
+      report(args.path, { name: parameterName })
+    }
+  },
+}