@draftlab/auth 0.10.4 → 0.12.0

package/dist/plugin/manager.mjs

@@ -1,160 +0,0 @@
-import { PluginError } from "./types.mjs";
-
-//#region src/plugin/manager.ts
-var PluginManager = class {
-	plugins = /* @__PURE__ */ new Map();
-	storage;
-	constructor(storage) {
-		this.storage = storage;
-	}
-	/**
-	* Register a plugin
-	*/
-	register(plugin) {
-		if (this.plugins.has(plugin.id)) throw new PluginError(`Plugin already registered`, plugin.id);
-		this.plugins.set(plugin.id, plugin);
-	}
-	/**
-	* Register multiple plugins at once
-	*/
-	registerAll(plugins) {
-		for (const plugin of plugins) this.register(plugin);
-	}
-	/**
-	* Get all registered plugins
-	*/
-	getAll() {
-		return Array.from(this.plugins.values());
-	}
-	/**
-	* Get plugin by id
-	*/
-	get(id) {
-		return this.plugins.get(id);
-	}
-	/**
-	* Initialize all plugins.
-	* Called once during issuer setup.
-	* Plugins can set up initial state or validate configuration.
-	*
-	* @throws PluginError if any plugin initialization fails
-	*/
-	async initialize() {
-		for (const plugin of this.plugins.values()) {
-			if (!plugin.onInit) continue;
-			try {
-				const context = {
-					pluginId: plugin.id,
-					request: new Request("http://internal/init"),
-					now: /* @__PURE__ */ new Date(),
-					storage: this.storage
-				};
-				await plugin.onInit(context);
-			} catch (error) {
-				throw new PluginError(`Initialization failed: ${error instanceof Error ? error.message : String(error)}`, plugin.id);
-			}
-		}
-	}
-	/**
-	* Execute authorize hooks for all plugins.
-	* Called before processing an authorization request.
-	* Can validate, rate limit, or enhance the request.
-	*/
-	async executeAuthorizeHooks(clientID, provider, scopes) {
-		for (const plugin of this.plugins.values()) {
-			if (!plugin.onAuthorize) continue;
-			try {
-				const context = {
-					pluginId: plugin.id,
-					request: new Request("http://internal/authorize"),
-					now: /* @__PURE__ */ new Date(),
-					storage: this.storage,
-					clientID,
-					provider,
-					scopes
-				};
-				await plugin.onAuthorize(context);
-			} catch (error) {
-				throw new PluginError(`Authorization hook failed: ${error instanceof Error ? error.message : String(error)}`, plugin.id);
-			}
-		}
-	}
-	/**
-	* Execute success hooks for all plugins.
-	* Called after successful authentication.
-	* Runs in parallel for better performance.
-	* Plugins cannot modify the response.
-	*/
-	async executeSuccessHooks(clientID, provider, subject) {
-		const hooks = Array.from(this.plugins.values()).filter((p) => p.onSuccess).map(async (plugin) => {
-			const context = {
-				pluginId: plugin.id,
-				request: new Request("http://internal/success"),
-				now: /* @__PURE__ */ new Date(),
-				storage: this.storage,
-				clientID,
-				provider,
-				subject
-			};
-			return plugin.onSuccess?.(context).catch((error) => {
-				console.error(`[Plugin: ${plugin.id}] Success hook failed:`, error instanceof Error ? error.message : String(error));
-			});
-		});
-		await Promise.all(hooks);
-	}
-	/**
-	* Execute error hooks for all plugins.
-	* Called when an authentication error occurs.
-	*/
-	async executeErrorHooks(error, clientID, provider) {
-		for (const plugin of this.plugins.values()) {
-			if (!plugin.onError) continue;
-			try {
-				const context = {
-					pluginId: plugin.id,
-					request: new Request("http://internal/error"),
-					now: /* @__PURE__ */ new Date(),
-					storage: this.storage,
-					error,
-					clientID,
-					provider
-				};
-				await plugin.onError(context);
-			} catch (hookError) {
-				console.error(`[Plugin: ${plugin.id}] Error hook failed:`, hookError instanceof Error ? hookError.message : String(hookError));
-			}
-		}
-	}
-	/**
-	* Setup plugin routes on a router
-	*/
-	setupRoutes(router) {
-		const registeredPaths = /* @__PURE__ */ new Set();
-		for (const plugin of this.plugins.values()) {
-			if (!plugin.routes) continue;
-			for (const route of plugin.routes) {
-				const fullPath = `/plugin/${plugin.id}${route.path}`;
-				if (registeredPaths.has(fullPath)) throw new PluginError(`Route conflict: ${fullPath} already registered`, plugin.id);
-				registeredPaths.add(fullPath);
-				const handler = async (ctx) => {
-					const pluginCtx = {
-						...ctx,
-						storage: this.storage
-					};
-					return await route.handler(pluginCtx);
-				};
-				switch (route.method) {
-					case "GET":
-						router.get(fullPath, handler);
-						break;
-					case "POST":
-						router.post(fullPath, handler);
-						break;
-				}
-			}
-		}
-	}
-};
-
-//#endregion
-export { PluginManager };

package/dist/plugin/plugin.d.mts

