keryx 0.3.0 → 0.3.2

package/initializers/db.ts

@@ -31,7 +31,7 @@ export class DB extends Initializer {
   async initialize() {
     const dbContainer = {} as {
       db: ReturnType<typeof drizzle>;
-      pool: Pool;
+      pool: InstanceType<typeof Pool>;
     };
     return Object.assign(
       {
@@ -104,7 +104,7 @@ export class DB extends Initializer {
     const migrationConfig = {
       schema: path.join("models", "*"),
       dbCredentials: {
-        uri: config.database.connectionString,
+        url: config.database.connectionString,
       },
       out: path.join("drizzle"),
     } satisfies DrizzleMigrateConfig;

package/keryx.ts

@@ -11,6 +11,7 @@ import {
   scaffoldProject,
   type ScaffoldOptions,
 } from "./util/scaffold";
+import { upgradeProject } from "./util/upgrade";
 
 const program = new Command();
 program.name(pkg.name).description(pkg.description).version(pkg.version);
@@ -57,6 +58,25 @@ Done! To get started:
     process.exit(0);
   });
 
+program
+  .command("upgrade")
+  .summary("Update framework-owned files to match the installed keryx version")
+  .option("--dry-run", "Show what would change without writing files")
+  .option("--force", "Overwrite all framework files without confirmation")
+  .option("-y, --yes", "Overwrite all framework files without confirmation")
+  .action(async (opts) => {
+    try {
+      await upgradeProject(process.cwd(), {
+        dryRun: opts.dryRun || false,
+        force: opts.force || opts.yes || false,
+      });
+      process.exit(0);
+    } catch (e) {
+      console.error((e as Error).message);
+      process.exit(1);
+    }
+  });
+
 program
   .command("start")
   .summary("Run the server")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "keryx",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "module": "index.ts",
   "type": "module",
   "license": "MIT",

package/util/scaffold.ts

@@ -51,6 +51,120 @@ export async function interactiveScaffold(
   return { projectName, options: { includeDb, includeExample } };
 }
 
+/**
+ * Generate config file contents from the framework config directory,
+ * with imports rewritten for user projects.
+ * Returns a Map of relativePath → content (e.g., "config/index.ts" → "...").
+ */
+export async function generateConfigFileContents(): Promise<
+  Map<string, string>
+> {
+  const result = new Map<string, string>();
+  const configDir = path.join(import.meta.dir, "..", "config");
+  const glob = new Glob("**/*.ts");
+
+  for await (const file of glob.scan(configDir)) {
+    let content = await Bun.file(path.join(configDir, file)).text();
+
+    // Rewrite relative imports to package imports
+    content = content.replace(
+      /from ["']\.\.\/\.\.\/util\/config["']/g,
+      'from "keryx"',
+    );
+    content = content.replace(
+      /from ["']\.\.\/util\/config["']/g,
+      'from "keryx"',
+    );
+    content = content.replace(
+      /from ["']\.\.\/classes\/Logger["']/g,
+      'from "keryx/classes/Logger.ts"',
+    );
+
+    // In index.ts, change `export const config` to `export default`
+    // and remove the KeryxConfig type export (it comes from the package)
+    if (file === "index.ts") {
+      content = content.replace("export const config =", "export default");
+      content = content.replace(
+        /\nexport type KeryxConfig = typeof config;\n/,
+        "\n",
+      );
+    }
+
+    result.set(`config/${file}`, content);
+  }
+
+  return result;
+}
+
+/**
+ * Generate built-in action file contents (status.ts, swagger.ts)
+ * with imports rewritten for user projects.
+ * Returns a Map of relativePath → content (e.g., "actions/status.ts" → "...").
+ */
+export async function generateBuiltinActionContents(): Promise<
+  Map<string, string>
+> {
+  const result = new Map<string, string>();
+  const builtinActions = ["status.ts", "swagger.ts"];
+  const actionsDir = path.join(import.meta.dir, "..", "actions");
+
+  for (const file of builtinActions) {
+    let content = await Bun.file(path.join(actionsDir, file)).text();
+
+    // Rewrite relative imports to package imports
+    content = content.replace(/from ["']\.\.\/api["']/g, 'from "keryx"');
+    content = content.replace(
+      /from ["']\.\.\/classes\/Action["']/g,
+      'from "keryx/classes/Action.ts"',
+    );
+    content = content.replace(
+      /from ["']\.\.\/package\.json["']/g,
+      'from "../package.json"',
+    );
+
+    result.set(`actions/${file}`, content);
+  }
+
+  return result;
+}
+
+/**
+ * Generate the tsconfig.json content for scaffolded projects.
+ */
+export function generateTsconfigContents(): string {
+  return (
+    JSON.stringify(
+      {
+        compilerOptions: {
+          lib: ["ESNext"],
+          target: "ESNext",
+          module: "ESNext",
+          moduleResolution: "bundler",
+          types: ["bun-types"],
+          strict: true,
+          skipLibCheck: true,
+          noEmit: true,
+          esModuleInterop: true,
+          resolveJsonModule: true,
+          isolatedModules: true,
+          verbatimModuleSyntax: true,
+          noImplicitAny: true,
+          noImplicitReturns: true,
+          noUnusedLocals: true,
+          noUnusedParameters: true,
+          noFallthroughCasesInSwitch: true,
+          forceConsistentCasingInFileNames: true,
+          allowImportingTsExtensions: true,
+        },
+        include: ["**/*.ts"],
+        exclude: ["node_modules", "drizzle"],
+      },
+      null,
+      2,
+    ) + "\n"
+  );
+}
+
 export async function scaffoldProject(
   projectName: string,
   targetDir: string,
@@ -115,75 +229,17 @@ export async function scaffoldProject(
     ) + "\n",
   );
 
-  // tsconfig.json is static JSON (no interpolation needed)
-  await write(
-    "tsconfig.json",
-    JSON.stringify(
-      {
-        compilerOptions: {
-          lib: ["ESNext"],
-          target: "ESNext",
-          module: "ESNext",
-          moduleResolution: "bundler",
-          types: ["bun-types"],
-          strict: true,
-          skipLibCheck: true,
-          noEmit: true,
-          esModuleInterop: true,
-          resolveJsonModule: true,
-          isolatedModules: true,
-          verbatimModuleSyntax: true,
-          noImplicitAny: true,
-          noImplicitReturns: true,
-          noUnusedLocals: true,
-          noUnusedParameters: true,
-          noFallthroughCasesInSwitch: true,
-          forceConsistentCasingInFileNames: true,
-          allowImportingTsExtensions: true,
-        },
-        include: ["**/*.ts"],
-        exclude: ["node_modules", "drizzle"],
-      },
-      null,
-      2,
-    ) + "\n",
-  );
+  await write("tsconfig.json", generateTsconfigContents());
 
   await writeTemplate("index.ts", "index.ts.mustache");
   await writeTemplate("keryx.ts", "keryx.ts.mustache");
   await writeTemplate(".env.example", "env.example.mustache");
   await writeTemplate(".gitignore", "gitignore.mustache");
-  // Copy config files from the framework, adjusting imports for user projects
-  const configDir = path.join(import.meta.dir, "..", "config");
-  const glob = new Glob("**/*.ts");
-  for await (const file of glob.scan(configDir)) {
-    let content = await Bun.file(path.join(configDir, file)).text();
 
-    // Rewrite relative imports to package imports
-    content = content.replace(
-      /from ["']\.\.\/\.\.\/util\/config["']/g,
-      'from "keryx"',
-    );
-    content = content.replace(
-      /from ["']\.\.\/util\/config["']/g,
-      'from "keryx"',
-    );
-    content = content.replace(
-      /from ["']\.\.\/classes\/Logger["']/g,
-      'from "keryx/classes/Logger.ts"',
-    );
-
-    // In index.ts, change `export const config` to `export default`
-    // and remove the KeryxConfig type export (it comes from the package)
-    if (file === "index.ts") {
-      content = content.replace("export const config =", "export default");
-      content = content.replace(
-        /\nexport type KeryxConfig = typeof config;\n/,
-        "\n",
-      );
-    }
-
-    await write(`config/${file}`, content);
+  // Copy config files from the framework, adjusting imports for user projects
+  const configFiles = await generateConfigFileContents();
+  for (const [filePath, content] of configFiles) {
+    await write(filePath, content);
   }
 
   // Create empty directories with .gitkeep
@@ -200,24 +256,9 @@ export async function scaffoldProject(
   }
 
   // --- Built-in actions (always included) ---
-  // Copy status and swagger actions from the framework, adjusting imports
-  const builtinActions = ["status.ts", "swagger.ts"];
-  const actionsDir = path.join(import.meta.dir, "..", "actions");
-  for (const file of builtinActions) {
-    let content = await Bun.file(path.join(actionsDir, file)).text();
-
-    // Rewrite relative imports to package imports
-    content = content.replace(/from ["']\.\.\/api["']/g, 'from "keryx"');
-    content = content.replace(
-      /from ["']\.\.\/classes\/Action["']/g,
-      'from "keryx/classes/Action.ts"',
-    );
-    content = content.replace(
-      /from ["']\.\.\/package\.json["']/g,
-      'from "../package.json"',
-    );
-
-    await write(`actions/${file}`, content);
+  const actionFiles = await generateBuiltinActionContents();
+  for (const [filePath, content] of actionFiles) {
+    await write(filePath, content);
   }
 
   // --- Example action ---

package/util/upgrade.ts

@@ -0,0 +1,163 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import * as readline from "readline";
+import pkg from "../package.json";
+import {
+  generateBuiltinActionContents,
+  generateConfigFileContents,
+  generateTsconfigContents,
+} from "./scaffold";
+
+export interface UpgradeOptions {
+  dryRun: boolean;
+  force: boolean;
+}
+
+interface UpgradeSummary {
+  updated: number;
+  created: number;
+  skipped: number;
+  upToDate: number;
+}
+
+async function promptOverwrite(filePath: string): Promise<"y" | "n" | "d"> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  return new Promise((resolve) => {
+    rl.question(`  Overwrite ${filePath}? (y/n/d for diff) `, (answer) => {
+      rl.close();
+      const a = answer.trim().toLowerCase();
+      if (a === "d") resolve("d");
+      else if (a === "y") resolve("y");
+      else resolve("n");
+    });
+  });
+}
+
+async function showDiff(
+  existingPath: string,
+  newContent: string,
+): Promise<void> {
+  const tmpFile = path.join(
+    os.tmpdir(),
+    `keryx-upgrade-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  await Bun.write(tmpFile, newContent);
+  try {
+    const proc = Bun.spawn(["diff", "-u", existingPath, tmpFile], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const output = await new Response(proc.stdout).text();
+    await proc.exited;
+    if (output) {
+      console.log(output);
+    }
+  } finally {
+    fs.unlinkSync(tmpFile);
+  }
+}
+
+export async function upgradeProject(
+  targetDir: string,
+  options: UpgradeOptions,
+): Promise<void> {
+  // Validate this is a keryx project
+  const pkgPath = path.join(targetDir, "package.json");
+  if (!fs.existsSync(pkgPath)) {
+    throw new Error(
+      "No package.json found. Run this command from a Keryx project directory.",
+    );
+  }
+
+  const projectPkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+  const deps = {
+    ...projectPkg.dependencies,
+    ...projectPkg.devDependencies,
+  };
+  if (!deps.keryx) {
+    throw new Error(
+      'This project does not have "keryx" as a dependency. Run this command from a Keryx project directory.',
+    );
+  }
+
+  console.log(`Upgrading project files to match keryx v${pkg.version}\n`);
+
+  // Generate all framework-owned file contents
+  const files = new Map<string, string>();
+
+  const configFiles = await generateConfigFileContents();
+  for (const [p, content] of configFiles) files.set(p, content);
+
+  const actionFiles = await generateBuiltinActionContents();
+  for (const [p, content] of actionFiles) files.set(p, content);
+
+  files.set("tsconfig.json", generateTsconfigContents());
+
+  const summary: UpgradeSummary = {
+    updated: 0,
+    created: 0,
+    skipped: 0,
+    upToDate: 0,
+  };
+
+  for (const [relativePath, newContent] of files) {
+    const fullPath = path.join(targetDir, relativePath);
+
+    if (!fs.existsSync(fullPath)) {
+      // New file — create it
+      if (!options.dryRun) {
+        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+        await Bun.write(fullPath, newContent);
+      }
+      console.log(`  + created  ${relativePath}`);
+      summary.created++;
+      continue;
+    }
+
+    const existingContent = await Bun.file(fullPath).text();
+    if (existingContent === newContent) {
+      console.log(`  ✓ up to date  ${relativePath}`);
+      summary.upToDate++;
+      continue;
+    }
+
+    // File differs
+    if (options.dryRun) {
+      console.log(`  ⚡ would update  ${relativePath}`);
+      summary.updated++;
+      continue;
+    }
+
+    if (options.force) {
+      await Bun.write(fullPath, newContent);
+      console.log(`  ⚡ updated  ${relativePath}`);
+      summary.updated++;
+      continue;
+    }
+
+    // Interactive prompt
+    let answer = await promptOverwrite(relativePath);
+    while (answer === "d") {
+      await showDiff(fullPath, newContent);
+      answer = await promptOverwrite(relativePath);
+    }
+
+    if (answer === "y") {
+      await Bun.write(fullPath, newContent);
+      console.log(`  ⚡ updated  ${relativePath}`);
+      summary.updated++;
+    } else {
+      console.log(`  ⊘ skipped  ${relativePath}`);
+      summary.skipped++;
+    }
+  }
+
+  console.log(
+    `\nUpdated ${summary.updated} file(s), created ${summary.created} file(s), ${summary.upToDate} already up to date` +
+      (summary.skipped > 0 ? `, ${summary.skipped} skipped` : ""),
+  );
+}