create-nexwire 4.2.5 → 4.4.0

package/fastify/src/framework/maker-cli/stubs/notification/route.api.ts.stub

@@ -0,0 +1,71 @@
+import type { FastifyPluginAsyncZod } from "fastify-type-provider-zod";
+import { HttpStatusCodes, z } from "@/framework/facade.js";
+import { authMiddleware } from "@/middlewares/auth-middleware.js";
+import { list, markAllRead, markRead, remove, unreadCount } from "../controllers/{{leaf}}.js";
+import { PaginatedNotificationsSchema, UnreadCountSchema } from "../schemas/{{leaf}}.js";
+
+const notificationId = z.object({ id: z.string().min(1) });
+const okResponse = z.object({ ok: z.boolean() });
+
+const notificationRoutes: FastifyPluginAsyncZod = async (app) => {
+  app.addHook("preHandler", authMiddleware);
+
+  app.route({
+    method: "GET",
+    url: "/",
+    schema: {
+      tags: ["Notifications"],
+      description: "List notifications",
+      response: { [HttpStatusCodes.OK]: PaginatedNotificationsSchema }
+    },
+    handler: list
+  });
+
+  app.route({
+    method: "GET",
+    url: "/unread-count",
+    schema: {
+      tags: ["Notifications"],
+      description: "Count unread notifications",
+      response: { [HttpStatusCodes.OK]: UnreadCountSchema }
+    },
+    handler: unreadCount
+  });
+
+  app.route({
+    method: "PATCH",
+    url: "/:id/read",
+    schema: {
+      tags: ["Notifications"],
+      description: "Mark a notification as read",
+      params: notificationId,
+      response: { [HttpStatusCodes.OK]: okResponse }
+    },
+    handler: markRead
+  });
+
+  app.route({
+    method: "PATCH",
+    url: "/read-all",
+    schema: {
+      tags: ["Notifications"],
+      description: "Mark every notification as read",
+      response: { [HttpStatusCodes.OK]: okResponse }
+    },
+    handler: markAllRead
+  });
+
+  app.route({
+    method: "DELETE",
+    url: "/:id",
+    schema: {
+      tags: ["Notifications"],
+      description: "Delete a notification",
+      params: notificationId,
+      response: { [HttpStatusCodes.OK]: okResponse }
+    },
+    handler: remove
+  });
+};
+
+export default notificationRoutes;

package/fastify/src/framework/maker-cli/stubs/notification/route.plain.ts.stub

@@ -0,0 +1,15 @@
+import type { FastifyPluginAsyncZod } from "fastify-type-provider-zod";
+import { authMiddleware } from "@/middlewares/auth-middleware.js";
+import { list, unreadCount, markRead, markAllRead, remove } from "../controllers/{{leaf}}.js";
+
+const notificationRoutes: FastifyPluginAsyncZod = async (app) => {
+  app.addHook("preHandler", authMiddleware);
+
+  app.get("/", list);
+  app.get("/unread-count", unreadCount);
+  app.patch("/:id/read", markRead);
+  app.patch("/read-all", markAllRead);
+  app.delete("/:id", remove);
+};
+
+export default notificationRoutes;

package/fastify/src/framework/maker-cli/stubs/notification/schema.plain.ts.stub

@@ -0,0 +1,26 @@
+import { z } from "@/framework/facade.js";
+
+export const NotificationSchema = z.object({
+  id: z.string(),
+  notifiableType: z.string(),
+  notifiableId: z.string(),
+  type: z.string(),
+  title: z.string(),
+  body: z.string().nullable(),
+  data: z.any().nullable(),
+  link: z.string().nullable(),
+  readAt: z.string().nullable(),
+  createdAt: z.string()
+});
+
+export const UnreadCountSchema = z.object({
+  count: z.number()
+});
+
+export const PaginatedNotificationsSchema = z.object({
+  data: z.array(NotificationSchema),
+  total: z.number(),
+  unread: z.number(),
+  page: z.number(),
+  perPage: z.number()
+});

