underpost 3.2.70 → 3.2.90

package/src/api/core/core.router.js

@@ -1,9 +1,7 @@
+import express from 'express';
+import { registerCrudRoutes } from '../../server/middlewares.js';
 import { adminGuard } from '../../server/auth.js';
-import { loggerFactory } from '../../server/logger.js';
 import { CoreController } from './core.controller.js';
-import express from 'express';
-
-const logger = loggerFactory(import.meta);
 
 class CoreRouter {
   /**
@@ -11,16 +9,12 @@ class CoreRouter {
    * @returns {import('express').Router}
    */
   static router(options) {
-    const router = express.Router();
-    router.post(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.post(req, res, options));
-    router.post(`/`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.post(req, res, options));
-    router.get(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.get(req, res, options));
-    router.get(`/`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.get(req, res, options));
-    router.put(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.put(req, res, options));
-    router.put(`/`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.put(req, res, options));
-    router.delete(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.delete(req, res, options));
-    router.delete(`/`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.delete(req, res, options));
-    return router;
+    const adminOnly = [options.authMiddleware, adminGuard];
+    return registerCrudRoutes(express.Router(), CoreController, options, {
+      readGuards: adminOnly,
+      writeGuards: adminOnly,
+      deleteAllGuards: adminOnly,
+    });
   }
 }
 

package/src/api/default/default.controller.js

@@ -1,74 +1,6 @@
-import { loggerFactory } from '../../server/logger.js';
+import { buildCrudController } from '../../server/middlewares.js';
 import { DefaultService } from './default.service.js';
 
