@veducio/keja 0.5.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veducio/keja",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "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/cli/dev-reload.ts

@@ -10,6 +10,7 @@ import {
   printServers,
   readProjectFailure,
 } from "./run-project.ts";
+import { scaffoldEmptyRoutes } from "./scaffold-empty-route.ts";
 
 export const reloadDebounceMs = 50;
 
@@ -111,6 +112,7 @@ export async function runDev(root = process.cwd()) {
       const token = String(generation);
       if (running) {
         printReloading();
+        await scaffoldEmptyRoutes(running.paths.public, running.paths.service);
       }
       const result = await refreshDevProject({
         running: running !== null,

package/src/cli/scaffold-empty-route.test.ts

@@ -0,0 +1,67 @@
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import {
+  emptyRouteSource,
+  routePathFromFile,
+  scaffoldEmptyRouteFile,
+  scaffoldEmptyRoutes,
+} from "./scaffold-empty-route.ts";
+
+describe("scaffold empty route", () => {
+  it("derives a path from the file name", () => {
+    expect(routePathFromFile("src/public/notes.ts")).toBe("/notes");
+    expect(routePathFromFile("hello.world.ts")).toBe("/hello.world");
+    expect(routePathFromFile("bad name.ts")).toBe("/route");
+  });
+
+  it("writes a public get stub and a service post stub", () => {
+    expect(emptyRouteSource("public", "/items")).toContain('method: "get"');
+    expect(emptyRouteSource("public", "/items")).toContain('path: "/items"');
+    expect(emptyRouteSource("service", "/jobs")).toContain('method: "post"');
+  });
+
+  it("fills an empty route file once", async () => {
+    const directory = await mkdtemp(path.join(tmpdir(), "keja-scaffold-"));
+    const file = path.join(directory, "items.ts");
+    await writeFile(file, "");
+    expect(await scaffoldEmptyRouteFile(file, "public")).toBe(true);
+    const first = await readFile(file, "utf8");
+    expect(first).toContain('path: "/items"');
+    expect(await scaffoldEmptyRouteFile(file, "public")).toBe(false);
+    expect(await readFile(file, "utf8")).toBe(first);
+  });
+
+  it("fills empty route modules under public and service folders", async () => {
+    const root = mkdtempSync(path.join(tmpdir(), "keja-scaffold-dirs-"));
+    const publicDir = path.join(root, "public");
+    const serviceDir = path.join(root, "service");
+    mkdirSync(publicDir);
+    mkdirSync(serviceDir);
+    writeFileSync(path.join(publicDir, "notes.ts"), "   \n");
+    writeFileSync(path.join(publicDir, "_middleware.ts"), "");
+    writeFileSync(path.join(serviceDir, "jobs.ts"), "");
+    writeFileSync(path.join(publicDir, "ready.ts"), "export {}\n");
+    const written = await scaffoldEmptyRoutes(publicDir, serviceDir);
+    expect(written.sort()).toEqual(
+      [
+        path.join(publicDir, "notes.ts"),
+        path.join(serviceDir, "jobs.ts"),
+      ].sort(),
+    );
+    expect(await readFile(path.join(publicDir, "notes.ts"), "utf8")).toContain(
+      'method: "get"',
+    );
+    expect(await readFile(path.join(serviceDir, "jobs.ts"), "utf8")).toContain(
+      'method: "post"',
+    );
+    expect(await readFile(path.join(publicDir, "_middleware.ts"), "utf8")).toBe(
+      "",
+    );
+    expect(await readFile(path.join(publicDir, "ready.ts"), "utf8")).toBe(
+      "export {}\n",
+    );
+  });
+});

package/src/cli/scaffold-empty-route.ts

@@ -0,0 +1,72 @@
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { collectRouteFiles } from "../project/load.ts";
+
+export function routePathFromFile(file: string) {
+  const base = path.basename(file, ".ts");
+  if (/^[A-Za-z0-9._~-]+$/.test(base)) {
+    return `/${base}`;
+  }
+  return "/route";
+}
+
+export function emptyRouteSource(
+  surface: "public" | "service",
+  routePath: string,
+) {
+  const method = surface === "service" ? "post" : "get";
+  return `import { defineRoute, response } from "@veducio/keja";
+import { z } from "zod";
+
+export default defineRoute({
+  method: "${method}",
+  path: "${routePath}",
+  version: "v1",
+  responses: {
+    Ok: response({
+      code: 200,
+      json: z.object({ ok: z.literal(true) }),
+    }),
+  },
+  handler: ({ respond }) => respond.Ok({ ok: true }),
+});
+`;
+}
+
+export async function scaffoldEmptyRouteFile(
+  file: string,
+  surface: "public" | "service",
+) {
+  if (!existsSync(file)) {
+    return false;
+  }
+  const content = await readFile(file, "utf8");
+  if (content.trim() !== "") {
+    return false;
+  }
+  await writeFile(file, emptyRouteSource(surface, routePathFromFile(file)));
+  return true;
+}
+
+export async function scaffoldEmptyRoutes(
+  publicDir: string,
+  serviceDir: string,
+) {
+  const written: string[] = [];
+  for (const [surface, directory] of [
+    ["public", publicDir],
+    ["service", serviceDir],
+  ] as const) {
+    if (!existsSync(directory)) {
+      continue;
+    }
+    for (const relative of await collectRouteFiles(directory)) {
+      const file = path.join(directory, relative);
+      if (await scaffoldEmptyRouteFile(file, surface)) {
+        written.push(file);
+      }
+    }
+  }
+  return written;
+}

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}:`)