divhunt 2.0.0

package/addons/core/database/back/functions/find/validation.js

@@ -0,0 +1,214 @@
+import database from '#database/addon.js';
+
+database.Fn('find.validation', function()
+{
+    const validation = {};
+    
+    validation.field = field =>
+    {
+        if (field === undefined || field === null)
+        {
+            throw new Error('Field name cannot be null or undefined');
+        }
+        
+        if (typeof field !== 'string')
+        {
+            throw new Error(`Field name must be a string, received: ${typeof field}`);
+        }
+        
+        if (!(/^[a-zA-Z][a-zA-Z0-9_\.]{0,63}$/.test(field)))
+        {
+            throw new Error(`Invalid field name format: '${field}'. Must start with a letter and contain only letters, numbers, underscores, and dots. Maximum length is 64 characters.`);
+        }
+
+        return true;
+    };
+    
+    validation.fields = fields =>
+    {
+        if (!Array.isArray(fields))
+        {
+            throw new Error(`Fields must be an array, received: ${typeof fields}`);
+        }
+        
+        if (fields.length === 0)
+        {
+            throw new Error('Fields array cannot be empty');
+        }
+        
+        for (let i = 0; i < fields.length; i++)
+        {
+            try
+            {
+                validation.field(fields[i]);
+            }
+            catch (error)
+            {
+                throw new Error(`Invalid field at index ${i}: ${error.message}`);
+            }
+        }
+        
+        return true;
+    };
+    
+    validation.limit = limit =>
+    {
+        if (limit === undefined || limit === null)
+        {
+            throw new Error('Limit cannot be null or undefined');
+        }
+        
+        if (typeof limit !== 'number')
+        {
+            throw new Error(`Limit must be a number, received: ${typeof limit}`);
+        }
+        
+        if (!Number.isInteger(limit))
+        {
+            throw new Error('Limit must be an integer');
+        }
+        
+        if (limit <= 0)
+        {
+            throw new Error(`Limit must be a positive number, received: ${limit}`);
+        }
+
+        return true;
+    };
+    
+    validation.page = page =>
+    {
+        if (page === undefined || page === null)
+        {
+            throw new Error('Page cannot be null or undefined');
+        }
+        
+        if (typeof page !== 'number')
+        {
+            throw new Error(`Page must be a number, received: ${typeof page}`);
+        }
+        
+        if (!Number.isInteger(page))
+        {
+            throw new Error('Page must be an integer');
+        }
+        
+        if (page < 1)
+        {
+            throw new Error(`Page must be greater than 0, received: ${page}`);
+        }
+
+        return true;
+    };
+    
+    validation.direction = direction =>
+    {
+        if (direction === undefined || direction === null)
+        {
+            throw new Error('Sort direction cannot be null or undefined');
+        }
+        
+        if (typeof direction !== 'string')
+        {
+            throw new Error(`Sort direction must be a string, received: ${typeof direction}`);
+        }
+        
+        direction = direction.toLowerCase();
+        
+        if (!['asc', 'desc'].includes(direction))
+        {
+            throw new Error(`Invalid sort direction: '${direction}'. Must be either 'asc' or 'desc'`);
+        }
+
+        return direction;
+    };
+    
+    validation.operator = (operator, operators) =>
+    {
+        if (operator === undefined || operator === null)
+        {
+            throw new Error('Operator cannot be null or undefined');
+        }
+        
+        if (typeof operator !== 'string')
+        {
+            throw new Error(`Operator must be a string, received: ${typeof operator}`);
+        }
+        
+        if (!operators || !Array.isArray(operators) || operators.length === 0)
+        {
+            throw new Error('Invalid operators list');
+        }
+        
+        const normalizedOperator = operator.toUpperCase();
+        const normalizedOperators = operators.map(op => typeof op === 'string' ? op.toUpperCase() : op);
+        
+        if (!normalizedOperators.includes(normalizedOperator))
+        {
+            throw new Error(`Invalid operator: '${operator}'. Allowed operators are: ${operators.join(', ')}`);
+        }
+
+        return true;
+    };
+    
+    validation.value = value =>
+    {
+        const validTypes = ['number', 'string', 'boolean'];
+        
+        if (value !== null && !validTypes.includes(typeof value))
+        {
+            throw new Error(`Value must be a string, number, boolean. Received: ${value === undefined ? 'undefined' : typeof value}`);
+        }
+        
+        return true;
+    };
+    
+    validation.between = value =>
+    {
+        if (!Array.isArray(value))
+        {
+            throw new Error(`Value for BETWEEN operator must be an array, received: ${typeof value}`);
+        }
+        
+        if (value.length !== 2)
+        {
+            throw new Error(`Value for BETWEEN operator must have exactly 2 elements, found: ${value.length}`);
+        }
+        
+        if (value[0] === undefined || value[1] === undefined)
+        {
+            throw new Error('BETWEEN values cannot contain undefined');
+        }
+
+        return true;
+    };
+    
+    validation.inList = value =>
+    {
+        if (!Array.isArray(value))
+        {
+            throw new Error(`Value for IN operator must be an array, received: ${typeof value}`);
+        }
+        
+        if (value.length === 0)
+        {
+            throw new Error('IN operator requires a non-empty array');
+        }
+        
+        for (let i = 0; i < value.length; i++)
+        {
+            try
+            {
+                validation.value(value[i]);
+            }
+            catch (error)
+            {
+                throw new Error(`Invalid value at index ${i} for IN operator: ${error.message}`);
+            }
+        }
+        
+        return true;
+    };
+    
+    return validation;
+});

