@veducio/keja 0.7.0 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veducio/keja",
-  "version": "0.7.0",
+  "version": "0.8.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/commands/seed.ts

@@ -4,9 +4,17 @@ import { runSeed } from "../seed-project.ts";
 export const seed = defineCommand({
   meta: {
     name: "seed",
-    description: "Insert project seeders",
+    description: "Clear seeded tables and insert project seeders",
   },
-  async run() {
-    await runSeed();
+  args: {
+    yes: {
+      type: "boolean",
+      description: "Skip the confirmation prompt",
+      alias: "y",
+      default: false,
+    },
+  },
+  async run({ args }) {
+    await runSeed(process.cwd(), { yes: args.yes === true });
   },
 });

package/src/cli/seed-project.ts

@@ -1,14 +1,19 @@
 import path from "node:path";
+import { createInterface } from "node:readline/promises";
 import { DBCall, setDatabase } from "../db/client.ts";
 import { connectDatabase } from "../db/postgres.ts";
 import { DependencyNotMet } from "../errors/framework-errors.ts";
 import { loadConfig } from "../project/config.ts";
-import { applySeeder } from "../seed/apply.ts";
+import { applySeeder, truncateSeedTables } from "../seed/apply.ts";
+import { confirmSeed } from "../seed/confirm.ts";
 import { loadSeeders } from "../seed/load.ts";
 import { formatSeed } from "../seed/report.ts";
 import { formatProjectFailure, readProjectFailure } from "./run-project.ts";
 
-export async function runSeed(root = process.cwd()) {
+export async function runSeed(
+  root = process.cwd(),
+  options: { yes?: boolean } = {},
+) {
   let opened = false;
   try {
     const project = await loadConfig(root);
@@ -18,6 +23,24 @@ export async function runSeed(root = process.cwd()) {
     await connectDatabase(Bun.env.DATABASE_URL ?? "");
     opened = true;
     const seeders = await loadSeeders(path.join(root, "seed"));
+    const tables = seeders.map((seeder) => seeder.table);
+    const confirmed = await confirmSeed({
+      yes: options.yes === true,
+      interactive:
+        process.stdin.isTTY === true && process.stdout.isTTY === true,
+      tables,
+      ask: askSeedConfirm,
+    });
+    if (confirmed === "needs-yes") {
+      console.error("Pass --yes to seed without a prompt.");
+      process.exitCode = 1;
+      return;
+    }
+    if (confirmed === "no") {
+      console.log("  Seed cancelled.");
+      return;
+    }
+    await truncateSeedTables(tables);
     const results = [];
     for (const seeder of seeders) {
       results.push({
@@ -44,3 +67,15 @@ export async function runSeed(root = process.cwd()) {
     process.exit(1);
   }
 }
+
+async function askSeedConfirm(message: string) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  try {
+    return await rl.question(`  ${message} [y/N] `);
+  } finally {
+    rl.close();
+  }
+}

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)) {

package/src/seed/apply.test.ts

@@ -1,11 +1,11 @@
 import { describe, expect, it } from "vitest";
 import { setDatabase } from "../db/client.ts";
 import { createTypeId } from "../typeid/id.ts";
-import { applySeeder } from "./apply.ts";
+import { applySeeder, truncateSeedTables } from "./apply.ts";
 import { defineSeeder } from "./define.ts";
 
 describe("applySeeder", () => {
-  it("inserts owned rows and skips an existing _id", async () => {
+  it("inserts owned rows after a clear", async () => {
     const calls: unknown[][] = [];
     setDatabase(((...args: unknown[]) => {
       calls.push(args);
@@ -41,8 +41,29 @@ describe("applySeeder", () => {
       const statement = Array.from(template?.[0] as ArrayLike<string>).join(
         " ",
       );
-      expect(statement).toContain("on conflict (_id) do nothing");
       expect(statement).toContain("returning _id");
+      expect(statement).not.toContain("on conflict");
+    } finally {
+      setDatabase(null);
+    }
+  });
+});
+
+describe("truncateSeedTables", () => {
+  it("truncates each seeded table once", async () => {
+    const statements: string[] = [];
+    setDatabase({
+      unsafe(statement: string) {
+        statements.push(statement);
+      },
+    } as never);
+    try {
+      await truncateSeedTables(["users", "notes", "users"]);
+      expect(statements).toEqual([
+        'truncate "users", "notes" restart identity cascade',
+      ]);
+      await truncateSeedTables([]);
+      expect(statements).toHaveLength(1);
     } finally {
       setDatabase(null);
     }

package/src/seed/apply.ts

@@ -1,11 +1,23 @@
 import { DBCall } from "../db/client.ts";
 import type { Seeder } from "./define.ts";
 
+export async function truncateSeedTables(tables: readonly string[]) {
+  const unique = [...new Set(tables)];
+  if (unique.length === 0) {
+    return;
+  }
+  const list = unique.map((table) => quote(table)).join(", ");
+  await DBCall.unsafe(`truncate ${list} restart identity cascade`);
+}
+
 export async function applySeeder(seeder: Seeder) {
   const inserted = await DBCall`
     insert into ${DBCall(seeder.table)} ${DBCall(seeder.objects)}
-    on conflict (_id) do nothing
     returning _id
   `;
   return Array.isArray(inserted) ? inserted.length : 0;
 }
+
+function quote(name: string) {
+  return `"${name.replaceAll('"', '""')}"`;
+}

package/src/seed/confirm.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+import { confirmSeed, confirmSeedMessage } from "./confirm.ts";
+
+describe("confirmSeed", () => {
+  it("names the tables that will be cleared", () => {
+    expect(confirmSeedMessage(["users", "notes", "users"])).toBe(
+      "This will clear users, notes and insert seed data. Continue?",
+    );
+  });
+
+  it("accepts --yes without asking", async () => {
+    let asked = false;
+    await expect(
+      confirmSeed({
+        yes: true,
+        interactive: true,
+        tables: ["users"],
+        ask: async () => {
+          asked = true;
+          return "n";
+        },
+      }),
+    ).resolves.toBe("yes");
+    expect(asked).toBe(false);
+  });
+
+  it("requires --yes when there is no terminal", async () => {
+    await expect(
+      confirmSeed({
+        yes: false,
+        interactive: false,
+        tables: ["users"],
+        ask: async () => "y",
+      }),
+    ).resolves.toBe("needs-yes");
+  });
+
+  it("accepts y or yes from the prompt", async () => {
+    await expect(
+      confirmSeed({
+        yes: false,
+        interactive: true,
+        tables: ["users"],
+        ask: async () => " Y ",
+      }),
+    ).resolves.toBe("yes");
+    await expect(
+      confirmSeed({
+        yes: false,
+        interactive: true,
+        tables: ["users"],
+        ask: async () => "no",
+      }),
+    ).resolves.toBe("no");
+  });
+});

package/src/seed/confirm.ts

@@ -0,0 +1,25 @@
+export function confirmSeedMessage(tables: readonly string[]) {
+  const unique = [...new Set(tables)];
+  const list = unique.length > 0 ? unique.join(", ") : "no tables";
+  return `This will clear ${list} and insert seed data. Continue?`;
+}
+
+export async function confirmSeed(options: {
+  yes: boolean;
+  interactive: boolean;
+  tables: readonly string[];
+  ask: (message: string) => Promise<string>;
+}) {
+  if (options.yes) {
+    return "yes" as const;
+  }
+  if (!options.interactive) {
+    return "needs-yes" as const;
+  }
+  const answer = (await options.ask(confirmSeedMessage(options.tables)))
+    .trim()
+    .toLowerCase();
+  return answer === "y" || answer === "yes"
+    ? ("yes" as const)
+    : ("no" as const);
+}