@nordcraft/search 1.0.52 → 1.0.54

package/src/rules/issues/events/unknownEventRule.test.ts

@@ -0,0 +1,238 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+import { describe, expect, test } from 'bun:test'
+import { searchProject } from '../../../searchProject'
+import { unknownEventRule } from './unknownEventRule'
+
+describe('unknownEvent', () => {
+  test('should report unknown events', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+                myNode: {
+                  type: 'component',
+                  name: 'test',
+                  attrs: {},
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'TriggerEvent',
+                          event: 'unknown-event',
+                          data: valueFormula(null),
+                        },
+                      ],
+                    },
+                  },
+                  children: [],
+                },
+                myOtherNode: {
+                  type: 'component',
+                  package: 'my_package',
+                  name: 'package_component',
+                  attrs: {},
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'TriggerEvent',
+                          event: 'unknown-event',
+                          data: valueFormula(null),
+                        },
+                      ],
+                    },
+                  },
+                  children: [],
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              events: [
+                {
+                  name: 'known-event',
+                  // eslint-disable-next-line inclusive-language/use-inclusive-words
+                  dummyEvent: {
+                    name: 'Name',
+                  },
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+              ],
+            },
+          },
+          packages: {
+            my_package: {
+              manifest: {
+                commit: 'commit',
+                name: 'my_package',
+              },
+              components: {
+                package_component: {
+                  name: 'package_component',
+                  nodes: {},
+                  formulas: {},
+                  apis: {},
+                  attributes: {},
+                  variables: {},
+                  events: [
+                    {
+                      name: 'known-event',
+                      // eslint-disable-next-line inclusive-language/use-inclusive-words
+                      dummyEvent: {
+                        name: 'Name',
+                      },
+                      '@nordcraft/metadata': {
+                        comments: null,
+                      },
+                    },
+                  ],
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownEventRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(2)
+    expect(problems[0].code).toBe('unknown event')
+    expect(problems[0].details).toEqual({ name: 'click' })
+    expect(problems[0].path).toEqual([
+      'components',
+      'test',
+      'nodes',
+      'myNode',
+      'events',
+      'click',
+    ])
+  })
+
+  test('should not report events that exist', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+                myNode: {
+                  type: 'component',
+                  name: 'test',
+                  attrs: {},
+                  events: {
+                    'known-event': {
+                      trigger: 'known-event',
+                      actions: [
+                        {
+                          type: 'TriggerEvent',
+                          event: 'unknown-event',
+                          data: valueFormula(null),
+                        },
+                      ],
+                    },
+                  },
+                  children: [],
+                },
+                myOtherNode: {
+                  type: 'component',
+                  package: 'my_package',
+                  name: 'package_component',
+                  attrs: {},
+                  events: {
+                    'known-event': {
+                      trigger: 'known-event',
+                      actions: [
+                        {
+                          type: 'TriggerEvent',
+                          event: 'unknown-event',
+                          data: valueFormula(null),
+                        },
+                      ],
+                    },
+                  },
+                  children: [],
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              events: [
+                {
+                  name: 'known-event',
+                  // eslint-disable-next-line inclusive-language/use-inclusive-words
+                  dummyEvent: {
+                    name: 'Name',
+                  },
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+              ],
+            },
+          },
+          packages: {
+            my_package: {
+              manifest: {
+                commit: 'commit',
+                name: 'my_package',
+              },
+              components: {
+                package_component: {
+                  name: 'package_component',
+                  nodes: {},
+                  formulas: {},
+                  apis: {},
+                  attributes: {},
+                  variables: {},
+                  events: [
+                    {
+                      name: 'known-event',
+                      // eslint-disable-next-line inclusive-language/use-inclusive-words
+                      dummyEvent: {
+                        name: 'Name',
+                      },
+                      '@nordcraft/metadata': {
+                        comments: null,
+                      },
+                    },
+                  ],
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownEventRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/issues/events/unknownEventRule.ts

@@ -0,0 +1,32 @@
+import { isDefined } from '@nordcraft/core/dist/utils/util'
+import type { Rule } from '../../../types'
+
+export const unknownEventRule: Rule<{
+  name: string
+}> = {
+  code: 'unknown event',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (
+      nodeType !== 'component-node' ||
+      value.type !== 'component' ||
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      Object.entries(value.events ?? {}).length === 0
+    ) {
+      return
+    }
+
+    const component = value.package
+      ? files.packages?.[value.package]?.components[value.name]
+      : files.components[value.name]
+    const componentEvents = new Set(
+      (component?.events ?? []).map((e) => e.name),
+    )
+    Object.entries(value.events).forEach(([eventKey, event]) => {
+      if (isDefined(event) && !componentEvents.has(event.trigger)) {
+        report([...path, 'events', eventKey], { name: event.trigger })
+      }
+    })
+  },
+}

package/src/rules/issues/events/unknownTriggerEventRule.test.ts

@@ -0,0 +1,118 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+import { describe, expect, test } from 'bun:test'
+import { searchProject } from '../../../searchProject'
+import { unknownTriggerEventRule } from './unknownTriggerEventRule'
+
+describe('unknownTriggerEventRule', () => {
+  test('should report unknown trigger events', () => {
+    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: 'known-event',
+                  // eslint-disable-next-line inclusive-language/use-inclusive-words
+                  dummyEvent: {
+                    name: 'Name',
+                  },
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+              ],
+            },
+          },
+        },
+        rules: [unknownTriggerEventRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown trigger event')
+    expect(problems[0].details).toEqual({ name: 'unknown-event' })
+  })
+
+  test('should not report events that exist', () => {
+    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),
+                        },
+                      ],
+                    },
+                  },
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              events: [
+                {
+                  name: 'known-event',
+                  // eslint-disable-next-line inclusive-language/use-inclusive-words
+                  dummyEvent: {
+                    name: 'Name',
+                  },
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+              ],
+            },
+          },
+        },
+        rules: [unknownTriggerEventRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/issues/events/unknownTriggerEventRule.ts

@@ -0,0 +1,20 @@
+import type { Rule } from '../../../types'
+
+export const unknownTriggerEventRule: Rule<{
+  name: string
+}> = {
+  code: 'unknown trigger event',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (nodeType !== 'action-model' || value.type !== 'TriggerEvent') {
+      return
+    }
+
+    const [, componentName] = path
+    const component = files.components[componentName]
+    if (!component?.events?.some((e) => e.name === value.event)) {
+      report(path, { name: value.event })
+    }
+  },
+}

package/src/rules/issues/formulas/formulaRules.index.ts

@@ -0,0 +1,11 @@
+import { legacyFormulaRule } from './legacyFormulaRule'
+import { noReferenceComponentFormulaRule } from './noReferenceComponentFormulaRule'
+import { noReferenceProjectFormulaRule } from './noReferenceProjectFormulaRule'
+
+export default [
+  legacyFormulaRule,
+  noReferenceComponentFormulaRule,
+  noReferenceProjectFormulaRule,
+  // unknownComponentFormulaInputRule,
+  // unknownProjectFormulaInputRule
+]