@carno.js/core 0.2.11 → 1.0.2

package/dist/Carno.mjs

@@ -0,0 +1,268 @@
+import "reflect-metadata";
+import { CONTROLLER_META, ROUTES_META, PARAMS_META, MIDDLEWARE_META } from "./metadata.mjs";
+import { compileHandler } from "./compiler/JITCompiler.mjs";
+import { Context } from "./context/Context.mjs";
+import { Container, Scope } from "./container/Container.mjs";
+import { CorsHandler } from "./cors/CorsHandler.mjs";
+import { HttpException } from "./exceptions/HttpException.mjs";
+import { ValidationException } from "./validation/ZodAdapter.mjs";
+import { EventType, hasEventHandlers, getEventHandlers } from "./events/Lifecycle.mjs";
+import { CacheService } from "./cache/CacheService.mjs";
+import { DEFAULT_STATIC_ROUTES } from "./DefaultRoutes.mjs";
+import { ZodAdapter } from "./validation/ZodAdapter.mjs";
+const NOT_FOUND_RESPONSE = new Response("Not Found", { status: 404 }), TEXT_OPTS = Object.freeze({
+  status: 200,
+  headers: { "Content-Type": "text/plain" }
+}), JSON_OPTS = Object.freeze({
+  status: 200,
+  headers: { "Content-Type": "application/json" }
+}), INTERNAL_ERROR_RESPONSE = new Response(
+  '{"statusCode":500,"message":"Internal Server Error"}',
+  { status: 500, headers: { "Content-Type": "application/json" } }
+);
+class Carno {
+  constructor(config = {}) {
+    this.config = config;
+    this._controllers = [];
+    this._services = [];
+    this._middlewares = [];
+    this.routes = {};
+    this.container = new Container();
+    this.corsHandler = null;
+    this.hasCors = !1;
+    this.validator = null;
+    // Cached lifecycle event flags - checked once at startup
+    this.hasInitHooks = !1;
+    this.hasBootHooks = !1;
+    this.hasShutdownHooks = !1;
+    if (this.config.exports = this.config.exports || [], this.config.globalMiddlewares = this.config.globalMiddlewares || [], this.config.cors && (this.corsHandler = new CorsHandler(this.config.cors), this.hasCors = !0), this.config.validation === void 0 || this.config.validation === !0)
+      this.validator = new ZodAdapter();
+    else if (typeof this.config.validation == "function") {
+      const AdapterClass = this.config.validation;
+      this.validator = new AdapterClass();
+    } else this.config.validation && (this.validator = this.config.validation);
+  }
+  /**
+   * Use a Carno plugin.
+   * Imports controllers, services and global middlewares from another Carno instance.
+   */
+  use(plugin) {
+    plugin._controllers.length > 0 && this._controllers.push(...plugin._controllers);
+    for (const exported of plugin.config.exports || []) {
+      const existingService = this.findServiceInPlugin(plugin, exported), serviceToAdd = this.shouldCloneService(existingService) ? { ...existingService } : exported;
+      this._services.push(serviceToAdd);
+    }
+    return plugin._services.length > 0 && this._services.push(...plugin._services), plugin.config.globalMiddlewares && this._middlewares.push(...plugin.config.globalMiddlewares), plugin._middlewares.length > 0 && this._middlewares.push(...plugin._middlewares), this;
+  }
+  findServiceInPlugin(plugin, exported) {
+    return plugin._services.find(
+      (s) => this.getServiceToken(s) === this.getServiceToken(exported)
+    );
+  }
+  getServiceToken(service) {
+    return service?.token || service;
+  }
+  shouldCloneService(service) {
+    return !!(service?.useValue !== void 0 || service?.useClass);
+  }
+  /**
+   * Register one or more services/providers.
+   */
+  services(serviceClass) {
+    const items = Array.isArray(serviceClass) ? serviceClass : [serviceClass];
+    return this._services.push(...items), this;
+  }
+  /**
+   * Register one or more global middlewares.
+   */
+  middlewares(handler) {
+    const items = Array.isArray(handler) ? handler : [handler];
+    return this._middlewares.push(...items), this;
+  }
+  /**
+   * Register one or more controllers.
+   */
+  controllers(controllerClass) {
+    const items = Array.isArray(controllerClass) ? controllerClass : [controllerClass];
+    return this._controllers.push(...items), this;
+  }
+  /**
+   * Get a service instance from the container.
+   */
+  get(token) {
+    return this.container.get(token);
+  }
+  listen(port = 3e3) {
+    this.bootstrap(), this.compileRoutes();
+    const config = {
+      port,
+      fetch: this.handleNotFound.bind(this),
+      error: this.handleError.bind(this),
+      routes: {
+        ...DEFAULT_STATIC_ROUTES,
+        ...this.routes
+      }
+    };
+    this.server = Bun.serve(config), this.hasBootHooks && this.executeLifecycleHooks(EventType.BOOT), this.hasShutdownHooks && this.registerShutdownHandlers(), this.config.disableStartupLog || console.log(`Carno running on port ${port}`);
+  }
+  bootstrap() {
+    this.hasInitHooks = hasEventHandlers(EventType.INIT), this.hasBootHooks = hasEventHandlers(EventType.BOOT), this.hasShutdownHooks = hasEventHandlers(EventType.SHUTDOWN), this.container.register({
+      token: Container,
+      useValue: this.container
+    });
+    const cacheConfig = typeof this.config.cache == "object" ? this.config.cache : {};
+    this.container.register({
+      token: CacheService,
+      useValue: new CacheService(cacheConfig)
+    });
+    for (const service of this._services)
+      this.container.register(service);
+    for (const ControllerClass of this._controllers)
+      this.container.register(ControllerClass);
+    this.hasInitHooks && this.executeLifecycleHooks(EventType.INIT);
+    for (const service of this._services) {
+      const token = typeof service == "function" ? service : service.token, serviceConfig = typeof service == "function" ? null : service;
+      (!serviceConfig || serviceConfig.scope !== Scope.REQUEST) && this.container.get(token);
+    }
+  }
+  compileRoutes() {
+    for (const ControllerClass of this._controllers)
+      this.compileController(ControllerClass);
+  }
+  compileController(ControllerClass, parentPath = "", inheritedMiddlewares = []) {
+    const meta = Reflect.getMetadata(CONTROLLER_META, ControllerClass) || { path: "" }, basePath = parentPath + (meta.path || ""), routes = Reflect.getMetadata(ROUTES_META, ControllerClass) || [], middlewares = Reflect.getMetadata(MIDDLEWARE_META, ControllerClass) || [], instance = this.container.get(ControllerClass), controllerMiddlewares = middlewares.filter((m) => !m.target).map((m) => m.handler), scopedMiddlewares = [...inheritedMiddlewares, ...controllerMiddlewares];
+    for (const route of routes) {
+      const fullPath = this.normalizePath(basePath + route.path), params = Reflect.getMetadata(PARAMS_META, ControllerClass, route.handlerName) || [], routeMiddlewares = middlewares.filter((m) => m.target === route.handlerName).map((m) => m.handler), paramTypes = Reflect.getMetadata("design:paramtypes", ControllerClass.prototype, route.handlerName) || [];
+      let bodyDtoType = null;
+      for (const param of params)
+        if (param.type === "body" && !param.key) {
+          const dtoType = paramTypes[param.index];
+          dtoType && this.validator?.hasValidation(dtoType) && (bodyDtoType = dtoType);
+        }
+      const compiled = compileHandler(instance, route.handlerName, params), resolvedMiddlewares = [
+        ...this.config.globalMiddlewares || [],
+        ...this._middlewares,
+        ...scopedMiddlewares,
+        ...routeMiddlewares
+      ].map((m) => this.resolveMiddleware(m)), hasMiddlewares = resolvedMiddlewares.length > 0, method = route.method.toUpperCase();
+      compiled.isStatic && !hasMiddlewares ? this.registerRoute(fullPath, method, this.createStaticResponse(compiled.staticValue)) : this.registerRoute(fullPath, method, this.createHandler(compiled, params, resolvedMiddlewares, bodyDtoType));
+    }
+    if (meta.children)
+      for (const ChildController of meta.children)
+        this.container.has(ChildController) || this.container.register(ChildController), this.compileController(ChildController, basePath, scopedMiddlewares);
+  }
+  /**
+   * Register a route with Bun's native router format.
+   * Path: "/users/:id", Method: "GET", Handler: Function or Response
+   */
+  registerRoute(path, method, handler) {
+    this.routes[path] || (this.routes[path] = {}), this.routes[path][method] = handler;
+  }
+  createStaticResponse(value) {
+    const isString = typeof value == "string", body = isString ? value : JSON.stringify(value), opts = isString ? TEXT_OPTS : JSON_OPTS;
+    return new Response(body, opts);
+  }
+  createHandler(compiled, params, middlewares, bodyDtoType) {
+    const handler = compiled.fn, hasMiddlewares = middlewares.length > 0, hasParams = params.length > 0, applyCors = this.hasCors ? this.applyCors.bind(this) : null, validator = bodyDtoType ? this.validator : null, hasMiddlewaresOrValidation = hasMiddlewares || !!validator;
+    return !hasMiddlewaresOrValidation && !hasParams ? compiled.isAsync ? async (req) => {
+      const ctx = new Context(req), result = await handler(ctx), response = this.buildResponse(result);
+      return applyCors ? applyCors(response, req) : response;
+    } : (req) => {
+      const ctx = new Context(req), result = handler(ctx), response = this.buildResponse(result);
+      return applyCors ? applyCors(response, req) : response;
+    } : !hasMiddlewaresOrValidation && hasParams ? compiled.isAsync ? async (req) => {
+      const ctx = new Context(req, req.params), result = await handler(ctx), response = this.buildResponse(result);
+      return applyCors ? applyCors(response, req) : response;
+    } : (req) => {
+      const ctx = new Context(req, req.params), result = handler(ctx), response = this.buildResponse(result);
+      return applyCors ? applyCors(response, req) : response;
+    } : async (req) => {
+      const ctx = new Context(req, req.params || {});
+      for (const middleware of middlewares) {
+        const result2 = await middleware(ctx);
+        if (result2 instanceof Response)
+          return applyCors ? applyCors(result2, req) : result2;
+      }
+      validator && bodyDtoType && (await ctx.parseBody(), validator.validateOrThrow(bodyDtoType, ctx.body));
+      const result = compiled.isAsync ? await handler(ctx) : handler(ctx), response = this.buildResponse(result);
+      return applyCors ? applyCors(response, req) : response;
+    };
+  }
+  resolveMiddleware(middleware) {
+    if (typeof middleware == "function" && middleware.prototype?.handle) {
+      const instance = this.container.get(middleware);
+      return (ctx) => instance.handle(ctx, () => {
+      });
+    }
+    return middleware;
+  }
+  /**
+   * Apply CORS headers to a response.
+   */
+  applyCors(response, req) {
+    const origin = req.headers.get("origin");
+    return origin && this.corsHandler ? this.corsHandler.apply(response, origin) : response;
+  }
+  /**
+   * Fallback handler - only called for unmatched routes.
+   * All matched routes go through Bun's native router.
+   */
+  handleNotFound(req) {
+    if (this.hasCors && req.method === "OPTIONS") {
+      const origin = req.headers.get("origin");
+      if (origin)
+        return this.corsHandler.preflight(origin);
+    }
+    return NOT_FOUND_RESPONSE;
+  }
+  buildResponse(result) {
+    return result instanceof Response ? result : typeof result == "string" ? new Response(result, TEXT_OPTS) : result === void 0 ? new Response(null, { status: 204 }) : Response.json(result);
+  }
+  normalizePath(path) {
+    return path.startsWith("/") || (path = "/" + path), path !== "/" && path.endsWith("/") && (path = path.slice(0, -1)), path.replace(/\/+/g, "/");
+  }
+  hasParams(path) {
+    return path.includes(":") || path.includes("*");
+  }
+  stop() {
+    this.server?.stop?.();
+  }
+  /**
+   * Error handler for Bun.serve.
+   * Converts exceptions to proper HTTP responses.
+   */
+  handleError(error) {
+    let response;
+    return error instanceof HttpException || error instanceof ValidationException ? response = error.toResponse() : (console.error("Unhandled error:", error), response = INTERNAL_ERROR_RESPONSE), this.hasCors && this.corsHandler ? this.corsHandler.apply(response, "*") : response;
+  }
+  /**
+   * Execute lifecycle hooks for a specific event type.
+   */
+  executeLifecycleHooks(type) {
+    const handlers = getEventHandlers(type);
+    for (const handler of handlers)
+      try {
+        const instance = this.container.has(handler.target) ? this.container.get(handler.target) : null;
+        if (instance && typeof instance[handler.methodName] == "function") {
+          const result = instance[handler.methodName]();
+          result instanceof Promise && result.catch(
+            (err) => console.error(`Error in ${type} hook ${handler.methodName}:`, err)
+          );
+        }
+      } catch (err) {
+        console.error(`Error in ${type} hook ${handler.methodName}:`, err);
+      }
+  }
+  /**
+   * Register SIGTERM/SIGINT handlers for graceful shutdown.
+   */
+  registerShutdownHandlers() {
+    const shutdown = () => {
+      this.executeLifecycleHooks(EventType.SHUTDOWN), this.stop(), process.exit(0);
+    };
+    process.on("SIGTERM", shutdown), process.on("SIGINT", shutdown);
+  }
+}
+export {
+  Carno
+};

