@desaubv/quik 0.0.21 → 0.0.81

package/dist/index.cjs

@@ -28,11 +28,27 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
+var src_exports = {};
+__export(src_exports, {
+  QuikRouter: () => QuikRouter,
+  Router: () => Router,
+  Server: () => Server,
+  ServerInvalidRouteError: () => ServerInvalidRouteError,
   logger: () => logger
 });
-module.exports = __toCommonJS(index_exports);
+module.exports = __toCommonJS(src_exports);
+
+// src/core/errors/serverErrors.ts
+var ServerInvalidRouteError = class extends Error {
+  constructor(path3) {
+    super(`"${path3}" is not a QuikRouter instance.`);
+  }
+};
+var ServerInvalidCronError = class extends Error {
+  constructor() {
+    super(`Invalid object, must be a QuikCron instance.`);
+  }
+};
 
 // src/core/logger.ts
 var import_node_fs = __toESM(require("fs"), 1);
@@ -60,37 +76,122 @@ var colors = Object.fromEntries(
 );
 
 // src/core/time.ts
-function dateToString(date, format) {
+function dateToString(date, format, timeZone) {
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hourCycle: "h23"
+  });
+  const parts = formatter.formatToParts(date);
+  const values = Object.fromEntries(
+    parts.filter(({ type }) => type !== "literal").map(({ type, value }) => [type, value])
+  );
   return format.replace(/(YYYY|MM|DD|hh|mm|ss)/g, (match) => {
     switch (match) {
       case "YYYY":
-        return date.getFullYear().toString();
+        return values.year || "";
       case "MM":
-        return (date.getMonth() + 1).toString().padStart(2, "0");
+        return values.month || "";
       case "DD":
-        return date.getDate().toString().padStart(2, "0");
+        return values.day || "";
       case "hh":
-        return date.getHours().toString().padStart(2, "0");
+        return values.hour || "";
       case "mm":
-        return date.getMinutes().toString().padStart(2, "0");
+        return values.minute || "";
       case "ss":
-        return date.getSeconds().toString().padStart(2, "0");
+        return values.second || "";
       default:
         return match;
     }
   });
 }
