@graphcommerce/next-config 8.1.0-canary.2 → 8.1.0-canary.5

package/src/interceptors/extractExports.ts

@@ -0,0 +1,230 @@
+/* eslint-disable no-continue */
+/* eslint-disable max-classes-per-file */
+import type {
+  ArrayExpression,
+  BooleanLiteral,
+  Identifier,
+  KeyValueProperty,
+  Module,
+  Node,
+  NullLiteral,
+  NumericLiteral,
+  ObjectExpression,
+  RegExpLiteral,
+  StringLiteral,
+  TemplateLiteral,
+} from '@swc/core'
+
+export class NoSuchDeclarationError extends Error {}
+
+function isIdentifier(node: Node): node is Identifier {
+  return node.type === 'Identifier'
+}
+
+function isBooleanLiteral(node: Node): node is BooleanLiteral {
+  return node.type === 'BooleanLiteral'
+}
+
+function isNullLiteral(node: Node): node is NullLiteral {
+  return node.type === 'NullLiteral'
+}
+
+function isStringLiteral(node: Node): node is StringLiteral {
+  return node.type === 'StringLiteral'
+}
+
+function isNumericLiteral(node: Node): node is NumericLiteral {
+  return node.type === 'NumericLiteral'
+}
+
+function isArrayExpression(node: Node): node is ArrayExpression {
+  return node.type === 'ArrayExpression'
+}
+
+function isObjectExpression(node: Node): node is ObjectExpression {
+  return node.type === 'ObjectExpression'
+}
+
+function isKeyValueProperty(node: Node): node is KeyValueProperty {
+  return node.type === 'KeyValueProperty'
+}
+
+function isRegExpLiteral(node: Node): node is RegExpLiteral {
+  return node.type === 'RegExpLiteral'
+}
+
+function isTemplateLiteral(node: Node): node is TemplateLiteral {
+  return node.type === 'TemplateLiteral'
+}
+
+export class UnsupportedValueError extends Error {
+  /** @example `config.runtime[0].value` */
+  path?: string
+
+  constructor(message: string, paths?: string[]) {
+    super(message)
+
+    // Generating "path" that looks like "config.runtime[0].value"
+    let codePath: string | undefined
+    if (Array.isArray(paths)) {
+      codePath = ''
+      for (const path of paths) {
+        if (path[0] === '[') {
+          // "array" + "[0]"
+          codePath += path
+        } else if (codePath === '') {
+          codePath = path
+        } else {
+          // "object" + ".key"
+          codePath += `.${path}`
+        }
+      }
+    }
+
+    this.path = codePath
+  }
+}
+
+export const RUNTIME_VALUE = Symbol('RUNTIME_VALUE')
+
+function extractValue(node: Node, path?: string[], optional: boolean = false): any {
+  if (isNullLiteral(node)) {
+    return null
+  }
+  if (isBooleanLiteral(node)) {
+    // e.g. true / false
+    return node.value
+  }
+  if (isStringLiteral(node)) {
+    // e.g. "abc"
+    return node.value
+  }
+  if (isNumericLiteral(node)) {
+    // e.g. 123
+    return node.value
+  }
+  if (isRegExpLiteral(node)) {
+    // e.g. /abc/i
+    return new RegExp(node.pattern, node.flags)
+  }
+  if (isIdentifier(node)) {
+    switch (node.value) {
+      case 'undefined':
+        return undefined
+      default:
+        if (optional) return RUNTIME_VALUE
+        throw new UnsupportedValueError(`Unknown identifier "${node.value}"`, path)
+    }
+  } else if (isArrayExpression(node)) {
+    // e.g. [1, 2, 3]
+    const arr: any[] = []
+    for (let i = 0, len = node.elements.length; i < len; i++) {
+      const elem = node.elements[i]
+      if (elem) {
+        if (elem.spread) {
+          // e.g. [ ...a ]
+          if (optional) return RUNTIME_VALUE
+          throw new UnsupportedValueError(
+            'Unsupported spread operator in the Array Expression',
+            path,
+          )
+        }
+
+        arr.push(extractValue(elem.expression, path && [...path, `[${i}]`], optional))
+      } else {
+        // e.g. [1, , 2]
+        //         ^^
+        arr.push(undefined)
+      }
+    }
+    return arr
+  } else if (isObjectExpression(node)) {
+    // e.g. { a: 1, b: 2 }
+    const obj: any = {}
+    for (const prop of node.properties) {
+      if (!isKeyValueProperty(prop)) {
+        // e.g. { ...a }
+        if (optional) return RUNTIME_VALUE
+        throw new UnsupportedValueError(
+          'Unsupported spread operator in the Object Expression',
+          path,
+        )
+      }
+
+      let key
+      if (isIdentifier(prop.key)) {
+        // e.g. { a: 1, b: 2 }
+        key = prop.key.value
+      } else if (isStringLiteral(prop.key)) {
+        // e.g. { "a": 1, "b": 2 }
+        key = prop.key.value
+      } else {
+        if (optional) return RUNTIME_VALUE
+        throw new UnsupportedValueError(
+          `Unsupported key type "${prop.key.type}" in the Object Expression`,
+          path,
+        )
+      }
+
+      obj[key] = extractValue(prop.value, path && [...path, key])
+    }
+
+    return obj
+  } else if (isTemplateLiteral(node)) {
+    // e.g. `abc`
+    if (node.expressions.length !== 0) {
+      // TODO: should we add support for `${'e'}d${'g'}'e'`?
+      if (optional) return RUNTIME_VALUE
+      throw new UnsupportedValueError('Unsupported template literal with expressions', path)
+    }
+
+    // When TemplateLiteral has 0 expressions, the length of quasis is always 1.
+    // Because when parsing TemplateLiteral, the parser yields the first quasi,
+    // then the first expression, then the next quasi, then the next expression, etc.,
+    // until the last quasi.
+    // Thus if there is no expression, the parser ends at the frst and also last quasis
+    //
+    // A "cooked" interpretation where backslashes have special meaning, while a
+    // "raw" interpretation where backslashes do not have special meaning
+    // https://exploringjs.com/impatient-js/ch_template-literals.html#template-strings-cooked-vs-raw
+    const [{ cooked, raw }] = node.quasis
+
+    return cooked ?? raw
+  } else {
+    if (optional) return RUNTIME_VALUE
+    throw new UnsupportedValueError(`Unsupported node type "${node.type}"`, path)
+  }
+}
+
+export function extractExports(module: Module) {
+  const exports: Record<string, unknown> = {}
+  const errors: string[] = []
+
+  for (const moduleItem of module.body) {
+    switch (moduleItem.type) {
+      case 'ExportAllDeclaration':
+        errors.push('You can not use export * from a plugin, exports must be explicit')
+        break
+      case 'ExportDefaultDeclaration':
+        errors.push('You can not use default exports from a plugin, exports must be explicit')
+        break
+      case 'ExportDeclaration':
+        switch (moduleItem.declaration.type) {
+          case 'ClassDeclaration':
+          case 'FunctionDeclaration':
+            exports[moduleItem.declaration.identifier.value] = RUNTIME_VALUE
+            // node.identifier.value
+            break
+          case 'VariableDeclaration':
+            moduleItem.declaration.declarations.forEach((decl) => {
+              if (isIdentifier(decl.id) && decl.init) {
+                exports[decl.id.value] = extractValue(decl.init, undefined, true)
+              }
+            })
+            break
+        }
+    }
+  }
+
+  return [exports, errors] as const
+}

