@nilejs/cli 1.0.1 → 1.0.3

package/README.md

@@ -72,12 +72,12 @@ const getUserSchema = z.object({
 
 type GetUserInput = z.infer<typeof getUserSchema>;
 
-const getUserHandler = async (input: GetUserInput) => {
+const getUserHandler = async (data: GetUserInput) => {
   // Implement users.get-user here
-  return Ok({ result: input });
+  return Ok({ result: data });
 };
 
-export const getUserAction = createAction<GetUserInput>({
+export const getUserAction = createAction({
   name: "get-user",
   description: "GetUser action for users",
   validation: getUserSchema,
@@ -103,11 +103,11 @@ Reads every action's validation schema from `src/services/services.config.ts` an
 | `-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 output. Share the generated files with a frontend to validate forms with the same rules as the server.
+Every registered action is included in `ServicePayloads`. Actions without a validation schema accept an object payload (`Record<string, unknown>`), so actions such as `tasks.list` can be called with `{}`. This fallback does not add server-side validation. Schemas that cannot be converted are reported separately. Share the generated files with a frontend to validate forms with the same rules as the server.
 
 ## Current starter
 
-CLI 1.0.1 targets Nile `^1.0.4`, Zod 4, TypeScript 7 and the Drizzle model helpers. The generated layout passes Nile’s strict boot checks. Database setup returns a Result and prevents startup on failure; shutdown drains Nile’s work before closing PGlite. Helpers are available as `utils.createModel`, and Result helpers come from `@nilejs/nile/fp`.
+The starter uses Nile `^1.0.5`, Zod 4, TypeScript 7 and the Drizzle model helpers. The generated layout passes Nile’s strict boot checks. Database setup returns a Result and prevents startup on failure; shutdown drains Nile’s work before closing PGlite. Helpers are available as `utils.createModel`, and Result helpers come from `@nilejs/nile/fp`.
 
 Existing apps are not rewritten when the CLI updates. For an older starter, add a service entry point at `src/services/<domain>/index.ts`, register its actions there, and import that service from `services.config.ts`. [Nile’s migration notes](https://github.com/nile-js/nile/blob/main/packages/nile/docs/release-migration.md) describe the current error and startup behavior.
 

package/dist/index.js

@@ -4,7 +4,7 @@
 import { resolve as resolve6 } from "node:path";
 import { Command } from "commander";
 // package.json
-var version = "1.0.1";
+var version = "1.0.3";
 
 // src/commands/generate-action.ts
 import { resolve } from "node:path";
@@ -99,12 +99,12 @@ const ${camel}Schema = z.object({
 
 type ${pascal}Input = z.infer<typeof ${camel}Schema>;
 
-const ${camel}Handler = async (input: ${pascal}Input) => {
+const ${camel}Handler = async (data: ${pascal}Input) => {
   // Implement ${serviceName}.${actionName} here
-  return Ok({ result: input });
+  return Ok({ result: data });
 };
 
-export const ${camel}Action = createAction<${pascal}Input>({
+export const ${camel}Action = createAction({
   name: "${actionName}",
   description: "${pascal} action for ${serviceName}",
   validation: ${camel}Schema,
@@ -210,7 +210,7 @@ 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, {
+      const zodCode = jsonSchema === null ? "z.record(z.string(), z.unknown())" : jsonSchemaToZod(jsonSchema, {
         noImport: true
       });
       entries.push({
@@ -237,7 +237,7 @@ var generateSchemasFile = (extraction) => {
     lines.push("");
   }
   if (extraction.skipped.length > 0) {
-    lines.push(`// Skipped (no validation): ${extraction.skipped.join(", ")}`);
+    lines.push(`// Skipped (schema conversion failed): ${extraction.skipped.join(", ")}`);
     lines.push("");
   }
   return lines.join(`
@@ -247,7 +247,7 @@ var generateTypesFile = (extraction) => {
   const entries = buildSchemaEntries(extraction);
   if (entries.length === 0) {
     return `${generateHeader()}
-// No action types found.
+export type ServicePayloads = Record<never, never>;
 `;
   }
   const schemaImports = entries.map((e) => e.exportName);
@@ -302,7 +302,7 @@ for (const service of services) {
 
   for (const action of service.actions) {
     if (!action.validation) {
-      skipped.push(\`\${service.name}.\${action.name}\`);
+      serviceSchemas[action.name] = null;
       continue;
     }
 
@@ -419,15 +419,8 @@ var generateSchemaCommand = async (options) => {
     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 actionCount = Object.values(extraction.schemas).reduce((sum, actions) => sum + Object.keys(actions).length, 0);
+  spinner.stop(`Read ${actionCount} action contract${actionCount === 1 ? "" : "s"}`);
   const outputDir = resolve3(projectRoot, options.output ?? DEFAULT_OUTPUT_DIR);
   await ensureDir(outputDir);
   const schemasContent = generateSchemasFile(extraction);
@@ -440,7 +433,7 @@ var generateSchemaCommand = async (options) => {
   success(`Generated ${typesPath.replace(projectRoot, "").replace(LEADING_SLASH2, "")}`);
   if (extraction.skipped.length > 0) {
     console.log("");
-    hint(`Skipped ${extraction.skipped.length} action(s) without validation:`);
+    warn(`Could not convert validation schemas for ${extraction.skipped.length} action(s):`);
     hint(extraction.skipped.join(", "));
   }
   outro();
@@ -466,11 +459,11 @@ const sample${pascal}Schema = z.object({
 
 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 } });
+const sample${pascal}Handler = async (data: Sample${pascal}Input) => {
+  return Ok({ ${camel}: { name: data.name } });
 };
 
-export const sample${pascal}Action = createAction<Sample${pascal}Input>({
+export const sample${pascal}Action = createAction({
   name: "sample",
   description: "Sample ${serviceName} action",
   validation: sample${pascal}Schema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nilejs/cli",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "CLI for scaffolding and generating Nile backend projects",
   "type": "module",
   "bin": {
@@ -17,12 +17,14 @@
   },
   "devDependencies": {
     "@types/node": "^22.8.1",
-    "typescript": "^5"
+    "typescript": "^5",
+    "zod": "4.6.7"
   },
   "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"
+    "export": "bun run typecheck && bun run build && node dist/index.js --version",
+    "test": "bun test scripts/schema-contracts.spec.ts"
   }
 }

package/template/README.md

@@ -127,7 +127,7 @@ Options:
 | `-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.
+Every registered action is included in `ServicePayloads`. Actions without validation accept an object payload (`Record<string, unknown>`); call `tasks.list` with `{}`. This fallback does not add server-side validation. Schemas that cannot be converted are reported separately.
 
 ## Database
 

package/template/SKILL.md

@@ -49,7 +49,7 @@ Structure violations fail startup by default. An application needs `src/index.ts
 
 ## The action pattern
 
-Every action uses a named schema, an inferred input type, a separately written named handler and `createAction<T>`:
+Define a named schema, derive the handler’s data type and pass the named handler to `createAction`. The action type and handler return type are inferred. Use `data` and `context` for the parameters you need; omit unused parameters:
 
 ```ts
 import { createAction } from "@nilejs/nile";
@@ -62,15 +62,15 @@ const createProjectSchema = z.object({
 
 type CreateProjectInput = z.infer<typeof createProjectSchema>;
 
-const createProjectHandler = (input: CreateProjectInput) => {
-  if (input.name === "system") {
+const createProjectHandler = (data: CreateProjectInput) => {
+  if (data.name === "system") {
     return Err("Choose a different project name");
   }
 
-  return Ok({ project: { name: input.name } });
+  return Ok({ project: { name: data.name } });
 };
 
-export const createProjectAction = createAction<CreateProjectInput>({
+export const createProjectAction = createAction({
   name: "create",
   description: "Create a project",
   validation: createProjectSchema,
@@ -104,7 +104,7 @@ Action names are unique within a service. Folder names do not create routes; onl
 
 ## Handlers take (data, context)
 
-Nile Js calls every handler with two arguments: the validated input and the execution's `NileContext`. The type marks the context optional. Use `createAction<Input>` for the schema’s parsed output type, and import `NileContext` when annotating a named handler’s second argument. Read an optional context with `?.` or explicitly reject its absence before using it.
+Nile Js calls every handler with two arguments: the validated input and the execution's `NileContext`. For a named handler, annotate `data` with the schema’s parsed output type and use `context` for its second parameter. Import `NileContext` when you need to annotate it. `createAction` infers its type from the handler; leave off the repeated generic argument and inferred return annotation. Read an optional context with `?.` or explicitly reject its absence before using it.
 
 - `context.getSession("rest")` returns the verified JWT identity (`userId`, `organizationId` and other claims) for a protected action.
 - `context.resources` holds what `createNileServer` received (`logger`, `database`).
@@ -324,7 +324,7 @@ Advanced pages cover handler context, composed hooks, execution options and test
 1. Read `services.config.ts`, the target service’s `index.ts` and its actions before you change anything.
 2. Follow the existing pattern in that service. Do not add a second architecture.
 3. Never invent an API. Check the guide, the installed `@nilejs/nile` types in `node_modules`, or the existing code. If it is not there, say so.
-4. Use named schemas, inferred input types, named handlers, `createAction<T>` and braces on every `if`.
+4. Use named schemas and handlers. Name action parameters `data` and `context`, and hook parameters `hookContext`. Annotate a named handler’s data from the schema; let `createAction` and return types infer the rest. Use braces on every `if`.
 5. Start with business rules in the action’s named handler. Move reusable rules or transaction coordination into ordinary domain functions when that makes them easier to share or test. Keep persistence in models or repositories; keep transaction boundaries explicit.
 6. Typecheck and run the relevant tests after a coherent change. Exercise the registered action through `server.invoke` or a transport when registration, policy or validation changes.
 7. Do not commit, publish or change secrets, `.env` values or deployment settings unless the user asks.

package/template/package.json

@@ -12,7 +12,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@nilejs/nile": "^1.0.4",
+    "@nilejs/nile": "^1.0.5",
     "@electric-sql/pglite": "^0.2.5",
     "drizzle-orm": "^0.45.4",
     "pino": "^10.4.0",

package/template/src/index.ts

@@ -54,12 +54,12 @@ const server = await createNileServer({
   onBoot: {
     // The first PGlite start on a slow machine can take longer than the 10 second default.
     maxWaitTime: 30_000,
-    fn: async (ctx) => {
+    fn: async (context) => {
       const prepared = await pushSchema();
       if (prepared.isErr) {
         return prepared;
       }
-      ctx.resources?.logger?.info({
+      context.resources?.logger?.info({
         atFunction: "onBoot",
         message: "{{projectName}} booted - PGLite schema ready",
       });

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

@@ -1,5 +1,5 @@
 import { createAction } from "@nilejs/nile";
-import { Err, Ok } from "@nilejs/nile/fp";
+import { Ok } from "@nilejs/nile/fp";
 import z from "zod";
 import { taskModel } from "@/db/models";
 
@@ -14,23 +14,23 @@ const createTaskSchema = z.object({
 
 type CreateTaskInput = z.infer<typeof createTaskSchema>;
 
-const createTaskHandler = async (input: CreateTaskInput) => {
+const createTaskHandler = async (data: CreateTaskInput) => {
   const result = await taskModel.create({
     data: {
-      title: input.title,
-      description: input.description,
-      status: input.status,
+      title: data.title,
+      description: data.description,
+      status: data.status,
     },
   });
 
   if (result.isErr) {
-    return Err(result.error);
+    return result;
   }
 
   return Ok({ task: result.value });
 };
 
-export const createTaskAction = createAction<CreateTaskInput>({
+export const createTaskAction = createAction({
   name: "create",
   description: "Create a new task",
   validation: createTaskSchema,

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

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

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

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

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

@@ -1,12 +1,12 @@
 import { createAction } from "@nilejs/nile";
-import { Err, Ok } from "@nilejs/nile/fp";
+import { 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 result;
   }
 
   return Ok({ tasks: result.value });

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

@@ -1,5 +1,5 @@
 import { createAction } from "@nilejs/nile";
-import { Err, Ok } from "@nilejs/nile/fp";
+import { Ok } from "@nilejs/nile/fp";
 import z from "zod";
 import { taskModel } from "@/db/models";
 
@@ -12,25 +12,25 @@ const updateTaskSchema = z.object({
 
 type UpdateTaskInput = z.infer<typeof updateTaskSchema>;
 
-const updateTaskHandler = async (input: UpdateTaskInput) => {
+const updateTaskHandler = async (data: UpdateTaskInput) => {
   // Fields left out of the request stay undefined and are not changed.
   const result = await taskModel.update({
-    id: input.id,
+    id: data.id,
     data: {
-      title: input.title,
-      description: input.description,
-      status: input.status,
+      title: data.title,
+      description: data.description,
+      status: data.status,
     },
   });
 
   if (result.isErr) {
-    return Err(result.error);
+    return result;
   }
 
   return Ok({ task: result.value });
 };
 
-export const updateTaskAction = createAction<UpdateTaskInput>({
+export const updateTaskAction = createAction({
   name: "update",
   description: "Update an existing task",
   validation: updateTaskSchema,