exp-node-server 1.1.7 → 2.0.0

package/README.md

@@ -4,7 +4,7 @@
 [![npm downloads](https://img.shields.io/npm/dw/exp-node-server.svg)](https://www.npmjs.com/package/exp-node-server)
 [![npm total downloads](https://img.shields.io/npm/dt/exp-node-server.svg)](https://www.npmjs.com/package/exp-node-server)
 [![Made with TypeScript](https://img.shields.io/badge/Made%20with-TypeScript-blue.svg)](https://www.typescriptlang.org/)
-[![Node.js](https://img.shields.io/badge/Node.js-18+-green.svg)](https://nodejs.org/)
+[![Node.js](https://img.shields.io/badge/Node.js-20.17+-green.svg)](https://nodejs.org/)
 
 ---
 
@@ -18,7 +18,6 @@ This tool helps developers quickly scaffold `clean`, `modular` `Express` APIs wi
 
 - ⚡ Generate complete `Express` + `TypeScript` modules
 - 🧩 Built-in `Mongoose` / `Prisma` support
-- 📘 Adds Swagger documentation automatically
 - 📘 Automatic `Swagger` documentation
 - 🔐 `Zod` validation ready
 - 🏗️ `Modular` clean architecture
@@ -30,19 +29,27 @@ This tool helps developers quickly scaffold `clean`, `modular` `Express` APIs wi
 
 Run directly using npx (recommended):
 
-```Bash
+```bash
 npx exp-node-server -c my-api
 ```
 
-This will:
+You'll be asked to pick a template (Mongoose or Prisma). To skip the prompt:
+
+```bash
+npx exp-node-server create my-api --template prisma
+```
 
-- Create an Express starter project
-- Install dependencies
-- Prepare the project for development
+Then:
+
+```bash
+cd my-api
+npm install
+npm run dev
+```
 
 ## 🧩 Generate a Module
 
-Inside your project run:
+Inside your project root run:
 
 ```bash
 npx exp-node-server -g <module-name>
@@ -52,33 +59,71 @@ Example: `npx exp-node-server -g order`
 
 Output:
 
-```Bash
-✔ order.interface.ts created
-✔ order.schema.ts created
-✔ order.validation.ts created
-✔ order.route.ts created
-✔ order.controller.ts created
-✔ order.service.ts created
-✔ order.swagger.ts created
+```bash
+✔ src/app/modules/order/order.controller.ts created
+✔ src/app/modules/order/order.route.ts created
+✔ src/app/modules/order/order.validation.ts created
+✔ src/app/modules/order/order.swagger.ts created
+✔ src/app/modules/order/order.interface.ts created
+✔ src/app/modules/order/order.schema.ts created
+✔ src/app/modules/order/order.service.ts created
+✔ tests/routes/order.test.ts created
+✔ Route registered in routes.ts
+✔ Swagger docs registered in swaggerOptions.ts
+```
 
-🔗 Route registered in routes.ts
-📘 Swagger docs registered
+The route and Swagger docs are wired up automatically. For Prisma projects a
+`prisma/schema/<module>.prisma` model is created as well.
 
+A ready-to-run [supertest](https://github.com/ladjs/supertest) suite is created in
+`tests/routes/<module>.test.ts`. It covers create, list, get, update and delete,
+including the 404s, and passes as generated:
+
+```bash
+npm test -- tests/routes/order.test.ts
 ```
 
+When you add fields, fill in `createPayload` / `updatePayload` at the top of the test.
+Mongoose tests run against an in-memory MongoDB; Prisma tests use the Prisma mock in
+`tests/helpers/prisma.ts`. Module names whose path is already taken (e.g. `auth`) are
+refused.
+
+## 🛠️ CLI Reference
+
+```text
+npx exp-node-server create <project-name> [--template <mongoose|prisma>]
+npx exp-node-server generate <module-name> [--force]
+
+Commands
+  create, -c <name>      Create a new project from a template
+  generate, -g <name>    Generate a module in the current project
+
+Options
+  -t, --template <name>  Template to use with create (mongoose | prisma)
+  -f, --force            Overwrite an existing module when generating
+  -h, --help             Show help
+  -v, --version          Show version
+```
+
+- Project names are lowercased and spaces become dashes (`My API` → `my-api`).
+- Module names are lowercased and spaces/dashes become underscores (`order-item` → `order_item`).
+
 ## 📁 Generated Module Structure
 
 Each module follows a clean structure:
 
 ```Bash
 src/app/modules/<module-name>/
- ├── <module>.interface.ts
- ├── <module>.schema.ts
+ ├── <module>.interface.ts    # mongoose
+ ├── <module>.schema.ts       # mongoose (prisma: prisma/schema/<module>.prisma)
  ├── <module>.validation.ts
  ├── <module>.route.ts
  ├── <module>.controller.ts
  ├── <module>.service.ts
  └── <module>.swagger.ts
+
+tests/routes/
+ └── <module>.test.ts
 ```
 
 ## ⚙️ Run the Project
@@ -103,6 +148,22 @@ http://localhost:5000/docs
 - JWT — Authentication
 - Swagger — API documentation
 
+## 🧑‍🔧 Development
+
+```bash
+npm install
+npm run dev        # rebuild on change (tsup --watch)
+npm run typecheck  # tsc
+npm test           # vitest (unit + end-to-end against dist/)
+npm run build      # bundle to dist/cli.js
+```
+
+Try the local build with `node dist/cli.js --help`, or run `npm link` to use
+`exp-node-server` globally.
+
+> Templates live in `templates/`. npm strips `.gitignore` files when
+> publishing, so name them `_gitignore`. They're renamed when a project is created.
+
 ## 👨‍💻 Author
 
 ### Abumahid
@@ -124,3 +185,4 @@ https://linkedin.com/in/md-abu-mahid-islam
 If you find this project helpful, consider giving it a ⭐ on `GitHub`.
 
 It helps the project grow and reach more developers.
+

package/dist/cli.js

@@ -0,0 +1,525 @@
+#!/usr/bin/env node
+var c=class extends Error{exitCode;constructor(t,r=1){super(t),this.name="CliError",this.exitCode=r}};import T from"chalk";var a={info:e=>console.log(e),success:e=>console.log(`${T.green("\u2714")} ${e}`),warn:e=>console.warn(`${T.yellow("\u26A0")} ${e}`),error:e=>console.error(`${T.red("\u2716")} ${e}`)};import S from"chalk";import{parseArgs as xe}from"util";import de from"@inquirer/select";import g from"chalk";import m from"fs";import h from"path";import pe from"ora";import j from"path";import{fileURLToPath as ce}from"url";var B=j.dirname(ce(import.meta.url)),C=j.basename(B)==="lib"?j.resolve(B,"../../templates"):j.resolve(B,"../templates");var le={_gitignore:".gitignore"},ue=new Set(["node_modules","dist","coverage",".env"]);async function k(e,{template:t,cwd:r=process.cwd()}={}){let s=h.join(r,e);if(m.existsSync(s))throw new c(`Folder '${e}' already exists.`);let n=t??await me(),i=h.join(C,n);if(!m.existsSync(i))throw new c(`Template '${n}' not found at ${i}.`);let o=pe(`Creating ${n} project...`).start();try{await m.promises.cp(i,s,{recursive:!0,filter:d=>!ue.has(h.basename(d))});for(let[d,f]of Object.entries(le)){let p=h.join(s,d);m.existsSync(p)&&await m.promises.rename(p,h.join(s,f))}await fe(s,e)}catch(d){throw o.fail("Failed to create project"),await m.promises.rm(s,{recursive:!0,force:!0}),d}o.succeed(`Project '${e}' created`),a.info(g.green(`
+Next steps:`)),a.info(g.cyan(`  cd ${e}`)),a.info(g.cyan("  npm install")),a.info(g.cyan("  cp .env.example .env    # then fill in the secrets")),a.info(g.cyan("  docker compose up -d    # starts the database")),n==="prisma"&&a.info(g.cyan("  npm run db:migrate")),a.info(g.cyan("  npm run dev")),a.info(g.cyan("  npm test"))}async function me(){return de({message:"Select a project template:",choices:[{name:"Mongoose (MongoDB)",value:"mongoose"},{name:"Prisma (PostgreSQL)",value:"prisma"}]})}async function fe(e,t){let r=h.join(e,"package.json");if(!m.existsSync(r))return;let s=JSON.parse(await m.promises.readFile(r,"utf-8"));s.name=t,await m.promises.writeFile(r,`${JSON.stringify(s,null,2)}
+`)}import y from"chalk";import $ from"fs";import l from"path";var _=(e,t)=>{let r=`await ${e}_service.${t}(req);`,s=`  const result = ${r}`;return s.length<=100?s:`  const result =
+    ${r}`},D=e=>`import catchAsync from '../../utils/catch_async.js';
+import manageResponse from '../../utils/manage_response.js';
+import { ${e}_service } from './${e}.service.js';
+
+const get_all_${e} = catchAsync(async (req, res) => {
+${_(e,`get_all_${e}_from_db`)}
+  manageResponse(res, {
+    success: true,
+    statusCode: 200,
+    message: 'All ${e} fetched successfully.',
+    data: result,
+    meta: {},
+  });
+});
+
+const get_single_${e} = catchAsync(async (req, res) => {
+${_(e,`get_single_${e}_from_db`)}
+  manageResponse(res, {
+    success: true,
+    statusCode: 200,
+    message: 'Single ${e} fetched successfully.',
+    data: result,
+    meta: {},
+  });
+});
+
+const create_${e} = catchAsync(async (req, res) => {
+${_(e,`create_${e}_into_db`)}
+  manageResponse(res, {
+    success: true,
+    statusCode: 201,
+    message: '${e} created successfully.',
+    data: result,
+    meta: {},
+  });
+});
+
+const update_${e} = catchAsync(async (req, res) => {
+${_(e,`update_${e}_into_db`)}
+  manageResponse(res, {
+    success: true,
+    statusCode: 200,
+    message: '${e} updated successfully.',
+    data: result,
+    meta: {},
+  });
+});
+
+const delete_${e} = catchAsync(async (req, res) => {
+${_(e,`delete_${e}_from_db`)}
+  manageResponse(res, {
+    success: true,
+    statusCode: 200,
+    message: '${e} deleted successfully.',
+    data: result,
+    meta: {},
+  });
+});
+
+export const ${e}_controller = {
+  get_all_${e},
+  get_single_${e},
+  create_${e},
+  update_${e},
+  delete_${e},
+};
+`;var x=(e,t)=>{let r=`router.${e}(${t.join(", ")});`;return r.length<=100?r:`router.${e}(
+${t.map(s=>`  ${s},`).join(`
+`)}
+);`},G=e=>`import { Router } from 'express';
+import RequestValidator from '../../middlewares/request_validator.js';
+import { ${e}_controller } from './${e}.controller.js';
+import { ${e}_validations } from './${e}.validation.js';
+
+const router = Router();
+
+${x("get",["'/'",`${e}_controller.get_all_${e}`])}
+${x("post",["'/'",`RequestValidator(${e}_validations.create_${e})`,`${e}_controller.create_${e}`])}
+${x("get",["'/:id'",`${e}_controller.get_single_${e}`])}
+${x("patch",["'/:id'",`RequestValidator(${e}_validations.update_${e})`,`${e}_controller.update_${e}`])}
+${x("delete",["'/:id'",`${e}_controller.delete_${e}`])}
+
+export default router;
+`;var A=`{
+          name: 'id',
+          in: 'path',
+          required: true,
+          schema: { type: 'string' },
+        }`,F=e=>`export const ${e}SwaggerDocs = {
+  '/api/${e}': {
+    post: {
+      tags: ['${e}'],
+      summary: 'Create new ${e}',
+      description: '',
+      requestBody: {
+        required: true,
+        content: {
+          'application/json': {
+            example: JSON.stringify({}), // put your request body
+          },
+        },
+      },
+      responses: {
+        201: { description: '${e} created successfully' },
+        500: { description: 'Validation error or internal server error' },
+      },
+    },
+    get: {
+      tags: ['${e}'],
+      summary: 'Get all ${e}',
+      description: '',
+      parameters: [
+        {
+          name: 'page',
+          in: 'query',
+          required: false,
+          schema: { type: 'number' },
+        },
+        {
+          name: 'limit',
+          in: 'query',
+          required: false,
+          schema: { type: 'number' },
+        },
+      ],
+      responses: {
+        200: { description: '${e} fetched successfully' },
+        401: { description: 'unauthorized' },
+      },
+    },
+  },
+
+  '/api/${e}/{id}': {
+    get: {
+      tags: ['${e}'],
+      summary: 'Get single ${e}',
+      description: '',
+      parameters: [
+        ${A},
+      ],
+      responses: {
+        200: { description: '${e} fetched successfully' },
+        401: { description: 'unauthorized' },
+      },
+    },
+    patch: {
+      tags: ['${e}'],
+      summary: 'Update ${e}',
+      description: '',
+      parameters: [
+        ${A},
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          'application/json': {
+            example: JSON.stringify({}), // put your request body
+          },
+        },
+      },
+      responses: {
+        200: { description: '${e} updated successfully' },
+        500: { description: 'Validation error or internal server error' },
+      },
+    },
+    delete: {
+      tags: ['${e}'],
+      summary: 'Delete ${e}',
+      description: '',
+      parameters: [
+        ${A},
+      ],
+      responses: {
+        200: { description: '${e} deleted successfully' },
+        401: { description: 'unauthorized' },
+      },
+    },
+  },
+};
+`;var O=e=>`import { z } from 'zod';
+
+const create_${e} = z.object({});
+const update_${e} = z.object({});
+
+export const ${e}_validations = {
+  create_${e},
+  update_${e},
+};
+`;var N=e=>`// add the fields of a ${e} here
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export type T_${e} = {};
+`;var M=e=>`import { Schema, model } from 'mongoose';
+import type { T_${e} } from './${e}.interface.js';
+
+const schema = new Schema<T_${e}>({}, { timestamps: true, versionKey: false });
+
+export const ${e}_model = model('${e}', schema);
+`;var L=e=>`import type { Request } from 'express';
+import { AppError } from '../../utils/app_error.js';
+import { ${e}_model } from './${e}.schema.js';
+
+const notFound = () => new AppError('${e} not found', 404);
+
+const get_all_${e}_from_db = async (_req: Request) => {
+  // define your own logic here
+  const result = await ${e}_model.find().lean();
+  return result;
+};
+
+const get_single_${e}_from_db = async (req: Request) => {
+  // define your own logic here
+  const { id } = req.params;
+  const result = await ${e}_model.findById(id).lean();
+  if (!result) throw notFound();
+  return result;
+};
+
+const create_${e}_into_db = async (req: Request) => {
+  // define your own logic here
+  const result = await ${e}_model.create(req.body);
+  return result;
+};
+
+const update_${e}_into_db = async (req: Request) => {
+  // define your own logic here
+  const { id } = req.params;
+  const result = await ${e}_model
+    .findByIdAndUpdate(id, req.body, { returnDocument: 'after' })
+    .lean();
+  if (!result) throw notFound();
+  return result;
+};
+
+const delete_${e}_from_db = async (req: Request) => {
+  // define your own logic here
+  const { id } = req.params;
+  const result = await ${e}_model.findByIdAndDelete(id).lean();
+  if (!result) throw notFound();
+  return result;
+};
+
+export const ${e}_service = {
+  get_all_${e}_from_db,
+  get_single_${e}_from_db,
+  create_${e}_into_db,
+  update_${e}_into_db,
+  delete_${e}_from_db,
+};
+`;var U=e=>`import { Types } from 'mongoose';
+import request from 'supertest';
+import { describe, expect, it } from 'vitest';
+import app from '../../src/app.js';
+import { ${e}_model } from '../../src/app/modules/${e}/${e}.schema.js';
+
+const BASE = '/api/${e}';
+
+// Valid request bodies. Fill them in as you add fields to ${e}.schema.ts and
+// ${e}.validation.ts (and protect the routes with auth() once they need it).
+const createPayload = {};
+const updatePayload = {};
+
+/** Inserts a ${e} directly in the database, for the read / update / delete tests. */
+const insert = () => ${e}_model.create(createPayload);
+
+describe(BASE, () => {
+  it('POST / creates one', async () => {
+    const res = await request(app).post(BASE).send(createPayload);
+
+    expect(res.status).toBe(201);
+    expect(await ${e}_model.countDocuments()).toBe(1);
+  });
+
+  it('GET / lists them', async () => {
+    await insert();
+
+    const res = await request(app).get(BASE);
+
+    expect(res.status).toBe(200);
+    expect(res.body.data).toHaveLength(1);
+  });
+
+  it('GET /:id returns one', async () => {
+    const doc = await insert();
+
+    const res = await request(app).get(\`\${BASE}/\${doc._id}\`);
+
+    expect(res.status).toBe(200);
+    expect(res.body.data._id).toBe(String(doc._id));
+  });
+
+  it('GET /:id is 404 when it does not exist', async () => {
+    const res = await request(app).get(\`\${BASE}/\${new Types.ObjectId()}\`);
+
+    expect(res.status).toBe(404);
+  });
+
+  it('GET /:id is 400 for a malformed id', async () => {
+    const res = await request(app).get(\`\${BASE}/not-an-id\`);
+
+    expect(res.status).toBe(400);
+  });
+
+  it('PATCH /:id updates it', async () => {
+    const doc = await insert();
+
+    const res = await request(app).patch(\`\${BASE}/\${doc._id}\`).send(updatePayload);
+
+    expect(res.status).toBe(200);
+    const stored = await ${e}_model.findById(doc._id).lean();
+    expect(stored).toMatchObject(updatePayload);
+  });
+
+  it('PATCH /:id is 404 when it does not exist', async () => {
+    const res = await request(app).patch(\`\${BASE}/\${new Types.ObjectId()}\`).send(updatePayload);
+
+    expect(res.status).toBe(404);
+  });
+
+  it('DELETE /:id deletes it', async () => {
+    const doc = await insert();
+
+    const res = await request(app).delete(\`\${BASE}/\${doc._id}\`);
+
+    expect(res.status).toBe(200);
+    const stillThere = await ${e}_model.exists({ _id: doc._id });
+    expect(stillThere).toBeNull();
+  });
+
+  it('DELETE /:id is 404 when it does not exist', async () => {
+    const res = await request(app).delete(\`\${BASE}/\${new Types.ObjectId()}\`);
+
+    expect(res.status).toBe(404);
+  });
+});
+`;var V=e=>e.charAt(0).toUpperCase()+e.slice(1);var H=e=>`model ${V(e)} {
+    id        String   @id @default(uuid())
+    createdAt DateTime @default(now())
+    updatedAt DateTime @updatedAt
+}
+`;var z=e=>`import type { Request } from 'express';
+import { prisma } from '../../lib/prisma.js';
+import { AppError } from '../../utils/app_error.js';
+
+const get_all_${e}_from_db = async (_req: Request) => {
+  // define your own logic here
+  const result = await prisma.${e}.findMany();
+  return result;
+};
+
+const get_single_${e}_from_db = async (req: Request) => {
+  // define your own logic here
+  const { id } = req.params as { id: string };
+  const result = await prisma.${e}.findUnique({ where: { id } });
+  if (!result) throw new AppError('${e} not found', 404);
+  return result;
+};
+
+const create_${e}_into_db = async (req: Request) => {
+  // define your own logic here
+  const result = await prisma.${e}.create({ data: req.body });
+  return result;
+};
+
+// update / delete of a missing record throw Prisma's P2025, which the global
+// error handler turns into a 404
+const update_${e}_into_db = async (req: Request) => {
+  // define your own logic here
+  const { id } = req.params as { id: string };
+  const result = await prisma.${e}.update({ where: { id }, data: req.body });
+  return result;
+};
+
+const delete_${e}_from_db = async (req: Request) => {
+  // define your own logic here
+  const { id } = req.params as { id: string };
+  const result = await prisma.${e}.delete({ where: { id } });
+  return result;
+};
+
+export const ${e}_service = {
+  get_all_${e}_from_db,
+  get_single_${e}_from_db,
+  create_${e}_into_db,
+  update_${e}_into_db,
+  delete_${e}_from_db,
+};
+`;var J=e=>`import { Prisma } from '@prisma/client';
+import request from 'supertest';
+import { describe, expect, it } from 'vitest';
+import app from '../../src/app.js';
+import { prismaMock } from '../helpers/prisma.js';
+
+const BASE = '/api/${e}';
+const db = prismaMock.${e};
+
+// Valid request bodies. Fill them in as you add fields to prisma/schema/${e}.prisma
+// and ${e}.validation.ts (and protect the routes with auth() once they need it).
+const createPayload = {};
+const updatePayload = {};
+
+// a row as the database would return it
+const row = {
+  id: '9b2f3c1e-7a41-4c8e-9d6b-2f4e8a1c5b70',
+  ...createPayload,
+  createdAt: new Date('2025-01-01'),
+  updatedAt: new Date('2025-01-01'),
+};
+// ...and as it looks in a JSON response
+const json = JSON.parse(JSON.stringify(row));
+
+const recordNotFound = () =>
+  new Prisma.PrismaClientKnownRequestError('Record not found', {
+    code: 'P2025',
+    clientVersion: 'test',
+  });
+
+describe(BASE, () => {
+  it('POST / creates one', async () => {
+    db.create.mockResolvedValue(row);
+
+    const res = await request(app).post(BASE).send(createPayload);
+
+    expect(res.status).toBe(201);
+    expect(res.body.data).toEqual(json);
+    expect(db.create).toHaveBeenCalledWith({ data: createPayload });
+  });
+
+  it('GET / lists them', async () => {
+    db.findMany.mockResolvedValue([row]);
+
+    const res = await request(app).get(BASE);
+
+    expect(res.status).toBe(200);
+    expect(res.body.data).toEqual([json]);
+  });
+
+  it('GET /:id returns one', async () => {
+    db.findUnique.mockResolvedValue(row);
+
+    const res = await request(app).get(\`\${BASE}/\${row.id}\`);
+
+    expect(res.status).toBe(200);
+    expect(res.body.data).toEqual(json);
+    expect(db.findUnique).toHaveBeenCalledWith({ where: { id: row.id } });
+  });
+
+  it('GET /:id is 404 when it does not exist', async () => {
+    db.findUnique.mockResolvedValue(null);
+
+    const res = await request(app).get(\`\${BASE}/\${row.id}\`);
+
+    expect(res.status).toBe(404);
+  });
+
+  it('PATCH /:id updates it', async () => {
+    db.update.mockResolvedValue(row);
+
+    const res = await request(app).patch(\`\${BASE}/\${row.id}\`).send(updatePayload);
+
+    expect(res.status).toBe(200);
+    expect(db.update).toHaveBeenCalledWith({ where: { id: row.id }, data: updatePayload });
+  });
+
+  it('PATCH /:id is 404 when it does not exist', async () => {
+    db.update.mockRejectedValue(recordNotFound());
+
+    const res = await request(app).patch(\`\${BASE}/\${row.id}\`).send(updatePayload);
+
+    expect(res.status).toBe(404);
+  });
+
+  it('DELETE /:id deletes it', async () => {
+    db.delete.mockResolvedValue(row);
+
+    const res = await request(app).delete(\`\${BASE}/\${row.id}\`);
+
+    expect(res.status).toBe(200);
+    expect(db.delete).toHaveBeenCalledWith({ where: { id: row.id } });
+  });
+
+  it('DELETE /:id is 404 when it does not exist', async () => {
+    db.delete.mockRejectedValue(recordNotFound());
+
+    const res = await request(app).delete(\`\${BASE}/\${row.id}\`);
+
+    expect(res.status).toBe(404);
+  });
+});
+`;var ge=/^import\s[\s\S]*?from\s*(['"])[^'"]+\1;?[ \t]*$|^import\s*(['"])[^'"]+\2;?[ \t]*$/gm;function E(e){return{quote:e.match(/^import[\s\S]*?(['"])/m)?.[1]==="'"?"'":'"',jsExtension:/from\s*['"]\.{1,2}\/[^'"]+\.js['"]/.test(e)}}function q(e,t){let r=-1;for(let s of e.matchAll(ge))r=s.index+s[0].length;return r===-1?`${t}
+${e}`:`${e.slice(0,r)}
+${t}${e.slice(r)}`}function v(e,t,r,s){let n=e.match(t);if(n?.index===void 0)return null;let i=n.index+n[0].length,o=e.indexOf(r,i);if(o===-1)return null;let d=e.slice(i,o),f=d.match(/\n([ \t]*)$/)?.[1]??"",p=d.match(/\n([ \t]+)\S/)?.[1]??`${f}  `,w=d.trimEnd(),ie=w.length>0&&!/[,[{]$/.test(w),ae=`${w}${ie?",":""}
+${p}${s}
+${f}`;return e.slice(0,i)+ae+e.slice(o)}function R(e,t){let r=e.includes(`\r
+`),s=t(r?e.replace(/\r\n/g,`
+`):e);return!r||s.status!=="updated"?s:{status:"updated",content:s.content.replace(/\n/g,`\r
+`)}}function W(e,t){return R(e,r=>$e(r,t))}function $e(e,t){let{quote:r,jsExtension:s}=E(e),n=`./app/modules/${t}/${t}.route`,i=`${t}Route`,o=e;if(o.includes(n)||(o=q(o,`import ${i} from ${r}${n}${s?".js":""}${r};`)),!new RegExp(`route:\\s*${i}\\b`).test(o)){let d=v(o,/const moduleRoutes\s*=\s*\[/,"]",`{ path: ${r}/${t}${r}, route: ${i} },`);if(d===null)return{status:"failed",reason:"could not find `const moduleRoutes = [...]`"};o=d}return o===e?{status:"unchanged"}:{status:"updated",content:o}}function K(e,t){return R(e,r=>he(r,t))}function he(e,t){let{quote:r,jsExtension:s}=E(e),n=`./app/modules/${t}/${t}.swagger`,i=`${t}SwaggerDocs`,o=e;if(o.includes(n)||(o=q(o,`import { ${i} } from ${r}${n}${s?".js":""}${r};`)),!o.includes(`...${i}`)){let d=v(o,/paths:\s*\{/,"}",`...${i},`);if(d===null)return{status:"failed",reason:"could not find `paths: { ... }`"};o=d}return o===e?{status:"unchanged"}:{status:"updated",content:o}}import Q from"fs";import X from"path";function Y(e,t){for(let r of e)Q.mkdirSync(X.dirname(r.path),{recursive:!0}),Q.writeFileSync(r.path,r.content),a.success(`${X.relative(t,r.path)} created`)}import Z from"fs";import ye from"path";var b=["mongoose","prisma"],P=".projectrc.json",I=e=>typeof e=="string"&&b.includes(e);function ee(e){let t=ye.join(e,P);if(!Z.existsSync(t))throw new c(`${P} not found. Run this command from the root of a project created with exp-node-server.`);let r;try{r=JSON.parse(Z.readFileSync(t,"utf-8"))}catch{throw new c(`${P} is not valid JSON.`)}let s=r?.database;if(!I(s))throw new c(`Invalid "database" in ${P}. Expected one of: ${b.join(", ")}.`);return s}async function re(e,{cwd:t=process.cwd(),force:r=!1}={}){let s=ee(t),n=l.join(t,"src/app/modules",e);if($.existsSync(n)&&!r)throw new c(`Module '${e}' already exists at ${l.relative(t,n)}. Use --force to overwrite it.`);_e(l.join(t,"src/routes.ts"),e);let i=(p,w)=>({path:l.join(n,`${e}.${p}`),content:w}),o=[i("controller.ts",D(e)),i("route.ts",G(e)),i("validation.ts",O(e)),i("swagger.ts",F(e))];s==="mongoose"?o.push(i("interface.ts",N(e)),i("schema.ts",M(e)),i("service.ts",L(e))):o.push(i("service.ts",z(e)),{path:l.join(t,"prisma/schema",`${e}.prisma`),content:H(e)});let d=l.join(t,"tests/routes",`${e}.test.ts`),f=we.some(p=>$.existsSync(l.join(t,p)));f&&o.push({path:d,content:s==="mongoose"?U(e):J(e)}),Y(o,t),f||a.info(y.dim("  no vitest config found, skipped tests/routes test")),te(l.join(t,"src/routes.ts"),p=>W(p,e),"Route registered"),te(l.join(t,"src/swaggerOptions.ts"),p=>K(p,e),"Swagger docs registered"),s==="prisma"&&(a.info(y.blue(`
+Next, run:`)),a.info(y.yellow("  npx prisma generate && npx prisma migrate dev"))),f&&a.info(y.blue(`
+Test it with: npm test -- tests/routes/${e}.test.ts`)),a.info(y.green(`
+Module '${e}' created successfully`))}var we=["vitest.config.ts","vitest.config.mts","vitest.config.js"];function _e(e,t){if(!$.existsSync(e))return;let r=$.readFileSync(e,"utf-8"),s=new RegExp(`path:\\s*['"]/${t}['"]\\s*,\\s*route:\\s*(\\w+)`).exec(r);if(s&&s[1]!==`${t}Route`)throw new c(`The path '/${t}' is already used by ${s[1]} in src/routes.ts. Pick another module name.`)}function te(e,t,r){let s=l.basename(e);if(!$.existsSync(e)){a.warn(`${s} not found, skipping registration`);return}let n=t($.readFileSync(e,"utf-8"));switch(n.status){case"updated":$.writeFileSync(e,n.content),a.success(`${r} in ${s}`);break;case"unchanged":a.info(y.dim(`  already registered in ${s}`));break;case"failed":a.warn(`Couldn't update ${s} (${n.reason}). Register it manually.`);break}}function se(e){if(!e)return null;let t=e.trim().toLowerCase().replace(/[-\s]+/g,"_");return/^[a-z][a-z_]*$/.test(t)?t:null}function oe(e){if(!e)return null;let t=e.trim().toLowerCase().replace(/\s+/g,"-");return/^[a-z0-9][a-z0-9-]*$/.test(t)?t:null}var u="exp-node-server",be=`
+${S.bold(u)} - scaffold Express + TypeScript APIs with Mongoose or Prisma
+
+${S.bold("Usage")}
+  npx ${u} create <project-name> [--template <mongoose|prisma>]
+  npx ${u} generate <module-name> [--force]
+
+${S.bold("Commands")}
+  create, -c <name>      Create a new project from a template
+  generate, -g <name>    Generate a module in the current project
+
+${S.bold("Options")}
+  -t, --template <name>  Template to use with create (${b.join(" | ")})
+  -f, --force            Overwrite an existing module when generating
+  -h, --help             Show this help
+  -v, --version          Show version
+
+${S.bold("Examples")}
+  npx ${u} -c my-api
+  npx ${u} create my-api --template prisma
+  npx ${u} -g order
+`;async function ne(e){let{values:t,positionals:r}=Se(e);if(t.version){console.log("2.0.0");return}let s=je(t,r);if(t.help||!s){console.log(be);return}if(s.kind==="create"){let i=oe(s.name);if(!i)throw new c(s.name?`Invalid project name '${s.name}'. Use letters, numbers and dashes.`:"Project name required. Example: exp-node-server -c my-api");let{template:o}=t;if(o!==void 0&&!I(o))throw new c(`Unknown template '${o}'. Use one of: ${b.join(", ")}.`);await k(i,{template:o});return}let n=se(s.name);if(!n)throw new c(s.name?`Invalid module name '${s.name}'. Use letters and underscores, starting with a letter.`:"Module name required. Example: exp-node-server -g order");await re(n,{force:t.force??!1})}function Se(e){try{return xe({args:e,allowPositionals:!0,strict:!0,options:{create:{type:"string",short:"c"},generate:{type:"string",short:"g"},template:{type:"string",short:"t"},force:{type:"boolean",short:"f"},help:{type:"boolean",short:"h"},version:{type:"boolean",short:"v"}}})}catch(t){let r=t instanceof Error?t.message:String(t);throw new c(`${r}
+Run '${u} --help' for usage.`)}}function je(e,t){if(e.create!==void 0&&e.generate!==void 0)throw new c("Use either -c (create) or -g (generate), not both.");if((e.create!==void 0||e.generate!==void 0)&&t.length>0)throw new c(`Unexpected argument '${t[0]}'. Run '${u} --help' for usage.`);if(e.create!==void 0)return{kind:"create",name:e.create};if(e.generate!==void 0)return{kind:"generate",name:e.generate};let[r,s,...n]=t;if(r===void 0)return null;if(n.length>0)throw new c(`Unexpected argument '${n[0]}'. Run '${u} --help' for usage.`);switch(r){case"create":case"c":return{kind:"create",name:s};case"generate":case"g":return{kind:"generate",name:s};default:throw new c(`Unknown command '${r}'. Run '${u} --help' for usage.`)}}try{await ne(process.argv.slice(2))}catch(e){e instanceof c?(a.error(e.message),process.exitCode=e.exitCode):e instanceof Error&&e.name==="ExitPromptError"?process.exitCode=130:(a.error("Unexpected error:"),console.error(e),process.exitCode=1)}