package/addons/core/database/back/functions/find.js

@@ -0,0 +1,25 @@
+import database from '#database/addon.js';
+
+database.Fn('find', function(connection, table, addon)
+{
+    const query = {
+        filters: [],
+        joins: [],
+        sort: null,
+        limit: 10,
+        page: 1,
+        distinct: false,
+        select: null,
+        table,
+        addon,
+        connection,
+        operators: [
+            'EQUALS', 'NOT EQUALS', 'LESS', 'GREATER', 'LESS EQUALS', 'GREATER EQUALS', 
+            'LIKE', 'NOT LIKE', 'ILIKE', 'NOT ILIKE', 'IN', 'NOT IN', 
+            'BETWEEN', 'NOT BETWEEN', 'NULL', 'NOT NULL', 
+            'CONTAINS', 'CONTAINED', 'HAS'
+        ]
+    };
+
+    return database.Fn('find.methods', query);
+});

package/addons/core/database/back/functions/update.js

@@ -0,0 +1,6 @@
+import database from '#database/addon.js';
+
+database.Fn('update', async function(connection, table, item)
+{
+    return database.Fn('item.update', item, connection);
+});

package/addons/core/database/back/item/catch/add.js

@@ -0,0 +1,25 @@
+import Knex from 'knex';
+import database from '#database/addon.js';
+
+database.ItemOn('add', function(item)
+{
+    const knex = Knex({
+        client: 'pg',
+        connection: {
+            port: item.Get('port'),
+            host: item.Get('hostname'),
+            user: item.Get('username'),
+            password: item.Get('password'),
+            database: item.Get('database'),
+        },
+        acquireConnectionTimeout: 1000,
+        pool: {
+            min: 0,   
+            max: 25,    
+            idleTimeoutMillis: 1000,
+            acquireTimeoutMillis: 1000
+        }
+    });
+
+    item.Set('connection', knex);
+});

package/addons/core/database/back/item/functions/create.js

@@ -0,0 +1,93 @@
+import database from '#database/addon.js';
+
+database.Fn('item.create', async function(item, addon, connection = null)
+{
+    if(!connection)
+    {
+        connection = item.Get('connection');
+    }
+
+    const table = addon.Table();
+
+    if(!table.name)
+    {
+        throw new Error('Addon must have table name set.');
+    }
+
+    const fields = {};
+    const id = item.Get('id');
+
+    Object.values(addon.Fields().data).forEach((field) =>
+    {
+        if(field.name !== 'id')
+        {
+            try
+            {
+                const key = table.prefix ? table.prefix + field.name : field.name;
+                fields[key] = item.Get(field.name);
+            }
+            catch(error)
+            {
+                throw new Error('Item Create GET Error. ' + error.message);
+            }
+        }
+    });
+
+    if(addon.FieldGet('updated'))
+    {
+        const updatedKey = table.prefix ? table.prefix + 'updated' : 'updated';
+        fields[updatedKey] = new Date().toISOString();
+    }
+
+    if(addon.FieldGet('created'))
+    {
+        const createdKey = table.prefix ? table.prefix + 'created' : 'created';
+        fields[createdKey] = new Date().toISOString();
+    }
+
+    if(addon.FieldGet('updated_at'))
+    {
+        const updatedKey = table.prefix ? table.prefix + 'updated_at' : 'updated_at';
+        fields[updatedKey] = new Date().toISOString();
+    }
+
+    if(addon.FieldGet('created_at'))
+    {
+        const createdKey = table.prefix ? table.prefix + 'created_at' : 'created_at';
+        fields[createdKey] = new Date().toISOString();
+    }
+
+    return connection(table.name).insert(fields).returning('*').then(([record]) =>
+    {
+        Object.entries(record).forEach(([key, value]) =>
+        {
+            try
+            {
+                if(value instanceof Date)
+                {
+                    value = value.toISOString();
+                }
+
+                if(table.prefix && key.startsWith(table.prefix))
+                {
+                    key = key.slice(table.prefix.length);
+                }
+
+                item.Set(key, value);
+            }
+            catch(error)
+            {
+                throw new Error('Item Create SET Error. ' + error.message);
+            }
+        });
+
+        addon.ItemRemove(id, false);
+
+        const created = addon.ItemAdd({id: item.Get('id')}, null, false);
+
+        created.data = item.data;
+        created.store = item.store;
+
+        return created;
+    });
+});

