create-daloy 0.1.0

package/README.md

@@ -0,0 +1,68 @@
+# create-daloy
+
+Scaffold a new [DaloyJS](https://github.com/daloyjs/daloy) project in seconds.
+
+```bash
+# pick the package manager you actually use
+pnpm create daloy@latest my-api
+npm  create daloy@latest my-api
+yarn create daloy           my-api
+bun  create daloy           my-api
+```
+
+The CLI is interactive when arguments are missing. It will ask you for:
+
+- A project directory name (defaults to `my-daloy-app`)
+- A template (`node-basic` or `cloudflare-worker`)
+- Whether to install dependencies
+- Whether to initialize a git repository
+
+## Non-interactive usage
+
+```bash
+pnpm create daloy@latest my-api \
+  --template node-basic \
+  --package-manager pnpm \
+  --install \
+  --git
+```
+
+### Flags
+
+| Flag | Description |
+| --- | --- |
+| `--template <name>` | `node-basic` (default) or `cloudflare-worker`. |
+| `--package-manager <pm>` | `pnpm` (default), `npm`, `yarn`, or `bun`. |
+| `--install` / `--no-install` | Install dependencies after scaffolding. Defaults to interactive. |
+| `--git` / `--no-git` | Initialize a git repository. Defaults to interactive. |
+| `--force` | Overwrite an existing non-empty directory. |
+| `--yes` | Accept all defaults; never prompt. |
+| `--help` | Print usage and exit. |
+| `--version` | Print version and exit. |
+
+## Templates
+
+### `node-basic`
+
+A production-ready Node.js HTTP server using `@daloyjs/core` with:
+
+- Strict TypeScript and `tsx` for instant dev runs.
+- Hardened `.npmrc` for safer installs.
+- `secureHeaders`, `requestId`, and `rateLimit` enabled by default.
+- A sample `GET /healthz` and contract-first `GET /books/:id` route with Zod validation.
+- `pnpm gen` wired to emit OpenAPI 3.1 + a typed Hey API client.
+
+### `cloudflare-worker`
+
+A minimal Cloudflare Worker bootstrap using `@daloyjs/core/cloudflare` with:
+
+- `wrangler.toml` ready to deploy.
+- Zod-validated route exposed as `fetch`.
+- A sample test that exercises `app.request(...)`.
+
+## What the CLI guarantees
+
+- Zero runtime dependencies (uses only Node built-ins) for a clean supply-chain footprint.
+- Templates are copied verbatim from this package's `templates/` directory.
+- Files prefixed with `_` are renamed (`_gitignore` → `.gitignore`, `_npmrc` → `.npmrc`) to survive npm packing.
+- The CLI never executes template scripts and never makes network calls beyond the package manager you select.

package/bin/create-daloy.mjs

@@ -0,0 +1,333 @@
+#!/usr/bin/env node
+// create-daloy — scaffold a new DaloyJS project.
+// Zero runtime dependencies; uses only Node built-ins.
+
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdir, readdir, readFile, stat, writeFile, copyFile, rename } from "node:fs/promises";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = path.resolve(__dirname, "..");
+const TEMPLATES_DIR = path.join(PKG_ROOT, "templates");
+
+const TEMPLATES = ["node-basic", "cloudflare-worker"];
+const PACKAGE_MANAGERS = ["pnpm", "npm", "yarn", "bun"];
+
+const RENAME_ON_COPY = new Map([
+  ["_gitignore", ".gitignore"],
+  ["_npmrc", ".npmrc"],
+  ["_env.example", ".env.example"],
+]);
+
+const COLORS = process.stdout.isTTY
+  ? {
+      reset: "\x1b[0m",
+      bold: "\x1b[1m",
+      dim: "\x1b[2m",
+      cyan: "\x1b[36m",
+      green: "\x1b[32m",
+      red: "\x1b[31m",
+      yellow: "\x1b[33m",
+    }
+  : { reset: "", bold: "", dim: "", cyan: "", green: "", red: "", yellow: "" };
+
+function color(code, s) {
+  return `${code}${s}${COLORS.reset}`;
+}
+
+function printHelp() {
+  console.log(`${color(COLORS.bold, "create-daloy")} — scaffold a DaloyJS project
+
+Usage:
+  pnpm create daloy@latest [project-name] [options]
+  npm  create daloy@latest [project-name] [options]
+
+Options:
+  --template <name>          ${TEMPLATES.join(" | ")}  (default: node-basic)
+  --package-manager <pm>     ${PACKAGE_MANAGERS.join(" | ")}  (default: pnpm)
+  --install / --no-install   Install dependencies after scaffolding.
+  --git / --no-git           Initialize a git repository.
+  --force                    Overwrite an existing non-empty directory.
+  --yes, -y                  Accept all defaults; never prompt.
+  --help, -h                 Print this help.
+  --version, -v              Print version.
+`);
+}
+
+async function readPkgVersion() {
+  try {
+    const raw = await readFile(path.join(PKG_ROOT, "package.json"), "utf8");
+    return JSON.parse(raw).version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+function parseArgs(argv) {
+  const out = {
+    projectName: undefined,
+    template: undefined,
+    packageManager: undefined,
+    install: undefined,
+    git: undefined,
+    force: false,
+    yes: false,
+    help: false,
+    version: false,
+  };
+  const args = [...argv];
+  while (args.length) {
+    const a = args.shift();
+    if (a === "--help" || a === "-h") out.help = true;
+    else if (a === "--version" || a === "-v") out.version = true;
+    else if (a === "--yes" || a === "-y") out.yes = true;
+    else if (a === "--force") out.force = true;
+    else if (a === "--install") out.install = true;
+    else if (a === "--no-install") out.install = false;
+    else if (a === "--git") out.git = true;
+    else if (a === "--no-git") out.git = false;
+    else if (a === "--template") out.template = args.shift();
+    else if (a?.startsWith("--template=")) out.template = a.slice("--template=".length);
+    else if (a === "--package-manager" || a === "--pm") out.packageManager = args.shift();
+    else if (a?.startsWith("--package-manager=")) out.packageManager = a.slice("--package-manager=".length);
+    else if (a?.startsWith("--pm=")) out.packageManager = a.slice("--pm=".length);
+    else if (a && !a.startsWith("-") && out.projectName === undefined) out.projectName = a;
+    else if (a) {
+      console.error(color(COLORS.red, `Unknown argument: ${a}`));
+      process.exit(1);
+    }
+  }
+  return out;
+}
+
+function detectPackageManager() {
+  const ua = process.env.npm_config_user_agent ?? "";
+  if (ua.startsWith("pnpm")) return "pnpm";
+  if (ua.startsWith("yarn")) return "yarn";
+  if (ua.startsWith("bun")) return "bun";
+  if (ua.startsWith("npm")) return "npm";
+  return "pnpm";
+}
+
+const VALID_NAME = /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+
+function validateProjectName(name) {
+  if (!name || !name.trim()) return "Project name cannot be empty.";
+  if (name === "." || name === "..") return "Use a real directory name.";
+  if (name.length > 214) return "Project name is too long (max 214 chars).";
+  if (!VALID_NAME.test(name)) {
+    return "Project name must be a valid npm package name (lowercase, no spaces, no leading dot/underscore).";
+  }
+  return true;
+}
+
+async function isDirEmpty(dir) {
+  try {
+    const entries = await readdir(dir);
+    return entries.length === 0;
+  } catch {
+    return true;
+  }
+}
+
+async function copyTemplate(src, dest) {
+  const entries = await readdir(src, { withFileTypes: true });
+  await mkdir(dest, { recursive: true });
+  for (const entry of entries) {
+    const renamed = RENAME_ON_COPY.get(entry.name) ?? entry.name;
+    const from = path.join(src, entry.name);
+    const to = path.join(dest, renamed);
+    if (entry.isDirectory()) {
+      await copyTemplate(from, to);
+    } else if (entry.isFile()) {
+      await copyFile(from, to);
+    }
+  }
+}
+
+async function patchPackageJson(dir, projectName) {
+  const file = path.join(dir, "package.json");
+  if (!existsSync(file)) return;
+  const raw = await readFile(file, "utf8");
+  const json = JSON.parse(raw);
+  json.name = projectName.startsWith("@") ? projectName : projectName.toLowerCase();
+  await writeFile(file, JSON.stringify(json, null, 2) + "\n", "utf8");
+}
+
+function run(cmd, args, cwd) {
+  return new Promise((resolve) => {
+    const proc = spawn(cmd, args, { cwd, stdio: "inherit", shell: process.platform === "win32" });
+    proc.on("exit", (code) => resolve(code ?? 0));
+    proc.on("error", () => resolve(1));
+  });
+}
+
+async function ask(rl, question, defaultValue) {
+  const suffix = defaultValue !== undefined ? color(COLORS.dim, ` (${defaultValue})`) : "";
+  const answer = (await rl.question(`${color(COLORS.cyan, "?")} ${question}${suffix} `)).trim();
+  return answer.length === 0 ? defaultValue : answer;
+}
+
+async function askYesNo(rl, question, defaultYes) {
+  const def = defaultYes ? "Y/n" : "y/N";
+  const answer = (await rl.question(`${color(COLORS.cyan, "?")} ${question} ${color(COLORS.dim, `(${def})`)} `))
+    .trim()
+    .toLowerCase();
+  if (answer.length === 0) return defaultYes;
+  return answer === "y" || answer === "yes";
+}
+
+async function askChoice(rl, question, choices, defaultChoice) {
+  const list = choices
+    .map((c, i) => `  ${color(COLORS.dim, `${i + 1})`)} ${c}${c === defaultChoice ? color(COLORS.dim, " (default)") : ""}`)
+    .join("\n");
+  console.log(`${color(COLORS.cyan, "?")} ${question}\n${list}`);
+  const raw = (await rl.question(`  > `)).trim();
+  if (raw.length === 0) return defaultChoice;
+  const asNumber = Number.parseInt(raw, 10);
+  if (Number.isInteger(asNumber) && asNumber >= 1 && asNumber <= choices.length) {
+    return choices[asNumber - 1];
+  }
+  if (choices.includes(raw)) return raw;
+  console.error(color(COLORS.red, `Invalid choice. Pick one of: ${choices.join(", ")}`));
+  return askChoice(rl, question, choices, defaultChoice);
+}
+
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+
+  if (opts.help) {
+    printHelp();
+    process.exit(0);
+  }
+  if (opts.version) {
+    console.log(await readPkgVersion());
+    process.exit(0);
+  }
+
+  console.log(color(COLORS.bold, "\n  create-daloy"));
+  console.log(color(COLORS.dim, `  https://daloyjs.dev\n`));
+
+  const detectedPm = detectPackageManager();
+  const interactive = !opts.yes && process.stdin.isTTY && process.stdout.isTTY;
+  const rl = interactive ? createInterface({ input, output }) : null;
+
+  try {
+    let projectName = opts.projectName;
+    if (!projectName) {
+      if (rl) {
+        while (true) {
+          const candidate = await ask(rl, "Project name?", "my-daloy-app");
+          const valid = validateProjectName(candidate);
+          if (valid === true) {
+            projectName = candidate;
+            break;
+          }
+          console.error(color(COLORS.red, `  ${valid}`));
+        }
+      } else {
+        projectName = "my-daloy-app";
+      }
+    }
+    const nameCheck = validateProjectName(projectName);
+    if (nameCheck !== true) {
+      console.error(color(COLORS.red, nameCheck));
+      process.exit(1);
+    }
+
+    let template = opts.template;
+    if (!template) {
+      template = rl ? await askChoice(rl, "Pick a template:", TEMPLATES, "node-basic") : "node-basic";
+    }
+    if (!TEMPLATES.includes(template)) {
+      console.error(color(COLORS.red, `Unknown template "${template}". Available: ${TEMPLATES.join(", ")}`));
+      process.exit(1);
+    }
+
+    const templateDir = path.join(TEMPLATES_DIR, template);
+    if (!existsSync(templateDir)) {
+      console.error(color(COLORS.red, `Template "${template}" is missing from this CLI build.`));
+      process.exit(1);
+    }
+
+    const targetDir = path.resolve(process.cwd(), projectName);
+    if (existsSync(targetDir)) {
+      const empty = await isDirEmpty(targetDir);
+      if (!empty && !opts.force) {
+        console.error(
+          color(
+            COLORS.red,
+            `Directory ${projectName} is not empty. Re-run with --force to overwrite.`,
+          ),
+        );
+        process.exit(1);
+      }
+    }
+
+    let packageManager = opts.packageManager ?? detectedPm;
+    if (!PACKAGE_MANAGERS.includes(packageManager)) {
+      console.error(
+        color(COLORS.red, `Unknown --package-manager "${packageManager}". Use one of: ${PACKAGE_MANAGERS.join(", ")}`),
+      );
+      process.exit(1);
+    }
+
+    let installDeps = opts.install;
+    if (installDeps === undefined) {
+      installDeps = rl ? await askYesNo(rl, `Install dependencies with ${packageManager}?`, true) : false;
+    }
+
+    let initGit = opts.git;
+    if (initGit === undefined) {
+      initGit = rl ? await askYesNo(rl, "Initialize a git repository?", true) : false;
+    }
+
+    rl?.close();
+
+    console.log(color(COLORS.dim, `\n  Scaffolding ${color(COLORS.bold, projectName)} from template ${color(COLORS.bold, template)}...`));
+
+    await mkdir(targetDir, { recursive: true });
+    await copyTemplate(templateDir, targetDir);
+    await patchPackageJson(targetDir, projectName);
+
+    if (initGit) {
+      const code = await run("git", ["init", "--quiet"], targetDir);
+      if (code === 0) {
+        console.log(color(COLORS.green, "  ✓ git repository initialized"));
+      } else {
+        console.warn(color(COLORS.yellow, "  ! git init failed; continuing"));
+      }
+    }
+
+    if (installDeps) {
+      console.log(color(COLORS.dim, `  Installing dependencies with ${packageManager}...`));
+      const code = await run(packageManager, ["install"], targetDir);
+      if (code !== 0) {
+        console.warn(
+          color(COLORS.yellow, `  ! ${packageManager} install exited with code ${code}; you can retry inside ${projectName}.`),
+        );
+      } else {
+        console.log(color(COLORS.green, "  ✓ dependencies installed"));
+      }
+    }
+
+    console.log(color(COLORS.green, `\n  Done.`));
+    console.log(`\n  Next steps:\n`);
+    console.log(`    cd ${projectName}`);
+    if (!installDeps) console.log(`    ${packageManager} install`);
+    console.log(`    ${packageManager} run dev`);
+    console.log("");
+    console.log(color(COLORS.dim, "  Docs: https://daloyjs.dev/docs"));
+    console.log(color(COLORS.dim, "  Issues: https://github.com/daloyjs/daloy/issues\n"));
+  } catch (err) {
+    rl?.close();
+    console.error(color(COLORS.red, `\n  Failed: ${(err && err.message) || err}`));
+    process.exit(1);
+  }
+}
+
+await main();

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "create-daloy",
+  "version": "0.1.0",
+  "description": "Scaffold a new DaloyJS project. Run with `pnpm create daloy`, `npm create daloy@latest`, `yarn create daloy`, or `bun create daloy`.",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/daloyjs/daloy.git",
+    "directory": "packages/create-daloy"
+  },
+  "homepage": "https://github.com/daloyjs/daloy/tree/main/packages/create-daloy#readme",
+  "bugs": {
+    "url": "https://github.com/daloyjs/daloy/issues"
+  },
+  "keywords": [
+    "daloy",
+    "daloyjs",
+    "scaffold",
+    "create",
+    "init",
+    "starter",
+    "template",
+    "cli",
+    "rest",
+    "api",
+    "openapi"
+  ],
+  "engines": {
+    "node": ">=20.10.0"
+  },
+  "bin": {
+    "create-daloy": "bin/create-daloy.mjs"
+  },
+  "files": [
+    "bin",
+    "templates",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "node --test test/**/*.test.mjs"
+  }
+}