-const logger = loggerFactory(import.meta);
-
-class DefaultController {
-  static post = async (req, res, options) => {
-    try {
-      const result = await DefaultService.post(req, res, options);
-      return res.status(200).json({
-        status: 'success',
-        data: result,
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-  static get = async (req, res, options) => {
-    try {
-      const { page, limit } = req.query;
-      const result = await DefaultService.get(
-        { ...req, query: { ...req.query, page: parseInt(page), limit: parseInt(limit) } },
-        res,
-        options,
-      );
-      return res.status(200).json({
-        status: 'success',
-        data: result,
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-  static put = async (req, res, options) => {
-    try {
-      const result = await DefaultService.put(req, res, options);
-      return res.status(200).json({
-        status: 'success',
-        data: result,
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-  static delete = async (req, res, options) => {
-    try {
-      const result = await DefaultService.delete(req, res, options);
-      return res.status(200).json({
-        status: 'success',
-        data: result,
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-}
+const DefaultController = buildCrudController(DefaultService);
 
 export { DefaultController };

package/src/api/default/default.router.js

@@ -1,8 +1,6 @@
-import { loggerFactory } from '../../server/logger.js';
-import { DefaultController } from './default.controller.js';
 import express from 'express';
-
-const logger = loggerFactory(import.meta);
+import { registerCrudRoutes } from '../../server/middlewares.js';
+import { DefaultController } from './default.controller.js';
 
 class DefaultRouter {
   /**
@@ -10,19 +8,11 @@ class DefaultRouter {
    * @returns {import('express').Router}
    */
   static router(options) {
-    const router = express.Router();
-    router.post(`/:id`, async (req, res) => await DefaultController.post(req, res, options));
-    router.post(`/`, async (req, res) => await DefaultController.post(req, res, options));
-    router.get(`/:id`,
-      // options.authMiddleware,
-      async (req, res) => await DefaultController.get(req, res, options),
-    );
-    router.get(`/`, async (req, res) => await DefaultController.get(req, res, options));
-    router.put(`/:id`, async (req, res) => await DefaultController.put(req, res, options));
-    router.put(`/`, async (req, res) => await DefaultController.put(req, res, options));
-    router.delete(`/:id`, async (req, res) => await DefaultController.delete(req, res, options));
-    router.delete(`/`, async (req, res) => await DefaultController.delete(req, res, options));
-    return router;
+    // Fully unguarded (matches prior behavior).
+    return registerCrudRoutes(express.Router(), DefaultController, options, {
+      writeGuards: [],
+      deleteAllGuards: [],
+    });
   }
 }
 

package/src/api/document/document.controller.js

@@ -1,81 +1,9 @@
-import { loggerFactory } from '../../server/logger.js';
+import { buildCrudController, serviceHandler } from '../../server/middlewares.js';
 import { DocumentService } from './document.service.js';
-const logger = loggerFactory(import.meta);
 
-class DocumentController {
-  static post = async (req, res, options) => {
-    try {
-      return res.status(200).json({
-        status: 'success',
-        data: await DocumentService.post(req, res, options),
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-  static get = async (req, res, options) => {
-    try {
-      return res.status(200).json({
-        status: 'success',
-        data: await DocumentService.get(req, res, options),
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-  static delete = async (req, res, options) => {
-    try {
-      const result = await DocumentService.delete(req, res, options);
-      return res.status(200).json({
-        status: 'success',
-        data: result,
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-  static put = async (req, res, options) => {
-    try {
-      const result = await DocumentService.put(req, res, options);
-      return res.status(200).json({
-        status: 'success',
-        data: result,
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-  static patch = async (req, res, options) => {
-    try {
-      const result = await DocumentService.patch(req, res, options);
-      return res.status(200).json({
-        status: 'success',
-        data: result,
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-}
+const DocumentController = buildCrudController(DocumentService, {
+  get: serviceHandler(DocumentService.get),
+  patch: serviceHandler(DocumentService.patch),
+});
 
 export { DocumentController };

package/src/api/document/document.router.js

@@ -1,8 +1,6 @@
-import { loggerFactory } from '../../server/logger.js';
-import { DocumentController } from './document.controller.js';
 import express from 'express';
-
-const logger = loggerFactory(import.meta);
+import { registerCrudRoutes } from '../../server/middlewares.js';
+import { DocumentController } from './document.controller.js';
 
 class DocumentRouter {
   /**
@@ -11,23 +9,21 @@ class DocumentRouter {
    */
   static router(options) {
     const router = express.Router();
-    router.post(`/:id`, options.authMiddleware, async (req, res) => await DocumentController.post(req, res, options));
-    router.post(`/`, options.authMiddleware, async (req, res) => await DocumentController.post(req, res, options));
+    const authOnly = [options.authMiddleware];
+    // Public listings — must come before the guarded generic /:id routes.
     router.get(`/public/high`, async (req, res) => await DocumentController.get(req, res, options));
     router.get(`/public`, async (req, res) => await DocumentController.get(req, res, options));
-    router.get(`/:id`, options.authMiddleware, async (req, res) => await DocumentController.get(req, res, options));
-    router.get(`/`, options.authMiddleware, async (req, res) => await DocumentController.get(req, res, options));
-    router.put(`/:id`, options.authMiddleware, async (req, res) => await DocumentController.put(req, res, options));
-    router.put(`/`, options.authMiddleware, async (req, res) => await DocumentController.put(req, res, options));
     router.patch(`/:id/copy-share-link`, async (req, res) => await DocumentController.patch(req, res, options));
     router.patch(
       `/:id/toggle-public`,
       options.authMiddleware,
       async (req, res) => await DocumentController.patch(req, res, options),
     );
-    router.delete(`/:id`, options.authMiddleware, async (req, res) => await DocumentController.delete(req, res, options));
-    router.delete(`/`, options.authMiddleware, async (req, res) => await DocumentController.delete(req, res, options));
-    return router;
+    return registerCrudRoutes(router, DocumentController, options, {
+      readGuards: authOnly,
+      writeGuards: authOnly,
+      deleteAllGuards: authOnly,
+    });
   }
 }
 

package/src/api/file/file.controller.js

@@ -1,59 +1,15 @@
-import { loggerFactory } from '../../server/logger.js';
+import { controllerHandler, sendSuccess, serviceHandler, setCrossOriginHeaders } from '../../server/middlewares.js';
 import { FileService } from './file.service.js';
-const logger = loggerFactory(import.meta);
 
 class FileController {
-  static post = async (req, res, options) => {
-    try {
-      return res.status(200).json({
-        status: 'success',
-        data: await FileService.post(req, res, options),
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-  static get = async (req, res, options) => {
-    try {
-      if (req && req.headers && req.headers.origin) {
-        res.set('Access-Control-Allow-Origin', req.headers.origin);
-      } else res.setHeader('Access-Control-Allow-Origin', '*');
-      res.setHeader('Cross-Origin-Resource-Policy', 'cross-origin');
-      const result = await FileService.get(req, res, options);
-      if (result instanceof Buffer) {
-        return res.status(200).end(result);
-      }
-      return res.status(200).json({
-        status: 'success',
-        data: result,
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-  static delete = async (req, res, options) => {
-    try {
-      const result = await FileService.delete(req, res, options);
-      return res.status(200).json({
-        status: 'success',
-        data: result,
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
+  static post = serviceHandler(FileService.post);
+  static get = controllerHandler(async (req, res, options) => {
+    setCrossOriginHeaders(req, res);
+    const result = await FileService.get(req, res, options);
+    if (result instanceof Buffer) return res.status(200).end(result);
+    return sendSuccess(res, result);
+  });
+  static delete = serviceHandler(FileService.delete);
 }
 
 export { FileController };

package/src/api/file/file.router.js

@@ -1,12 +1,10 @@
+import express from 'express';
 import { adminGuard } from '../../server/auth.js';
-import { loggerFactory } from '../../server/logger.js';
 import { FileController } from './file.controller.js';
-import express from 'express';
-
-const logger = loggerFactory(import.meta);
 
 class FileRouter {
   /**
+   * authenticated writes, admin-only deletes.
    * @param {import('../types.js').RouterOptions} options
    * @returns {import('express').Router}
    */
@@ -17,8 +15,18 @@ class FileRouter {
     router.get(`/blob/:id`, async (req, res) => await FileController.get(req, res, options));
     router.get(`/:id`, async (req, res) => await FileController.get(req, res, options));
     router.get(`/`, async (req, res) => await FileController.get(req, res, options));
-    router.delete(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await FileController.delete(req, res, options));
-    router.delete(`/`, options.authMiddleware, adminGuard, async (req, res) => await FileController.delete(req, res, options));
+    router.delete(
+      `/:id`,
+      options.authMiddleware,
+      adminGuard,
+      async (req, res) => await FileController.delete(req, res, options),
+    );
+    router.delete(
+      `/`,
+      options.authMiddleware,
+      adminGuard,
+      async (req, res) => await FileController.delete(req, res, options),
+    );
     return router;
   }
 }

package/src/api/test/test.controller.js

@@ -1,59 +1,14 @@
-import { loggerFactory } from '../../server/logger.js';
+import { controllerHandler, sendSuccess, serviceHandler } from '../../server/middlewares.js';
 import { TestService } from './test.service.js';
 
-const logger = loggerFactory(import.meta);
-
 class TestController {
-  static post = async (req, res, options) => {
-    try {
-      return res.status(200).json({
-        status: 'success',
-        data: await TestService.post(req, res, options),
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-  static get = async (req, res, options) => {
-    try {
-      const result = await TestService.get(req, res, options);
-      if (result)
-        return res.status(200).json({
-          status: 'success',
-          data: result,
-        });
-      else
-        return res.status(400).json({
-          status: 'error',
-        });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-  static delete = async (req, res, options) => {
-    try {
-      const result = await TestService.delete(req, res, options);
-
-      return res.status(200).json({
-        status: 'success',
-        data: result,
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
+  static post = serviceHandler(TestService.post);
+  static get = controllerHandler(async (req, res, options) => {
+    const result = await TestService.get(req, res, options);
+    if (result) return sendSuccess(res, result);
+    return res.status(400).json({ status: 'error' });
+  });
+  static delete = serviceHandler(TestService.delete);
 }
 
 export { TestController };

package/src/api/test/test.router.js

@@ -1,8 +1,5 @@
-import { loggerFactory } from '../../server/logger.js';
-import { TestController } from './test.controller.js';
 import express from 'express';
-
-const logger = loggerFactory(import.meta);
+import { TestController } from './test.controller.js';
 
 class TestRouter {
   /**