@nilejs/cli 0.0.1

package/README.md

@@ -0,0 +1,152 @@
+# @nilejs/cli
+
+[![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://www.npmjs.com/package/@nilejs/nile) backend projects.
+
+## Install
+
+```bash
+bun add -g @nilejs/cli
+```
+
+```bash
+npm install -g @nilejs/cli
+```
+
+Or use without installing:
+
+```bash
+bunx @nilejs/cli new my-app
+```
+
+```bash
+npx @nilejs/cli new my-app
+```
+
+## Commands
+
+### `nile new <project-name>`
+
+Scaffold a new Nile project. Copies the project template, replaces placeholders with your project name, and prints next steps.
+
+```bash
+nile new my-app
+```
+
+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>`
+
+Alias: `nile g service <name>`
+
+Generate a new service directory under `src/services/` with a demo action and barrel export. Run this from the project root.
+
+```bash
+nile g service users
+```
+
+Creates:
+
+```
+src/services/users/
+  sample.ts       # Demo action with Zod schema, handler, and createAction
+  index.ts        # Barrel export
+```
+
+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>`
+
+Alias: `nile g action <service-name> <action-name>`
+
+Generate a new action file in an existing service directory.
+
+```bash
+nile g action users get-user
+```
+
+Creates `src/services/users/get-user.ts` with:
+
+```typescript
+import { type Action, createAction } from "@nilejs/nile";
+import { Ok } from "slang-ts";
+import z from "zod";
+
+const getUserSchema = z.object({
+  // Define your validation schema here
+});
+
+const getUserHandler = async (data: Record<string, unknown>) => {
+  // Implement your users.get-user logic here
+  return Ok({ result: data });
+};
+
+export const getUserAction: Action = createAction({
+  name: "get-user",
+  description: "GetUser action for users",
+  handler: getUserHandler,
+  validation: getUserSchema,
+});
+```
+
+Kebab-case names are converted to camelCase for variables and PascalCase for 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
+```
+
+## Requirements
+
+- Node.js 18+ or Bun
+- The scaffolded project uses Bun as its runtime (`Bun.serve`, `bun run`)
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/generate-action.ts
+import { resolve } from "node:path";
+
+// src/utils/files.ts
+import { existsSync } from "node:fs";
+import { cp, mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+var pathExists = (path) => existsSync(path);
+var ensureDir = async (path) => {
+  await mkdir(path, { recursive: true });
+};
+var writeFileSafe = async (filePath, content) => {
+  await ensureDir(dirname(filePath));
+  await writeFile(filePath, content, "utf-8");
+};
+var readFileContent = async (filePath) => {
+  return readFile(filePath, "utf-8");
+};
+var copyDir = async (src, dest) => {
+  await cp(src, dest, { recursive: true });
+};
+var getFilesRecursive = async (dir, root) => {
+  const base = root ?? dir;
+  const entries = await readdir(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await getFilesRecursive(fullPath, base);
+      files.push(...nested);
+    } else {
+      files.push(fullPath);
+    }
+  }
+  return files;
+};
+var replaceInFile = async (filePath, replacements) => {
+  let content = await readFileContent(filePath);
+  for (const [placeholder, value] of Object.entries(replacements)) {
+    content = content.replaceAll(placeholder, value);
+  }
+  await writeFile(filePath, content, "utf-8");
+};
+
+// src/utils/log.ts
+import pc from "picocolors";
+var success = (msg) => console.log(pc.green(`  ✓ ${msg}`));
+var info = (msg) => console.log(pc.cyan(`  ${msg}`));
+var warn = (msg) => console.log(pc.yellow(`  ⚠ ${msg}`));
+var error = (msg) => console.error(pc.red(`  ✗ ${msg}`));
+var header = (msg) => console.log(`
+${pc.bold(msg)}
+`);
+var hint = (msg) => console.log(pc.dim(`    ${msg}`));
+
+// src/commands/generate-action.ts
+var toCamelCase = (str) => str.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+var toPascalCase = (str) => {
+  const camel = toCamelCase(str);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+};
+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";
+import z from "zod";
+
+const ${camel}Schema = z.object({
+  // Define your validation schema here
+});
+
+const ${camel}Handler = async (data: Record<string, unknown>) => {
+  // Implement your ${serviceName}.${actionName} logic here
+  return Ok({ result: data });
+};
+
+export const ${camel}Action: Action = createAction({
+  name: "${actionName}",
+  description: "${pascal} action for ${serviceName}",
+  handler: ${camel}Handler,
+  validation: ${camel}Schema,
+});
+`;
+};
+var generateActionCommand = async (serviceName, actionName) => {
+  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)) {
+    error(`Action file "${actionName}.ts" already exists in src/services/${serviceName}/`);
+    process.exit(1);
+  }
+  header(`Generating action: ${serviceName}/${actionName}`);
+  await writeFileSafe(actionFile, generateActionContent(actionName, serviceName));
+  success(`Action created at src/services/${serviceName}/${actionName}.ts`);
+  const camel = toCamelCase(actionName);
+  header("Next steps:");
+  hint("Import and register the action in your service config:");
+  hint(`  import { ${camel}Action } from "./${serviceName}/${actionName}";`);
+};
+
+// src/commands/generate-service.ts
+import { resolve as resolve2 } from "node:path";
+
+// src/utils/prompt.ts
+import { createInterface } from "node:readline";
+var confirmPrompt = async (question, defaultYes = true) => {
+  const suffix = defaultYes ? "[Y/n]" : "[y/N]";
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2) => {
+    rl.question(`  ${question} ${suffix} `, (answer) => {
+      rl.close();
+      const trimmed = answer.trim().toLowerCase();
+      if (trimmed === "") {
+        resolve2(defaultYes);
+        return;
+      }
+      resolve2(trimmed === "y" || trimmed === "yes");
+    });
+  });
+};
+
+// src/commands/generate-service.ts
+var toCamelCase2 = (str) => str.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+var toPascalCase2 = (str) => {
+  const camel = toCamelCase2(str);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+};
+var generateActionContent2 = (serviceName) => {
+  const camel = toCamelCase2(serviceName);
+  const pascal = toPascalCase2(serviceName);
+  return `import { type Action, createAction } from "@nilejs/nile";
+import { Ok } from "slang-ts";
+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 } });
+};
+
+export const sample${pascal}Action: Action = createAction({
+  name: "sample",
+  description: "Sample ${serviceName} action",
+  handler: sample${pascal}Handler,
+  validation: sample${pascal}Schema,
+});
+`;
+};
+var generateBarrelContent = (serviceName) => {
+  const pascal = toPascalCase2(serviceName);
+  return `export { sample${pascal}Action } from "./sample";
+`;
+};
+var generateConfigSnippet = (serviceName) => {
+  const pascal = toPascalCase2(serviceName);
+  const importLine = `import { sample${pascal}Action } from "./${serviceName}/sample";`;
+  const serviceEntry = `  {
+    name: "${serviceName}",
+    description: "${pascal} service",
+    actions: createActions([sample${pascal}Action]),
+  },`;
+  return `${importLine}
+
+// Add to services array:
+${serviceEntry}`;
+};
+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 importLines = content.split(`
+`).filter((line) => line.startsWith("import "));
+    if (importLines.length === 0) {
+      return false;
+    }
+    const lastImport = importLines.at(-1);
+    if (!lastImport) {
+      return false;
+    }
+    content = content.replace(lastImport, `${lastImport}
+${importLine}`);
+    const serviceEntry = `  {
+    name: "${serviceName}",
+    description: "${pascal} service",
+    actions: createActions([sample${pascal}Action]),
+  },`;
+    const closingIndex = content.lastIndexOf("];");
+    if (closingIndex === -1) {
+      return false;
+    }
+    content = content.slice(0, closingIndex) + serviceEntry + `
+` + content.slice(closingIndex);
+    await writeFileSafe(configPath, content);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var generateServiceCommand = async (serviceName) => {
+  const servicesDir = resolve2(process.cwd(), "src/services");
+  if (!pathExists(servicesDir)) {
+    error("Could not find src/services/ directory.");
+    hint("Make sure you're in a Nile project root.");
+    process.exit(1);
+  }
+  const serviceDir = resolve2(servicesDir, serviceName);
+  if (pathExists(serviceDir)) {
+    error(`Service "${serviceName}" already exists at src/services/${serviceName}/`);
+    process.exit(1);
+  }
+  header(`Generating service: ${serviceName}`);
+  await ensureDir(serviceDir);
+  info("Creating demo action...");
+  await writeFileSafe(resolve2(serviceDir, "sample.ts"), generateActionContent2(serviceName));
+  info("Creating barrel export...");
+  await writeFileSafe(resolve2(serviceDir, "index.ts"), generateBarrelContent(serviceName));
+  success(`Service "${serviceName}" created at src/services/${serviceName}/`);
+  const configPath = resolve2(servicesDir, "services.config.ts");
+  if (!pathExists(configPath)) {
+    warn("Could not find services.config.ts");
+    header("Add this to your services config:");
+    console.log(generateConfigSnippet(serviceName));
+    return;
+  }
+  const shouldRegister = await confirmPrompt("Register this service in services.config.ts?");
+  if (shouldRegister) {
+    const registered = await autoRegisterService(configPath, serviceName);
+    if (registered) {
+      success("Service registered in services.config.ts");
+    } else {
+      warn("Could not auto-register. Add manually:");
+      console.log(`
+${generateConfigSnippet(serviceName)}
+`);
+    }
+  } else {
+    header("Add this to your services config:");
+    console.log(generateConfigSnippet(serviceName));
+  }
+};
+
+// src/commands/new.ts
+import { resolve as resolve3 } from "node:path";
+import { fileURLToPath } from "node:url";
+var __dirname2 = fileURLToPath(new URL(".", import.meta.url));
+var resolveTemplateDir = () => {
+  const devPath = resolve3(__dirname2, "../../template");
+  if (pathExists(devPath)) {
+    return devPath;
+  }
+  const distPath = resolve3(__dirname2, "../template");
+  if (pathExists(distPath)) {
+    return distPath;
+  }
+  throw new Error("Template directory not found. The CLI package may be corrupted.");
+};
+var newCommand = async (projectName) => {
+  const targetDir = resolve3(process.cwd(), projectName);
+  if (pathExists(targetDir)) {
+    error(`Directory "${projectName}" already exists.`);
+    process.exit(1);
+  }
+  header(`Creating project: ${projectName}`);
+  const templateDir = resolveTemplateDir();
+  info("Copying project files...");
+  await copyDir(templateDir, targetDir);
+  info("Configuring project...");
+  const allFiles = await getFilesRecursive(targetDir);
+  const replacements = { "{{projectName}}": projectName };
+  for (const filePath of allFiles) {
+    if (filePath.endsWith(".ts") || filePath.endsWith(".json") || filePath.endsWith(".md")) {
+      await replaceInFile(filePath, replacements);
+    }
+  }
+  success(`Project "${projectName}" created.`);
+  header("Next steps:");
+  hint(`cd ${projectName}`);
+  hint("bun install");
+  hint("cp .env.example .env");
+  hint("bun run dev");
+};
+
+// src/index.ts
+var program = new Command;
+program.name("nile").description("CLI for the Nile backend framework").version("0.0.1");
+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("g").description("Generate services and actions");
+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);
+program.parse();

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@nilejs/cli",
+  "version": "0.0.1",
+  "description": "CLI for scaffolding and generating Nile backend projects",
+  "type": "module",
+  "bin": {
+    "nile": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "template"
+  ],
+  "scripts": {
+    "build": "bun run scripts/build.ts",
+    "dev": "bun run src/index.ts"
+  },
+  "dependencies": {
+    "commander": "^13.1.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.8.1",
+    "typescript": "^5"
+  }
+}

