@objectstack/plugin-hono-server 1.0.4 → 1.0.6

package/dist/adapter.js

@@ -1,145 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HonoHttpServer = void 0;
-// Export IHttpServer from core
-__exportStar(require("@objectstack/core"), exports);
-const hono_1 = require("hono");
-const node_server_1 = require("@hono/node-server");
-const serve_static_1 = require("@hono/node-server/serve-static");
-/**
- * Hono Implementation of IHttpServer
- */
-class HonoHttpServer {
-    port;
-    staticRoot;
-    app;
-    server;
-    listeningPort;
-    constructor(port = 3000, staticRoot) {
-        this.port = port;
-        this.staticRoot = staticRoot;
-        this.app = new hono_1.Hono();
-    }
-    // internal helper to convert standard handler to Hono handler
-    wrap(handler) {
-        return async (c) => {
-            let body = {};
-            // Try to parse JSON body first if content-type is JSON
-            if (c.req.header('content-type')?.includes('application/json')) {
-                try {
-                    body = await c.req.json();
-                }
-                catch (e) {
-                    // If JSON parsing fails, try parseBody
-                    try {
-                        body = await c.req.parseBody();
-                    }
-                    catch (e2) { }
-                }
-            }
-            else {
-                // For non-JSON content types, use parseBody
-                try {
-                    body = await c.req.parseBody();
-                }
-                catch (e) { }
-            }
-            const req = {
-                params: c.req.param(),
-                query: c.req.query(),
-                body,
-                headers: c.req.header(),
-                method: c.req.method,
-                path: c.req.path
-            };
-            let capturedResponse;
-            const res = {
-                json: (data) => { capturedResponse = c.json(data); },
-                send: (data) => { capturedResponse = c.html(data); },
-                status: (code) => { c.status(code); return res; },
-                header: (name, value) => { c.header(name, value); return res; }
-            };
-            await handler(req, res);
-            return capturedResponse;
-        };
-    }
-    get(path, handler) {
-        this.app.get(path, this.wrap(handler));
-    }
-    post(path, handler) {
-        this.app.post(path, this.wrap(handler));
-    }
-    put(path, handler) {
-        this.app.put(path, this.wrap(handler));
-    }
-    delete(path, handler) {
-        this.app.delete(path, this.wrap(handler));
-    }
-    patch(path, handler) {
-        this.app.patch(path, this.wrap(handler));
-    }
-    use(pathOrHandler, handler) {
-        if (typeof pathOrHandler === 'string' && handler) {
-            // Path based middleware
-            // Hono middleware signature is different (c, next) => ...
-            this.app.use(pathOrHandler, async (c, next) => {
-                // Simplistic conversion
-                await handler({}, {}, next);
-            });
-        }
-        else if (typeof pathOrHandler === 'function') {
-            // Global middleware
-            this.app.use('*', async (c, next) => {
-                await pathOrHandler({}, {}, next);
-            });
-        }
-    }
-    /**
-     * Mount a sub-application or router
-     */
-    mount(path, subApp) {
-        this.app.route(path, subApp);
-    }
-    async listen(port) {
-        return new Promise((resolve) => {
-            if (this.staticRoot) {
-                this.app.get('/*', (0, serve_static_1.serveStatic)({ root: this.staticRoot }));
-            }
-            const targetPort = port || this.port;
-            this.server = (0, node_server_1.serve)({
-                fetch: this.app.fetch,
-                port: targetPort
-            }, (info) => {
-                this.listeningPort = info.port;
-                resolve();
-            });
-        });
-    }
-    getPort() {
-        return this.listeningPort || this.port;
-    }
-    // Expose raw app for scenarios where standard interface is not enough
-    getRawApp() {
-        return this.app;
-    }
-    async close() {
-        if (this.server && typeof this.server.close === 'function') {
-            this.server.close();
-        }
-    }
-}
-exports.HonoHttpServer = HonoHttpServer;

package/dist/hono-plugin.d.ts

