@ahmedbaset/adminjs-hono 0.1.0

package/lib/authentication/refresh.handler.js

@@ -0,0 +1,42 @@
+/**
+ * Registers token refresh route with the Hono app
+ * Delegates to authentication provider's refresh method if available
+ *
+ * @param app - Hono app instance
+ * @param admin - AdminJS instance
+ * @param auth - Authentication options
+ */
+export function withRefresh(app, admin, auth) {
+    const { provider } = auth;
+    // Only register refresh route if provider supports it
+    if (!provider || !provider.handleRefresh) {
+        return;
+    }
+    // Typically refresh is at /refresh, but this depends on the provider
+    const refreshPath = '/refresh';
+    app.post(refreshPath, async (c) => {
+        try {
+            const fields = c.get('fields') || {};
+            const session = c.get('session');
+            // Call provider's refresh method
+            const refreshedUser = await provider.handleRefresh({
+                headers: Object.fromEntries(c.req.raw.headers.entries()),
+                query: c.req.query(),
+                params: c.req.param(),
+                data: fields,
+            }, { req: c, res: c });
+            if (refreshedUser) {
+                // Update session with new credentials
+                session.adminUser = refreshedUser;
+                return c.json({ success: true });
+            }
+            else {
+                return c.json({ success: false, error: 'Refresh failed' }, 401);
+            }
+        }
+        catch (error) {
+            console.error('Token refresh error:', error);
+            return c.json({ success: false, error: error.message || 'Refresh failed' }, 401);
+        }
+    });
+}

package/lib/buildAuthenticatedRouter.d.ts

@@ -0,0 +1,15 @@
+import AdminJS from 'adminjs';
+import type { Hono } from 'hono';
+import type { AuthenticationOptions, SessionOptions, UploadOptions } from './types.js';
+/**
+ * Builds a Hono app with AdminJS routes protected by session-based authentication
+ *
+ * @param admin - The AdminJS instance
+ * @param auth - Authentication configuration
+ * @param predefinedApp - Optional existing Hono app to use
+ * @param sessionOptions - Optional session configuration
+ * @param uploadOptions - Optional upload configuration
+ * @returns Configured Hono app with authentication
+ */
+export declare function buildAuthenticatedRouter(admin: AdminJS, auth: AuthenticationOptions, predefinedApp?: Hono, sessionOptions?: SessionOptions, uploadOptions?: UploadOptions): Hono;
+//# sourceMappingURL=buildAuthenticatedRouter.d.ts.map

package/lib/buildAuthenticatedRouter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildAuthenticatedRouter.d.ts","sourceRoot":"","sources":["../src/buildAuthenticatedRouter.ts"],"names":[],"mappings":"AAAA,OAAO,OAAkC,MAAM,SAAS,CAAA;AACxD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AAWhC,OAAO,KAAK,EAAE,qBAAqB,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAItF;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,qBAAqB,EAC3B,aAAa,CAAC,EAAE,IAAI,EACpB,cAAc,CAAC,EAAE,cAAc,EAC/B,aAAa,CAAC,EAAE,aAAa,GAC5B,IAAI,CA2DN"}

package/lib/buildAuthenticatedRouter.js

