@nordcraft/search 1.0.0

package/src/rules/duplicateRouteRule.test.ts

@@ -0,0 +1,209 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+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: {
+            home: {
+              type: 'redirect',
+              source: {
+                path: [],
+                query: {},
+              },
+              destination: {
+                path: {},
+                queryParams: {},
+                url: valueFormula(''),
+              },
+            },
+            oldBlog: {
+              type: 'rewrite',
+              source: {
+                path: [],
+                query: {},
+              },
+              destination: {
+                path: {},
+                queryParams: {},
+                url: valueFormula(''),
+              },
+            },
+          },
+        },
+        rules: [duplicateRouteRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(4)
+    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: 'home', type: 'route' },
+      { name: 'oldBlog', type: 'route' },
+      { 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: {
+            unknown: {
+              type: 'redirect',
+              source: {
+                path: [
+                  {
+                    name: 'unused-path',
+                    type: 'static',
+                  },
+                ],
+                query: {},
+              },
+              destination: {
+                path: {},
+                queryParams: {},
+                url: valueFormula(''),
+              },
+            },
+            oldBlog: {
+              type: 'rewrite',
+              source: {
+                path: [
+                  {
+                    name: 'old-blog',
+                    type: 'static',
+                  },
+                ],
+                query: {},
+              },
+              destination: {
+                path: {},
+                queryParams: {},
+                url: valueFormula(''),
+              },
+            },
+          },
+        },
+        rules: [duplicateRouteRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/duplicateRouteRule.ts

@@ -0,0 +1,83 @@
+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)) &&
+      nodeType !== 'project-route'
+    ) {
+      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,
+        Array<{ name: string; type: 'route' | 'page' }>
+      >()
+      Object.entries(files.routes ?? {}).map(([route, routeValue]) => {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (routeValue.source) {
+          const key = getRouteKey(routeValue.source.path)
+          const existing = routes.get(key)
+          if (existing) {
+            existing.push({ name: route, type: 'route' })
+          } else {
+            routes.set(key, [{ name: route, type: 'route' }])
+          }
+        }
+      })
+      // 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({ name: component, type: 'page' })
+            } else {
+              routes.set(key, [{ name: component, type: 'page' }])
+            }
+          }
+        },
+      )
+      return routes
+    })
+    if (nodeType === 'project-route') {
+      const match = allRoutes.get(getRouteKey(value.source.path))
+      if (match && match.length > 1) {
+        report([...path, 'source', 'path'], {
+          name: args.routeName,
+          type: 'route',
+          duplicates: match.filter(
+            (m) => m.name !== args.routeName || m.type === 'page',
+          ),
+        })
+      }
+    } else if (isPageComponent(value)) {
+      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.name !== value.name || m.type === 'route',
+          ),
+        })
+      }
+    }
+  },
+}

package/src/rules/events/duplicateEventTriggerRule.test.ts

