@veducio/keja 0.0.0-stage → 0.3.0

package/src/cli/banner.ts

@@ -0,0 +1,209 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { Chalk } from "chalk";
+
+export const veducioAnnotation =
+  "Veducio Keja is part of Veducio and its Labs program, with a mission to contribute quality software to open source.";
+
+export function projectLabel(
+  pkg: { name?: string; version?: string },
+  fallbackName: string,
+) {
+  const name = pkg.name?.trim() || fallbackName;
+  const version = pkg.version?.trim();
+  return version ? `${name} ${version}` : name;
+}
+
+export function readProjectLabel(root = process.cwd()) {
+  const project = readProject(root);
+  return projectLabel(project, project.name);
+}
+
+export function formatBanner(options: {
+  name: string;
+  version?: string;
+  color?: boolean;
+}) {
+  const style = ink(options.color === true);
+  const version = options.version?.trim();
+  const title = version
+    ? `${style.bold(options.name)} ${style.dim(version)}`
+    : style.bold(options.name);
+  const note = wrap(veducioAnnotation, 72)
+    .map((line) => `  ${style.dim(line)}`)
+    .join("\n");
+  return `\n  ${title}\n\n${note}\n`;
+}
+
+export function formatAddresses(
+  publicUrl: string,
+  serviceUrl: string,
+  color = false,
+) {
+  const style = ink(color);
+  const row = (label: string, url: string) =>
+    `  ${style.dim(`- ${label.padEnd(8)}`)} ${url}`;
+  return `\n${row("Public", publicUrl)}\n${row("Service", serviceUrl)}\n`;
+}
+
+export function printStartup(root = process.cwd()) {
+  const project = readProject(root);
+  console.log(
+    formatBanner({
+      name: project.name,
+      version: project.version,
+      color: process.stdout.isTTY,
+    }),
+  );
+}
+
+export function formatProjectPaths(
+  paths: {
+    config: string | null;
+    versioning: string;
+    public: string;
+    service: string;
+  },
+  color = false,
+) {
+  const style = ink(color);
+  const row = (label: string, value: string) =>
+    `  ${style.dim(`- ${label.padEnd(10)}`)} ${value}`;
+  return `\n${row("Config", paths.config ?? "defaults")}\n${row("Versioning", paths.versioning)}\n${row("Public", paths.public)}\n${row("Service", paths.service)}\n`;
+}
+
+export function printProjectPaths(paths: {
+  config: string | null;
+  versioning: string;
+  public: string;
+  service: string;
+}) {
+  console.log(formatProjectPaths(paths, process.stdout.isTTY === true));
+}
+
+export function formatIdentity(
+  identity: { name: string; public: string[]; service: string[] },
+  argus?: { url: string; env: string } | null,
+  color = false,
+  vault?: { address: string; mount: string } | null,
+) {
+  const style = ink(color);
+  const row = (label: string, value: string) =>
+    `  ${style.dim(`- ${label.padEnd(10)}`)} ${value}`;
+  const lines = [
+    row("Name", identity.name),
+    row("Public", identity.public.join(", ")),
+    row("Service", identity.service.join(", ")),
+  ];
+  if (argus) {
+    lines.push(row("Argus", `${argus.url} (${argus.env})`));
+  }
+  if (vault) {
+    lines.push(row("Vault", `${vault.address} (${vault.mount})`));
+  }
+  return `\n${lines.join("\n")}\n`;
+}
+
+export function printIdentity(
+  identity: { name: string; public: string[]; service: string[] },
+  argus?: { url: string; env: string } | null,
+  vault?: { address: string; mount: string } | null,
+) {
+  console.log(
+    formatIdentity(identity, argus, process.stdout.isTTY === true, vault),
+  );
+}
+
+export function formatDatabase(
+  database:
+    | { migrations: string; applied: string[] }
+    | { connected: true }
+    | null,
+  color = false,
+) {
+  const style = ink(color);
+  const row = (label: string, value: string) =>
+    `  ${style.dim(`- ${label.padEnd(10)}`)} ${value}`;
+  if (!database) {
+    return `\n${row("Database", "disabled")}\n`;
+  }
+  if (!("applied" in database)) {
+    return `\n${row("Database", "postgres")}\n`;
+  }
+  const applied =
+    database.applied.length > 0 ? database.applied.join(", ") : "up to date";
+  return `\n${row("Database", "postgres")}\n${row("Migrations", database.migrations)}\n${row("Applied", applied)}\n`;
+}
+
+export function printDatabase(
+  database:
+    | { migrations: string; applied: string[] }
+    | { connected: true }
+    | null,
+) {
+  console.log(formatDatabase(database, process.stdout.isTTY === true));
+}
+
+export function printAddresses(publicUrl: string, serviceUrl: string) {
+  console.log(
+    formatAddresses(publicUrl, serviceUrl, process.stdout.isTTY === true),
+  );
+}
+
+export function formatReloading(color = false) {
+  const style = ink(color);
+  return `\n  ${style.dim("reloading...")}\n`;
+}
+
+export function formatProjectReady(color = false) {
+  const style = ink(color);
+  return `\n  ${style.green("no issues found")}\n`;
+}
+
+export function printReloading() {
+  console.log(formatReloading(process.stdout.isTTY === true));
+}
+
+export function printProjectReady() {
+  console.log(formatProjectReady(process.stdout.isTTY === true));
+}
+
+function readProject(root: string) {
+  const fallbackName = path.basename(root);
+  try {
+    const parsed = JSON.parse(
+      readFileSync(path.join(root, "package.json"), "utf8"),
+    ) as { name?: unknown; version?: unknown };
+    return {
+      name:
+        typeof parsed.name === "string" && parsed.name.trim()
+          ? parsed.name.trim()
+          : fallbackName,
+      version: typeof parsed.version === "string" ? parsed.version : undefined,
+    };
+  } catch {
+    return { name: fallbackName, version: undefined };
+  }
+}
+
+function ink(color: boolean) {
+  return new Chalk({ level: color ? 1 : 0 });
+}
+
+function wrap(text: string, width: number) {
+  const lines: string[] = [];
+  let line = "";
+  for (const word of text.split(" ")) {
+    const next = line ? `${line} ${word}` : word;
+    if (next.length > width && line) {
+      lines.push(line);
+      line = word;
+      continue;
+    }
+    line = next;
+  }
+  if (line) {
+    lines.push(line);
+  }
+  return lines;
+}