package/src/interceptors/findOriginalSource.ts

@@ -0,0 +1,105 @@
+import path from 'path'
+import { ResolveDependency, ResolveDependencyReturn } from '../utils/resolveDependency'
+import { PluginConfig } from './generateInterceptor'
+import { parseSync } from './swc'
+import { ExportAllDeclaration } from '@swc/core'
+
+function parseAndFindExport(
+  resolved: ResolveDependencyReturn,
+  findExport: string,
+  resolve: ResolveDependency,
+): ResolveDependencyReturn {
+  if (!resolved?.source) return undefined
+  const ast = parseSync(resolved.source)
+
+  for (const node of ast.body) {
+    if (node.type === 'ExportDeclaration') {
+      switch (node.declaration.type) {
+        case 'ClassDeclaration':
+        case 'FunctionDeclaration':
+          if (node.declaration.identifier.value === findExport) return resolved
+          break
+        case 'VariableDeclaration':
+          for (const declaration of node.declaration.declarations) {
+            if (declaration.type === 'VariableDeclarator') {
+              if (declaration.id.type === 'Identifier') {
+                if (declaration.id.value === findExport) return resolved
+              } else {
+                console.log(declaration)
+              }
+            }
+          }
+          break
+      }
+    }
+  }
+
+  const exports = ast.body
+    .filter((node): node is ExportAllDeclaration => node.type === 'ExportAllDeclaration')
+    .sort((a, b) => {
+      const probablyA = a.source.value.includes(findExport)
+      const probablyB = b.source.value.includes(findExport)
+      // eslint-disable-next-line no-nested-ternary
+      return probablyA === probablyB ? 0 : probablyA ? -1 : 1
+    })
+
+  for (const node of exports) {
+    const isRelative = node.source.value.startsWith('.')
+    if (isRelative) {
+      const d =
+        resolved.dependency === resolved.denormalized
+          ? resolved.dependency.substring(0, resolved.dependency.lastIndexOf('/'))
+          : resolved.dependency
+
+      const newPath = path.join(d, node.source.value)
+
+      const resolveResult = resolve(newPath, { includeSources: true })
+      // eslint-disable-next-line no-continue
+      if (!resolveResult) continue
+
+      const newResolved = parseAndFindExport(resolveResult, findExport, resolve)
+
+      if (newResolved && resolved.dependency !== newResolved.dependency) return newResolved
+    }
+  }
+
+  return undefined
+}
+
+const cachedResults = new Map<string, ResolveDependencyReturn>()
+
+export function findOriginalSource(
+  plug: PluginConfig,
+  resolved: ResolveDependencyReturn,
+  resolve: ResolveDependency,
+):
+  | { resolved: NonNullable<ResolveDependencyReturn>; error: undefined }
+  | { resolved: undefined; error: Error } {
+  if (!resolved?.source)
+    return {
+      resolved: undefined,
+      error: new Error(`Could not resolve ${plug.targetModule}`),
+    }
+
+  // const cacheKey = `${plug.targetModule}#${plug.targetExport}`
+  // if (cachedResults.has(cacheKey)) {
+  //   return {
+  //     resolved: cachedResults.get(cacheKey) as NonNullable<ResolveDependencyReturn>,
+  //     error: undefined,
+  //   }
+  // }
+
+  const newResolved = parseAndFindExport(resolved, plug.targetExport, resolve)
+
+  if (!newResolved) {
+    return {
+      resolved: undefined,
+      error: new Error(
+        `Can not find ${plug.targetModule}#${plug.sourceExport} for plugin ${plug.sourceModule}`,
+      ),
+    }
+  }
+
+  // cachedResults.set(cacheKey, newResolved)
+  return { resolved: newResolved, error: undefined }
+}