@@ -0,0 +1,61 @@
+import { Router as AdminRouter } from 'adminjs';
+import { withLogin } from './authentication/login.handler.js';
+import { withLogout } from './authentication/logout.handler.js';
+import { withProtectedRoutesHandler } from './authentication/protected-routes.handler.js';
+import { withRefresh } from './authentication/refresh.handler.js';
+import { buildAssets, buildRoutes, initializeAdmin } from './buildRouter.js';
+import { INVALID_AUTH_CONFIG_ERROR, MISSING_AUTH_CONFIG_ERROR, WrongArgumentError, } from './errors.js';
+import { createFormParserMiddleware } from './formParser.js';
+import { createSessionMiddleware } from './session.js';
+/**
+ * Builds a Hono app with AdminJS routes protected by session-based authentication
+ *
+ * @param admin - The AdminJS instance
+ * @param auth - Authentication configuration
+ * @param predefinedApp - Optional existing Hono app to use
+ * @param sessionOptions - Optional session configuration
+ * @param uploadOptions - Optional upload configuration
+ * @returns Configured Hono app with authentication
+ */
+export function buildAuthenticatedRouter(admin, auth, predefinedApp, sessionOptions, uploadOptions) {
+    // Initialize AdminJS
+    initializeAdmin(admin);
+    // Validate authentication configuration
+    if (!auth.authenticate && !auth.provider) {
+        throw new WrongArgumentError(MISSING_AUTH_CONFIG_ERROR);
+    }
+    if (auth.authenticate && auth.provider) {
+        throw new WrongArgumentError(INVALID_AUTH_CONFIG_ERROR);
+    }
+    // Use provided app or create new Hono instance
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { Hono: HonoClass } = require('hono');
+    const app = predefinedApp ?? new HonoClass();
+    // Get routes and assets from AdminJS
+    const { routes, assets } = AdminRouter;
+    // If provider is configured, add its UI props to AdminJS env
+    if (auth.provider) {
+        admin.options.env = {
+            ...admin.options.env,
+            ...auth.provider.getUiProps(),
+        };
+    }
+    // Configure session middleware
+    const cookieName = auth.cookieName || 'adminjs';
+    app.use('*', createSessionMiddleware(auth.cookiePassword, cookieName, sessionOptions));
+    // Register form parsing middleware
+    app.use('*', createFormParserMiddleware(uploadOptions));
+    // Register login handler (must be before protected routes middleware)
+    withLogin(app, admin, auth);
+    // Register logout handler (must be before protected routes middleware)
+    withLogout(app, admin, auth);
+    // Build assets (must be before protected routes middleware)
+    buildAssets(assets, routes, app, admin);
+    // Register protected routes middleware (applies to all subsequent routes)
+    withProtectedRoutesHandler(app, admin);
+    // Register refresh handler (after protected routes middleware)
+    withRefresh(app, admin, auth);
+    // Build routes (after protected routes middleware)
+    buildRoutes(routes, app, admin);
+    return app;
+}

package/lib/buildRouter.d.ts

@@ -0,0 +1,53 @@
+import AdminJS, { Router as AdminRouter } from 'adminjs';
+import type { Hono, Handler } from 'hono';
+import type { HonoVariables } from './types.js';
+/**
+ * Validates and initializes an AdminJS instance
+ * @param admin - The AdminJS instance to initialize
+ * @throws {WrongArgumentError} If the admin parameter is not a valid AdminJS instance
+ */
+export declare function initializeAdmin(admin: AdminJS): void;
+/**
+ * Creates a Hono route handler from an AdminJS route
+ * Extracts request data and invokes the AdminJS controller
+ *
+ * @param admin - The AdminJS instance
+ * @param route - The AdminJS route definition
+ * @returns Hono handler function
+ */
+export declare function routeHandler(admin: AdminJS, route: (typeof AdminRouter)['routes'][0]): Handler<{
+    Variables: HonoVariables;
+}>;
+/**
+ * Registers a single AdminJS route with the Hono app
+ * @param route - The AdminJS route to register
+ * @param app - The Hono app instance
+ * @param admin - The AdminJS instance
+ */
+export declare function buildRoute(route: (typeof AdminRouter)['routes'][number], app: Hono, admin: AdminJS): void;
+/**
+ * Registers all AdminJS routes with the Hono app
+ * @param routes - Array of AdminJS routes
+ * @param app - The Hono app instance
+ * @param admin - The AdminJS instance
+ */
+export declare function buildRoutes(routes: (typeof AdminRouter)['routes'], app: Hono, admin: AdminJS): void;
+/**
+ * Registers AdminJS asset routes with the Hono app
+ * @param assets - Array of AdminJS assets
+ * @param routes - Array of AdminJS routes (to find component bundler route)
+ * @param app - The Hono app instance
+ * @param admin - The AdminJS instance
+ */
+export declare function buildAssets(assets: (typeof AdminRouter)['assets'], routes: (typeof AdminRouter)['routes'], app: Hono, admin: AdminJS): void;
+import type { UploadOptions } from './types.js';
+/**
+ * Builds a Hono app with AdminJS routes (without authentication)
+ *
+ * @param admin - The AdminJS instance
+ * @param predefinedApp - Optional existing Hono app to use
+ * @param uploadOptions - Optional upload configuration
+ * @returns Configured Hono app
+ */
+export declare function buildRouter(admin: AdminJS, predefinedApp?: Hono, uploadOptions?: UploadOptions): Hono;
+//# sourceMappingURL=buildRouter.d.ts.map

