@nilejs/cli 0.0.6 → 1.0.0

package/README.md

@@ -2,187 +2,112 @@
 
 [![NPM Version](https://img.shields.io/npm/v/@nilejs/cli.svg)](https://www.npmjs.com/package/@nilejs/cli)
 
-CLI for scaffolding and generating [Nile](https://github.com/nile-js/nile/tree/main/packages/nile) backend projects.
+Create [Nile Js](https://nile-js.github.io/nile/) projects and generate services, actions and schemas.
 
-## Install
-
-```bash
-bun add -g @nilejs/cli
-```
-
-```bash
-npm install -g @nilejs/cli
-```
-
-Or use without installing:
+## Create a project
 
 ```bash
 bunx @nilejs/cli new my-app
+cd my-app
+bun install
+cp .env.example .env
+bun run dev
 ```
 
-```bash
-npx @nilejs/cli new my-app
-```
+The server starts on `http://localhost:8000`. The starter stores its data in an embedded PGlite database, so there is no database server to install. The [getting started guide](https://nile-js.github.io/nile/guide/start/getting-started/) walks through the starter step by step.
 
-## Commands
+The starter includes:
 
-### `nile new <project-name>`
+- `src/index.ts`: server entry point on Bun's native HTTP server, with a logger and an `onBoot` schema push
+- `src/db/`: PGlite and Drizzle client, the `tasks` table and a `taskModel` built with `createModel`
+- `src/services/`: a `tasks` service with create, list, get, update and delete actions
+- `Dockerfile`, `docker-compose.yml` and `docker-compose.dev.yml` for container deployments
+- `drizzle.config.ts`, `.env.example`, `tsconfig.json` and `package.json`
 
-Scaffold a new Nile project. Copies the project template, replaces placeholders with your project name, and prints next steps.
+## Generate code
 
-```bash
-nile new my-app
-```
+Run the generators from the project root. The starter's `gen` script calls the CLI for you.
 
-Output:
-
-```
-Creating project: my-app
-
-  Copying project files...
-  Configuring project...
-  Project "my-app" created.
-
-Next steps:
-
-    cd my-app
-    bun install
-    cp .env.example .env
-    bun run dev
-```
-
-The scaffolded project includes:
-
-- `src/index.ts`, server entry with PGLite and Drizzle
-- `src/db/`, database client, schema, types, and a `tasks` model using `createModel`
-- `src/services/`, a `tasks` service with five CRUD actions
-- `drizzle.config.ts`, `.env.example`, `tsconfig.json`, `package.json`
-
-### `nile generate service <name>`
+| Command | Description |
+|---|---|
+| `bun run gen service <name>` | Add a service with a sample action |
+| `bun run gen action <service> <name>` | Add an action to an existing service |
+| `bun run gen action <service> <name> --folder` | Add an action in its own folder, for private helper modules |
+| `bun run gen schema` | Generate Zod schemas and TypeScript types from your actions |
 
-Alias: `nile gen service <name>`
+`generate` also has the alias `gen`, so `bunx @nilejs/cli gen service users` works outside the starter.
 
-Generate a new service directory under `src/services/` with a demo action and barrel export. Run this from the project root.
+### Services
 
 ```bash
-nile gen service users
+bun run gen service users
 ```
 
 Creates:
 
-```
+```text
 src/services/users/
-  sample.ts       # Demo action with Zod schema, handler, and createAction
-  index.ts        # Barrel export
+  actions/sample.ts   Sample action with a schema, an input type and a named handler
+  index.ts            Exports the sample action
 ```
 
-After creating the files, the CLI asks whether to auto-register the service in `src/services/services.config.ts`. If you accept, it adds the import and service entry. If you decline, it prints the snippet to add manually.
-
-### `nile generate action <service-name> <action-name>`
+The CLI then asks whether to register the service in `src/services/services.config.ts`. If you decline, it prints the lines to add yourself.
 
-Alias: `nile gen action <service-name> <action-name>`
-
-Generate a new action file in an existing service directory.
+### Actions
 
 ```bash
-nile gen action users get-user
+bun run gen action users get-user
 ```
 
-Creates `src/services/users/get-user.ts` with:
+Creates `src/services/users/actions/get-user.ts`:
 
-```typescript
-import { type Action, createAction } from "@nilejs/nile";
-import { Ok } from "slang-ts";
+```ts
+import { createAction } from "@nilejs/nile";
+import { Ok } from "@nilejs/nile/fp";
 import z from "zod";
 
 const getUserSchema = z.object({
-  // Define your validation schema here
+  // Describe the input this action accepts
 });
 
-const getUserHandler = async (data: Record<string, unknown>) => {
-  // Implement your users.get-user logic here
-  return Ok({ result: data });
+type GetUserInput = z.infer<typeof getUserSchema>;
+
+const getUserHandler = async (input: GetUserInput) => {
+  // Implement users.get-user here
+  return Ok({ result: input });
 };
 
-export const getUserAction: Action = createAction({
+export const getUserAction = createAction<GetUserInput>({
   name: "get-user",
   description: "GetUser action for users",
-  handler: getUserHandler,
   validation: getUserSchema,
+  handler: getUserHandler,
 });
 ```
 
-Kebab-case names are converted to camelCase for variables and PascalCase for types.
-
-### `nile generate schema`
+Kebab-case names become camelCase variables and PascalCase types. Register the action by importing it in `src/services/services.config.ts` and adding it to the service's `actions` list.
 
-Alias: `nile gen schema`
-
-Extract Zod validation schemas from your action definitions and generate TypeScript files with schema exports and inferred types.
+### Schemas and types
 
 ```bash
-nile gen schema
+bun run gen schema
 ```
 
-The command auto-detects `src/services/services.config.ts`. If the file is not found, it prompts for the path. It spawns a `bun` subprocess to import your services config, extracts JSON Schema from each action's validation field, and converts them back to Zod code strings.
-
-Output (default `src/generated/`):
+Reads every action's validation schema from `src/services/services.config.ts` and writes:
 
-- `schemas.ts` — named Zod schema exports (`tasksCreateSchema`, `tasksUpdateSchema`, etc.)
-- `types.ts` — TypeScript types via `z.infer` (`TasksCreatePayload`, `TasksUpdatePayload`, etc.)
-
-Options:
+- `src/generated/schemas.ts`: named Zod schemas, such as `tasksCreateSchema`
+- `src/generated/types.ts`: inferred types, such as `TasksCreatePayload`
 
 | Flag | Description |
 |---|---|
-| `-e, --entry <path>` | Path to services config (auto-detected by default) |
+| `-e, --entry <path>` | Path to the services config (detected by default) |
 | `-o, --output <path>` | Output directory (default: `src/generated`) |
 
-Actions without a `validation` schema are skipped and listed in the CLI output.
-
-Requires [Bun](https://bun.sh) installed for the extraction subprocess.
-
-### Quick Reference
-
-| Command | Description |
-|---|---|
-| `nile new <name>` | Scaffold a new project |
-| `nile gen service <name>` | Add a service with a demo action |
-| `nile gen action <service> <name>` | Add an action to an existing service |
-| `nile gen schema` | Generate Zod schemas and TypeScript types |
-
-## Generated Project Structure
-
-```
-my-app/
-  package.json
-  tsconfig.json
-  drizzle.config.ts
-  .env.example
-  src/
-    index.ts
-    db/
-      client.ts
-      schema.ts
-      types.ts
-      index.ts
-      models/
-        tasks.ts
-        index.ts
-    services/
-      services.config.ts
-      tasks/
-        create.ts
-        list.ts
-        get.ts
-        update.ts
-        delete.ts
-```
+Actions without a validation schema are skipped and listed in the output. Share the generated files with a frontend to validate forms with the same rules as the server.
 
 ## Requirements
 
-- Node.js 18+ or Bun
-- The scaffolded project uses Bun as its runtime (`Bun.serve`, `bun run`)
+- [Bun](https://bun.sh) 1.4.2 or later. The starter runs on Bun, and `gen schema` imports your services with Bun.
 
 ## License
 

package/dist/index.js

@@ -3,6 +3,8 @@
 // src/index.ts
 import { resolve as resolve6 } from "node:path";
 import { Command } from "commander";
+// package.json
+var version = "1.0.0";
 
 // src/commands/generate-action.ts
 import { resolve } from "node:path";
@@ -87,47 +89,60 @@ var toPascalCase = (str) => {
 var generateActionContent = (actionName, serviceName) => {
   const camel = toCamelCase(actionName);
   const pascal = toPascalCase(actionName);
-  return `import { type Action, createAction } from "@nilejs/nile";
-import { Ok } from "slang-ts";
+  return `import { createAction } from "@nilejs/nile";
+import { Ok } from "@nilejs/nile/fp";
 import z from "zod";
 
 const ${camel}Schema = z.object({
-  // Define your validation schema here
+  // Describe the input this action accepts
 });
 
-const ${camel}Handler = async (data: Record<string, unknown>) => {
-  // Implement your ${serviceName}.${actionName} logic here
-  return Ok({ result: data });
+type ${pascal}Input = z.infer<typeof ${camel}Schema>;
+
+const ${camel}Handler = async (input: ${pascal}Input) => {
+  // Implement ${serviceName}.${actionName} here
+  return Ok({ result: input });
 };
 
-export const ${camel}Action: Action = createAction({
+export const ${camel}Action = createAction<${pascal}Input>({
   name: "${actionName}",
   description: "${pascal} action for ${serviceName}",
-  handler: ${camel}Handler,
   validation: ${camel}Schema,
+  handler: ${camel}Handler,
 });
 `;
 };
-var generateActionCommand = async (serviceName, actionName) => {
+var generateActionCommand = async (serviceName, actionName, options = {}) => {
   const serviceDir = resolve(process.cwd(), "src/services", serviceName);
   if (!pathExists(serviceDir)) {
     error(`Service "${serviceName}" not found at src/services/${serviceName}/`);
     hint(`Create the service first: nile generate service ${serviceName}`);
     process.exit(1);
   }
-  const actionFile = resolve(serviceDir, `${actionName}.ts`);
-  if (pathExists(actionFile)) {
+  const relative = options.folder ? `actions/${actionName}/${actionName}.ts` : `actions/${actionName}.ts`;
+  const actionFile = resolve(serviceDir, relative);
+  const existingEntries = [
+    actionFile,
+    resolve(serviceDir, `${actionName}.ts`),
+    resolve(serviceDir, `actions/${actionName}.ts`),
+    resolve(serviceDir, `actions/${actionName}/${actionName}.ts`)
+  ];
+  if (existingEntries.some(pathExists)) {
     error(`Action file "${actionName}.ts" already exists in src/services/${serviceName}/`);
     process.exit(1);
   }
   brand();
   const spinner = createSpinner(`Creating action ${actionName}...`);
   await writeFileSafe(actionFile, generateActionContent(actionName, serviceName));
-  spinner.stop(`Action created at src/services/${serviceName}/${actionName}.ts`);
+  if (options.folder) {
+    await writeFileSafe(resolve(serviceDir, `actions/${actionName}/index.ts`), `export { ${toCamelCase(actionName)}Action } from "./${actionName}";
+`);
+  }
+  spinner.stop(`Action created at src/services/${serviceName}/${relative}`);
   const camel = toCamelCase(actionName);
   console.log("");
   hint("Register the action in your service config:");
-  hint(`  import { ${camel}Action } from "./${serviceName}/${actionName}";`);
+  hint(`  import { ${camel}Action } from "./${serviceName}/actions/${actionName}";`);
   outro();
 };
 
@@ -143,15 +158,15 @@ var confirmPrompt = (question, defaultYes = true) => {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve2) => {
+  return new Promise((resolve) => {
     rl.question(`  ${question} ${suffix} `, (answer) => {
       rl.close();
       const trimmed = answer.trim().toLowerCase();
       if (trimmed === "") {
-        resolve2(defaultYes);
+        resolve(defaultYes);
         return;
       }
-      resolve2(trimmed === "y" || trimmed === "yes");
+      resolve(trimmed === "y" || trimmed === "yes");
     });
   });
 };
@@ -160,10 +175,10 @@ var inputPrompt = (question) => {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve2) => {
+  return new Promise((resolve) => {
     rl.question(`  ${question} `, (answer) => {
       rl.close();
-      resolve2(answer.trim());
+      resolve(answer.trim());
     });
   });
 };
@@ -313,7 +328,7 @@ var extractSchemas = (configPath, projectRoot) => {
   const importPath = resolveImportPath(configPath, projectRoot);
   const scriptContent = buildExtractionScript(importPath);
   const tempScriptPath = resolve2(projectRoot, TEMP_SCRIPT_NAME);
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve, reject) => {
     writeFile2(tempScriptPath, scriptContent, "utf-8").then(() => {
       execFile("bun", ["run", TEMP_SCRIPT_NAME], { cwd: projectRoot, timeout: 30000 }, (err, stdout, stderr) => {
         unlink(tempScriptPath).catch(() => {});
@@ -325,7 +340,7 @@ ${message}`));
         }
         try {
           const result = JSON.parse(stdout.trim());
-          resolve3(result);
+          resolve(result);
         } catch {
           reject(new Error(`Failed to parse extraction output. Raw output:
 ${stdout.trim()}`));
@@ -347,12 +362,12 @@ var DEFAULT_OUTPUT_DIR = "src/generated";
 var LEADING_SLASH2 = /^\//;
 var resolveConfigPath = async (projectRoot, entryFlag) => {
   if (entryFlag) {
-    const absolute2 = resolve3(projectRoot, entryFlag);
-    if (!pathExists(absolute2)) {
+    const absolute = resolve3(projectRoot, entryFlag);
+    if (!pathExists(absolute)) {
       error(`Config file not found: ${entryFlag}`);
       return null;
     }
-    return absolute2;
+    return absolute;
   }
   const detected = findServicesConfig(projectRoot);
   if (detected) {
@@ -439,34 +454,36 @@ var toPascalCase2 = (str) => {
 var generateActionContent2 = (serviceName) => {
   const camel = toCamelCase3(serviceName);
   const pascal = toPascalCase2(serviceName);
-  return `import { type Action, createAction } from "@nilejs/nile";
-import { Ok } from "slang-ts";
+  return `import { createAction } from "@nilejs/nile";
+import { Ok } from "@nilejs/nile/fp";
 import z from "zod";
 
 const sample${pascal}Schema = z.object({
   name: z.string().min(1, "Name is required"),
 });
 
-const sample${pascal}Handler = async (data: Record<string, unknown>) => {
-  return Ok({ ${camel}: { name: data.name } });
+type Sample${pascal}Input = z.infer<typeof sample${pascal}Schema>;
+
+const sample${pascal}Handler = async (input: Sample${pascal}Input) => {
+  return Ok({ ${camel}: { name: input.name } });
 };
 
-export const sample${pascal}Action: Action = createAction({
+export const sample${pascal}Action = createAction<Sample${pascal}Input>({
   name: "sample",
   description: "Sample ${serviceName} action",
-  handler: sample${pascal}Handler,
   validation: sample${pascal}Schema,
+  handler: sample${pascal}Handler,
 });
 `;
 };
 var generateBarrelContent = (serviceName) => {
   const pascal = toPascalCase2(serviceName);
-  return `export { sample${pascal}Action } from "./sample";
+  return `export { sample${pascal}Action } from "./actions/sample";
 `;
 };
 var generateConfigSnippet = (serviceName) => {
   const pascal = toPascalCase2(serviceName);
-  const importLine = `import { sample${pascal}Action } from "./${serviceName}/sample";`;
+  const importLine = `import { sample${pascal}Action } from "./${serviceName}/actions/sample";`;
   const serviceEntry = `  {
     name: "${serviceName}",
     description: "${pascal} service",
@@ -481,7 +498,7 @@ var autoRegisterService = async (configPath, serviceName) => {
   try {
     let content = await readFileContent(configPath);
     const pascal = toPascalCase2(serviceName);
-    const importLine = `import { sample${pascal}Action } from "./${serviceName}/sample";`;
+    const importLine = `import { sample${pascal}Action } from "./${serviceName}/actions/sample";`;
     const importLines = content.split(`
 `).filter((line) => line.startsWith("import "));
     if (importLines.length === 0) {
@@ -498,7 +515,9 @@ ${importLine}`);
     description: "${pascal} service",
     actions: [sample${pascal}Action],
   },`;
-    const closingIndex = content.lastIndexOf("];");
+    const wrappedClosingIndex = content.lastIndexOf("]);");
+    const plainClosingIndex = content.lastIndexOf("];");
+    const closingIndex = Math.max(wrappedClosingIndex, plainClosingIndex);
     if (closingIndex === -1) {
       return false;
     }
@@ -525,7 +544,7 @@ var generateServiceCommand = async (serviceName) => {
   brand();
   const spinner = createSpinner(`Creating service ${serviceName}...`);
   await ensureDir(serviceDir);
-  await writeFileSafe(resolve4(serviceDir, "sample.ts"), generateActionContent2(serviceName));
+  await writeFileSafe(resolve4(serviceDir, "actions/sample.ts"), generateActionContent2(serviceName));
   await writeFileSafe(resolve4(serviceDir, "index.ts"), generateBarrelContent(serviceName));
   spinner.stop(`Service created at src/services/${serviceName}/`);
   const configPath = resolve4(servicesDir, "services.config.ts");
@@ -557,6 +576,7 @@ ${generateConfigSnippet(serviceName)}
 };
 
 // src/commands/new.ts
+import { rename } from "node:fs/promises";
 import { resolve as resolve5 } from "node:path";
 import { fileURLToPath } from "node:url";
 var __dirname2 = fileURLToPath(new URL(".", import.meta.url));
@@ -581,6 +601,10 @@ var newCommand = async (projectName) => {
   const spinner = createSpinner(`Creating ${projectName}...`);
   const templateDir = resolveTemplateDir();
   await copyDir(templateDir, targetDir);
+  const shippedGitignore = resolve5(targetDir, "gitignore");
+  if (pathExists(shippedGitignore)) {
+    await rename(shippedGitignore, resolve5(targetDir, ".gitignore"));
+  }
   const allFiles = await getFilesRecursive(targetDir);
   const replacements = { "{{projectName}}": projectName };
   for (const filePath of allFiles) {
@@ -597,9 +621,9 @@ var newCommand = async (projectName) => {
   hint("bun run dev");
   console.log("");
   success("Generate with the CLI:");
-  hint("nile g service <name>          Add a new service");
-  hint("nile g action <service> <name> Add an action to a service");
-  hint("nile g schema                  Generate Zod schemas & types");
+  hint("bun run gen service <name>          Add a new service");
+  hint("bun run gen action <service> <name>  Add an action to a service");
+  hint("bun run gen schema                   Generate Zod schemas and types");
   outro();
 };
 
@@ -613,10 +637,10 @@ var ensureDepsInstalled = () => {
   }
 };
 var program = new Command;
-program.name("nile").description("CLI for the Nile backend framework").version("0.0.1");
+program.name("nile").description("CLI for the Nile backend framework").version(version);
 program.command("new").argument("<project-name>", "Name of the project to create").description("Scaffold a new Nile project").action(newCommand);
 var generate = program.command("generate").alias("gen").description("Generate services and actions").hook("preAction", ensureDepsInstalled);
 generate.command("service").argument("<name>", "Service name (kebab-case recommended)").description("Generate a new service with a demo action").action(generateServiceCommand);
-generate.command("action").argument("<service-name>", "Name of the existing service").argument("<action-name>", "Name of the action to create").description("Generate a new action in an existing service").action(generateActionCommand);
+generate.command("action").argument("<service-name>", "Name of the existing service").argument("<action-name>", "Name of the action to create").description("Generate a new action in an existing service").option("--folder", "Create an action folder for private modules").action(generateActionCommand);
 generate.command("schema").option("-e, --entry <path>", "Path to services config file").option("-o, --output <path>", "Output directory for generated files").description("Generate Zod schemas and TypeScript types from action validations").action(generateSchemaCommand);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nilejs/cli",
-  "version": "0.0.6",
+  "version": "1.0.0",
   "description": "CLI for scaffolding and generating Nile backend projects",
   "type": "module",
   "bin": {
@@ -10,10 +10,6 @@
     "dist",
     "template"
   ],
-  "scripts": {
-    "build": "bun run scripts/build.ts",
-    "dev": "bun run src/index.ts"
-  },
   "dependencies": {
     "commander": "^13.1.0",
     "json-schema-to-zod": "^2.7.0",
@@ -22,5 +18,11 @@
   "devDependencies": {
     "@types/node": "^22.8.1",
     "typescript": "^5"
+  },
+  "scripts": {
+    "build": "bun run scripts/build.ts",
+    "dev": "bun run src/index.ts",
+    "typecheck": "tsc --noEmit",
+    "export": "bun run typecheck && bun run build && node dist/index.js --version"
   }
-}
+}

package/template/.dockerignore

@@ -0,0 +1,12 @@
+node_modules/
+.git/
+dist/
+.env
+.env.*
+!.env.example
+*.log
+.DS_Store
+*.local
+coverage/
+.vscode/
+.idea/

package/template/Dockerfile

@@ -0,0 +1,18 @@
+FROM oven/bun:1-alpine
+
+WORKDIR /app
+
+# Copy package files
+COPY package.json bun.lock ./
+
+# Install production dependencies only
+RUN bun install --frozen-lockfile --production
+
+# Copy source code
+COPY . .
+
+# Expose the port (default for Nile)
+EXPOSE 8000
+
+# Start the server
+CMD ["bun", "run", "src/index.ts"]

package/template/README.md

@@ -1,6 +1,8 @@
 # {{projectName}}
 
-Built with [Nile](https://github.com/nile-js/nile).
+Built with [Nile Js](https://nile-js.github.io/nile/). Read the [getting started guide](https://nile-js.github.io/nile/guide/start/getting-started/) for a walkthrough of this starter.
+
+The server runs on Bun's native HTTP server (`runtime: "bun", native: true` in `src/index.ts`). REST settings live under `rest`; custom routes and middleware are available on `server.nativeRest`.
 
 ## Setup
 
@@ -10,7 +12,7 @@ cp .env.example .env
 bun run dev
 ```
 
-The server starts at `http://localhost:8000`. PGLite creates an embedded Postgres database automatically, no external database required.
+The server starts at `http://localhost:8000`. PGlite creates an embedded Postgres database in `data/` on first start, so no database server is required. The first start can take up to 30 seconds.
 
 ## Scripts
 
@@ -24,13 +26,13 @@ The server starts at `http://localhost:8000`. PGLite creates an embedded Postgre
 | `bun run db:push` | Push schema changes directly to the database |
 | `bun run db:studio` | Open Drizzle Studio to browse your data |
 
-## Project Structure
+## Project structure
 
 ```
 src/
   index.ts                        # Server entry point
   db/
-    client.ts                     # PGLite + Drizzle client
+    client.ts                     # PGlite + Drizzle client
     schema.ts                     # Drizzle table definitions
     types.ts                      # Inferred types from schema
     index.ts                      # Barrel export
@@ -39,7 +41,7 @@ src/
       index.ts                    # Barrel export
   services/
     services.config.ts            # Service registry
-    tasks/
+    tasks/actions/
       create.ts                   # Create task action
       list.ts                     # List tasks action
       get.ts                      # Get task by ID action
@@ -75,7 +77,7 @@ curl -X POST http://localhost:8000/api/services \
   -d '{"intent":"schema","service":"tasks","action":"*","payload":{}}'
 ```
 
-## Adding Services
+## Adding services
 
 Generate a new service with the CLI:
 
@@ -83,9 +85,9 @@ Generate a new service with the CLI:
 bun run gen service users
 ```
 
-Or manually create a directory under `src/services/` with action files and register it in `src/services/services.config.ts`.
+The generator offers to register the service in `src/services/services.config.ts`. To add one by hand, create a folder under `src/services/` with an `actions/` folder and register its actions in `services.config.ts`.
 
-## Adding Actions
+## Adding actions
 
 Generate a new action in an existing service:
 
@@ -93,9 +95,9 @@ Generate a new action in an existing service:
 bun run gen action users get-user
 ```
 
-Each action file exports a single action created with `createAction`, which takes a Zod validation schema and a handler function that returns `Ok(data)` or `Err(message)`.
+This creates `src/services/users/actions/get-user.ts`. Each action file exports one action created with `createAction`: a named Zod schema, an input type inferred from it and a named handler that returns `Ok(data)` or `Err(message)`. Import the action in `src/services/services.config.ts` and add it to the service's `actions` list.
 
-## Generating Schemas & Types
+## Generating schemas and types
 
 Extract Zod validation schemas from your actions and generate TypeScript types:
 
@@ -105,8 +107,8 @@ bun run gen schema
 
 This auto-detects `src/services/services.config.ts`, reads validation schemas from all actions, and outputs two files:
 
-- `src/generated/schemas.ts` — named Zod schema exports
-- `src/generated/types.ts` — inferred TypeScript types via `z.infer`
+- `src/generated/schemas.ts`: named Zod schema exports
+- `src/generated/types.ts`: inferred TypeScript types via `z.infer`
 
 Options:
 
@@ -119,14 +121,14 @@ Actions without a validation schema are skipped and listed in the CLI output.
 
 ## Database
 
-This project ships with [PGLite](https://electric-sql.com/product/pglite) for zero-setup local development. For production, you can swap it for Postgres, MySQL, SQLite, or any other database supported by Drizzle. Update `src/db/client.ts` with your connection and driver.
+This project ships with [PGlite](https://electric-sql.com/product/pglite) for zero-setup local development. For production, you can swap it for Postgres, MySQL, SQLite, or any other database supported by Drizzle. Update `src/db/client.ts` with your connection and driver.
 
 See the [Drizzle getting started guide](https://orm.drizzle.team/docs/get-started) for setup instructions with each supported database.
 
-## Tech Stack
+## Tech stack
 
 - **Runtime:** [Bun](https://bun.sh)
-- **Framework:** [@nilejs/nile](https://github.com/nile-js/nile/tree/main/packages/nile)
-- **Database:** [PGLite](https://electric-sql.com/product/pglite) (embedded Postgres)
+- **Framework:** [Nile Js](https://nile-js.github.io/nile/) (`@nilejs/nile`)
+- **Database:** [PGlite](https://electric-sql.com/product/pglite) (embedded Postgres)
 - **ORM:** [Drizzle](https://orm.drizzle.team)
 - **Validation:** [Zod](https://zod.dev)

package/template/docker-compose.dev.yml

@@ -0,0 +1,13 @@
+
+services:
+  nile:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    ports:
+      - "8000:8000"
+    environment:
+      - NODE_ENV=development
+    volumes:
+      - ./data:/app/data
+    restart: unless-stopped

package/template/docker-compose.yml

@@ -0,0 +1,16 @@
+services:
+  nile:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    ports:
+      - "8000:8000"
+    environment:
+      - NODE_ENV=production
+    volumes:
+      # The starter keeps its PGlite database in ./data; this volume keeps it across restarts.
+      - nile_data:/app/data
+    restart: unless-stopped
+
+volumes:
+  nile_data:

package/template/gitignore

@@ -0,0 +1,16 @@
+# Dependencies
+node_modules/
+
+# Local environment
+.env
+.env.*
+!.env.example
+
+# Local PGlite database and logs
+data/
+logs/
+*.log
+
+# Build output and generated files
+dist/
+.DS_Store

package/template/package.json

@@ -4,7 +4,7 @@
   "type": "module",
   "private": true,
   "scripts": {
-    "dev": "bun run src/index.ts",
+    "dev": "bun --watch src/index.ts",
     "gen": "bunx @nilejs/cli generate",
     "db:generate": "bunx drizzle-kit generate",
     "db:push": "bunx drizzle-kit push",
@@ -15,7 +15,6 @@
     "@electric-sql/pglite": "^0.2.5",
     "drizzle-orm": "^0.45.2",
     "pino": "^10.3.1",
-    "slang-ts": "^0.0.7",
     "zod": "^4.3.6"
   },
   "devDependencies": {

package/template/src/index.ts

@@ -1,6 +1,6 @@
 import { createLogger, createNileServer } from "@nilejs/nile";
 import { sql } from "drizzle-orm";
-import { Err, Ok, safeTry } from "slang-ts";
+import { Ok, safeTry } from "@nilejs/nile/fp";
 import { db } from "@/db/client";
 import { services } from "@/services/services.config";
 
@@ -31,6 +31,9 @@ const pushSchema = async () => {
 
 const server = await createNileServer({
   serverName: "{{projectName}}",
+  runtime: "bun",
+  native: true,
+  project: { structure: "error" },
   services,
   resources: { logger, database: db },
   rest: {
@@ -42,6 +45,8 @@ const server = await createNileServer({
     discovery: { enabled: true },
   },
   onBoot: {
+    // The first PGlite start on a slow machine can take longer than the 10 second default.
+    maxWaitTime: 30_000,
     fn: async (ctx) => {
       await pushSchema();
       ctx.resources?.logger?.info({
@@ -54,18 +59,19 @@ const server = await createNileServer({
 });
 
 // Register custom middleware (runs before all service requests)
-server.rest?.addMiddleware("/api", async (c, next) => {
+server.nativeRest?.addMiddleware("/api", async (c, next) => {
   const start = performance.now();
   await next();
   const ms = (performance.now() - start).toFixed(1);
   logger.info({
     atFunction: "requestLog",
-    message: `${c.req.method} ${c.req.path} - ${ms}ms`,
+    message: `${c.request.method} ${c.path} - ${ms}ms`,
   });
+  return undefined;
 });
 
-if (server.rest) {
+if (server.nativeRest) {
   const port = server.config.rest?.port ?? 8000;
-  Bun.serve({ port, fetch: server.rest.app.fetch });
+  Bun.serve({ port, fetch: server.nativeRest.fetch });
   console.log(`\n{{projectName}} listening on http://localhost:${port}\n`);
 }

package/template/src/services/services.config.ts

@@ -1,9 +1,9 @@
 import { createServices, type Services } from "@nilejs/nile";
-import { createTaskAction } from "./tasks/create";
-import { deleteTaskAction } from "./tasks/delete";
-import { getTaskAction } from "./tasks/get";
-import { listTaskAction } from "./tasks/list";
-import { updateTaskAction } from "./tasks/update";
+import { createTaskAction } from "./tasks/actions/create";
+import { deleteTaskAction } from "./tasks/actions/delete";
+import { getTaskAction } from "./tasks/actions/get";
+import { listTaskAction } from "./tasks/actions/list";
+import { updateTaskAction } from "./tasks/actions/update";
 
 export const services: Services = createServices([
   {

package/template/src/services/tasks/{create.ts → actions/create.ts}

@@ -1,5 +1,5 @@
-import { type Action, createAction } from "@nilejs/nile";
-import { Err, Ok } from "slang-ts";
+import { createAction } from "@nilejs/nile";
+import { Err, Ok } from "@nilejs/nile/fp";
 import z from "zod";
 import { taskModel } from "@/db/models";
 
@@ -12,23 +12,27 @@ const createTaskSchema = z.object({
     .default("pending"),
 });
 
-const createTaskHandler = async (data: Record<string, unknown>) => {
+type CreateTaskInput = z.infer<typeof createTaskSchema>;
+
+const createTaskHandler = async (input: CreateTaskInput) => {
   const result = await taskModel.create({
     data: {
-      title: data.title as string,
-      description: (data.description as string) ?? "",
-      status: (data.status as "pending" | "in-progress" | "done") ?? "pending",
+      title: input.title,
+      description: input.description,
+      status: input.status,
     },
   });
+
   if (result.isErr) {
     return Err(result.error);
   }
+
   return Ok({ task: result.value });
 };
 
-export const createTaskAction: Action = createAction({
+export const createTaskAction = createAction<CreateTaskInput>({
   name: "create",
   description: "Create a new task",
-  handler: createTaskHandler,
   validation: createTaskSchema,
+  handler: createTaskHandler,
 });

package/template/src/services/tasks/actions/delete.ts

@@ -0,0 +1,27 @@
+import { createAction } from "@nilejs/nile";
+import { Err, Ok } from "@nilejs/nile/fp";
+import z from "zod";
+import { taskModel } from "@/db/models";
+
+const deleteTaskSchema = z.object({
+  id: z.string().min(1, "Task ID is required"),
+});
+
+type DeleteTaskInput = z.infer<typeof deleteTaskSchema>;
+
+const deleteTaskHandler = async (input: DeleteTaskInput) => {
+  const result = await taskModel.delete(input.id);
+
+  if (result.isErr) {
+    return Err(result.error);
+  }
+
+  return Ok({ deleted: true, id: input.id });
+};
+
+export const deleteTaskAction = createAction<DeleteTaskInput>({
+  name: "delete",
+  description: "Delete a task by ID",
+  validation: deleteTaskSchema,
+  handler: deleteTaskHandler,
+});

package/template/src/services/tasks/{get.ts → actions/get.ts}

@@ -1,5 +1,5 @@
-import { type Action, createAction } from "@nilejs/nile";
-import { Err, Ok } from "slang-ts";
+import { createAction } from "@nilejs/nile";
+import { Err, Ok } from "@nilejs/nile/fp";
 import z from "zod";
 import { taskModel } from "@/db/models";
 
@@ -7,17 +7,21 @@ const getTaskSchema = z.object({
   id: z.string().min(1, "Task ID is required"),
 });
 
-const getTaskHandler = async (data: Record<string, unknown>) => {
-  const result = await taskModel.findById(data.id as string);
+type GetTaskInput = z.infer<typeof getTaskSchema>;
+
+const getTaskHandler = async (input: GetTaskInput) => {
+  const result = await taskModel.findById(input.id);
+
   if (result.isErr) {
     return Err(result.error);
   }
+
   return Ok({ task: result.value });
 };
 
-export const getTaskAction: Action = createAction({
+export const getTaskAction = createAction<GetTaskInput>({
   name: "get",
   description: "Get a task by ID",
-  handler: getTaskHandler,
   validation: getTaskSchema,
+  handler: getTaskHandler,
 });

package/template/src/services/tasks/{list.ts → actions/list.ts}

@@ -1,16 +1,18 @@
-import { type Action, createAction } from "@nilejs/nile";
-import { Err, Ok } from "slang-ts";
+import { createAction } from "@nilejs/nile";
+import { Err, Ok } from "@nilejs/nile/fp";
 import { taskModel } from "@/db/models";
 
 const listTasksHandler = async () => {
   const result = await taskModel.findAll();
+
   if (result.isErr) {
     return Err(result.error);
   }
+
   return Ok({ tasks: result.value });
 };
 
-export const listTaskAction: Action = createAction({
+export const listTaskAction = createAction({
   name: "list",
   description: "List all tasks",
   handler: listTasksHandler,

package/template/src/services/tasks/{update.ts → actions/update.ts}

@@ -1,5 +1,5 @@
-import { type Action, createAction } from "@nilejs/nile";
-import { Err, Ok } from "slang-ts";
+import { createAction } from "@nilejs/nile";
+import { Err, Ok } from "@nilejs/nile/fp";
 import z from "zod";
 import { taskModel } from "@/db/models";
 
@@ -10,22 +10,29 @@ const updateTaskSchema = z.object({
   status: z.enum(["pending", "in-progress", "done"]).optional(),
 });
 
-const updateTaskHandler = async (data: Record<string, unknown>) => {
-  const { id, ...updates } = data;
+type UpdateTaskInput = z.infer<typeof updateTaskSchema>;
 
+const updateTaskHandler = async (input: UpdateTaskInput) => {
+  // Fields left out of the request stay undefined and are not changed.
   const result = await taskModel.update({
-    id: id as string,
-    data: updates,
+    id: input.id,
+    data: {
+      title: input.title,
+      description: input.description,
+      status: input.status,
+    },
   });
+
   if (result.isErr) {
     return Err(result.error);
   }
+
   return Ok({ task: result.value });
 };
 
-export const updateTaskAction: Action = createAction({
+export const updateTaskAction = createAction<UpdateTaskInput>({
   name: "update",
   description: "Update an existing task",
-  handler: updateTaskHandler,
   validation: updateTaskSchema,
+  handler: updateTaskHandler,
 });

package/template/src/services/tasks/delete.ts

@@ -1,23 +0,0 @@
-import { type Action, createAction } from "@nilejs/nile";
-import { Err, Ok } from "slang-ts";
-import z from "zod";
-import { taskModel } from "@/db/models";
-
-const deleteTaskSchema = z.object({
-  id: z.string().min(1, "Task ID is required"),
-});
-
-const deleteTaskHandler = async (data: Record<string, unknown>) => {
-  const result = await taskModel.delete(data.id as string);
-  if (result.isErr) {
-    return Err(result.error);
-  }
-  return Ok({ deleted: true, id: data.id });
-};
-
-export const deleteTaskAction: Action = createAction({
-  name: "delete",
-  description: "Delete a task by ID",
-  handler: deleteTaskHandler,
-  validation: deleteTaskSchema,
-});