@nilejs/cli 0.0.2 → 0.0.4

package/README.md

@@ -2,7 +2,7 @@
 
 [![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.
+CLI for scaffolding and generating [Nile](https://github.com/nile-js/nile/tree/main/packages/nile) backend projects.
 
 ## Install
 
@@ -60,12 +60,12 @@ The scaffolded project includes:
 
 ### `nile generate service <name>`
 
-Alias: `nile g service <name>`
+Alias: `nile gen 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
+nile gen service users
 ```
 
 Creates:
@@ -80,12 +80,12 @@ After creating the files, the CLI asks whether to auto-register the service in `
 
 ### `nile generate action <service-name> <action-name>`
 
-Alias: `nile g action <service-name> <action-name>`
+Alias: `nile gen action <service-name> <action-name>`
 
 Generate a new action file in an existing service directory.
 
 ```bash
-nile g action users get-user
+nile gen action users get-user
 ```
 
 Creates `src/services/users/get-user.ts` with:
@@ -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 gen schema`
+
+Extract Zod validation schemas from your action definitions and generate TypeScript files with schema exports and inferred types.
+
+```bash
+nile 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/`):
+
+- `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 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
 
 ```

package/dist/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
+import { resolve as resolve6 } from "node:path";
 import { Command } from "commander";
 
 // src/commands/generate-action.ts
@@ -130,8 +131,9 @@ var generateActionCommand = async (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";
@@ -153,15 +155,289 @@ var confirmPrompt = (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) => `  ${name},`),
+    `} from "./schemas.js";`,
+    ""
+  ];
+  for (const entry of entries) {
+    lines.push(`export type ${entry.typeName} = z.infer<typeof ${entry.exportName}>;`);
+  }
+  lines.push("");
+  lines.push("/** Map of all services and their action payloads for @nilejs/client */");
+  lines.push("export type ServicePayloads = {");
+  const serviceMap = {};
+  for (const entry of entries) {
+    if (!serviceMap[entry.serviceName]) {
+      serviceMap[entry.serviceName] = [];
+    }
+    serviceMap[entry.serviceName].push(`    "${entry.actionName}": ${entry.typeName};`);
+  }
+  for (const [service, actions] of Object.entries(serviceMap)) {
+    lines.push(`  "${service}": {`);
+    lines.push(...actions);
+    lines.push("  };");
+  }
+  lines.push("};");
+  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";
@@ -194,7 +470,7 @@ var generateConfigSnippet = (serviceName) => {
   const serviceEntry = `  {
     name: "${serviceName}",
     description: "${pascal} service",
-    actions: createActions([sample${pascal}Action]),
+    actions: [sample${pascal}Action],
   },`;
   return `${importLine}
 
@@ -220,7 +496,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) {
@@ -235,13 +511,13 @@ ${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);
@@ -249,10 +525,10 @@ var generateServiceCommand = async (serviceName) => {
   brand();
   const spinner = createSpinner(`Creating service ${serviceName}...`);
   await ensureDir(serviceDir);
-  await writeFileSafe(resolve2(serviceDir, "sample.ts"), generateActionContent2(serviceName));
-  await writeFileSafe(resolve2(serviceDir, "index.ts"), generateBarrelContent(serviceName));
+  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 = resolve2(servicesDir, "services.config.ts");
+  const configPath = resolve4(servicesDir, "services.config.ts");
   if (!pathExists(configPath)) {
     warn("Could not find services.config.ts");
     console.log("");
@@ -281,22 +557,22 @@ ${generateConfigSnippet(serviceName)}
 };
 
 // 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);
@@ -315,18 +591,32 @@ var newCommand = async (projectName) => {
   spinner.stop("Project ready.");
   success(`Created ${projectName}`);
   console.log("");
-  hint("cd " + projectName);
+  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
+var ensureDepsInstalled = () => {
+  const nodeModulesPath = resolve6(process.cwd(), "node_modules");
+  if (!pathExists(nodeModulesPath)) {
+    error("Dependencies not installed.");
+    hint("Run 'bun install' first, then try again.");
+    process.exit(1);
+  }
+};
 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");
+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("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.2",
+  "version": "0.0.4",
   "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

@@ -1,6 +1,6 @@
 # {{projectName}}
 
-Built with [Nile](https://www.npmjs.com/package/@nilejs/nile).
+Built with [Nile](https://github.com/nile-js/nile).
 
 ## Setup
 
@@ -17,6 +17,9 @@ The server starts at `http://localhost:8000`. PGLite creates an embedded Postgre
 | Script | Description |
 |---|---|
 | `bun run dev` | Start the development server |
+| `bun run gen service <name>` | Generate a new service |
+| `bun run gen action <service> <name>` | Generate a new action |
+| `bun run gen schema` | Generate Zod schemas and TypeScript types |
 | `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 |
@@ -77,7 +80,7 @@ curl -X POST http://localhost:8000/api/services \
 Generate a new service with the CLI:
 
 ```bash
-nile generate service users
+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`.
@@ -87,11 +90,33 @@ Or manually create a directory under `src/services/` with action files and regis
 Generate a new action in an existing service:
 
 ```bash
-nile generate action users get-user
+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)`.
 
+## Generating Schemas & Types
+
+Extract Zod validation schemas from your actions and generate TypeScript types:
+
+```bash
+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`
+
+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.
@@ -101,7 +126,7 @@ See the [Drizzle getting started guide](https://orm.drizzle.team/docs/get-starte
 ## Tech Stack
 
 - **Runtime:** [Bun](https://bun.sh)
-- **Framework:** [@nilejs/nile](https://www.npmjs.com/package/@nilejs/nile)
+- **Framework:** [@nilejs/nile](https://github.com/nile-js/nile/tree/main/packages/nile)
 - **Database:** [PGLite](https://electric-sql.com/product/pglite) (embedded Postgres)
 - **ORM:** [Drizzle](https://orm.drizzle.team)
 - **Validation:** [Zod](https://zod.dev)

package/template/package.json

@@ -5,12 +5,13 @@
   "private": true,
   "scripts": {
     "dev": "bun run src/index.ts",
+    "gen": "bunx @nilejs/cli generate",
     "db:generate": "bunx drizzle-kit generate",
     "db:push": "bunx drizzle-kit push",
     "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/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,
-    ]),
+    ],
   },
-];
+]);