package/lib/buildRouter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildRouter.d.ts","sourceRoot":"","sources":["../src/buildRouter.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,EAAE,EAAE,MAAM,IAAI,WAAW,EAAE,MAAM,SAAS,CAAA;AACxD,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAW,MAAM,MAAM,CAAA;AAIlD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE/C;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAQpD;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,CAAC,OAAO,WAAW,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,GACvC,OAAO,CAAC;IAAE,SAAS,EAAE,aAAa,CAAA;CAAE,CAAC,CA+CvC;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,CAAC,OAAO,WAAW,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,EAC7C,GAAG,EAAE,IAAI,EACT,KAAK,EAAE,OAAO,GACb,IAAI,CAUN;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,CAAC,OAAO,WAAW,CAAC,CAAC,QAAQ,CAAC,EACtC,GAAG,EAAE,IAAI,EACT,KAAK,EAAE,OAAO,GACb,IAAI,CAEN;AA0BD;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,CAAC,OAAO,WAAW,CAAC,CAAC,QAAQ,CAAC,EACtC,MAAM,EAAE,CAAC,OAAO,WAAW,CAAC,CAAC,QAAQ,CAAC,EACtC,GAAG,EAAE,IAAI,EACT,KAAK,EAAE,OAAO,GACb,IAAI,CAgCN;AAED,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAG/C;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,OAAO,EACd,aAAa,CAAC,EAAE,IAAI,EACpB,aAAa,CAAC,EAAE,aAAa,GAC5B,IAAI,CAoBN"}

package/lib/buildRouter.js