package/template/.env.example

@@ -0,0 +1 @@
+MODE=dev

package/template/README.md

@@ -0,0 +1,107 @@
+# {{projectName}}
+
+Built with [Nile](https://www.npmjs.com/package/@nilejs/nile).
+
+## Setup
+
+```bash
+bun install
+cp .env.example .env
+bun run dev
+```
+
+The server starts at `http://localhost:3000`. PGLite creates an embedded Postgres database automatically, no external database required.
+
+## Scripts
+
+| Script | Description |
+|---|---|
+| `bun run dev` | Start the development server |
+| `bun run db:generate` | Generate Drizzle migrations from schema changes |
+| `bun run db:push` | Push schema changes directly to the database |
+| `bun run db:studio` | Open Drizzle Studio to browse your data |
+
+## Project Structure
+
+```
+src/
+  index.ts                        # Server entry point
+  db/
+    client.ts                     # PGLite + Drizzle client
+    schema.ts                     # Drizzle table definitions
+    types.ts                      # Inferred types from schema
+    index.ts                      # Barrel export
+    models/
+      tasks.ts                    # Task model (createModel)
+      index.ts                    # Barrel export
+  services/
+    services.config.ts            # Service registry
+    tasks/
+      create.ts                   # Create task action
+      list.ts                     # List tasks action
+      get.ts                      # Get task by ID action
+      update.ts                   # Update task action
+      delete.ts                   # Delete task action
+```
+
+## Usage
+
+All requests go through a single POST endpoint. The `intent` field determines the operation.
+
+### Explore available services
+
+```bash
+curl -X POST http://localhost:3000/api/services \
+  -H "Content-Type: application/json" \
+  -d '{"intent":"explore","service":"*","action":"*","payload":{}}'
+```
+
+### Execute an action
+
+```bash
+curl -X POST http://localhost:3000/api/services \
+  -H "Content-Type: application/json" \
+  -d '{"intent":"execute","service":"tasks","action":"create","payload":{"title":"My first task"}}'
+```
+
+### Get action schemas
+
+```bash
+curl -X POST http://localhost:3000/api/services \
+  -H "Content-Type: application/json" \
+  -d '{"intent":"schema","service":"tasks","action":"*","payload":{}}'
+```
+
+## Adding Services
+
+Generate a new service with the CLI:
+
+```bash
+nile generate service users
+```
+
+Or manually create a directory under `src/services/` with action files and register it in `src/services/services.config.ts`.
+
+## Adding Actions
+
+Generate a new action in an existing service:
+
+```bash
+nile generate 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)`.
+
+## 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.
+
+See the [Drizzle getting started guide](https://orm.drizzle.team/docs/get-started) for setup instructions with each supported database.
+
+## Tech Stack
+
+- **Runtime:** [Bun](https://bun.sh)
+- **Framework:** [@nilejs/nile](https://www.npmjs.com/package/@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/drizzle.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  dialect: "postgresql",
+  schema: "./src/db/schema.ts",
+  out: "./src/db/migrations",
+});

package/template/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "{{projectName}}",
+  "version": "0.0.1",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "db:generate": "bunx drizzle-kit generate",
+    "db:push": "bunx drizzle-kit push",
+    "db:studio": "bunx drizzle-kit studio"
+  },
+  "dependencies": {
+    "@nilejs/nile": "^0.0.1",
+    "@electric-sql/pglite": "^0.2.5",
+    "drizzle-orm": "^0.39.2",
+    "pino": "^10.3.1",
+    "slang-ts": "^0.0.7",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "drizzle-kit": "^0.31.4",
+    "typescript": "^5"
+  }
+}