package/src/cli/commands/build.ts

@@ -0,0 +1,12 @@
+import { defineCommand } from "citty";
+
+export const build = defineCommand({
+  meta: {
+    name: "build",
+    description: "Build the server",
+  },
+  run() {
+    console.error("build is not implemented");
+    process.exit(1);
+  },
+});

package/src/cli/commands/dev.ts

@@ -0,0 +1,12 @@
+import { defineCommand } from "citty";
+import { runDev } from "../dev-reload.ts";
+
+export const dev = defineCommand({
+  meta: {
+    name: "dev",
+    description: "Start the development server",
+  },
+  async run() {
+    await runDev();
+  },
+});

package/src/cli/commands/generate.ts

@@ -0,0 +1,12 @@
+import { defineCommand } from "citty";
+import { runGenerate } from "../generate-project.ts";
+
+export const generate = defineCommand({
+  meta: {
+    name: "generate",
+    description: "Generate repositories from migrations",
+  },
+  async run() {
+    await runGenerate();
+  },
+});

package/src/cli/commands/init.ts

@@ -0,0 +1,57 @@
+import { defineCommand } from "citty";
+import {
+  askOnTerminal,
+  runCommand,
+  runInit,
+  starterPaths,
+} from "../init-project.ts";
+
+export const init = defineCommand({
+  meta: {
+    name: "init",
+    description: "Create a new project",
+  },
+  args: {
+    name: {
+      type: "string",
+      description: "Name of the project",
+    },
+    dir: {
+      type: "string",
+      description: "Where to create the project",
+    },
+    public: {
+      type: "string",
+      description: "Public route folder",
+    },
+    service: {
+      type: "string",
+      description: "Service route folder",
+    },
+  },
+  async run({ args }) {
+    const paths = starterPaths();
+    try {
+      await runInit({
+        input: {
+          name: args.name,
+          dir: args.dir,
+          public: args.public,
+          service: args.service,
+        },
+        cwd: process.cwd(),
+        templateDir: paths.templateDir,
+        packageRoot: paths.packageRoot,
+        interactive: process.stdin.isTTY === true,
+        ask: askOnTerminal,
+        run: runCommand,
+        log(message) {
+          console.log(message);
+        },
+      });
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : "init failed");
+      process.exit(1);
+    }
+  },
+});

package/src/cli/commands/migrate.ts

@@ -0,0 +1,12 @@
+import { defineCommand } from "citty";
+import { runMigrate } from "../migrate-project.ts";
+
+export const migrate = defineCommand({
+  meta: {
+    name: "migrate",
+    description: "Apply project migrations",
+  },
+  async run() {
+    await runMigrate();
+  },
+});

package/src/cli/commands/seed.ts

@@ -0,0 +1,12 @@
+import { defineCommand } from "citty";
+import { runSeed } from "../seed-project.ts";
+
+export const seed = defineCommand({
+  meta: {
+    name: "seed",
+    description: "Insert project seeders",
+  },
+  async run() {
+    await runSeed();
+  },
+});

package/src/cli/commands/start.ts

