goaded.utils 1.0.0 → 1.1.0

package/db.js

@@ -14,7 +14,6 @@ class Db {
         const db = this.db;
         const tableName = name.toLowerCase() + 's';
         const definition = schema.definition;
-
         const createTableSql = `
             CREATE TABLE IF NOT EXISTS ${tableName} (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -24,46 +23,94 @@ class Db {
 
         const tableReady = new Promise((resolve, reject) => {
             db.run(createTableSql, (err) => {
-                if (err) {
-                    console.error(`Error creating table ${tableName}:`, err.message);
-                    reject(err);
-                } else {
-                    resolve();
-                }
+                if (err) reject(err);
+                else resolve();
             });
         });
 
+        const hydrate = (value, type) => {
+            if (value === undefined || value === null) return value;
+
+            if (Array.isArray(type)) {
+                if (!Array.isArray(value)) return []; 
+                const InnerType = type[0];
+                return value.map(item => hydrate(item, InnerType));
+            }
+
+            const isPrimitive = [String, Number, Boolean, Object, Date].includes(type);
+            
+            if (!isPrimitive && typeof type === 'function') {
+                if (value instanceof type) return value;
+                
+                try {
+                    return new type(value);
+                } catch (e) {
+                    console.warn(`Could not hydrate type ${type.name}`, e);
+                    return value;
+                }
+            }
+
+            return value;
+        };
+
+        const validateValue = (key, value, rule) => {
+            const type = rule.type || rule;
+            if (rule.required && (value === undefined || value === null || value === '')) {
+                return `Path \`${key}\` is required.`;
+            }
+            if (value === undefined || value === null) return null; 
+
+            if (Array.isArray(type)) {
+                if (!Array.isArray(value)) return `Path \`${key}\` must be an Array.`;
+                const InnerType = type[0];
+                for (let i = 0; i < value.length; i++) {
+                    const error = validateValue(`${key}[${i}]`, value[i], { ...rule, type: InnerType, required: false });
+                    if (error) return error;
+                }
+                return null;
+            }
+
+            if (type === String && typeof value !== 'string') return `Path \`${key}\` must be a String`;
+            if (type === Number && isNaN(value)) return `Path \`${key}\` must be a Number`;
+            if (type === Boolean && typeof value !== 'boolean') return `Path \`${key}\` must be a Boolean`;
+
+            const isPrimitive = [String, Number, Boolean, Object, Date].includes(type);
+            if (!isPrimitive && typeof type === 'function') {
+                if (!(value instanceof type)) {
+                    if (value && typeof value === 'object' && typeof type.validate === 'function') {
+                         try { type.validate(value); } 
+                         catch(e) { return `Validation failed in nested ${type.name}: ${e.message}`; }
+                    } else {
+                        return `Path \`${key}\` must be instance of ${type.name}`;
+                    }
+                }
+            }
+            
+            return null;
+        };
+
         return class Model {
             constructor(data) {
-                this._data = {}; 
+                this._data = {};
                 
                 Object.keys(definition).forEach(key => {
                     const rule = definition[key];
-                    const inputVal = data[key];
+                    let inputVal = data[key];
+                    const type = rule.type || rule;
 
                     if (inputVal === undefined && rule.default !== undefined) {
-                        this._data[key] = typeof rule.default === 'function' ? rule.default() : rule.default;
-                    } else if (inputVal !== undefined) {
-                        this._data[key] = inputVal;
+                        inputVal = typeof rule.default === 'function' ? rule.default() : rule.default;
+                    }
+                    if (inputVal !== undefined) {
+                         this._data[key] = hydrate(inputVal, type);
                     }
                 });
-                
-                if(data.id) this._data.id = data.id;
-            }
 
-            JSONify() {
-                console.log(this._data);
-                return this._data;
-            }
-
-            toJSON() {
-                return this._data;
-            }
+                if(data.id) this._data.id = data.id;
 
-            static createProxy(instance) {
-                return new Proxy(instance, {
+                return new Proxy(this, {
                     get(target, prop) {
-                        if (prop in target) return target[prop];
+                        if (prop in target) return target[prop]; 
                         return target._data[prop];
                     },
                     set(target, prop, value) {
@@ -71,44 +118,23 @@ class Db {
                             target._data[prop] = value;
                             return true;
                         }
-                        return true; 
+                        return true;
                     }
                 });
             }
 
+            toJSON() {
+                return this._data;
+            }
+
             static validate(dataObject) {
                 const errors = {};
                 Object.keys(definition).forEach(key => {
-                    let value = dataObject[key];
-                    const rules = definition[key];
-
-                    if (typeof value === 'string') {
-                        if (rules.trim) value = value.trim();
-                        if (rules.lowercase) value = value.toLowerCase();
-                        if (rules.uppercase) value = value.toUpperCase();
-                        dataObject[key] = value;
-                    }
-
-                    if (rules.required && (value === undefined || value === null || value === '')) {
-                        errors[key] = `Path \`${key}\` is required.`;
-                        return;
-                    }
-
-                    if (value === undefined || value === null) return; 
-
-                    if (rules.type === Number && isNaN(value)) errors[key] = "Not a number";
-                    if (rules.type === Boolean && typeof value !== 'boolean') errors[key] = "Not a boolean";
-
-                    if (rules.type === String) {
-                        if (rules.enum && !rules.enum.includes(value)) 
-                            errors[key] = `\`${value}\` is not allowed.`;
-                        if (rules.match && !rules.match.test(value)) 
-                            errors[key] = "Regex validation failed";
-                    }
-                    if (rules.type === Number) {
-                        if (rules.min !== undefined && value < rules.min) errors[key] = `Min ${rules.min}`;
-                        if (rules.max !== undefined && value > rules.max) errors[key] = `Max ${rules.max}`;
-                    }
+                    const rule = definition[key];
+                    const value = dataObject._data ? dataObject._data[key] : dataObject[key];
+                    
+                    const error = validateValue(key, value, rule);
+                    if (error) errors[key] = error;
                 });
 
                 if (Object.keys(errors).length > 0) throw { message: "Validation failed", errors };
@@ -116,9 +142,8 @@ class Db {
 
             async save() {
                 await tableReady;
-                
                 try {
-                    Model.validate(this._data);
+                    Model.validate(this);
                 } catch (e) {
                     return Promise.reject(e);
                 }
@@ -128,18 +153,16 @@ class Db {
                     const self = this; 
 
                     if (this._data.id) {
-                         const sql = `UPDATE ${tableName} SET info = ? WHERE id = ?`;
-                         db.run(sql, [jsonPayload, this._data.id], function(err) {
+                         db.run(`UPDATE ${tableName} SET info = ? WHERE id = ?`, [jsonPayload, this._data.id], (err) => {
                              if(err) reject(err);
                              else resolve(self); 
                          });
                     } else {
-                        const sql = `INSERT INTO ${tableName} (info) VALUES (?)`;
-                        db.run(sql, [jsonPayload], function(err) {
+                        db.run(`INSERT INTO ${tableName} (info) VALUES (?)`, [jsonPayload], function(err) {
                             if (err) reject(err);
                             else {
                                 self._data.id = this.lastID; 
-                                resolve(Model.createProxy(self)); 
+                                resolve(self); 
                             }
                         });
                     }
@@ -161,9 +184,7 @@ class Db {
                         }).filter(x => x).join(' AND ');
 
                         if(clauses) sql += ` WHERE ${clauses}`;
-                        keys.forEach(key => { 
-                            if(definition[key] || key === 'id') params.push(query[key]); 
-                        });
+                        keys.forEach(key => params.push(query[key])); 
                     }
 
                     db.all(sql, params, (err, rows) => {
@@ -172,7 +193,7 @@ class Db {
                             const results = rows.map(row => {
                                 const data = JSON.parse(row.info);
                                 data.id = row.id;
-                                return Model.createProxy(new Model(data));
+                                return new Model(data);
                             });
                             resolve(results);
                         }
@@ -181,10 +202,11 @@ class Db {
             }
 
             static async create(data) {
-                const instance = Model.createProxy(new Model(data));
+                const instance = new Model(data);
                 return await instance.save();
             }
         };
     }
 }
+
 module.exports = Db;

package/events.js

@@ -1,20 +1,52 @@
+/**
+ * A simple event emitter class that manages event subscriptions and emissions.
+ * Supports synchronous and asynchronous execution, one-time events, and repeated emissions.
+ */
 class emitter {
+    /**
+     * Internal storage for event listeners.
+     * @type {Array<{event: string, callback: Function}>}
+     */
     listeners = [];
-    
+
+    /**
+     * Creates a new instance of the emitter.
+     */
     constructor() {}
-    
+
+    /**
+     * Subscribes a callback function to a specific event.
+     * 
+     * @param {string} event - The name of the event to subscribe to.
+     * @param {Function} callback - The function to execute when the event is emitted.
+     * @returns {emitter} The current instance for chaining.
+     */
     on(event, callback) {
         this.listeners.push({event, callback});
         return this;
     }
-    
+
+    /**
+     * Unsubscribes a specific callback from an event.
+     * 
+     * @param {string} event - The name of the event.
+     * @param {Function} callback - The specific callback function to remove.
+     * @returns {emitter} The current instance for chaining.
+     */
     off(event, callback) {
         this.listeners = this.listeners.filter(
             listener => listener.event !== event || listener.callback !== callback
         );
         return this;
     }
-    
+
+    /**
+     * Subscribes to an event only once. The callback is removed after the first execution.
+     * 
+     * @param {string} event - The name of the event.
+     * @param {Function} callback - The function to execute once.
+     * @returns {emitter} The current instance for chaining.
+     */
     once(event, callback) {
         const wrappedCallback = (...args) => {
             callback(...args);
@@ -23,7 +55,15 @@ class emitter {
         this.on(event, wrappedCallback);
         return this;
     }
-    
+
+    /**
+     * Synchronously calls all listeners registered for the specified event.
+     * Errors in listeners are caught and logged, preventing the loop from breaking.
+     * 
+     * @param {string} event - The name of the event to emit.
+     * @param {...*} args - Arguments to pass to the callback functions.
+     * @returns {void}
+     */
     emit(event, ...args) {
         this.listeners.forEach(listener => {
             if(listener.event === event) {
@@ -35,7 +75,16 @@ class emitter {
             }
         });
     }
-    
+
+    /**
+     * Asynchronously calls all listeners registered for the specified event.
+     * Waits for all promises returned by listeners to resolve.
+     * 
+     * @async
+     * @param {string} event - The name of the event to emit.
+     * @param {...*} args - Arguments to pass to the callback functions.
+     * @returns {Promise<void>} A promise that resolves when all listeners have completed.
+     */
     async emitAsync(event, ...args) {
         const promises = this.listeners
             .filter(listener => listener.event === event)
@@ -43,7 +92,15 @@ class emitter {
         
         await Promise.all(promises);
     }
-    
+
+    /**
+     * Synchronously calls all listeners for an event and then immediately removes them.
+     * This effectively "flushes" the listeners for that specific event.
+     * 
+     * @param {string} event - The name of the event.
+     * @param {...*} args - Arguments to pass to the callback functions.
+     * @returns {void}
+     */
     emitOnce(event, ...args) {
         this.listeners = this.listeners.filter(listener => {
             if(listener.event === event) {
@@ -52,12 +109,20 @@ class emitter {
                 } catch(error) {
                     console.error(`Error in event listener for "${event}":`, error);
                 }
-                return false;
+                return false; // Remove listener
             }
-            return true;
+            return true; // Keep listener
         });
     }
-    
+
+    /**
+     * Asynchronously calls all listeners for an event and then removes them.
+     * 
+     * @async
+     * @param {string} event - The name of the event.
+     * @param {...*} args - Arguments to pass to the callback functions.
+     * @returns {Promise<void>} A promise that resolves when all listeners have completed.
+     */
     async emitOnceAsync(event, ...args) {
         const matchingListeners = this.listeners.filter(
             listener => listener.event === event
@@ -73,7 +138,15 @@ class emitter {
             )
         );
     }
-    
+
+    /**
+     * Synchronously triggers listeners for an event a specific number of times.
+     * 
+     * @param {string} event - The name of the event.
+     * @param {number} times - The number of times to trigger the listeners.
+     * @param {...*} args - Arguments to pass to the callback functions.
+     * @returns {void}
+     */
     emitRepeat(event, times, ...args) {
         this.listeners.forEach(listener => {
             if(listener.event === event) {
@@ -87,7 +160,17 @@ class emitter {
             }
         });
     }
-    
+
+    /**
+     * Asynchronously triggers listeners for an event a specific number of times.
+     * It waits for all listeners to complete one round before starting the next iteration.
+     * 
+     * @async
+     * @param {string} event - The name of the event.
+     * @param {number} times - The number of times to trigger the listeners.
+     * @param {...*} args - Arguments to pass to the callback functions.
+     * @returns {Promise<void>} A promise that resolves when all repetitions are complete.
+     */
     async emitRepeatAsync(event, times, ...args) {
         const matchingListeners = this.listeners.filter(
             listener => listener.event === event

package/package.json

@@ -3,7 +3,7 @@
     "sqlite3": "^5.1.7"
   },
   "name": "goaded.utils",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "",
   "main": "services.js",
   "devDependencies": {},