package/template/src/db/client.ts

@@ -0,0 +1,13 @@
+import { PGlite } from "@electric-sql/pglite";
+import { drizzle } from "drizzle-orm/pglite";
+// biome-ignore lint/performance/noNamespaceImport: Drizzle requires namespace import for schema passthrough
+import * as schema from "./schema";
+
+/** Resolve data directory relative to project root (where bun run is invoked) */
+const DATA_DIR = `${process.cwd()}/data`;
+
+/** PGLite instance with file-based persistence */
+export const pglite = new PGlite(DATA_DIR);
+
+/** Drizzle ORM instance wrapping PGLite, with schema for relational queries */
+export const db = drizzle(pglite, { schema });

package/template/src/db/index.ts

@@ -0,0 +1,3 @@
+export { db } from "./client";
+export * from "./schema";
+export type { NewTask, Task } from "./types";

package/template/src/db/models/index.ts

@@ -0,0 +1 @@
+export { taskModel } from "./tasks";

package/template/src/db/models/tasks.ts

@@ -0,0 +1,6 @@
+import { createModel } from "@nilejs/nile";
+import { db } from "@/db/client";
+import { tasks } from "@/db/schema";
+
+/** CRUD model for tasks — auto-validates, handles errors, and supports transactions */
+export const taskModel = createModel(tasks, { db, name: "task" });

