imdone-core 1.54.10 → 2.0.1

package/lib/plugins/plugin-manager.js

@@ -1,25 +1,39 @@
-const Emitter = require('events')
-const Plugin = require('imdone-api')
-const _path = require('path')
-const downloadRepo = require('../adapters/git-download')
-const rimraf = require('rimraf')
-const sane = require('sane')
-const debounce = require('lodash.debounce')
-const { exists, mkdir, readdir } = require('../adapters/file-gateway')
-const appContext = require('../context/ApplicationContext')
-
-module.exports = class PluginManager extends Emitter {
+import Emitter from 'events'
+import Plugin from 'imdone-api'
+import _path from 'path'
+import { downloadPlugin } from '../adapters/git-download.js'
+import rimraf from 'rimraf'
+import chokidar from 'chokidar'
+import debounce from 'lodash.debounce'
+import { exists, mkdir, readdir } from '../adapters/file-gateway.js'
+import { appContext } from '../context/ApplicationContext.js'
+import { createRequire } from 'node:module';
+
+import PersistTagsPlugin from './persist-tags-plugin.js'
+import DefaultBoardPropertiesPlugin from './default-board-properties-plugin.js'
+import DefaultBoardActionsPlugin from './default-board-actions-plugin.js'
+import ArchivePlugin from './archive-plugin.js'
+import EpicPlugin from './epic-plugin.js'
+import ExtensionPlugin from './extension-plugin.js'
+import { logger } from '../adapters/logger.js'
+
+const require = createRequire(import.meta.url);
+const url = new URL(import.meta.url)
+const __dirname = _path.dirname(url.pathname)
+
+export class PluginManager extends Emitter {
   constructor(project) {
     super()
     this.project = project
     this.defaultPlugins = [
-      './persist-tags-plugin',
-      './default-board-properties-plugin',
-      './default-board-actions-plugin',
-      './archive-plugin',
-      './epic-plugin', 
-      './extension-plugin',
+      PersistTagsPlugin,
+      DefaultBoardPropertiesPlugin,
+      DefaultBoardActionsPlugin,
+      ArchivePlugin,
+      EpicPlugin,
+      ExtensionPlugin,
     ]
+
     this.pluginsMap = {}
     this.pluginPath = _path.join(project.path, '.imdone', 'plugins')
     this.onDevChange = debounce(this.onDevChange.bind(this), 1000)
@@ -29,7 +43,7 @@ module.exports = class PluginManager extends Emitter {
     if (this.project && this.project.config.devMode && !this.watcher) {
       if (!(await exists(this.pluginPath)))
         await mkdir(this.pluginPath)
-      this.watcher = sane(this.pluginPath, {
+      this.watcher = chokidar(this.pluginPath, {
         ignored(path) {
           return /node_modules/.test(path)
         },
@@ -58,7 +72,7 @@ module.exports = class PluginManager extends Emitter {
       await this.reloadPlugins()
       this.emit('plugins-reloaded')
     } catch {
-      console.error('Error reloading plugins.', err)
+      logger.error('Error reloading plugins.', err)
       throw err
     }
   }
@@ -71,7 +85,7 @@ module.exports = class PluginManager extends Emitter {
 
   async uninstallPlugin(pluginName) {
     return new Promise((resolve, reject) => {
-      console.log('Preparing to uninstall plugin:', pluginName)
+      logger.log('Preparing to uninstall plugin:', pluginName)
       const pluginClassName = Object.keys(this.pluginsMap).find((key) => {
         return this.getPlugin(key).info.name === pluginName
       })
@@ -81,7 +95,7 @@ module.exports = class PluginManager extends Emitter {
       const { info } = this.getPlugin(pluginClassName)
       const { path } = info
       // const pkg = { version, name }
-      console.log('Uninstalling:', info)
+      logger.log('Uninstalling:', info)
 
       rimraf(path, (err) => {
         if (err) return reject(err)
@@ -96,15 +110,15 @@ module.exports = class PluginManager extends Emitter {
     if (!(await exists(this.pluginPath)))
       await mkdir(this.pluginPath)
     const installPath = _path.join(this.pluginPath, name)
-    await downloadRepo(version, installPath)
-    console.log(`Done installing ${name}`)
+    await downloadPlugin(version, installPath)
+    logger.log(`Done installing ${name}`)
     await this.loadPlugin(installPath)
     this.emit('plugin-installed', name)
   }
 
   async loadPlugins() {
-    for (const pluginPath of this.defaultPlugins) {
-      await this.loadPlugin(pluginPath)
+    for (const PluginClass of this.defaultPlugins) {
+      await this.createPlugin(PluginClass)
     }
 
     await this.loadInstalledPlugins()
@@ -143,40 +157,49 @@ module.exports = class PluginManager extends Emitter {
   }
 
   async loadPlugin(path) {
-    console.log('Loading plugin: ', path)
+    logger.log('Loading plugin: ', path)
+    const fullPath = path.endsWith('.js') 
+      ? _path.resolve(path) 
+      : _path.join(_path.resolve(path), 'bundle.js')
+
     try {
       // eslint-disable-next-line
-      delete require.cache[require.resolve(path)]
+      delete require.cache[require.resolve(fullPath)]
       // eslint-disable-next-line
-      const pluginClass = require(path)
-      const pluginInstance = await this.createPlugin(pluginClass, path)
-      if (pluginInstance.init) await pluginInstance.init()
+      const pluginClass = await import(_path.resolve(path))
+      const pluginInstance = await this.createPlugin(pluginClass.default, path)
+      return pluginInstance
     } catch (e) {
-      console.error(`Error loading plugin at: ${path}`, e)
+      logger.error(`Error loading plugin at: ${path}`, e)
     }
   }
 
-  async createPlugin(pluginClass, path) {
-    if (!this.isPlugin(pluginClass))
-      throw new Error(`${pluginClass.name} is not a plugin`)
-    const name = pluginClass.name.toString()
-    const pluginInstance = new pluginClass(this.project)
-    let info = {}
+  getPackageInfo(path) {
+    if (!path) return {}
+    let info = { path }
     try {
-      info = require(`${path}/package.json`)
+      info = {...info, ...require(`${path}/package.json`) }
       delete info.dependencies
       delete info.devDependencies
       delete info.scripts
       delete info.main
     } catch (e) {
-      console.info('No info on plugin:', path)
-    } finally {
-      info.path = path
-      info.name = name
+      logger.info('No info on plugin:', path)
+    }
+  }
+  
+  async createPlugin(pluginClass, path = undefined) {
+    if (!this.isPlugin(pluginClass))
+      throw new Error(`${pluginClass.name} is not a plugin`)
+    const name = pluginClass.name.toString()
+    const pluginInstance = new pluginClass(this.project)
+    let info = {
+      name,
+      ...this.getPackageInfo(path),
     }
 
     pluginInstance.getSettings = () => {
-      return this.getPluginSettings(info.name)
+      return this.getPluginSettings(name)
     }
     
     this.pluginsMap[name] = {
@@ -185,6 +208,8 @@ module.exports = class PluginManager extends Emitter {
       info,
     }
 
+    if (pluginInstance.init) await pluginInstance.init()
+
     return pluginInstance
   }
 
@@ -200,7 +225,15 @@ module.exports = class PluginManager extends Emitter {
   }
 
   isPlugin(pluginClass) {
-    return Object.getPrototypeOf(pluginClass).name === Plugin.name
+    // const pluginClassName = Plugin.name.toString()
+    // return pluginClass.proname.toString() === pluginClassName
+    const pluginClassPrototypeName = Object.getPrototypeOf(pluginClass.prototype).constructor.name
+    const pluginClassName = Plugin.name.toString()
+    logger.log('pluginClassPrototypeName', pluginClassPrototypeName)
+    logger.log('pluginClassName', pluginClassName)
+    return pluginClassPrototypeName === pluginClassName
+   
+    // return Object.getPrototypeOf(pluginClass.prototype) === Plugin.prototype
   }
 
   eachPlugin(cb) {
@@ -227,6 +260,10 @@ module.exports = class PluginManager extends Emitter {
     })
   }
 
+  disablePlugin(name) {
+    delete this.pluginsMap[name]
+  }
+
   getPluginName(pluginInstance) {
     return Object.keys(this.pluginsMap).find(
       (pluginName) =>
@@ -249,7 +286,7 @@ module.exports = class PluginManager extends Emitter {
   }
 
   pluginError(method, pluginInstance, error) {
-    console.warn(
+    logger.warn(
       `Plugin: ${this.getPluginName(
         pluginInstance
       )} threw an error on ${method}: `,
@@ -261,13 +298,13 @@ module.exports = class PluginManager extends Emitter {
     if (!lists || lists.length == 0) return
     await this.eachPluginAsync(async ({ pluginInstance }) => {
       // const timeLabel = `${this.getPluginName(pluginInstance)} onBoardUpdate time`
-      // console.time(timeLabel)
+      // logger.time(timeLabel)
       try {
         await pluginInstance.onBoardUpdate(lists)
       } catch (e) {
         this.pluginError('onBoardUpdate', pluginInstance, e)
       }
-      // console.timeEnd(timeLabel)
+      // logger.timeEnd(timeLabel)
     })
     return lists
   }
@@ -340,10 +377,7 @@ module.exports = class PluginManager extends Emitter {
     return cardProps
   }
 
-  // READY Make getBoardProperties async
-  // <!--
-  // order:-10
-  // -->
+
   async getBoardProperties() {
     let boardProps = {}
     await this.eachPluginAsync(async ({ pluginInstance }) => {
@@ -409,13 +443,16 @@ module.exports = class PluginManager extends Emitter {
   }
 
   async performBoardAction(action, task) {
+    const title = action.title || action.name
     const plugin = this.getPluginInstance(action.plugin)
     try {
       return action.index 
       ? await plugin.getBoardActions()[action.index].action(task)
-      : await plugin.getBoardActions().find(a => a.title === action.title).action(task)
+      : await plugin.getBoardActions().find(a => a.title === title).action(task)
     } catch (e) {
+      
       this.pluginError('getBoardActions', plugin, e)
+      throw new Error(`Error performing action ${title} on plugin ${plugin.name}: ${e.message}`)
     }
   }
 }

package/lib/plugins/plugin-registry.js

@@ -1,29 +1,25 @@
-const {
+import https from 'https'
+import {
 	renderMarkdown,
-} = require('../adapters/markdown')
-
-module.exports = {
-  
-  getAvailablePlugins: async function () {
-    const response = await fetch('https://raw.githubusercontent.com/imdone/imdone-plugins/main/index.json')
-    const plugins = response.body
-    for (const plugin of plugins) {
-      plugin.content = renderMarkdown(await getReadmeContent(plugin))
-    }
-    return plugins
-  },
+} from '../adapters/markdown.js'
 
+export async function getAvailablePlugins() {
+  const response = await fetch('https://raw.githubusercontent.com/imdone/imdone-plugins/main/index.json')
+  const plugins = response.body
+  for (const plugin of plugins) {
+    plugin.content = renderMarkdown(await getReadmeContent(plugin))
+  }
+  return plugins
 }
 
 async function getReadmeContent({version}) {
   const response = await fetch(`https://api.github.com/repos/${version}/readme`)
-  const { content } = response.body
+  const { content } = response?.body
+  if (!content) return ''
   const buffer = Buffer.from(content, 'base64');
   return buffer.toString('utf-8');
 }
 
-const https = require('https')
-
 async function fetch(url, opts = { method: 'GET', headers: {} }) {
   const { method, headers, body, debug = () => { } } = opts
   if (body) headers['Content-Length'] = body.length

package/lib/project-factory.js

@@ -1,20 +1,21 @@
-const Repository = require('./repository')
-const watchedFsStore = require('./mixins/repo-watched-fs-store')
-const fsStore = require('./mixins/repo-fs-store')
-const ProjectContext = require('./ProjectContext')
-const Project = require('./project')
-const context = require('./context/ApplicationContext')
+import { Repository } from './repository.js'
+import { watchedFileSystemStoreMixin } from './mixins/repo-watched-fs-store.js'
+import { fileSystemStoreMixin } from './mixins/repo-fs-store.js'
+import { ProjectContext } from './ProjectContext.js'
+import { WorkerProject } from './project.js'
+import { appContext as context } from './context/ApplicationContext.js'
+import _path from 'node:path'
 
-function createFileSystemProject({
+export function createFileSystemProject({
     path,
     config,
-    repo = fsStore(new Repository(path, config)),
+    repo = fileSystemStoreMixin(new Repository(_path.resolve(path), config)),
     loadInstalledPlugins,
     loadPluginsNotInstalled
 }) {
     context().repo = repo
     context().projectContext = new ProjectContext(repo)
-    context().project = new Project(repo)
+    context().project = new WorkerProject(repo)
     if (loadInstalledPlugins) {
         context().project.pluginManager.loadInstalledPlugins = loadInstalledPlugins
     }
@@ -24,22 +25,18 @@ function createFileSystemProject({
     return context().project
 }
 
-module.exports = {
-    createWatchedFileSystemProject: function({
+export function createWatchedFileSystemProject({
+    path,
+    config,
+    repo = watchedFileSystemStoreMixin(new Repository(_path.resolve(path), config)),
+    loadInstalledPlugins,
+    loadPluginsNotInstalled    
+}) {
+    return createFileSystemProject({
         path,
         config,
-        repo = watchedFsStore(new Repository(path, config)),
+        repo,
         loadInstalledPlugins,
-        loadPluginsNotInstalled    
-    }) {
-        return createFileSystemProject({
-            path,
-            config,
-            repo,
-            loadInstalledPlugins,
-            loadPluginsNotInstalled        
-        })
-    },
-
-    createFileSystemProject
+        loadPluginsNotInstalled        
+    })
 }