divhunt 2.0.0

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

@@ -0,0 +1,160 @@
+import database from '#database/addon.js';
+
+database.Fn('find.builder', function()
+{
+    const builder = {};
+    
+    builder.applyFilters = (knexQuery, filters) =>
+    {
+        if(!filters.length)
+        {
+            return;
+        }
+        
+        const groups = {};
+
+        filters.forEach(filter => 
+        {
+            if(!groups[filter.group])
+            {
+                groups[filter.group] = { type: 'AND', filters: [] };
+            }
+            
+            if(filter.groupStart)
+            {
+                groups[filter.group].type = filter.type;
+            }
+            else
+            {
+                groups[filter.group].filters.push(filter);
+            }
+        });
+        
+        knexQuery.where(function()
+        {
+            let first = true;
+            
+            Object.entries(groups).forEach(([groupId, group]) => 
+            {
+                if(!group.filters.length)
+                {
+                    return;
+                }
+                
+                const method = first ? 'where' : (group.type === 'OR' ? 'orWhere' : 'andWhere');
+                first = false;
+                
+                this[method](function()
+                {
+                    group.filters.forEach((filter, i) => 
+                    {
+                        builder.applyFilter(this, filter, i);
+                    });
+                });
+            });
+        });
+    };
+    
+    builder.applyFilter = (query, filter, index) =>
+    {
+        const method = index === 0 ? 'where' : (filter.type === 'OR' ? 'orWhere' : 'where');
+        const operator = filter.operator.toUpperCase();
+        
+        if(operator === 'NULL')
+        {
+            query[method + 'Null'](filter.field);
+        }
+        else if(operator === 'NOT NULL')
+        {
+            query[method + 'NotNull'](filter.field);
+        }
+        else if(operator === 'BETWEEN')
+        {
+            query[method + 'Between'](filter.field, filter.value);
+        }
+        else if(operator === 'NOT BETWEEN')
+        {
+            query[method + 'NotBetween'](filter.field, filter.value);
+        }
+        else if(operator === 'CONTAINS')
+        {
+            const val = Array.isArray(filter.value) ? filter.value : [filter.value];
+            const type = typeof val[0] === 'number' ? '::int[]' : '::varchar[]';
+            query.whereRaw(`?? @> ARRAY[${val.map(() => '?').join(',')}]${type}`, [filter.field, ...val]);
+        }
+        else if(operator === 'CONTAINED')
+        {
+            const val = Array.isArray(filter.value) ? filter.value : [filter.value];
+            const type = typeof val[0] === 'number' ? '::int[]' : '::varchar[]';
+            query.whereRaw(`?? <@ ARRAY[${val.map(() => '?').join(',')}]${type}`, [filter.field, ...val]);
+        }
+        else if(operator === 'HAS')
+        {
+            query.whereRaw(`?? ? ?`, [filter.field, filter.value]);
+        }
+        else if(['IN', 'NOT IN'].includes(operator))
+        {
+            const values = Array.isArray(filter.value) ? filter.value : [filter.value];
+            query[method](filter.field, operatorToKnex(operator), values);
+        }
+        else
+        {
+            query[method](filter.field, operatorToKnex(operator), filter.value);
+        }
+    };
+    
+    const operatorToKnex = (operator) =>
+    {
+        const map = {
+            'EQUALS': '=',
+            'NOT EQUALS': '!=',
+            'LESS': '<',
+            'GREATER': '>',
+            'LESS EQUALS': '<=',
+            'GREATER EQUALS': '>=',
+            'LIKE': 'like',
+            'NOT LIKE': 'not like',
+            'ILIKE': 'ilike',
+            'NOT ILIKE': 'not ilike',
+            'IN': 'in',
+            'NOT IN': 'not in'
+        };
+        
+        return map[operator] || operator.toLowerCase();
+    };
+    
+    builder.applySort = (knexQuery, sort) =>
+    {
+        if(sort)
+        {
+            knexQuery.orderBy(sort.field, sort.direction);
+        }
+    };
+    
+    builder.applyPagination = (knexQuery, limit, page) =>
+    {
+        if(limit > 0)
+        {
+            knexQuery.limit(limit);
+
+            if(page > 1)
+            {
+                knexQuery.offset((page - 1) * limit);
+            }
+        }
+    };
+    
+    builder.applySelect = (knexQuery, select, distinct) =>
+    {
+        if(select)
+        {
+            knexQuery[distinct ? 'distinct' : 'select'](select);
+        }
+        else
+        {
+            knexQuery[distinct ? 'distinct' : 'select']('*');
+        }
+    };
+    
+    return builder;
+});

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

@@ -0,0 +1,12 @@
+import database from '#database/addon.js';
+
+database.Fn('find.count', async function(query)
+{
+    const builder = database.Fn('find.builder');
+    const knexQuery = query.connection(query.table.name).count('* as count');
+    
+    builder.applyFilters(knexQuery, query.filters);
+
+    const result = await knexQuery;
+    return parseInt(result[0]?.count || 0);
+});

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