package/template/src/db/schema.ts

@@ -0,0 +1,17 @@
+import { pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+
+export const tasks = pgTable("tasks", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  title: text("title").notNull(),
+  description: text("description"),
+  status: text("status", { enum: ["pending", "in-progress", "done"] })
+    .notNull()
+    .default("pending"),
+  created_at: timestamp("created_at", { withTimezone: true })
+    .notNull()
+    .defaultNow(),
+  updated_at: timestamp("updated_at", { withTimezone: true })
+    .notNull()
+    .defaultNow()
+    .$onUpdate(() => new Date()),
+});

package/template/src/db/types.ts

@@ -0,0 +1,4 @@
+import type { tasks } from "./schema";
+
+export type Task = typeof tasks.$inferSelect;
+export type NewTask = typeof tasks.$inferInsert;

package/template/src/index.ts

@@ -0,0 +1,67 @@
+import { createLogger, createNileServer } from "@nilejs/nile";
+import { sql } from "drizzle-orm";
+import { safeTry } from "slang-ts";
+import { db } from "@/db/client";
+import { services } from "@/services/services.config";
+
+const logger = createLogger("{{projectName}}", { chunking: "monthly" });
+
+/**
+ * Push schema to PGLite on boot.
+ * Creates the tasks table if it doesn't exist.
+ */
+const pushSchema = async () => {
+  const result = await safeTry(() =>
+    db.execute(sql`
+      CREATE TABLE IF NOT EXISTS tasks (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        title TEXT NOT NULL,
+        description TEXT,
+        status TEXT NOT NULL DEFAULT 'pending',
+        created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+      )
+    `)
+  );
+
+  if (result.isErr) {
+    console.error("[pushSchema] Failed:", result.error);
+  }
+};
+
+const server = createNileServer({
+  serverName: "{{projectName}}",
+  services,
+  resources: { logger, database: db },
+  rest: {
+    baseUrl: "/api",
+    host: "localhost",
+    port: 3000,
+    allowedOrigins: ["http://localhost:3000"],
+    enableStatus: true,
+  },
+  onBoot: {
+    fn: async () => {
+      await pushSchema();
+      logger.info({
+        atFunction: "onBoot",
+        message: "{{projectName}} booted — PGLite schema ready",
+      });
+    },
+  },
+});
+
+if (server.rest) {
+  const port = server.config.rest?.port ?? 3000;
+  const { fetch } = server.rest.app;
+
+  Bun.serve({ port, fetch });
+
+  console.log(`\n{{projectName}} listening on http://localhost:${port}`);
+  console.log("\nTry it:");
+  console.log(`  curl -X POST http://localhost:${port}/api/services \\`);
+  console.log(`    -H "Content-Type: application/json" \\`);
+  console.log(
+    `    -d '{"intent":"explore","service":"*","action":"*","payload":{}}'`
+  );
+}

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