package/fastify/src/framework/maker-cli/stubs/notification/schema.ts.stub

@@ -0,0 +1,26 @@
+import { z } from "@/framework/facade.js";
+
+export const NotificationSchema = z.object({
+  id: z.string(),
+  notifiableType: z.string(),
+  notifiableId: z.string(),
+  type: z.string(),
+  title: z.string(),
+  body: z.string().nullable(),
+  data: z.any().nullable(),
+  link: z.string().nullable(),
+  readAt: z.string().nullable(),
+  createdAt: z.string()
+});
+
+export const UnreadCountSchema = z.object({
+  count: z.number()
+});
+
+export const PaginatedNotificationsSchema = z.object({
+  data: z.array(NotificationSchema),
+  total: z.number(),
+  unread: z.number(),
+  page: z.number(),
+  perPage: z.number()
+});

package/fastify/src/framework/maker-cli/stubs/provider/module-barrel.ts.stub

@@ -0,0 +1,19 @@
+/**
+ * Providers for the {{module}} module.
+ *
+ * This file is imported automatically at boot, so whatever it registers is
+ * available to the whole application. Use this to plug implementations (e.g.
+ * auth, payments) into the app - not to export the module's API to other
+ * modules (that is what facade.ts is for):
+ *
+ *   import { registerProvider } from "@/framework/facade.js";
+ *
+ *   registerProvider("{{module}}", { ... });
+ *
+ * A module with more than one provider keeps them in providers/*.ts instead -
+ * those files are imported at boot too.
+ *
+ * Rule: a module never imports another module's provider implementation.
+ */
+
+export {};

package/fastify/src/framework/maker-cli/stubs/provider/module.ts.stub

@@ -0,0 +1,21 @@
+import { registerProvider } from "@/framework/facade.js";
+
+/**
+ * Why: Plugs the {{name}} implementation into the application.
+ * When: Imported automatically at boot from each module's providers folder.
+ * Where: src/modules/{{module}}/providers/{{name}}.ts
+ *
+ * Reach it from anywhere in the app:
+ *
+ *   import { getProvider } from "@/framework/facade.js";
+ *   const {{camel}} = getProvider<typeof {{camel}}Provider>("{{name}}");
+ *
+ * Rule: a provider never imports another module's provider implementation.
+ */
+export const {{camel}}Provider = {
+  async handle(input: unknown) {
+    return input;
+  }
+};
+
+registerProvider("{{name}}", {{camel}}Provider);

package/fastify/src/framework/maker-cli/stubs/provider/name.ts.stub

@@ -0,0 +1,21 @@
+import { registerProvider } from "@/framework/facade.js";
+
+/**
+ * Why: Plugs the {{name}} implementation into the application.
+ * When: Imported automatically at boot from src/providers/.
+ * Where: src/providers/{{name}}.ts
+ *
+ * Reach it from anywhere in the app:
+ *
+ *   import { getProvider } from "@/framework/facade.js";
+ *   const {{camel}} = getProvider<typeof {{camel}}Provider>("{{name}}");
+ *
+ * Rule: a provider never imports another provider's implementation.
+ */
+export const {{camel}}Provider = {
+  async handle(input: unknown) {
+    return input;
+  }
+};
+
+registerProvider("{{name}}", {{camel}}Provider);

package/fastify/src/framework/maker-cli/stubs/route/api.ts.stub