@@ -0,0 +1,178 @@
+import { Router as AdminRouter } from 'adminjs';
+import { WrongArgumentError, INVALID_ADMINJS_INSTANCE } from './errors.js';
+import { log } from './logger.js';
+import { convertToHonoRoute } from './convertRoutes.js';
+/**
+ * Validates and initializes an AdminJS instance
+ * @param admin - The AdminJS instance to initialize
+ * @throws {WrongArgumentError} If the admin parameter is not a valid AdminJS instance
+ */
+export function initializeAdmin(admin) {
+    if (admin?.constructor?.name !== 'AdminJS') {
+        throw new WrongArgumentError(INVALID_ADMINJS_INSTANCE);
+    }
+    admin.initialize().then(() => {
+        log.debug('AdminJS: bundle ready');
+    });
+}
+/**
+ * Creates a Hono route handler from an AdminJS route
+ * Extracts request data and invokes the AdminJS controller
+ *
+ * @param admin - The AdminJS instance
+ * @param route - The AdminJS route definition
+ * @returns Hono handler function
+ */
+export function routeHandler(admin, route) {
+    return async (c) => {
+        // Get session from context (may be undefined for non-authenticated routes)
+        const session = c.get('session');
+        const adminUser = session?.adminUser;
+        // Instantiate the AdminJS controller
+        const controller = new route.Controller({ admin }, adminUser);
+        // Extract request data
+        const params = c.req.param();
+        const query = c.req.query();
+        const method = c.req.method.toLowerCase();
+        // Get parsed form data from context (set by form parser middleware)
+        const fields = c.get('fields') || {};
+        const files = c.get('files') || {};
+        const payload = {
+            ...fields,
+            ...files,
+        };
+        // Execute the controller action
+        const html = await controller[route.action]({
+            ...c.req,
+            params,
+            query,
+            payload,
+            method,
+        }, c.res);
+        // Set Content-Type header if specified
+        if (route.contentType) {
+            c.header('Content-Type', route.contentType);
+        }
+        // Return response
+        if (html) {
+            return c.body(html);
+        }
+        // If no response body, return empty response
+        return c.body(null);
+    };
+}
+/**
+ * Registers a single AdminJS route with the Hono app
+ * @param route - The AdminJS route to register
+ * @param app - The Hono app instance
+ * @param admin - The AdminJS instance
+ */
+export function buildRoute(route, app, admin) {
+    // Convert AdminJS route path to Hono format
+    const honoPath = convertToHonoRoute(route.path);
+    // Register handler based on HTTP method
+    if (route.method === 'GET') {
+        app.get(honoPath, routeHandler(admin, route));
+    }
+    else if (route.method === 'POST') {
+        app.post(honoPath, routeHandler(admin, route));
+    }
+}
+/**
+ * Registers all AdminJS routes with the Hono app
+ * @param routes - Array of AdminJS routes
+ * @param app - The Hono app instance
+ * @param admin - The AdminJS instance
+ */
+export function buildRoutes(routes, app, admin) {
+    routes.forEach((route) => buildRoute(route, app, admin));
+}
+/**
+ * Determines Content-Type header based on file extension
+ * @param path - File path
+ * @returns Content-Type string
+ */
+function getContentType(path) {
+    if (path.endsWith('.js')) {
+        return 'application/javascript';
+    }
+    else if (path.endsWith('.css')) {
+        return 'text/css';
+    }
+    else if (path.endsWith('.html')) {
+        return 'text/html';
+    }
+    else if (path.endsWith('.json')) {
+        return 'application/json';
+    }
+    else if (path.endsWith('.png')) {
+        return 'image/png';
+    }
+    else if (path.endsWith('.jpg') || path.endsWith('.jpeg')) {
+        return 'image/jpeg';
+    }
+    else if (path.endsWith('.svg')) {
+        return 'image/svg+xml';
+    }
+    return 'application/octet-stream';
+}
+/**
+ * Registers AdminJS asset routes with the Hono app
+ * @param assets - Array of AdminJS assets
+ * @param routes - Array of AdminJS routes (to find component bundler route)
+ * @param app - The Hono app instance
+ * @param admin - The AdminJS instance
+ */
+export function buildAssets(assets, routes, app, admin) {
+    // Register component bundler route if it exists
+    const componentBundlerRoute = routes.find((r) => r.action === 'bundleComponents');
+    if (componentBundlerRoute) {
+        buildRoute(componentBundlerRoute, app, admin);
+    }
+    // Register static asset routes
+    assets.forEach((asset) => {
+        app.get(asset.path, async (c) => {
+            try {
+                // Read file using Node.js fs (for Node runtime)
+                // For other runtimes, this would need runtime detection
+                const fs = await import('fs/promises');
+                const path = await import('path');
+                const filePath = path.resolve(asset.src);
+                const fileContent = await fs.readFile(filePath);
+                // Set appropriate Content-Type header
+                const contentType = getContentType(asset.path);
+                c.header('Content-Type', contentType);
+                return c.body(fileContent);
+            }
+            catch (error) {
+                console.error(`Error serving asset ${asset.path}:`, error);
+                return c.text('Asset not found', 404);
+            }
+        });
+    });
+}
+import { createFormParserMiddleware } from './formParser.js';
+/**
+ * Builds a Hono app with AdminJS routes (without authentication)
+ *
+ * @param admin - The AdminJS instance
+ * @param predefinedApp - Optional existing Hono app to use
+ * @param uploadOptions - Optional upload configuration
+ * @returns Configured Hono app
+ */
+export function buildRouter(admin, predefinedApp, uploadOptions) {
+    // Initialize AdminJS
+    initializeAdmin(admin);
+    // Use provided app or create new Hono instance
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { Hono: HonoClass } = require('hono');
+    const app = predefinedApp ?? new HonoClass();
+    // Get routes and assets from AdminJS
+    const { routes, assets } = AdminRouter;
+    // Register form parsing middleware
+    app.use('*', createFormParserMiddleware(uploadOptions));
+    // Build assets and routes
+    buildAssets(assets, routes, app, admin);
+    buildRoutes(routes, app, admin);
+    return app;
+}

package/lib/convertRoutes.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Converts AdminJS route path format to Hono route path format
+ * AdminJS uses {param} notation while Hono uses :param notation
+ *
+ * @param path - AdminJS route path (e.g., "/resources/{resourceId}/actions/{action}")
+ * @returns Hono route path (e.g., "/resources/:resourceId/actions/:action")
+ */
+export declare function convertToHonoRoute(path: string): string;
+//# sourceMappingURL=convertRoutes.d.ts.map

package/lib/convertRoutes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertRoutes.d.ts","sourceRoot":"","sources":["../src/convertRoutes.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvD"}

package/lib/convertRoutes.js