@@ -0,0 +1,21 @@
+import { createActions, 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";
+
+export const services: Services = [
+  {
+    name: "tasks",
+    description: "Task management with CRUD operations",
+    meta: { version: "1.0.0" },
+    actions: createActions([
+      createTaskAction,
+      listTaskAction,
+      getTaskAction,
+      updateTaskAction,
+      deleteTaskAction,
+    ]),
+  },
+];

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

@@ -0,0 +1,34 @@
+import { type Action, createAction } from "@nilejs/nile";
+import { Err, Ok } from "slang-ts";
+import z from "zod";
+import { taskModel } from "@/db/models";
+
+const createTaskSchema = z.object({
+  title: z.string().min(1, "Title is required"),
+  description: z.string().optional().default(""),
+  status: z
+    .enum(["pending", "in-progress", "done"])
+    .optional()
+    .default("pending"),
+});
+
+const createTaskHandler = async (data: Record<string, unknown>) => {
+  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",
+    },
+  });
+  if (result.isErr) {
+    return Err(result.error);
+  }
+  return Ok({ task: result.value });
+};
+
+export const createTaskAction: Action = createAction({
+  name: "create",
+  description: "Create a new task",
+  handler: createTaskHandler,
+  validation: createTaskSchema,
+});

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

@@ -0,0 +1,23 @@
+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,
+});

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

@@ -0,0 +1,23 @@
+import { type Action, createAction } from "@nilejs/nile";
+import { Err, Ok } from "slang-ts";
+import z from "zod";
+import { taskModel } from "@/db/models";
+
+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);
+  if (result.isErr) {
+    return Err(result.error);
+  }
+  return Ok({ task: result.value });
+};
+
+export const getTaskAction: Action = createAction({
+  name: "get",
+  description: "Get a task by ID",
+  handler: getTaskHandler,
+  validation: getTaskSchema,
+});

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

@@ -0,0 +1,17 @@
+import { type Action, createAction } from "@nilejs/nile";
+import { Err, Ok } from "slang-ts";
+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({
+  name: "list",
+  description: "List all tasks",
+  handler: listTasksHandler,
+});

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

@@ -0,0 +1,31 @@
+import { type Action, createAction } from "@nilejs/nile";
+import { Err, Ok } from "slang-ts";
+import z from "zod";
+import { taskModel } from "@/db/models";
+
+const updateTaskSchema = z.object({
+  id: z.string().min(1, "Task ID is required"),
+  title: z.string().min(1).optional(),
+  description: z.string().optional(),
+  status: z.enum(["pending", "in-progress", "done"]).optional(),
+});
+
+const updateTaskHandler = async (data: Record<string, unknown>) => {
+  const { id, ...updates } = data;
+
+  const result = await taskModel.update({
+    id: id as string,
+    data: updates,
+  });
+  if (result.isErr) {
+    return Err(result.error);
+  }
+  return Ok({ task: result.value });
+};
+
+export const updateTaskAction: Action = createAction({
+  name: "update",
+  description: "Update an existing task",
+  handler: updateTaskHandler,
+  validation: updateTaskSchema,
+});

package/template/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "./dist",
+    "rootDir": ".",
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["./src/**/*.ts", "./drizzle.config.ts"],
+  "exclude": ["node_modules", "dist", "data"]
+}