package/src/interceptors/findPlugins.ts

@@ -1,51 +1,12 @@
-import { parseFileSync } from '@swc/core'
 // eslint-disable-next-line import/no-extraneous-dependencies
+import { parseFileSync } from '@swc/core'
 import chalk from 'chalk'
 // eslint-disable-next-line import/no-extraneous-dependencies
-import glob from 'glob'
-import get from 'lodash/get'
-import type { Path } from 'react-hook-form'
+import { sync as globSync } from 'glob'
 import { GraphCommerceConfig } from '../generated/config'
 import { resolveDependenciesSync } from '../utils/resolveDependenciesSync'
-import {
-  isMethodPluginConfig,
-  isPluginBaseConfig,
-  isPluginConfig,
-  isReactPluginConfig,
-  PluginConfig,
-} from './generateInterceptors'
-
-type ParseResult = {
-  component?: string
-  exported?: string
-  ifConfig?: Path<GraphCommerceConfig>
-}
-
-function parseStructure(file: string): ParseResult {
-  const ast = parseFileSync(file, { syntax: 'typescript', tsx: true })
-
-  const imports: Record<string, string> = {}
-  const exports: Record<string, string> = {}
-
-  ast.body.forEach((node) => {
-    if (node.type === 'ImportDeclaration') {
-      node.specifiers.forEach((s) => {
-        if (s.type === 'ImportSpecifier') {
-          imports[s.local.value] = node.source.value
-        }
-      })
-    }
-    if (node.type === 'ExportDeclaration' && node.declaration.type === 'VariableDeclaration') {
-      node.declaration.declarations.forEach((declaration) => {
-        if (declaration.init?.type === 'StringLiteral' && declaration.id.type === 'Identifier') {
-          exports[declaration.id.value] = declaration.init.value
-        }
-      })
-    }
-  })
-
-  return exports as ParseResult
-}
+import { PluginConfig } from './generateInterceptor'
+import { parseStructure } from './parseStructure'
 
 const pluginLogs: Record<string, string> = {}
 
