@sohan_fahad/wilt 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Wilt Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,250 @@
+# Wilt
+
+A NestJS-like framework for **Cloudflare Workers** built on [Hono](https://hono.dev). Write modular, decorator-driven APIs that deploy to the edge — no server required.
+
+```bash
+npx wilt new my-app
+```
+
+## Features
+
+- **Module system** — `@Module`, `@Controller`, `@Injectable` decorators like NestJS
+- **Dependency injection** — powered by [tsyringe](https://github.com/microsoft/tsyringe)
+- **Validation** — Zod schema decorators for body, query, and params
+- **Built-in middleware** — request logger, CORS, secure headers
+- **CLI** — scaffold projects, modules, services, controllers, and Cloudflare service bindings
+
+## Requirements
+
+- Node 20+
+- [pnpm](https://pnpm.io/), npm, or bun
+
+## Quick Start
+
+```bash
+npx wilt new my-app
+cd my-app
+pnpm db:migrate   # apply local D1 migrations
+pnpm dev          # http://localhost:4001
+```
+
+```bash
+curl http://localhost:4001/health
+curl http://localhost:4001/hello
+```
+
+## CLI
+
+### `wilt new`
+
+Scaffold a new Wilt project with a Hello module, D1 setup, Drizzle config, and Wrangler config.
+
+```bash
+npx wilt new <project-name>
+```
+
+### `wilt generate`
+
+Scaffold files inside an existing project.
+
+```bash
+npx wilt generate module <name>       # module + controller + service + dto
+npx wilt generate service <name>
+npx wilt generate controller <name>
+
+# --path to target a specific directory
+npx wilt generate service payment --path src/modules/app/payment
+
+# Short aliases
+npx wilt g m <name>
+npx wilt g s <name>
+npx wilt g c <name>
+```
+
+### `wilt add`
+
+Add a Cloudflare service binding directly to `wrangler.jsonc`.
+
+```bash
+npx wilt add d1 <BINDING> <database-name>
+npx wilt add r2 <BINDING> <bucket-name>
+npx wilt add kv <BINDING>
+npx wilt add queue <BINDING> <queue-name>
+npx wilt add ai <BINDING>
+npx wilt add durable-object <BINDING> <ClassName>
+npx wilt add vectorize <BINDING> <index-name> [dimensions]
+npx wilt add browser <BINDING>
+npx wilt add hyperdrive <BINDING> <connection-string>
+```
+
+**Examples:**
+
+```bash
+npx wilt add d1 PAYMENTS_DB payments-db
+npx wilt add r2 ASSETS_BUCKET my-assets
+npx wilt add kv SESSION_KV
+npx wilt add queue MAIL_QUEUE mailer
+npx wilt add durable-object CHAT_ROOM ChatRoom
+npx wilt add vectorize VECTOR_IDX my-index 1536
+```
+
+## Framework API
+
+### Decorators
+
+```ts
+import { Module, Controller, Injectable, Inject, Get, Post, Put, Delete } from "wilt";
+```
+
+| Decorator | Target | Description |
+| --- | --- | --- |
+| `@Module({ imports, controllers, providers })` | Class | Define a module |
+| `@Controller(prefix)` | Class | Register HTTP routes under a prefix |
+| `@Injectable()` | Class | Mark a class for DI |
+| `@Inject(token)` | Constructor param | Inject a dependency |
+| `@Get(path?)` | Method | GET route |
+| `@Post(path?)` | Method | POST route |
+| `@Put(path?)` | Method | PUT route |
+| `@Delete(path?)` | Method | DELETE route |
+
+### Validation
+
+```ts
+import { ZodBody, ZodQuery } from "wilt";
+import { z } from "zod";
+
+const CreatePostDto = z.object({ title: z.string(), body: z.string() });
+
+@Post()
+@ZodBody(CreatePostDto)
+async create(c: Context) { ... }
+```
+
+### `createModule`
+
+Bootstrap your app from the root module.
+
+```ts
+import { createModule } from "wilt";
+import { cors } from "hono/cors";
+import { requestLogger } from "wilt/middleware";
+import { AppModule } from "./app.module";
+
+const app = createModule(AppModule, {
+  middlewares: [cors(), requestLogger],
+});
+
+export default { fetch: app.fetch };
+```
+
+### `ResponseUtil`
+
+```ts
+import { ResponseUtil } from "wilt";
+
+return ResponseUtil.success(c, data);
+return ResponseUtil.error(c, "Not found", 404);
+```
+
+## Example Module
+
+```ts
+// posts/posts.module.ts
+import { Module } from "wilt";
+import { PostsController } from "./posts.controller";
+import { PostsService } from "./posts.service";
+
+@Module({
+  controllers: [PostsController],
+  providers: [PostsService],
+})
+export class PostsModule {}
+```
+
+```ts
+// posts/posts.controller.ts
+import type { Context } from "hono";
+import { Controller, Get, Post, Inject } from "wilt";
+import { ResponseUtil } from "wilt";
+import { ZodBody } from "wilt";
+import { PostsService } from "./posts.service";
+import { CreatePostDto } from "./posts.dto";
+
+@Controller("/posts")
+export class PostsController {
+  constructor(@Inject(PostsService) private postsService: PostsService) {}
+
+  @Get()
+  async list(c: Context) {
+    const posts = await this.postsService.findAll();
+    return ResponseUtil.success(c, posts);
+  }
+
+  @Post()
+  @ZodBody(CreatePostDto)
+  async create(c: Context) {
+    const body = await c.req.json();
+    const post = await this.postsService.create(body);
+    return ResponseUtil.success(c, post, 201);
+  }
+}
+```
+
+```ts
+// posts/posts.service.ts
+import { Injectable } from "wilt";
+
+@Injectable()
+export class PostsService {
+  async findAll() { ... }
+  async create(data: unknown) { ... }
+}
+```
+
+## Project Structure (generated)
+
+```
+my-app/
+├── src/
+│   ├── index.ts              # Worker entry
+│   ├── app.module.ts         # Root module
+│   ├── database/
+│   │   └── connection.ts     # Drizzle + D1
+│   └── modules/
+│       └── hello/            # Starter module
+├── migrations/               # D1 SQL migrations
+├── worker-configuration.d.ts # Cloudflare binding types (includes TEST_MIGRATIONS for tests)
+├── wrangler.jsonc            # Cloudflare Worker config
+├── tsconfig.json
+├── vite.config.ts
+└── .dev.vars.example         # Local secrets template (only needed for auth features)
+```
+
+## Peer Dependencies
+
+Installed automatically in generated projects:
+
+```json
+{
+  "hono": ">=4",
+  "reflect-metadata": ">=0.2",
+  "tsyringe": ">=4",
+  "zod": ">=3"
+}
+```
+
+## Deploy
+
+```bash
+pnpm deploy
+```
+
+Set your Cloudflare secrets before deploying to production:
+
+```bash
+wrangler secret put JWT_SECRET
+```
+
+## License
+
+MIT

package/bin/commands/add.ts

@@ -0,0 +1,155 @@
+import {
+  addD1,
+  addR2,
+  addKv,
+  addQueue,
+  addAi,
+  addDurableObject,
+  addVectorize,
+  addBrowser,
+  addHyperdrive,
+} from "../utils/wrangler.js";
+
+const USAGE = `
+Usage:
+  pnpm wilt add d1 <BINDING_NAME> <database-name>
+  pnpm wilt add r2 <BINDING_NAME> <bucket-name>
+  pnpm wilt add kv <BINDING_NAME>
+  pnpm wilt add queue <BINDING_NAME> <queue-name>
+  pnpm wilt add ai <BINDING_NAME>
+  pnpm wilt add durable-object <BINDING_NAME> <ClassName>
+  pnpm wilt add vectorize <BINDING_NAME> <index-name> [dimensions]
+  pnpm wilt add browser <BINDING_NAME>
+  pnpm wilt add hyperdrive <BINDING_NAME> <connection-string>
+
+Examples:
+  pnpm wilt add d1 PAYMENTS_DB payments-db
+  pnpm wilt add r2 ASSETS_BUCKET my-assets
+  pnpm wilt add kv SESSION_KV
+  pnpm wilt add queue MAIL_QUEUE mailer
+  pnpm wilt add ai AI
+  pnpm wilt add durable-object CHAT_ROOM ChatRoom
+  pnpm wilt add vectorize VECTOR_IDX my-index 1536
+  pnpm wilt add browser BROWSER
+  pnpm wilt add hyperdrive HYPERDRIVE postgres://user:pass@host/db
+`.trim();
+
+export function runAdd(args: string[]): void {
+  const [service, ...rest] = args;
+
+  if (!service) {
+    console.error(`  ✗ Missing service type.\n\n${USAGE}`);
+    process.exit(1);
+  }
+
+  const svc = service.toLowerCase();
+
+  switch (svc) {
+    case "d1": {
+      const [binding, dbName] = rest;
+      if (!binding || !dbName) {
+        console.error(`  ✗ Usage: pnpm wilt add d1 <BINDING_NAME> <database-name>`);
+        process.exit(1);
+      }
+      console.log(`\n  Adding D1 binding to wrangler.jsonc...\n`);
+      addD1(binding, dbName);
+      break;
+    }
+
+    case "r2": {
+      const [binding, bucketName] = rest;
+      if (!binding || !bucketName) {
+        console.error(`  ✗ Usage: pnpm wilt add r2 <BINDING_NAME> <bucket-name>`);
+        process.exit(1);
+      }
+      console.log(`\n  Adding R2 binding to wrangler.jsonc...\n`);
+      addR2(binding, bucketName);
+      break;
+    }
+
+    case "kv": {
+      const [binding] = rest;
+      if (!binding) {
+        console.error(`  ✗ Usage: pnpm wilt add kv <BINDING_NAME>`);
+        process.exit(1);
+      }
+      console.log(`\n  Adding KV namespace binding to wrangler.jsonc...\n`);
+      addKv(binding);
+      break;
+    }
+
+    case "queue": {
+      const [binding, queueName] = rest;
+      if (!binding || !queueName) {
+        console.error(`  ✗ Usage: pnpm wilt add queue <BINDING_NAME> <queue-name>`);
+        process.exit(1);
+      }
+      console.log(`\n  Adding Queue binding to wrangler.jsonc...\n`);
+      addQueue(binding, queueName);
+      break;
+    }
+
+    case "ai": {
+      const [binding] = rest;
+      if (!binding) {
+        console.error(`  ✗ Usage: pnpm wilt add ai <BINDING_NAME>`);
+        process.exit(1);
+      }
+      console.log(`\n  Adding AI binding to wrangler.jsonc...\n`);
+      addAi(binding);
+      break;
+    }
+
+    case "durable-object":
+    case "do": {
+      const [binding, className] = rest;
+      if (!binding || !className) {
+        console.error(`  ✗ Usage: pnpm wilt add durable-object <BINDING_NAME> <ClassName>`);
+        process.exit(1);
+      }
+      console.log(`\n  Adding Durable Object binding to wrangler.jsonc...\n`);
+      addDurableObject(binding, className);
+      break;
+    }
+
+    case "vectorize":
+    case "vector": {
+      const [binding, indexName, rawDimensions] = rest;
+      if (!binding || !indexName) {
+        console.error(`  ✗ Usage: pnpm wilt add vectorize <BINDING_NAME> <index-name> [dimensions]`);
+        process.exit(1);
+      }
+      const dimensions = rawDimensions ? parseInt(rawDimensions, 10) : 1536;
+      console.log(`\n  Adding Vectorize binding to wrangler.jsonc...\n`);
+      addVectorize(binding, indexName, dimensions);
+      break;
+    }
+
+    case "browser": {
+      const [binding] = rest;
+      if (!binding) {
+        console.error(`  ✗ Usage: pnpm wilt add browser <BINDING_NAME>`);
+        process.exit(1);
+      }
+      console.log(`\n  Adding Browser rendering binding to wrangler.jsonc...\n`);
+      addBrowser(binding);
+      break;
+    }
+
+    case "hyperdrive": {
+      const [binding, connectionString] = rest;
+      if (!binding || !connectionString) {
+        console.error(`  ✗ Usage: pnpm wilt add hyperdrive <BINDING_NAME> <connection-string>`);
+        process.exit(1);
+      }
+      console.log(`\n  Adding Hyperdrive binding to wrangler.jsonc...\n`);
+      addHyperdrive(binding, connectionString);
+      break;
+    }
+
+    default: {
+      console.error(`  ✗ Unknown service type: "${service}"\n\n${USAGE}`);
+      process.exit(1);
+    }
+  }
+}

package/bin/commands/generate.ts

@@ -0,0 +1,74 @@
+import {
+  generateModule,
+  generateService,
+  generateController,
+} from "../generators/module.generator.js";
+import { loadConfig } from "../utils/config.js";
+
+const USAGE = `
+Usage:
+  pnpm wilt generate module <name> [--path <dir>] [--no-test]
+  pnpm wilt generate service <name> [--path <dir>]
+  pnpm wilt generate controller <name> [--path <dir>]
+
+Aliases:
+  g m  →  generate module
+  g s  →  generate service
+  g c  →  generate controller
+
+Flags:
+  --no-test   Skip generating the .test.ts file for a module
+
+Examples:
+  pnpm wilt generate module payment
+  pnpm wilt g m payment
+  pnpm wilt generate module payment --no-test
+  pnpm wilt generate service payment --path src/modules/app/payment
+`.trim();
+
+function parsePath(args: string[]): { args: string[]; path?: string } {
+  const idx = args.indexOf("--path");
+  if (idx === -1) return { args };
+  const path = args[idx + 1];
+  const cleaned = args.filter((_, i) => i !== idx && i !== idx + 1);
+  return { args: cleaned, path };
+}
+
+function parseNoTest(args: string[]): { args: string[]; noTest: boolean } {
+  const idx = args.indexOf("--no-test");
+  if (idx === -1) return { args, noTest: false };
+  return { args: args.filter((_, i) => i !== idx), noTest: true };
+}
+
+export async function runGenerate(args: string[]): Promise<void> {
+  const { args: withoutPath, path: targetPath } = parsePath(args);
+  const { args: cleanArgs, noTest } = parseNoTest(withoutPath);
+  const [subcommand, name] = cleanArgs;
+
+  if (!subcommand || !name) {
+    console.error(`  ✗ Missing arguments.\n\n${USAGE}`);
+    process.exit(1);
+  }
+
+  const config = await loadConfig();
+  const sub = subcommand.toLowerCase();
+
+  if (sub === "module" || sub === "m") {
+    console.log(`\n  Generating module "${name}"...\n`);
+    generateModule(name, {
+      dir: targetPath,
+      modulesDir: config.modulesDir,
+      defaultFiles: config.generate.files,
+      noTest,
+    });
+  } else if (sub === "service" || sub === "s") {
+    console.log(`\n  Generating service "${name}"...\n`);
+    generateService(name, targetPath, config.modulesDir);
+  } else if (sub === "controller" || sub === "c") {
+    console.log(`\n  Generating controller "${name}"...\n`);
+    generateController(name, targetPath, config.modulesDir);
+  } else {
+    console.error(`  ✗ Unknown generate subcommand: "${subcommand}"\n\n${USAGE}`);
+    process.exit(1);
+  }
+}