@nordcraft/search 1.0.38 → 1.0.40

package/src/rules/actions/legacyActionRule.ts

@@ -1,5 +1,10 @@
+import type {
+  ActionModel,
+  CustomActionArgument,
+} from '@nordcraft/core/dist/component/component.types'
+import { set } from '@nordcraft/core/dist/utils/collections'
 import type { Rule } from '../../types'
-import { isLegacyAction } from '../../util/helpers'
+import { isLegacyAction, renameArguments } from '../../util/helpers'
 
 export const legacyActionRule: Rule<{
   name: string
@@ -11,7 +16,6 @@ export const legacyActionRule: Rule<{
     if (nodeType !== 'action-model') {
       return
     }
-
     if (isLegacyAction(value)) {
       let details: { name: string } | undefined
       if ('name' in value) {
@@ -19,8 +23,166 @@ export const legacyActionRule: Rule<{
           name: value.name,
         }
       }
-
-      report(path, details)
+      report(
+        path,
+        details,
+        unfixableLegacyActions.has(value.name)
+          ? undefined
+          : !formulaNamedActions.includes(value.name) ||
+              // Check if the first argument is a value formula with a string value
+              (value.arguments?.[0].formula.type === 'value' &&
+                typeof value.arguments[0].formula.value === 'string')
+            ? ['replace-legacy-action']
+            : undefined,
+      )
     }
   },
+  fixes: {
+    'replace-legacy-action': ({ path, value, nodeType, files }) => {
+      if (nodeType !== 'action-model') {
+        return
+      }
+      if (!isLegacyAction(value)) {
+        return
+      }
+
+      let newAction: ActionModel | undefined
+      switch (value.name) {
+        case 'If': {
+          const trueActions = value.events?.['true']?.actions ?? []
+          const falseActions = value.events?.['false']?.actions ?? []
+          const trueCondition: CustomActionArgument | undefined =
+            (value.arguments ?? [])[0]
+          newAction = {
+            type: 'Switch',
+            cases: [
+              {
+                condition: trueCondition?.formula ?? null,
+                actions: trueActions,
+              },
+            ],
+            default: { actions: falseActions },
+          }
+          break
+        }
+        case 'PreventDefault': {
+          newAction = {
+            name: '@toddle/preventDefault',
+            arguments: [],
+            label: 'Prevent default',
+          }
+          break
+        }
+        case 'StopPropagation': {
+          newAction = {
+            name: '@toddle/stopPropagation',
+            arguments: [],
+            label: 'Stop propagation',
+          }
+          break
+        }
+        case 'UpdateVariable': {
+          const variableName =
+            value.arguments?.[0]?.formula.type === 'value'
+              ? value.arguments[0].formula.value
+              : undefined
+          if (typeof variableName !== 'string') {
+            break
+          }
+          const variableValue = value.arguments?.[1]?.formula
+          if (!variableValue) {
+            break
+          }
+          newAction = {
+            type: 'SetVariable',
+            variable: variableName,
+            data: variableValue,
+          }
+          break
+        }
+        case 'SetTimeout': {
+          newAction = {
+            ...value,
+            name: '@toddle/sleep',
+            arguments: renameArguments(
+              { 'Delay in ms': 'Delay in milliseconds' },
+              value.arguments,
+            ),
+            events: value.events?.['timeout']
+              ? { tick: value.events.timeout }
+              : undefined,
+            label: 'Sleep',
+          }
+          break
+        }
+        case 'SetInterval': {
+          newAction = {
+            ...value,
+            name: '@toddle/interval',
+            arguments: renameArguments(
+              { 'Interval in ms': 'Interval in milliseconds' },
+              value.arguments,
+            ),
+            label: 'Interval',
+          }
+          break
+        }
+        case 'Debug': {
+          newAction = {
+            ...value,
+            name: '@toddle/logToConsole',
+            label: 'Log to console',
+          }
+          break
+        }
+        case 'GoToURL': {
+          newAction = {
+            name: '@toddle/gotToURL', // Yes, the typo is in the action name
+            arguments: renameArguments({ url: 'URL' }, value.arguments),
+            label: 'Go to URL',
+          }
+          break
+        }
+        case 'TriggerEvent': {
+          const eventName =
+            value.arguments?.[0]?.formula.type === 'value'
+              ? value.arguments[0].formula.value
+              : undefined
+          if (typeof eventName !== 'string') {
+            break
+          }
+          const eventData = value.arguments?.[1]?.formula
+          if (!eventData) {
+            break
+          }
+          newAction = {
+            type: 'TriggerEvent',
+            event: eventName,
+            data: eventData,
+          }
+          break
+        }
+      }
+      if (newAction) {
+        return set(files, path, newAction)
+      }
+    },
+  },
 }
