feat(api): add schemas endpoints for dynamic creation via api key

Author: yash-pouranik

backend/app.js

@@ -71,13 +71,14 @@ const projectRoute = require('./routes/projects');
 const dataRoute = require('./routes/data');
 const userAuthRoute = require('./routes/userAuth');
 const storageRoute = require('./routes/storage');
+const schemaRoute = require('./routes/schemas');
 
 // ROUTES SETUP 
 app.use('/api/auth', dashboardLimiter, authRoute); // Developer Auth
 app.use('/api/projects', dashboardLimiter, projectRoute); // Project Mgmt
 app.use('/api/userAuth', limiter, logger, userAuthRoute);
 app.use('/api/data', limiter, cors(adminCorsOptions), logger, dataRoute);
-app.use('/api/data', limiter, cors(adminCorsOptions), logger, dataRoute);
+app.use('/api/schemas', limiter, cors(adminCorsOptions), logger, schemaRoute);
 app.use('/api/storage', limiter, cors(adminCorsOptions), logger, storageRoute);
 
 app.get('/api/server-ip', async (req, res) => {

backend/controllers/schema.controller.js

@@ -0,0 +1,75 @@
+const { createSchemaApiKeySchema } = require('../utils/input.validation');
+const Project = require('../models/Project');
+const { v4: uuidv4 } = require('uuid');
+const { deleteProjectById, setProjectById, deleteProjectByApiKeyCache } = require('../services/redisCaching');
+const { z } = require('zod');
+
+module.exports.checkSchema = async (req, res) => {
+    try {
+        const { collectionName } = req.params;
+        const project = req.project;
+
+        if (!project) return res.status(401).json({ error: "Project missing from request." });
+
+        const collectionConfig = project.collections.find(c => c.name === collectionName);
+
+        if (!collectionConfig) {
+            return res.status(404).json({ error: "Schema/Collection not found" });
+        }
+
+        res.status(200).json({ message: "Schema exists", collection: collectionConfig });
+    } catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+};
+
+module.exports.createSchema = async (req, res) => {
+    try {
+        const { name, fields } = createSchemaApiKeySchema.parse(req.body);
+        let project = req.project; // From verifyApiKey
+
+        // Need the full document to call .save(), req.project from cache might be a lean object.
+        // It's safer to fetch the mongoose model instance to modify it.
+        const projectId = project._id;
+        const fullProject = await Project.findById(projectId);
+
+        if (!fullProject) return res.status(404).json({ error: 'Project not found' });
+
+        const exists = fullProject.collections.find(c => c.name === name);
+        if (exists) return res.status(400).json({ error: 'Collection/Schema already exists' });
+
+        if (!fullProject.jwtSecret) fullProject.jwtSecret = uuidv4();
+
+        // Convert the incoming API payload (name, type, required) into the UrBackend schema format (key, type, required)
+        const transformedFields = (fields || []).map(f => {
+            // Capitalize first letter of type mapping "string" -> "String" requirement
+            const mappedType = f.type.charAt(0).toUpperCase() + f.type.slice(1).toLowerCase();
+            return {
+                key: f.name,
+                type: mappedType,
+                required: f.required === true
+            };
+        });
+
+        fullProject.collections.push({ name: name, model: transformedFields });
+        await fullProject.save();
+
+        // Clear redis cache
+        await deleteProjectById(projectId.toString());
+        await setProjectById(projectId.toString(), fullProject);
+        await deleteProjectByApiKeyCache(fullProject.apiKey); // In case it was cached by hashed key
+        // NOTE: req.hashedApiKey is available from middleware if we strictly want that.
+        if (req.hashedApiKey) {
+            await deleteProjectByApiKeyCache(req.hashedApiKey);
+        }
+
+        const projectObj = fullProject.toObject();
+        delete projectObj.apiKey;
+        delete projectObj.jwtSecret;
+
+        res.status(201).json({ message: "Schema created successfully", project: projectObj });
+    } catch (err) {
+        if (err instanceof z.ZodError) return res.status(400).json({ error: err.errors });
+        res.status(500).json({ error: err.message });
+    }
+};

backend/routes/schemas.js

@@ -0,0 +1,14 @@
+const express = require('express');
+const router = express.Router();
+const verifyApiKey = require('../middleware/verifyApiKey');
+const { checkSchema, createSchema } = require("../controllers/schema.controller");
+
+// GET Route to check if a schema exists
+// GET /api/schemas/error_logs
+router.get('/:collectionName', verifyApiKey, checkSchema);
+
+// POST Route to create a new schema
+// POST /api/schemas
+router.post('/', verifyApiKey, createSchema);
+
+module.exports = router;

backend/test_schemas.js

@@ -0,0 +1,8 @@
+// We will need a project API key to test this.
+// Before running this test, you'll need the dev server running, or try starting it up in another terminal.
+const http = require('http');
+
+async function getAdminToken() {
+    // You'd normally fetch or login...
+    // Let's do a curl test instead manually if we don't have a known API key
+}

backend/utils/input.validation.js

@@ -54,6 +54,16 @@ module.exports.createCollectionSchema = z.object({
     })).optional()
 });
 
+// Create Collection Schema (API Key based)
+module.exports.createSchemaApiKeySchema = z.object({
+    name: z.string().min(1, "Collection Name is required"),
+    fields: z.array(z.object({
+        name: z.string(),
+        type: z.enum(['string', 'number', 'boolean', 'date', 'String', 'Number', 'Boolean', 'Date']),
+        required: z.boolean().optional()
+    })).optional()
+});
+
 module.exports.sanitize = (obj) => {
     const clean = {};
     for (const key in obj) {