@nordcraft/search 1.0.0

package/src/rules/requireExtensionRule.test.ts

@@ -0,0 +1,73 @@
+import { searchProject } from '../searchProject'
+import { requireExtensionRule } from './requireExtensionRule'
+
+describe('requireExtension', () => {
+  test('should report missing browser extension', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              onLoad: {
+                trigger: 'onLoad',
+                actions: [
+                  {
+                    name: '@toddle/setSessionCookies',
+                    arguments: [],
+                  },
+                ],
+              },
+            },
+          },
+        },
+        rules: [requireExtensionRule],
+        state: {
+          isBrowserExtensionAvailable: false,
+        },
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('required extension')
+  })
+  test('should not report missing browser extension', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              onLoad: {
+                trigger: 'onLoad',
+                actions: [
+                  {
+                    type: 'Custom',
+                    name: 'Set session cookies',
+                    arguments: [],
+                  },
+                ],
+              },
+            },
+          },
+        },
+        rules: [requireExtensionRule],
+        state: {
+          isBrowserExtensionAvailable: true,
+        },
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/requireExtensionRule.ts

@@ -0,0 +1,21 @@
+import type { Rule } from '../types'
+
+export const requireExtensionRule: Rule<{
+  name: string
+}> = {
+  code: 'required extension',
+  level: 'info',
+  category: 'Quality',
+  visit: (report, { path, value, nodeType }, state) => {
+    if (
+      nodeType !== 'action-model' ||
+      value.type !== undefined ||
+      value.name !== '@toddle/setSessionCookies' ||
+      !state ||
+      state.isBrowserExtensionAvailable === true
+    ) {
+      return
+    }
+    report(path)
+  },
+}

package/src/rules/slots/unknownClassnameRule.test.ts

@@ -0,0 +1,93 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+import { searchProject } from '../../searchProject'
+import { unknownClassnameRule } from './unknownClassnameRule'
+
+describe('unknownClassname', () => {
+  test('should report referencing unknown classnames', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {
+                    'my-class': {
+                      formula: valueFormula(true),
+                    },
+                  },
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                  variants: [
+                    {
+                      className: 'unknown',
+                      breakpoint: 'small',
+                      style: {},
+                    },
+                  ],
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownClassnameRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown classname')
+    expect(problems[0].details).toEqual({ name: 'unknown' })
+  })
+
+  test('should not report classnames that exist', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {
+                    'my-class': {
+                      formula: valueFormula(true),
+                    },
+                  },
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                  variants: [
+                    {
+                      className: 'my-class',
+                      breakpoint: 'small',
+                      style: {},
+                    },
+                  ],
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownClassnameRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/slots/unknownClassnameRule.ts

@@ -0,0 +1,20 @@
+import { isDefined } from '@nordcraft/core/dist/utils/util'
+import type { Rule } from '../../types'
+
+export const unknownClassnameRule: Rule<{
+  name: string
+}> = {
+  code: 'unknown classname',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, value, nodeType }) => {
+    if (
+      nodeType !== 'style-variant' ||
+      typeof value.variant.className !== 'string' ||
+      isDefined(value.element.classes[value.variant.className])
+    ) {
+      return
+    }
+    report(path, { name: value.variant.className })
+  },
+}

package/src/rules/slots/unknownComponentSlotRule.test.ts

