blaizejs 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -132,8 +132,31 @@ function compose(middlewareStack) {
 }
 
 // src/plugins/create.ts
-function create2(name, version, setup, _defaultOptions = {}) {
-  throw new Error("Plugin system not yet available");
+function create2(name, version, setup, defaultOptions = {}) {
+  if (!name || typeof name !== "string") {
+    throw new Error("Plugin name must be a non-empty string");
+  }
+  if (!version || typeof version !== "string") {
+    throw new Error("Plugin version must be a non-empty string");
+  }
+  if (typeof setup !== "function") {
+    throw new Error("Plugin setup must be a function");
+  }
+  return function pluginFactory(userOptions) {
+    const mergedOptions = { ...defaultOptions, ...userOptions };
+    const plugin = {
+      name,
+      version,
+      // The register hook calls the user's setup function
+      register: async (app) => {
+        const result = await setup(app, mergedOptions);
+        if (result && typeof result === "object") {
+          Object.assign(plugin, result);
+        }
+      }
+    };
+    return plugin;
+  };
 }
 
 // src/router/discovery/finder.ts
@@ -173,12 +196,18 @@ async function findRouteFiles(routesDir, options = {}) {
   return routeFiles;
 }
 function isRouteFile(filename) {
-  return !filename.startsWith("_") && (filename.endsWith(".ts") || filename.endsWith(".js")) && filename !== "index.ts" && filename !== "index.js";
+  return !filename.startsWith("_") && (filename.endsWith(".ts") || filename.endsWith(".js"));
 }
 
 // src/router/discovery/parser.ts
 var path2 = __toESM(require("path"), 1);
 function parseRoutePath(filePath, basePath) {
+  if (filePath.startsWith("file://")) {
+    filePath = filePath.replace("file://", "");
+  }
+  if (basePath.startsWith("file://")) {
+    basePath = basePath.replace("file://", "");
+  }
   const forwardSlashFilePath = filePath.replace(/\\/g, "/");
   const forwardSlashBasePath = basePath.replace(/\\/g, "/");
   const normalizedBasePath = forwardSlashBasePath.endsWith("/") ? forwardSlashBasePath : `${forwardSlashBasePath}/`;
@@ -712,21 +741,56 @@ function createRouter(options) {
   const matcher = createMatcher();
   let initialized = false;
   let initializationPromise = null;
-  let _watcher = null;
+  let _watchers = null;
+  const routeSources = /* @__PURE__ */ new Map();
+  const routeDirectories = /* @__PURE__ */ new Set([routerOptions.routesDir]);
+  function addRouteWithSource(route, source) {
+    const existingSources = routeSources.get(route.path) || [];
+    if (existingSources.includes(source)) {
+      console.warn(`Skipping duplicate route: ${route.path} from ${source}`);
+      return;
+    }
+    if (existingSources.length > 0) {
+      const conflictError = new Error(
+        `Route conflict for path "${route.path}": already defined in ${existingSources.join(", ")}, now being added from ${source}`
+      );
+      console.error(conflictError.message);
+      throw conflictError;
+    }
+    routeSources.set(route.path, [...existingSources, source]);
+    addRouteInternal(route);
+  }
+  async function loadRoutesFromDirectory(directory, source, prefix) {
+    try {
+      const discoveredRoutes = await findRoutes(directory, {
+        basePath: routerOptions.basePath
+      });
+      for (const route of discoveredRoutes) {
+        const finalRoute = prefix ? {
+          ...route,
+          path: `${prefix}${route.path}`
+        } : route;
+        addRouteWithSource(finalRoute, source);
+      }
+      console.log(
+        `Loaded ${discoveredRoutes.length} routes from ${source}${prefix ? ` with prefix ${prefix}` : ""}`
+      );
+    } catch (error) {
+      console.error(`Failed to load routes from ${source}:`, error);
+      throw error;
+    }
+  }
   async function initialize() {
     if (initialized || initializationPromise) {
       return initializationPromise;
     }
     initializationPromise = (async () => {
       try {
-        const discoveredRoutes = await findRoutes(routerOptions.routesDir, {
-          basePath: routerOptions.basePath
-        });
-        for (const route of discoveredRoutes) {
-          addRouteInternal(route);
+        for (const directory of routeDirectories) {
+          await loadRoutesFromDirectory(directory, directory);
         }
         if (routerOptions.watchMode) {
-          setupWatcher();
+          setupWatcherForAllDirectories();
         }
         initialized = true;
       } catch (error) {
@@ -743,47 +807,81 @@ function createRouter(options) {
       matcher.add(route.path, method, methodOptions);
     });
   }
-  function setupWatcher() {
-    _watcher = watchRoutes(routerOptions.routesDir, {
-      ignore: ["node_modules", ".git"],
+  function createWatcherCallbacks(directory, source, prefix) {
+    return {
       onRouteAdded: (addedRoutes) => {
         console.log(
-          `${addedRoutes.length} route(s) added:`,
+          `${addedRoutes.length} route(s) added from ${directory}:`,
           addedRoutes.map((r) => r.path)
         );
-        addedRoutes.forEach((route) => addRouteInternal(route));
+        addedRoutes.forEach((route) => {
+          const finalRoute = prefix ? { ...route, path: `${prefix}${route.path}` } : route;
+          addRouteWithSource(finalRoute, source);
+        });
       },
       onRouteChanged: (changedRoutes) => {
         console.log(
-          `${changedRoutes.length} route(s) changed:`,
+          `${changedRoutes.length} route(s) changed in ${directory}:`,
           changedRoutes.map((r) => r.path)
         );
         changedRoutes.forEach((route) => {
-          const index = routes.findIndex((r) => r.path === route.path);
+          const finalPath = prefix ? `${prefix}${route.path}` : route.path;
+          const index = routes.findIndex((r) => r.path === finalPath);
           if (index >= 0) {
             routes.splice(index, 1);
+            const sources = routeSources.get(finalPath) || [];
+            const filteredSources = sources.filter((s) => s !== source);
+            if (filteredSources.length > 0) {
+              routeSources.set(finalPath, filteredSources);
+            } else {
+              routeSources.delete(finalPath);
+            }
           }
-          addRouteInternal(route);
+          const finalRoute = prefix ? { ...route, path: finalPath } : route;
+          addRouteWithSource(finalRoute, source);
         });
       },
       onRouteRemoved: (filePath, removedRoutes) => {
-        console.log("-----------------------Routes before removal:", routes);
         console.log(
-          `File removed: ${filePath} with ${removedRoutes.length} route(s):`,
+          `File removed from ${directory}: ${filePath} with ${removedRoutes.length} route(s):`,
           removedRoutes.map((r) => r.path)
         );
         removedRoutes.forEach((route) => {
-          const index = routes.findIndex((r) => r.path === route.path);
+          const finalPath = prefix ? `${prefix}${route.path}` : route.path;
+          const index = routes.findIndex((r) => r.path === finalPath);
           if (index >= 0) {
             routes.splice(index, 1);
           }
+          const sources = routeSources.get(finalPath) || [];
+          const filteredSources = sources.filter((s) => s !== source);
+          if (filteredSources.length > 0) {
+            routeSources.set(finalPath, filteredSources);
+          } else {
+            routeSources.delete(finalPath);
+          }
         });
-        console.log("-----------------------Routes after removal:", routes);
       },
       onError: (error) => {
-        console.error("Route watcher error:", error);
+        console.error(`Route watcher error for ${directory}:`, error);
       }
+    };
+  }
+  function setupWatcherForDirectory(directory, source, prefix) {
+    const callbacks = createWatcherCallbacks(directory, source, prefix);
+    const watcher = watchRoutes(directory, {
+      ignore: ["node_modules", ".git"],
+      ...callbacks
     });
+    if (!_watchers) {
+      _watchers = /* @__PURE__ */ new Map();
+    }
+    _watchers.set(directory, watcher);
+    return watcher;
+  }
+  function setupWatcherForAllDirectories() {
+    for (const directory of routeDirectories) {
+      setupWatcherForDirectory(directory, directory);
+    }
   }
   initialize().catch((error) => {
     console.error("Failed to initialize router on creation:", error);
@@ -833,6 +931,34 @@ function createRouter(options) {
      */
     addRoute(route) {
       addRouteInternal(route);
+    },
+    /**
+     * Add a route directory (for plugins)
+     */
+    async addRouteDirectory(directory, options2 = {}) {
+      if (routeDirectories.has(directory)) {
+        console.warn(`Route directory ${directory} already registered`);
+        return;
+      }
+      routeDirectories.add(directory);
+      if (initialized) {
+        await loadRoutesFromDirectory(directory, directory, options2.prefix);
+        if (routerOptions.watchMode) {
+          setupWatcherForDirectory(directory, directory, options2.prefix);
+        }
+      }
+    },
+    /**
+     * Get route conflicts
+     */
+    getRouteConflicts() {
+      const conflicts = [];
+      for (const [path5, sources] of routeSources.entries()) {
+        if (sources.length > 1) {
+          conflicts.push({ path: path5, sources });
+        }
+      }
+      return conflicts;
     }
   };
 }
@@ -855,7 +981,7 @@ function getCallerFilePath() {
   try {
     Error.prepareStackTrace = (_, stack2) => stack2;
     const stack = new Error().stack;
-    const callerFrame = stack[2];
+    const callerFrame = stack[3];
     if (!callerFrame || typeof callerFrame.getFileName !== "function") {
       throw new Error("Unable to determine caller file frame");
     }
@@ -869,9 +995,11 @@ function getCallerFilePath() {
   }
 }
 function getRoutePath() {
+  console.log("getRoutePath called");
   const callerPath = getCallerFilePath();
   const routesDir = getRoutesDir();
   const parsedRoute = parseRoutePath(callerPath, routesDir);
+  console.log(`Parsed route path: ${parsedRoute.routePath} from file: ${callerPath}`);
   return parsedRoute.routePath;
 }
 var createGetRoute = (config2) => {
@@ -1560,12 +1688,12 @@ async function stopServer(serverInstance, options = {}) {
     return;
   }
   const timeout = options.timeout || 3e4;
-  const plugins = serverInstance.plugins;
   try {
     if (options.onStopping) {
       await options.onStopping();
     }
     events.emit("stopping");
+    await serverInstance.pluginManager.onServerStop(serverInstance, server);
     const timeoutPromise = new Promise((_, reject) => {
       setTimeout(() => {
         reject(new Error("Server shutdown timed out waiting for requests to complete"));
@@ -1580,13 +1708,7 @@ async function stopServer(serverInstance, options = {}) {
       });
     });
     await Promise.race([closePromise, timeoutPromise]);
-    if (plugins?.length) {
-      for (const plugin of [...plugins].reverse()) {
-        if (plugin.terminate) {
-          await plugin.terminate();
-        }
-      }
-    }
+    await serverInstance.pluginManager.terminatePlugins(serverInstance);
     if (options.onStopped) {
       await options.onStopped();
     }
@@ -1661,6 +1783,158 @@ function validateServerOptions(options) {
   }
 }
 
+// src/plugins/lifecycle.ts
+function createPluginLifecycleManager(options = {}) {
+  const { continueOnError = true, debug = false, onError } = options;
+  function log(message, ...args) {
+    if (debug) {
+      console.log(`[PluginLifecycle] ${message}`, ...args);
+    }
+  }
+  function handleError(plugin, phase, error) {
+    const errorMessage = `Plugin ${plugin.name} failed during ${phase}: ${error.message}`;
+    if (onError) {
+      onError(plugin, phase, error);
+    } else {
+      console.error(errorMessage, error);
+    }
+    if (!continueOnError) {
+      throw new Error(errorMessage);
+    }
+  }
+  return {
+    /**
+     * Initialize all plugins
+     */
+    async initializePlugins(server) {
+      log("Initializing plugins...");
+      for (const plugin of server.plugins) {
+        if (plugin.initialize) {
+          try {
+            log(`Initializing plugin: ${plugin.name}`);
+            await plugin.initialize(server);
+          } catch (error) {
+            handleError(plugin, "initialize", error);
+          }
+        }
+      }
+      log(`Initialized ${server.plugins.length} plugins`);
+    },
+    /**
+     * Terminate all plugins in reverse order
+     */
+    async terminatePlugins(server) {
+      log("Terminating plugins...");
+      const pluginsToTerminate = [...server.plugins].reverse();
+      for (const plugin of pluginsToTerminate) {
+        if (plugin.terminate) {
+          try {
+            log(`Terminating plugin: ${plugin.name}`);
+            await plugin.terminate(server);
+          } catch (error) {
+            handleError(plugin, "terminate", error);
+          }
+        }
+      }
+      log(`Terminated ${pluginsToTerminate.length} plugins`);
+    },
+    /**
+     * Notify plugins that the server has started
+     */
+    async onServerStart(server, httpServer) {
+      log("Notifying plugins of server start...");
+      for (const plugin of server.plugins) {
+        if (plugin.onServerStart) {
+          try {
+            log(`Notifying plugin of server start: ${plugin.name}`);
+            await plugin.onServerStart(httpServer);
+          } catch (error) {
+            handleError(plugin, "onServerStart", error);
+          }
+        }
+      }
+    },
+    /**
+     * Notify plugins that the server is stopping
+     */
+    async onServerStop(server, httpServer) {
+      log("Notifying plugins of server stop...");
+      const pluginsToNotify = [...server.plugins].reverse();
+      for (const plugin of pluginsToNotify) {
+        if (plugin.onServerStop) {
+          try {
+            log(`Notifying plugin of server stop: ${plugin.name}`);
+            await plugin.onServerStop(httpServer);
+          } catch (error) {
+            handleError(plugin, "onServerStop", error);
+          }
+        }
+      }
+    }
+  };
+}
+
+// src/plugins/errors.ts
+var PluginValidationError = class extends Error {
+  constructor(pluginName, message) {
+    super(`Plugin validation error${pluginName ? ` for "${pluginName}"` : ""}: ${message}`);
+    this.pluginName = pluginName;
+    this.name = "PluginValidationError";
+  }
+};
+
+// src/plugins/validation.ts
+var RESERVED_NAMES = /* @__PURE__ */ new Set([
+  "core",
+  "server",
+  "router",
+  "middleware",
+  "context",
+  "blaize",
+  "blaizejs"
+]);
+var VALID_NAME_PATTERN = /^[a-z]([a-z0-9-]*[a-z0-9])?$/;
+var VALID_VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[a-zA-Z0-9-.]+)?(?:\+[a-zA-Z0-9-.]+)?$/;
+function validatePlugin(plugin, options = {}) {
+  const { requireVersion = true, validateNameFormat = true, checkReservedNames = true } = options;
+  if (!plugin || typeof plugin !== "object") {
+    throw new PluginValidationError("", "Plugin must be an object");
+  }
+  const p = plugin;
+  if (!p.name || typeof p.name !== "string") {
+    throw new PluginValidationError("", "Plugin must have a name (string)");
+  }
+  if (validateNameFormat && !VALID_NAME_PATTERN.test(p.name)) {
+    throw new PluginValidationError(
+      p.name,
+      "Plugin name must be lowercase letters, numbers, and hyphens only"
+    );
+  }
+  if (checkReservedNames && RESERVED_NAMES.has(p.name.toLowerCase())) {
+    throw new PluginValidationError(p.name, `Plugin name "${p.name}" is reserved`);
+  }
+  if (requireVersion) {
+    if (!p.version || typeof p.version !== "string") {
+      throw new PluginValidationError(p.name, "Plugin must have a version (string)");
+    }
+    if (!VALID_VERSION_PATTERN.test(p.version)) {
+      throw new PluginValidationError(
+        p.name,
+        'Plugin version must follow semantic versioning (e.g., "1.0.0")'
+      );
+    }
+  }
+  if (!p.register || typeof p.register !== "function") {
+    throw new PluginValidationError(p.name, "Plugin must have a register method (function)");
+  }
+  const lifecycleMethods = ["initialize", "terminate", "onServerStart", "onServerStop"];
+  for (const method of lifecycleMethods) {
+    if (p[method] && typeof p[method] !== "function") {
+      throw new PluginValidationError(p.name, `Plugin ${method} must be a function if provided`);
+    }
+  }
+}
+
 // src/server/create.ts
 var DEFAULT_OPTIONS = {
   port: 3e3,
@@ -1691,7 +1965,9 @@ function createServerOptions(options = {}) {
 function createListenMethod(serverInstance, validatedOptions, initialMiddleware, initialPlugins) {
   return async () => {
     await initializeComponents(serverInstance, initialMiddleware, initialPlugins);
+    await serverInstance.pluginManager.initializePlugins(serverInstance);
     await startServer(serverInstance, validatedOptions);
+    await serverInstance.pluginManager.onServerStart(serverInstance, serverInstance.server);
     setupServerLifecycle(serverInstance);
     return serverInstance;
   };
@@ -1737,13 +2013,6 @@ function createRegisterMethod(serverInstance) {
     return serverInstance;
   };
 }
-function validatePlugin(plugin) {
-  if (!plugin || typeof plugin !== "object" || !("register" in plugin) || typeof plugin.register !== "function") {
-    throw new Error(
-      "Invalid plugin. Must be a valid BlaizeJS plugin object with a register method."
-    );
-  }
-}
 function create3(options = {}) {
   const mergedOptions = createServerOptions(options);
   let validatedOptions;
@@ -1763,6 +2032,10 @@ function create3(options = {}) {
     routesDir: validatedOptions.routesDir,
     watchMode: process.env.NODE_ENV === "development"
   });
+  const pluginManager = createPluginLifecycleManager({
+    debug: process.env.NODE_ENV === "development",
+    continueOnError: true
+  });
   const events = new import_node_events.default();
   const serverInstance = {
     server: null,
@@ -1779,7 +2052,8 @@ function create3(options = {}) {
     listen: async () => serverInstance,
     close: async () => {
     },
-    router
+    router,
+    pluginManager
   };
   serverInstance.listen = createListenMethod(
     serverInstance,