@onetype/framework 2.0.49 → 2.0.51

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

@@ -1,160 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,93 +0,0 @@
-import onetype 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 = onetype.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

@@ -1,235 +0,0 @@
-import onetype 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 = onetype.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 = onetype.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

@@ -1,25 +0,0 @@
-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
-    };
-});