@automate-crud/mongoose 0.1.0

package/README.md

@@ -0,0 +1,56 @@
+# @automate-crud/mongoose
+
+Auto-generate CRUD APIs for Express using a Mongoose model.
+
+## Install
+
+```bash
+npm i @automate-crud/mongoose express mongoose
+```
+
+## Usage
+
+```js
+import express from "express";
+import mongoose from "mongoose";
+import { createCrudRouter, crudErrorHandler } from "@automate-crud/mongoose";
+
+await mongoose.connect(process.env.MONGO_URI);
+
+const User = mongoose.model(
+  "User",
+  new mongoose.Schema({ name: String, email: String }, { timestamps: true })
+);
+
+const app = express();
+app.use(express.json());
+
+app.use(
+  "/users",
+  createCrudRouter({
+    model: User,
+    searchFields: ["name", "email"],
+    allowedIncludes: []
+  })
+);
+
+app.use(crudErrorHandler);
+app.listen(4000);
+```
+
+## Generated Routes
+
+- `GET /users`
+- `GET /users/:id`
+- `POST /users`
+- `PATCH /users/:id`
+- `DELETE /users/:id`
+
+## List Query Params
+
+- `page`, `limit`
+- `sort`
+- `select`
+- `q` (search)
+- `include`
+- `filter` (JSON string)

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@automate-crud/mongoose",
+  "version": "0.1.0",
+  "description": "Auto CRUD for Express + Mongoose",
+  "main": "src/index.js",
+  "type": "module",
+  "license": "MIT",
+  "peerDependencies": {
+    "express": "^4.18.0 || ^5.0.0",
+    "mongoose": "^8.0.0"
+  },
+  "devDependencies": {
+    "supertest": "^7.1.0",
+    "mongodb-memory-server": "^10.1.0"
+  },
+  "scripts": {
+    "test": "node test/run-tests.js"
+  }
+}

package/src/createCrudRouter.js

@@ -0,0 +1,189 @@
+import express from 'express';
+
+function parseListQuery(query = {}) {
+    const page = Math.max(1, Number(query.page) || 1);
+    const limit = Math.min(100, Math.max(1, Math.max(1, Number(query.limit) || 20)));
+    const skip = (page - 1) * limit;
+
+    return {
+        page,
+        limit,
+        skip,
+        sort: query.sort || "-createdAt",
+        select: query.select || "",
+        q: query.q || "",
+        include: query.include || ""
+    };
+}
+
+function normalizeInclude(include) {
+    if (!include) return [];
+
+    return String(include).split(",").map((v) => v.trim()).filter(Boolean);
+}
+
+function pickAllowedIncludes(includes, allowedIncludes = []) {
+    if (!allowedIncludes.length) return includes;
+    const allowed = new Set(allowedIncludes);
+    return includes.filter((i) => allowed.has(i))
+}
+
+function parseFilter(query = {}) {
+    const reserved = new Set(["page", "limit", "sort", "select", "q", "include", "filter"]);
+
+    const fromQuery = {};
+
+    for (const [key, value] of Object.entries(query)) {
+        if (reserved.has(key)) continue;
+        fromQuery[key] = value;
+    }
+
+    if (!query.filter) return fromQuery;
+
+    try {
+        const parsed = JSON.parse(query.filter);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return { ...fromQuery, ...parsed };
+        }
+    } catch (error) {
+        // ignore invalid filter JSON
+    }
+
+    return fromQuery;
+}
+
+function applySearch(filter, q, searchFields = []) {
+    if (!q || !searchFields.length) return filter;
+
+    const regex = new RegExp(q, "i");
+
+    return {
+        ...filter,
+        $or: searchFields.map((field) => ({ [field]: regex }))
+    };
+}
+
+export function createCrudRouter({
+    model,
+    searchFields = [],
+    allowedIncludes = [],
+    idParam = "id"
+}) {
+    if (!model) throw new Error("createCrudRouter requires a Mongoose model");
+
+    const router = express.Router();
+    const idPath = `/:${idParam}`;
+
+    // LIST
+    router.get("/", async (req, res, next) => {
+        try {
+            const listQuery = parseListQuery(req.query);
+            const filter = applySearch(parseFilter(req.query), listQuery.q, searchFields);
+
+            let query = model.find(filter);
+
+            if (listQuery.select) query = query.select(listQuery.select);
+            if (listQuery.sort) query = query.sort(listQuery.sort);
+
+            const includes = pickAllowedIncludes(
+                normalizeInclude(listQuery.include),
+                allowedIncludes
+            );
+
+            for (const path of includes) {
+                query = query.populate(path);
+            }
+
+            const [items, total] = await Promise.all([
+                query.skip(listQuery.skip).limit(listQuery.limit).lean().exec(),
+                model.countDocuments(filter)
+            ]);
+
+            res.json({
+                data: items,
+                meta: {
+                    total,
+                    page: listQuery.page,
+                    limit: listQuery.limit,
+                    pages: Math.max(1, Math.ceil(total / listQuery.limit))
+                }
+            });
+        } catch (error) {
+            next(error);
+        }
+    });
+
+    // GET ONE
+    router.get(idPath, async (req, res, next) => {
+        try {
+            let query = model.findById(req.params[idParam]);
+
+            if (req.query.select) query = query.select(String(req.query.select));
+
+            const includes = pickAllowedIncludes(
+                normalizeInclude(req.query.include),
+                allowedIncludes
+            );
+
+            for (const path of includes) {
+                query = query.populate(path);
+            }
+
+            const doc = await query.lean().exec();
+
+            if (!doc) {
+                return res.status(404).json({ error: { message: "Not found" } });
+            }
+
+            res.json({ data: doc });
+
+        } catch (error) {
+            next(error);
+        }
+    });
+
+    // CREATE
+    router.post("/", async (req, res, next) => {
+        try {
+            const created = await model.create(req.body);
+            res.status(201).json({ data: created.toObject() });
+        } catch (error) {
+            next(error);
+        }
+    });
+
+    // UPDATE
+    router.patch(idPath, async (req, res, next) => {
+        try {
+            const updated = await model.findByIdAndUpdate(req.params[idParam], req.body, {
+                new: true,
+                runValidators: true
+            }).lean().exec()
+
+            if (!updated) {
+                return res.status(404).json({ error: { message: "Not found" } });
+            }
+
+            res.json({ data: updated });
+        } catch (error) {
+            next(error);
+        }
+    });
+
+    // DELETE  
+    router.delete(idPath, async (req, res, next) => {
+        try {
+            const deleted = await model.findByIdAndDelete(req.params[idParam]).lean().exec();
+
+            if (!deleted) {
+                return res.status(404).json({ error: { message: "Not found" } });
+            }
+
+            res.json({ data: deleted });
+        } catch (error) {
+            next(error);
+        }
+    });
+
+    return router;
+}