@@ -1,49 +0,0 @@
-import { Plugin, PluginContext } from '@objectstack/core';
-import { RestServerConfig } from '@objectstack/spec/api';
-export interface HonoPluginOptions {
-    port?: number;
-    staticRoot?: string;
-    /**
-     * REST server configuration
-     * Controls automatic endpoint generation and API behavior
-     */
-    restConfig?: RestServerConfig;
-    /**
-     * Whether to register standard ObjectStack CRUD endpoints
-     * @default true
-     */
-    registerStandardEndpoints?: boolean;
-    /**
-     * Whether to load endpoints from API Registry
-     * @default true
-     */
-    useApiRegistry?: boolean;
-}
-/**
- * Hono Server Plugin
- *
- * Provides HTTP server capabilities using Hono framework.
- * Registers routes for ObjectStack Runtime Protocol.
- */
-export declare class HonoServerPlugin implements Plugin {
-    name: string;
-    version: string;
-    private static readonly DEFAULT_ENDPOINT_PRIORITY;
-    private static readonly CORE_ENDPOINT_PRIORITY;
-    private static readonly DISCOVERY_ENDPOINT_PRIORITY;
-    private options;
-    private server;
-    constructor(options?: HonoPluginOptions);
-    /**
-     * Init phase - Setup HTTP server and register as service
-     */
-    init: (ctx: PluginContext) => Promise<void>;
-    /**
-     * Start phase - Bind routes and start listening
-     */
-    start: (ctx: PluginContext) => Promise<void>;
-    /**
-     * Destroy phase - Stop server
-     */
-    destroy(): Promise<void>;
-}

package/dist/hono-plugin.js

@@ -1,90 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HonoServerPlugin = void 0;
-const adapter_1 = require("./adapter");
-const hono_1 = require("@objectstack/hono");
-/**
- * Hono Server Plugin
- *
- * Provides HTTP server capabilities using Hono framework.
- * Registers routes for ObjectStack Runtime Protocol.
- */
-class HonoServerPlugin {
-    name = 'com.objectstack.server.hono';
-    version = '0.9.0';
-    // Constants
-    static DEFAULT_ENDPOINT_PRIORITY = 100;
-    static CORE_ENDPOINT_PRIORITY = 950;
-    static DISCOVERY_ENDPOINT_PRIORITY = 900;
-    options;
-    server;
-    constructor(options = {}) {
-        this.options = {
-            port: 3000,
-            registerStandardEndpoints: true,
-            useApiRegistry: true,
-            ...options
-        };
-        this.server = new adapter_1.HonoHttpServer(this.options.port, this.options.staticRoot);
-    }
-    /**
-     * Init phase - Setup HTTP server and register as service
-     */
-    init = async (ctx) => {
-        ctx.logger.debug('Initializing Hono server plugin', {
-            port: this.options.port,
-            staticRoot: this.options.staticRoot
-        });
-        // Register HTTP server service as IHttpServer
-        // Register as 'http.server' to match core requirements
-        ctx.registerService('http.server', this.server);
-        // Alias 'http-server' for backward compatibility
-        ctx.registerService('http-server', this.server);
-        ctx.logger.debug('HTTP server service registered', { serviceName: 'http.server' });
-    };
-    /**
-     * Start phase - Bind routes and start listening
-     */
-    start = async (ctx) => {
-        ctx.logger.debug('Starting Hono server plugin');
-        // Use Standard ObjectStack Runtime Hono App
-        try {
-            const kernel = ctx.getKernel();
-            const config = this.options.restConfig || {};
-            // Calculate prefix similar to before
-            const apiVersion = config.api?.version || 'v1';
-            const basePath = config.api?.basePath || '/api';
-            const apiPath = config.api?.apiPath || `${basePath}/${apiVersion}`;
-            const app = (0, hono_1.createHonoApp)({
-                kernel,
-                prefix: apiPath // Use the calculated path
-            });
-            ctx.logger.debug('Mounting ObjectStack Runtime App', { prefix: apiPath });
-            // Use the mount method we added to HonoHttpServer
-            this.server.mount('/', app);
-        }
-        catch (e) {
-            ctx.logger.error('Failed to create standard Hono app', e);
-        }
-        // Start server on kernel:ready hook
-        ctx.hook('kernel:ready', async () => {
-            const port = this.options.port || 3000;
-            ctx.logger.debug('Starting HTTP server', { port });
-            await this.server.listen(port);
-            const actualPort = this.server.getPort();
-            ctx.logger.info('HTTP server started successfully', {
-                port: actualPort,
-                url: `http://localhost:${actualPort}`
-            });
-        });
-    };
-    /**
-     * Destroy phase - Stop server
-     */
-    async destroy() {
-        this.server.close();
-        // Note: Can't use ctx.logger here since we're in destroy
-        console.log('[HonoServerPlugin] Server stopped');
-    }
-}
-exports.HonoServerPlugin = HonoServerPlugin;