hola-server 1.0.11 → 2.0.1

package/core/type.js

@@ -1,329 +1,368 @@
+/**
+ * @fileoverview Type conversion and validation system.
+ * @module core/type
+ */
+
 const { has_value, is_undefined } = require('./validate');
 const { encrypt_pwd } = require('./encrypt');
+
 const type_manager = {};
 
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
 /**
- * register your use type
- * @param {type object to do validation and type conversion} type 
+ * Create success result.
+ * @param {*} value - Converted value.
+ * @returns {{value: *}} Success result.
  */
-const register_type = type => {
-    type_manager[type.name] = type;
-}
-
-const convert_number = (value, type) => {
-    const num_value = Number(value);
-    if (isNaN(num_value)) {
-        return { err: 'convert error for value:' + value + ",and type:" + type };
-    } else {
-        return { value: num_value };
-    }
-}
-
-const convert_float = (value, type) => {
-    const float_value = parseFloat(value);
-    if (isNaN(float_value)) {
-        return { err: 'convert error for value:' + value + ",and type:" + type };
-    } else {
-        return { value: parseFloat(float_value.toFixed(2)) };
-    }
-}
+const ok = (value) => ({ value });
 
 /**
- * get your user type
- * @param {type name} name 
- * @returns 
+ * Create error result.
+ * @param {string} type - Type name.
+ * @param {*} value - Original value.
+ * @returns {{err: string}} Error result.
  */
