@ajke/cli 0.1.0

package/bin/generators/module.generator.ts

@@ -0,0 +1,266 @@
+import { writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { APP_MODULES_DIR, wiltImportPath, ensureDir } from "../utils/paths.js";
+
+function toPascalCase(name: string): string {
+  return name
+    .replace(/[-_](.)/g, (_, c) => c.toUpperCase())
+    .replace(/^(.)/, (_, c) => c.toUpperCase());
+}
+
+function toCamelCase(name: string): string {
+  const pascal = toPascalCase(name);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+
+function toKebabCase(name: string): string {
+  return name
+    .replace(/([A-Z])/g, "-$1")
+    .replace(/^-/, "")
+    .replace(/_/g, "-")
+    .toLowerCase();
+}
+
+function pluralize(name: string): string {
+  return name.endsWith("s") ? name : name + "s";
+}
+
+function moduleTemplate(name: string, wiltPath: string): string {
+  const pascal = toPascalCase(name);
+  const kebab = toKebabCase(name);
+
+  return `import { Module } from "${wiltPath}";
+import { ${pascal}Controller } from "./${kebab}.controller";
+import { ${pascal}Service } from "./${kebab}.service";
+
+@Module({
+  controllers: [${pascal}Controller],
+  providers: [${pascal}Service],
+  exports: [${pascal}Service],
+})
+export class ${pascal}Module {}
+`;
+}
+
+function entityTemplate(name: string): string {
+  const camel = toCamelCase(name);
+  const kebab = toKebabCase(name);
+  const pascal = toPascalCase(name);
+  const entityVar = pluralize(camel);
+  const tableName = pluralize(kebab);
+
+  return `import { sqliteTable, integer } from "drizzle-orm/sqlite-core";
+
+export const ${entityVar} = sqliteTable("${tableName}", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  createdAt: integer("created_at", { mode: "timestamp" })
+    .$defaultFn(() => new Date())
+    .notNull(),
+});
+
+export type ${pascal} = typeof ${entityVar}.$inferSelect;
+export type New${pascal} = typeof ${entityVar}.$inferInsert;
+`;
+}
+
+function controllerTemplate(name: string, wiltPath: string): string {
+  const pascal = toPascalCase(name);
+  const camel = toCamelCase(name);
+  const kebab = toKebabCase(name);
+  return `import type { Context } from "hono";
+import { Controller, Get, Inject } from "${wiltPath}";
+import { ResponseUtil } from "${wiltPath}";
+import { ${pascal}Service } from "./${kebab}.service";
+
+@Controller("/${kebab}")
+export class ${pascal}Controller {
+  constructor(@Inject(${pascal}Service) private ${camel}Service: ${pascal}Service) {}
+
+  @Get()
+  async getAll(c: Context) {
+    const data = await this.${camel}Service.findAll();
+    return ResponseUtil.success(c, data);
+  }
+}
+`;
+}
+
+function serviceTemplate(name: string, wiltPath: string): string {
+  const pascal = toPascalCase(name);
+  return `import { Injectable } from "${wiltPath}";
+import { createDatabase } from "../../../database/connection";
+
+@Injectable()
+export class ${pascal}Service {
+
+  private getDatabase(env: CloudflareBindings) {
+    return createDatabase(env.DB);
+  }
+
+  async findAll() {
+    return [];
+  }
+}
+`;
+}
+
+function testTemplate(name: string): string {
+  const kebab = toKebabCase(name);
+  const pascal = toPascalCase(name);
+  const table = pluralize(kebab.replace(/-/g, "_"));
+  return `import { describe, it, expect, beforeAll, afterEach } from "vitest";
+import { SELF, env, applyD1Migrations } from "cloudflare:test";
+import { ${pascal}Service } from "./${kebab}.service";
+
+const BASE = "http://localhost";
+const service = new ${pascal}Service();
+
+beforeAll(async () => {
+  await applyD1Migrations(env.DB, JSON.parse(env.TEST_MIGRATIONS));
+});
+
+afterEach(async () => {
+  await env.DB.prepare("DELETE FROM ${table}").run();
+});
+
+describe("${pascal}Service", () => {
+  it("should be defined", () => {
+    expect(service).toBeDefined();
+  });
+});
+
+describe("GET /${kebab}", () => {
+  it("returns an empty list", async () => {
+    const res = await SELF.fetch(\`\${BASE}/${kebab}\`);
+    expect(res.status).toBe(200);
+    const { data } = await res.json() as { data: unknown[] };
+    expect(data).toEqual([]);
+  });
+});
+`;
+}
+
+function dtoTemplate(name: string): string {
+  const pascal = toPascalCase(name);
+  return `import { z } from "zod";
+
+export const Create${pascal}Dto = z.object({
+  // TODO: define your fields
+});
+
+export const Update${pascal}Dto = Create${pascal}Dto.partial();
+
+export type Create${pascal}DtoType = z.infer<typeof Create${pascal}Dto>;
+export type Update${pascal}DtoType = z.infer<typeof Update${pascal}Dto>;
+`;
+}
+
+export type GeneratableFile = "module" | "controller" | "service" | "dto" | "entity" | "test";
+
+export interface GenerateModuleOptions {
+  /** Override output directory — defaults to config.modulesDir/<name>/ */
+  dir?: string;
+  /** Which files to generate — defaults to config.generate.files */
+  files?: GeneratableFile[];
+  /** Base directory for generated modules (from wilt.config.ts) */
+  modulesDir?: string;
+  /** Default file list (from wilt.config.ts) */
+  defaultFiles?: GeneratableFile[];
+  /** Skip generating the test file even if it is in defaultFiles */
+  noTest?: boolean;
+}
+
+export function generateModule(name: string, options: GenerateModuleOptions = {}): void {
+  const kebab = toKebabCase(name);
+  const pascal = toPascalCase(name);
+  const basedir = options.modulesDir ?? APP_MODULES_DIR;
+  const moduleDir = options.dir ?? join(basedir, kebab);
+  let filesToGen = options.files ?? options.defaultFiles ?? ["module", "controller", "service", "dto", "entity", "test"];
+  if (options.noTest) filesToGen = filesToGen.filter((f) => f !== "test");
+
+  if (existsSync(moduleDir)) {
+    console.error(`  ✗ Directory already exists: ${moduleDir}`);
+    process.exit(1);
+  }
+
+  ensureDir(moduleDir);
+
+  const wiltPath = wiltImportPath();
+  const hasEntity = filesToGen.includes("entity");
+
+  const fileMap: Record<string, string> = {
+    module: moduleTemplate(name, wiltPath),
+    controller: controllerTemplate(name, wiltPath),
+    service: serviceTemplate(name, wiltPath),
+    dto: dtoTemplate(name),
+    entity: entityTemplate(name),
+    test: testTemplate(name),
+  };
+
+  const extMap: Record<string, string> = {
+    module: `${kebab}.module.ts`,
+    controller: `${kebab}.controller.ts`,
+    service: `${kebab}.service.ts`,
+    dto: `${kebab}.dto.ts`,
+    entity: `${kebab}.entity.ts`,
+    test: `${kebab}.test.ts`,
+  };
+
+  for (const file of filesToGen) {
+    const filePath = join(moduleDir, extMap[file]);
+    writeFileSync(filePath, fileMap[file], "utf-8");
+    console.log(`  ✔ Created ${filePath.replace(process.cwd() + "/", "")}`);
+  }
+
+  const relModuleDir = moduleDir.replace(process.cwd() + "/", "");
+  const entityLine = hasEntity
+    ? `\n  2. Add the entity to src/database/schema.ts:\n\n    import { ${pluralize(toCamelCase(name))} } from "@app/${relModuleDir.replace(/^src\//, "")}/${kebab}.entity";\n\n    export const schema = {\n      ...existing,\n      ${pluralize(toCamelCase(name))},\n    };\n`
+    : "";
+  console.log(`
+  Next steps —
+
+  1. Register the module in src/app.module.ts:
+
+    import { ${pascal}Module } from "./${relModuleDir.replace(/^src\//, "")}/${kebab}.module";
+
+    @Module({
+      imports: [..., ${pascal}Module],
+    })
+    export class AppModule {}
+${entityLine}  Then run \`pnpm db:gen\` to generate a migration.
+`);
+}
+
+export function generateService(name: string, dir?: string, modulesDir?: string): void {
+  const kebab = toKebabCase(name);
+  const basedir = modulesDir ?? APP_MODULES_DIR;
+  const targetDir = dir ?? join(basedir, kebab);
+  const wiltPath = wiltImportPath();
+  const filePath = join(targetDir, `${kebab}.service.ts`);
+
+  if (existsSync(filePath)) {
+    console.error(`  ✗ File already exists: ${filePath}`);
+    process.exit(1);
+  }
+
+  ensureDir(targetDir);
+  writeFileSync(filePath, serviceTemplate(name, wiltPath), "utf-8");
+  console.log(`  ✔ Created ${filePath.replace(process.cwd() + "/", "")}`);
+}
+
+export function generateController(name: string, dir?: string, modulesDir?: string): void {
+  const kebab = toKebabCase(name);
+  const basedir = modulesDir ?? APP_MODULES_DIR;
+  const targetDir = dir ?? join(basedir, kebab);
+  const wiltPath = wiltImportPath();
+  const filePath = join(targetDir, `${kebab}.controller.ts`);
+
+  if (existsSync(filePath)) {
+    console.error(`  ✗ File already exists: ${filePath}`);
+    process.exit(1);
+  }
+
+  ensureDir(targetDir);
+  writeFileSync(filePath, controllerTemplate(name, wiltPath), "utf-8");
+  console.log(`  ✔ Created ${filePath.replace(process.cwd() + "/", "")}`);
+}

package/bin/utils/config.ts

@@ -0,0 +1,43 @@
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+export interface WiltConfig {
+  modulesDir?: string;
+  srcDir?: string;
+  generate?: {
+    files?: Array<"module" | "controller" | "service" | "dto" | "entity">;
+  };
+}
+
+export interface ResolvedWiltConfig {
+  modulesDir: string;
+  srcDir: string;
+  generate: {
+    files: Array<"module" | "controller" | "service" | "dto" | "entity">;
+  };
+}
+
+export async function loadConfig(cwd: string = process.cwd()): Promise<ResolvedWiltConfig> {
+  let userConfig: WiltConfig = {};
+
+  for (const name of ["ajke.config.ts", "ajke.config.js", "ajke.config.mjs", "wilt.config.ts", "wilt.config.js", "wilt.config.mjs"]) {
+    const configPath = join(cwd, name);
+    if (existsSync(configPath)) {
+      try {
+        const mod = await import(configPath);
+        userConfig = mod.default ?? {};
+      } catch {
+        // .ts files require tsx; compiled binary falls back to defaults
+      }
+      break;
+    }
+  }
+
+  return {
+    modulesDir: resolve(cwd, userConfig.modulesDir ?? "src/modules/app"),
+    srcDir: resolve(cwd, userConfig.srcDir ?? "src"),
+    generate: {
+      files: userConfig.generate?.files ?? ["module", "controller", "service", "dto", "entity"],
+    },
+  };
+}

package/bin/utils/paths.ts

@@ -0,0 +1,32 @@
+import { join } from "node:path";
+import { existsSync, mkdirSync } from "node:fs";
+
+/** Absolute path to the project root (where the CLI is invoked from) */
+export const PROJECT_ROOT = process.cwd();
+
+/** Absolute path to src/ */
+export const SRC_DIR = join(PROJECT_ROOT, "src");
+
+/** Absolute path to src/modules/ */
+export const MODULES_DIR = join(SRC_DIR, "modules");
+
+/** Absolute path to src/modules/app/ (default location for generated modules) */
+export const APP_MODULES_DIR = join(MODULES_DIR, "app");
+
+/** Absolute path to wrangler.jsonc */
+export const WRANGLER_JSONC = join(PROJECT_ROOT, "wrangler.jsonc");
+
+/** Absolute path to src/app.module.ts */
+export const APP_MODULE_FILE = join(SRC_DIR, "app.module.ts");
+
+/** The @ajke/core import used in generated files */
+export function wiltImportPath(): string {
+  return "@ajke/core";
+}
+
+/** Ensure a directory exists, creating it recursively if needed */
+export function ensureDir(dir: string): void {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}

package/bin/utils/wrangler.ts

@@ -0,0 +1,216 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { WRANGLER_JSONC } from "./paths.js";
+
+type WranglerConfig = Record<string, any>;
+
+/** Strip `//` line comments from a JSONC string so JSON.parse can handle it. */
+function stripComments(text: string): string {
+  return text
+    .split("\n")
+    .map((line) => line.replace(/\s*\/\/.*$/, ""))
+    .join("\n");
+}
+
+export function readWrangler(): WranglerConfig {
+  const raw = readFileSync(WRANGLER_JSONC, "utf-8");
+  return JSON.parse(stripComments(raw));
+}
+
+export function writeWrangler(config: WranglerConfig): void {
+  const header = `{\n  "$schema": "node_modules/wrangler/config-schema.json",`;
+  const body = JSON.stringify(config, null, 2);
+
+  // Remove opening brace and $schema from body (we add them above with the comment header)
+  const bodyWithoutSchema = body
+    .replace(/^\{/, "")
+    .replace(/\s+"?\$schema"?\s*:\s*"[^"]*",?\n/, "\n");
+
+  writeFileSync(WRANGLER_JSONC, header + bodyWithoutSchema, "utf-8");
+}
+
+// ─── Binding mutators ────────────────────────────────────────────────────────
+
+export function addD1(binding: string, databaseName: string): void {
+  const config = readWrangler();
+  if (!config.d1_databases) config.d1_databases = [];
+
+  const alreadyExists = config.d1_databases.some(
+    (db: any) => db.binding === binding
+  );
+  if (alreadyExists) {
+    console.error(`  ✗ D1 binding "${binding}" already exists in wrangler.jsonc`);
+    process.exit(1);
+  }
+
+  config.d1_databases.push({
+    binding,
+    database_name: databaseName,
+    database_id: "00000000-0000-0000-0000-000000000000",
+    migrations_dir: "migrations",
+  });
+
+  writeWrangler(config);
+  console.log(`  ✔ Added D1 binding "${binding}" (database: ${databaseName})`);
+  console.log(`  ! Remember to replace database_id with your actual D1 database ID.`);
+}
+
+export function addR2(binding: string, bucketName: string): void {
+  const config = readWrangler();
+  if (!config.r2_buckets) config.r2_buckets = [];
+
+  if (config.r2_buckets.some((b: any) => b.binding === binding)) {
+    console.error(`  ✗ R2 binding "${binding}" already exists in wrangler.jsonc`);
+    process.exit(1);
+  }
+
+  config.r2_buckets.push({
+    binding,
+    bucket_name: bucketName,
+    preview_bucket_name: `${bucketName}-preview`,
+  });
+
+  writeWrangler(config);
+  console.log(`  ✔ Added R2 binding "${binding}" (bucket: ${bucketName})`);
+}
+
+export function addKv(binding: string): void {
+  const config = readWrangler();
+  if (!config.kv_namespaces) config.kv_namespaces = [];
+
+  if (config.kv_namespaces.some((k: any) => k.binding === binding)) {
+    console.error(`  ✗ KV binding "${binding}" already exists in wrangler.jsonc`);
+    process.exit(1);
+  }
+
+  config.kv_namespaces.push({
+    binding,
+    id: "00000000000000000000000000000000",
+  });
+
+  writeWrangler(config);
+  console.log(`  ✔ Added KV namespace binding "${binding}"`);
+  console.log(`  ! Remember to replace id with your actual KV namespace ID.`);
+}
+
+export function addQueue(binding: string, queueName: string): void {
+  const config = readWrangler();
+  if (!config.queues) config.queues = { producers: [], consumers: [] };
+  if (!config.queues.producers) config.queues.producers = [];
+  if (!config.queues.consumers) config.queues.consumers = [];
+
+  if (config.queues.producers.some((p: any) => p.binding === binding)) {
+    console.error(`  ✗ Queue producer binding "${binding}" already exists in wrangler.jsonc`);
+    process.exit(1);
+  }
+
+  config.queues.producers.push({ binding, queue: queueName });
+  config.queues.consumers.push({
+    queue: queueName,
+    max_batch_size: 10,
+    max_batch_timeout: 10,
+    max_retries: 3,
+  });
+
+  writeWrangler(config);
+  console.log(`  ✔ Added Queue binding "${binding}" (queue: ${queueName})`);
+}
+
+export function addAi(binding: string): void {
+  const config = readWrangler();
+
+  if (config.ai) {
+    console.error(`  ✗ AI binding already exists in wrangler.jsonc`);
+    process.exit(1);
+  }
+
+  config.ai = { binding };
+  writeWrangler(config);
+  console.log(`  ✔ Added AI binding "${binding}"`);
+}
+
+export function addDurableObject(binding: string, className: string): void {
+  const config = readWrangler();
+  if (!config.durable_objects) config.durable_objects = { bindings: [] };
+  if (!config.durable_objects.bindings) config.durable_objects.bindings = [];
+
+  if (config.durable_objects.bindings.some((b: any) => b.name === binding)) {
+    console.error(`  ✗ Durable Object binding "${binding}" already exists in wrangler.jsonc`);
+    process.exit(1);
+  }
+
+  config.durable_objects.bindings.push({
+    name: binding,
+    class_name: className,
+  });
+
+  // Also add a migration entry
+  if (!config.migrations) config.migrations = [];
+  const existingClasses: string[] = config.migrations.flatMap(
+    (m: any) => m.new_sqlite_classes ?? m.new_classes ?? []
+  );
+  if (!existingClasses.includes(className)) {
+    const nextTag = `v${config.migrations.length + 1}`;
+    config.migrations.push({
+      tag: nextTag,
+      new_sqlite_classes: [className],
+    });
+    console.log(`  ! Added migration entry "${nextTag}" for ${className}.`);
+  }
+
+  writeWrangler(config);
+  console.log(`  ✔ Added Durable Object binding "${binding}" (class: ${className})`);
+}
+
+export function addVectorize(binding: string, indexName: string, dimensions: number = 1536): void {
+  const config = readWrangler();
+  if (!config.vectorize) config.vectorize = [];
+
+  if (config.vectorize.some((v: any) => v.binding === binding)) {
+    console.error(`  ✗ Vectorize binding "${binding}" already exists in wrangler.jsonc`);
+    process.exit(1);
+  }
+
+  config.vectorize.push({
+    binding,
+    index_name: indexName,
+    dimensions,
+    metric: "cosine",
+  });
+
+  writeWrangler(config);
+  console.log(`  ✔ Added Vectorize binding "${binding}" (index: ${indexName}, dimensions: ${dimensions})`);
+  console.log(`  ! Create the index with: wrangler vectorize create ${indexName} --dimensions=${dimensions} --metric=cosine`);
+}
+
+export function addBrowser(binding: string): void {
+  const config = readWrangler();
+
+  if (config.browser) {
+    console.error(`  ✗ Browser binding already exists in wrangler.jsonc`);
+    process.exit(1);
+  }
+
+  config.browser = { binding };
+  writeWrangler(config);
+  console.log(`  ✔ Added Browser rendering binding "${binding}"`);
+}
+
+export function addHyperdrive(binding: string, connectionString: string): void {
+  const config = readWrangler();
+  if (!config.hyperdrive) config.hyperdrive = [];
+
+  if (config.hyperdrive.some((h: any) => h.binding === binding)) {
+    console.error(`  ✗ Hyperdrive binding "${binding}" already exists in wrangler.jsonc`);
+    process.exit(1);
+  }
+
+  config.hyperdrive.push({
+    binding,
+    id: "00000000000000000000000000000000",
+    localConnectionString: connectionString,
+  });
+
+  writeWrangler(config);
+  console.log(`  ✔ Added Hyperdrive binding "${binding}"`);
+  console.log(`  ! Remember to replace id with your actual Hyperdrive config ID.`);
+}