balda-js 0.0.54 → 0.0.56

package/.adminjs/bundle.js

@@ -0,0 +1 @@
+(function(){"use strict";AdminJS.UserComponents={}})();

package/.adminjs/entry.js

@@ -0,0 +1 @@
+AdminJS.UserComponents = {}

package/lib/index.cjs

@@ -2395,12 +2395,40 @@ var Request2 = class _Request extends NativeRequest {
   }
 };
 
+// src/runtime/native_env.ts
+var NativeEnv = class {
+  get(key) {
+    switch (runtime.type) {
+      case "node":
+      case "bun":
+      case "deno":
+        return process.env[key] ?? "";
+      default:
+        throw new Error(`Unsupported runtime: ${runtime.type}`);
+    }
+  }
+  getEnvironment() {
+    switch (runtime.type) {
+      case "node":
+      case "deno":
+      case "bun":
+        return Object.fromEntries(
+          Object.entries(process.env).filter(
+            ([_, value]) => value !== void 0
+          )
+        );
+    }
+  }
+};
+
 // src/errors/error_factory.ts
+var nativeEnv = new NativeEnv();
 var errorFactory = (error) => {
+  const isDevelopment = nativeEnv.get("NODE_ENV") !== "production";
   return {
-    cause: error.cause,
+    code: error.name || "INTERNAL_ERROR",
     message: error.message,
-    stack: error.stack
+    ...isDevelopment && { stack: error.stack, cause: error.cause }
   };
 };
 
@@ -3440,6 +3468,330 @@ async function verifySignedCookie(value, secret) {
   return signature === expectedSignature ? cookieValue : false;
 }
 