@@ -0,0 +1,101 @@
+import type { FastifyPluginAsyncZod } from "fastify-type-provider-zod";
+import { HttpStatusCodes, ValidationErrorSchema } from "@/framework/facade.js";
+import { authMiddleware } from "@/middlewares/auth-middleware.js";
+import { requireRole } from "@/middlewares/role-middleware.js";
+import { destroy, index, show, store, update } from "@/modules/{{module}}/controllers/{{controller}}.js";
+import {
+  Create{{ClassName}}Schema,
+  {{ClassName}}IdParamsSchema,
+  {{ClassName}}ListResponseSchema,
+  {{ClassName}}MessageSchema,
+  {{ClassName}}ResponseSchema,
+  Update{{ClassName}}Schema
+} from "@/modules/{{module}}/schemas/{{controller}}.js";
+
+const routes: FastifyPluginAsyncZod = async (app) => {
+  app.route({
+    method: "GET",
+    url: "/",
+    schema: {
+      tags: ["{{ModuleClass}}"],
+      description: "List {{module}}",
+      response: {
+        [HttpStatusCodes.OK]: {{ClassName}}ListResponseSchema
+      }
+    },
+    handler: index
+  });
+
+  app.route({
+    method: "GET",
+    url: "/:id",
+    schema: {
+      tags: ["{{ModuleClass}}"],
+      description: "Get one {{module}}",
+      params: {{ClassName}}IdParamsSchema,
+      response: {
+        [HttpStatusCodes.OK]: {{ClassName}}ResponseSchema,
+        [HttpStatusCodes.NOT_FOUND]: {{ClassName}}MessageSchema
+      }
+    },
+    handler: show
+  });
+
+  app.route({
+    method: "POST",
+    url: "/",
+    schema: {
+      tags: ["{{ModuleClass}}"],
+      description: "Create {{module}}",
+      body: Create{{ClassName}}Schema,
+      response: {
+        [HttpStatusCodes.CREATED]: {{ClassName}}ResponseSchema,
+        [HttpStatusCodes.UNPROCESSABLE_ENTITY]: ValidationErrorSchema
+      }
+    },
+    handler: store
+  });
+
+  app.route({
+    method: "PUT",
+    url: "/:id",
+    schema: {
+      tags: ["{{ModuleClass}}"],
+      description: "Update {{module}}",
+      params: {{ClassName}}IdParamsSchema,
+      body: Update{{ClassName}}Schema,
+      response: {
+        [HttpStatusCodes.OK]: {{ClassName}}ResponseSchema,
+        [HttpStatusCodes.NOT_FOUND]: {{ClassName}}MessageSchema,
+        [HttpStatusCodes.UNPROCESSABLE_ENTITY]: ValidationErrorSchema
+      }
+    },
+    handler: update
+  });
+
+  app.route({
+    method: "DELETE",
+    url: "/:id",
+    schema: {
+      tags: ["{{ModuleClass}}"],
+      description: "Delete {{module}}",
+      params: {{ClassName}}IdParamsSchema,
+      response: {
+        [HttpStatusCodes.OK]: {{ClassName}}MessageSchema,
+        [HttpStatusCodes.NOT_FOUND]: {{ClassName}}MessageSchema
+      }
+    },
+    handler: destroy
+  });
+
+  // Gate the whole plugin (authMiddleware resolves the session once for every route):
+  //   app.addHook("preHandler", authMiddleware);
+  //
+  // Or gate a single route by role. requireRole reads the role authMiddleware set,
+  // so authMiddleware must run first:
+  //   app.route({ ..., preHandler: [authMiddleware, requireRole("admin")], handler: destroy });
+  //
+  // Delete the imports above when you do not need them.
+};
+
+export default routes;

package/fastify/src/framework/maker-cli/stubs/route/plain.ts.stub

@@ -0,0 +1,23 @@
+import type { FastifyPluginAsyncZod } from "fastify-type-provider-zod";
+import { authMiddleware } from "@/middlewares/auth-middleware.js";
+import { requireRole } from "@/middlewares/role-middleware.js";
+import { index, show, store, update, destroy } from "@/modules/{{module}}/controllers/{{controller}}.js";
+
+const routes: FastifyPluginAsyncZod = async (app) => {
+  app.get("/", index);
+  app.get("/:id", show);
+  app.post("/", store);
+  app.put("/:id", update);
+  app.delete("/:id", destroy);
+
+  // Gate the whole plugin (authMiddleware resolves the session once for every route):
+  //   app.addHook("preHandler", authMiddleware);
+  //
+  // Or gate a single route by role. requireRole reads the role authMiddleware set,
+  // so authMiddleware must run first:
+  //   app.route({ method: "DELETE", url: "/:id", preHandler: [authMiddleware, requireRole("admin")], handler: destroy });
+  //
+  // Delete the imports above when you do not need them.
+};
+
+export default routes;