-const get_type = name => {
-    const type = type_manager[name];
-    if (type) {
-        return type;
-    } else {
-        throw new Error('no type registered for name [' + name + ']');
+const err = (type, value) => ({ err: `invalid ${type}:${value}` });
+
+/**
+ * Check if value is an integer.
+ * @param {*} value - Value to check.
+ * @returns {boolean} True if integer.
+ */
+const is_int = (value) => parseInt(value) === parseFloat(value);
+
+/**
+ * Create a regex validation type.
+ * @param {string} name - Type name.
+ * @param {RegExp} pattern - Regex pattern.
+ * @returns {Object} Type definition.
+ */
+const regex_type = (name, pattern) => ({
+    name,
+    convert: (value) => pattern.test(value) ? ok(value) : err(name, value)
+});
+
+/**
+ * Create an integer range validation type.
+ * @param {string} name - Type name.
+ * @param {number[]} valid_values - Array of valid values.
+ * @returns {Object} Type definition.
+ */
+const int_enum_type = (name, valid_values) => ({
+    name,
+    convert: (value) => {
+        if (!is_int(value)) return err(name, value);
+        const int_value = parseInt(value);
+        return valid_values.includes(int_value) ? ok(int_value) : err(name, value);
     }
-}
+});
 
-const obj_type = {
-    name: "obj",
-    convert: function (value) {
-        return value;
+/**
+ * Create an integer range validation type.
+ * @param {string} name - Type name.
+ * @param {number} min - Minimum value.
+ * @param {number} max - Maximum value.
+ * @returns {Object} Type definition.
+ */
+const int_range_type = (name, min, max) => ({
+    name,
+    convert: (value) => {
+        if (!is_int(value)) return err(name, value);
+        const int_value = parseInt(value);
+        return (int_value >= min && int_value <= max) ? ok(int_value) : err(name, value);
     }
-}
+});
 
-register_type(obj_type);
+/**
+ * Create a passthrough string type.
+ * @param {string} name - Type name.
+ * @returns {Object} Type definition.
+ */
+const string_type = (name) => ({ name, convert: (value) => ok(value + "") });
+
+// ============================================================================
+// Type Registration
+// ============================================================================
+
+/**
+ * Register a custom type with conversion function.
+ * @param {Object} type - Type definition with name and convert function.
+ */
+const register_type = (type) => { type_manager[type.name] = type; };
 
-const boolean_type = {
+/**
+ * Get registered type by name.
+ * @param {string} name - Type name.
+ * @returns {Object} Type definition.
+ * @throws {Error} If type not registered.
+ */
+const get_type = (name) => {
+    const type = type_manager[name];
+    if (!type) throw new Error(`no type registered for name [${name}]`);
+    return type;
+};
+
+// ============================================================================
+// Built-in Types: Basic
+// ============================================================================
+
+register_type({ name: "obj", convert: ok });
+register_type({ name: "string", convert: (value) => ok(value ? (value + "").trim() : "") });
+register_type({ name: "password", convert: (value) => ok(encrypt_pwd(value)) });
+register_type({ name: "file", convert: ok });
+
+// Passthrough string types
+register_type(string_type("lstr"));
+register_type(string_type("text"));
+register_type(string_type("date"));
+register_type(string_type("enum"));
+register_type(string_type("log_category"));
+
+// ============================================================================
+// Built-in Types: Boolean
+// ============================================================================
+
+register_type({
     name: "boolean",
-    convert: function (value) {
-        if (value === true || value === "true") {
-            return { value: true };
-        } else if (value === false || value === "false") {
-            return { value: false };
-        } else {
-            return { err: 'boolean convert error for value:' + value };
-        }
+    convert: (value) => {
+        if (value === true || value === "true") return ok(true);
+        if (value === false || value === "false") return ok(false);
+        return err("boolean", value);
     }
-}
+});
 
-register_type(boolean_type);
+// ============================================================================
+// Built-in Types: Numeric
+// ============================================================================
 
-const is_int = (value) => {
-    return parseInt(value) == parseFloat(value);
-}
-const int_type = {
-    name: "int",
-    convert: function (value) {
-        return is_int(value) ? { value: parseInt(value) } : { err: 'int convert error for value:' + value };
+register_type({
+    name: "number",
+    convert: (value) => {
+        const num = Number(value);
+        return isNaN(num) ? err("number", value) : ok(num);
     }
-}
+});
 
-register_type(int_type);
+register_type({
+    name: "int",
+    convert: (value) => is_int(value) ? ok(parseInt(value)) : err("int", value)
+});
 
-const uint_type = {
+register_type({
     name: "uint",
-    convert: function (value) {
+    convert: (value) => {
         const int_value = parseInt(value);
-        return is_int(value) && int_value >= 0 ? { value: int_value } : { err: 'int convert error for value:' + value };
+        return (is_int(value) && int_value >= 0) ? ok(int_value) : err("uint", value);
     }
-}
+});
 
-register_type(uint_type);
-
-const float_type = {
+register_type({
     name: "float",
-    convert: function (value) {
-        return convert_float(value, "float");
+    convert: (value) => {
+        const num = parseFloat(value);
+        return isNaN(num) ? err("float", value) : ok(parseFloat(num.toFixed(2)));
     }
-}
-
-register_type(float_type);
+});
 
-const ufloat_type = {
+register_type({
     name: "ufloat",
-    convert: function (value) {
-        const float_value = parseFloat(value);
-        if (isNaN(float_value) || float_value < 0) {
-            return { err: 'float convert error for value:' + value };
-        } else {
-            return { value: parseFloat(float_value.toFixed(2)) };
-        }
+    convert: (value) => {
+        const num = parseFloat(value);
+        return (isNaN(num) || num < 0) ? err("ufloat", value) : ok(parseFloat(num.toFixed(2)));
     }
-}
-
-register_type(ufloat_type);
+});
 
-const number_type = {
-    name: "number",
-    convert: function (value) {
-        return convert_number(value, "number");
+register_type({
+    name: "decimal",
+    convert: (value) => {
+        const num = parseFloat(value);
+        return isNaN(num) ? err("decimal", value) : ok(num);
     }
-}
+});
 
-register_type(number_type);
-
-const string_type = {
-    name: "string",
-    convert: function (value) {
-        return { value: value ? (value + "").trim() : "" };
+register_type({
+    name: "percentage",
+    convert: (value) => {
+        const num = parseFloat(value);
+        return isNaN(num) ? err("percentage", value) : ok(parseFloat(num.toFixed(2)));
     }
-}
+});
 
-register_type(string_type);
-
-const password_type = {
-    name: "password",
-    convert: function (value) {
-        return { value: encrypt_pwd(value) };
+register_type({
+    name: "currency",
+    convert: (value) => {
+        const num = Number(value);
+        return isNaN(num) ? err("currency", value) : ok(num);
     }
-}
+});
 
-register_type(password_type);
+// ============================================================================
+// Built-in Types: Date/Time
+// ============================================================================
 
-const file_type = {
-    name: "file",
-    convert: function (value) {
-        return { value: value };
+register_type({
+    name: "datetime",
+    convert: (value) => {
+        const date = new Date(value);
+        return isNaN(date.getTime()) ? err("datetime", value) : ok(date.toISOString());
     }
-}
-
-register_type(file_type);
+});
 
-const array_type = {
-    name: "array",
-    convert: function (value) {
-        if (typeof value === "string") {
-            return { value: value.split(",") }
-        } else if (Array.isArray(value)) {
-            return { value: value }
-        } else {
-            return { err: "error array type" }
-        }
-    }
-}
+register_type(regex_type("time", /^([0-1]?[0-9]|2[0-3]):[0-5][0-9](:[0-5][0-9])?$/));
 
-register_type(array_type);
+// ============================================================================
+// Built-in Types: Validation
+// ============================================================================
 
-const lstr_type = {
-    name: "lstr",
-    convert: function (value) {
-        return { value: value + "" };
+register_type({
+    name: "email",
+    convert: (value) => {
+        const pattern = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+        return pattern.test(value) ? ok(value) : err("email", value);
     }
-}
-
-register_type(lstr_type);
+});
 
-const text_type = {
-    name: "text",
-    convert: function (value) {
-        return { value: value + "" };
+register_type({
+    name: "url",
+    convert: (value) => {
+        try { new URL(value); return ok(value); }
+        catch { return err("url", value); }
     }
-}
-
-register_type(text_type);
+});
 
-const date_type = {
-    name: "date",
-    convert: function (value) {
-        return { value: value + "" };
-    }
-}
-
-register_type(date_type);
-
-const age_type = {
-    name: "age",
-    convert: function (value) {
-        if (is_int(value)) {
-            const int_value = parseInt(value);
-            if (int_value < 0 || int_value > 200) {
-                return { err: "invalid age value:" + value };
-            } else {
-                return { value: int_value };
-            }
-        } else {
-            return { err: "age isn't int type:" + value };
-        }
+register_type({
+    name: "phone",
+    convert: (value) => {
+        const cleaned = value.replace(/[\s\-\(\)]/g, '');
+        return /^\+?[1-9]\d{1,14}$/.test(cleaned) ? ok(cleaned) : err("phone", value);
     }
-}
-
-register_type(age_type);
-
-const gender_type = {
-    name: "gender",
-    convert: function (value) {
-        if (is_int(value)) {
-            const int_value = parseInt(value);
-            if (int_value == 0 || int_value == 1) {
-                return { value: int_value };
-            } else {
-                return { err: "invalid gender value:" + value }
-            }
-        } else {
-            return { err: "gender isn't int type:" + value };
-        }
-    }
-}
-
-register_type(gender_type);
-
-const log_level_type = {
-    name: "log_level",
-    convert: function (value) {
-        if (is_int(value)) {
-            const int_value = parseInt(value);
-            if (int_value == 0 || int_value == 1 || int_value == 2 || int_value == 3) {
-                return { value: int_value };
-            } else {
-                return { err: "invalid level value:" + value }
-            }
-        } else {
-            return { err: "log level isn't int type:" + value };
-        }
-    }
-}
+});
 
-register_type(log_level_type);
+register_type(regex_type("uuid", /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i));
+register_type(regex_type("color", /^#([0-9A-F]{3}){1,2}$/i));
 
-const log_category_type = {
-    name: "log_category",
-    convert: function (value) {
-        return { value: value + "" };
+register_type({
+    name: "ip_address",
+    convert: (value) => {
+        if (!/^(\d{1,3}\.){3}\d{1,3}$/.test(value)) return err("ip_address", value);
+        const valid = value.split('.').every(part => parseInt(part) <= 255);
+        return valid ? ok(value) : err("ip_address", value);
     }
-}
+});
 
-register_type(log_category_type);
+// ============================================================================
+// Built-in Types: Data Structures
+// ============================================================================
 
-const percentage_type = {
-    name: "percentage",
-    convert: function (value) {
-        return convert_float(value, "percentage");
+register_type({
+    name: "array",
+    convert: (value) => {
+        if (typeof value === "string") return ok(value.split(","));
+        if (Array.isArray(value)) return ok(value);
+        return err("array", value);
     }
-}
-
-register_type(percentage_type);
-
-const currency_type = {
-    name: "currency",
-    convert: function (value) {
-        return convert_number(value, "currency");
+});
+
+register_type({
+    name: "json",
+    convert: (value) => {
+        if (typeof value === 'object') return ok(value);
+        try { return ok(JSON.parse(value)); }
+        catch { return err("json", value); }
     }
-}
+});
 
-register_type(currency_type);
+// ============================================================================
+// Built-in Types: Transformations
+// ============================================================================
 
-const email_type = {
-    name: "email",
-    convert: function (value) {
-        const pattern = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/
-        if (pattern.test(value)) {
-            return { value: value };
-        } else {
-            return { err: 'err email for value:' + value };
-        }
-    }
-}
+register_type({
+    name: "slug",
+    convert: (value) => ok(value.toString().toLowerCase().trim()
+        .replace(/\s+/g, '-')
+        .replace(/[^\w\-]+/g, '')
+        .replace(/\-\-+/g, '-'))
+});
 
-register_type(email_type);
+// ============================================================================
+// Built-in Types: Domain-Specific
+// ============================================================================
 
-const convert_type = function (obj, fields) {
-    const result = {};
-    const error_field_names = [];
+register_type(int_range_type("age", 0, 200));
+register_type(int_enum_type("gender", [0, 1]));
+register_type(int_enum_type("log_level", [0, 1, 2, 3]));
 
-    fields.forEach(function (field) {
-        const field_value = obj[field.name];
-        if (has_value(field_value)) {
-            const type_name = field.type ? field.type : "string";
-            const type = get_type(type_name);
-            const { value, err } = type.convert(field_value);
-            if (err) {
-                error_field_names.push(field.name);
-            } else {
-                result[field.name] = value;
-            }
-        }
-    });
-    return { obj: result, error_field_names: error_field_names };
-}
+// ============================================================================
+// Conversion Functions
+// ============================================================================
+
+/**
+ * Convert a single field value.
+ * @param {*} field_value - Value to convert.
+ * @param {string} type_name - Type name.
+ * @returns {{value?: *, err?: string}} Conversion result.
+ */
+const convert_field = (field_value, type_name) => {
+    const type = get_type(type_name || "string");
+    return type.convert(field_value);
+};
 
-const convert_update_type = function (obj, fields) {
+/**
+ * Convert object fields to their defined types.
+ * @param {Object} obj - Object with values to convert.
+ * @param {Array<{name: string, type?: string}>} fields - Field definitions.
+ * @param {boolean} preserve_empty - Whether to preserve empty values as "".
+ * @returns {{obj: Object, error_field_names: string[]}} Converted object and error fields.
+ */
+const convert_fields = (obj, fields, preserve_empty = false) => {
     const result = {};
     const error_field_names = [];
 
-    fields.forEach(function (field) {
+    for (const field of fields) {
         const field_value = obj[field.name];
+
         if (has_value(field_value)) {
-            const type_name = field.type ? field.type : "string";
-            const type = get_type(type_name);
-            const { value, err } = type.convert(field_value);
-            if (err) {
-                error_field_names.push(field.name);
-            } else {
-                result[field.name] = value;
-            }
-        } else if (!is_undefined(field_value)) {
+            const { value, err } = convert_field(field_value, field.type);
+            if (err) error_field_names.push(field.name);
+            else result[field.name] = value;
+        } else if (preserve_empty && !is_undefined(field_value)) {
             result[field.name] = "";
         }
-    });
-    return { obj: result, error_field_names: error_field_names };
-}
+    }
+
+    return { obj: result, error_field_names };
+};
 
-module.exports = { register_type, convert_type, convert_update_type, get_type }
+/**
+ * Convert object fields to their defined types.
+ * @param {Object} obj - Object with values to convert.
+ * @param {Array<{name: string, type?: string}>} fields - Field definitions.
+ * @returns {{obj: Object, error_field_names: string[]}} Converted object and error fields.
+ */
+const convert_type = (obj, fields) => convert_fields(obj, fields, false);
+
+/**
+ * Convert object fields for update operation (preserves empty values).
+ * @param {Object} obj - Object with values to convert.
+ * @param {Array<{name: string, type?: string}>} fields - Field definitions.
+ * @returns {{obj: Object, error_field_names: string[]}} Converted object and error fields.
+ */
+const convert_update_type = (obj, fields) => convert_fields(obj, fields, true);
+
+module.exports = {
+    register_type,
+    convert_type,
+    convert_update_type,
+    get_type,
+    // Helper functions for custom type creation
+    ok,
+    err,
+    is_int,
+    regex_type,
+    int_enum_type,
+    int_range_type,
+    string_type
+};

package/core/url.js

@@ -1,22 +1,30 @@
+/**
+ * @fileoverview URL and HTTP request utility functions.
+ * @module core/url
+ */
+
 const axios = require('axios');
 const { get_settings } = require("../setting");
 
-const url = function (url, method) {
+/**
+ * Create HTTP request function with preset URL and method.
+ * @param {string} url - Request URL.
+ * @param {string} method - HTTP method (GET, POST, etc.).
+ * @returns {Function} Function that accepts config and returns axios promise.
+ */
+const url = (url, method) => {
     const settings = get_settings();
     const axios_config = settings.axios;
 
-    return function (config) {
-        let params = {
-            url: url,
-            method: method,
-            validateStatus: false
+    return (config) => {
+        const params = {
+            url,
+            method,
+            validateStatus: false,
+            ...(axios_config.proxy && { proxy: axios_config.proxy })
         };
-        if (axios_config.proxy) {
-            params.proxy = axios_config.proxy;
-        }
         return axios.request({ ...params, ...config });
-    }
+    };
 };
 
-
-module.exports = { url }
+module.exports = { url };