@@ -0,0 +1,97 @@
+import { searchProject } from '../../searchProject'
+import { duplicateEventTriggerRule } from './duplicateEventTriggerRule'
+
+describe('duplicateEventTriggerRule', () => {
+  test('should detect duplicate event triggers', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                n1: {
+                  type: 'element',
+                  tag: 'button',
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [],
+                    },
+                    otherEvent: {
+                      trigger: 'click',
+                      actions: [],
+                    },
+                  },
+                  attrs: {},
+                  style: {},
+                  children: [],
+                  classes: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [duplicateEventTriggerRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('duplicate event trigger')
+    expect(problems[0].details).toEqual({ trigger: 'click' })
+    expect(problems[0].path).toEqual([
+      'components',
+      'test',
+      'nodes',
+      'n1',
+      'events',
+      'otherEvent',
+    ])
+  })
+  test('should not detect events that do not have duplicate triggers', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                n1: {
+                  type: 'element',
+                  tag: 'button',
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [],
+                    },
+                    otherEvent: {
+                      trigger: 'mouseenter',
+                      actions: [],
+                    },
+                  },
+                  attrs: {},
+                  style: {},
+                  children: [],
+                  classes: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [duplicateEventTriggerRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/events/duplicateEventTriggerRule.ts

@@ -0,0 +1,23 @@
+import type { Rule } from '../../types'
+
+export const duplicateEventTriggerRule: Rule<{ trigger: string }> = {
+  code: 'duplicate event trigger',
+  level: 'warning',
+  category: 'Quality',
+  visit: (report, { nodeType, path, value }) => {
+    if (nodeType !== 'component-node' || value.type !== 'element') {
+      return
+    }
+    const eventTriggers = new Set<string>()
+
+    Object.entries(value.events ?? {}).forEach(([key, event]) => {
+      if (typeof event.trigger !== 'string') {
+        return
+      }
+      if (eventTriggers.has(event.trigger)) {
+        report([...path, 'events', key], { trigger: event.trigger })
+      }
+      eventTriggers.add(event.trigger)
+    })
+  },
+}

package/src/rules/events/noReferenceEventRule.test.ts

@@ -0,0 +1,147 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+import { searchProject } from '../../searchProject'
+import { noReferenceEventRule } from './noReferenceEventRule'
+
+describe('noReferenceEventRule', () => {
+  test('should detect events with no references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'TriggerEvent',
+                          event: 'unknown-event',
+                          data: valueFormula(null),
+                        },
+                      ],
+                    },
+                  },
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              events: [
+                {
+                  name: 'unused-event',
+                  // eslint-disable-next-line inclusive-language/use-inclusive-words
+                  dummyEvent: {
+                    name: 'Name',
+                  },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              ],
+            },
+          },
+        },
+        rules: [noReferenceEventRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('no-reference event')
+    expect(problems[0].path).toEqual(['components', 'test', 'events', 0])
+    expect(problems[0].details).toEqual({ name: 'unused-event' })
+  })
+
+  test('should not detect events with references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'TriggerEvent',
+                          event: 'known-event',
+                          data: valueFormula(null),
+                        },
+                        {
+                          name: 'TriggerEvent',
+                          events: {},
+                          arguments: [
+                            {
+                              name: 'name',
+                              formula: {
+                                type: 'value',
+                                value: 'used-event',
+                              },
+                            },
+                            {
+                              name: 'data',
+                              formula: {
+                                type: 'value',
+                                value: 'TestValue',
+                              },
+                            },
+                          ],
+                        },
+                      ],
+                    },
+                  },
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              events: [
+                {
+                  name: 'known-event',
+                  // eslint-disable-next-line inclusive-language/use-inclusive-words
+                  dummyEvent: {
+                    name: 'Name',
+                  },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+                {
+                  name: 'used-event',
+                  // eslint-disable-next-line inclusive-language/use-inclusive-words
+                  dummyEvent: {
+                    name: 'Name',
+                  },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              ],
+            },
+          },
+        },
+        rules: [noReferenceEventRule],
+      }),
+    )
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/events/noReferenceEventRule.ts

@@ -0,0 +1,46 @@
+import type { Rule } from '../../types'
+import { isLegacyAction } from '../../util/helpers'
+
+export const noReferenceEventRule: Rule<{ name: string }> = {
+  code: 'no-reference event',
+  level: 'warning',
+  category: 'No References',
+  visit: (report, args) => {
+    if (args.nodeType !== 'component-event') {
+      return
+    }
+    const { path, memo, value } = args
+    const { component, event } = value
+    const events = memo(`${component.name}-events`, () => {
+      const events = new Set<string>()
+      for (const [, action] of component.actionModelsInComponent()) {
+        if (isLegacyAction(action)) {
+          if (
+            'name' in action &&
+            'arguments' in action &&
+            action.name === 'TriggerEvent' &&
+            action.version === undefined
+          ) {
+            const formula = action.arguments?.find(
+              (a) => a.name === 'name',
+            )?.formula
+            if (
+              formula?.type === 'value' &&
+              typeof formula.value === 'string'
+            ) {
+              events.add(formula.value)
+            }
+          }
+        } else if (action.type === 'TriggerEvent') {
+          events.add(action.event)
+        }
+      }
+      return events
+    })
+    if (events.has(event.name)) {
+      return
+    }
+
+    report(path, { name: event.name })
+  },
+}