✨ feat(Watch): New watch mode added, no more db connection waits :)

Author: GroophyLifefor

deno.json

@@ -1,11 +1,12 @@
 {
   "name": "@murat/yelix",
   "exports": "./mod.ts",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "license": "MIT",
   "nodeModulesDir": "auto",
   "tasks": {
-    "dev": "deno run --watch --allow-net --allow-read --allow-env ./testing/main.ts",
+    "dev": "deno run --allow-net --allow-read --allow-env ./testing/main.ts",
+    "dev:watch": "deno run --watch --allow-net --allow-read --allow-env ./testing/main.ts",
     "bump:patch": "deno run --allow-read --allow-write bump_version.ts patch",
     "bump:minor": "deno run --allow-read --allow-write bump_version.ts minor",
     "bump:major": "deno run --allow-read --allow-write bump_version.ts major",

deploy.bat

@@ -3,8 +3,8 @@
 echo.
 echo ------------------------------
 echo TESTING, I know no one likes to test, but it's important
-echo $ deno test
-deno test
+echo $ deno task test
+deno task test
 :testing_question
 set /p test="TESTING - Can I continue? (y/n/kill): "
 if "%test%"=="y" goto testing_continue

jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@murat/yelix",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "license": "MIT",
   "exports": "./mod.ts",
   "imports": {

src/api/endpoints/loadEndpoints.ts

@@ -17,10 +17,18 @@ async function loadEndpointsFromFolder(yelix: Yelix, _path: string) {
   for (const file of files) {
     if (file.isFile) {
       yelix.log(`📄 Processing file: ${file.name}`);
-      const globePath = "file:" + path.join(_path, file.name);
-      const endpoint = await import(globePath);
-      yelix.log(`✅ Successfully imported endpoint from ${file.name}`);
-      endpoints.push(endpoint);
+      // Add cache busting query parameter to force reload
+      const cacheBuster = `?cacheBust=${Date.now()}`;
+      const globePath = "file:" + path.join(_path, file.name) + cacheBuster;
+
+      try {
+        // Force reload by bypassing cache
+        const endpoint = await import(globePath);
+        yelix.log(`✅ Successfully imported endpoint from ${file.name}`);
+        endpoints.push(endpoint);
+      } catch (err) {
+        yelix.warn(`Failed to import ${file.name}: ${err}`);
+      }
     }
   }
 

src/api/endpoints/serveEndpoints.ts

@@ -8,6 +8,7 @@ import type {
 } from "@/src/OpenAPI/index.ts";
 import type { Yelix } from "@/src/core/Yelix.ts";
 import type { NewEndpointParams } from "@/src/OpenAPI/index.ts";
+import type { DocsManager } from "@/src/core/DocsManager.ts";
 
 interface MethodMap {
   [key: string]: (path: string, ...handlers: H[]) => void;
@@ -28,7 +29,11 @@ function createMethodMap(app: Hono): MethodMap {
   };
 }
 
-function serveEndpoints(yelix: Yelix, endpointList: ParsedEndpoint[]) {
+function serveEndpoints(
+  yelix: Yelix,
+  docsManager: DocsManager,
+  endpointList: ParsedEndpoint[],
+) {
   const methodMap = createMethodMap(yelix.app);
 
   for (const endpoint of endpointList) {
@@ -54,7 +59,7 @@ function serveEndpoints(yelix: Yelix, endpointList: ParsedEndpoint[]) {
         query: endpoint.openAPI?.query ?? {},
       };
 
-      if (!isHide) yelix.YelixOpenAPI?.addNewEndpoint(newAPIDoc);
+      if (!isHide) docsManager.YelixOpenAPI?.addNewEndpoint(newAPIDoc);
 
       methodMap[method.method](endpoint.path, ...middlewares, async (c) => {
         const res = await method.handler(c);

src/api/indexPage/getHtml.ts

@@ -1,23 +1,23 @@
 import type { Ctx, Yelix } from "@/mod.ts";
+import type { DocsManager } from "@/src/core/DocsManager.ts";
 
 type IndexPageParams = {
   yelix: Yelix;
+  docsManager: DocsManager;
   docsPath?: string;
 };
 
 export function serveIndexPage(params: IndexPageParams) {
   params.yelix.app.notFound((ctx: Ctx) => {
     if (ctx.req.path === "/") {
-      return ctx.html(getHtml({ docsPath: params.yelix.docsPath }), 200);
+      return ctx.html(getHtml({ docsPath: params.docsManager.docsPath }), 200);
     }
 
     return new Response("Not Found", { status: 404 });
   });
 }
 
-function getHtml({ docsPath }: {
-  docsPath?: string;
-}): string {
+function getHtml({ docsPath }: { docsPath?: string }): string {
   return /*html*/ `
 <!DOCTYPE html>
 <html lang="en">

src/core/DocsManager.ts

@@ -0,0 +1,54 @@
+import type { Hono } from "hono";
+import { apiReference } from "npm:@scalar/hono-api-reference@0.5.172";
+import { YelixOpenAPI } from "@/src/OpenAPI/index.ts";
+import type { InitOpenAPIParams } from "@/src/types/types.d.ts";
+
+export class DocsManager {
+  private app: Hono;
+  YelixOpenAPI?: YelixOpenAPI;
+  docsPath?: string;
+
+  constructor(app: Hono) {
+    this.app = app;
+  }
+
+  initOpenAPI(
+    config: InitOpenAPIParams,
+  ): { title: string; description: string } {
+    const path = config.path || "/docs";
+    this.docsPath = path;
+
+    this.YelixOpenAPI = new YelixOpenAPI({
+      title: config.title || "Yelix API",
+      version: config.version || "1.0.0",
+      description: config.description || "Yelix API Documentation",
+    });
+
+    this.app.get("/yelix-openapi-raw", (c) => {
+      return c.json(this.YelixOpenAPI!.getJSON(), 200);
+    });
+
+    const defaultConfig = {
+      theme: "saturn",
+      favicon: "/public/favicon.ico",
+      pageTitle: "Yelix API Docs",
+    };
+    const apiReferenceConfig = Object.assign(
+      defaultConfig,
+      config.apiReferenceConfig,
+    );
+
+    apiReferenceConfig.spec = { url: "/yelix-openapi-raw" };
+
+    this.app.get(path, apiReference(apiReferenceConfig));
+
+    return {
+      title: "OpenAPI Docs",
+      description: path,
+    };
+  }
+
+  getOpenAPI() {
+    return this.YelixOpenAPI;
+  }
+}

src/core/Logger.ts

@@ -0,0 +1,49 @@
+// deno-lint-ignore-file no-explicit-any
+import { yelix_log, yelixClientLog } from "@/src/utils/logging.ts";
+import type { Yelix } from "@/src/core/Yelix.ts";
+
+export class Logger {
+  private debug: boolean;
+  private yelix: Yelix;
+
+  constructor(yelix: Yelix, debug: boolean) {
+    this.debug = debug;
+    this.yelix = yelix;
+  }
+
+  clientLog(...params: any): void {
+    yelixClientLog(...params);
+  }
+
+  log(...params: any): void {
+    const props = [
+      "%c INFO %c",
+      "background-color: white; color: black;",
+      "background-color: inherit",
+      ...params,
+    ];
+    yelix_log(this.yelix, ...props);
+  }
+
+  warn(...params: any): void {
+    const props = [
+      "%c WARN %c",
+      "background-color: orange;",
+      "background-color: inherit",
+      ...params,
+    ];
+    yelix_log(this.yelix, ...props);
+  }
+
+  throw(...params: any): void {
+    const props = [
+      "%c WARN %c",
+      "background-color: red;",
+      "background-color: inherit",
+      ...params,
+    ];
+    yelix_log(this.yelix, ...props);
+    console.error("❌", ...params);
+    throw new Error(...params);
+  }
+}

src/core/ServerManager.ts

@@ -0,0 +1,111 @@
+// deno-lint-ignore-file no-explicit-any
+import { yelixClientLog } from "@/src/utils/logging.ts";
+import type { Logger } from "./Logger.ts";
+import version from "@/version.ts";
+import type { Yelix } from "@/src/core/Yelix.ts";
+
+export class ServerManager {
+  private yelix: Yelix;
+  private server: any;
+  private sigintListener: any;
+  private servedInformations: { title: string; description: string }[] = [];
+  private logger: Logger;
+
+  constructor(yelix: Yelix, logger: Logger) {
+    this.yelix = yelix;
+    this.logger = logger;
+  }
+
+  private addLocalInformationToInitiate(addr: any) {
+    const hostname = addr.hostname;
+    const isLocalhost = hostname === "0.0.0.0";
+    const port = addr.port;
+    const addrStr = isLocalhost
+      ? `http://localhost:${port}`
+      : `http://${hostname}:${port}`;
+
+    this.servedInformations.unshift({
+      title: "Local",
+      description: addrStr,
+    });
+  }
+
+  onListen(addr: any) {
+    this.addLocalInformationToInitiate(addr);
+
+    const packageVersion = version;
+
+    if (this.yelix.isFirstServe) {
+      this.logger.clientLog();
+      this.logger.clientLog(
+        "  %c 𝕐 Yelix %c" + packageVersion,
+        "color: orange;",
+        "color: inherit",
+      );
+      const maxLength = Math.max(
+        ...this.servedInformations.map((i) => i.title.length),
+      );
+      this.servedInformations.forEach((info) => {
+        this.logger.clientLog(
+          `   - ${info.title.padEnd(maxLength)}:   ${info.description}`,
+        );
+      });
+      this.logger.clientLog();
+    }
+  }
+
+  addServedInformation(info: { title: string; description: string }) {
+    this.servedInformations.push(info);
+  }
+
+  startServer(port: number, appFetch: any) {
+    this.sigintListener = () => {
+      yelixClientLog("interrupted!");
+      this.kill();
+      Deno.exit();
+    };
+
+    Deno.addSignalListener("SIGINT", this.sigintListener);
+
+    return new Promise<void>((resolve) => {
+      this.server = Deno.serve(
+        { port, onListen: (addr: any) => this.onListen(addr) },
+        appFetch,
+      );
+      resolve();
+    });
+  }
+
+  async kill(forceAfterMs = 3000) {
+    if (this.server) {
+      try {
+        let timeoutId = 0;
+        const timeoutPromise = new Promise<void>((resolve) => {
+          timeoutId = setTimeout(() => {
+            this.logger.warn("Server shutdown timed out, forcing close");
+            resolve();
+          }, forceAfterMs);
+        });
+
+        const shutdownPromise = this.server.shutdown();
+
+        // Race between normal shutdown and timeout
+        await Promise.race([shutdownPromise, timeoutPromise]);
+        clearTimeout(timeoutId);
+
+        Deno.removeSignalListener("SIGINT", this.sigintListener);
+
+        // Clear the reference to prevent any lingering issues
+        this.server = null;
+      } catch (error) {
+        this.logger.warn("Error during server shutdown:", error);
+        Deno.removeSignalListener("SIGINT", this.sigintListener);
+        this.server = null;
+      }
+    } else {
+      yelixClientLog(
+        "You tried to kill the server but it was not running. This is fine.",
+      );
+    }
+  }
+}