package/fastify/src/framework/maker-cli/stubs/route/standalone.api.ts.stub

@@ -0,0 +1,120 @@
+import type { FastifyPluginAsyncZod } from "fastify-type-provider-zod";
+import { HttpStatusCodes, z } from "@/framework/facade.js";
+import { authMiddleware } from "@/middlewares/auth-middleware.js";
+import { requireRole } from "@/middlewares/role-middleware.js";
+
+/**
+ * {{module}} routes for {{controller}}.
+ *
+ * Wire each route to a handler:
+ *   import { index, show, store, update, destroy } from "@/modules/{{module}}/controllers/{{controller}}.js";
+ *   app.get("/", index);
+ *
+ * Wire each route to its validation schema:
+ *   import {
+ *     Create{{ClassName}}Schema,
+ *     {{ClassName}}IdParamsSchema,
+ *     {{ClassName}}ListResponseSchema,
+ *     {{ClassName}}MessageSchema,
+ *     {{ClassName}}ResponseSchema,
+ *     Update{{ClassName}}Schema
+ *   } from "@/modules/{{module}}/schemas/{{controller}}.js";
+ */
+
+const listResponse = z.object({
+  message: z.string(),
+  data: z.array(z.object({ id: z.number(), name: z.string() }))
+});
+
+const itemResponse = z.object({
+  message: z.string(),
+  data: z.object({ id: z.number(), name: z.string() })
+});
+
+const messageResponse = z.object({ message: z.string() });
+
+const routes: FastifyPluginAsyncZod = async (app) => {
+  app.route({
+    method: "GET",
+    url: "/",
+    schema: {
+      tags: ["{{ModuleClass}}"],
+      description: "List {{module}}",
+      response: {
+        [HttpStatusCodes.OK]: listResponse
+      }
+    },
+    handler: async (_request, reply) =>
+      reply.code(HttpStatusCodes.OK).send({ message: "{{module}} list not implemented", data: [] })
+  });
+
+  app.route({
+    method: "GET",
+    url: "/:id",
+    schema: {
+      tags: ["{{ModuleClass}}"],
+      description: "Get one {{module}}",
+      response: {
+        [HttpStatusCodes.OK]: itemResponse,
+        [HttpStatusCodes.NOT_FOUND]: messageResponse
+      }
+    },
+    handler: async (_request, reply) =>
+      reply.code(HttpStatusCodes.OK).send({ message: "{{module}} item not implemented", data: { id: 0, name: "" } })
+  });
+
+  app.route({
+    method: "POST",
+    url: "/",
+    schema: {
+      tags: ["{{ModuleClass}}"],
+      description: "Create {{module}}",
+      response: {
+        [HttpStatusCodes.CREATED]: messageResponse
+      }
+    },
+    handler: async (_request, reply) =>
+      reply.code(HttpStatusCodes.CREATED).send({ message: "{{module}} create not implemented" })
+  });
+
+  app.route({
+    method: "PUT",
+    url: "/:id",
+    schema: {
+      tags: ["{{ModuleClass}}"],
+      description: "Update {{module}}",
+      response: {
+        [HttpStatusCodes.OK]: messageResponse,
+        [HttpStatusCodes.NOT_FOUND]: messageResponse
+      }
+    },
+    handler: async (_request, reply) =>
+      reply.code(HttpStatusCodes.OK).send({ message: "{{module}} update not implemented" })
+  });
+
+  app.route({
+    method: "DELETE",
+    url: "/:id",
+    schema: {
+      tags: ["{{ModuleClass}}"],
+      description: "Delete {{module}}",
+      response: {
+        [HttpStatusCodes.OK]: messageResponse,
+        [HttpStatusCodes.NOT_FOUND]: messageResponse
+      }
+    },
+    handler: async (_request, reply) =>
+      reply.code(HttpStatusCodes.OK).send({ message: "{{module}} delete not implemented" })
+  });
+
+  // Gate the whole plugin (authMiddleware resolves the session once for every route):
+  //   app.addHook("preHandler", authMiddleware);
+  //
+  // Or gate a single route by role. requireRole reads the role authMiddleware set,
+  // so authMiddleware must run first:
+  //   app.route({ ..., preHandler: [authMiddleware, requireRole("admin")], handler: destroy });
+  //
+  // Delete the imports above when you do not need them.
+};
+
+export default routes;