+function isValidTimeZone(timeZone) {
+  try {
+    new Intl.DateTimeFormat("en-US", {
+      timeZone
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/locales/en.json
+var en_default = {
+  logger: {
+    levels: {
+      log: "log",
+      info: "info",
+      warning: "warning",
+      error: "error",
+      debug: "debug"
+    }
+  },
+  server: {
+    name: "server",
+    start: "Server running at",
+    routers_loaded: "routers loaded",
+    crons_loaded: "crons loaded",
+    static_loaded: "static dirs loaded",
+    static_warn: "directory does not exist"
+  },
+  time: {
+    invalidTimeZone1: "Invalid time zone:",
+    invalidTimeZone2: "Using system default time zone."
+  }
+};
+
+// src/locales/es.json
+var es_default = {
+  logger: {
+    levels: {
+      log: "log",
+      info: "info",
+      warning: "advertencia",
+      error: "error",
+      debug: "depuraci\xF3n"
+    }
+  },
+  server: {
+    name: "servidor",
+    start: "Servidor corriendo en",
+    routers_loaded: "rutas cargadas",
+    crons_loaded: "crons cargados",
+    static_loaded: "carpetas estaticas cargadas",
+    static_warn: "no existe el directorio"
+  },
+  time: {
+    invalidTimeZone1: "Zona horaria inv\xE1lida:",
+    invalidTimeZone2: "Usando la zona horaria predeterminada del sistema."
+  }
+};
+
+// src/core/translator.ts
+var locales = {
+  en: en_default,
+  es: es_default
+};
+function translate(language, key) {
+  return locales[language][key];
+}
 
 // src/core/logger.ts
 var defaultConfig = {
+  language: "en",
   save: {
     logFilePath: null,
-    errorFilePath: null,
-    //"logs/error.log",
-    warningFilePath: null
+    infoFilePath: null,
+    errorFilePath: "logs/error.log",
+    warningFilePath: "logs/warning.log"
   },
   color: {
     logColor: "blue",
+    infoColor: "green",
     errorColor: "red",
     warningColor: "yellow",
     debugColor: null
@@ -135,7 +236,17 @@ function write(level, color2, file, ...content) {
 function parseContent(level, ...body) {
   let header = "";
   if (config.format.timestampFormat) {
-    const timestamp = dateToString(/* @__PURE__ */ new Date(), config.format.timestampFormat);
+    const now = /* @__PURE__ */ new Date();
+    const timeZone = config.format.timeZone;
+    let tz = timeZone;
+    if (timeZone && !isValidTimeZone(timeZone)) {
+      tz = void 0;
+    }
+    const timestamp = dateToString(
+      now,
+      config.format.timestampFormat,
+      tz
+    );
     header += `${timestamp} `;
   }
   switch (config.format.titleCase) {
@@ -167,6 +278,8 @@ function saveToFile(filePath, content) {
 }
 function mergeConfig(current, update) {
   return {
+    ...current,
+    ...update,
     save: {
       ...current.save,
       ...update.save
@@ -191,43 +304,435 @@ var logger = {
     return Object.freeze(structuredClone(config));
   },
   log(...content) {
+    const messages = translate(config.language, "logger");
     write(
-      "log",
+      messages.levels.log,
       config.color.logColor,
       config.save.logFilePath,
       ...content
     );
   },
+  info(...content) {
+    const messages = translate(config.language, "logger");
+    write(
+      messages.levels.info,
+      config.color.infoColor,
+      config.save.infoFilePath,
+      ...content
+    );
+  },
   error(...content) {
+    const messages = translate(config.language, "logger");
     write(
-      "error",
+      messages.levels.error,
       config.color.errorColor,
       config.save.errorFilePath,
       ...content
     );
   },
   warning(...content) {
+    const messages = translate(config.language, "logger");
     write(
-      "warning",
+      messages.levels.warning,
       config.color.warningColor,
       config.save.warningFilePath,
       ...content
     );
   },
   debug(...content) {
+    const messages = translate(config.language, "logger");
     write(
-      "debug",
+      messages.levels.debug,
       config.color.debugColor,
       null,
       ...content
     );
   },
+  clear() {
+    console.clear();
+  },
   custom(level, color2, file, ...content) {
     write(level, color2, file, ...content);
   }
 };
+
+// src/core/router.ts
+var import_express = require("express");
+var QuikRouter = class {
+  router;
+  pendingMiddleware = [];
+  currentPath = "";
+  constructor() {
+    this.router = (0, import_express.Router)();
+  }
+  middleware(...handlers) {
+    this.pendingMiddleware.push(...handlers);
+    return this;
+  }
+  path(path3) {
+    this.currentPath = path3;
+    return this;
+  }
+  register(method, handler) {
+    this.router[method](
+      this.currentPath,
+      ...this.pendingMiddleware,
+      async (req, res, next) => {
+        try {
+          await handler(req, res, next);
+        } catch (err) {
+          next(err);
+        }
+      }
+    );
+    this.pendingMiddleware = [];
+    this.currentPath = "";
+    return this;
+  }
+  get(handler) {
+    return this.register("get", handler);
+  }
+  post(handler) {
+    return this.register("post", handler);
+  }
+  put(handler) {
+    return this.register("put", handler);
+  }
+  patch(handler) {
+    return this.register("patch", handler);
+  }
+  delete(handler) {
+    return this.register("delete", handler);
+  }
+};
+function Router() {
+  return new QuikRouter();
+}
+
+// src/core/server.ts
+var import_express2 = __toESM(require("express"), 1);
+var import_node_http = __toESM(require("http"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var import_node_fs2 = __toESM(require("fs"), 1);
+
+// src/cron/cron.ts
+var import_node_cron = __toESM(require("node-cron"), 1);
+var import_node_cron2 = require("node-cron");
+
+// src/http/status.ts
+var Status = {
+  // 1xx Informational
+  CONTINUE: 100,
+  SWITCHING_PROTOCOLS: 101,
+  PROCESSING: 102,
+  EARLY_HINTS: 103,
+  // 2xx Success
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NON_AUTHORITATIVE_INFORMATION: 203,
+  NO_CONTENT: 204,
+  RESET_CONTENT: 205,
+  PARTIAL_CONTENT: 206,
+  MULTI_STATUS: 207,
+  ALREADY_REPORTED: 208,
+  IM_USED: 226,
+  // 3xx Redirection
+  MULTIPLE_CHOICES: 300,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  NOT_MODIFIED: 304,
+  TEMPORARY_REDIRECT: 307,
+  PERMANENT_REDIRECT: 308,
+  // 4xx Client Errors
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  PROXY_AUTHENTICATION_REQUIRED: 407,
+  REQUEST_TIMEOUT: 408,
+  CONFLICT: 409,
+  GONE: 410,
+  LENGTH_REQUIRED: 411,
+  PRECONDITION_FAILED: 412,
+  PAYLOAD_TOO_LARGE: 413,
+  URI_TOO_LONG: 414,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  RANGE_NOT_SATISFIABLE: 416,
+  EXPECTATION_FAILED: 417,
+  IM_A_TEAPOT: 418,
+  MISDIRECTED_REQUEST: 421,
+  UNPROCESSABLE_CONTENT: 422,
+  LOCKED: 423,
+  FAILED_DEPENDENCY: 424,
+  UPGRADE_REQUIRED: 426,
+  PRECONDITION_REQUIRED: 428,
+  TOO_MANY_REQUESTS: 429,
+  REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
+  UNAVAILABLE_FOR_LEGAL_REASONS: 451,
+  // 5xx Server Errors
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504,
+  HTTP_VERSION_NOT_SUPPORTED: 505,
+  VARIANT_ALSO_NEGOTIATES: 506,
+  INSUFFICIENT_STORAGE: 507,
+  LOOP_DETECTED: 508,
+  NOT_EXTENDED: 510,
+  NETWORK_AUTHENTICATION_REQUIRED: 511
+};
+
+// src/core/handlers/notFoundHandler.ts
+var QuikNotFoundHandler = (req, res) => {
+  res.status(Status.NOT_FOUND).json({
+    error: "Not Found",
+    message: `Route ${req.method} ${req.originalUrl} not found`
+  });
+};
+
+// src/core/handlers/httpErrorHandler.ts
+var QuikErrorHandler = (err, req, res, next) => {
+  logger.error(err);
+  if (res.headersSent) {
+    return next(err);
+  }
+  res.status(Status.INTERNAL_SERVER_ERROR).json({
+    error: "Internal Server Error"
+  });
+};
+
+// src/core/server.ts
+var defaultConfig2 = {
+  language: "en",
+  bodyParser: {
+    type: "json"
+  },
+  http: {
+    port: 8080
+  },
+  express: {}
+};
+var defaultNotFoundHandler = QuikNotFoundHandler;
+var defaultErrorHandler = QuikErrorHandler;
+var QuikServer = class {
+  app;
+  httpServer;
+  middlewares = [];
+  routes = {};
+  staticDirs = [];
+  crons = [];
+  notFoundHandler;
+  errorHandler;
+  config;
+  constructor() {
+    this.app = (0, import_express2.default)();
+    this.config = structuredClone(defaultConfig2);
+    this.httpServer = import_node_http.default.createServer(
+      this.app
+    );
+    this.notFoundHandler = defaultNotFoundHandler;
+    this.errorHandler = defaultErrorHandler;
+  }
+  setConfig(config2) {
+    this.config = {
+      ...this.config,
+      ...config2,
+      http: {
+        ...this.config.http,
+        ...config2.http
+      },
+      express: {
+        ...this.config.express,
+        ...config2.express
+      }
+    };
+    if (config2.timeZone && !isValidTimeZone(config2.timeZone)) {
+      const messages = translate(this.config.language, "time");
+      logger.warning(
+        `${messages.invalidTimeZone1} ${config2.timeZone}. ${messages.invalidTimeZone2}`
+      );
+    }
+    return this;
+  }
+  setNotFoundHandler(handler) {
+    if (!handler) {
+      this.notFoundHandler = void 0;
+      return this;
+    }
+    this.notFoundHandler = handler;
+    return this;
+  }
+  setErrorHandler(handler) {
+    if (!handler) {
+      this.errorHandler = void 0;
+      return this;
+    }
+    this.errorHandler = handler;
+    return this;
+  }
+  addMiddleware(...middlewares) {
+    this.middlewares.push(
+      ...middlewares
+    );
+    return this;
+  }
+  addRoute(path3, router) {
+    if (!(router instanceof QuikRouter)) {
+      throw new ServerInvalidRouteError(path3);
+    }
+    if (!path3.startsWith("/"))
+      path3 = "/" + path3;
+    this.routes[path3] = router;
+    return this;
+  }
+  #listen() {
+    const { port, host } = this.config.http;
+    const messages = translate(this.config.language, "server");
+    this.httpServer.listen(
+      port,
+      host,
+      () => {
+        logger.info(`${messages.start} ${host ?? "localhost"}:${port}`);
+      }
+    );
+    return this;
+  }
+  addCron(cron2) {
+    if (cron2.constructor.name != "QuikCron") {
+      throw new ServerInvalidCronError();
+    }
+    this.crons.push(cron2);
+    return this;
+  }
+  addStaticDir(...paths) {
+    for (const i in paths) {
+      const dir = paths[i] ?? "";
+      const dirPath = import_node_path2.default.resolve(dir);
+      const exists = import_node_fs2.default.existsSync(dirPath);
+      if (!exists) {
+        const messages = translate(this.config.language, "server");
+        logger.warning(`[ STATIC ] "${dir}" ${messages.static_warn}`);
+        continue;
+      }
+      this.staticDirs.push(...paths);
+    }
+    return this;
+  }
+  #configureHTTP() {
+    const config2 = this.config.http;
+    if (config2.timeout)
+      this.httpServer.timeout = config2.timeout;
+    if (config2.keepAlive)
+      this.httpServer.keepAliveTimeout = config2.keepAlive;
+    if (config2.maxConnections)
+      this.httpServer.maxConnections = config2.maxConnections;
+    return this;
+  }
+  #configureExpress() {
+    const config2 = this.config.express;
+    if (config2.trustProxy !== void 0) {
+      this.app.set(
+        "trust proxy",
+        config2.trustProxy
+      );
+    }
+    return this;
+  }
+  #configureMiddleware() {
+    const bodyParser = this.config.bodyParser;
+    switch (bodyParser.type) {
+      case "json":
+        this.app.use(
+          import_express2.default.json(bodyParser.options)
+        );
+        break;
+      case "urlencoded":
+        this.app.use(
+          import_express2.default.urlencoded(bodyParser.options)
+        );
+        break;
+      case "raw":
+        this.app.use(
+          import_express2.default.raw(bodyParser.options)
+        );
+        break;
+      case "text":
+        this.app.use(
+          import_express2.default.text(bodyParser.options)
+        );
+        break;
+    }
+    if (this.middlewares.length > 0)
+      this.app.use(...this.middlewares);
+    return this;
+  }
+  #configureRoutes() {
+    for (const [path3, router] of Object.entries(this.routes)) {
+      this.app.use(
+        path3,
+        router.router
+      );
+    }
+    const messages = translate(this.config.language, "server");
+    logger.info(`[ ROUTER ] ${Object.entries(this.routes).length} ${messages.routers_loaded}.`);
+    return this;
+  }
+  #loadCrons() {
+    for (const cron2 of this.crons) {
+      cron2.start();
+    }
+    const messages = translate(this.config.language, "server");
+    logger.info(`[  CRON  ] ${this.crons.length} ${messages.crons_loaded}.`);
+    return this;
+  }
+  #loadStaticDirs() {
+    for (const dir of this.staticDirs) {
+      const dirPath = import_node_path2.default.resolve(dir);
+      this.app.use(import_express2.default.static(dirPath));
+    }
+    const messages = translate(this.config.language, "server");
+    logger.info(`[ STATIC ] ${this.staticDirs.length} ${messages.static_loaded}.`);
+    return this;
+  }
+  #loadHandlers() {
+    if (this.notFoundHandler) {
+      this.app.use(
+        this.notFoundHandler
+      );
+    }
+    if (this.errorHandler) {
+      this.app.use(
+        this.errorHandler
+      );
+    }
+  }
+  start() {
+    this.#configureExpress();
+    this.#configureMiddleware();
+    this.#loadStaticDirs();
+    this.#configureRoutes();
+    this.#loadHandlers();
+    this.#loadCrons();
+    this.#configureHTTP();
+    this.#listen();
+    return this;
+  }
+};
+function Server() {
+  return new QuikServer();
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  QuikRouter,
+  Router,
+  Server,
+  ServerInvalidRouteError,
   logger
 });
 //# sourceMappingURL=index.cjs.map