@@ -0,0 +1,10 @@
+/**
+ * Converts AdminJS route path format to Hono route path format
+ * AdminJS uses {param} notation while Hono uses :param notation
+ *
+ * @param path - AdminJS route path (e.g., "/resources/{resourceId}/actions/{action}")
+ * @returns Hono route path (e.g., "/resources/:resourceId/actions/:action")
+ */
+export function convertToHonoRoute(path) {
+    return path.replace(/\{([^}]+)\}/g, ':$1');
+}

package/lib/errors.d.ts

@@ -0,0 +1,10 @@
+export declare class WrongArgumentError extends Error {
+    constructor(message: string);
+}
+export declare const INVALID_ADMINJS_INSTANCE = "You have to pass an instance of AdminJS to the buildRouter() function";
+export declare const MISSING_AUTH_CONFIG_ERROR = "You must provide either \"authenticate\" function or \"provider\" in authentication options";
+export declare const INVALID_AUTH_CONFIG_ERROR = "You cannot provide both \"authenticate\" function and \"provider\" in authentication options";
+export declare class OldBodyParserUsedError extends Error {
+    constructor();
+}
+//# sourceMappingURL=errors.d.ts.map

package/lib/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,kBAAmB,SAAQ,KAAK;gBAC/B,OAAO,EAAE,MAAM;CAI5B;AAED,eAAO,MAAM,wBAAwB,0EACoC,CAAA;AAEzE,eAAO,MAAM,yBAAyB,gGACqD,CAAA;AAE3F,eAAO,MAAM,yBAAyB,iGACsD,CAAA;AAE5F,qBAAa,sBAAuB,SAAQ,KAAK;;CAOhD"}

package/lib/errors.js

@@ -0,0 +1,15 @@
+export class WrongArgumentError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'WrongArgumentError';
+    }
+}
+export const INVALID_ADMINJS_INSTANCE = 'You have to pass an instance of AdminJS to the buildRouter() function';
+export const MISSING_AUTH_CONFIG_ERROR = 'You must provide either "authenticate" function or "provider" in authentication options';
+export const INVALID_AUTH_CONFIG_ERROR = 'You cannot provide both "authenticate" function and "provider" in authentication options';
+export class OldBodyParserUsedError extends Error {
+    constructor() {
+        super('You are using old body-parser middleware which is not compatible with AdminJS. Please remove it.');
+        this.name = 'OldBodyParserUsedError';
+    }
+}

package/lib/formParser.d.ts

@@ -0,0 +1,13 @@
+import type { MiddlewareHandler } from 'hono';
+import type { UploadOptions, HonoVariables } from './types.js';
+/**
+ * Creates middleware to parse form data (multipart/form-data and application/x-www-form-urlencoded)
+ * Extracts fields and files from the request and stores them in context variables
+ *
+ * @param options - Upload configuration options
+ * @returns Hono middleware handler
+ */
+export declare function createFormParserMiddleware(options?: UploadOptions): MiddlewareHandler<{
+    Variables: HonoVariables;
+}>;
+//# sourceMappingURL=formParser.d.ts.map

package/lib/formParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formParser.d.ts","sourceRoot":"","sources":["../src/formParser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAW,MAAM,MAAM,CAAA;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE9D;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,CAAC,EAAE,aAAa,GACtB,iBAAiB,CAAC;IAAE,SAAS,EAAE,aAAa,CAAA;CAAE,CAAC,CA4DjD"}

package/lib/formParser.js

