@kaito-http/core 1.3.3 → 2.0.1

package/dist/index.js

@@ -1,256 +0,0 @@
-var __defProp = Object.defineProperty;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {enumerable: true, configurable: true, writable: true, value}) : obj[key] = value;
-var __assign = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-
-// src/Kaito.ts
-import "reflect-metadata";
-
-// src/types.ts
-var MetadataKeys;
-(function(MetadataKeys2) {
-  MetadataKeys2["HTTP_METHOD"] = "kaito:http:method";
-  MetadataKeys2["SCHEMA"] = "kaito:route:schema";
-  MetadataKeys2["QUERY_SCHEMA"] = "kaito:route:schema:query";
-  MetadataKeys2["CONTROLLER_PATH"] = "kaito:controller:path";
-  MetadataKeys2["AVAILABLE_ROUTE_METHODS"] = "kaito:route:methods";
-  MetadataKeys2["ROUTE_PATH"] = "kaito:route:path";
-})(MetadataKeys || (MetadataKeys = {}));
-
-// src/utils/url.ts
-var FORWARD_SLASH_CHAR_CODE = 47;
-function normalizePath(base, path) {
-  return lead(base) + lead(path);
-}
-function lead(path) {
-  return path.charCodeAt(0) === FORWARD_SLASH_CHAR_CODE ? path : "/" + path;
-}
-
-// src/utils/metadata.ts
-function readControllerMetadata(controller) {
-  const base = Reflect.getMetadata(MetadataKeys.CONTROLLER_PATH, controller.constructor);
-  const classMethods = Reflect.getMetadata(MetadataKeys.AVAILABLE_ROUTE_METHODS, controller) || [];
-  return {
-    base,
-    routes: classMethods.map((methodKey) => {
-      const method2 = Reflect.getMetadata(MetadataKeys.HTTP_METHOD, controller, methodKey);
-      const schema = Reflect.getMetadata(MetadataKeys.SCHEMA, controller, methodKey);
-      const querySchema = Reflect.getMetadata(MetadataKeys.QUERY_SCHEMA, controller, methodKey);
-      const routePath = Reflect.getMetadata(MetadataKeys.ROUTE_PATH, controller, methodKey);
-      const path = normalizePath(base, routePath);
-      return {
-        path,
-        schema,
-        method: method2,
-        routePath,
-        querySchema,
-        methodName: methodKey
-      };
-    })
-  };
-}
-
-// src/Kaito.ts
-import {App} from "@tinyhttp/app";
-
-// src/exceptions.ts
-var HttpException = class extends Error {
-  constructor(code, message) {
-    super(typeof message === "string" ? message : message.join(", "));
-    this.code = code;
-  }
-};
-var NotFoundException = class extends HttpException {
-  constructor() {
-    super(404, "That resource was not found");
-  }
-};
-
-// src/utils/errors.ts
-import {ZodError} from "zod";
-function defaultErrorHandler(err, ctx) {
-  ctx.res.setHeader("Content-Type", "application/json");
-  if (err instanceof HttpException) {
-    const body = JSON.stringify({
-      message: err.message,
-      code: err.code,
-      error: "HttpException"
-    });
-    ctx.res.writeHead(err.code, {
-      "Content-Type": "application/json"
-    });
-    ctx.res.end(body);
-  } else if (err instanceof ZodError) {
-    const body = JSON.stringify({
-      message: err.errors.map((error) => error.message).join(", "),
-      code: 422,
-      error: "ZodError"
-    });
-    ctx.res.writeHead(422, {
-      "Content-Type": "application/json"
-    });
-    ctx.res.end(body);
-  } else {
-    ctx.res.statusCode = 500;
-    const body = JSON.stringify({
-      message: "Something went wrong on our side",
-      error: err.constructor.name,
-      code: 500
-    });
-    ctx.res.end(body);
-  }
-}
-
-// src/Kaito.ts
-import {blue, bold} from "colorette";
-var Kaito = class extends App {
-  constructor(options) {
-    super({
-      settings: {
-        xPoweredBy: "kaito.cloud"
-      }
-    });
-    this.server = null;
-    this.addControllers(options.controllers);
-    this.kaitoOptions = options;
-    this.use = this.use.bind(this);
-  }
-  async parseBody(req) {
-    var _a;
-    const get = async () => {
-      let chunks = "";
-      for await (const chunk of req)
-        chunks += chunk;
-      return chunks;
-    };
-    switch ((_a = req.headers["content-type"]) == null ? void 0 : _a.toLowerCase()) {
-      case "application/json": {
-        return JSON.parse(await get());
-      }
-      default:
-        return null;
-    }
-  }
-  listen(port) {
-    const parsed = (typeof port === "string" ? parseInt(port) : port) || process.env.PORT && parseInt(process.env.PORT) || void 0;
-    this.server = super.listen(parsed, () => this.log(`starting on ${parsed}`));
-    return this.server;
-  }
-  log(...args) {
-    if (this.kaitoOptions.logging) {
-      console.log(blue(bold("[kaito/core]")), ...args);
-    }
-  }
-  close(cb) {
-    this.log("shutting down");
-    if (!this.server) {
-      this.log("trying to close a server that was never started");
-      cb == null ? void 0 : cb(new Error("Could not close a server that was never started"));
-      return;
-    }
-    try {
-      this.server.removeAllListeners();
-      this.server.close(cb);
-      this.server = null;
-      cb == null ? void 0 : cb();
-    } catch (e) {
-      cb == null ? void 0 : cb(e);
-    }
-  }
-  addControllers(controllers) {
-    for (const controller of controllers) {
-      const {routes} = readControllerMetadata(controller);
-      for (const route of routes) {
-        const {method: method2, schema, path, methodName, querySchema} = route;
-        if (method2 === "get" && schema) {
-          throw new Error(`Method ${methodName} (${path}) cannot have a schema as it is a GET only route.`);
-        }
-        const handler = controller[methodName];
-        this[method2](path, async (req, res) => {
-          var _a, _b;
-          const ip = req.headers["x-forwarded-for"] || req.connection.remoteAddress || req.ip;
-          const ctx = {
-            body: await this.parseBody(req),
-            params: req.params,
-            path: req.path,
-            query: req.query,
-            url: req.url,
-            req,
-            res,
-            ip
-          };
-          try {
-            if (querySchema) {
-              ctx.query = await querySchema.parseAsync(ctx.query);
-            }
-            if (schema) {
-              ctx.body = await schema.parseAsync(ctx.body);
-            }
-            const result = await handler(ctx);
-            res.writeHead((_a = result == null ? void 0 : result.status) != null ? _a : 200, __assign({"Content-Type": "application/json"}, result == null ? void 0 : result.headers)).end(JSON.stringify((_b = result == null ? void 0 : result.body) != null ? _b : "OK"));
-          } catch (e) {
-            if (this.kaitoOptions.onError) {
-              this.kaitoOptions.onError(e, ctx);
-            } else {
-              defaultErrorHandler(e, ctx);
-            }
-          }
-        });
-      }
-    }
-  }
-};
-
-// src/decorators.ts
-var method = (method2) => (path = "/") => (target, property) => {
-  Reflect.defineMetadata(MetadataKeys.HTTP_METHOD, method2, target, property);
-  Reflect.defineMetadata(MetadataKeys.ROUTE_PATH, path, target, property);
-  const existing = Reflect.getMetadata(MetadataKeys.AVAILABLE_ROUTE_METHODS, target) || [];
-  Reflect.defineMetadata(MetadataKeys.AVAILABLE_ROUTE_METHODS, [...existing, property], target);
-};
-var Schema = (schema) => (target, property) => {
-  Reflect.defineMetadata(MetadataKeys.SCHEMA, schema, target, property);
-};
-var QuerySchema = (schema) => (target, property) => {
-  Reflect.defineMetadata(MetadataKeys.QUERY_SCHEMA, schema, target, property);
-};
-var Controller = (path = "/") => (target) => {
-  if (!path.startsWith("/")) {
-    throw new Error(`Path must start with / for ${target}`);
-  }
-  Reflect.defineMetadata(MetadataKeys.CONTROLLER_PATH, path, target);
-};
-var Get = method("get");
-var Post = method("post");
-var Patch = method("patch");
-var Put = method("put");
-var Delete = method("delete");
-var Method = (m) => method(m);
-export {
-  Controller,
-  Delete,
-  Get,
-  HttpException,
-  Kaito,
-  MetadataKeys,
-  Method,
-  NotFoundException,
-  Patch,
-  Post,
-  Put,
-  QuerySchema,
-  Schema,
-  method
-};