@@ -57,35 +18,15 @@ export function findPlugins(config: GraphCommerceConfig, cwd: string = process.c
   const errors: string[] = []
   const plugins: PluginConfig[] = []
   dependencies.forEach((dependency, path) => {
-    const files = glob.sync(`${dependency}/plugins/**/*.{ts,tsx}`)
+    const files = globSync(`${dependency}/plugins/**/*.{ts,tsx}`, { dotRelative: true })
     files.forEach((file) => {
-      try {
-        const result = parseStructure(file)
-        if (!result) return
-
-        const pluginConfig = {
-          plugin: file.replace(dependency, path).replace('.tsx', '').replace('.ts', ''),
-          ...result,
-          enabled: !result.ifConfig || Boolean(get(config, result.ifConfig)),
-        }
+      const sourceModule = file.replace(dependency, path).replace('.tsx', '').replace('.ts', '')
 
-        if (!isPluginConfig(pluginConfig)) {
-          if (!isPluginBaseConfig(pluginConfig))
-            errors.push(
-              `Plugin ${file} is not a valid plugin, make it has "export const exported = '@graphcommerce/my-package"`,
-            )
-          else if (file.endsWith('.ts')) {
-            errors.push(
-              `Plugin ${file} is not a valid plugin, please define the method to create a plugin for "export const method = 'someMethod'"`,
-            )
-          } else if (file.endsWith('.tsx')) {
-            errors.push(
-              `Plugin ${file} is not a valid plugin, please define the compoennt to create a plugin for "export const component = 'SomeComponent'"`,
-            )
-          }
-        } else {
-          plugins.push(pluginConfig)
-        }
+      try {
+        const ast = parseFileSync(file, { syntax: 'typescript', tsx: true })
+        parseStructure(ast, config, sourceModule).forEach((result) => {
+          plugins.push(result)
+        })
       } catch (e) {
         console.error(`Error parsing ${file}`, e)
       }
@@ -93,27 +34,35 @@ export function findPlugins(config: GraphCommerceConfig, cwd: string = process.c
   })
 
   if (process.env.NODE_ENV === 'development' && debug) {
-    const byExported = plugins.reduce((acc, plugin) => {
-      const componentStr = isReactPluginConfig(plugin) ? plugin.component : ''
-      const funcStr = isMethodPluginConfig(plugin) ? plugin.func : ''
-      const key = `🔌 ${chalk.greenBright(
-        `Plugins loaded for ${plugin.exported}#${componentStr}${funcStr}`,
-      )}`
-      if (!acc[key]) acc[key] = []
-      acc[key].push(plugin)
-      return acc
-    }, {} as Record<string, Pick<PluginConfig, 'plugin' | 'ifConfig' | 'enabled'>[]>)
+    const byExported = plugins.reduce(
+      (acc, plugin) => {
+        const key = `🔌 ${chalk.greenBright(
+          `Plugins loaded for ${plugin.targetModule}#${plugin.targetExport}`,
+        )}`
+        if (!acc[key]) acc[key] = []
+        acc[key].push(plugin)
+        return acc
+      },
+      {} as Record<
+        string,
+        Pick<PluginConfig, 'sourceModule' | 'sourceExport' | 'ifConfig' | 'enabled'>[]
+      >,
+    )
 
     const toLog: string[] = []
     Object.entries(byExported).forEach(([key, p]) => {
       const logStr = p
         .filter((c) => debug || c.enabled)
-        .map(
-          (c) =>
-            `${c.enabled ? `🟢` : `⚪️`} ${c.plugin} ${
-              c.ifConfig ? `(${c.ifConfig}: ${c.enabled ? 'true' : 'false'})` : ''
-            }`,
-        )
+        .map((c) => {
+          // eslint-disable-next-line no-nested-ternary
+          const ifConfigStr = c.ifConfig
+            ? Array.isArray(c.ifConfig)
+              ? `${c.ifConfig[0]}=${c.ifConfig[1]}`
+              : `${c.ifConfig}`
+            : ''
+
+          return `${c.enabled ? `🟢` : `⚪️`} ${c.sourceModule} ${ifConfigStr}`
+        })
         .join('\n')
 
       if (logStr && pluginLogs[key] !== logStr) {
@@ -123,7 +72,7 @@ export function findPlugins(config: GraphCommerceConfig, cwd: string = process.c
     })
 
     // eslint-disable-next-line no-console
-    console.log(toLog.join('\n\n'))
+    if (toLog.length) console.log(toLog.join('\n\n'))
   }
 
   return [plugins, errors] as const