package/templates/cloudflare-worker/README.md

@@ -0,0 +1,18 @@
+# my-daloy-worker
+
+A [DaloyJS](https://daloyjs.dev) Cloudflare Workers starter.
+
+## Develop
+
+```bash
+pnpm install
+pnpm dev          # http://localhost:8787
+```
+
+## Deploy
+
+```bash
+pnpm deploy
+```
+
+`@daloyjs/core/cloudflare` exposes `toFetchHandler(app)`, so the same `App` you would use on Node also runs on Workers.

package/templates/cloudflare-worker/_gitignore

@@ -0,0 +1,7 @@
+node_modules/
+.wrangler/
+dist/
+.DS_Store
+*.log
+.env
+.dev.vars

package/templates/cloudflare-worker/_npmrc

@@ -0,0 +1,4 @@
+auto-install-peers=true
+strict-peer-dependencies=true
+prefer-frozen-lockfile=true
+verify-store-integrity=true

package/templates/cloudflare-worker/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "my-daloy-worker",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "wrangler dev",
+    "deploy": "wrangler deploy",
+    "typecheck": "tsc --noEmit",
+    "test": "node --import tsx --test tests/**/*.test.ts"
+  },
+  "dependencies": {
+    "@daloyjs/core": "^0.1.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20240909.0",
+    "tsx": "^4.22.0",
+    "typescript": "^6.0.3",
+    "wrangler": "^4.0.0"
+  }
+}

