@veducio/keja 0.5.0 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veducio/keja",
-  "version": "0.5.0",
+  "version": "0.6.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;
+}