@nordcraft/search 1.0.0

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

@@ -0,0 +1,329 @@
+import { searchProject } from '../../searchProject'
+import { legacyFormulaRule } from './legacyFormulaRule'
+
+describe('legacyFormula', () => {
+  test('should detect legacy formulas used in global formula', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {
+            ADD: {
+              name: 'ADD',
+              arguments: [],
+              handler: '',
+            },
+            EQ: {
+              name: 'EQ',
+              arguments: [],
+              handler: '',
+            },
+            'my-formula-1': {
+              name: 'my-formula-1',
+              arguments: [],
+              formula: {
+                type: 'function',
+                name: 'ADD',
+                arguments: [
+                  {
+                    name: 'arg',
+                    formula: {
+                      type: 'value',
+                      value: 'value',
+                    },
+                  },
+                ],
+              },
+            },
+            'my-formula-2': {
+              name: 'my-formula-2',
+              arguments: [],
+              formula: {
+                type: 'function',
+                name: 'EQ',
+                arguments: [
+                  {
+                    name: 'arg',
+                    formula: {
+                      type: 'value',
+                      value: 'value',
+                    },
+                  },
+                ],
+              },
+            },
+          },
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [legacyFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(2)
+    expect(problems[0].code).toBe('legacy formula')
+    expect(problems[0].details).toEqual({ name: 'ADD' })
+    expect(problems[1].code).toBe('legacy formula')
+    expect(problems[1].details).toEqual({ name: 'EQ' })
+  })
+
+  test('should detect legacy formulas used in global formula as argument', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {
+            ADD: {
+              name: 'ADD',
+              arguments: [],
+              handler: '',
+            },
+            'my-formula-1': {
+              name: 'my-formula-1',
+              arguments: [],
+              formula: {
+                type: 'function',
+                name: 'my-formula-2',
+                arguments: [
+                  {
+                    name: '0',
+                    formula: {
+                      type: 'function',
+                      name: 'ADD',
+                      arguments: [
+                        {
+                          name: '1',
+                          formula: {
+                            type: 'value',
+                            value: 'value',
+                          },
+                        },
+                        {
+                          name: '2',
+                          formula: {
+                            type: 'value',
+                            value: 'value',
+                          },
+                        },
+                      ],
+                    },
+                  },
+                ],
+              },
+            },
+          },
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [legacyFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('legacy formula')
+    expect(problems[0].details).toEqual({ name: 'ADD' })
+  })
+
+  test('should detect legacy formulas used in the component', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {
+            ADD: {
+              name: 'ADD',
+              arguments: [],
+              handler: '',
+            },
+          },
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {
+                    'my-class': {
+                      formula: {
+                        type: 'function',
+                        name: 'ADD',
+                        arguments: [],
+                      },
+                    },
+                  },
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {
+                'my-formula-2': {
+                  name: 'my-formula-2',
+                  arguments: [],
+                  formula: {
+                    type: 'function',
+                    name: 'ADD',
+                    arguments: [],
+                  },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [legacyFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(2)
+    expect(problems[0].code).toBe('legacy formula')
+    expect(problems[1].code).toBe('legacy formula')
+    expect(problems[0].details).toEqual({ name: 'ADD' })
+    expect(problems[1].details).toEqual({ name: 'ADD' })
+  })
+
+  test('should not detect legacy formulas 1', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {
+            APPLY_FORMULA: {
+              name: 'APPLY_FORMULA',
+              arguments: [],
+              handler: '',
+            },
+            'my-formula-1': {
+              name: 'my-formula-1',
+              arguments: [],
+              formula: {
+                type: 'function',
+                name: 'APPLY_FORMULA',
+                arguments: [
+                  {
+                    name: 'arg',
+                    formula: {
+                      type: 'value',
+                      value: 'value',
+                    },
+                  },
+                ],
+              },
+            },
+          },
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [legacyFormulaRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+
+  test('should not detect legacy formulas 2', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {
+                    'my-class': {
+                      formula: {
+                        type: 'function',
+                        name: 'Add',
+                        arguments: [],
+                      },
+                    },
+                  },
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {
+                known: {
+                  name: 'known',
+                  arguments: [],
+                  formula: {
+                    type: 'value',
+                    value: null,
+                  },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [legacyFormulaRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/formulas/legacyFormulaRule.ts

@@ -0,0 +1,158 @@
+import type { FunctionOperation } from '@nordcraft/core/dist/formula/formula'
+import { isToddleFormula } from '@nordcraft/core/dist/formula/formulaTypes'
+import { isDefined } from '@nordcraft/core/dist/utils/util'
+import type { ProjectFiles } from '@nordcraft/ssr/dist/ssr.types'
+import type { Rule } from '../../types'
+
+export const legacyFormulaRule: Rule<{
+  name: string
+}> = {
+  code: 'legacy formula',
+  level: 'warning',
+  category: 'Deprecation',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (
+      nodeType !== 'formula' ||
+      value.type !== 'function' ||
+      !isLegacyFormula(value, files)
+    ) {
+      return
+    }
+    report(path, { name: value.name })
+  },
+}
+
+const isLegacyFormula = (
+  formula: FunctionOperation,
+  files: Omit<ProjectFiles, 'config'> & Partial<Pick<ProjectFiles, 'config'>>,
+) => {
+  const pluginFormula = files.formulas?.[formula.name]
+
+  if (
+    isUpperCase(formula.name) &&
+    isDefined(pluginFormula) &&
+    !isToddleFormula(pluginFormula) &&
+    pluginFormula.version === undefined &&
+    (builtInFormulas.has(formula.name.toLowerCase()) ||
+      legacyFormulas.has(formula.name.toLowerCase()))
+  ) {
+    return true
+  } else {
+    return false
+  }
+}
+
+const isUpperCase = (str: string) => str === str.toUpperCase()
+
+const legacyFormulas = new Set([
+  'and',
+  'concat',
+  'count',
+  'default',
+  'delete',
+  'eq',
+  'flat',
+  'gt',
+  'gte',
+  'if',
+  'list',
+  'lt',
+  'lte',
+  'mod',
+  'neq',
+  'or',
+  'type',
+])
+
+// cSpell: disable
+const builtInFormulas = new Set([
+  'absolute',
+  'add',
+  'append',
+  'boolean',
+  'canshare',
+  'capitalize',
+  'clamp',
+  'concatenate',
+  'currenturl',
+  'datefromstring',
+  'datefromtimestamp',
+  'decodebase64',
+  'decodeuricomponent',
+  'defaultto',
+  'deletekey',
+  'divide',
+  'drop',
+  'droplast',
+  'encodebase64',
+  'encodejson',
+  'encodeuricomponent',
+  'entries',
+  'equals',
+  'every',
+  'filter',
+  'find',
+  'findindex',
+  'findlast',
+  'first',
+  'flatten',
+  'formatdate',
+  'formatnumber',
+  'fromentries',
+  'get',
+  'getelementbyid',
+  'getfromlocalstorage',
+  'getfromsessionstorage',
+  'greaterorequeal',
+  'greaterthan',
+  'groupby',
+  'includes',
+  'indexof',
+  'join',
+  'json',
+  'keyby',
+  'last',
+  'lastindexof',
+  'lessorequal',
+  'lessthan',
+  'lowercase',
+  'map',
+  'matches',
+  'max',
+  'min',
+  'minus',
+  'modulo',
+  'multiply',
+  'not',
+  'notequal',
+  'now',
+  'number',
+  'parsejson',
+  'parseurl',
+  'randomnumber',
+  'range',
+  'reduce',
+  'replaceall',
+  'reverse',
+  'round',
+  'rounddown',
+  'roundup',
+  'set',
+  'shuffle',
+  'size',
+  'some',
+  'sort_by',
+  'split',
+  'squareroot',
+  'startswith',
+  'string',
+  'sum',
+  'take',
+  'takelast',
+  'timestamp',
+  'trim',
+  'typeof',
+  'unique',
+  'uppercase',
+])
+// cSpell: enable