@motiadev/workbench 0.14.0-beta.165-285707 → 0.15.0-beta.165

package/dist/motia-plugin/__tests__/generator.test.ts

@@ -0,0 +1,129 @@
+import {
+  generateCssImports,
+  generateImports,
+  generatePackageMap,
+  generatePluginCode,
+  generatePluginLogic,
+  isValidCode,
+} from '../generator'
+import type { WorkbenchPlugin } from '../types'
+
+describe('Generator', () => {
+  describe('generateImports', () => {
+    it('should generate import statements', () => {
+      const packages = ['@test/plugin-1', '@test/plugin-2']
+      const imports = generateImports(packages)
+
+      expect(imports).toContain("import * as plugin_0 from '@test/plugin-1'")
+      expect(imports).toContain("import * as plugin_1 from '@test/plugin-2'")
+    })
+
+    it('should handle empty package array', () => {
+      const imports = generateImports([])
+
+      expect(imports).toBe('')
+    })
+  })
+
+  describe('generatePackageMap', () => {
+    it('should generate package map', () => {
+      const packages = ['@test/plugin-1', '@test/plugin-2']
+      const map = generatePackageMap(packages)
+
+      expect(map).toContain('const packageMap')
+      expect(map).toContain("'@test/plugin-1': plugin_0")
+      expect(map).toContain("'@test/plugin-2': plugin_1")
+    })
+  })
+
+  describe('generatePluginLogic', () => {
+    it('should generate plugin processing logic', () => {
+      const plugins: WorkbenchPlugin[] = [{ packageName: '@test/plugin', label: 'Test' }]
+      const logic = generatePluginLogic(plugins)
+
+      expect(logic).toContain('const motiaPlugins')
+      expect(logic).toContain('export const plugins')
+      expect(logic).toContain('packageMap[plugin.packageName]')
+    })
+  })
+
+  describe('generatePluginCode', () => {
+    it('should generate complete module code', () => {
+      const plugins: WorkbenchPlugin[] = [{ packageName: '@test/plugin', label: 'Test' }]
+      const code = generatePluginCode(plugins)
+
+      expect(code).toContain('import * as plugin_0')
+      expect(code).toContain('const packageMap')
+      expect(code).toContain('export const plugins')
+    })
+
+    it('should handle empty plugins array', () => {
+      const code = generatePluginCode([])
+
+      expect(code).toBe('export const plugins = []')
+    })
+
+    it('should handle multiple plugins', () => {
+      const plugins: WorkbenchPlugin[] = [{ packageName: '@test/plugin-1' }, { packageName: '@test/plugin-2' }]
+      const code = generatePluginCode(plugins)
+
+      expect(code).toContain("'@test/plugin-1'")
+      expect(code).toContain("'@test/plugin-2'")
+    })
+  })
+
+  describe('generateCssImports', () => {
+    it('should generate CSS import statements', () => {
+      const plugins: WorkbenchPlugin[] = [{ packageName: '@test/plugin', cssImports: ['styles.css', 'theme.css'] }]
+      const css = generateCssImports(plugins)
+
+      expect(css).toContain("@import 'styles.css';")
+      expect(css).toContain("@import 'theme.css';")
+    })
+
+    it('should filter empty CSS imports', () => {
+      const plugins: WorkbenchPlugin[] = [{ packageName: '@test/plugin', cssImports: ['styles.css', '', '  '] }]
+      const css = generateCssImports(plugins)
+
+      expect(css).toContain("@import 'styles.css';")
+      expect(css).not.toContain("@import '';")
+    })
+
+    it('should return empty string for plugins without CSS imports', () => {
+      const plugins: WorkbenchPlugin[] = [{ packageName: '@test/plugin' }]
+      const css = generateCssImports(plugins)
+
+      expect(css).toBe('')
+    })
+
+    it('should flatten CSS imports from multiple plugins', () => {
+      const plugins: WorkbenchPlugin[] = [
+        { packageName: '@test/plugin-1', cssImports: ['a.css'] },
+        { packageName: '@test/plugin-2', cssImports: ['b.css'] },
+      ]
+      const css = generateCssImports(plugins)
+
+      expect(css).toContain("@import 'a.css';")
+      expect(css).toContain("@import 'b.css';")
+    })
+  })
+
+  describe('isValidCode', () => {
+    it('should return true for valid code', () => {
+      expect(isValidCode('export const plugins = []')).toBe(true)
+    })
+
+    it('should return false for empty string', () => {
+      expect(isValidCode('')).toBe(false)
+    })
+
+    it('should return false for whitespace only', () => {
+      expect(isValidCode('   \n\t  ')).toBe(false)
+    })
+
+    it('should return false for non-string', () => {
+      expect(isValidCode(null as any)).toBe(false)
+      expect(isValidCode(undefined as any)).toBe(false)
+    })
+  })
+})