package/templates/cloudflare-worker/src/index.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { App, NotFoundError, requestId, secureHeaders } from "@daloyjs/core";
+import { toFetchHandler } from "@daloyjs/core/cloudflare";
+
+const app = new App({
+  bodyLimitBytes: 256 * 1024,
+  requestTimeoutMs: 5_000,
+  production: true,
+});
+
+app.use(requestId());
+app.use(secureHeaders());
+
+const Book = z.object({ id: z.string(), title: z.string() });
+const books = new Map<string, z.infer<typeof Book>>([
+  ["1", { id: "1", title: "Noli Me Tangere" }],
+]);
+
+app.route({
+  method: "GET",
+  path: "/books/:id",
+  operationId: "getBookById",
+  tags: ["Books"],
+  request: { params: z.object({ id: z.string() }) },
+  responses: {
+    200: { description: "Found", body: Book },
+    404: { description: "Not found" },
+  },
+  handler: async ({ params }) => {
+    const book = books.get(params.id);
+    if (!book) throw new NotFoundError(`Book ${params.id} not found`);
+    return { status: 200, body: book };
+  },
+});
+
+export default { fetch: toFetchHandler(app) };

package/templates/cloudflare-worker/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2022"],
+    "types": ["@cloudflare/workers-types"],
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true
+  },
+  "include": ["src/**/*"]
+}