+
+// These actions take a first argument which is a formula as the name
+// of the thing to update/trigger. We can only safely autofix these if
+// the argument is a value operation and a string
+const formulaNamedActions = ['UpdateVariable', 'TriggerEvent']
+
+const unfixableLegacyActions = new Set([
+  'CopyToClipboard', // Previously, this action would JSON stringify non-string inputs
+  'Update URL parameter', // The user will need to pick a history mode (push/replace)
+  'Fetch', // This was mainly used for APIs v1
+  'FocusElement', // The new 'Focus' action takes an element as input - not a selector
+  'UpdateVariable', // The variable name could be a formula in the legacy version
+  'TriggerEvent', // The name of the event could be a formula in the legacy version
+  '@toddle/setSessionCookies', // The new 'Set cookie' action takes more arguments
+])
+
+export type LegacyActionRuleFix = 'replace-legacy-action'

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

@@ -1,8 +1,9 @@
 import { describe, expect, test } from 'bun:test'
+import { fixProject } from '../../fixProject'
 import { searchProject } from '../../searchProject'
 import { noReferenceComponentRule } from './noReferenceComponentRule'
 
-describe('noReferenceComponentRule', () => {
+describe('detect noReferenceComponentRule', () => {
   test('should detect components with no references', () => {
     const problems = Array.from(
       searchProject({
@@ -213,3 +214,88 @@ describe('noReferenceComponentRule', () => {
     expect(problems[0].path).toEqual(['components', 'exportedOrphan'])
   })
 })
+
+describe('fix noReferenceComponentRule', () => {
+  test('should remove components with no references', () => {
+    const fixedProject = fixProject({
+      files: {
+        formulas: {},
+        components: {
+          orphan: {
+            name: 'test',
+            nodes: {},
+            formulas: {},
+            apis: {},
+            attributes: {},
+            variables: {},
+          },
+          anotherOrphan: {
+            name: 'test 2',
+            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: {},
+            },
+          },
+        },
+      },
+      rule: noReferenceComponentRule,
+      fixType: 'delete-component',
+      state: {
+        projectDetails: {
+          type: 'package',
+          id: 'test-project-id',
+          name: 'test-project',
+          short_id: 'test-project-id',
+        },
+      },
+    })
+    // The orphan component should no longer exist
+    expect(fixedProject.components).toEqual({
+      exportedOrphan: {
+        name: 'test',
+        nodes: {},
+        formulas: {},
+        apis: {},
+        attributes: {},
+        variables: {},
+        exported: true,
+      },
+      page: {
+        name: 'my-page',
+        nodes: {},
+        formulas: {},
+        apis: {},
+        attributes: {},
+        variables: {},
+        route: {
+          info: {},
+          path: [],
+          query: {},
+        },
+      },
+    })
+  })
+})

package/src/rules/components/noReferenceComponentRule.ts

@@ -1,40 +1,55 @@
 import type { Component } from '@nordcraft/core/dist/component/component.types'
+import { omit } from '@nordcraft/core/dist/utils/collections'
 import { isDefined } from '@nordcraft/core/dist/utils/util'
-import type { Rule } from '../../types'
+import type { ApplicationState, NodeType, Rule } from '../../types'
 
 export const noReferenceComponentRule: Rule<void> = {
   code: 'no-reference component',
   level: 'warning',
   category: 'No References',
-  visit: (report, { path, nodeType, files, value }, state) => {
-    // 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) ||
-      (state?.projectDetails?.type === 'package' && value.exported === true)
-    ) {
+  visit: (report, data, state) => {
+    if (hasReferences(data, state)) {
       return
     }
+    report(data.path, undefined, ['delete-component'])
+  },
+  fixes: {
+    'delete-component': (data, state) => {
+      if (hasReferences(data, state)) {
+        return
+      }
+      return omit(data.files, data.path)
+    },
+  },
+}
 
-    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
-        }
+const hasReferences = (data: NodeType, state?: ApplicationState) => {
+  if (
+    data.nodeType !== 'component' ||
+    isPage(data.value) ||
+    (state?.projectDetails?.type === 'package' && data.value.exported === true)
+  ) {
+    return true
+  }
+  for (const component of Object.values(data.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 === data.value.name &&
+        // Circular references from a component to itself should
+        // not count as a reference
+        node.name !== component!.name
+      ) {
+        return true
       }
     }
-
-    report(path)
-  },
+  }
+  return false
 }
 
+export type NoReferenceComponentRuleFix = 'delete-component'
+
 const isPage = (
   value: Component,
 ): value is Component & { route: Required<Component['route']> } =>

package/src/rules/formulas/legacyFormulaRule.test.ts

@@ -1,8 +1,11 @@
+import type { ToddleFormula } from '@nordcraft/core/dist/formula/formulaTypes'
+import type { ProjectFiles } from '@nordcraft/ssr/dist/ssr.types'
 import { describe, expect, test } from 'bun:test'
+import { fixProject } from '../../fixProject'
 import { searchProject } from '../../searchProject'
 import { legacyFormulaRule } from './legacyFormulaRule'
 
-describe('legacyFormula', () => {
+describe('detect legacyFormula', () => {
   test('should detect legacy formulas used in global formula', () => {
     const problems = Array.from(
       searchProject({
@@ -328,3 +331,241 @@ describe('legacyFormula', () => {
     expect(problems).toEqual([])
   })
 })
+describe('fix legacyFormula', () => {
+  test('should fix the legacy AND formula', () => {
+    const files: ProjectFiles = {
+      formulas: {
+        AND: {
+          name: 'AND',
+          arguments: [],
+          handler: '',
+        },
+        'my-formula-1': {
+          name: 'my-formula-1',
+          arguments: [],
+          formula: {
+            type: 'function',
+            name: '@toddle/concatenate',
+            arguments: [
+              {
+                name: '0',
+                formula: {
+                  type: 'function',
+                  name: 'AND',
+                  arguments: [
+                    {
+                      name: 'Condition',
+                      formula: { type: 'value', value: true },
+                    },
+                    {
+                      name: 'Condition',
+                      formula: { type: 'value', value: true },
+                    },
+                  ],
+                  variableArguments: true,
+                },
+              },
+            ],
+            variableArguments: true,
+            display_name: 'Concatenate',
+          },
+        },
+      },
+      components: {},
+    }
+    const fixedProject = fixProject({
+      files,
+      rule: legacyFormulaRule,
+      fixType: 'replace-legacy-formula',
+    })
+
+    expect(
+      (fixedProject.formulas?.['my-formula-1'] as ToddleFormula).formula,
+    ).toEqual({
+      type: 'function',
+      name: '@toddle/concatenate',
+      arguments: [
+        {
+          name: '0',
+          formula: {
+            type: 'and',
+            arguments: [
+              {
+                formula: { type: 'value', value: true },
+              },
+              {
+                formula: { type: 'value', value: true },
+              },
+            ],
+            variableArguments: true,
+          },
+        },
+      ],
+      variableArguments: true,
+      display_name: 'Concatenate',
+    } as any)
+  })
+  test('should fix the legacy IF formula', () => {
+    const files: ProjectFiles = {
+      formulas: {
+        IF: {
+          name: 'IF',
+          arguments: [],
+          handler: '',
+        },
+      },
+      components: {
+        'project-sidebar-item': {
+          apis: {},
+          name: 'project-sidebar-item',
+          nodes: {},
+          events: [],
+          onLoad: {
+            actions: [],
+            trigger: 'Load',
+          },
+          contexts: {
+            EditorPage: {
+              formulas: ['XK0T8tQWA0YhkfDUzqu-h'],
+              workflows: ['sNo0Ya'],
+              componentName: 'EditorPage',
+            },
+          },
+          formulas: {
+            p_Z1PzOcDop79KGafQ7Lm: {
+              name: 'Preview domain',
+              formula: {
+                name: 'IF',
+                type: 'function',
+                arguments: [
+                  {
+                    name: 'If',
+                    formula: {
+                      name: '@toddle/equals',
+                      type: 'function',
+                      arguments: [
+                        {
+                          name: 'First',
+                          formula: {
+                            path: ['Attributes', 'branch-name'],
+                            type: 'path',
+                          },
+                        },
+                        {
+                          name: 'Second',
+                          formula: {
+                            type: 'value',
+                            value: 'main',
+                          },
+                        },
+                      ],
+                      display_name: 'Equals',
+                    },
+                  },
+                  {
+                    name: 'Then',
+                    formula: {
+                      name: '@toddle/concatenate',
+                      type: 'function',
+                      arguments: [
+                        {
+                          name: 'Items',
+                          formula: {
+                            type: 'value',
+                            value: 'https://',
+                          },
+                        },
+                        {
+                          formula: {
+                            path: ['Attributes', 'project-name'],
+                            type: 'path',
+                          },
+                        },
+                        {
+                          formula: {
+                            type: 'value',
+                            value: '.toddle.site',
+                          },
+                        },
+                      ],
+                      display_name: 'Concatenate',
+                      variableArguments: true,
+                    },
+                  },
+                  {
+                    name: 'Else',
+                    formula: {
+                      name: '@toddle/concatenate',
+                      type: 'function',
+                      arguments: [
+                        {
+                          formula: {
+                            type: 'value',
+                            value: 'https://',
+                          },
+                        },
+                        {
+                          formula: {
+                            path: ['Attributes', 'branch-name'],
+                            type: 'path',
+                          },
+                        },
+                        {
+                          formula: {
+                            type: 'value',
+                            value: '-',
+                          },
+                        },
+                        {
+                          formula: {
+                            path: ['Attributes', 'project-name'],
+                            type: 'path',
+                          },
+                        },
+                        {
+                          formula: {
+                            type: 'value',
+                            value: '.toddle.site',
+                          },
+                        },
+                      ],
+                      display_name: 'Concatenate',
+                      variableArguments: true,
+                    },
+                  },
+                ],
+              },
+              memoize: false,
+              arguments: [],
+            },
+          },
+          variables: {},
+          workflows: {},
+          attributes: {},
+        },
+      },
+    }
+    const fixedProject = fixProject({
+      files,
+      rule: legacyFormulaRule,
+      fixType: 'replace-legacy-formula',
+      pathsToVisit: [
+        [
+          'components',
+          'project-sidebar-item',
+          'formulas',
+          'p_Z1PzOcDop79KGafQ7Lm',
+          'formula',
+        ],
+      ],
+      useExactPaths: true,
+    })
+
+    const updatedFormula = (
+      fixedProject.components['project-sidebar-item']?.formulas?.[
+        'p_Z1PzOcDop79KGafQ7Lm'
+      ] as any
+    )?.formula
+    expect(updatedFormula.type).toEqual('switch')
+  })
+})