@nilejs/cli 0.0.7 → 1.0.1

package/template/src/index.ts

@@ -1,7 +1,7 @@
-import { createLogger, createNileServer } from "@nilejs/nile";
+import { createLogger, createNileServer, utils } from "@nilejs/nile";
 import { sql } from "drizzle-orm";
-import { Err, Ok, safeTry } from "slang-ts";
-import { db } from "@/db/client";
+import { Ok, safeTry } from "@nilejs/nile/fp";
+import { db, pglite } from "@/db/client";
 import { services } from "@/services/services.config";
 
 const logger = createLogger("{{projectName}}", {
@@ -25,12 +25,22 @@ const pushSchema = async () => {
   );
 
   if (result.isErr) {
-    console.error("[pushSchema] Failed:", result.error);
+    return utils.handleError({
+      message: "Could not prepare the task database.",
+      data: utils.describeError(result.raw),
+      atFunction: "pushSchema",
+      logger: logger,
+    });
   }
+
+  return Ok(null);
 };
 
 const server = await createNileServer({
   serverName: "{{projectName}}",
+  runtime: "bun",
+  native: true,
+  project: { root: process.cwd(), structure: "error" },
   services,
   resources: { logger, database: db },
   rest: {
@@ -42,8 +52,13 @@ const server = await createNileServer({
     discovery: { enabled: true },
   },
   onBoot: {
+    // The first PGlite start on a slow machine can take longer than the 10 second default.
+    maxWaitTime: 30_000,
     fn: async (ctx) => {
-      await pushSchema();
+      const prepared = await pushSchema();
+      if (prepared.isErr) {
+        return prepared;
+      }
       ctx.resources?.logger?.info({
         atFunction: "onBoot",
         message: "{{projectName}} booted - PGLite schema ready",
@@ -54,18 +69,34 @@ const server = await createNileServer({
 });
 
 // Register custom middleware (runs before all service requests)
-server.rest?.addMiddleware("/api", async (c, next) => {
+server.nativeRest?.addMiddleware("/api", async (c, next) => {
   const start = performance.now();
   await next();
   const ms = (performance.now() - start).toFixed(1);
   logger.info({
     atFunction: "requestLog",
-    message: `${c.req.method} ${c.req.path} - ${ms}ms`,
+    message: `${c.request.method} ${c.path} - ${ms}ms`,
   });
+  return undefined;
 });
 
-if (server.rest) {
+if (server.nativeRest) {
   const port = server.config.rest?.port ?? 8000;
-  Bun.serve({ port, fetch: server.rest.app.fetch });
+  const listener = Bun.serve({
+    port: port,
+    fetch: server.nativeRest.fetch,
+  });
+  let closing = false;
+  const shutdown = async () => {
+    if (closing) {
+      return;
+    }
+    closing = true;
+    listener.stop();
+    await server.lifecycle.shutdown();
+    await pglite.close();
+  };
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
   console.log(`\n{{projectName}} listening on http://localhost:${port}\n`);
 }

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

@@ -1,21 +1,4 @@
-import { createServices, type Services } from "@nilejs/nile";
-import { createTaskAction } from "./tasks/create";
-import { deleteTaskAction } from "./tasks/delete";
-import { getTaskAction } from "./tasks/get";
-import { listTaskAction } from "./tasks/list";
-import { updateTaskAction } from "./tasks/update";
+import { createServices } from "@nilejs/nile";
+import { tasksService } from "./tasks";
 
-export const services: Services = createServices([
-  {
-    name: "tasks",
-    description: "Task management with CRUD operations",
-    meta: { version: "1.0.0" },
-    actions: [
-      createTaskAction,
-      listTaskAction,
-      getTaskAction,
-      updateTaskAction,
-      deleteTaskAction,
-    ],
-  },
-]);
+export const services = createServices([tasksService]);

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,18 @@
+import { createService } from "@nilejs/nile";
+import { createTaskAction } from "./actions/create";
+import { deleteTaskAction } from "./actions/delete";
+import { getTaskAction } from "./actions/get";
+import { listTaskAction } from "./actions/list";
+import { updateTaskAction } from "./actions/update";
+
+export const tasksService = createService({
+  name: "tasks",
+  description: "Task management with CRUD operations",
+  actions: [
+    createTaskAction,
+    listTaskAction,
+    getTaskAction,
+    updateTaskAction,
+    deleteTaskAction,
+  ],
+});

package/template/tsconfig.json

@@ -8,11 +8,23 @@
     "skipLibCheck": true,
     "outDir": "./dist",
     "rootDir": ".",
-    "baseUrl": ".",
     "paths": {
-      "@/*": ["./src/*"]
-    }
+      "@/*": [
+        "./src/*"
+      ]
+    },
+    "noEmit": true,
+    "types": [
+      "bun"
+    ]
   },
-  "include": ["./src/**/*.ts", "./drizzle.config.ts"],
-  "exclude": ["node_modules", "dist", "data"]
+  "include": [
+    "./src/**/*.ts",
+    "./drizzle.config.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "data"
+  ]
 }

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

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