@@ -0,0 +1,12 @@
+import { defineCommand } from "citty";
+import { runProject } from "./../run-project.ts";
+
+export const start = defineCommand({
+  meta: {
+    name: "start",
+    description: "Start the server",
+  },
+  async run() {
+    await runProject();
+  },
+});

package/src/cli/dev-reload.test.ts

@@ -0,0 +1,87 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import {
+  isIgnoredWatch,
+  refreshDevProject,
+  subscribeDirectories,
+  watchDirectories,
+} from "./dev-reload.ts";
+
+describe("dev reload", () => {
+  it("does not relaunch the process under bun --watch", () => {
+    const entry = readFileSync(new URL("./index.ts", import.meta.url), "utf8");
+    const dev = readFileSync(
+      new URL("./commands/dev.ts", import.meta.url),
+      "utf8",
+    );
+    expect(entry.includes("--watch")).toBe(false);
+    expect(dev.includes("--watch")).toBe(false);
+  });
+
+  it("watches the project and route dependencies outside it", () => {
+    const root = path.resolve("app");
+    expect(isIgnoredWatch("node_modules/pkg/index.ts")).toBe(true);
+    expect(isIgnoredWatch("src/data.ts")).toBe(false);
+    expect(
+      watchDirectories(
+        root,
+        {
+          config: path.join(root, "keja.config.ts"),
+          versioning: path.join(root, "keja.versioning.ts"),
+          public: path.join(root, "src", "public"),
+          service: path.join(root, "src", "service"),
+        },
+        ["D:/shared/schema.ts"],
+      ),
+    ).toContain(path.resolve("D:/shared"));
+  });
+
+  it("keeps the running project when a reload fails", async () => {
+    let swapped = false;
+    const result = await refreshDevProject({
+      running: true,
+      load: () => Promise.reject(new Error("bad route")),
+      boot: () => Promise.resolve(),
+      swap: () => {
+        swapped = true;
+      },
+    });
+    expect(swapped).toBe(false);
+    expect(result).toEqual({
+      error: expect.any(Error),
+      waiting: false,
+    });
+  });
+
+  it("boots when the servers are not up yet", async () => {
+    let booted = false;
+    const result = await refreshDevProject({
+      running: false,
+      load: () => Promise.reject(new Error("unused")),
+      boot: () => {
+        booted = true;
+        return Promise.resolve();
+      },
+      swap: () => {
+        throw new Error("swap");
+      },
+    });
+    expect(booted).toBe(true);
+    expect(result).toBe("booted");
+  });
+
+  it("subscribes through the injected watcher", () => {
+    const opened: string[] = [];
+    const subscription = subscribeDirectories(
+      [process.cwd()],
+      () => {},
+      (directory) => {
+        opened.push(directory);
+        return { close() {} };
+      },
+    );
+    expect(opened).toEqual([path.resolve(process.cwd())]);
+    subscription.close();
+  });
+});

package/src/cli/dev-reload.ts

