owebjs 1.3.7 → 1.3.9

package/dist/utils/assignRoutes.js

@@ -12,7 +12,14 @@ import generateFunctionFromTypescript from './generateFunctionFromTypescript.js'
 import { readdirSync } from "node:fs";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 let matcherOverrides = {};
-let routeFunctions = {};
+let routeFunctions = {
+  get: {},
+  post: {},
+  put: {},
+  delete: {},
+  patch: {},
+  options: {}
+};
 const temporaryRequests = {
   get: {},
   post: {},
@@ -71,7 +78,7 @@ const applyRouteHMR = /* @__PURE__ */ __name(async (oweb, op, workingDir, fallba
   if (op === "new-file") {
     const start = Date.now();
     const files = await walk(workingDir, [], fallbackDir);
-    const routes = await generateRoutes(files);
+    const routes = await generateRoutes(files, path2);
     routesCache = routes;
     const f = routes.find((x) => x.fileInfo.filePath == path2);
     temporaryRequests[f.method.toLowerCase()][f.url] = inner(oweb, f);
@@ -80,29 +87,34 @@ const applyRouteHMR = /* @__PURE__ */ __name(async (oweb, op, workingDir, fallba
   } else if (op === "modify-file") {
     const start = Date.now();
     const files = await walk(workingDir, [], fallbackDir);
-    const routes = await generateRoutes(files);
+    const routes = await generateRoutes(files, path2);
     routesCache = routes;
     const f = routes.find((x) => x.fileInfo.filePath == path2);
     if (f.url in temporaryRequests[f.method.toLowerCase()]) {
       temporaryRequests[f.method.toLowerCase()][f.url] = inner(oweb, f);
     } else {
-      routeFunctions[f.fileInfo.filePath] = inner(oweb, f);
+      routeFunctions[f.method.toLowerCase()][f.url] = inner(oweb, f);
     }
     const end = Date.now() - start;
     success(`Route ${f.method.toUpperCase()}:${f.url} reloaded in ${end}ms`, "HMR");
   } else if (op === "delete-file") {
     const start = Date.now();
-    const f = routesCache.find((x) => x.fileInfo.filePath == path2);
+    const newFilePath = path2.slice(workingDir.length).replaceAll("\\", "/").slice(0, -3);
+    let builded = buildRouteURL(newFilePath);
+    if (builded.url.endsWith("/index")) {
+      builded.url = builded.url.slice(0, -"/index".length);
+    }
+    const f = routesCache.find((x) => x.method == builded.method && x.url == builded.url);
     if (f.url in temporaryRequests[f.method.toLowerCase()]) {
       delete temporaryRequests[f.method.toLowerCase()][f.url];
     } else {
-      delete routeFunctions[f.fileInfo.filePath];
+      delete routeFunctions[f.method.toLowerCase()][f.url];
     }
     const end = Date.now() - start;
     success(`Route ${f.method.toUpperCase()}:${f.url} removed in ${end}ms`, "HMR");
   }
 }, "applyRouteHMR");
-const generateRoutes = /* @__PURE__ */ __name(async (files) => {
+const generateRoutes = /* @__PURE__ */ __name(async (files, onlyGenerateFn) => {
   const routes = [];
   for (const file of files) {
     const parsedFile = path.parse(file.rel);
@@ -120,9 +132,12 @@ const generateRoutes = /* @__PURE__ */ __name(async (files) => {
       });
       continue;
     }
-    const cacheBuster = `?t=${Date.now()}`;
-    const def = await import(packageURL + cacheBuster);
-    const routeFuncs = def.default;
+    let routeFuncs;
+    if (!(onlyGenerateFn && file.filePath !== onlyGenerateFn)) {
+      const cacheBuster = `?t=${Date.now()}`;
+      const def = await import(packageURL + cacheBuster);
+      routeFuncs = def.default;
+    }
     routes.push({
       url: route.url,
       method: route.method,
@@ -205,12 +220,12 @@ __name(send404, "send404");
 function assignSpecificRoute(oweb, route) {
   if (!route.fn) return;
   const routeFunc = new route.fn();
-  routeFunctions[route.fileInfo.filePath] = inner(oweb, route);
+  routeFunctions[route.method][route.url] = inner(oweb, route);
   oweb[route.method](route.url, routeFunc._options || {}, function(req, res) {
-    if (routeFunctions[route.fileInfo.filePath]) {
-      return routeFunctions[route.fileInfo.filePath](req, res);
+    if (routeFunctions[route.method][route.url]) {
+      return routeFunctions[route.method][route.url](req, res);
     } else {
-      const vals = temporaryRequests[req.method.toLowerCase()];
+      const vals = temporaryRequests[route.method];
       const keys = Object.keys(vals);
       if (!vals || !keys.length) {
         return send404(req, res);

package/dist/utils/generateFunctionFromTypescript.js

@@ -4,44 +4,49 @@ import {
 import { parse } from "@babel/parser";
 import traverse from "@babel/traverse";
 import generate from "@babel/generator";
+import * as babel from "@babel/core";
 import path from "node:path";
-import babel from "@babel/core";
 import { pathToFileURL } from "node:url";
 import { writeFile, unlink, readFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
-import { tmpdir } from "node:os";
 import { randomBytes } from "node:crypto";
-import { createRequire } from "node:module";
 import { error } from './logger.js';
-const require2 = createRequire(import.meta.url);
-async function getAliasesFromTsConfig(tsConfigPath) {
+async function getTsConfig(projectRoot) {
+  const tsConfigPath = path.join(projectRoot, "tsconfig.json");
   if (!existsSync(tsConfigPath)) {
+    error("tsconfig.json not found in the project root.", "HMR");
     return null;
   }
   try {
     const tsConfigFile = await readFile(tsConfigPath, "utf-8");
     const json = JSON.parse(tsConfigFile.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, ""));
     const compilerOptions = json.compilerOptions || {};
+    if (!compilerOptions.outDir) {
+      error("`compilerOptions.outDir` is not defined in tsconfig.json.", "HMR");
+      return null;
+    }
     const baseUrl = path.resolve(path.dirname(tsConfigPath), compilerOptions.baseUrl || ".");
+    const outDir = path.resolve(path.dirname(tsConfigPath), compilerOptions.outDir);
     const paths = compilerOptions.paths || {};
     return {
       paths,
-      baseUrl
+      baseUrl,
+      outDir
     };
-  } catch (error2) {
-    console.error("Error reading or parsing tsconfig.json:", error2);
+  } catch (e) {
+    error(`Error reading or parsing tsconfig.json: ${e.message}`, "HMR");
     return null;
   }
 }
-__name(getAliasesFromTsConfig, "getAliasesFromTsConfig");
-function resolveAlias(importPath, tsConfigPaths, baseUrl) {
-  for (const alias in tsConfigPaths) {
+__name(getTsConfig, "getTsConfig");
+function resolveAliasToSourcePath(importPath, tsConfig) {
+  const { paths, baseUrl } = tsConfig;
+  for (const alias in paths) {
     const aliasPattern = new RegExp(`^${alias.replace("*", "(.*)")}$`);
     const match = importPath.match(aliasPattern);
     if (match) {
       const [_fullMatch, restOfPath] = match;
-      const targetPaths = tsConfigPaths[alias];
-      const targetPath = targetPaths[0];
+      const targetPath = paths[alias][0];
       if (!alias.endsWith("*")) {
         return path.resolve(baseUrl, targetPath);
       }
@@ -51,10 +56,13 @@ function resolveAlias(importPath, tsConfigPaths, baseUrl) {
   }
   return null;
 }
-__name(resolveAlias, "resolveAlias");
+__name(resolveAliasToSourcePath, "resolveAliasToSourcePath");
 async function generateFunctionFromTypescript(tsCode, filePath) {
-  const tsConfigPath = path.join(process.cwd(), "tsconfig.json");
-  const tsConfig = await getAliasesFromTsConfig(tsConfigPath);
+  const projectRoot = process.cwd();
+  const tsConfig = await getTsConfig(projectRoot);
+  if (!tsConfig) {
+    throw new Error("Failed to load or validate tsconfig.json configuration.");
+  }
   const result = babel.transformSync(tsCode, {
     presets: [
       "@babel/preset-typescript"
@@ -65,44 +73,35 @@ async function generateFunctionFromTypescript(tsCode, filePath) {
   const ast = parse(jsCode, {
     sourceType: "module"
   });
-  const fileDir = path.dirname(filePath);
+  const originalFileDir = path.dirname(filePath);
   traverse.default(ast, {
     ImportDeclaration(astPath) {
-      const importSourceNode = astPath.node.source;
-      const importPath = importSourceNode.value;
-      let resolvedUrl = null;
-      if (tsConfig && tsConfig.paths) {
-        const resolvedAliasPath = resolveAlias(importPath, tsConfig.paths, tsConfig.baseUrl);
-        if (resolvedAliasPath) {
-          const finalPath = path.extname(resolvedAliasPath) === "" ? resolvedAliasPath + ".ts" : resolvedAliasPath;
-          resolvedUrl = pathToFileURL(finalPath).href;
-        }
-      }
-      if (!resolvedUrl && importPath.startsWith(".")) {
-        const resolvedPathWithExt = path.extname(importPath) === "" ? importPath + ".ts" : importPath;
-        const absoluteDepPath = path.resolve(fileDir, resolvedPathWithExt);
-        resolvedUrl = pathToFileURL(absoluteDepPath).href;
+      const importNode = astPath.node.source;
+      const importPath = importNode.value;
+      let resolvedPathForDist = null;
+      const aliasedSourcePath = resolveAliasToSourcePath(importPath, tsConfig);
+      if (aliasedSourcePath) {
+        resolvedPathForDist = path.relative(tsConfig.baseUrl, aliasedSourcePath);
+      } else if (importPath.startsWith(".")) {
+        const absoluteSourcePath = path.resolve(originalFileDir, importPath);
+        resolvedPathForDist = path.relative(tsConfig.baseUrl, absoluteSourcePath);
       }
-      if (!resolvedUrl) {
-        try {
-          const resolvedNodeModulePath = require2.resolve(importPath, {
-            paths: [
-              fileDir
-            ]
-          });
-          resolvedUrl = pathToFileURL(resolvedNodeModulePath).href;
-        } catch (_) {
-          error(`Could not resolve import path for: ${importPath} in ${filePath}.`, "HMR");
+      if (resolvedPathForDist) {
+        if (resolvedPathForDist.startsWith("src" + path.sep)) {
+          resolvedPathForDist = resolvedPathForDist.substring("src".length + 1);
         }
-      }
-      if (resolvedUrl) {
-        importSourceNode.value = resolvedUrl;
+        let jsPath = resolvedPathForDist.replace(/\.(ts|js|mts|cts)$/, ".js");
+        if (jsPath.startsWith("dist")) {
+          jsPath = jsPath.slice("dist".length + 1);
+        }
+        const targetDistPath = path.join(tsConfig.outDir, jsPath);
+        importNode.value = pathToFileURL(targetDistPath).href;
       }
     }
   });
   const { code: modifiedCode } = generate.default(ast);
   const tempFileName = `oweb-temp-${randomBytes(16).toString("hex")}.mjs`;
-  const tempFilePath = path.join(tmpdir(), tempFileName);
+  const tempFilePath = path.join(process.cwd(), tempFileName);
   let module;
   try {
     await writeFile(tempFilePath, modifiedCode, "utf-8");
@@ -112,6 +111,9 @@ async function generateFunctionFromTypescript(tsCode, filePath) {
     await unlink(tempFilePath).catch(() => {
     });
   }
+  if (!module || typeof module.default === "undefined") {
+    throw new Error(`The file ${filePath} was processed, but it did not have a default export.`);
+  }
   return module.default;
 }
 __name(generateFunctionFromTypescript, "generateFunctionFromTypescript");

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "owebjs",
-    "version": "1.3.7",
+    "version": "1.3.9",
     "description": "A flexible and modern web framework built on top of Fastify",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",