@@ -1,42 +0,0 @@
-import { Plugin, PluginAuthorizeHook, PluginErrorHook, PluginInitHook, PluginRouteHandler, PluginSuccessHook } from "./types.mjs";
-
-//#region src/plugin/plugin.d.ts
-
-/**
- * Plugin builder interface for creating plugins with a fluent API.
- *
- * The builder pattern allows for elegant plugin definition:
- * - Chain route definitions with lifecycle hooks
- * - Each method returns this for chaining
- * - Build finalizes the plugin definition
- *
- * @example
- * ```ts
- * const myPlugin = plugin("my-plugin")
- *   .onInit(async (ctx) => {
- *     console.log("Plugin initialized")
- *   })
- *   .post("/action", async (ctx) => {
- *     return ctx.json({ success: true })
- *   })
- *   .build()
- * ```
- */
-interface PluginBuilder {
-  /** Register a GET route */
-  get(path: string, handler: PluginRouteHandler): PluginBuilder;
-  /** Register a POST route */
-  post(path: string, handler: PluginRouteHandler): PluginBuilder;
-  /** Register initialization hook (called once during issuer setup) */
-  onInit(handler: PluginInitHook): PluginBuilder;
-  /** Register authorization hook (called before authorization request) */
-  onAuthorize(handler: PluginAuthorizeHook): PluginBuilder;
-  /** Register success hook (called after successful authentication) */
-  onSuccess(handler: PluginSuccessHook): PluginBuilder;
-  /** Register error hook (called when authentication fails) */
-  onError(handler: PluginErrorHook): PluginBuilder;
-  /** Build the final plugin */
-  build(): Plugin;
-}
-//#endregion
-export { PluginBuilder };

package/dist/plugin/types.d.mts

@@ -1,99 +0,0 @@
-import { StorageAdapter } from "../storage/storage.mjs";
-import { RouterContext } from "@draftlab/auth-router/types";
-
-//#region src/plugin/types.d.ts
-
-interface PluginContext extends RouterContext {
-  storage: StorageAdapter;
-}
-/**
- * Plugin route handler function
- */
-type PluginRouteHandler = (context: PluginContext) => Promise<Response>;
-/**
- * Plugin route definition
- */
-interface PluginRoute {
-  /** Route path (e.g., "/admin", "/stats") */
-  readonly path: string;
-  /** HTTP method */
-  readonly method: "GET" | "POST";
-  /** Route handler function */
-  readonly handler: PluginRouteHandler;
-}
-/**
- * Lifecycle hook context provided to plugin hooks.
- * Contains information about the current operation and access to isolated storage.
- */
-interface PluginHookContext {
-  /** Unique identifier for the plugin */
-  pluginId: string;
-  /** Raw request object */
-  request: Request;
-  /** Current time for consistency across hook execution */
-  now: Date;
-  /** Storage adapter for data persistence */
-  storage: StorageAdapter;
-}
-/**
- * Hook called when the issuer is being initialized.
- * Useful for plugins that need to set up initial state or validate configuration.
- * Should complete quickly - takes place during server startup.
- */
-type PluginInitHook = (context: PluginHookContext) => Promise<void>;
-/**
- * Hook called before an authorization request is processed.
- * Use for validation, rate limiting, or request enhancement.
- */
-type PluginAuthorizeHook = (context: PluginHookContext & {
-  clientID: string;
-  provider?: string;
-  scopes?: string[];
-}) => Promise<void>;
-/**
- * Hook called after successful authentication.
- * Use for logging, analytics, webhooks, or side effects.
- * Cannot modify the response - hooks run in parallel.
- */
-type PluginSuccessHook = (context: PluginHookContext & {
-  clientID: string;
-  provider?: string;
-  subject: {
-    type: string;
-    properties: Record<string, unknown>;
-  };
-}) => Promise<void>;
-/**
- * Hook called when an authentication error occurs.
- * Use for error logging, custom error pages, or error transformation.
- */
-type PluginErrorHook = (context: PluginHookContext & {
-  error: Error;
-  clientID?: string;
-  provider?: string;
-}) => Promise<void>;
-/**
- * Main plugin interface with lifecycle hooks and storage isolation
- */
-interface Plugin {
-  /** Unique plugin identifier */
-  readonly id: string;
-  /** Custom routes added by this plugin */
-  readonly routes?: readonly PluginRoute[];
-  /** Called once when the issuer initializes */
-  readonly onInit?: PluginInitHook;
-  /** Called before authorization request is processed */
-  readonly onAuthorize?: PluginAuthorizeHook;
-  /** Called after successful authentication */
-  readonly onSuccess?: PluginSuccessHook;
-  /** Called when an error occurs during authentication */
-  readonly onError?: PluginErrorHook;
-}
-/**
- * Plugin error types
- */
-declare class PluginError extends Error {
-  constructor(message: string, pluginId: string);
-}
-//#endregion
-export { Plugin, PluginAuthorizeHook, PluginContext, PluginError, PluginErrorHook, PluginHookContext, PluginInitHook, PluginRoute, PluginRouteHandler, PluginSuccessHook };

package/dist/plugin/types.mjs

@@ -1,13 +0,0 @@
-//#region src/plugin/types.ts
-/**
-* Plugin error types
-*/
-var PluginError = class extends Error {
-	constructor(message, pluginId) {
-		super(`[Plugin: ${pluginId}] ${message}`);
-		this.name = "PluginError";
-	}
-};
-
-//#endregion
-export { PluginError };