plugin system working

README.md

@@ -16,7 +16,8 @@
 ## Plugins
 
 - [x] shadowdog-rake
-- [ ] shadowdog-local-cache
-- [ ] shadowdog-remote-cache (minio, aws)
+- [x] shadowdog-local-cache
+- [x] shadowdog-tag
+- [ ] shadowdog-remote-aws-s3-cache (minio, aws)
 - [ ] shadowdog-tree
 - [ ] shadowdog-git

shadowdog.json

@@ -1,48 +1,42 @@
 {
   "$schema": "./src/config/schema.json",
   "plugins": [
+    {
+      "name": "shadowdog-rake"
+    },
     {
       "name": "shadowdog-local-cache",
       "options": {
-        "path": "/tmp/shadowdog/cache"
+        "boira": true
       }
+    },
+    {
+      "name": "shadowdog-tag"
     }
   ],
   "cache": {
     "enabled": false
   },
   "watchers": [
     {
-      "files": ["./src/config/build-schema.ts", "./src/config.ts"],
+      "files": ["./src/config/build-schema.ts", "./src/config.ts", "./src/plugins/index.ts"],
       "commands": [
         {
           "artifacts": [
             {
-              "output": "./src/config/schema.json"
+              "output": "./src/config/schema.json",
+              "tags": ["schema"]
             }
           ],
           "command": "npm run build-schema"
         }
       ]
     },
     {
-      "files": ["./file1"],
+      "files": [],
       "commands": [
         {
-          "artifacts": [
-            {
-              "output": "./file1a.output"
-            }
-          ],
-          "command": "cat file1 > ./file1a.output"
-        },
-        {
-          "artifacts": [
-            {
-              "output": "./file1b.output"
-            }
-          ],
-          "command": "cat file1 > ./file1b.output"
+          "command": "echo 'hello shadowdog'"
         }
       ]
     }

src/cli.ts

@@ -30,9 +30,8 @@ cli
   .command('generate')
   .description('TBA')
   .addOption(configOption)
-  .option('-t, --tag <tag>', 'TBA')
-  .action(({ config: configFilePath, tag }) => {
-    generate(configFilePath, tag)
+  .action(({ config: configFilePath }) => {
+    generate(configFilePath)
   })
 
 cli.parse(process.argv)

src/config.ts

@@ -2,10 +2,7 @@ import fs from 'fs-extra'
 import { logMessage } from './utils'
 import { z } from 'zod'
 import chalk from 'chalk'
-
-// TODO: rake plugin
-// const PluginTypeEnum = z.enum(['shadowdog-rake', 'shadowdog-local-cache'])
-const PluginTypeEnum = z.enum(['shadowdog-local-cache'])
+import { PluginNameEnum } from './plugins'
 
 export const configSchema = z
   .object({
@@ -22,12 +19,7 @@ export const configSchema = z
       .default(['.git', '**/node_modules'])
       .describe('Default ignored files when watching files'),
     plugins: z
-      .array(
-        z.union([
-          PluginTypeEnum.describe('Plugin name'),
-          z.object({ name: PluginTypeEnum, options: z.any() }).strict(),
-        ]),
-      )
+      .array(z.object({ name: PluginNameEnum, options: z.any() }).strict())
       .optional()
       .default([])
       .describe('List of plugins to use'),
@@ -144,6 +136,8 @@ export type CommandConfig = WatcherConfig['commands'][number]
 
 export type ArtifactConfig = NonNullable<CommandConfig['artifacts']>[number]
 
+export type PluginsConfig = ConfigFile['plugins']
+
 export const loadConfig = (configFilePath: string): ConfigFile => {
   logMessage(`✨ Reading config file from ${chalk.blue(configFilePath)}...`)
 

src/config/schema.json

@@ -22,25 +22,16 @@
     "plugins": {
       "type": "array",
       "items": {
-        "anyOf": [
-          {
+        "type": "object",
+        "properties": {
+          "name": {
             "type": "string",
-            "enum": ["shadowdog-local-cache"],
-            "description": "Plugin name"
+            "enum": ["shadowdog-rake", "shadowdog-local-cache", "shadowdog-tag"]
           },
-          {
-            "type": "object",
-            "properties": {
-              "name": {
-                "type": "string",
-                "enum": ["shadowdog-local-cache"]
-              },
-              "options": {}
-            },
-            "required": ["name"],
-            "additionalProperties": false
-          }
-        ]
+          "options": {}
+        },
+        "required": ["name"],
+        "additionalProperties": false
       },
       "default": [],
       "description": "List of plugins to use"

src/daemon.ts

@@ -5,62 +5,16 @@ import debounce from 'lodash/debounce'
 import uniq from 'lodash/uniq'
 import path from 'path'
 
-import { restoreCache } from './cache'
 import { ConfigFile, loadConfig } from './config'
-import { createClient } from './global-cache'
 import { notifyState } from './notifications'
 import { runTask } from './tasks'
 import { logMessage } from './utils'
 import chalk from 'chalk'
-import { Client } from 'minio'
 
-// TODO: Add the rest of the plugins
-import shadowdogRake from './plugins/shadowdog-rake'
-import shadowdogLocalCache from './plugins/shadowdog-local-cache'
+import { TaskRunner } from './task-runner'
+import { filterMiddlewarePlugins } from './plugins'
 
-const PLUGINS_MAP = {
-  'shadowdog-local-cache': shadowdogLocalCache,
-} as const
-
-type Result = any
-
-export type Middleware<Context = any> = (
-  ctx: Context,
-  next: () => Promise<Result>,
-  abort: () => void,
-) => Promise<Result>
-
-class TaskManager {
-  middlewares: Array<{ middleware: Middleware; options: any }>
-
-  constructor() {
-    this.middlewares = []
-  }
-
-  use(middleware: Middleware, options: any = {}) {
-    this.middlewares.push({ middleware, options })
-  }
-
-  async execute(context: any) {
-    let index = -1
-    let isAborted = false
-
-    const abort = () => {
-      isAborted = true
-    }
-
-    const next = async () => {
-      if (isAborted || ++index >= this.middlewares.length) return context.result
-      const current = this.middlewares[index]
-      return current.middleware({ ...context, options: current.options }, next, abort)
-    }
-
-    context.result = await next()
-    return context.result
-  }
-}
-
-const setupWatchers = (config: ConfigFile, socketPath: string, client: Client | null) => {
+const setupWatchers = (config: ConfigFile) => {
   return Promise.all<chokidar.FSWatcher>(
     config.watchers
       .filter(({ files, enabled = true }) => {
@@ -150,30 +104,24 @@ const setupWatchers = (config: ConfigFile, socketPath: string, client: Client |
 
             await Promise.all(
               watcherConfig.commands.map(async (commandConfig) => {
-                const taskManager = new TaskManager()
+                const taskRunner = new TaskRunner(watcherConfig, commandConfig)
 
-                config.plugins.forEach((pluginName) => {
-                  if (typeof pluginName === 'object') {
-                    return taskManager.use(PLUGINS_MAP[pluginName.name], pluginName.options)
-                  }
-                  taskManager.use(PLUGINS_MAP[pluginName])
+                filterMiddlewarePlugins(config.plugins).forEach((pluginFn) => {
+                  taskRunner.use(pluginFn.middleware)
                 })
 
-                taskManager.use(() => {
+                taskRunner.use(() => {
                   return runTask({
                     command: commandConfig.command,
                     workingDirectory: process.cwd(),
-                    filePath,
+                    changedFilePath: filePath,
                     onSpawn: (task) => {
                       tasks.push(task)
                     },
                   })
                 })
 
-                return taskManager.execute({
-                  watcherConfig,
-                  commandConfig,
-                })
+                return taskRunner.execute()
 
                 ///////////////////////////// REVIEW THIS CODE /////////////////////////////
 
@@ -256,13 +204,13 @@ const setupWatchers = (config: ConfigFile, socketPath: string, client: Client |
   )
 }
 
-const watchFiles = async (configFilePath: string, socketPath: string) => {
+const watchFiles = async (configFilePath: string) => {
   let currentWatchers: chokidar.FSWatcher[] = []
   let currentConfig = loadConfig(configFilePath)
 
   fs.mkdirpSync(currentConfig.cache.path)
 
-  const client = currentConfig.cache.enabled ? createClient() : null
+  // const client = currentConfig.cache.enabled ? createClient() : null
 
   const configWatcher = chokidar.watch(configFilePath, {
     ignoreInitial: true,
@@ -275,15 +223,15 @@ const watchFiles = async (configFilePath: string, socketPath: string) => {
       try {
         currentConfig = loadConfig(configFilePath)
         await Promise.all(currentWatchers.map((watcher) => watcher.close()))
-        currentWatchers = await setupWatchers(currentConfig, socketPath, client)
+        currentWatchers = await setupWatchers(currentConfig)
         logMessage(`🐕 Shadowdog has been restarted successfully.`)
       } catch (error) {
         logMessage(`🚨 Error while restarting Shadowdog: ${(error as Error).message}`)
       }
     }, currentConfig.debounceTime),
   )
 
-  currentWatchers = await setupWatchers(currentConfig, socketPath, client)
+  currentWatchers = await setupWatchers(currentConfig)
 
   return currentWatchers
 }
@@ -301,7 +249,7 @@ export const runDaemon = async (configFilePath: string, socketPath: string) => {
     false,
   )
 
-  await watchFiles(configFilePath, socketPath)
+  await watchFiles(configFilePath)
 
   logMessage('🚀 Shadowdog is ready to watch your files!')