@@ -0,0 +1,53 @@
+/**
+ * Creates middleware to parse form data (multipart/form-data and application/x-www-form-urlencoded)
+ * Extracts fields and files from the request and stores them in context variables
+ *
+ * @param options - Upload configuration options
+ * @returns Hono middleware handler
+ */
+export function createFormParserMiddleware(options) {
+    return async (c, next) => {
+        const contentType = c.req.header('content-type');
+        if (contentType?.includes('multipart/form-data') ||
+            contentType?.includes('application/x-www-form-urlencoded')) {
+            try {
+                const formData = await c.req.formData();
+                const fields = {};
+                const files = {};
+                for (const [key, value] of formData.entries()) {
+                    if (value instanceof File) {
+                        // Check file size if maxFileSize is specified
+                        if (options?.maxFileSize && value.size > options.maxFileSize) {
+                            throw new Error(`File ${value.name} exceeds maximum size of ${options.maxFileSize} bytes`);
+                        }
+                        files[key] = value;
+                    }
+                    else {
+                        fields[key] = value;
+                    }
+                }
+                // Check total fields size if maxFieldsSize is specified
+                if (options?.maxFieldsSize) {
+                    const totalFieldsSize = Object.values(fields).reduce((sum, val) => sum + String(val).length, 0);
+                    if (totalFieldsSize > options.maxFieldsSize) {
+                        throw new Error(`Total fields size exceeds maximum of ${options.maxFieldsSize} bytes`);
+                    }
+                }
+                // Check number of fields if maxFields is specified
+                if (options?.maxFields && Object.keys(fields).length > options.maxFields) {
+                    throw new Error(`Number of fields exceeds maximum of ${options.maxFields}`);
+                }
+                c.set('fields', fields);
+                c.set('files', files);
+            }
+            catch (error) {
+                // Handle parsing errors gracefully
+                console.error('Form parsing error:', error);
+                c.set('fields', {});
+                c.set('files', {});
+                throw error;
+            }
+        }
+        await next();
+    };
+}

package/lib/index.d.ts

@@ -0,0 +1,55 @@
+import { buildAuthenticatedRouter } from './buildAuthenticatedRouter.js';
+import { buildRouter } from './buildRouter.js';
+/**
+ * @module @adminjs/hono
+ *
+ * AdminJS adapter for Hono web framework
+ *
+ * Provides two main functions:
+ * - buildRouter: Creates a Hono app with AdminJS routes (no authentication)
+ * - buildAuthenticatedRouter: Creates a Hono app with AdminJS routes protected by session authentication
+ *
+ * @example
+ * ```typescript
+ * import { Hono } from 'hono'
+ * import AdminJS from 'adminjs'
+ * import { buildRouter } from '@adminjs/hono'
+ *
+ * const admin = new AdminJS({
+ *   databases: [],
+ *   rootPath: '/admin',
+ * })
+ *
+ * const app = new Hono()
+ * const adminRouter = buildRouter(admin)
+ * app.route('/admin', adminRouter)
+ * ```
+ */
+/**
+ * Plugin name
+ */
+export declare const name = "AdminJSHono";
+/**
+ * Plugin interface
+ */
+export type HonoPlugin = {
+    name: string;
+    buildAuthenticatedRouter: typeof buildAuthenticatedRouter;
+    buildRouter: typeof buildRouter;
+};
+/**
+ * Default plugin export
+ */
+declare const plugin: HonoPlugin;
+export default plugin;
+export { buildRouter } from './buildRouter.js';
+export { buildAuthenticatedRouter } from './buildAuthenticatedRouter.js';
+export type { AuthenticationOptions, UploadOptions, AuthenticationMaxRetriesOptions, AuthenticationContext, SessionOptions, SessionData, } from './types.js';
+export { convertToHonoRoute } from './convertRoutes.js';
+export * from './errors.js';
+export { log } from './logger.js';
+export { withLogin } from './authentication/login.handler.js';
+export { withLogout } from './authentication/logout.handler.js';
+export { withProtectedRoutesHandler } from './authentication/protected-routes.handler.js';
+export { withRefresh } from './authentication/refresh.handler.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAA;AACxE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;GAEG;AACH,eAAO,MAAM,IAAI,gBAAgB,CAAA;AAEjC;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,wBAAwB,EAAE,OAAO,wBAAwB,CAAA;IACzD,WAAW,EAAE,OAAO,WAAW,CAAA;CAChC,CAAA;AAED;;GAEG;AACH,QAAA,MAAM,MAAM,EAAE,UAA4D,CAAA;AAE1E,eAAe,MAAM,CAAA;AAGrB,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAA;AAGxE,YAAY,EACV,qBAAqB,EACrB,aAAa,EACb,+BAA+B,EAC/B,qBAAqB,EACrB,cAAc,EACd,WAAW,GACZ,MAAM,YAAY,CAAA;AAGnB,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AACvD,cAAc,aAAa,CAAA;AAC3B,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AAGjC,OAAO,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAA;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAA;AAC/D,OAAO,EAAE,0BAA0B,EAAE,MAAM,8CAA8C,CAAA;AACzF,OAAO,EAAE,WAAW,EAAE,MAAM,qCAAqC,CAAA"}

