@nordcraft/search 1.0.0

package/src/rules/attributes/unknownAttributeRule.test.ts

@@ -0,0 +1,92 @@
+import { searchProject } from '../../searchProject'
+import { unknownAttributeRule } from './unknownAttributeRule'
+
+describe('unknownAttribute', () => {
+  test('should report reading unknown attributes', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {
+                    'my-class': {
+                      formula: {
+                        type: 'path',
+                        path: ['Attributes', 'unknown'],
+                      },
+                    },
+                  },
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownAttributeRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown attribute')
+    expect(problems[0].details).toEqual({ name: 'unknown' })
+  })
+
+  test('should not report attributes that exist', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {
+                    'my-class': {
+                      formula: {
+                        type: 'path',
+                        path: ['Attributes', 'known'],
+                      },
+                    },
+                  },
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              variables: {},
+              attributes: {
+                known: {
+                  name: 'known',
+                  testValue: { type: 'value', value: null },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownAttributeRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/attributes/unknownAttributeRule.ts

@@ -0,0 +1,25 @@
+import type { Rule } from '../../types'
+
+export const unknownAttributeRule: Rule<{
+  name: string
+}> = {
+  code: 'unknown attribute',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (
+      nodeType !== 'formula' ||
+      value.type !== 'path' ||
+      value.path[0] !== 'Attributes'
+    ) {
+      return
+    }
+
+    const [, componentName] = path
+    const [, attributeKey] = value.path
+    const component = files.components[componentName]
+    if (!component?.attributes?.[attributeKey]) {
+      report(path, { name: attributeKey })
+    }
+  },
+}

package/src/rules/components/noReferenceComponentRule.test.ts

@@ -0,0 +1,140 @@
+import { searchProject } from '../../searchProject'
+import { noReferenceComponentRule } from './noReferenceComponentRule'
+
+describe('noReferenceComponentRule', () => {
+  test('should detect components with no references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            orphan: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+            exportedOrphan: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              exported: true,
+            },
+            page: {
+              name: 'my-page',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                info: {},
+                path: [],
+                query: {},
+              },
+            },
+          },
+        },
+        rules: [noReferenceComponentRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('no-reference component')
+    expect(problems[0].path).toEqual(['components', 'orphan'])
+  })
+  test('should detect components that are only referenced by themselves', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            orphan: {
+              name: 'test',
+              nodes: {
+                abc: {
+                  type: 'component',
+                  attrs: {},
+                  children: [],
+                  name: 'test',
+                  events: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+            page: {
+              name: 'my-page',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                info: {},
+                path: [],
+                query: {},
+              },
+            },
+          },
+        },
+        rules: [noReferenceComponentRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('no-reference component')
+    expect(problems[0].path).toEqual(['components', 'orphan'])
+  })
+
+  test('should not detect components with references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            abcd: {
+              name: 'my-component',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+            page: {
+              name: 'my-page',
+              nodes: {
+                root: {
+                  type: 'component',
+                  name: 'my-component',
+                  attrs: {},
+                  children: [],
+                  events: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                info: {},
+                path: [],
+                query: {},
+              },
+            },
+          },
+        },
+        rules: [noReferenceComponentRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/components/noReferenceComponentRule.ts

@@ -0,0 +1,37 @@
+import type { Component } from '@nordcraft/core/dist/component/component.types'
+import { isDefined } from '@nordcraft/core/dist/utils/util'
+import type { Rule } from '../../types'
+
+export const noReferenceComponentRule: Rule<void> = {
+  code: 'no-reference component',
+  level: 'warning',
+  category: 'No References',
+  visit: (report, { path, nodeType, files, value }) => {
+    // We need a way to flag if a component is exported as a web component, as it would be a valid orphan
+    if (nodeType !== 'component' || isPage(value) || value.exported === true) {
+      return
+    }
+
+    for (const component of Object.values(files.components)) {
+      // Enforce that the component is not undefined since we're iterating
+      for (const node of Object.values(component!.nodes ?? {})) {
+        if (
+          node.type === 'component' &&
+          node.name === value.name &&
+          // Circular references from a component to itself should
+          // not count as a reference
+          node.name !== component!.name
+        ) {
+          return
+        }
+      }
+    }
+
+    report(path)
+  },
+}
+
+const isPage = (
+  value: Component,
+): value is Component & { route: Required<Component['route']> } =>
+  isDefined(value.route)

package/src/rules/components/unknownComponentRule.test.ts

@@ -0,0 +1,114 @@
+import { searchProject } from '../../searchProject'
+import { unknownComponentRule } from './unknownComponentRule'
+
+describe('unknownComponent', () => {
+  test('should report unknown component node references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  name: 'unknown',
+                  type: 'component',
+                  attrs: {},
+                  events: {},
+                  children: ['test'],
+                  style: {},
+                },
+                test: {
+                  name: 'unknown-package',
+                  package: 'unknown',
+                  type: 'component',
+                  attrs: {},
+                  events: {},
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownComponentRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(2)
+    expect(problems[0].code).toBe('unknown component')
+    expect(problems[0].details).toEqual({ name: 'unknown' })
+    expect(problems[1].code).toBe('unknown component')
+    expect(problems[1].details).toEqual({ name: 'unknown-package' })
+  })
+
+  test('should not report known component node references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          packages: {
+            known_package: {
+              manifest: {
+                commit: '123',
+                name: 'known_package',
+              },
+              components: {
+                known_package_component: {
+                  name: 'known_package_component',
+                  nodes: {},
+                  formulas: {},
+                  apis: {},
+                  attributes: {},
+                  variables: {},
+                },
+              },
+            },
+          },
+          components: {
+            known: {
+              name: 'known',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  name: 'known',
+                  type: 'component',
+                  attrs: {},
+                  events: {},
+                  children: ['test'],
+                  style: {},
+                },
+                test: {
+                  name: 'known_package_component',
+                  package: 'known_package',
+                  type: 'component',
+                  attrs: {},
+                  events: {},
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownComponentRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/components/unknownComponentRule.ts

@@ -0,0 +1,24 @@
+import { isDefined } from '@nordcraft/core/dist/utils/util'
+import type { Rule } from '../../types'
+
+export const unknownComponentRule: Rule<{
+  name: string
+}> = {
+  code: 'unknown component',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (
+      nodeType !== 'component-node' ||
+      value.type !== 'component' ||
+      // Check if the component exists in the project
+      (!isDefined(value.package) && isDefined(files.components[value.name])) ||
+      // Check if the component exists in a specified package
+      (value.package &&
+        isDefined(files.packages?.[value.package]?.components[value.name]))
+    ) {
+      return
+    }
+    report(path, { name: value.name })
+  },
+}

package/src/rules/context/noContextConsumersRule.test.ts

@@ -0,0 +1,239 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+import { searchProject } from '../../searchProject'
+import { noContextConsumersRule } from './noContextConsumersRule'
+
+describe('noContextConsumersRule', () => {
+  test('should detect component with exposed formulas but no slot/component child', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            provider: {
+              name: 'provider',
+              nodes: {
+                textNode: {
+                  type: 'text',
+                  value: valueFormula('Hello world'),
+                },
+              },
+              formulas: {
+                test: {
+                  name: 'test',
+                  arguments: [],
+                  formula: {
+                    type: 'value',
+                    value: 1,
+                  },
+                  exposeInContext: true,
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {},
+              contexts: {
+                known: {
+                  formulas: ['test'],
+                  workflows: ['test'],
+                  componentName: 'known',
+                },
+              },
+            },
+          },
+        },
+        rules: [noContextConsumersRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('no context consumers')
+  })
+  test('should detect component with exposed workflows but no slot/component child', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            provider: {
+              name: 'provider',
+              nodes: {
+                textNode: {
+                  type: 'text',
+                  value: valueFormula('Hello world'),
+                },
+              },
+              formulas: {},
+              workflows: {
+                test: {
+                  actions: [],
+                  exposeInContext: true,
+                  name: 'test',
+                  parameters: [],
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {},
+              contexts: {
+                known: {
+                  formulas: ['test'],
+                  workflows: ['test'],
+                  componentName: 'known',
+                },
+              },
+            },
+          },
+        },
+        rules: [noContextConsumersRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('no context consumers')
+  })
+  test('should not detect component with no exposed workflows/formulas', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            provider: {
+              name: 'provider',
+              nodes: {
+                textNode: {
+                  type: 'text',
+                  value: valueFormula('Hello world'),
+                },
+              },
+              formulas: {},
+              workflows: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              contexts: {},
+            },
+          },
+        },
+        rules: [noContextConsumersRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+  test('should not detect component with exposed workflows/formulas when a slot exists', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            provider: {
+              name: 'provider',
+              nodes: {
+                textNode: {
+                  type: 'text',
+                  value: valueFormula('Hello world'),
+                },
+                slotNode: {
+                  type: 'slot',
+                  children: [],
+                },
+              },
+              formulas: {
+                test: {
+                  name: 'test',
+                  arguments: [],
+                  formula: {
+                    type: 'value',
+                    value: 1,
+                  },
+                  exposeInContext: true,
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              workflows: {
+                test: {
+                  actions: [],
+                  exposeInContext: true,
+                  name: 'test',
+                  parameters: [],
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {},
+              contexts: {},
+            },
+          },
+        },
+        rules: [noContextConsumersRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+  test('should not detect component with exposed workflows/formulas when a child component exists', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            provider: {
+              name: 'provider',
+              nodes: {
+                textNode: {
+                  type: 'text',
+                  value: valueFormula('Hello world'),
+                },
+                componentNode: {
+                  type: 'component',
+                  name: 'test-component',
+                  attrs: {},
+                  events: {},
+                  children: [],
+                },
+              },
+              formulas: {
+                test: {
+                  name: 'test',
+                  arguments: [],
+                  formula: {
+                    type: 'value',
+                    value: 1,
+                  },
+                  exposeInContext: true,
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              workflows: {
+                test: {
+                  actions: [],
+                  exposeInContext: true,
+                  name: 'test',
+                  parameters: [],
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {},
+              contexts: {},
+            },
+          },
+        },
+        rules: [noContextConsumersRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})