package/addons/core/database/back/item/functions/delete.js

@@ -0,0 +1,25 @@
+import database from '#database/addon.js';
+
+database.Fn('item.delete', async function(item, connection = null)
+{
+    if(!connection)
+    {
+        connection = item.Get('connection');
+    }
+
+    const addon = item.addon;
+    const table = addon.Table();
+
+    if(!table.name)
+    {
+        throw new Error('Addon must have table name set.');
+    }
+
+    const key = table.prefix ? table.prefix + 'id' : 'id';
+
+    return connection(table.name).where(key, item.Get('id')).del().then(() =>
+    {
+        item.Set('id', null);
+        return item;
+    });
+});

package/addons/core/database/back/item/functions/find.js

@@ -0,0 +1,19 @@
+import database from '#database/addon.js';
+
+database.Fn('item.find', function(item, connection = null)
+{
+    if(!connection)
+    {
+        connection = item.Get('connection');
+    }
+
+    const addon = item.addon;
+    const table = addon.Table();
+    
+    if(!table.name)
+    {
+        throw new Error('Addon must have table name set.');
+    }
+
+    return database.Fn('find', connection, table, addon);
+});

package/addons/core/database/back/item/functions/save.js

@@ -0,0 +1,15 @@
+import database from '#database/addon.js';
+
+database.Fn('item.save', async function(item, connection = null)
+{
+    const itemId = item.Get('id');
+    
+    if(itemId)
+    {
+        return database.Fn('item.update', item, connection);
+    }
+    else
+    {
+        return database.Fn('item.create', item, item.addon, connection);
+    }
+});

package/addons/core/database/back/item/functions/transaction.js

@@ -0,0 +1,17 @@
+import database from '#database/addon.js';
+
+database.Fn('item.transaction', function(item, callback)
+{
+    item.Get('connection').transaction(async (trx) => 
+    {
+        try 
+        {
+            await callback(trx);
+            trx.commit();
+        }
+        catch(error)
+        {
+            trx.rollback();
+        }
+    });
+});

package/addons/core/database/back/item/functions/update.js

@@ -0,0 +1,76 @@
+import database from '#database/addon.js';
+
+database.Fn('item.update', async function(item, connection = null)
+{
+    if(!connection)
+    {
+        connection = item.Get('connection');
+    }
+
+    const addon = item.addon;
+    const table = addon.Table();
+
+    if(!table.name)
+    {
+        throw new Error('Addon must have table name set.');
+    }
+
+    const fields = {};
+
+    Object.values(addon.Fields().data).forEach((field) =>
+    {
+        if(field.name !== 'id')
+        {
+            try
+            {
+                const key = table.prefix ? table.prefix + field.name : field.name;
+                fields[key] = item.Get(field.name);
+            }
+            catch(error)
+            {
+                throw new Error('Item Update GET Error. ' + error.message);
+            }
+        }
+    });
+
+    if(addon.FieldGet('updated'))
+    {
+        const updatedKey = table.prefix ? table.prefix + 'updated' : 'updated';
+        fields[updatedKey] = new Date().toISOString();
+    }
+
+    if(addon.FieldGet('updated_at'))
+    {
+        const updatedKey = table.prefix ? table.prefix + 'updated_at' : 'updated_at';
+        fields[updatedKey] = new Date().toISOString();
+    }
+
+    const key = table.prefix ? table.prefix + 'id' : 'id';
+
+    return connection(table.name).where(key, item.Get('id')).update(fields).returning('*').then(([record]) =>
+    {
+        Object.entries(record).forEach(([key, value]) =>
+        {
+            try
+            {
+                if(value instanceof Date)
+                {
+                    value = value.toISOString();
+                }
+
+                if(table.prefix && key.startsWith(table.prefix))
+                {
+                    key = key.slice(table.prefix.length);
+                }
+
+                item.Set(key, value);
+            }
+            catch(error)
+            {
+                throw new Error('Item Update SET Error. ' + error.message);
+            }
+        });
+
+        return item;
+    });
+});