package/fastify/src/framework/maker-cli/stubs/route/standalone.plain.ts.stub

@@ -0,0 +1,50 @@
+import type { FastifyPluginAsyncZod } from "fastify-type-provider-zod";
+import { HttpStatusCodes } from "@/framework/facade.js";
+import { authMiddleware } from "@/middlewares/auth-middleware.js";
+import { requireRole } from "@/middlewares/role-middleware.js";
+
+/**
+ * {{module}} routes for {{controller}}.
+ *
+ * Wire each handler to a controller:
+ *   import { index, show, store, update, destroy } from "@/modules/{{module}}/controllers/{{controller}}.js";
+ *   app.get("/", index);
+ *
+ * Add validation with the validate() helper:
+ *   import { validate } from "@/framework/facade.js";
+ *   import { {{ClassName}}IdParamsSchema } from "@/modules/{{module}}/schemas/{{controller}}.js";
+ *   const params = await validate({{ClassName}}IdParamsSchema, request.params);
+ */
+
+const routes: FastifyPluginAsyncZod = async (app) => {
+  app.get("/", async (_request, reply) =>
+    reply.code(HttpStatusCodes.OK).send({ message: "{{module}} list not implemented", data: [] })
+  );
+
+  app.get("/:id", async (_request, reply) =>
+    reply.code(HttpStatusCodes.OK).send({ message: "{{module}} item not implemented", data: { id: 0, name: "" } })
+  );
+
+  app.post("/", async (_request, reply) =>
+    reply.code(HttpStatusCodes.CREATED).send({ message: "{{module}} create not implemented" })
+  );
+
+  app.put("/:id", async (_request, reply) =>
+    reply.code(HttpStatusCodes.OK).send({ message: "{{module}} update not implemented" })
+  );
+
+  app.delete("/:id", async (_request, reply) =>
+    reply.code(HttpStatusCodes.OK).send({ message: "{{module}} delete not implemented" })
+  );
+
+  // Gate the whole plugin (authMiddleware resolves the session once for every route):
+  //   app.addHook("preHandler", authMiddleware);
+  //
+  // Or gate a single route by role. requireRole reads the role authMiddleware set,
+  // so authMiddleware must run first:
+  //   app.route({ method: "DELETE", url: "/:id", preHandler: [authMiddleware, requireRole("admin")], handler: destroy });
+  //
+  // Delete the imports above when you do not need them.
+};
+
+export default routes;

package/fastify/src/framework/maker-cli/stubs/schedule/name.ts.stub

@@ -0,0 +1,36 @@
+import { DateTime } from "luxon";
+import { defineSchedule, dispatchEvent } from "@/framework/facade.js";
+
+/**
+ * name: Unique schedule id used as the distributed lock key.
+ * expression: Cron expression that controls when the task runs.
+ * timezone: IANA timezone for cron evaluation (example: "UTC").
+ * runOnInit: Runs once immediately when scheduler starts.
+ * enabled: Enables or disables this schedule without deleting code.
+ * ttlMs: Lock TTL in milliseconds to avoid duplicate execution.
+ */
+defineSchedule({
+  name: "{{module}}:{{name}}",
+  expression: "0 * * * * *",
+  // timezone: "UTC",
+  // runOnInit: false,
+  // enabled: true,
+  // ttlMs: 120000,
+  handler: async () => {
+    /**
+     * dispatchEvent name: Event id to publish to listeners.
+     * payload: Data sent to queue/broadcast consumers.
+     * queue: Optional queue target for async event consumers.
+     * broadcast: Optional realtime fanout (all/users/roles/rooms).
+     */
+    // await dispatchEvent("{{module}}.{{name}}", {
+    //   origin: "scheduler",
+    //   createdAt: DateTime.now()
+    // }, {
+    //   queue: "default"
+    // });
+
+    DateTime.now().toISO();
+  }
+});
+

