@nilejs/cli 0.0.1 → 0.0.3

package/README.md

@@ -114,6 +114,43 @@ export const getUserAction: Action = createAction({
 
 Kebab-case names are converted to camelCase for variables and PascalCase for types.
 
+### `nile generate schema`
+
+Alias: `nile g schema`
+
+Extract Zod validation schemas from your action definitions and generate TypeScript files with schema exports and inferred types.
+
+```bash
+nile g 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/`):
+
+- `schemas.ts` — named Zod schema exports (`tasksCreateSchema`, `tasksUpdateSchema`, etc.)
+- `types.ts` — TypeScript types via `z.infer` (`TasksCreatePayload`, `TasksUpdatePayload`, etc.)
+
+Options:
+
+| Flag | Description |
+|---|---|
+| `-e, --entry <path>` | Path to services config (auto-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 g service <name>` | Add a service with a demo action |
+| `nile g action <service> <name>` | Add an action to an existing service |
+| `nile g schema` | Generate Zod schemas and TypeScript types |
+
 ## Generated Project Structure
 
 ```

package/dist/index.js

@@ -18,7 +18,7 @@ var writeFileSafe = async (filePath, content) => {
   await ensureDir(dirname(filePath));
   await writeFile(filePath, content, "utf-8");
 };
-var readFileContent = async (filePath) => {
+var readFileContent = (filePath) => {
   return readFile(filePath, "utf-8");
 };
 var copyDir = async (src, dest) => {
@@ -49,14 +49,33 @@ var replaceInFile = async (filePath, replacements) => {
 
 // src/utils/log.ts
 import pc from "picocolors";
+var brand = () => console.log(`
+  ${pc.bold(pc.cyan("~ Nile"))}
+`);
+var outro = () => console.log(pc.dim(`
+  Happy hacking. Let code flow like river Nile.
+`));
 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}`));
+var SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+var createSpinner = (msg) => {
+  let i = 0;
+  const stream = process.stdout;
+  const id = setInterval(() => {
+    const frame = SPINNER_FRAMES[i % SPINNER_FRAMES.length];
+    stream.write(`\r  ${pc.cyan(frame)} ${msg}`);
+    i++;
+  }, 80);
+  return {
+    stop: (finalMsg) => {
+      clearInterval(id);
+      stream.write(`\r  ${pc.green("✓")} ${finalMsg}
+`);
+    }
+  };
+};
 
 // src/commands/generate-action.ts
 var toCamelCase = (str) => str.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
@@ -92,7 +111,7 @@ 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);
+    hint(`Create the service first: nile generate service ${serviceName}`);
     process.exit(1);
   }
   const actionFile = resolve(serviceDir, `${actionName}.ts`);
@@ -100,21 +119,24 @@ var generateActionCommand = async (serviceName, actionName) => {
     error(`Action file "${actionName}.ts" already exists in src/services/${serviceName}/`);
     process.exit(1);
   }
-  header(`Generating action: ${serviceName}/${actionName}`);
+  brand();
+  const spinner = createSpinner(`Creating action ${actionName}...`);
   await writeFileSafe(actionFile, generateActionContent(actionName, serviceName));
-  success(`Action created at src/services/${serviceName}/${actionName}.ts`);
+  spinner.stop(`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:");
+  console.log("");
+  hint("Register the action in your service config:");
   hint(`  import { ${camel}Action } from "./${serviceName}/${actionName}";`);
+  outro();
 };
 
-// src/commands/generate-service.ts
-import { resolve as resolve2 } from "node:path";
+// src/commands/generate-schema.ts
+import { execFileSync } from "node:child_process";
+import { resolve as resolve3 } from "node:path";
 
 // src/utils/prompt.ts
 import { createInterface } from "node:readline";
-var confirmPrompt = async (question, defaultYes = true) => {
+var confirmPrompt = (question, defaultYes = true) => {
   const suffix = defaultYes ? "[Y/n]" : "[y/N]";
   const rl = createInterface({
     input: process.stdin,
@@ -132,15 +154,273 @@ var confirmPrompt = async (question, defaultYes = true) => {
     });
   });
 };
+var inputPrompt = (question) => {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2) => {
+    rl.question(`  ${question} `, (answer) => {
+      rl.close();
+      resolve2(answer.trim());
+    });
+  });
+};
 
-// src/commands/generate-service.ts
+// src/utils/schema-codegen.ts
+import { jsonSchemaToZod } from "json-schema-to-zod";
+var toSchemaExportName = (service, action) => {
+  const pascalAction = action.charAt(0).toUpperCase() + action.slice(1);
+  return `${toCamelCase2(service)}${pascalAction}Schema`;
+};
+var toTypeExportName = (service, action) => {
+  const pascalService = toCamelCase2(service).charAt(0).toUpperCase() + toCamelCase2(service).slice(1);
+  const pascalAction = action.charAt(0).toUpperCase() + action.slice(1);
+  return `${pascalService}${pascalAction}Payload`;
+};
 var toCamelCase2 = (str) => str.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+var generateHeader = () => {
+  const timestamp = new Date().toISOString();
+  return [
+    `// Auto-generated by @nilejs/cli on ${timestamp}`,
+    "// Do not edit manually. Re-run `nile generate schema` to update.",
+    ""
+  ].join(`
+`);
+};
+var buildSchemaEntries = (extraction) => {
+  const entries = [];
+  for (const [serviceName, actions] of Object.entries(extraction.schemas)) {
+    for (const [actionName, jsonSchema] of Object.entries(actions)) {
+      const zodCode = jsonSchemaToZod(jsonSchema, {
+        noImport: true
+      });
+      entries.push({
+        serviceName,
+        actionName,
+        exportName: toSchemaExportName(serviceName, actionName),
+        typeName: toTypeExportName(serviceName, actionName),
+        zodCode
+      });
+    }
+  }
+  return entries;
+};
+var generateSchemasFile = (extraction) => {
+  const entries = buildSchemaEntries(extraction);
+  if (entries.length === 0) {
+    return `${generateHeader()}
+// No action schemas found.
+`;
+  }
+  const lines = [generateHeader(), `import { z } from "zod";`, ""];
+  for (const entry of entries) {
+    lines.push(`export const ${entry.exportName} = ${entry.zodCode};`);
+    lines.push("");
+  }
+  if (extraction.skipped.length > 0) {
+    lines.push(`// Skipped (no validation): ${extraction.skipped.join(", ")}`);
+    lines.push("");
+  }
+  return lines.join(`
+`);
+};
+var generateTypesFile = (extraction) => {
+  const entries = buildSchemaEntries(extraction);
+  if (entries.length === 0) {
+    return `${generateHeader()}
+// No action types found.
+`;
+  }
+  const schemaImports = entries.map((e) => e.exportName);
+  const lines = [
+    generateHeader(),
+    `import type { z } from "zod";`,
+    "import type {",
+    ...schemaImports.map((name, i) => i < schemaImports.length - 1 ? `  ${name},` : `  ${name},`),
+    `} from "./schemas";`,
+    ""
+  ];
+  for (const entry of entries) {
+    lines.push(`export type ${entry.typeName} = z.infer<typeof ${entry.exportName}>;`);
+  }
+  lines.push("");
+  return lines.join(`
+`);
+};
+
+// src/utils/schema-extractor.ts
+import { execFile } from "node:child_process";
+import { unlink, writeFile as writeFile2 } from "node:fs/promises";
+import { resolve as resolve2 } from "node:path";
+var TEMP_SCRIPT_NAME = ".nile-schema-extract.ts";
+var LEADING_SLASH = /^\//;
+var TS_EXTENSION = /\.ts$/;
+var buildExtractionScript = (configPath) => {
+  return `import z from "zod";
+import { services } from "${configPath}";
+
+const schemas: Record<string, Record<string, unknown>> = {};
+const skipped: string[] = [];
+
+for (const service of services) {
+  const serviceSchemas: Record<string, unknown> = {};
+
+  for (const action of service.actions) {
+    if (!action.validation) {
+      skipped.push(\`\${service.name}.\${action.name}\`);
+      continue;
+    }
+
+    try {
+      const jsonSchema = z.toJSONSchema(action.validation, { unrepresentable: "any" });
+      serviceSchemas[action.name] = jsonSchema;
+    } catch {
+      skipped.push(\`\${service.name}.\${action.name}\`);
+    }
+  }
+
+  if (Object.keys(serviceSchemas).length > 0) {
+    schemas[service.name] = serviceSchemas;
+  }
+}
+
+console.log(JSON.stringify({ schemas, skipped }));
+`;
+};
+var resolveImportPath = (configPath, projectRoot) => {
+  const relative = configPath.replace(projectRoot, "").replace(LEADING_SLASH, "./").replace(TS_EXTENSION, "");
+  return relative.startsWith("./") ? relative : `./${relative}`;
+};
+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) => {
+    writeFile2(tempScriptPath, scriptContent, "utf-8").then(() => {
+      execFile("bun", ["run", TEMP_SCRIPT_NAME], { cwd: projectRoot, timeout: 30000 }, (err, stdout, stderr) => {
+        unlink(tempScriptPath).catch(() => {});
+        if (err) {
+          const message = stderr?.trim() || err.message;
+          reject(new Error(`Schema extraction failed:
+${message}`));
+          return;
+        }
+        try {
+          const result = JSON.parse(stdout.trim());
+          resolve3(result);
+        } catch {
+          reject(new Error(`Failed to parse extraction output. Raw output:
+${stdout.trim()}`));
+        }
+      });
+    }).catch((writeErr) => {
+      reject(new Error(`Failed to write temp extraction script: ${writeErr.message}`));
+    });
+  });
+};
+var DEFAULT_CONFIG_PATH = "src/services/services.config.ts";
+var findServicesConfig = (projectRoot) => {
+  const defaultPath = resolve2(projectRoot, DEFAULT_CONFIG_PATH);
+  return pathExists(defaultPath) ? defaultPath : null;
+};
+
+// src/commands/generate-schema.ts
+var DEFAULT_OUTPUT_DIR = "src/generated";
+var LEADING_SLASH2 = /^\//;
+var resolveConfigPath = async (projectRoot, entryFlag) => {
+  if (entryFlag) {
+    const absolute2 = resolve3(projectRoot, entryFlag);
+    if (!pathExists(absolute2)) {
+      error(`Config file not found: ${entryFlag}`);
+      return null;
+    }
+    return absolute2;
+  }
+  const detected = findServicesConfig(projectRoot);
+  if (detected) {
+    success("Found services config at src/services/services.config.ts");
+    return detected;
+  }
+  warn("Could not find src/services/services.config.ts");
+  const userPath = await inputPrompt("Enter the path to your services config file:");
+  if (!userPath) {
+    error("No config path provided.");
+    return null;
+  }
+  const absolute = resolve3(projectRoot, userPath);
+  if (!pathExists(absolute)) {
+    error(`Config file not found: ${userPath}`);
+    return null;
+  }
+  return absolute;
+};
+var checkBunAvailable = () => {
+  try {
+    execFileSync("bun", ["--version"], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+};
+var generateSchemaCommand = async (options) => {
+  const projectRoot = process.cwd();
+  brand();
+  if (!checkBunAvailable()) {
+    error("Bun is required for schema extraction but was not found.");
+    hint("Install bun: https://bun.sh");
+    process.exit(1);
+  }
+  const configPath = await resolveConfigPath(projectRoot, options.entry);
+  if (!configPath) {
+    process.exit(1);
+  }
+  const spinner = createSpinner("Extracting action schemas...");
+  let extraction;
+  try {
+    extraction = await extractSchemas(configPath, projectRoot);
+  } catch (err) {
+    spinner.stop("Extraction failed");
+    console.log("");
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+  const schemaCount = Object.values(extraction.schemas).reduce((sum, actions) => sum + Object.keys(actions).length, 0);
+  if (schemaCount === 0) {
+    spinner.stop("No action schemas found");
+    warn("None of the actions have validation schemas defined.");
+    hint("Add a Zod validation schema to your actions to generate types.");
+    outro();
+    return;
+  }
+  spinner.stop(`Extracted ${schemaCount} action schema${schemaCount > 1 ? "s" : ""}`);
+  const outputDir = resolve3(projectRoot, options.output ?? DEFAULT_OUTPUT_DIR);
+  await ensureDir(outputDir);
+  const schemasContent = generateSchemasFile(extraction);
+  const typesContent = generateTypesFile(extraction);
+  const schemasPath = resolve3(outputDir, "schemas.ts");
+  const typesPath = resolve3(outputDir, "types.ts");
+  await writeFileSafe(schemasPath, schemasContent);
+  success(`Generated ${schemasPath.replace(projectRoot, "").replace(LEADING_SLASH2, "")}`);
+  await writeFileSafe(typesPath, typesContent);
+  success(`Generated ${typesPath.replace(projectRoot, "").replace(LEADING_SLASH2, "")}`);
+  if (extraction.skipped.length > 0) {
+    console.log("");
+    hint(`Skipped ${extraction.skipped.length} action(s) without validation:`);
+    hint(extraction.skipped.join(", "));
+  }
+  outro();
+};
+
+// src/commands/generate-service.ts
+import { resolve as resolve4 } from "node:path";
+var toCamelCase3 = (str) => str.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
 var toPascalCase2 = (str) => {
-  const camel = toCamelCase2(str);
+  const camel = toCamelCase3(str);
   return camel.charAt(0).toUpperCase() + camel.slice(1);
 };
 var generateActionContent2 = (serviceName) => {
-  const camel = toCamelCase2(serviceName);
+  const camel = toCamelCase3(serviceName);
   const pascal = toPascalCase2(serviceName);
   return `import { type Action, createAction } from "@nilejs/nile";
 import { Ok } from "slang-ts";
@@ -173,7 +453,7 @@ var generateConfigSnippet = (serviceName) => {
   const serviceEntry = `  {
     name: "${serviceName}",
     description: "${pascal} service",
-    actions: createActions([sample${pascal}Action]),
+    actions: [sample${pascal}Action],
   },`;
   return `${importLine}
 
@@ -199,7 +479,7 @@ ${importLine}`);
     const serviceEntry = `  {
     name: "${serviceName}",
     description: "${pascal} service",
-    actions: createActions([sample${pascal}Action]),
+    actions: [sample${pascal}Action],
   },`;
     const closingIndex = content.lastIndexOf("];");
     if (closingIndex === -1) {
@@ -214,36 +494,37 @@ ${importLine}`);
   }
 };
 var generateServiceCommand = async (serviceName) => {
-  const servicesDir = resolve2(process.cwd(), "src/services");
+  const servicesDir = resolve4(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);
+  const serviceDir = resolve4(servicesDir, serviceName);
   if (pathExists(serviceDir)) {
     error(`Service "${serviceName}" already exists at src/services/${serviceName}/`);
     process.exit(1);
   }
-  header(`Generating service: ${serviceName}`);
+  brand();
+  const spinner = createSpinner(`Creating 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");
+  await writeFileSafe(resolve4(serviceDir, "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");
   if (!pathExists(configPath)) {
     warn("Could not find services.config.ts");
-    header("Add this to your services config:");
+    console.log("");
+    hint("Add this to your services config:");
     console.log(generateConfigSnippet(serviceName));
+    outro();
     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");
+      success("Registered in services.config.ts");
     } else {
       warn("Could not auto-register. Add manually:");
       console.log(`
@@ -251,37 +532,38 @@ ${generateConfigSnippet(serviceName)}
 `);
     }
   } else {
-    header("Add this to your services config:");
+    console.log("");
+    hint("Add this to your services config:");
     console.log(generateConfigSnippet(serviceName));
   }
+  outro();
 };
 
 // src/commands/new.ts
-import { resolve as resolve3 } from "node:path";
+import { resolve as resolve5 } from "node:path";
 import { fileURLToPath } from "node:url";
 var __dirname2 = fileURLToPath(new URL(".", import.meta.url));
 var resolveTemplateDir = () => {
-  const devPath = resolve3(__dirname2, "../../template");
+  const devPath = resolve5(__dirname2, "../../template");
   if (pathExists(devPath)) {
     return devPath;
   }
-  const distPath = resolve3(__dirname2, "../template");
+  const distPath = resolve5(__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);
+  const targetDir = resolve5(process.cwd(), projectName);
   if (pathExists(targetDir)) {
     error(`Directory "${projectName}" already exists.`);
     process.exit(1);
   }
-  header(`Creating project: ${projectName}`);
+  brand();
+  const spinner = createSpinner(`Creating ${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) {
@@ -289,12 +571,19 @@ var newCommand = async (projectName) => {
       await replaceInFile(filePath, replacements);
     }
   }
-  success(`Project "${projectName}" created.`);
-  header("Next steps:");
+  spinner.stop("Project ready.");
+  success(`Created ${projectName}`);
+  console.log("");
   hint(`cd ${projectName}`);
   hint("bun install");
   hint("cp .env.example .env");
   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");
+  outro();
 };
 
 // src/index.ts
@@ -304,4 +593,5 @@ program.command("new").argument("<project-name>", "Name of the project to create
 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);
+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.1",
+  "version": "0.0.3",
   "description": "CLI for scaffolding and generating Nile backend projects",
   "type": "module",
   "bin": {
@@ -16,6 +16,7 @@
   },
   "dependencies": {
     "commander": "^13.1.0",
+    "json-schema-to-zod": "^2.7.0",
     "picocolors": "^1.1.1"
   },
   "devDependencies": {

package/template/README.md

@@ -10,7 +10,7 @@ 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.
+The server starts at `http://localhost:8000`. PGLite creates an embedded Postgres database automatically, no external database required.
 
 ## Scripts
 
@@ -51,7 +51,7 @@ All requests go through a single POST endpoint. The `intent` field determines th
 ### Explore available services
 
 ```bash
-curl -X POST http://localhost:3000/api/services \
+curl -X POST http://localhost:8000/api/services \
   -H "Content-Type: application/json" \
   -d '{"intent":"explore","service":"*","action":"*","payload":{}}'
 ```
@@ -59,7 +59,7 @@ curl -X POST http://localhost:3000/api/services \
 ### Execute an action
 
 ```bash
-curl -X POST http://localhost:3000/api/services \
+curl -X POST http://localhost:8000/api/services \
   -H "Content-Type: application/json" \
   -d '{"intent":"execute","service":"tasks","action":"create","payload":{"title":"My first task"}}'
 ```
@@ -67,7 +67,7 @@ curl -X POST http://localhost:3000/api/services \
 ### Get action schemas
 
 ```bash
-curl -X POST http://localhost:3000/api/services \
+curl -X POST http://localhost:8000/api/services \
   -H "Content-Type: application/json" \
   -d '{"intent":"schema","service":"tasks","action":"*","payload":{}}'
 ```
@@ -78,6 +78,7 @@ Generate a new service with the CLI:
 
 ```bash
 nile generate service users
+# or: nile g service users
 ```
 
 Or manually create a directory under `src/services/` with action files and register it in `src/services/services.config.ts`.
@@ -88,10 +89,34 @@ Generate a new action in an existing service:
 
 ```bash
 nile generate action users get-user
+# or: nile g 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)`.
 
+## Generating Schemas & Types
+
+Extract Zod validation schemas from your actions and generate TypeScript types:
+
+```bash
+nile generate schema
+# or: nile g 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`
+
+Options:
+
+| Flag | Description |
+|---|---|
+| `-e, --entry <path>` | Path to services config (auto-detected by default) |
+| `-o, --output <path>` | Output directory (default: `src/generated`) |
+
+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.

package/template/package.json

@@ -10,7 +10,7 @@
     "db:studio": "bunx drizzle-kit studio"
   },
   "dependencies": {
-    "@nilejs/nile": "^0.0.1",
+    "@nilejs/nile": "latest",
     "@electric-sql/pglite": "^0.2.5",
     "drizzle-orm": "^0.39.2",
     "pino": "^10.3.1",

package/template/src/index.ts

@@ -36,8 +36,8 @@ const server = createNileServer({
   rest: {
     baseUrl: "/api",
     host: "localhost",
-    port: 3000,
-    allowedOrigins: ["http://localhost:3000"],
+    port: 8000,
+    allowedOrigins: ["http://localhost:8000"],
     enableStatus: true,
   },
   onBoot: {
@@ -52,7 +52,7 @@ const server = createNileServer({
 });
 
 if (server.rest) {
-  const port = server.config.rest?.port ?? 3000;
+  const port = server.config.rest?.port ?? 8000;
   const { fetch } = server.rest.app;
 
   Bun.serve({ port, fetch });

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

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