@@ -0,0 +1,182 @@
+import { existsSync, watch as watchDirectory } from "node:fs";
+import path from "node:path";
+import type { LoadedProject } from "../project/load.ts";
+import { loadProject } from "../project/load.ts";
+import { projectDependenciesOutsideRoot } from "../project/reload-graph.ts";
+import { listen } from "../server/index.ts";
+import { printProjectReady, printReloading } from "./banner.ts";
+import {
+  formatProjectFailure,
+  printServers,
+  readProjectFailure,
+} from "./run-project.ts";
+
+export const reloadDebounceMs = 50;
+
+export function isIgnoredWatch(file: string) {
+  return file
+    .split(/[\\/]/)
+    .some(
+      (part) => part === "node_modules" || part === ".git" || part === "dist",
+    );
+}
+
+export function watchDirectories(
+  root: string,
+  paths: LoadedProject["paths"],
+  outside: readonly string[],
+) {
+  const dirs = [
+    root,
+    paths.public,
+    paths.service,
+    path.dirname(paths.versioning),
+  ];
+  if (paths.config) {
+    dirs.push(path.dirname(paths.config));
+  }
+  for (const file of outside) {
+    dirs.push(path.dirname(file));
+  }
+  return [...new Set(dirs.map((dir) => path.resolve(dir)))];
+}
+
+export async function refreshDevProject(input: {
+  running: boolean;
+  load: () => Promise<LoadedProject>;
+  boot: () => Promise<void>;
+  swap: (project: LoadedProject) => void;
+}) {
+  if (!input.running) {
+    try {
+      await input.boot();
+      return "booted" as const;
+    } catch (error) {
+      return { error, waiting: true as const };
+    }
+  }
+  try {
+    const project = await input.load();
+    input.swap(project);
+    return "reloaded" as const;
+  } catch (error) {
+    return { error, waiting: false as const };
+  }
+}
+
+export function subscribeDirectories(
+  directories: readonly string[],
+  onFile: (file: string | null) => void,
+  open: (
+    directory: string,
+    onFile: (file: string | null) => void,
+  ) => { close: () => void } = defaultWatch,
+) {
+  const watchers = new Map<string, { close: () => void }>();
+  const add = (directory: string) => {
+    const resolved = path.resolve(directory);
+    if (watchers.has(resolved) || !existsSync(resolved)) {
+      return;
+    }
+    watchers.set(resolved, open(resolved, onFile));
+  };
+  for (const directory of directories) {
+    add(directory);
+  }
+  return {
+    add,
+    close() {
+      for (const watcher of watchers.values()) {
+        watcher.close();
+      }
+      watchers.clear();
+    },
+  };
+}
+
+export async function runDev(root = process.cwd()) {
+  let running: Awaited<ReturnType<typeof listen>> | null = null;
+  let generation = 0;
+  let busy = false;
+  let queued = false;
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  const refresh = async () => {
+    if (busy) {
+      queued = true;
+      return;
+    }
+    busy = true;
+    try {
+      generation += 1;
+      const token = String(generation);
+      if (running) {
+        printReloading();
+      }
+      const result = await refreshDevProject({
+        running: running !== null,
+        load: () => loadProject(root, { generation: token }),
+        boot: async () => {
+          running = await listen(root, { generation: token });
+          printServers(running);
+        },
+        swap(project) {
+          running?.reload(project);
+        },
+      });
+      if (result === "reloaded") {
+        printProjectReady();
+      } else if (typeof result === "object") {
+        console.error(
+          formatProjectFailure(readProjectFailure(result.error), {
+            wait: result.waiting,
+            color: process.stderr.isTTY === true,
+          }),
+        );
+      }
+      if (running) {
+        for (const directory of watchDirectories(
+          root,
+          running.paths,
+          projectDependenciesOutsideRoot(),
+        )) {
+          subscription.add(directory);
+        }
+      }
+    } finally {
+      busy = false;
+      if (queued) {
+        queued = false;
+        await refresh();
+      }
+    }
+  };
+  const subscription = subscribeDirectories([root], (file) => {
+    if (file && isIgnoredWatch(file)) {
+      return;
+    }
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      timer = null;
+      void refresh();
+    }, reloadDebounceMs);
+  });
+  await refresh();
+  await new Promise(() => {});
+}
+
+function defaultWatch(
+  directory: string,
+  onFile: (file: string | null) => void,
+) {
+  const watcher = watchDirectory(
+    directory,
+    { recursive: true },
+    (_event, filename) => {
+      onFile(filename === null ? null : String(filename));
+    },
+  );
+  watcher.on("error", () => {});
+  return { close: () => watcher.close() };
+}

package/src/cli/generate-project.ts

@@ -0,0 +1,39 @@
+import { Chalk } from "chalk";
+import { generateRepositories } from "../repository/generate.ts";
+import { formatProjectFailure, readProjectFailure } from "./run-project.ts";
+
+export function formatGenerate(
+  output: string,
+  tables: readonly string[],
+  color = false,
+) {
+  const style = new Chalk({ level: color ? 1 : 0 });
+  const row = (label: string, value: string) =>
+    `  ${style.dim(`- ${label.padEnd(10)}`)} ${value}`;
+  const names = tables.length > 0 ? tables.join(", ") : "none";
+  return `\n  ${style.dim("GENERATE")}\n\n${row("File", output)}\n${row("Tables", names)}\n`;
+}
+
+export async function runGenerate(root = process.cwd()) {
+  try {
+    const generated = await generateRepositories(root);
+    console.log(
+      formatGenerate(
+        generated.output,
+        generated.tables,
+        process.stdout.isTTY === true,
+      ),
+    );
+  } catch (error) {
+    console.error(
+      formatProjectFailure(readProjectFailure(error), {
+        wait: false,
+        color: process.stderr.isTTY === true,
+      }),
+    );
+    process.exitCode = 1;
+  }
+  if (process.exitCode === 1) {
+    process.exit(1);
+  }
+}

package/src/cli/index.ts

@@ -0,0 +1,29 @@
+#!/usr/bin/env bun
+import { defineCommand, runMain } from "citty";
+import { printStartup } from "./banner.ts";
+import { build } from "./commands/build.ts";
+import { dev } from "./commands/dev.ts";
+import { generate } from "./commands/generate.ts";
+import { init } from "./commands/init.ts";
+import { migrate } from "./commands/migrate.ts";
+import { seed } from "./commands/seed.ts";
+import { start } from "./commands/start.ts";
+
+const main = defineCommand({
+  meta: {
+    name: "keja",
+    description: "Run Keja",
+  },
+  subCommands: {
+    dev,
+    start,
+    migrate,
+    generate,
+    seed,
+    build,
+    init,
+  },
+});
+
+printStartup();
+runMain(main);