@underpostnet/underpost 2.97.0 → 2.97.5

package/src/client/services/file/file.service.js

@@ -29,24 +29,51 @@ const FileService = {
         }),
     ),
   get: (options = { id: '' }) =>
-    new Promise((resolve, reject) =>
-      fetch(getApiBaseUrl({ id: options.id, endpoint }), {
-        method: 'GET',
-        headers: headersFactory(),
-        credentials: 'include',
-      })
-        .then(async (res) => {
-          return await res.json();
+    new Promise((resolve, reject) => {
+      // Handle blob endpoint - fetch binary data directly
+      if (options.id && options.id.startsWith('blob/')) {
+        const blobId = options.id.substring(5); // Remove 'blob/' prefix
+        fetch(getApiBaseUrl({ id: blobId, endpoint: 'file/blob' }), {
+          method: 'GET',
+          headers: headersFactory(),
+          credentials: 'include',
         })
-        .then((res) => {
-          logger.info(res);
-          return resolve(res);
+          .then(async (res) => {
+            if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+            return await res.blob();
+          })
+          .then((blob) => {
+            logger.info('Blob fetched successfully');
+            return resolve({
+              status: 'success',
+              data: [blob],
+            });
+          })
+          .catch((error) => {
+            logger.error(error);
+            return reject(error);
+          });
+      } else {
+        // Handle regular metadata endpoint - fetch JSON
+        fetch(getApiBaseUrl({ id: options.id, endpoint }), {
+          method: 'GET',
+          headers: headersFactory(),
+          credentials: 'include',
         })
-        .catch((error) => {
-          logger.error(error);
-          return reject(error);
-        }),
-    ),
+          .then(async (res) => {
+            if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+            return await res.json();
+          })
+          .then((res) => {
+            logger.info(res);
+            return resolve(res);
+          })
+          .catch((error) => {
+            logger.error(error);
+            return reject(error);
+          });
+      }
+    }),
   delete: (options = { id: '', body: {} }) =>
     new Promise((resolve, reject) =>
       fetch(getApiBaseUrl({ id: options.id, endpoint }), {

package/src/client/services/user/user.service.js

@@ -1,6 +1,6 @@
 import { Auth } from '../../components/core/Auth.js';
 import { loggerFactory } from '../../components/core/Logger.js';
-import { getApiBaseUrl, headersFactory, payloadFactory } from '../core/core.service.js';
+import { getApiBaseUrl, headersFactory, payloadFactory, buildQueryUrl } from '../core/core.service.js';
 
 const logger = loggerFactory(import.meta);
 
@@ -37,15 +37,19 @@ const UserService = {
           return reject(error);
         }),
     ),
-  get: (options = { id: '', page: 1, limit: 10 }) => {
-    const { id = '', page, limit } = options;
-    const query = new URLSearchParams();
-    if (page) query.set('page', page);
-    if (limit) query.set('limit', limit);
-    const queryString = query.toString();
-    const url = `${getApiBaseUrl({ id, endpoint })}${queryString ? (id.includes('?') ? '&' : '?') + queryString : ''}`;
+  get: (options = {}) => {
+    const { id, page, limit, filterModel, sortModel, sort, asc, order } = options;
+    const url = buildQueryUrl(getApiBaseUrl({ id, endpoint }), {
+      page,
+      limit,
+      filterModel,
+      sortModel,
+      sort,
+      asc,
+      order,
+    });
     return new Promise((resolve, reject) =>
-      fetch(url, {
+      fetch(url.toString(), {
         method: 'GET',
         headers: headersFactory(),
         credentials: 'include',

package/src/db/DataBaseProvider.js

@@ -20,7 +20,7 @@ class DataBaseProviderService {
   /**
    * Internal storage for database connection instances, keyed by host+path.
    * @type {object.<string, object>}
-   * @private
+   * @method
    */
   #instance = {};
 

package/src/db/mongo/MongooseDB.js

@@ -28,7 +28,7 @@ class MongooseDBService {
    */
   async connect(host, name) {
     const uri = `${host}/${name}`;
-    logger.info('MongooseDB connect', { host, name, uri });
+    // logger.info('MongooseDB connect', { host, name, uri });
     return await mongoose
       .createConnection(uri, {
         serverSelectionTimeoutMS: 5000,

package/src/index.js

@@ -36,7 +36,7 @@ class Underpost {
    * @type {String}
    * @memberof Underpost
    */
-  static version = 'v2.97.0';
+  static version = 'v2.97.5';
   /**
    * Repository cli API
    * @static

package/src/mailer/MailerProvider.js

@@ -41,7 +41,7 @@ class MailerProviderService {
   /**
    * Internal storage for mailer instances (transporters, options, templates), keyed by ID.
    * @type {object.<string, object>}
-   * @private
+   * @method
    */
   #instance = {};
 
@@ -108,14 +108,14 @@ class MailerProviderService {
             P1: {
               en: `Email confirmed! Thanks.
                <br />
-             <span style="font-size: 12px; color: gray"> 
-                If it is not automatically verified, 
+             <span style="font-size: 12px; color: gray">
+                If it is not automatically verified,
                 please allow the image to be seen, thank you.
              </span>
               `,
               es: `Correo electrónico confirmado! Gracias.
               <br />
-              <span style="font-size: 12px; color: gray"> 
+              <span style="font-size: 12px; color: gray">
                Si no se verifica automáticamente, por favor permita que se vea la imagen, gracias.
               </span>
               `,

package/src/runtime/express/Express.js

@@ -180,6 +180,7 @@ class ExpressService {
 
       // Database and Valkey connections
       if (db && apis) await DataBaseProvider.load({ apis, host, path, db });
+
       if (valkey) await createValkeyConnection({ host, path }, valkey);
 
       // Mailer setup
@@ -202,7 +203,7 @@ class ExpressService {
         for (const api of apis) {
           logger.info(`Build api server`, `${host}${apiPath}/${api}`);
           const { ApiRouter } = await import(`../../api/${api}/${api}.router.js`);
-          const router = ApiRouter({ host, path, apiPath, mailer, db, authMiddleware, origins });
+          const router = ApiRouter({ app, host, path, apiPath, mailer, db, authMiddleware, origins });
           app.use(`${apiPath}/${api}`, router);
         }
       }

package/src/runtime/lampp/Lampp.js

@@ -20,7 +20,7 @@ const logger = loggerFactory(import.meta);
  */
 class LamppService {
   /**
-   * @private
+   * @method
    * @type {string | undefined}
    * @description Stores the accumulated Apache virtual host configuration (router definition).
    * @memberof LamppService
@@ -273,7 +273,7 @@ Listen ${port}
   ErrorDocument 504 ${path === '/' ? '' : path}/500.html
 
 </VirtualHost>
-            
+
 `);
 
     return { disabled: false };

package/src/server/auth.js

@@ -221,7 +221,7 @@ const authMiddlewareFactory = (options = { host: '', path: '' }) => {
 
       if (payload.userAgent && payload.userAgent !== req.headers['user-agent']) {
         logger.warn(`UA mismatch for ${payload._id}`);
-        return res.status(401).json({ status: 'error', message: 'unauthorized: user-agent mismatch' });
+        return res.status(401).json({ status: 'error', message: 'unauthorized device' });
       }
 
       // Non-guest verify session exists
@@ -247,7 +247,7 @@ const authMiddlewareFactory = (options = { host: '', path: '' }) => {
         // check session userAgent
         if (session.userAgent !== req.headers['user-agent']) {
           logger.warn(`UA mismatch for ${payload._id}`);
-          return res.status(401).json({ status: 'error', message: 'unauthorized: user-agent mismatch' });
+          return res.status(401).json({ status: 'error', message: 'unauthorized device' });
         }
 
         // compare payload host and path with session host and path
@@ -441,22 +441,19 @@ async function logoutSession(User, req, res) {
  * @param {import('express').Request} req The Express request object.
  * @param {import('express').Response} res The Express response object.
  * @param {import('mongoose').Model} User The Mongoose User model.
- * @param {import('mongoose').Model} File The Mongoose File model.
  * @param {object} [options={}] Additional options.
- * @param {Function} options.getDefaultProfileImageId Function to get the default profile image ID.
  * @param {string} options.host The host name.
  * @param {string} options.path The path name.
  * @returns {Promise<{token: string, user: object}>} The access token and user object.
  * @throws {Error} If password validation fails.
  * @memberof Auth
  */
-async function createUserAndSession(req, res, User, File, options = { host: '', path: '' }) {
+async function createUserAndSession(req, res, User, options = { host: '', path: '' }) {
   const pwdCheck = validatePasswordMiddleware(req);
   if (pwdCheck.status === 'error') throw new Error(pwdCheck.message);
 
   req.body.password = await hashPassword(req.body.password);
   req.body.role = req.body.role === 'guest' ? 'guest' : 'user';
-  req.body.profileImageId = await options.getDefaultProfileImageId(File);
 
   const saved = await new User(req.body).save();
   const user = await User.findOne({ _id: saved._id }).select(UserDto.select.get());

package/src/server/data-query.js

@@ -0,0 +1,449 @@
+/**
+ * Module for parsing data query parameters into Mongoose query options.
+ * Supports AG Grid filterModel/sortModel as well as simple legacy parameters.
+ * @module src/server/data-query.js
+ * @namespace DataQuery
+ */
+
+export const DataQuery = {
+  /**
+   * Parse request query parameters into Mongoose query options
+   * @param {Object} params - The request query parameters (req.query)
+   * @param {string|Object} [params.filterModel] - AG Grid filterModel as JSON string or object
+   * @param {string|Object} [params.sortModel] - AG Grid sortModel as JSON string or object
+   * @param {number|string} [params.page=1] - Page number for pagination
+   * @param {number|string} [params.limit=10] - Items per page for pagination
+   * @param {string} [params.sort] - Simple sort field (legacy)
+   * @param {string|boolean} [params.asc] - Simple sort direction (legacy, '1'/'true' for asc)
+   * @param {string} [params.order] - Simple order string, e.g. "field1:asc,field2:desc" (legacy)
+   * @param {Object} [params.query] - Default query object to merge with filters
+   * @memberof DataQuery
+   * @returns {Object} { query, sort, skip, limit, page }
+   */
+  parse: (params = {}) => {
+    let { filterModel, sortModel, page, limit, sort: sortParam, asc, order, query: defaultQuery } = params;
+
+    // === 1. Pagination ===
+    page = parseInt(page, 10) || 1;
+    limit = parseInt(limit, 10) || 10;
+    const skip = (page - 1) * limit;
+
+    // === 2. Sorting ===
+    const sort = DataQuery._parseSort(sortModel, sortParam, asc, order);
+
+    // === 3. Filtering ===
+    const query = DataQuery._parseFilter(filterModel, defaultQuery);
+
+    return { query, sort, skip, limit, page };
+  },
+
+  /**
+   * Parse sort parameters from AG Grid sortModel or simple sort params
+   * @method
+   * @param {string|Object} sortModel - AG Grid sortModel as JSON string or object
+   * @param {string} sortParam - Simple sort field (legacy)
+   * @param {string|boolean} asc - Simple sort direction (legacy)
+   * @param {string} order - Simple order string (legacy)
+   * @return {Object} sort object for Mongoose
+   * @memberof DataQuery
+   */
+  _parseSort: (sortModel, sortParam, asc, order) => {
+    const sort = {};
+
+    // Parse sortModel from string if needed
+    if (typeof sortModel === 'string' && sortModel.trim()) {
+      try {
+        sortModel = JSON.parse(sortModel);
+      } catch (e) {
+        console.warn('DataQuery: Failed to parse sortModel JSON:', e.message);
+        sortModel = null;
+      }
+    }
+
+    // AG Grid sortModel format: [{ colId: 'field', sort: 'asc' | 'desc' }]
+    if (Array.isArray(sortModel) && sortModel.length > 0) {
+      sortModel.forEach((sortItem) => {
+        if (sortItem && sortItem.colId && sortItem.sort) {
+          sort[sortItem.colId] = sortItem.sort === 'asc' ? 1 : -1;
+        }
+      });
+      return sort;
+    }
+
+    // Simple sort params (legacy support)
+    if (sortParam && typeof sortParam === 'string') {
+      const direction = asc === '1' || asc === 'true' || asc === true ? 1 : -1;
+      sort[sortParam] = direction;
+      return sort;
+    }
+
+    // Order param format: "field1:asc,field2:desc"
+    if (order && typeof order === 'string') {
+      const orderParts = order.split(',');
+      orderParts.forEach((part) => {
+        const [field, dir] = part.split(':');
+        if (field && field.trim()) {
+          sort[field.trim()] = dir === 'desc' ? -1 : 1;
+        }
+      });
+      return sort;
+    }
+
+    return sort;
+  },
+
+  /**
+   * Parse filter parameters from AG Grid filterModel
+   * @method
+   * @param {string|Object} filterModel - AG Grid filterModel as JSON string or object
+   * @param {Object} defaultQuery - Default query object to merge with filters
+   * @return {Object} query object for Mongoose
+   * @memberof DataQuery
+   */
+  _parseFilter: (filterModel, defaultQuery) => {
+    let query = defaultQuery ? { ...defaultQuery } : {};
+
+    // Parse filterModel from string if needed
+    if (typeof filterModel === 'string' && filterModel.trim()) {
+      try {
+        filterModel = JSON.parse(filterModel);
+      } catch (e) {
+        console.warn('DataQuery: Failed to parse filterModel JSON:', e.message);
+        filterModel = null;
+      }
+    }
+
+    if (!filterModel || typeof filterModel !== 'object' || Array.isArray(filterModel)) {
+      return query;
+    }
+
+    // Process each filter in the filterModel
+    Object.entries(filterModel).forEach(([field, filter]) => {
+      if (!field || !filter) return;
+      const fieldQuery = DataQuery._parseFieldFilter(field, filter);
+      if (fieldQuery) {
+        query = { ...query, ...fieldQuery };
+      }
+    });
+
+    return query;
+  },
+
+  /**
+   * Parse a single field filter
+   * @method
+   * @param {string} field - The field name
+   * @param {Object} filter - The filter object
+   * @return {Object|null} query condition for the field or null if invalid
+   * @memberof DataQuery
+   */
+  _parseFieldFilter: (field, filter) => {
+    if (!filter || !filter.filterType) {
+      return null;
+    }
+
+    const { filterType } = filter;
+
+    switch (filterType) {
+      case 'text':
+        return DataQuery._parseTextFilter(field, filter);
+      case 'number':
+        return DataQuery._parseNumberFilter(field, filter);
+      case 'date':
+        return DataQuery._parseDateFilter(field, filter);
+      case 'set':
+        return DataQuery._parseSetFilter(field, filter);
+      case 'multi':
+        return DataQuery._parseMultiFilter(field, filter);
+      default:
+        return null;
+    }
+  },
+
+  /**
+   * Parse text filter
+   * @method
+   * @param {string} field - The field name
+   * @param {Object} filter - The filter object
+   * @return {Object|null} query condition for the text field or null if invalid
+   * @memberof DataQuery
+   */
+  _parseTextFilter: (field, filter) => {
+    const { type, filter: filterValue } = filter;
+
+    if (filterValue === null || filterValue === undefined || filterValue === '') {
+      // Handle blank/notBlank without a filter value
+      if (type === 'blank' || type === 'notBlank') {
+        const query = {};
+        if (type === 'blank') {
+          query[field] = { $in: [null, ''] };
+        } else {
+          query[field] = { $nin: [null, ''], $exists: true };
+        }
+        return query;
+      }
+      return null;
+    }
+
+    const query = {};
+    // Escape special regex characters for safety
+    const escapeRegex = (str) => String(str).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+    switch (type) {
+      case 'equals':
+        query[field] = filterValue;
+        break;
+      case 'notEqual':
+        query[field] = { $ne: filterValue };
+        break;
+      case 'contains':
+        query[field] = { $regex: escapeRegex(filterValue), $options: 'i' };
+        break;
+      case 'notContains':
+        query[field] = { $not: { $regex: escapeRegex(filterValue), $options: 'i' } };
+        break;
+      case 'startsWith':
+        query[field] = { $regex: `^${escapeRegex(filterValue)}`, $options: 'i' };
+        break;
+      case 'endsWith':
+        query[field] = { $regex: `${escapeRegex(filterValue)}$`, $options: 'i' };
+        break;
+      case 'blank':
+        query[field] = { $in: [null, ''] };
+        break;
+      case 'notBlank':
+        query[field] = { $nin: [null, ''], $exists: true };
+        break;
+      default:
+        query[field] = { $regex: escapeRegex(filterValue), $options: 'i' };
+    }
+
+    return query;
+  },
+
+  /**
+   * Parse number filter
+   * @method
+   * @param {string} field - The field name
+   * @param {Object} filter - The filter object
+   * @return {Object|null} query condition for the number field or null if invalid
+   * @memberof DataQuery
+   */
+  _parseNumberFilter: (field, filter) => {
+    const { type, filter: filterValue, filterTo } = filter;
+
+    if (filterValue === null || filterValue === undefined) {
+      return null;
+    }
+
+    const query = {};
+    const numValue = parseFloat(filterValue);
+
+    if (isNaN(numValue)) {
+      return null;
+    }
+
+    switch (type) {
+      case 'equals':
+        query[field] = numValue;
+        break;
+      case 'notEqual':
+        query[field] = { $ne: numValue };
+        break;
+      case 'lessThan':
+        query[field] = { $lt: numValue };
+        break;
+      case 'lessThanOrEqual':
+        query[field] = { $lte: numValue };
+        break;
+      case 'greaterThan':
+        query[field] = { $gt: numValue };
+        break;
+      case 'greaterThanOrEqual':
+        query[field] = { $gte: numValue };
+        break;
+      case 'inRange':
+        if (filterTo !== null && filterTo !== undefined) {
+          const numTo = parseFloat(filterTo);
+          if (!isNaN(numTo)) {
+            query[field] = { $gte: numValue, $lte: numTo };
+          }
+        }
+        break;
+      case 'blank':
+        query[field] = { $in: [null, undefined] };
+        break;
+      case 'notBlank':
+        query[field] = { $nin: [null, undefined], $exists: true };
+        break;
+      default:
+        query[field] = numValue;
+    }
+
+    return query;
+  },
+
+  /**
+   * Parse date filter
+   * @method
+   * @param {string} field - The field name
+   * @param {Object} filter - The filter object
+   * @return {Object|null} query condition for the date field or null if invalid
+   * @memberof DataQuery
+   */
+  _parseDateFilter: (field, filter) => {
+    const { type, dateFrom, dateTo } = filter;
+
+    // Handle blank/notBlank without dates
+    if (type === 'blank' || type === 'notBlank') {
+      const query = {};
+      if (type === 'blank') {
+        query[field] = { $in: [null, undefined] };
+      } else {
+        query[field] = { $nin: [null, undefined], $exists: true };
+      }
+      return query;
+    }
+
+    if (!dateFrom && !dateTo) {
+      return null;
+    }
+
+    const query = {};
+
+    const parseDate = (dateStr) => {
+      if (!dateStr) return null;
+      const date = new Date(dateStr);
+      return isNaN(date.getTime()) ? null : date;
+    };
+
+    const fromDate = parseDate(dateFrom);
+    const toDate = parseDate(dateTo);
+
+    if (!fromDate && !toDate) {
+      return null;
+    }
+
+    switch (type) {
+      case 'equals':
+        if (fromDate) {
+          // Match the entire day
+          const startOfDay = new Date(fromDate);
+          startOfDay.setHours(0, 0, 0, 0);
+          const endOfDay = new Date(fromDate);
+          endOfDay.setHours(23, 59, 59, 999);
+          query[field] = { $gte: startOfDay, $lte: endOfDay };
+        }
+        break;
+      case 'notEqual':
+        if (fromDate) {
+          const startOfDay = new Date(fromDate);
+          startOfDay.setHours(0, 0, 0, 0);
+          const endOfDay = new Date(fromDate);
+          endOfDay.setHours(23, 59, 59, 999);
+          query[field] = { $not: { $gte: startOfDay, $lte: endOfDay } };
+        }
+        break;
+      case 'lessThan':
+        if (fromDate) {
+          query[field] = { $lt: fromDate };
+        }
+        break;
+      case 'lessThanOrEqual':
+        if (fromDate) {
+          query[field] = { $lte: fromDate };
+        }
+        break;
+      case 'greaterThan':
+        if (fromDate) {
+          query[field] = { $gt: fromDate };
+        }
+        break;
+      case 'greaterThanOrEqual':
+        if (fromDate) {
+          query[field] = { $gte: fromDate };
+        }
+        break;
+      case 'inRange':
+        if (fromDate && toDate) {
+          // For inRange, set toDate to end of day
+          const endOfToDate = new Date(toDate);
+          endOfToDate.setHours(23, 59, 59, 999);
+          query[field] = { $gte: fromDate, $lte: endOfToDate };
+        } else if (fromDate) {
+          query[field] = { $gte: fromDate };
+        } else if (toDate) {
+          const endOfToDate = new Date(toDate);
+          endOfToDate.setHours(23, 59, 59, 999);
+          query[field] = { $lte: endOfToDate };
+        }
+        break;
+      case 'blank':
+        query[field] = { $in: [null, undefined] };
+        break;
+      case 'notBlank':
+        query[field] = { $nin: [null, undefined], $exists: true };
+        break;
+      default:
+        if (fromDate) {
+          query[field] = fromDate;
+        }
+    }
+
+    return query;
+  },
+
+  /**
+   * Parse set filter
+   * @method
+   * @param {string} field - The field name
+   * @param {Object} filter - The filter object
+   * @return {Object|null} query condition for the set field or null if invalid
+   * @memberof DataQuery
+   */
+  _parseSetFilter: (field, filter) => {
+    const { values } = filter;
+
+    if (!Array.isArray(values) || values.length === 0) {
+      return null;
+    }
+
+    return { [field]: { $in: values } };
+  },
+
+  /**
+   * Parse multi filter (combines multiple filters with AND/OR)
+   * @method
+   * @param {string} field - The field name
+   * @param {Object} filter - The multi filter object
+   * @return {Object|null} query condition for the multi filter or null if invalid
+   * @memberof DataQuery
+   */
+  _parseMultiFilter: (field, filter) => {
+    const { filterModels, operator } = filter;
+
+    if (!Array.isArray(filterModels) || filterModels.length === 0) {
+      return null;
+    }
+
+    const conditions = filterModels
+      .map((subFilter) => DataQuery._parseFieldFilter(field, subFilter))
+      .filter((condition) => condition !== null);
+
+    if (conditions.length === 0) {
+      return null;
+    }
+
+    if (conditions.length === 1) {
+      return conditions[0];
+    }
+
+    // Combine conditions with AND or OR
+    if (operator === 'OR') {
+      return { $or: conditions };
+    } else {
+      // AND operator (default)
+      return { $and: conditions };
+    }
+  },
+};