package/dist/DefaultRoutes.js

@@ -0,0 +1,51 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod), __decorateClass = (decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp(target, key, result), result;
+};
+var DefaultRoutes_exports = {};
+__export(DefaultRoutes_exports, {
+  DEFAULT_STATIC_ROUTES: () => DEFAULT_STATIC_ROUTES,
+  DefaultRoutes: () => DefaultRoutes
+});
+module.exports = __toCommonJS(DefaultRoutes_exports);
+var import_Controller = require('./decorators/Controller.js'), import_methods = require('./decorators/methods.js');
+let DefaultRoutes = class {
+  favicon() {
+    return new Response(null, { status: 204 });
+  }
+};
+__decorateClass([
+  (0, import_methods.Get)("/favicon.ico")
+], DefaultRoutes.prototype, "favicon", 1), DefaultRoutes = __decorateClass([
+  (0, import_Controller.Controller)()
+], DefaultRoutes);
+const DEFAULT_STATIC_ROUTES = {
+  "/health": new Response('{"status":"ok"}', {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  }),
+  "/ready": new Response('{"ready":true}', {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  }),
+  "/favicon.ico": new Response(null, { status: 204 })
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_STATIC_ROUTES,
+  DefaultRoutes
+});

package/dist/DefaultRoutes.mjs

@@ -0,0 +1,34 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp(target, key, result), result;
+};
+import { Controller } from "./decorators/Controller.mjs";
+import { Get } from "./decorators/methods.mjs";
+let DefaultRoutes = class {
+  favicon() {
+    return new Response(null, { status: 204 });
+  }
+};
+__decorateClass([
+  Get("/favicon.ico")
+], DefaultRoutes.prototype, "favicon", 1), DefaultRoutes = __decorateClass([
+  Controller()
+], DefaultRoutes);
+const DEFAULT_STATIC_ROUTES = {
+  "/health": new Response('{"status":"ok"}', {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  }),
+  "/ready": new Response('{"ready":true}', {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  }),
+  "/favicon.ico": new Response(null, { status: 204 })
+};
+export {
+  DEFAULT_STATIC_ROUTES,
+  DefaultRoutes
+};