@desaubv/quik 0.0.31 → 0.1.0

package/dist/index.js

@@ -1,3 +1,25 @@
+// 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.`);
+  }
+};
+var ServerInvalidWebSocketError = class extends Error {
+  constructor() {
+    super(`Invalid object, must be a QuikWebSocket instance.`);
+  }
+};
+var ServerInvalidSocketIOError = class extends Error {
+  constructor() {
+    super(`Invalid object, must be a QuikSocketIO instance.`);
+  }
+};
+
 // src/core/logger.ts
 import fs from "fs";
 import path from "path";
@@ -24,37 +46,128 @@ 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",
+    socket_loaded: "socket loaded",
+    static_loaded: "static dirs loaded",
+    views_loaded: "views dirs loaded",
+    static_warn: "directory does not exist",
+    view_warn: "file don't 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",
+    socket_loaded: "socket cargado",
+    static_loaded: "carpetas estaticas cargadas",
+    views_loaded: "carpetas de vistas cargadas",
+    static_warn: "no existe el directorio",
+    view_warn: "no existe el archivo"
+  },
+  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
@@ -99,7 +212,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) {
@@ -131,6 +254,8 @@ function saveToFile(filePath, content) {
 }
 function mergeConfig(current, update) {
   return {
+    ...current,
+    ...update,
     save: {
       ...current.save,
       ...update.save
@@ -155,37 +280,53 @@ 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);
   }
@@ -193,10 +334,10 @@ var logger = {
 
 // src/core/router.ts
 import { Router as ExpressRouter } from "express";
-var Router = class {
+var QuikRouter = class {
   router;
   pendingMiddleware = [];
-  pnedingPath = "";
+  currentPath = "";
   constructor() {
     this.router = ExpressRouter();
   }
@@ -204,13 +345,13 @@ var Router = class {
     this.pendingMiddleware.push(...handlers);
     return this;
   }
-  path(path2) {
-    this.pnedingPath = path2;
+  path(path3) {
+    this.currentPath = path3;
     return this;
   }
   register(method, handler) {
     this.router[method](
-      this.pnedingPath,
+      this.currentPath,
       ...this.pendingMiddleware,
       async (req, res, next) => {
         try {
@@ -221,7 +362,7 @@ var Router = class {
       }
     );
     this.pendingMiddleware = [];
-    this.pnedingPath = "";
+    this.currentPath = "";
     return this;
   }
   get(handler) {
@@ -240,8 +381,409 @@ var Router = class {
     return this.register("delete", handler);
   }
 };
+function Router() {
+  return new QuikRouter();
+}
+
+// src/core/server.ts
+import express from "express";
+import http from "http";
+import path2 from "path";
+import fs2 from "fs";
+
+// src/cron/cron.ts
+import cron from "node-cron";
+import "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 = [];
+  ws;
+  io;
+  viewDirs = [];
+  notFoundHandler;
+  errorHandler;
+  config;
+  constructor() {
+    this.app = express();
+    this.config = structuredClone(defaultConfig2);
+    this.httpServer = http.createServer(
+      this.app
+    );
+    this.io = void 0;
+    this.ws = void 0;
+    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;
+  }
+  addViewDir(...paths) {
+    for (const view of paths) {
+      const viewPath = path2.resolve(view);
+      if (!fs2.existsSync(viewPath)) {
+        const messages = translate(this.config.language, "server");
+        logger.warning(
+          `[ VIEW ] "${view}" ${messages.view_warn}`
+        );
+        continue;
+      }
+      this.viewDirs.push(viewPath);
+    }
+    return this;
+  }
+  addCron(cron2) {
+    if (cron2.constructor.name != "QuikCron") {
+      throw new ServerInvalidCronError();
+    }
+    this.crons.push(cron2);
+    return this;
+  }
+  useWebSocket(ws) {
+    if (ws.constructor.name != "QuikWebSocket") {
+      throw new ServerInvalidWebSocketError();
+    }
+    this.ws = ws;
+    return this;
+  }
+  useSocketIO(socket) {
+    if (socket?.constructor.name != "QuikSocketIO") {
+      throw new ServerInvalidSocketIOError();
+    }
+    this.io = socket;
+    return this;
+  }
+  addStaticDir(...paths) {
+    for (const dir of paths) {
+      const dirPath = path2.resolve(dir);
+      if (!fs2.existsSync(dirPath)) {
+        const messages = translate(this.config.language, "server");
+        logger.warning(
+          `[ STATIC ] "${dir}" ${messages.static_warn}`
+        );
+        continue;
+      }
+      this.staticDirs.push(dirPath);
+    }
+    return this;
+  }
+  #configureExpress() {
+    const config2 = this.config.express;
+    const { name, env, trustProxy, viewEngine } = config2;
+    if (trustProxy) {
+      this.app.set(
+        "trust proxy",
+        config2.trustProxy
+      );
+    }
+    if (env) {
+      this.app.set("env", config2.env);
+    }
+    if (name) {
+      this.app.set("name", name);
+    }
+    if (viewEngine) {
+      this.app.set("view engine", viewEngine);
+    }
+    if (this.viewDirs.length > 0) {
+      const messages = translate(this.config.language, "server");
+      logger.info(`[  VIEWS  ] ${this.viewDirs.length} ${messages.views_loaded}.`);
+      this.app.set("views", this.viewDirs);
+    }
+    return this;
+  }
+  #configureMiddleware() {
+    const bodyParser = this.config.bodyParser;
+    switch (bodyParser.type) {
+      case "json":
+        this.app.use(
+          express.json(bodyParser.options)
+        );
+        break;
+      case "urlencoded":
+        this.app.use(
+          express.urlencoded(bodyParser.options)
+        );
+        break;
+      case "raw":
+        this.app.use(
+          express.raw(bodyParser.options)
+        );
+        break;
+      case "text":
+        this.app.use(
+          express.text(bodyParser.options)
+        );
+        break;
+    }
+    if (this.middlewares.length > 0)
+      this.app.use(...this.middlewares);
+    return this;
+  }
+  #loadRoutes() {
+    for (const [path3, router] of Object.entries(this.routes)) {
+      this.app.use(
+        path3,
+        router.router
+      );
+    }
+    const messages = translate(this.config.language, "server");
+    if (Object.entries(this.routes).length > 0) {
+      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");
+    if (this.crons.length > 0) {
+      logger.info(`[  CRON  ] ${this.crons.length} ${messages.crons_loaded}.`);
+    }
+    return this;
+  }
+  #loadWS() {
+    if (this.ws) {
+      this.ws.start(this.httpServer);
+    }
+    const messages = translate(this.config.language, "server");
+    if (this.ws) {
+      logger.info(`[   WS   ] ${messages.socket_loaded}.`);
+    }
+    return this;
+  }
+  #loadIO() {
+    if (this.io) {
+      this.io.start(this.httpServer);
+    }
+    const messages = translate(this.config.language, "server");
+    if (this.io) {
+      logger.info(`[ SOCKET ] ${messages.socket_loaded}.`);
+    }
+    return this;
+  }
+  #loadStaticDirs() {
+    for (const dir of this.staticDirs) {
+      const dirPath = path2.resolve(dir);
+      this.app.use(express.static(dirPath));
+    }
+    const messages = translate(this.config.language, "server");
+    if (this.staticDirs.length > 0) {
+      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
+      );
+    }
+  }
+  #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;
+  }
+  #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;
+  }
+  start() {
+    this.#configureExpress();
+    this.#configureMiddleware();
+    this.#loadStaticDirs();
+    this.#loadRoutes();
+    this.#loadHandlers();
+    this.#loadCrons();
+    this.#loadWS();
+    this.#loadIO();
+    this.#configureHTTP();
+    this.#listen();
+    return this;
+  }
+};
+function Server() {
+  return new QuikServer();
+}
 export {
+  QuikRouter,
   Router,
+  Server,
+  ServerInvalidRouteError,
   logger
 };
 //# sourceMappingURL=index.js.map