owebjs 1.3.5 → 1.3.8

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,13 +87,13 @@ 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");
@@ -96,13 +103,13 @@ const applyRouteHMR = /* @__PURE__ */ __name(async (oweb, op, workingDir, fallba
     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 +127,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 +215,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,16 +4,65 @@ 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 } from "node:fs/promises";
-import { tmpdir } from "node:os";
+import { writeFile, unlink, readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
 import { randomBytes } from "node:crypto";
-import { createRequire } from "node:module";
 import { error } from './logger.js';
-const require2 = createRequire(import.meta.url);
+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,
+      outDir
+    };
+  } catch (e) {
+    error(`Error reading or parsing tsconfig.json: ${e.message}`, "HMR");
+    return null;
+  }
+}
+__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 targetPath = paths[alias][0];
+      if (!alias.endsWith("*")) {
+        return path.resolve(baseUrl, targetPath);
+      }
+      const resolvedPath = targetPath.replace("*", restOfPath);
+      return path.resolve(baseUrl, resolvedPath);
+    }
+  }
+  return null;
+}
+__name(resolveAliasToSourcePath, "resolveAliasToSourcePath");
 async function generateFunctionFromTypescript(tsCode, filePath) {
+  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"
@@ -24,37 +73,33 @@ async function generateFunctionFromTypescript(tsCode, filePath) {
   const ast = parse(jsCode, {
     sourceType: "module"
   });
+  const originalFileDir = path.dirname(filePath);
   traverse.default(ast, {
     ImportDeclaration(astPath) {
-      const importSourceNode = astPath.node.source;
-      let relativePath = importSourceNode.value;
-      if (relativePath.startsWith(".")) {
-        let resolvedPath = relativePath;
-        if (path.extname(relativePath) === "") {
-          resolvedPath = relativePath + ".ts";
-        }
-        const originalFileDir = path.dirname(filePath);
-        const absoluteDepPath = path.resolve(originalFileDir, resolvedPath);
-        const absoluteDepUrl = pathToFileURL(absoluteDepPath).href;
-        importSourceNode.value = absoluteDepUrl;
-      } else {
-        try {
-          const resolvedPath = require2.resolve(relativePath, {
-            paths: [
-              path.dirname(filePath)
-            ]
-          });
-          const resolvedUrl = pathToFileURL(resolvedPath).href;
-          importSourceNode.value = resolvedUrl;
-        } catch (_) {
-          error(`Could not resolve module "${relativePath}". Please ensure it is installed.`, "HMR");
+      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 (resolvedPathForDist) {
+        if (resolvedPathForDist.startsWith("src" + path.sep)) {
+          resolvedPathForDist = resolvedPathForDist.substring("src".length + 1);
         }
+        let jsPath = resolvedPathForDist.replace(/\.(ts|mts|cts)$/, "");
+        jsPath += ".js";
+        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");
@@ -64,6 +109,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.5",
+    "version": "1.3.8",
     "description": "A flexible and modern web framework built on top of Fastify",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -18,7 +18,7 @@
     },
     "scripts": {
         "start": "node .",
-        "build": "tsup",
+        "build": "tsup && node scripts/copyBinaries",
         "dev": "tsup && node .",
         "test": "tsup && node scripts/copyBinaries && node test/index.js",
         "format": "prettier --write . --ignore-path .gitignore"