package/templates/cloudflare-worker/wrangler.toml

@@ -0,0 +1,3 @@
+name = "my-daloy-worker"
+main = "src/index.ts"
+compatibility_date = "2025-01-01"

package/templates/node-basic/README.md

@@ -0,0 +1,41 @@
+# my-daloy-app
+
+A [DaloyJS](https://daloyjs.dev) starter — runtime-portable, contract-first TypeScript REST API.
+
+## Develop
+
+```bash
+pnpm install
+pnpm dev          # http://localhost:3000
+```
+
+Try it:
+
+```bash
+curl http://localhost:3000/healthz
+curl http://localhost:3000/books/1
+```
+
+## Generate OpenAPI + typed client
+
+```bash
+pnpm gen
+# → generated/openapi.json
+# → generated/client/  (typed Hey API client)
+```
+
+## Build
+
+```bash
+pnpm build
+node dist/index.js
+```
+
+## What's included
+
+- `@daloyjs/core` with `secureHeaders`, `requestId`, and `rateLimit` enabled.
+- A health route and a contract-first `/books/:id` route with Zod validation.
+- Hardened `.npmrc` for safer installs.
+- Hey API codegen wired to `pnpm gen`.
+
+Read the docs at <https://daloyjs.dev/docs>.

package/templates/node-basic/_env.example

@@ -0,0 +1 @@
+PORT=3000

package/templates/node-basic/_gitignore

@@ -0,0 +1,9 @@
+node_modules/
+dist/
+coverage/
+.DS_Store
+*.log
+.env
+.env.*
+!.env.example
+generated/

package/templates/node-basic/_npmrc

@@ -0,0 +1,7 @@
+auto-install-peers=true
+strict-peer-dependencies=true
+prefer-frozen-lockfile=true
+verify-store-integrity=true
+# Optional, pnpm 10+:
+# minimum-release-age=1440
+# ignore-scripts=true

package/templates/node-basic/openapi-ts.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "@hey-api/openapi-ts";
+
+export default defineConfig({
+  input: "./generated/openapi.json",
+  output: { path: "./generated/client" },
+  plugins: ["@hey-api/client-fetch", "@hey-api/typescript", "@hey-api/sdk"],
+});

package/templates/node-basic/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "my-daloy-app",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "engines": {
+    "node": ">=20.10.0"
+  },
+  "scripts": {
+    "dev": "node --import tsx --watch src/index.ts",
+    "start": "node --import tsx src/index.ts",
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit",
+    "test": "node --import tsx --test tests/**/*.test.ts",
+    "gen:openapi": "node --import tsx scripts/dump-openapi.ts",
+    "gen:client": "openapi-ts",
+    "gen": "pnpm gen:openapi && pnpm gen:client",
+    "audit": "pnpm audit --prod"
+  },
+  "dependencies": {
+    "@daloyjs/core": "^0.1.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@hey-api/openapi-ts": "^0.97.1",
+    "@types/node": "^25.7.0",
+    "tsx": "^4.22.0",
+    "typescript": "^6.0.3"
+  }
+}