+// src/plugins/express/express.ts
+function toBaldaToExpressRequest(baldaReq, basePath = "") {
+  const url = new URL(baldaReq.url);
+  const headersObj = Object.fromEntries(baldaReq.headers.entries());
+  const expressReq = {
+    body: baldaReq.body,
+    query: baldaReq.query,
+    params: baldaReq.params,
+    cookies: baldaReq.cookies,
+    session: baldaReq.session,
+    originalUrl: url.pathname + url.search,
+    baseUrl: basePath,
+    path: url.pathname.replace(basePath, "") || "/",
+    method: baldaReq.method,
+    ip: baldaReq.ip,
+    headers: headersObj,
+    url: url.pathname,
+    get(name) {
+      return baldaReq.headers.get(name.toLowerCase()) ?? void 0;
+    },
+    header(name) {
+      return baldaReq.headers.get(name.toLowerCase()) ?? void 0;
+    },
+    app: {},
+    res: null,
+    route: null,
+    protocol: url.protocol.replace(":", ""),
+    secure: url.protocol === "https:",
+    hostname: url.hostname,
+    host: url.host,
+    fresh: false,
+    stale: true,
+    xhr: headersObj["x-requested-with"]?.toLowerCase() === "xmlhttprequest",
+    accepts: () => void 0,
+    acceptsCharsets: () => void 0,
+    acceptsEncodings: () => void 0,
+    acceptsLanguages: () => void 0,
+    is: () => null,
+    range: () => void 0,
+    param: (name) => baldaReq.params[name] ?? baldaReq.query[name],
+    files: baldaReq.files,
+    file: baldaReq.file,
+    rawBody: baldaReq.rawBody
+  };
+  return expressReq;
+}
+function createExpressResponse(baldaRes) {
+  const expressRes = {
+    locals: {},
+    headersSent: false,
+    statusCode: baldaRes.responseStatus,
+    status(code) {
+      baldaRes.status(code);
+      this.statusCode = code;
+      return this;
+    },
+    sendStatus(code) {
+      this.status(code).send(String(code));
+      return this;
+    },
+    send(body) {
+      this.headersSent = true;
+      const hasContentType = !!baldaRes.headers["Content-Type"];
+      if (!hasContentType && typeof body === "string") {
+        const trimmed = body.trim();
+        if (trimmed.startsWith("<!DOCTYPE") || trimmed.startsWith("<html") || trimmed.startsWith("<HTML")) {
+          baldaRes.html(body);
+          return this;
+        }
+      }
+      baldaRes.send(body);
+      return this;
+    },
+    json(body) {
+      this.headersSent = true;
+      baldaRes.json(body);
+      return this;
+    },
+    redirect(statusOrUrl, url) {
+      this.headersSent = true;
+      const redirectUrl = typeof statusOrUrl === "string" ? statusOrUrl : url;
+      const status = typeof statusOrUrl === "number" ? statusOrUrl : 302;
+      baldaRes.status(status).setHeader("Location", redirectUrl);
+      baldaRes.send("");
+      return this;
+    },
+    setHeader(name, value) {
+      const stringValue = Array.isArray(value) ? value.join(", ") : String(value);
+      baldaRes.setHeader(name, stringValue);
+      return this;
+    },
+    set(field, value) {
+      if (typeof field === "object") {
+        for (const [key, val] of Object.entries(field)) {
+          baldaRes.setHeader(key, val);
+        }
+      } else if (value !== void 0) {
+        baldaRes.setHeader(field, value);
+      }
+      return this;
+    },
+    header(field, value) {
+      return this.set(field, value);
+    },
+    type(contentType) {
+      baldaRes.setHeader("Content-Type", contentType);
+      return this;
+    },
+    contentType(type) {
+      return this.type(type);
+    },
+    end(data) {
+      this.headersSent = true;
+      baldaRes.send(data ?? "");
+      return this;
+    },
+    write(chunk) {
+      return true;
+    },
+    get(name) {
+      return baldaRes.headers[name];
+    },
+    getHeader(name) {
+      return baldaRes.headers[name];
+    },
+    removeHeader(name) {
+      delete baldaRes.headers[name];
+      return this;
+    },
+    append(field, value) {
+      const prev = baldaRes.headers[field];
+      const newValue = Array.isArray(value) ? value.join(", ") : value;
+      baldaRes.setHeader(field, prev ? `${prev}, ${newValue}` : newValue);
+      return this;
+    },
+    cookie(name, value, options) {
+      baldaRes.cookie?.(name, value, options);
+      return this;
+    },
+    clearCookie(name, options) {
+      baldaRes.clearCookie?.(name, options);
+      return this;
+    },
+    render(view, options, callback) {
+      throw new Error(
+        "render() is not supported in Express compatibility layer"
+      );
+    },
+    format(obj) {
+      return this;
+    },
+    attachment(filename) {
+      if (filename) {
+        baldaRes.setHeader(
+          "Content-Disposition",
+          `attachment; filename="${filename}"`
+        );
+      } else {
+        baldaRes.setHeader("Content-Disposition", "attachment");
+      }
+      return this;
+    },
+    sendFile(path2, options, fn) {
+      baldaRes.file(path2);
+    },
+    download(path2, filename, options, fn) {
+      const fname = typeof filename === "string" ? filename : path2.split("/").pop();
+      this.attachment(fname);
+      baldaRes.file(path2);
+    },
+    links(links) {
+      const link = Object.entries(links).map(([rel, url]) => `<${url}>; rel="${rel}"`).join(", ");
+      baldaRes.setHeader("Link", link);
+      return this;
+    },
+    location(url) {
+      baldaRes.setHeader("Location", url);
+      return this;
+    },
+    vary(field) {
+      baldaRes.setHeader("Vary", field);
+      return this;
+    },
+    app: {},
+    req: null
+  };
+  return expressRes;
+}
+function expressMiddleware(expressHandler2, basePath = "") {
+  return async (baldaReq, baldaRes, next) => {
+    const expressReq = toBaldaToExpressRequest(baldaReq, basePath);
+    const expressRes = createExpressResponse(baldaRes);
+    await new Promise((resolve, reject) => {
+      const expressNext = (err) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve();
+      };
+      try {
+        const result = expressHandler2(expressReq, expressRes, expressNext);
+        if (result instanceof Promise) {
+          result.catch(reject);
+        }
+      } catch (error) {
+        reject(error);
+      }
+    });
+    await next();
+  };
+}
+function expressHandler(handler, basePath = "") {
+  return async (baldaReq, baldaRes) => {
+    const expressReq = toBaldaToExpressRequest(baldaReq, basePath);
+    const expressRes = createExpressResponse(baldaRes);
+    const next = () => {
+    };
+    await handler(expressReq, expressRes, next);
+  };
+}
+function mountExpressRouter(basePath, expressRouter) {
+  const normalizedBase = normalizePath(basePath);
+  const stack = expressRouter.stack;
+  if (!stack) {
+    console.warn("Express router has no stack - routes may not be registered");
+    return;
+  }
+  for (const layer of stack) {
+    processExpressLayer(layer, normalizedBase);
+  }
+}
+function processExpressLayer(layer, basePath) {
+  if (layer.route) {
+    const routePath = normalizePath(basePath + layer.route.path);
+    const methods = Object.keys(layer.route.methods).filter(
+      (m) => layer.route.methods[m]
+    );
+    for (const method of methods) {
+      const handlers = layer.route.stack.map((s) => s.handle);
+      registerExpressHandlers(
+        method.toUpperCase(),
+        routePath,
+        handlers,
+        basePath
+      );
+    }
+    return;
+  }
+  if (layer.handle && typeof layer.handle === "function") {
+    const layerPath = layer.path || "";
+    const fullPath = normalizePath(basePath + layerPath);
+    const layerStack = layer.handle.stack;
+    if (layerStack && Array.isArray(layerStack)) {
+      for (const subLayer of layerStack) {
+        processExpressLayer(subLayer, fullPath);
+      }
+      return;
+    }
+    const wildcardPath = fullPath === "/" ? "/*" : `${fullPath}/*`;
+    const middleware2 = expressMiddleware(
+      layer.handle,
+      basePath
+    );
+    const methods = [
+      "GET",
+      "POST",
+      "PUT",
+      "PATCH",
+      "DELETE",
+      "OPTIONS",
+      "HEAD"
+    ];
+    for (const method of methods) {
+      router.addOrUpdate(method, wildcardPath, [middleware2], async () => {
+      }, {
+        excludeFromSwagger: true
+      });
+    }
+  }
+}
+function registerExpressHandlers(method, path2, handlers, basePath) {
+  const middlewares = handlers.slice(0, -1).map((h) => expressMiddleware(h, basePath));
+  const lastHandler = handlers[handlers.length - 1];
+  const finalHandler = expressHandler(lastHandler, basePath);
+  router.addOrUpdate(method, path2, middlewares, finalHandler, {
+    excludeFromSwagger: true
+  });
+}
+function normalizePath(path2) {
+  let normalized = path2.replace(/\/+/g, "/");
+  if (!normalized.startsWith("/")) {
+    normalized = "/" + normalized;
+  }
+  if (normalized.length > 1 && normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+function createExpressAdapter(server) {
+  return {
+    use(pathOrMiddleware, maybeMiddleware) {
+      if (typeof pathOrMiddleware === "string") {
+        const path2 = pathOrMiddleware;
+        const middleware3 = maybeMiddleware;
+        const middlewareStack2 = middleware3.stack;
+        if (middlewareStack2 && Array.isArray(middlewareStack2)) {
+          mountExpressRouter(path2, middleware3);
+          return;
+        }
+        server.use(expressMiddleware(middleware3, path2));
+        return;
+      }
+      const middleware2 = pathOrMiddleware;
+      const middlewareStack = middleware2.stack;
+      if (middlewareStack && Array.isArray(middlewareStack)) {
+        mountExpressRouter("/", middleware2);
+        return;
+      }
+      server.use(expressMiddleware(middleware2));
+    }
+  };
+}
+
 // src/plugins/log/log.ts
 var log = (options) => {
   return async (req, res, next) => {
@@ -3729,32 +4081,6 @@ function setNestedValue(obj, key, value) {
   current[lastKey] = value;
 }
 
-// src/runtime/native_env.ts
-var NativeEnv = class {
-  get(key) {
-    switch (runtime.type) {
-      case "node":
-      case "bun":
-      case "deno":
-        return process.env[key] ?? "";
-      default:
-        throw new Error(`Unsupported runtime: ${runtime.type}`);
-    }
-  }
-  getEnvironment() {
-    switch (runtime.type) {
-      case "node":
-      case "deno":
-      case "bun":
-        return Object.fromEntries(
-          Object.entries(process.env).filter(
-            ([_, value]) => value !== void 0
-          )
-        );
-    }
-  }
-};
-
 // src/runtime/native_hash.ts
 var NativeHash = class {
   ITERATIONS = 6e5;
@@ -5011,7 +5337,18 @@ var PROTECTED_KEYS = [
   "startUpOptions",
   "tmpDir",
   "logger",
-  "getMockServer"
+  "getMockServer",
+  "useExpress",
+  "expressMiddleware",
+  "mountExpressRouter",
+  "setNotFoundHandler",
+  "setGlobalCronErrorHandler",
+  "startRegisteredCrons",
+  "bootstrap",
+  "handleNotFound",
+  "registerNotFoundRoutes",
+  "importControllers",
+  "applyPlugins"
 ];
 
 // src/server/server.ts
@@ -5229,6 +5566,16 @@ var Server = class {
   use(...middlewares) {
     this.globalMiddlewares.push(...middlewares);
   }
+  useExpress(pathOrMiddleware, maybeMiddleware) {
+    const adapter = createExpressAdapter(this);
+    adapter.use(pathOrMiddleware, maybeMiddleware);
+  }
+  expressMiddleware(middleware2) {
+    return expressMiddleware(middleware2);
+  }
+  mountExpressRouter(basePath, expressRouter) {
+    mountExpressRouter(basePath, expressRouter);
+  }
   setErrorHandler(errorHandler) {
     this.globalMiddlewares.unshift(async (req, res, next) => {
       try {
@@ -5414,6 +5761,7 @@ var Server = class {
   }
   /**
    * Handles not found routes by delegating to custom handler or default error response
+   * Checks if the path exists for other methods and returns 405 if so
    * @internal
    */
   handleNotFound = (req, res) => {
@@ -5421,7 +5769,38 @@ var Server = class {
       this.notFoundHandler(req, res);
       return;
     }
-    const notFoundError = new RouteNotFoundError(req.url, req.method);
+    const pathname = new URL(req.url).pathname;
+    const allMethods = [
+      "GET",
+      "POST",
+      "PUT",
+      "PATCH",
+      "DELETE",
+      "OPTIONS",
+      "HEAD"
+    ];
+    const allowedMethods = [];
+    for (const method of allMethods) {
+      if (method === req.method.toUpperCase()) {
+        continue;
+      }
+      const match = router.find(method, pathname);
+      if (match && match.handler !== this.handleNotFound) {
+        allowedMethods.push(method);
+      }
+    }
+    if (allowedMethods.length > 0) {
+      res.setHeader("Allow", allowedMethods.join(", "));
+      const methodNotAllowedError = new MethodNotAllowedError(
+        pathname,
+        req.method
+      );
+      res.methodNotAllowed({
+        ...errorFactory(methodNotAllowedError)
+      });
+      return;
+    }
+    const notFoundError = new RouteNotFoundError(pathname, req.method);
     res.notFound({
       ...errorFactory(notFoundError)
     });
@@ -5437,7 +5816,8 @@ var Server = class {
       "PUT",
       "PATCH",
       "DELETE",
-      "OPTIONS"
+      "OPTIONS",
+      "HEAD"
     ];
     for (const method of methods) {
       router.addOrUpdate(method, "*", [], this.handleNotFound, {
@@ -5532,11 +5912,14 @@ exports.commandRegistry = commandRegistry;
 exports.controller = controller;
 exports.cookie = cookie;
 exports.cors = cors;
+exports.createExpressAdapter = createExpressAdapter;
 exports.createPolicyDecorator = createPolicyDecorator;
 exports.cron = cron;
 exports.defineLoggerConfig = defineLoggerConfig;
 exports.defineQueueConfiguration = defineQueueConfiguration;
 exports.del = del;
+exports.expressHandler = expressHandler;
+exports.expressMiddleware = expressMiddleware;
 exports.fileParser = fileParser;
 exports.flag = flag;
 exports.get = get;
@@ -5546,6 +5929,7 @@ exports.helmet = helmet;
 exports.json = json;
 exports.log = log;
 exports.middleware = middleware;
+exports.mountExpressRouter = mountExpressRouter;
 exports.patch = patch;
 exports.post = post;
 exports.publish = publish;