package/src/crudErrorHandler.js

@@ -0,0 +1,8 @@
+export function crudErrorHandler(err, req, res, next) {
+    const status = err.status || 500;
+    res.status(status).json({
+        error: {
+            message: err.message || "Internal server error"
+        }
+    });
+}

package/src/index.js

@@ -0,0 +1,2 @@
+export { createCrudRouter } from "./createCrudRouter.js";
+export { crudErrorHandler } from './crudErrorHandler.js'

package/test/run-tests.js

@@ -0,0 +1,56 @@
+import assert from "node:assert/strict";
+import { createCrudRouter } from "../src/index.js";
+
+function makeFindChain(result = []) {
+  const chain = {
+    select: () => chain,
+    sort: () => chain,
+    populate: () => chain,
+    skip: () => chain,
+    limit: () => chain,
+    lean: () => chain,
+    exec: async () => result
+  };
+  return chain;
+}
+
+function makeFindOneChain(result = null) {
+  const chain = {
+    select: () => chain,
+    populate: () => chain,
+    lean: () => chain,
+    exec: async () => result
+  };
+  return chain;
+}
+
+function makeUpdateDeleteChain(result = null) {
+  const chain = {
+    lean: () => chain,
+    exec: async () => result
+  };
+  return chain;
+}
+
+function testThrowsWithoutModel() {
+  assert.throws(() => createCrudRouter({}), /requires a Mongoose model/);
+}
+
+function testReturnsRouter() {
+  const fakeModel = {
+    find: () => makeFindChain([]),
+    findById: () => makeFindOneChain(null),
+    create: async (body) => ({ toObject: () => body }),
+    findByIdAndUpdate: () => makeUpdateDeleteChain(null),
+    findByIdAndDelete: () => makeUpdateDeleteChain(null),
+    countDocuments: async () => 0
+  };
+
+  const router = createCrudRouter({ model: fakeModel });
+  assert.equal(typeof router, "function");
+  assert.equal(typeof router.handle, "function");
+}
+
+testThrowsWithoutModel();
+testReturnsRouter();
+console.log("mongoose tests: ok");

package/test/smoke.js

@@ -0,0 +1,33 @@
+import express from 'express';
+import mongoose from 'mongoose';
+import { createCrudRouter } from '../src/index.js';
+
+const app = express();
+app.use(express.json());
+
+await mongoose.connect(process.env.MONGO_URI);
+
+const User = mongoose.model("User", new mongoose.Schema(
+    {
+        name: { type: String, required: true, index: true },
+        email: { type: String, required: true, unique: true, index: true }
+    },
+    { timestamps: true }
+));
+
+app.use(
+    "/users",
+    createCrudRouter({
+        model: User,
+        searchFields: ["name", "email"],
+        allowedIncludes: []
+    })
+)
+
+app.use((err, req, res, next) => {
+    res.status(500).json({ error: { message: err.message || "Internal error" } });
+});
+
+app.listen(4000, () => {
+    console.log("Running at http://localhost:4000");
+});