quar 2.0.0 → 2.1.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # quar
 
+## 2.1.0
+
+### Minor Changes
+
+- de7986b: add sub schema support
+- 15bd5a4: add typescript support
+
+## 2.0.1
+
+### Patch Changes
+
+- 6036aa0: move mongoose to peer dependencies
+
 ## 2.0.0
 
 ### Major Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quar",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "This will load all Mongoose models from the folder and start a local web UI to Create, view, update, and delete documents.",
   "main": "index.js",
   "type": "module",
@@ -22,7 +22,6 @@
     "chalk": "^5.4.1",
     "express": "^5.1.0",
     "minimist": "^1.2.8",
-    "mongoose": "^9.1.1",
     "open": "^10.1.2",
     "zare": "2.6.0"
   },
@@ -36,5 +35,8 @@
   "homepage": "https://github.com/IsmailBinMujeeb/quar-studio#readme",
   "devDependencies": {
     "@changesets/cli": "^2.29.8"
+  },
+  "peerDependencies": {
+    "mongoose": "^9.1.1"
   }
 }

package/server.js

@@ -1,12 +1,12 @@
-import express from 'express';
-import mongoose from 'mongoose';
-import path from "path"
-import loadModels from './utils/loadModels.js';
+import express from "express";
+import mongoose from "mongoose";
+import path from "path";
+import loadModels from "./utils/loadModels.js";
 
 const app = express();
 const PORT = 8319;
 
-app.set('view engine', 'zare');
+app.set("view engine", "zare");
 app.set("views", path.join(import.meta.dirname, "views"));
 app.set("port", PORT);
 
@@ -14,229 +14,221 @@ app.use(express.static(path.join(import.meta.dirname, "public")));
 app.use(express.json());
 app.use(express.urlencoded({ extended: true }));
 
