@veducio/keja 0.6.0 → 0.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veducio/keja",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "packageManager": "bun@1.4.4",
   "description": "Veducio Keja - RESTFUL Web Server, Based on Lightweight Hono Framework, Written in TypeScript, Powered by Bun",
   "license": "MIT",

package/src/project/reload-graph.test.ts

@@ -1,3 +1,5 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
 import path from "node:path";
 import { describe, expect, it } from "vitest";
 import { freshImportUrl, resolveProjectImport } from "./reload-graph.ts";
@@ -26,6 +28,32 @@ describe("project reload imports", () => {
     });
   });
 
+  it("adds a TypeScript extension to an extensionless relative import", () => {
+    const project = mkdtempSync(path.join(tmpdir(), "keja-reload-"));
+    const repositories = path.join(project, "src", "db", "repositories.ts");
+    const importer = path.join(
+      project,
+      "src",
+      "public",
+      "config",
+      "tenants.ts",
+    );
+    mkdirSync(path.dirname(repositories), { recursive: true });
+    mkdirSync(path.dirname(importer), { recursive: true });
+    writeFileSync(repositories, "export {}\n");
+    try {
+      const resolved = resolveProjectImport({
+        importer: `keja:${importer}`,
+        specifier: "../../db/repositories",
+        projectRoot: project,
+        generation: "4",
+      });
+      expect(resolved?.file).toBe(repositories);
+    } finally {
+      rmSync(project, { recursive: true, force: true });
+    }
+  });
+
   it("follows the next file imported by that dependency", () => {
     const data = path.join(root, "src", "data.ts");
     const resolved = resolveProjectImport({

package/src/project/reload-graph.ts

@@ -1,4 +1,4 @@
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -35,7 +35,9 @@ export function resolveProjectImport(input: {
   if (!inProject && !inGraph) {
     return null;
   }
-  const resolved = path.resolve(path.dirname(importerFile), specifier);
+  const resolved = resolveRelativeFile(
+    path.resolve(path.dirname(importerFile), specifier),
+  );
   if (isNodeModules(resolved)) {
     return null;
   }
@@ -148,6 +150,46 @@ function isRelativeSpecifier(specifier: string) {
   return specifier.startsWith("./") || specifier.startsWith("../");
 }
 
+const sourceExtensions = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".json",
+] as const;
+
+function resolveRelativeFile(resolved: string) {
+  if (fileExists(resolved)) {
+    return resolved;
+  }
+  if (path.extname(resolved) !== "") {
+    return resolved;
+  }
+  for (const extension of sourceExtensions) {
+    const candidate = `${resolved}${extension}`;
+    if (fileExists(candidate)) {
+      return candidate;
+    }
+  }
+  for (const extension of sourceExtensions) {
+    const candidate = path.join(resolved, `index${extension}`);
+    if (fileExists(candidate)) {
+      return candidate;
+    }
+  }
+  return resolved;
+}
+
+function fileExists(file: string) {
+  try {
+    return existsSync(file) && statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+
 function filePath(importer: string) {
   const withoutQuery = importer.split("?")[0] ?? importer;
   const clean = withoutQuery.startsWith(`${namespace}:`)

package/src/route/middleware.test.ts

@@ -60,4 +60,18 @@ describe("runMiddleware", () => {
       ).rejects.toThrow(`Middleware cannot pass reserved field ${key}`);
     }
   });
+
+  it("rejects next() when the rest of the chain does not return a Response", async () => {
+    const step = defineMiddleware(async ({ next }) => {
+      const response = await next();
+      return response;
+    });
+    await expect(
+      runMiddleware(
+        [{ definition: step, allowFields: true }],
+        context,
+        () => undefined as never,
+      ),
+    ).rejects.toThrow("next() must resolve to a Response");
+  });
 });

package/src/route/middleware.ts

@@ -128,7 +128,11 @@ export async function runMiddleware(
           }
           Object.assign(fields, passed);
         }
-        return dispatch();
+        const nextResponse = await dispatch();
+        if (!(nextResponse instanceof Response)) {
+          throw new Error("next() must resolve to a Response");
+        }
+        return nextResponse;
       },
     });
     if (!(response instanceof Response)) {