@nordcraft/search 1.0.53 → 1.0.54

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

@@ -0,0 +1,240 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+import { describe, expect, test } from 'bun:test'
+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,
+                  '@nordcraft/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: [],
+                  '@nordcraft/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,
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              workflows: {
+                test: {
+                  actions: [],
+                  exposeInContext: true,
+                  name: 'test',
+                  parameters: [],
+                  '@nordcraft/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,
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              workflows: {
+                test: {
+                  actions: [],
+                  exposeInContext: true,
+                  name: 'test',
+                  parameters: [],
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {},
+              contexts: {},
+            },
+          },
+        },
+        rules: [noContextConsumersRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

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

@@ -0,0 +1,39 @@
+import type { Rule } from '../../../types'
+
+/**
+ * Rule for checking if a component exposes formulas or workflows
+ * in context but has no slots or components that could consume them
+ */
+export const noContextConsumersRule: Rule<{
+  providerName: string
+  formulaName: string
+}> = {
+  code: 'no context consumers',
+  level: 'warning',
+  category: 'Quality',
+  visit: (report, { path, value, nodeType }) => {
+    if (nodeType !== 'component') {
+      return
+    }
+    const exposesFormulas = Object.values(value.formulas ?? {}).some(
+      (f) => f.exposeInContext,
+    )
+    const exposesWorkflows = Object.values(value.workflows ?? {}).some(
+      (w) => w.exposeInContext,
+    )
+    if (!exposesFormulas && !exposesWorkflows) {
+      return
+    }
+    const hasSlots = Object.values(value.nodes).some((n) => n.type === 'slot')
+    if (hasSlots) {
+      return
+    }
+    const hasComponents = Object.values(value.nodes).some(
+      (n) => n.type === 'component',
+    )
+    if (hasComponents) {
+      return
+    }
+    report(path)
+  },
+}

package/src/rules/issues/context/unknownContextFormulaRule.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, test } from 'bun:test'
+import { searchProject } from '../../../searchProject'
+import { unknownContextFormulaRule } from './unknownContextFormulaRule'
+
+describe('unknownContextFormulaRule', () => {
+  test('should detect context formulas that are not subscribed', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            consumer: {
+              name: 'consumer',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {
+                test: {
+                  initialValue: {
+                    type: 'path',
+                    path: ['Contexts', 'unknown', 'test'],
+                  },
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+                test2: {
+                  initialValue: {
+                    type: 'path',
+                    path: ['Contexts', 'known', 'unknown'],
+                  },
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              contexts: {
+                known: {
+                  formulas: ['test'],
+                  workflows: ['test'],
+                  componentName: 'known',
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownContextFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(2)
+    expect(problems[0].code).toBe('unknown context formula')
+    expect(problems[1].code).toBe('unknown context formula')
+  })
+
+  test('should not detect when context formulas are subscribed', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            consumer: {
+              name: 'consumer',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {
+                test: {
+                  initialValue: {
+                    type: 'path',
+                    path: ['Contexts', 'known', 'test'],
+                  },
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              contexts: {
+                known: {
+                  formulas: ['test'],
+                  workflows: ['test'],
+                  componentName: 'known',
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownContextFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/issues/context/unknownContextFormulaRule.ts

@@ -0,0 +1,30 @@
+import type { Rule } from '../../../types'
+
+export const unknownContextFormulaRule: Rule<{
+  providerName: string
+  formulaName: string
+}> = {
+  code: 'unknown context formula',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (
+      path[0] !== 'components' ||
+      nodeType !== 'formula' ||
+      value.type !== 'path' ||
+      value.path[0] !== 'Contexts'
+    ) {
+      return
+    }
+
+    const contexts = files.components[path[1]]?.contexts ?? {}
+    if (contexts[value.path[1]]?.formulas.includes(value.path[2])) {
+      return
+    }
+
+    report(path, {
+      providerName: value.path[1],
+      formulaName: value.path[2],
+    })
+  },
+}

package/src/rules/issues/context/unknownContextProviderFormulaRule.test.ts

@@ -0,0 +1,175 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+import { describe, expect, test } from 'bun:test'
+import { searchProject } from '../../../searchProject'
+import { unknownContextProviderFormulaRule } from './unknownContextProviderFormulaRule'
+
+describe('unknownContextFormulaProviderRule', () => {
+  test('should detect invalid context provider formula references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            known: {
+              name: 'known',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+            consumer: {
+              name: 'consumer',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {
+                test: {
+                  initialValue: {
+                    type: 'path',
+                    path: ['Contexts', 'known', 'test'],
+                  },
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              contexts: {
+                known: {
+                  formulas: ['test'],
+                  workflows: ['test'],
+                  componentName: 'known',
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownContextProviderFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown context provider formula')
+    expect(problems[0].details).toEqual({
+      providerName: 'known',
+      formulaName: 'test',
+    })
+  })
+  test('should detect non-exposed context provider formula references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            known: {
+              name: 'known',
+              nodes: {},
+              formulas: {
+                test: {
+                  name: 'test',
+                  exposeInContext: false,
+                  formula: valueFormula(true),
+                  arguments: [],
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+            consumer: {
+              name: 'consumer',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {
+                test: {
+                  initialValue: {
+                    type: 'path',
+                    path: ['Contexts', 'known', 'test'],
+                  },
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              contexts: {
+                known: {
+                  formulas: ['test'],
+                  workflows: ['test'],
+                  componentName: 'known',
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownContextProviderFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown context provider formula')
+    expect(problems[0].details).toEqual({
+      providerName: 'known',
+      formulaName: 'test',
+    })
+  })
+  test('should not detect exposed context provider formula references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            known: {
+              name: 'known',
+              nodes: {},
+              formulas: {
+                test: {
+                  name: 'test',
+                  exposeInContext: true,
+                  formula: valueFormula(true),
+                  arguments: [],
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+            consumer: {
+              name: 'consumer',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {
+                test: {
+                  initialValue: {
+                    type: 'path',
+                    path: ['Contexts', 'known', 'test'],
+                  },
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              contexts: {
+                known: {
+                  formulas: ['test'],
+                  workflows: ['test'],
+                  componentName: 'known',
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownContextProviderFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/issues/context/unknownContextProviderFormulaRule.ts

@@ -0,0 +1,35 @@
+import type { Rule } from '../../../types'
+
+export const unknownContextProviderFormulaRule: Rule<{
+  providerName: string
+  formulaName: string
+}> = {
+  code: 'unknown context provider formula',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (
+      nodeType !== 'component-context' ||
+      !value.componentName ||
+      (value.formulas ?? []).length === 0
+    ) {
+      return
+    }
+
+    // Lookup the target component and verify it holds the formula
+    const component = value.package
+      ? files.packages?.[value.package]?.components[value.componentName]
+      : files.components[value.componentName]
+    if (!component) {
+      return
+    }
+    for (const formulaName of value.formulas) {
+      if (component.formulas?.[formulaName]?.exposeInContext !== true) {
+        report(path, {
+          providerName: value.componentName,
+          formulaName,
+        })
+      }
+    }
+  },
+}

package/src/rules/issues/context/unknownContextProviderRule.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, test } from 'bun:test'
+import { searchProject } from '../../../searchProject'
+import { unknownContextProviderRule } from './unknownContextProviderRule'
+
+describe('unknownContextProviderRule', () => {
+  test('should detect context from component that does not exist', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            consumer: {
+              name: 'consumer',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              contexts: {
+                unknown: {
+                  formulas: ['test'],
+                  workflows: ['test'],
+                  componentName: 'unknown',
+                },
+              },
+            },
+            provider: {
+              name: 'provider',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownContextProviderRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown context provider')
+  })
+
+  test('should not detect when context exist', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            consumer: {
+              name: 'consumer',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              contexts: {
+                provider: {
+                  formulas: ['test'],
+                  workflows: ['test'],
+                  componentName: 'provider',
+                },
+              },
+            },
+            provider: {
+              name: 'provider',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownContextProviderRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})