@@ -0,0 +1,37 @@
+import database from '#database/addon.js';
+
+database.Fn('find.filter', function(query, field, value, operator, type, group, returnMethods)
+{
+    const validation = database.Fn('find.validation');
+    const normalizedOperator = operator.toUpperCase();
+    
+    if(normalizedOperator === 'NULL' || normalizedOperator === 'NOT NULL')
+    {
+        validation.field(field);
+    }
+    else if(normalizedOperator === 'BETWEEN' || normalizedOperator === 'NOT BETWEEN')
+    {
+        validation.field(field);
+        validation.between(value);
+    }
+    else if(normalizedOperator === 'IN' || normalizedOperator === 'NOT IN')
+    {
+        validation.field(field);
+        validation.operator(normalizedOperator, query.operators.map(op => op.toUpperCase()));
+        validation.inList(value);
+    }
+    else
+    {
+        validation.field(field);
+        validation.operator(normalizedOperator, query.operators.map(op => op.toUpperCase()));
+        validation.value(value);
+    }
+    
+    if(query.table.prefix)
+    {
+        field = query.table.prefix + field;
+    }
+
+    query.filters.push({ field, value, operator: normalizedOperator, type, group });
+    return returnMethods;
+});

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

@@ -0,0 +1,7 @@
+import database from '#database/addon.js';
+
+database.Fn('find.filters', function(knexQuery, filters = [])
+{
+    const builder = database.Fn('find.builder');
+    builder.applyFilters(knexQuery, filters);
+});

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

@@ -0,0 +1,93 @@
+import divhunt from '#framework/load.js';
+import database from '#database/addon.js';
+
+database.Fn('find.many', async function(query, set = false)
+{
+    const builder = database.Fn('find.builder');
+    const knexQuery = query.connection(query.table.name);
+
+    builder.applySelect(knexQuery, query.select, query.distinct);
+    builder.applyFilters(knexQuery, query.filters);
+    builder.applySort(knexQuery, query.sort);
+    builder.applyPagination(knexQuery, query.limit, query.page);
+
+    const result = await knexQuery;
+
+    const items = result.map((record) =>
+    {
+        const data = {};
+
+        Object.entries(record).forEach(([key, value]) =>
+        {
+            if(value instanceof Date)
+            {
+                value = value.toISOString();
+            }
+
+            if(query.table.prefix && key.startsWith(query.table.prefix))
+            {
+                key = key.slice(query.table.prefix.length);
+            }
+
+            data[key] = value;
+        });
+
+        return query.addon.ItemAdd(data, null, false, set);
+    });
+
+    if(query.joins.length)
+    {
+        for(const join of query.joins)
+        {
+            const addon = divhunt.AddonGet(join.addon);
+
+            if(!addon)
+            {
+                throw new Error(`Join addon '${join.addon}' not found`);
+            }
+
+            const ids = [];
+
+            items.forEach(item =>
+            {
+                const value = item.Get(join.field);
+
+                if(join.many && Array.isArray(value))
+                {
+                    value.forEach(id => { if(id && !ids.includes(id)) ids.push(id); });
+                }
+                else if(value && !ids.includes(value))
+                {
+                    ids.push(value);
+                }
+            });
+
+            if(!ids.length)
+            {
+                continue;
+            }
+
+            const joined = await addon.Find(query.connection).filter('id', ids, 'IN').limit(ids.length).many();
+            const map = {};
+
+            const fields = Object.keys(addon.Fields().data);
+            joined.forEach(item => { map[String(item.Get('id'))] = item.Get(fields); });
+
+            items.forEach(item =>
+            {
+                const value = item.Get(join.field);
+
+                if(join.many && Array.isArray(value))
+                {
+                    item.Set(join.output, value.map(id => map[String(id)]).filter(Boolean));
+                }
+                else if(value)
+                {
+                    item.Set(join.output, map[String(value)] || null);
+                }
+            });
+        }
+    }
+
+    return items;
+});

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