package/dist/motia-plugin/__tests__/resolver.test.ts

@@ -0,0 +1,82 @@
+import { createAliasConfig, getUniquePackageNames, resolvePluginPackage } from '../resolver'
+import type { WorkbenchPlugin } from '../types'
+
+describe('Resolver', () => {
+  describe('resolvePluginPackage', () => {
+    it('should resolve local plugin', () => {
+      const plugin: WorkbenchPlugin = { packageName: '~/plugins/local' }
+      const resolved = resolvePluginPackage(plugin)
+
+      expect(resolved.packageName).toBe('~/plugins/local')
+      expect(resolved.isLocal).toBe(true)
+      expect(resolved.resolvedPath).toContain('plugins/local')
+      expect(resolved.alias).toBe('~/plugins/local')
+    })
+
+    it('should resolve npm package', () => {
+      const plugin: WorkbenchPlugin = { packageName: '@test/plugin' }
+      const resolved = resolvePluginPackage(plugin)
+
+      expect(resolved.packageName).toBe('@test/plugin')
+      expect(resolved.isLocal).toBe(false)
+      expect(resolved.resolvedPath).toContain('node_modules')
+      expect(resolved.resolvedPath).toContain('@test/plugin')
+      expect(resolved.alias).toBe('@test/plugin')
+    })
+
+    it('should normalize paths', () => {
+      const plugin: WorkbenchPlugin = { packageName: 'simple-plugin' }
+      const resolved = resolvePluginPackage(plugin)
+
+      expect(resolved.resolvedPath).not.toContain('\\')
+    })
+  })
+
+  describe('createAliasConfig', () => {
+    it('should create aliases for all plugins', () => {
+      const plugins: WorkbenchPlugin[] = [{ packageName: '~/plugins/local' }, { packageName: '@test/npm' }]
+
+      const aliases = createAliasConfig(plugins)
+
+      expect(aliases['~/plugins/local']).toBeDefined()
+      expect(aliases['@test/npm']).toBeDefined()
+    })
+
+    it('should handle duplicate package names', () => {
+      const plugins: WorkbenchPlugin[] = [{ packageName: '@test/plugin' }, { packageName: '@test/plugin' }]
+
+      const aliases = createAliasConfig(plugins)
+
+      expect(Object.keys(aliases)).toHaveLength(1)
+      expect(aliases['@test/plugin']).toBeDefined()
+    })
+
+    it('should return empty object for empty plugins array', () => {
+      const aliases = createAliasConfig([])
+
+      expect(aliases).toEqual({})
+    })
+  })
+
+  describe('getUniquePackageNames', () => {
+    it('should return unique package names', () => {
+      const plugins: WorkbenchPlugin[] = [
+        { packageName: '@test/a' },
+        { packageName: '@test/b' },
+        { packageName: '@test/a' },
+      ]
+
+      const unique = getUniquePackageNames(plugins)
+
+      expect(unique).toHaveLength(2)
+      expect(unique).toContain('@test/a')
+      expect(unique).toContain('@test/b')
+    })
+
+    it('should return empty array for no plugins', () => {
+      const unique = getUniquePackageNames([])
+
+      expect(unique).toEqual([])
+    })
+  })
+})

package/dist/motia-plugin/__tests__/validator.test.ts