-app.get('/', async (_, res) => {
-    try {
-        const modelNames = mongoose.modelNames();
+app.get("/", async (_, res) => {
+  try {
+    const modelNames = mongoose.modelNames();
 
-        modelNames.sort((a, b) => a.localeCompare(b));
+    modelNames.sort((a, b) => a.localeCompare(b));
 
-        const result = await Promise.all(
-            modelNames.map(async name => {
-                const model = mongoose.model(name);
-                const count = await model.countDocuments();
-                return { name, count };
-            })
-        );
-
-        res.render('pages/index', { models: result });
-    } catch (error) {
-        res.status(500).json({ error: error.message || "Internal server error" });
-    }
+    const result = await Promise.all(
+      modelNames.map(async (name) => {
+        const model = mongoose.model(name);
+        const count = await model.countDocuments();
+        return { name, count };
+      })
+    );
+
+    res.render("pages/index", { models: result });
+  } catch (error) {
+    res.status(500).json({ error: error.message || "Internal server error" });
+  }
 });
 
 app.get("/models", async (_, res) => {
-
-    try {
-
-        if (!app.locals.modelPath) return res.status(409).json({ error: "model directory path not set" })
-        loadModels(app.locals.modelPath)
-        const modelNames = mongoose.modelNames();
-        modelNames.sort((a, b) => a.localeCompare(b));
-
-        const result = await Promise.all(
-            modelNames.map(async name => {
-                const model = mongoose.model(name);
-                const count = await model.countDocuments();
-                return { name, count };
-            })
-        );
-
-        res.status(200).json({ models: result });
-    } catch (error) {
-        res.status(500).json({ error: error.message || "Internal server error" });
-    }
+  try {
+    if (!app.locals.modelPath)
+      return res.status(409).json({ error: "model directory path not set" });
+    loadModels(app.locals.modelPath);
+    const modelNames = mongoose.modelNames();
+    modelNames.sort((a, b) => a.localeCompare(b));
+
+    const result = await Promise.all(
+      modelNames.map(async (name) => {
+        const model = mongoose.model(name);
+        const count = await model.countDocuments();
+        return { name, count };
+      })
+    );
+
+    res.status(200).json({ models: result });
+  } catch (error) {
+    res.status(500).json({ error: error.message || "Internal server error" });
+  }
 });
 
 app.get("/models/:modelName", async (req, res) => {
-    try {
-
-        const { modelName } = req.params;
-        const { page = 1, limit = 100 } = req.query;
-        const model = mongoose.model(modelName);
-        const modelSchema = model.schema.paths;
-        const documents = await model.find({}).limit(limit).skip((page - 1) * limit);
-        const totalCount = await model.countDocuments();
-        const count = documents.length;
-        const totalPages = Math.ceil(totalCount / limit);
-
-        res.status(200).json({ documents, schema: modelSchema, totalCount, count, totalPages });
-    } catch (error) {
-        console.log(error)
-        res.status(500).json({ error: error.message || "Internal server error" });
-    }
+  try {
+    const { modelName } = req.params;
+    const { page = 1, limit = 100 } = req.query;
+    const model = mongoose.model(modelName);
+    const documents = await model
+      .find({})
+      .limit(limit)
+      .skip((page - 1) * limit);
+    const totalCount = await model.countDocuments();
+    const count = documents.length;
+    const totalPages = Math.ceil(totalCount / limit);
+
+    res.status(200).json({ documents, totalCount, count, totalPages });
+  } catch (error) {
+    console.log(error);
+    res.status(500).json({ error: error.message || "Internal server error" });
+  }
 });
 
 app.get("/schema/:modelName", async (req, res) => {
-    try {
-        const modelName = req.params.modelName;
-        const Model = mongoose.model(modelName);
-
-        if (!Model) return res.status(404).json({ error: 'Model not found' });
-
-        const paths = Model.schema.paths;
-        const schema = {};
+  try {
+    const modelName = req.params.modelName;
+    const Model = mongoose.model(modelName);
 
-        function getSchema(paths) {
-            for (const path in paths) {
+    if (!Model) return res.status(404).json({ error: "Model not found" });
 
-                if (path === '_id' || path === '__v') continue;
+    const paths = Model.schema.paths;
+    const schema = {};
 
-                if (paths[path].instance === 'Embedded') {
-                    getSchema(paths[path].schema.paths);
-                    continue;
-                };
+    function getSchema(paths) {
+      for (const path in paths) {
+        if (path === "_id" || path === "__v") continue;
 
-                const field = paths[path];
-                const fieldType = field.instance;
-                const fieldOptions = Object.assign({}, field.options);
+        if (paths[path].instance === "Embedded") {
+          getSchema(paths[path].schema.paths);
+          continue;
+        }
 
-                delete fieldOptions["type"];
+        const field = paths[path];
+        const fieldType = field.instance;
+        const fieldOptions = Object.assign({}, field.options);
 
-                schema[path] = {
-                    type: fieldType,
-                    ...fieldOptions
-                }
-            }
-        }
-        getSchema(paths)
+        delete fieldOptions["type"];
 
-        res.status(200).json(schema);
-    } catch (error) {
-        res.status(500).json({ error: error.message || "Intenral Server Error" })
+        schema[path] = {
+          type: fieldType,
+          ...fieldOptions,
+        };
+      }
     }
+    getSchema(paths);
+
+    res.status(200).json(schema);
+  } catch (error) {
+    res.status(500).json({ error: error.message || "Intenral Server Error" });
+  }
 });
 
 app.get("/id/:modelName", async (req, res) => {
+  try {
+    const { modelName } = req.params;
+    const Model = mongoose.model(modelName);
+    if (!Model) return res.status(404).json({ error: "model not found" });
 
-    try {
-        const { modelName } = req.params;
-        const Model = mongoose.model(modelName)
-        if (!Model) return res.status(404).json({ error: "model not found" });
-
-        const docs = await Model.find({});
-        const ids = [];
+    const docs = await Model.find({});
+    const ids = [];
 
-        docs.map(doc => ids.push(doc._id))
+    docs.map((doc) => ids.push(doc._id));
 
-        res.status(200).json(ids)
-    } catch (error) {
-        res.status(500).json({ error: error.message || "Internal server error" })
-    }
-})
+    res.status(200).json(ids);
+  } catch (error) {
+    res.status(500).json({ error: error.message || "Internal server error" });
+  }
+});
 
 app.post("/insert/:modelName", async (req, res) => {
+  try {
+    const { modelName } = req.params;
+    const body = req.body;
 
-    try {
-        const { modelName } = req.params;
-        const body = req.body;
+    const Model = mongoose.model(modelName);
 
-        const Model = mongoose.model(modelName);
+    if (!Model) return res.status(404).json({ error: "model not found" });
 
-        if (!Model) return res.status(404).json({ error: "model not found" });
+    const paths = Model.schema.paths;
 
-        const paths = Model.schema.paths;
+    function getSchema(paths) {
+      let schema = {};
+      for (const path in paths) {
+        if (path === "_id" || path === "__v") continue;
 
-        function getSchema(paths) {
-
-            let schema = {};
-            for (const path in paths) {
-
-                if (path === '_id' || path === '__v') continue;
-
-                if (paths[path].instance === 'Embedded') {
-                    schema[path] = getSchema(paths[path].schema.paths);
-                    continue;
-                };
-
-                schema[path] = paths[path].instance;
-            }
-
-            return schema;
+        if (paths[path].instance === "Embedded") {
+          schema[path] = getSchema(paths[path].schema.paths);
+          continue;
         }
 
-        const schema = getSchema(paths)
+        schema[path] = paths[path].instance;
+      }
 
-        function getData(body, schema) {
-
-            let data = {};
-
-            for (const key in schema) {
-                if (typeof schema[key] === 'object' && schema[key] !== null) {
+      return schema;
+    }
 
-                    data[key] = getData(body, schema[key]);
-                    continue;
-                }
+    const schema = getSchema(paths);
 
-                if (Object.keys(body).includes(key)) {
-                    data[key] = body[key];
-                }
-            }
+    function getData(body, schema) {
+      let data = {};
 
-            return data;
+      for (const key in schema) {
+        if (typeof schema[key] === "object" && schema[key] !== null) {
+          data[key] = getData(body, schema[key]);
+          continue;
         }
 
-        const data = getData(body, schema)
-
-        const result = await Model.create(data)
+        if (Object.keys(body).includes(key)) {
+          data[key] = body[key];
+        }
+      }
 
-        res.status(200).json(result)
-    } catch (error) {
-        res.status(500).json({ error: error.message || "Internal server error" })
+      return data;
     }
-})
 
-app.put("/update/:modelName/:id", async (req, res) => {
-    try {
-        const { modelName, id } = req.params;
-        const model = mongoose.model(modelName);
-        const updatedDoc = req.body;
+    const data = getData(body, schema);
 
-        delete updatedDoc._id;
-        const result = await model.findByIdAndUpdate(id, updatedDoc, { new: true });
+    const result = await Model.create(data);
 
-        res.status(200).json(result);
-    } catch (error) {
+    res.status(200).json(result);
+  } catch (error) {
+    res.status(500).json({ error: error.message || "Internal server error" });
+  }
+});
 
-        res.status(500).json({ error: error.message || "Internal server error" });
-    }
+app.put("/update/:modelName/:id", async (req, res) => {
+  try {
+    const { modelName, id } = req.params;
+    const model = mongoose.model(modelName);
+    const updatedDoc = req.body;
+
+    delete updatedDoc._id;
+    const result = await model.findByIdAndUpdate(id, updatedDoc, { new: true });
+
+    res.status(200).json(result);
+  } catch (error) {
+    res.status(500).json({ error: error.message || "Internal server error" });
+  }
 });
 
 app.delete("/delete/:modelName/:id", async (req, res) => {
-    try {
-        const { modelName, id } = req.params;
-        const model = mongoose.model(modelName);
+  try {
+    const { modelName, id } = req.params;
+    const model = mongoose.model(modelName);
 
-        await model.findByIdAndDelete(id);
-        const count = await model.countDocuments();
+    await model.findByIdAndDelete(id);
+    const count = await model.countDocuments();
 
-        res.status(200).json({ count });
-    } catch (error) {
-        res.status(500).json({ error: error.message || "Internal server error" });
-    }
+    res.status(200).json({ count });
+  } catch (error) {
+    res.status(500).json({ error: error.message || "Internal server error" });
+  }
 });
 
 app.delete("/delete-all/:modelName", async (req, res) => {
-    try {
-        const { modelName } = req.params;
-        const model = mongoose.model(modelName);
-        if (!model) return res.status(404).json({ error: "model not found" });
+  try {
+    const { modelName } = req.params;
+    const model = mongoose.model(modelName);
+    if (!model) return res.status(404).json({ error: "model not found" });
 
-        await model.deleteMany({});
+    await model.deleteMany({});
 
-        res.status(200).json({ success: true });
-    } catch (error) {
-        res.status(500).json({ error: error.message || "Internal server error" });
-    }
-})
+    res.status(200).json({ success: true });
+  } catch (error) {
+    res.status(500).json({ error: error.message || "Internal server error" });
+  }
+});
 
-export default app;
+export default app;

package/utils/loadModels.js

@@ -5,23 +5,26 @@ import chalk from "chalk";
 import { pathToFileURL } from "url";
 
 export default (modelPath) => {
-    if (!fs.existsSync(modelPath)) {
-        console.log(
-            chalk.red.bold('[ERROR]') +
-            ' The specified model path does not exist:\n  ' +
-            chalk.gray(modelPath)
-        );
-        console.log('Tip: Check the path or create the folder first.');
-        process.exit(1);
-    }
+  if (!fs.existsSync(modelPath)) {
+    console.log(
+      chalk.red.bold("[ERROR]") +
+        " The specified model path does not exist:\n  " +
+        chalk.gray(modelPath)
+    );
+    console.log("Tip: Check the path or create the folder first.");
+    process.exit(1);
+  }
 
-    fs.readdirSync(modelPath).forEach(async (file) => {
-        if (file.endsWith('.js')) {
-            const filePath = path.join(modelPath, file);
-            const moduleUrl = pathToFileURL(filePath);
-            await import(moduleUrl.href);
-        }
-    });
+  fs.readdirSync(modelPath).forEach(async (file) => {
+    if (file.endsWith(".js") || file.endsWith(".ts")) {
+      const filePath = path.join(modelPath, file);
+      const moduleUrl = pathToFileURL(filePath);
+      await import(moduleUrl.href);
+    }
+  });
 
-    console.log(chalk.blue.bold('[INFO]'), chalk.gray("Models loaded from: " + modelPath))
-}
+  console.log(
+    chalk.blue.bold("[INFO]"),
+    chalk.gray("Models loaded from: " + modelPath)
+  );
+};