@@ -0,0 +1,169 @@
+import { searchProject } from '../../searchProject'
+import { unknownComponentSlotRule } from './unknownComponentSlotRule'
+
+describe('unknownComponentSlotRule', () => {
+  test('should detect elements in unknown component slots', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            noSlotComponent: {
+              name: 'noSlotComponent',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+            attemptToUseNoSlotComponent: {
+              name: 'attemptToUseNoSlotComponent',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: ['noSlotComponent'],
+                  style: {},
+                },
+                noSlotComponent: {
+                  name: 'noSlotComponent',
+                  attrs: {},
+                  events: {},
+                  type: 'component',
+                  children: ['divInUnknownSlot', 'divInUnknownSlot2'],
+                },
+                divInUnknownSlot: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+                divInUnknownSlot2: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                  slot: 'unknown',
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownComponentSlotRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(2)
+    expect(problems[0].code).toBe('unknown component slot')
+    expect(problems[0].details).toEqual({ slotName: 'default' })
+    expect(problems[1].code).toBe('unknown component slot')
+    expect(problems[1].details).toEqual({ slotName: 'unknown' })
+  })
+
+  test('should pass when using existing slots', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            slotComponent: {
+              name: 'slotComponent',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+                default: {
+                  type: 'slot',
+                  children: [],
+                },
+                slot: {
+                  type: 'slot',
+                  children: [],
+                  name: 'slot',
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+            attemptToUseSlotComponent: {
+              name: 'attemptToUseSlotComponent',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: ['slotComponent'],
+                  style: {},
+                },
+                slotComponent: {
+                  name: 'slotComponent',
+                  attrs: {},
+                  events: {},
+                  type: 'component',
+                  children: ['divInKnownSlot', 'divInKnownSlot2'],
+                },
+                divInKnownSlot: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+                divInKnownSlot2: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                  slot: 'slot',
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownComponentSlotRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/slots/unknownComponentSlotRule.ts

@@ -0,0 +1,50 @@
+import { ToddleComponent } from '@nordcraft/core/dist/component/ToddleComponent'
+import type { SlotNodeModel } from '@nordcraft/core/dist/component/component.types'
+import type { Rule } from '../../types'
+
+export const unknownComponentSlotRule: Rule<{ slotName: string }> = {
+  code: 'unknown component slot',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (nodeType !== 'component-node') {
+      return
+    }
+
+    // We only want to check the immediate children of a "sub component"
+    if (value.type !== 'component' || value.children.length === 0) {
+      return
+    }
+
+    const [, currentComponentName, ,] = path
+
+    const component = files.components[value.name]
+    if (!component) {
+      return
+    }
+    // Load the component to get the slots
+    const subComponent = new ToddleComponent({
+      component,
+      getComponent: (name) => files.components[name],
+      packageName: undefined,
+      globalFormulas: {
+        formulas: files.formulas,
+        packages: files.packages,
+      },
+    })
+
+    const usableSlots = Object.values(subComponent.nodes)
+      .filter((node): node is SlotNodeModel => node.type === 'slot')
+      .map((node) => node.name ?? 'default')
+
+    // Loop the children and report issue when using a slot that doesn't exist
+    value.children.forEach((child) => {
+      const childNode = files.components[currentComponentName]?.nodes[child]
+      const usedSlot = childNode?.slot ?? 'default'
+
+      if (!usableSlots.includes(usedSlot)) {
+        report([path[0], path[1], path[2], child], { slotName: usedSlot })
+      }
+    })
+  },
+}

package/src/rules/unknownCookieRule.test.ts

@@ -0,0 +1,111 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+import { searchProject } from '../searchProject'
+import { unknownCookieRule } from './unknownCookieRule'
+
+describe('unknownCookie', () => {
+  test('should report unknown cookies', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {
+                'my-api': {
+                  name: 'my-api',
+                  type: 'http',
+                  version: 2,
+                  autoFetch: valueFormula(true),
+                  inputs: {},
+                  headers: {
+                    Authorization: {
+                      formula: {
+                        type: 'function',
+                        name: '@toddle/getHttpOnlyCookie',
+                        arguments: [
+                          {
+                            formula: {
+                              type: 'value',
+                              value: 'unknown',
+                            },
+                          },
+                        ],
+                      },
+                    },
+                  },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownCookieRule],
+        state: {
+          cookiesAvailable: [{ name: 'known' } as any],
+          isBrowserExtensionAvailable: true,
+        },
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown cookie')
+  })
+  test('should not report known cookies', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {
+                'my-api': {
+                  name: 'my-api',
+                  type: 'http',
+                  version: 2,
+                  autoFetch: valueFormula(true),
+                  inputs: {},
+                  headers: {
+                    Authorization: {
+                      formula: {
+                        type: 'function',
+                        name: '@toddle/getHttpOnlyCookie',
+                        arguments: [
+                          {
+                            formula: {
+                              type: 'value',
+                              value: 'known',
+                            },
+                          },
+                        ],
+                      },
+                    },
+                  },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownCookieRule],
+        state: {
+          cookiesAvailable: [{ name: 'known' } as any],
+          isBrowserExtensionAvailable: true,
+        },
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/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 })
+    }
+  },
+}