@@ -0,0 +1,71 @@
+import { validatePlugins } from '../validator'
+
+describe('Validator', () => {
+  describe('validatePlugins', () => {
+    it('should validate array of valid plugins', () => {
+      const plugins = [
+        { packageName: '@test/plugin-1', label: 'Plugin 1' },
+        { packageName: '@test/plugin-2', label: 'Plugin 2' },
+      ]
+      const result = validatePlugins(plugins)
+
+      expect(result.valid).toBe(true)
+      expect(result.errors).toHaveLength(0)
+    })
+
+    it('should reject non-array input', () => {
+      const result = validatePlugins('not-an-array' as any)
+
+      expect(result.valid).toBe(false)
+      expect(result.errors.some((err) => err.includes('array'))).toBe(true)
+    })
+
+    it('should handle empty array', () => {
+      const result = validatePlugins([])
+
+      expect(result.valid).toBe(true)
+      expect(result.warnings.some((w) => w.includes('No plugins'))).toBe(true)
+    })
+
+    it('should collect all errors from multiple plugins', () => {
+      const plugins = [{ packageName: '' }, { packageName: '' }, { packageName: 'valid' }]
+      const result = validatePlugins(plugins)
+
+      expect(result.valid).toBe(false)
+      expect(result.errors.length).toBeGreaterThanOrEqual(2)
+    })
+
+    it('should warn about duplicate package names', () => {
+      const plugins = [
+        { packageName: '@test/plugin', label: 'Plugin 1' },
+        { packageName: '@test/plugin', label: 'Plugin 2' },
+      ]
+      const result = validatePlugins(plugins)
+
+      expect(result.valid).toBe(true)
+      expect(result.warnings.some((w) => w.includes('Duplicate'))).toBe(true)
+    })
+
+    it('should support failFast option', () => {
+      const plugins = [{ packageName: '' }, { packageName: '' }]
+      const result = validatePlugins(plugins, { failFast: true })
+
+      expect(result.valid).toBe(false)
+      // With failFast, should stop after first plugin validation fails
+      // Each plugin with empty packageName generates 2 errors (min length + invalid format)
+      // So failFast should result in only the first plugin's errors
+      expect(result.errors.length).toBeLessThanOrEqual(2)
+      // Verify it didn't process second plugin by checking error messages don't mention index 1
+      const hasIndex1Error = result.errors.some((err) => err.includes('index 1'))
+      expect(hasIndex1Error).toBe(false)
+    })
+
+    it('should handle mixed valid and invalid plugins', () => {
+      const plugins = [{ packageName: '@test/valid' }, { packageName: '' }, { packageName: '@test/another-valid' }]
+      const result = validatePlugins(plugins)
+
+      expect(result.valid).toBe(false)
+      expect(result.errors.length).toBeGreaterThan(0)
+    })
+  })
+})

package/dist/motia-plugin/{generator.js → generator.ts}

@@ -1,12 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateImports = generateImports;
-exports.generatePackageMap = generatePackageMap;
-exports.generatePluginLogic = generatePluginLogic;
-exports.generatePluginCode = generatePluginCode;
-exports.generateCssImports = generateCssImports;
-exports.isValidCode = isValidCode;
-const resolver_1 = require("./resolver");
+import { getUniquePackageNames } from './resolver'
+import type { WorkbenchPlugin } from './types'
+
 /**
  * Generates import statements for all unique plugin packages.
  *
@@ -21,9 +15,10 @@ const resolver_1 = require("./resolver");
  * // import * as plugin_1 from '~/plugins/local'
  * ```
  */
