hola-server 1.0.11 → 2.0.1

package/db/gridfs.js

@@ -1,221 +1,175 @@
+/**
+ * @fileoverview GridFS file storage utilities.
+ * @module db/gridfs
+ */
+
 const fs = require('fs');
 const { GridFSBucket, MongoClient } = require('mongodb');
 const { get_settings } = require('../setting');
 
+const CHUNK_SIZE = 1024 * 1024; // 1MB
+
 let gridfs_instance;
 
+/**
+ * Get or create GridFS singleton instance.
+ * @returns {Promise<GridFS>} GridFS instance
+ */
 const get_gridfs_instance = async () => {
-    if (gridfs_instance) {
-        return gridfs_instance;
-    } else {
-        const mongo = get_settings().mongo;
-        gridfs_instance = new GridFS();
-        const client = await gridfs_instance.connect(mongo.url);
-        gridfs_instance.db = client.db();
-        return gridfs_instance;
-    }
-}
+    if (gridfs_instance) return gridfs_instance;
+
+    const { url } = get_settings().mongo;
+    const client = await MongoClient.connect(url, { useUnifiedTopology: true, useNewUrlParser: true });
+
+    gridfs_instance = new GridFS(client.db());
+    return gridfs_instance;
+};
+
+/**
+ * Wrap stream in promise.
+ * @param {Stream} stream - Stream to wrap
+ * @returns {Promise} Resolves on finish, rejects on error
+ */
+const stream_to_promise = (stream) => new Promise((resolve, reject) => {
+    stream.on('error', reject).on('finish', resolve);
+});
 
 class GridFS {
-    /**
-     * Connect to mongodb
-     * @param {url of mongo} url 
-     * @returns 
-     */
-    connect(url) {
-        return new Promise((resolve, reject) => {
-            MongoClient.connect(url, { useUnifiedTopology: true, useNewUrlParser: true }, (err, client) => {
-                if (err) return reject(err);
-                resolve(client);
-            });
-        });
+    constructor(db) {
+        this.db = db;
     }
 
     /**
-     * 
-     * @param {mongodb bucket name} bucketname 
-     * @param {the file name} filename 
-     * @param {the file path} filepath 
-     * @returns 
+     * Get GridFS bucket.
+     * @param {string} bucket_name - Bucket name
+     * @returns {GridFSBucket} Bucket instance
      */
-    async save_file(bucketname, filename, filepath) {
-        const bucket = new GridFSBucket(this.db, { chunkSizeBytes: 1024 * 1024, bucketName: bucketname });
-        const files = await bucket.find({ filename: filename }).toArray();
-        if (files && files.length > 0) {
-            await delete_file(bucket, files[0]._id);
-        }
-        return new Promise((resolve, reject) => {
-            if (typeof filepath === 'string') {
-                fs.createReadStream(filepath).pipe(bucket.openUploadStream(filename))
-                    .on('error', err => reject(err))
-                    .on('finish', item => resolve(item));
-            } else {
-                filepath.pipe(bucket.openUploadStream(filename))
-                    .on('error', err => reject(err))
-                    .on('finish', item => resolve(item));
-            }
-        });
+    bucket(bucket_name) {
+        return new GridFSBucket(this.db, { chunkSizeBytes: CHUNK_SIZE, bucketName: bucket_name });
     }
 
     /**
-     * 
-     * @param {mongodb bucket name} bucketname 
-     * @param {the file name} filename 
-     * @param {http response} response 
+     * Save file to GridFS (replaces existing if found).
+     * @param {string} bucket_name - Bucket name
+     * @param {string} filename - File name
+     * @param {string|Stream} source - File path or readable stream
+     * @returns {Promise} Upload result
      */
-    read_file(bucketname, filename, response) {
-        const bucket = new GridFSBucket(this.db, { chunkSizeBytes: 1024 * 1024, bucketName: bucketname });
-        const stream = bucket.openDownloadStreamByName(filename);
-        stream.on('data', (chunk) => {
-            response.write(chunk);
-        });
-        stream.on('error', () => {
-            response.sendStatus(404);
-        });
-        stream.on('end', () => {
-            response.end();
-        });
+    async save_file(bucket_name, filename, source) {
+        const bucket = this.bucket(bucket_name);
+
+        // Delete existing file if present
+        const existing = await bucket.find({ filename }).toArray();
+        if (existing.length > 0) {
+            await bucket.delete(existing[0]._id);
+        }
+
+        // Create read stream from path if string
+        const read_stream = typeof source === 'string' ? fs.createReadStream(source) : source;
+        return stream_to_promise(read_stream.pipe(bucket.openUploadStream(filename)));
     }
 
     /**
-     * 
-     * @param {mongodb bucket name} bucketname
-     * @param {the file name} filename
-     * @param {the dest file name} dest_file 
+     * Stream file to HTTP response.
+     * @param {string} bucket_name - Bucket name
+     * @param {string} filename - File name
+     * @param {Response} response - HTTP response object
      */
-    async pipe_file(bucketname, filename, dest_filename) {
-        const bucket = new GridFSBucket(this.db, { chunkSizeBytes: 1024 * 1024, bucketName: bucketname });
-        const stream = bucket.openDownloadStreamByName(filename);
-        const write_stream = require("fs").createWriteStream(dest_filename);
-
-        return new Promise((resolve, reject) => {
-            stream.pipe(write_stream)
-                .on('error', err => reject(err))
-                .on('finish', item => resolve(item));
-        });
+    read_file(bucket_name, filename, response) {
+        const stream = this.bucket(bucket_name).openDownloadStreamByName(filename);
+        stream.on('data', chunk => response.write(chunk));
+        stream.on('error', () => response.sendStatus(404));
+        stream.on('end', () => response.end());
     }
 
     /**
-     * Delete the files by file name
-     * @param {bucket name} bucketname 
-     * @param {file name} filename 
+     * Pipe file from GridFS to disk.
+     * @param {string} bucket_name - Bucket name
+     * @param {string} filename - Source file name
+     * @param {string} dest_path - Destination file path
+     * @returns {Promise} Pipe result
      */
-    async delete_files(bucketname, filename) {
-        const bucket = new GridFSBucket(this.db, { chunkSizeBytes: 1024 * 1024, bucketName: bucketname });
-        const files = await bucket.find({ filename: filename }).toArray();
-        if (files && files.length > 0) {
-            await delete_file(bucket, files[0]._id);
-        }
+    pipe_file(bucket_name, filename, dest_path) {
+        const stream = this.bucket(bucket_name).openDownloadStreamByName(filename);
+        return stream_to_promise(stream.pipe(fs.createWriteStream(dest_path)));
     }
 
     /**
-     * Delete the file using id
-     * @param {mongodb bucket name} bucket 
-     * @param {id of the file} id 
-     * @returns 
+     * Delete file by name.
+     * @param {string} bucket_name - Bucket name
+     * @param {string} filename - File name
      */
-    delete_file(bucket, id) {
-        return new Promise((resolve, reject) => {
-            bucket.delete(id, (async (err) => {
-                if (err) {
-                    reject(err);
-                } else {
-                    resolve(true);
-                }
-            }));
-        });
+    async delete_file(bucket_name, filename) {
+        const bucket = this.bucket(bucket_name);
+        const files = await bucket.find({ filename }).toArray();
+        if (files.length > 0) {
+            await bucket.delete(files[0]._id);
+        }
     }
 }
 
 /**
- * set file fields of the entity
- * @param {meta info} meta 
- * @param {http request} req 
- * @param {entity object} obj 
+ * Set file field values on entity object based on uploaded files.
+ * @param {Object} meta - Entity meta info
+ * @param {Request} req - HTTP request
+ * @param {Object} obj - Entity object
  */
-const set_file_fields = function (meta, req, obj) {
-    const file_fields = meta.file_fields;
-
-    if (file_fields && file_fields.length > 0 && req.files) {
-        const primary_key = meta.primary_keys.map(key => obj[key]).join("_");
-        file_fields.forEach(function (field) {
-            const files = req.files[field.name];
-
-            if (files && files.length > 0) {
-                if (file_fields.length == 1) {
-                    obj[field.name] = primary_key;
-                } else {
-                    obj[field.name] = primary_key + "_" + field.name;
-                }
-            } else {
-                delete obj[field.name];
-            }
-        });
+const set_file_fields = (meta, req, obj) => {
+    const { file_fields, primary_keys } = meta;
+    if (!file_fields?.length || !req.files) return;
+
+    const primary_key = primary_keys.map(key => obj[key]).join('_');
+
+    for (const field of file_fields) {
+        const files = req.files[field.name];
+        if (files?.length > 0) {
+            obj[field.name] = file_fields.length === 1 ? primary_key : `${primary_key}_${field.name}`;
+        } else {
+            delete obj[field.name];
+        }
     }
-}
+};
 
 /**
- * 
- * @param {mongodb collection name} collection 
- * @param {file fields of the entity} file_fields 
- * @param {http request object} req 
- * @param {entity object} obj 
+ * Save uploaded file fields to GridFS.
+ * @param {string} collection - MongoDB collection name
+ * @param {Object[]} file_fields - File field definitions
+ * @param {Request} req - HTTP request
+ * @param {Object} obj - Entity object
  */
-const save_file_fields_to_db = async function (collection, file_fields, req, obj) {
-    if (file_fields && file_fields.length > 0 && req.files) {
-        for (let i = 0; i < file_fields.length; i++) {
-            const field = file_fields[i];
-            if (obj[field.name]) {
-                const file = req.files[field.name][0];
-                const instance = await get_gridfs_instance();
-                await instance.save_file(collection, obj[field.name], file.path);
-                fs.unlinkSync(file.path);
-            }
-        }
+const save_file_fields_to_db = async (collection, file_fields, req, obj) => {
+    if (!file_fields?.length || !req.files) return;
+
+    const instance = await get_gridfs_instance();
+
+    for (const field of file_fields) {
+        if (!obj[field.name]) continue;
+
+        const [file] = req.files[field.name];
+        await instance.save_file(collection, obj[field.name], file.path);
+        fs.unlinkSync(file.path);
     }
-}
+};
 
-/**
- * Save file to gridfs file
- * @param {collection name} collection 
- * @param {file name} filename 
- * @param {file full path} filepath 
- */
+// Wrapper functions for external API
 const save_file = async (collection, filename, filepath) => {
     const instance = await get_gridfs_instance();
     await instance.save_file(collection, filename, filepath);
-}
+};
 
-/**
- * read file from gridfs
- * @param {collection name} collection 
- * @param {file name} filename 
- * @param {http response} response
- */
 const read_file = async (collection, filename, response) => {
     const instance = await get_gridfs_instance();
-    await instance.read_file(collection, filename, response);
-}
+    instance.read_file(collection, filename, response);
+};
 
-/**
- * pipe file from gridfs
- * @param {collection name} collection 
- * @param {file name} filename 
- * @param {dest file name} dest_filename
- */
 const pipe_file = async (collection, filename, dest_filename) => {
     const instance = await get_gridfs_instance();
     await instance.pipe_file(collection, filename, dest_filename);
-}
+};
 
-/**
- * delete file from gridfs
- * @param {collection name} collection 
- * @param {file name} filename 
- */
 const delete_file = async (collection, filename) => {
     const instance = await get_gridfs_instance();
-    await instance.delete_files(collection, filename);
-}
+    await instance.delete_file(collection, filename);
+};
 
 module.exports = { set_file_fields, save_file_fields_to_db, save_file, read_file, pipe_file, delete_file };

package/design/add_default_field_attr.md

@@ -0,0 +1,56 @@
+# Default Field Attribute
+
+Added `default` attribute support to meta field definitions for automatic value population during create operations.
+
+## Changes
+
+### Server: `core/meta.js`
+
+1. Added `default` to `FIELD_ATTRS` array
+2. Added validation in `validate_field`:
+   - Validates default value against field type using `type.convert()`
+   - Throws error if default value is invalid for the field type
+
+```javascript
+// Validate default value against field type
+if (field.default !== undefined && field.type) {
+    const type = get_type(field.type);
+    const result = type.convert(field.default);
+    if (result.err) throw meta_error(meta.collection, `invalid default value...`);
+}
+```
+
+### Client: `components/BasicForm.vue`
+
+1. Added `apply_defaults(form)` method that applies default values to empty form fields
+2. Called during initialization and form prop changes
+
+```javascript
+apply_defaults(form) {
+    const result = { ...form };
+    for (const field of this.fields) {
+        if (field.default !== undefined && 
+            (result[field.name] === undefined || result[field.name] === null || result[field.name] === "")) {
+            result[field.name] = field.default;
+        }
+    }
+    return result;
+}
+```
+
+## Usage
+
+```javascript
+{
+    collection: "products",
+    primary_keys: ["name"],
+    fields: [
+        { name: "name", type: "string", required: true },
+        { name: "quantity", type: "int", default: 0 },
+        { name: "active", type: "boolean", default: true },
+        { name: "price", type: "float", default: 9.99 }
+    ]
+}
+```
+
+When creating a new product, form fields automatically populate with their defined default values.

package/http/context.js

@@ -1,17 +1,31 @@
+/**
+ * @fileoverview Request context management using AsyncLocalStorage.
+ * @module http/context
+ */
+
 const { AsyncLocalStorage } = require('async_hooks');
 const asyncLocalStorage = new AsyncLocalStorage();
 
+/**
+ * Set value in current request context.
+ * @param {string} key - Context key
+ * @param {*} obj - Value to store
+ */
 const set_context_value = (key, obj) => {
     const store = asyncLocalStorage.getStore();
-    store && (store[key] = obj);
-}
+    if (store) {
+        store[key] = obj;
+    }
+};
 
+/**
+ * Get value from current request context.
+ * @param {string} key - Context key
+ * @returns {*} Stored value or null
+ */
 const get_context_value = (key) => {
     const store = asyncLocalStorage.getStore();
-    if (!store) {
-        return null;
-    }
-    return store[key];
-}
+    return store ? store[key] : null;
+};
 
-module.exports = { asyncLocalStorage, set_context_value, get_context_value }
+module.exports = { asyncLocalStorage, set_context_value, get_context_value };

package/http/cors.js

@@ -1,15 +1,32 @@
+/**
+ * @fileoverview CORS middleware initialization.
+ * @module http/cors
+ */
+
 const cors = require('cors');
 const { get_settings } = require('../setting');
 
+/**
+ * Initialize CORS middleware with client URL whitelist.
+ * @param {Object} app - Express application instance
+ * @throws {Error} If server settings are missing
+ */
 const init_cors = (app) => {
-    const server = get_settings().server;
-    if (server && server.client_web_url) {
-        app.use(cors({
-            origin: server.client_web_url,
-            methods: ['GET', 'POST'],
-            credentials: true
-        }));
+    const settings = get_settings();
+    if (!settings?.server) {
+        throw new Error('Server settings required for CORS initialization');
+    }
+
+    const client_urls = settings.server.client_web_url;
+    if (!Array.isArray(client_urls)) {
+        return;
     }
-}
+
+    app.use(cors({
+        origin: client_urls,
+        methods: ['GET', 'POST'],
+        credentials: true
+    }));
+};
 
 module.exports = { init_cors };

package/http/error.js

@@ -1,21 +1,39 @@
+/**
+ * @fileoverview Error handling middleware and utilities.
+ * @module http/error
+ */
+
 const { ERROR } = require('./code');
 const { LOG_SYSTEM, is_log_error, log_error } = require('../db/db');
 
+/**
+ * Wrap async route handler to catch errors.
+ * @param {Function} fn - Async route handler
+ * @returns {Function} Wrapped handler
+ */
 const wrap_http = fn => (...args) => fn(...args).catch(args[2]);
 
+/**
+ * Global error handler middleware.
+ * Logs errors when enabled and returns standardized error response.
+ * @param {Object} app - Express application instance
+ */
 const handle_exception = app => {
     app.use(function (error, req, res, next) {
-        if (is_log_error()) {
-            if (error) {
-                const error_msg = error.stack ? error.stack : JSON.stringify(error);
-                log_error(LOG_SYSTEM, error_msg);
+        if (error) {
+            const error_msg = error.stack || error.message || JSON.stringify(error);
+
+            if (is_log_error()) {
+                log_error(LOG_SYSTEM, error_msg, { path: req.originalUrl, method: req.method });
+            } else {
+                console.error('[Error]', error_msg);
             }
-        } else {
-            throw new Error(error);
         }
 
-        res.json({ code: ERROR, err: "errors occur in server" });
+        if (!res.headersSent) {
+            res.json({ code: ERROR, err: "server error" });
+        }
     });
-}
+};
 
-module.exports = { wrap_http, handle_exception }
+module.exports = { wrap_http, handle_exception };

package/http/express.js

@@ -1,9 +1,15 @@
+/**
+ * @fileoverview Express server initialization and configuration.
+ * @module http/express
+ */
+
 const express = require('express');
 
 const { init_cors } = require('./cors');
 const { NO_SESSION } = require('./code');
-const { init_session, get_session_userid } = require('./session');
+const { init_session, get_session_user_id } = require('./session');
 const { init_router_dirs } = require('./router');
+const { ensure_entity_indexes } = require('../db/db');
 const { handle_exception } = require('./error');
 const { get_settings } = require('../setting');
 const { asyncLocalStorage, set_context_value } = require('./context');
@@ -11,65 +17,88 @@ const { asyncLocalStorage, set_context_value } = require('./context');
 const app = express();
 let server_initialized = false;
 
+/**
+ * Check if URL is in the excluded list.
+ * @param {Object} server - Server settings
+ * @param {Object} req - Express request
+ * @returns {boolean} True if URL should be excluded from auth
+ */
 const is_excluded_url = (server, req) => {
-    const exclude_urls = server.exclude_urls;
-    for (let i = 0; i < exclude_urls.length; i++) {
-        const re = new RegExp(exclude_urls[i], "gim");
-        if (re.test(req.originalUrl)) {
-            return true;
+    const patterns = server.exclude_urls;
+    if (!Array.isArray(patterns)) {
+        return false;
+    }
+    return patterns.some(pattern => new RegExp(pattern, "i").test(req.originalUrl));
+};
+
+/**
+ * Configure body parser middleware with optional size limit.
+ * @param {Object} app - Express application
+ * @param {string|undefined} body_limit - Optional body size limit
+ */
+const configure_body_parser = (app, body_limit) => {
+    const options = body_limit ? { limit: body_limit, extended: true } : { extended: true };
+    app.use(express.json(options));
+    app.use(express.urlencoded(options));
+};
+
+/**
+ * Create authentication middleware.
+ * @param {Object} server - Server settings
+ * @returns {Function} Express middleware
+ */
+const create_auth_middleware = (server) => (req, res, next) => {
+    if (server.check_user && !is_excluded_url(server, req)) {
+        if (!get_session_user_id(req)) {
+            res.json({ code: NO_SESSION, err: "authentication required" });
+            return;
         }
     }
 
-    return false;
-}
+    asyncLocalStorage.run({}, () => {
+        set_context_value("req", req);
+        next();
+    });
+};
 
+/**
+ * Initialize Express server with middleware and routes.
+ * @param {string} base_dir - Base directory for router files
+ * @param {string} port_attr - Port attribute name in settings
+ * @param {Function} [callback] - Optional callback after server starts
+ * @returns {Object} Express app instance
+ * @throws {Error} If server settings are invalid
+ */
 const init_express_server = (base_dir, port_attr, callback) => {
-    if (server_initialized === true) {
+    if (server_initialized) {
         return app;
     }
 
-    const server = get_settings().server;
-    const threshold = server.threshold;
-
-    init_cors(app);
+    const settings = get_settings();
+    if (!settings?.server) {
+        throw new Error('Server settings required for initialization');
+    }
 
-    if (threshold) {
-        app.use(express.json({ limit: threshold.body_limit, extended: true }));
-        app.use(express.urlencoded({ limit: threshold.body_limit, extended: true }));
+    const { server } = settings;
+    const port = server[port_attr];
+    if (!port) {
+        throw new Error(`Port attribute '${port_attr}' not found in server settings`);
     }
 
+    init_cors(app);
+    configure_body_parser(app, server.threshold?.body_limit);
     init_session(app);
-
-    app.use((req, res, next) => {
-        if (server.check_user && !is_excluded_url(server, req)) {
-            const user_id = get_session_userid(req);
-            if (user_id == null) {
-                res.json({ code: NO_SESSION, err: "no session found" });
-            } else {
-                asyncLocalStorage.run({}, () => {
-                    set_context_value("req", req);
-                    next();
-                });
-            }
-        } else {
-            asyncLocalStorage.run({}, () => {
-                set_context_value("req", req);
-                next();
-            });
-        }
-    });
-
+    app.use(create_auth_middleware(server));
     init_router_dirs(app, base_dir);
+    ensure_entity_indexes();
     handle_exception(app);
 
-    app.listen(server[port_attr], async function () {
-        if (callback) {
-            await callback();
-        }
+    app.listen(port, async () => {
+        if (callback) await callback();
     });
 
     server_initialized = true;
     return app;
-}
+};
 
 module.exports = { init_express_server };