package/templates/node-basic/scripts/dump-openapi.ts

@@ -0,0 +1,22 @@
+import { writeFile, mkdir } from "node:fs/promises";
+import { generateOpenAPI } from "@daloyjs/core/openapi";
+import { App } from "@daloyjs/core";
+
+// Re-import the app definition, then write the spec.
+// Keep this script deterministic so codegen output is stable in CI.
+
+async function main() {
+  const { default: app } = (await import("../src/index.js")) as { default: App };
+  const doc = generateOpenAPI(app, {
+    info: { title: "My Daloy API", version: "0.0.1" },
+    servers: [{ url: "http://localhost:3000" }],
+  });
+  await mkdir("generated", { recursive: true });
+  await writeFile("generated/openapi.json", JSON.stringify(doc, null, 2));
+  console.log("wrote generated/openapi.json");
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/templates/node-basic/src/index.ts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import {
+  App,
+  NotFoundError,
+  rateLimit,
+  requestId,
+  secureHeaders,
+} from "@daloyjs/core";
+import { serve } from "@daloyjs/core/node";
+
+const app = new App({
+  bodyLimitBytes: 1024 * 1024,
+  requestTimeoutMs: 5_000,
+  production: process.env.NODE_ENV === "production",
+});
+
+app.use(requestId());
+app.use(secureHeaders());
+app.use(rateLimit({ windowMs: 60_000, max: 120 }));
+
+app.route({
+  method: "GET",
+  path: "/healthz",
+  operationId: "healthz",
+  tags: ["Ops"],
+  responses: {
+    200: {
+      description: "Service is healthy",
+      body: z.object({ ok: z.literal(true), uptime: z.number() }),
+    },
+  },
+  handler: async () => ({
+    status: 200,
+    body: { ok: true, uptime: process.uptime() },
+  }),
+});
+
+const Book = z.object({ id: z.string(), title: z.string() });
+const books = new Map<string, z.infer<typeof Book>>([
+  ["1", { id: "1", title: "Noli Me Tangere" }],
+  ["2", { id: "2", title: "El Filibusterismo" }],
+]);
+
+app.route({
+  method: "GET",
+  path: "/books/:id",
+  operationId: "getBookById",
+  tags: ["Books"],
+  request: { params: z.object({ id: z.string() }) },
+  responses: {
+    200: { description: "Found", body: Book },
+    404: { description: "Not found" },
+  },
+  handler: async ({ params }) => {
+    const book = books.get(params.id);
+    if (!book) throw new NotFoundError(`Book ${params.id} not found`);
+    return { status: 200, body: book };
+  },
+});
+
+const port = Number(process.env.PORT ?? 3000);
+serve(app, { port });
+console.log(`DaloyJS listening on http://localhost:${port}`);

package/templates/node-basic/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "types": ["node"],
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "declaration": true,
+    "sourceMap": true,
+    "outDir": "dist",
+    "rootDir": "./src",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}