package/fastify/src/framework/maker-cli/stubs/schema/name.plain.ts.stub

@@ -0,0 +1,14 @@
+import { z } from "@/framework/facade.js";
+
+export const Create{{ClassName}}Schema = z.object({
+  name: z.string().min(1)
+});
+
+export const Update{{ClassName}}Schema = z.object({
+  name: z.string().min(1)
+});
+
+export const {{ClassName}}IdParamsSchema = z.object({
+  id: z.coerce.number().int().positive()
+});
+

package/fastify/src/framework/maker-cli/stubs/schema/name.ts.stub

@@ -0,0 +1,33 @@
+import { z } from "@/framework/facade.js";
+
+export const {{ClassName}}ItemSchema = z.object({
+  id: z.number(),
+  name: z.string()
+});
+
+export const Create{{ClassName}}Schema = z.object({
+  name: z.string().min(1)
+});
+
+export const Update{{ClassName}}Schema = z.object({
+  name: z.string().min(1)
+});
+
+export const {{ClassName}}IdParamsSchema = z.object({
+  id: z.coerce.number().int().positive()
+});
+
+export const {{ClassName}}ListResponseSchema = z.object({
+  message: z.string(),
+  data: z.array({{ClassName}}ItemSchema)
+});
+
+export const {{ClassName}}ResponseSchema = z.object({
+  message: z.string(),
+  data: {{ClassName}}ItemSchema
+});
+
+export const {{ClassName}}MessageSchema = z.object({
+  message: z.string()
+});
+

package/fastify/src/framework/maker-cli/stubs/seeder/name.ts.stub

@@ -0,0 +1,18 @@
+import { db } from "@/framework/facade.js";
+import { {{tableVariable}} } from "@/modules/{{module}}/database/models/{{name}}.js";
+
+export const table = {{tableVariable}};
+
+export default async function {{ClassName}}Seeder() {
+  const rows = [
+    // Add your seed data here
+    // Example:
+    // { name: "{{ClassName}} 1", description: "This is the first {{name}}" },
+    // { name: "{{ClassName}} 2", description: "This is the second {{name}}" }
+  ];
+
+  for (const row of rows) await db.insert({{tableVariable}}).values(row);
+
+  console.log(`{{ClassName}}: ${rows.length} row(s) prepared`);
+}
+

package/fastify/src/framework/maker-cli/stubs/seeder/standalone.ts.stub

@@ -0,0 +1,22 @@
+/**
+ * Standalone seeder for "{{name}}" — no model of that name exists in module
+ * "{{module}}", so nothing was imported for you. Uncomment the two lines below,
+ * point them at the table you want, then add your rows.
+ *
+ * Run with: bun maker module:seed {{module}}
+ */
+
+import { db } from "@/framework/facade.js";
+// import { {{tableVariable}} } from "@/modules/{{module}}/database/models/{{name}}.js";
+// export const table = {{tableVariable}};
+
+export default async function {{ClassName}}Seeder() {
+  const rows: Record<string, unknown>[] = [
+    // { name: "{{ClassName}} 1" },
+    // { name: "{{ClassName}} 2" }
+  ];
+
+  // for (const row of rows) await db.insert({{tableVariable}}).values(row);
+
+  console.log(`{{ClassName}}: ${rows.length} row(s) ready`);
+}