package/lib/index.js

@@ -0,0 +1,48 @@
+import { buildAuthenticatedRouter } from './buildAuthenticatedRouter.js';
+import { buildRouter } from './buildRouter.js';
+/**
+ * @module @adminjs/hono
+ *
+ * AdminJS adapter for Hono web framework
+ *
+ * Provides two main functions:
+ * - buildRouter: Creates a Hono app with AdminJS routes (no authentication)
+ * - buildAuthenticatedRouter: Creates a Hono app with AdminJS routes protected by session authentication
+ *
+ * @example
+ * ```typescript
+ * import { Hono } from 'hono'
+ * import AdminJS from 'adminjs'
+ * import { buildRouter } from '@adminjs/hono'
+ *
+ * const admin = new AdminJS({
+ *   databases: [],
+ *   rootPath: '/admin',
+ * })
+ *
+ * const app = new Hono()
+ * const adminRouter = buildRouter(admin)
+ * app.route('/admin', adminRouter)
+ * ```
+ */
+/**
+ * Plugin name
+ */
+export const name = 'AdminJSHono';
+/**
+ * Default plugin export
+ */
+const plugin = { name, buildAuthenticatedRouter, buildRouter };
+export default plugin;
+// Export main functions
+export { buildRouter } from './buildRouter.js';
+export { buildAuthenticatedRouter } from './buildAuthenticatedRouter.js';
+// Export utilities
+export { convertToHonoRoute } from './convertRoutes.js';
+export * from './errors.js';
+export { log } from './logger.js';
+// Export authentication handlers (for advanced usage)
+export { withLogin } from './authentication/login.handler.js';
+export { withLogout } from './authentication/logout.handler.js';
+export { withProtectedRoutesHandler } from './authentication/protected-routes.handler.js';
+export { withRefresh } from './authentication/refresh.handler.js';

package/lib/logger.d.ts

@@ -0,0 +1,7 @@
+export declare const log: {
+    debug: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+};
+//# sourceMappingURL=logger.d.ts.map

package/lib/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,GAAG;qBACG,OAAO,EAAE;oBAKV,OAAO,EAAE;oBAGT,OAAO,EAAE;qBAGR,OAAO,EAAE;CAG3B,CAAA"}

package/lib/logger.js

@@ -0,0 +1,17 @@
+const DEBUG = process.env.ADMINJS_HONO_DEBUG === 'true';
+export const log = {
+    debug: (...args) => {
+        if (DEBUG) {
+            console.log('[AdminJS Hono]', ...args);
+        }
+    },
+    info: (...args) => {
+        console.log('[AdminJS Hono]', ...args);
+    },
+    warn: (...args) => {
+        console.warn('[AdminJS Hono]', ...args);
+    },
+    error: (...args) => {
+        console.error('[AdminJS Hono]', ...args);
+    },
+};

package/lib/session.d.ts

@@ -0,0 +1,25 @@
+import type { MiddlewareHandler } from 'hono';
+import type { SessionData, SessionOptions, HonoVariables } from './types.js';
+/**
+ * Creates session middleware for Hono
+ * Manages cookie-based sessions with in-memory storage
+ *
+ * @param secret - Secret key for session (currently unused, for future HMAC signing)
+ * @param cookieName - Name of the session cookie
+ * @param options - Session cookie options
+ * @returns Hono middleware handler
+ */
+export declare function createSessionMiddleware(secret: string, cookieName: string, options?: SessionOptions): MiddlewareHandler<{
+    Variables: HonoVariables;
+}>;
+/**
+ * Destroys a session by removing it from the store
+ * @param sessionId - The session ID to destroy
+ */
+export declare function destroySession(sessionId: string): void;
+/**
+ * Gets the session store (for testing purposes)
+ * @returns The session store Map
+ */
+export declare function getSessionStore(): Map<string, SessionData>;
+//# sourceMappingURL=session.d.ts.map

package/lib/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAW,MAAM,MAAM,CAAA;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAa5E;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,cAAc,GACvB,iBAAiB,CAAC;IAAE,SAAS,EAAE,aAAa,CAAA;CAAE,CAAC,CA0BjD;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAEtD;AAED;;;GAGG;AACH,wBAAgB,eAAe,IAAI,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAE1D"}