@motiadev/workbench 0.13.0-beta.162-650022 → 0.13.0-beta.162-125657

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

@@ -1,129 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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/hmr.ts

@@ -1,123 +0,0 @@
-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
-}

package/dist/motia-plugin/index.ts

@@ -1,183 +0,0 @@
-import { Printer } from '@motiadev/core'
-import path from 'path'
-import type { Plugin, ViteDevServer } from 'vite'
-import { generateCssImports, generatePluginCode, isValidCode } from './generator'
-import { handlePluginHotUpdate } from './hmr'
-import { createAliasConfig, resolvePluginPackage } from './resolver'
-import type { WorkbenchPlugin } from './types'
-import { CONSTANTS } from './types'
-import { isLocalPlugin, normalizePath } from './utils'
-import { validatePlugins } from './validator'
-
-/**
- * Vite plugin for loading and managing Motia workbench plugins.
- *
- * Features:
- * - Hot Module Replacement (HMR) support
- * - Runtime validation with detailed error messages
- * - Verbose logging for debugging
- * - CSS injection for plugin styles
- *
- * @param plugins - Array of plugin configurations
- * @param options - Optional loader configuration
- * @returns Vite plugin instance
- *
- * @example
- * ```ts
- * export default defineConfig({
- *   plugins: [
- *     motiaPluginsPlugin([
- *       { packageName: '@my-org/plugin', label: 'My Plugin' }
- *     ])
- *   ]
- * })
- * ```
- */
-const printer = new Printer(process.cwd())
-
-export default function motiaPluginsPlugin(plugins: WorkbenchPlugin[]): Plugin {
-  let devServer: ViteDevServer | null = null
-
-  try {
-    const validationResult = validatePlugins(plugins, {
-      failFast: false,
-    })
-
-    if (!validationResult.valid) {
-      printer.printPluginError('Plugin configuration validation failed:')
-      for (const err of validationResult.errors) {
-        printer.printPluginError(`  ${err}`)
-      }
-      throw new Error('Invalid plugin configuration. See errors above.')
-    }
-
-    if (validationResult.warnings.length > 0) {
-      for (const warning of validationResult.warnings) {
-        printer.printPluginWarn(warning)
-      }
-    }
-  } catch (error) {
-    printer.printPluginError(`Failed to validate plugins: ${error}`)
-    throw error
-  }
-
-  const alias = createAliasConfig(plugins)
-
-  printer.printPluginLog(`Initialized with ${plugins.length} plugin(s)`)
-
-  return {
-    name: 'vite-plugin-motia-plugins',
-    enforce: 'pre',
-
-    buildStart() {
-      printer.printPluginLog('Build started')
-    },
-
-    config: () => ({
-      resolve: {
-        alias,
-      },
-    }),
-
-    configureServer(server) {
-      devServer = server
-      printer.printPluginLog('Dev server configured, HMR enabled')
-
-      const configPaths = [path.join(process.cwd(), 'motia.config.ts'), path.join(process.cwd(), 'motia.config.js')]
-
-      for (const configPath of configPaths) {
-        server.watcher.add(configPath)
-      }
-      printer.printPluginLog('Watching for config file changes')
-
-      const localPlugins = plugins.filter((p) => isLocalPlugin(p.packageName))
-      if (localPlugins.length > 0) {
-        printer.printPluginLog(`Watching ${localPlugins.length} local plugin(s)`)
-
-        for (const plugin of localPlugins) {
-          const resolved = resolvePluginPackage(plugin)
-          const watchPath = resolved.resolvedPath
-
-          server.watcher.add(watchPath)
-          printer.printPluginLog(`Watching: ${watchPath}`)
-        }
-
-        server.watcher.on('change', (file) => {
-          const normalizedFile = normalizePath(file)
-          printer.printPluginLog(`File watcher detected change: ${normalizedFile}`)
-        })
-
-        server.watcher.on('add', (file) => {
-          const normalizedFile = normalizePath(file)
-          printer.printPluginLog(`File watcher detected new file: ${normalizedFile}`)
-        })
-      }
-    },
-
-    resolveId(id) {
-      if (id === CONSTANTS.VIRTUAL_MODULE_ID) {
-        return CONSTANTS.RESOLVED_VIRTUAL_MODULE_ID
-      }
-    },
-
-    load(id) {
-      if (id !== CONSTANTS.RESOLVED_VIRTUAL_MODULE_ID) {
-        return null
-      }
-
-      printer.printPluginLog('Loading plugins virtual module')
-      printer.printPluginLog('Generating plugin code...')
-
-      const code = generatePluginCode(plugins)
-
-      if (!isValidCode(code)) {
-        printer.printPluginError('Generated code is invalid or empty')
-        return 'export const plugins = []'
-      }
-
-      printer.printPluginLog('Plugin code generated successfully')
-
-      return code
-    },
-
-    async transform(code, id) {
-      const normalizedId = normalizePath(id)
-
-      if (!normalizedId.endsWith('src/index.css')) {
-        return null
-      }
-
-      printer.printPluginLog('Injecting plugin CSS imports')
-
-      const cssImports = generateCssImports(plugins)
-
-      if (!cssImports) {
-        return null
-      }
-
-      return {
-        code: `${cssImports}\n${code}`,
-        map: null,
-      }
-    },
-
-    handleHotUpdate(ctx) {
-      if (!devServer) {
-        printer.printPluginWarn('HMR: Dev server not available')
-        return
-      }
-
-      const modulesToUpdate = handlePluginHotUpdate(ctx, plugins, printer)
-
-      if (modulesToUpdate && modulesToUpdate.length > 0) {
-        const merged = Array.from(new Set([...(ctx.modules || []), ...modulesToUpdate]))
-        printer.printPluginLog(`HMR: Successfully updated ${merged.length} module(s)`)
-        return merged
-      }
-    },
-
-    buildEnd() {
-      printer.printPluginLog('Build ended')
-    },
-  }
-}