@@ -0,0 +1,235 @@
+import divhunt from '#framework/load.js';
+import database from '#database/addon.js';
+
+database.Fn('find.methods', function(query, context = null, groupId = 'default')
+{
+    const validation = database.Fn('find.validation');
+    const methods = {};
+    
+    methods.limit = limit =>
+    {
+        try
+        {
+            validation.limit(limit);
+            query.limit = limit;
+            return methods;
+        }
+        catch (error)
+        {
+            throw new Error(`Invalid limit parameter: ${error.message}`);
+        }
+    };
+    
+    methods.page = page =>
+    {
+        try
+        {
+            validation.page(page);
+            query.page = page;
+            return methods;
+        }
+        catch (error)
+        {
+            throw new Error(`Invalid page parameter: ${error.message}`);
+        }
+    };
+    
+    methods.sort = (field, direction = 'asc') =>
+    {
+        try
+        {
+            validation.field(field);
+            direction = validation.direction(direction);
+
+            if(query.table.prefix)
+            {
+                field = query.table.prefix + field;
+            }
+
+            query.sort = { field, direction };
+            return methods;
+        }
+        catch (error)
+        {
+            throw new Error(`Invalid sort parameters: ${error.message}`);
+        }
+    };
+    
+    methods.select = fields =>
+    {
+        try
+        {
+            if (fields === undefined || fields === null)
+            {
+                throw new Error('Fields parameter cannot be null or undefined');
+            }
+
+            fields = Array.isArray(fields) ? fields : [fields];
+            validation.fields(fields);
+
+            if(query.table.prefix)
+            {
+                fields = fields.map(f => query.table.prefix + f);
+            }
+
+            query.select = fields;
+            return methods;
+        }
+        catch (error)
+        {
+            throw new Error(`Invalid select parameters: ${error.message}`);
+        }
+    };
+    
+    methods.distinct = (value = true) =>
+    {
+        query.distinct = Boolean(value);
+        return methods;
+    };
+    
+    methods.filter = (field, value, operator = 'EQUALS') => 
+    {
+        try
+        {
+            return database.Fn('find.filter', query, field, value, operator, 'AND', groupId, methods);
+        }
+        catch (error)
+        {
+            throw new Error(`Filter error for field '${field}': ${error.message}`);
+        }
+    };
+
+    methods.orFilter = (field, value, operator = 'EQUALS') => 
+    {
+        try 
+        {
+            return database.Fn('find.filter', query, field, value, operator, 'OR', groupId, methods);
+        }
+        catch (error)
+        {
+            throw new Error(`OR filter error for field '${field}': ${error.message}`);
+        }
+    };
+    
+    methods.group = (type = 'AND') =>
+    {
+        try
+        {
+            if (type !== 'AND' && type !== 'OR')
+            {
+                throw new Error(`Group type must be 'AND' or 'OR', received: ${type}`);
+            }
+            
+            const TID = divhunt.GenerateTID();
+            
+            if (!query.filters)
+            {
+                query.filters = [];
+            }
+            
+            query.filters.push({ groupStart: true, group: TID, type });
+            
+            const groupMethods = database.Fn('find.methods', query, methods, TID);
+            groupMethods.end = () => context || methods;
+            
+            return groupMethods;
+        }
+        catch (error)
+        {
+            throw new Error(`Error creating filter group: ${error.message}`);
+        }
+    };
+    
+    methods.join = (addon, field, output = null) =>
+    {
+        try
+        {
+            const config = query.addon.FieldGet(field);
+
+            if(!config)
+            {
+                throw new Error(`Field '${field}' not found in addon`);
+            }
+
+            const parsed = divhunt.DataParseConfig(config.define);
+            const many = parsed.type.includes('array');
+
+            query.joins.push({ addon, field, output: output || field, many });
+
+            return methods;
+        }
+        catch (error)
+        {
+            throw new Error(`Join error for field '${field}': ${error.message}`);
+        }
+    };
+
+    methods.many = async (set = false) =>
+    {
+        try
+        {
+            return database.Fn('find.many', query, set);
+        }
+        catch (error)
+        {
+            throw new Error(`Error executing 'many' query: ${error.message}`);
+        }
+    };
+
+    methods.plain = async () =>
+    {
+        try
+        {
+            return database.Fn('find.plain', query);
+        }
+        catch (error)
+        {
+            throw new Error(`Error executing 'plain' query: ${error.message}`);
+        }
+    };
+    
+    methods.count = async () =>
+    {
+        try
+        {
+            return database.Fn('find.count', query);
+        }
+        catch (error)
+        {
+            throw new Error(`Error executing 'count' query: ${error.message}`);
+        }
+    };
+    
+    methods.one = async (set = false) =>
+    {
+        try
+        {
+            const results = await methods.limit(1).many(set);
+            return results.length > 0 ? results[0] : null;
+        }
+        catch (error)
+        {
+            throw new Error(`Error executing 'one' query: ${error.message}`);
+        }
+    };
+    
+    methods.exists = async () =>
+    {
+        try
+        {
+            const count = await methods.limit(1).count();
+            return count > 0;
+        }
+        catch (error)
+        {
+            throw new Error(`Error executing 'exists' query: ${error.message}`);
+        }
+    };
+    
+    if(context) 
+    {
+        methods.end = () => context;
+    }
+    
+    return methods;
+});

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

@@ -0,0 +1,25 @@
+import database from '#database/addon.js';
+
+database.Fn('find.plain', async function(query)
+{
+    const builder = database.Fn('find.builder');
+    const countQuery = query.connection(query.table.name).count('* as count');
+
+    builder.applyFilters(countQuery, query.filters);
+
+    const [items, countResult] = await Promise.all([
+        database.Fn('find.many', query),
+        countQuery
+    ]);
+
+    const total = parseInt(countResult[0]?.count || 0);
+    const fields = Object.keys(query.addon.Fields().data);
+
+    return {
+        items: items.map(item => item.Get(fields)),
+        total,
+        page: query.page,
+        pages: query.limit > 0 ? Math.ceil(total / query.limit) : 1,
+        limit: query.limit
+    };
+});