-function generateImports(packages) {
-    return packages.map((packageName, index) => `import * as plugin_${index} from '${packageName}'`).join('\n');
+export function generateImports(packages: string[]): string {
+  return packages.map((packageName, index) => `import * as plugin_${index} from '${packageName}'`).join('\n')
 }
+
 /**
  * Generates the package map that links package names to their imported modules.
  *
@@ -36,18 +31,19 @@ function generateImports(packages) {
  * // Returns: const packageMap = {'@org/plugin-1': plugin_0,'~/plugins/local': plugin_1}
  * ```
  */
-function generatePackageMap(packages) {
-    const entries = packages.map((packageName, index) => `'${packageName}': plugin_${index}`);
-    return `const packageMap = {${entries.join(',')}}`;
+export function generatePackageMap(packages: string[]): string {
+  const entries = packages.map((packageName, index) => `'${packageName}': plugin_${index}`)
+  return `const packageMap = {${entries.join(',')}}`
 }
+
 /**
  * Generates the plugin transformation logic that processes plugin configurations.
  *
  * @param plugins - Array of plugin configurations
  * @returns JavaScript code string with plugin processing logic
  */
-function generatePluginLogic(plugins) {
-    return `
+export function generatePluginLogic(plugins: WorkbenchPlugin[]): string {
+  return `
       const motiaPlugins = ${JSON.stringify(plugins)}
 
       export const plugins = motiaPlugins.map((plugin) => {
@@ -63,8 +59,9 @@ function generatePluginLogic(plugins) {
           component: componentName ? component[componentName] : component.default,
         }
       })
-`;
+`
 }
+
 /**
  * Generates the complete virtual module code for all plugins.
  * This is the main code generation function that combines all parts.
@@ -81,18 +78,21 @@ function generatePluginLogic(plugins) {
  * // Returns complete module code with imports, map, and logic
  * ```
  */
-function generatePluginCode(plugins) {
-    if (!plugins || plugins.length === 0) {
-        return 'export const plugins = []';
-    }
-    const packages = (0, resolver_1.getUniquePackageNames)(plugins);
-    const imports = generateImports(packages);
-    const packageMap = generatePackageMap(packages);
-    const logic = generatePluginLogic(plugins);
-    return `${imports}
+export function generatePluginCode(plugins: WorkbenchPlugin[]): string {
+  if (!plugins || plugins.length === 0) {
+    return 'export const plugins = []'
+  }
+
+  const packages = getUniquePackageNames(plugins)
+  const imports = generateImports(packages)
+  const packageMap = generatePackageMap(packages)
+  const logic = generatePluginLogic(plugins)
+
+  return `${imports}
 ${packageMap}
-${logic}`;
+${logic}`
 }
+
 /**
  * Generates CSS imports for plugins that specify cssImports.
  *
@@ -110,19 +110,21 @@ ${logic}`;
  * // @import 'theme.css';
  * ```
  */
-function generateCssImports(plugins) {
-    const cssImports = plugins
-        .flatMap((plugin) => plugin.cssImports || [])
-        .filter((cssImport) => cssImport && cssImport.trim() !== '')
-        .map((cssImport) => `@import '${cssImport}';`);
-    return cssImports.join('\n');
+export function generateCssImports(plugins: WorkbenchPlugin[]): string {
+  const cssImports = plugins
+    .flatMap((plugin) => plugin.cssImports || [])
+    .filter((cssImport) => cssImport && cssImport.trim() !== '')
+    .map((cssImport) => `@import '${cssImport}';`)
+
+  return cssImports.join('\n')
 }
+
 /**
  * Checks if the generated code is valid (non-empty and has content).
  *
  * @param code - The generated code to check
  * @returns True if code is valid
  */
-function isValidCode(code) {
-    return typeof code === 'string' && code.trim().length > 0;
+export function isValidCode(code: string): boolean {
+  return typeof code === 'string' && code.trim().length > 0
 }

package/dist/motia-plugin/hmr.ts

@@ -0,0 +1,123 @@
+import type { Printer } from '@motiadev/core'
+import path from 'path'
+import type { HmrContext, ModuleNode } from 'vite'
+import { resolvePluginPackage } from './resolver'
+import type { WorkbenchPlugin } from './types'
+import { CONSTANTS } from './types'
+import { isLocalPlugin, normalizePath } from './utils'
+
+const WATCHED_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.css', '.scss', '.less']
+
+export function isConfigFile(file: string): boolean {
+  const normalizedFile = normalizePath(file)
+  return normalizedFile.endsWith('motia.config.ts') || normalizedFile.endsWith('motia.config.js')
+}
+
+/**
+ * Checks if a file change should trigger HMR for plugins.
+ *
+ * @param file - The file path that changed
+ * @param plugins - Current plugin configurations
+ * @returns True if the change affects plugins
+ */
+export function shouldInvalidatePlugins(file: string, plugins: WorkbenchPlugin[]): boolean {
+  const normalizedFile = normalizePath(file)
+  const absoluteFile = path.isAbsolute(normalizedFile) ? normalizedFile : path.resolve(process.cwd(), normalizedFile)
+
+  if (isConfigFile(file)) {
+    return true
+  }
+
+  const hasWatchedExtension = WATCHED_EXTENSIONS.some((ext) => absoluteFile.endsWith(ext))
+  if (!hasWatchedExtension) {
+    return false
+  }
+
+  for (const plugin of plugins) {
+    if (isLocalPlugin(plugin.packageName)) {
+      const resolved = resolvePluginPackage(plugin)
+      const pluginAbsolutePath = path.isAbsolute(resolved.resolvedPath)
+        ? resolved.resolvedPath
+        : path.resolve(process.cwd(), resolved.resolvedPath)
+
+      const normalizedPluginPath = pluginAbsolutePath.endsWith(path.sep)
+        ? pluginAbsolutePath
+        : `${pluginAbsolutePath}${path.sep}`
+
+      if (absoluteFile.startsWith(normalizedPluginPath) || absoluteFile === pluginAbsolutePath) {
+        return true
+      }
+    }
+  }
+
+  return false
+}
+
+/**
+ * Handles hot updates for the plugin system.
+ * This function is called by Vite's handleHotUpdate hook.
+ *
+ * @param ctx - Vite's HMR context
+ * @param plugins - Current plugin configurations
+ * @param printer - Printer instance for logging
+ * @returns Array of modules to update, or undefined to continue with default behavior
+ */
+export function handlePluginHotUpdate(
+  ctx: HmrContext,
+  plugins: WorkbenchPlugin[],
+  printer: Printer,
+): ModuleNode[] | undefined {
+  const { file, server, timestamp } = ctx
+
+  printer.printPluginLog(`HMR: File changed: ${normalizePath(file)}`)
+
+  if (isConfigFile(file)) {
+    printer.printPluginLog('HMR: Config file changed, triggering full page reload')
+    printer.printPluginWarn(
+      'Configuration changes require a server restart for full effect. Please restart the dev server to apply all changes.',
+    )
+    server.ws.send({
+      type: 'full-reload',
+      path: '*',
+    })
+    return
+  }
+
+  if (!shouldInvalidatePlugins(file, plugins)) {
+    printer.printPluginLog('HMR: Change outside plugin scope, delegating to Vite default handling')
+    return
+  }
+
+  printer.printPluginLog('HMR: Plugin change detected, invalidating virtual module')
+
+  const virtualModule = server.moduleGraph.getModuleById(CONSTANTS.RESOLVED_VIRTUAL_MODULE_ID)
+
+  if (!virtualModule) {
+    printer.printPluginWarn('HMR: Virtual module not found, triggering full reload as fallback')
+    server.ws.send({
+      type: 'full-reload',
+      path: '*',
+    })
+    return
+  }
+
+  server.moduleGraph.invalidateModule(virtualModule, new Set(), timestamp)
+  printer.printPluginLog('HMR: Virtual module invalidated')
+
+  const modulesToUpdateSet = new Set<ModuleNode>([virtualModule])
+  const processedModules = new Set<ModuleNode>([virtualModule])
+
+  for (const importer of virtualModule.importers) {
+    if (!processedModules.has(importer)) {
+      processedModules.add(importer)
+      modulesToUpdateSet.add(importer)
+      server.moduleGraph.invalidateModule(importer, new Set(), timestamp)
+    }
+  }
+
+  const modulesToUpdate = Array.from(modulesToUpdateSet)
+
+  printer.printPluginLog(`HMR: Updated ${modulesToUpdate.length} module(s)`)
+
+  return modulesToUpdate
+}