@desaubv/quik 0.0.4 → 0.0.7

package/dist/index.d.cts

@@ -1,17 +1,24 @@
 import express, { Router as Router$1, RequestHandler, Express } from 'express';
 import { Server as Server$1 } from 'node:http';
+import { Q as QuikCron } from './cron-BLi976po.cjs';
+
+declare class ServerInvalidRouteError extends Error {
+    constructor(path: string);
+}
 
 type ConfigValue = string | null | false;
 type Cases = "uppercase" | "lowercase" | "capitalize" | "none" | null;
 type ColorName = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white";
 type ColorValue = ColorName | null;
 type SaveConfig = {
+    infoFilePath: ConfigValue;
     logFilePath: ConfigValue;
     errorFilePath: ConfigValue;
     warningFilePath: ConfigValue;
 };
 type ColorConfig = {
     logColor: ColorValue;
+    infoColor: ColorValue;
     errorColor: ColorValue;
     warningColor: ColorValue;
     debugColor: ColorValue;
@@ -21,8 +28,10 @@ type Formatconfig = {
     titleCase: Cases;
     prefix?: string;
     suffix?: string;
+    timeZone?: string;
 };
 type LoggerConfig = {
+    language: Language;
     save: SaveConfig;
     color: ColorConfig;
     format: Formatconfig;
@@ -36,13 +45,15 @@ declare const logger: {
     setConfig(newConfig: PartialConfig): void;
     config(): Readonly<LoggerConfig>;
     log(...content: unknown[]): void;
+    info(...content: unknown[]): void;
     error(...content: unknown[]): void;
     warning(...content: unknown[]): void;
     debug(...content: unknown[]): void;
+    clear(): void;
     custom(level: string, color: ColorName | null | false, file: ConfigValue, ...content: unknown[]): void;
 };
 
-declare class QuickRouter {
+declare class QuikRouter {
     readonly router: Router$1;
     private pendingMiddleware;
     private currentPath;
@@ -56,9 +67,8 @@ declare class QuickRouter {
     patch(handler: RequestHandler): this;
     delete(handler: RequestHandler): this;
 }
-declare function Router(): QuickRouter;
+declare function Router(): QuikRouter;
 
-type Language = "en" | "es";
 type JsonOptions = Parameters<typeof express.json>[0];
 type UrlencodedOptions = Parameters<typeof express.urlencoded>[0];
 type RawOptions = Parameters<typeof express.raw>[0];
@@ -89,25 +99,27 @@ type ExpressConfig = {
 };
 type QuikServerConfig = {
     language: Language;
+    timeZone?: string;
     bodyParser: BodyParserConfig;
     http: HTTPConfig;
     express: ExpressConfig;
 };
-type RoutingDict = Record<string, QuickRouter>;
+type RoutingDict = Record<string, QuikRouter>;
 declare class QuikServer {
     #private;
     app: Express;
-    httpQuikServer: Server$1;
+    httpServer: Server$1;
     middlewares: RequestHandler[];
     routes: RoutingDict;
+    crons: QuikCron[];
     config: QuikServerConfig;
     constructor();
-    configure(config: Partial<QuikServerConfig>): this;
-    middleware(...middlewares: RequestHandler[]): this;
-    route(path: string, router: QuickRouter): this;
-    listen(): this;
+    setConfig(config: Partial<QuikServerConfig>): this;
+    addMiddleware(...middlewares: RequestHandler[]): this;
+    addRoute(path: string, router: QuikRouter): this;
+    addCron(cron: QuikCron): this;
     start(): this;
 }
 declare function Server(): QuikServer;
 
-export { QuickRouter, Router, Server, logger };
+export { QuikRouter, Router, Server, ServerInvalidRouteError, logger };

package/dist/index.d.ts

@@ -1,17 +1,24 @@
 import express, { Router as Router$1, RequestHandler, Express } from 'express';
 import { Server as Server$1 } from 'node:http';
+import { Q as QuikCron } from './cron-BLi976po.js';
+
+declare class ServerInvalidRouteError extends Error {
+    constructor(path: string);
+}
 
 type ConfigValue = string | null | false;
 type Cases = "uppercase" | "lowercase" | "capitalize" | "none" | null;
 type ColorName = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white";
 type ColorValue = ColorName | null;
 type SaveConfig = {
+    infoFilePath: ConfigValue;
     logFilePath: ConfigValue;
     errorFilePath: ConfigValue;
     warningFilePath: ConfigValue;
 };
 type ColorConfig = {
     logColor: ColorValue;
+    infoColor: ColorValue;
     errorColor: ColorValue;
     warningColor: ColorValue;
     debugColor: ColorValue;
@@ -21,8 +28,10 @@ type Formatconfig = {
     titleCase: Cases;
     prefix?: string;
     suffix?: string;
+    timeZone?: string;
 };
 type LoggerConfig = {
+    language: Language;
     save: SaveConfig;
     color: ColorConfig;
     format: Formatconfig;
@@ -36,13 +45,15 @@ declare const logger: {
     setConfig(newConfig: PartialConfig): void;
     config(): Readonly<LoggerConfig>;
     log(...content: unknown[]): void;
+    info(...content: unknown[]): void;
     error(...content: unknown[]): void;
     warning(...content: unknown[]): void;
     debug(...content: unknown[]): void;
+    clear(): void;
     custom(level: string, color: ColorName | null | false, file: ConfigValue, ...content: unknown[]): void;
 };
 
-declare class QuickRouter {
+declare class QuikRouter {
     readonly router: Router$1;
     private pendingMiddleware;
     private currentPath;
@@ -56,9 +67,8 @@ declare class QuickRouter {
     patch(handler: RequestHandler): this;
     delete(handler: RequestHandler): this;
 }
-declare function Router(): QuickRouter;
+declare function Router(): QuikRouter;
 
-type Language = "en" | "es";
 type JsonOptions = Parameters<typeof express.json>[0];
 type UrlencodedOptions = Parameters<typeof express.urlencoded>[0];
 type RawOptions = Parameters<typeof express.raw>[0];
@@ -89,25 +99,27 @@ type ExpressConfig = {
 };
 type QuikServerConfig = {
     language: Language;
+    timeZone?: string;
     bodyParser: BodyParserConfig;
     http: HTTPConfig;
     express: ExpressConfig;
 };
-type RoutingDict = Record<string, QuickRouter>;
+type RoutingDict = Record<string, QuikRouter>;
 declare class QuikServer {
     #private;
     app: Express;
-    httpQuikServer: Server$1;
+    httpServer: Server$1;
     middlewares: RequestHandler[];
     routes: RoutingDict;
+    crons: QuikCron[];
     config: QuikServerConfig;
     constructor();
-    configure(config: Partial<QuikServerConfig>): this;
-    middleware(...middlewares: RequestHandler[]): this;
-    route(path: string, router: QuickRouter): this;
-    listen(): this;
+    setConfig(config: Partial<QuikServerConfig>): this;
+    addMiddleware(...middlewares: RequestHandler[]): this;
+    addRoute(path: string, router: QuikRouter): this;
+    addCron(cron: QuikCron): this;
     start(): this;
 }
 declare function Server(): QuikServer;
 
-export { QuickRouter, Router, Server, logger };
+export { QuikRouter, Router, Server, ServerInvalidRouteError, logger };

package/dist/index.js

@@ -1,3 +1,15 @@
+// src/errors/serverError.ts
+var ServerInvalidRouteError = class extends Error {
+  constructor(path2) {
+    super(`"${path2}" is not a QuikRouter instance.`);
+  }
+};
+var ServerInvalidCronError = class extends Error {
+  constructor() {
+    super(`Invalid object, must be a QuikCron instance.`);
+  }
+};
+
 // src/core/logger.ts
 import fs from "fs";
 import path from "path";
@@ -24,37 +36,118 @@ 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"
+  },
+  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"
+  },
+  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 +192,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 +234,8 @@ function saveToFile(filePath, content) {
 }
 function mergeConfig(current, update) {
   return {
+    ...current,
+    ...update,
     save: {
       ...current.save,
       ...update.save
@@ -155,37 +260,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,7 +314,7 @@ var logger = {
 
 // src/core/router.ts
 import { Router as ExpressRouter } from "express";
-var QuickRouter = class {
+var QuikRouter = class {
   router;
   pendingMiddleware = [];
   currentPath = "";
@@ -241,37 +362,16 @@ var QuickRouter = class {
   }
 };
 function Router() {
-  return new QuickRouter();
+  return new QuikRouter();
 }
 
 // src/core/server.ts
 import express from "express";
 import http from "http";
 
-// src/locales/en.json
-var en_default = {
-  server: {
-    name: "server",
-    start: "Server running at"
-  }
-};
-
-// src/locales/es.json
-var es_default = {
-  server: {
-    name: "servidor",
-    start: "Servidor corriendo en"
-  }
-};
-
-// src/core/translator.ts
-var locales = {
-  en: en_default,
-  es: es_default
-};
-function translate(language, key) {
-  return locales[language][key];
-}
+// src/cron/cron.ts
+import cron from "node-cron";
+import "node-cron";
 
 // src/core/server.ts
 var defaultConfig2 = {
@@ -286,18 +386,19 @@ var defaultConfig2 = {
 };
 var QuikServer = class {
   app;
-  httpQuikServer;
+  httpServer;
   middlewares = [];
   routes = {};
+  crons = [];
   config;
   constructor() {
     this.app = express();
     this.config = structuredClone(defaultConfig2);
-    this.httpQuikServer = http.createServer(
+    this.httpServer = http.createServer(
       this.app
     );
   }
-  configure(config2) {
+  setConfig(config2) {
     this.config = {
       ...this.config,
       ...config2,
@@ -310,38 +411,56 @@ var QuikServer = class {
         ...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;
   }
-  middleware(...middlewares) {
+  addMiddleware(...middlewares) {
     this.middlewares.push(
       ...middlewares
     );
     return this;
   }
-  route(path2, router) {
+  addRoute(path2, router) {
+    if (!(router instanceof QuikRouter)) {
+      throw new ServerInvalidRouteError(path2);
+    }
+    if (!path2.startsWith("/"))
+      path2 = "/" + path2;
     this.routes[path2] = router;
     return this;
   }
-  listen() {
+  #listen() {
     const { port, host } = this.config.http;
     const messages = translate(this.config.language, "server");
-    this.httpQuikServer.listen(
+    this.httpServer.listen(
       port,
       host,
       () => {
-        logger.custom(messages.name, "green", null, `${messages.start} ${host ?? "localhost"}:${port}`);
+        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;
+  }
   #configureHTTP() {
     const config2 = this.config.http;
     if (config2.timeout)
-      this.httpQuikServer.timeout = config2.timeout;
+      this.httpServer.timeout = config2.timeout;
     if (config2.keepAlive)
-      this.httpQuikServer.keepAliveTimeout = config2.keepAlive;
+      this.httpServer.keepAliveTimeout = config2.keepAlive;
     if (config2.maxConnections)
-      this.httpQuikServer.maxConnections = config2.maxConnections;
+      this.httpServer.maxConnections = config2.maxConnections;
     return this;
   }
   #configureExpress() {
@@ -389,14 +508,25 @@ var QuikServer = class {
         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;
   }
   start() {
     this.#configureExpress();
     this.#configureMiddleware();
     this.#configureRoutes();
+    this.#loadCrons();
     this.#configureHTTP();
-    this.listen();
+    this.#listen();
     return this;
   }
 };
@@ -404,9 +534,10 @@ function Server() {
   return new QuikServer();
 }
 export {
-  QuickRouter,
+  QuikRouter,
   Router,
   Server,
+  ServerInvalidRouteError,
   logger
 };
 //# sourceMappingURL=index.js.map