@onetype/framework 2.0.49 → 2.0.52

package/addons/core/database/back/functions/items/methods/query.js

@@ -0,0 +1,33 @@
+import database from '#database/addon.js';
+
+database.Fn('items.methods.query', async function(query)
+{
+	const builder = database.Fn('items.builder');
+	const knexQuery = query.knex(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 records = result.map((record) =>
+	{
+		const data = {};
+
+		Object.entries(record).forEach(([key, value]) =>
+		{
+			if(value instanceof Date)
+			{
+				value = value.toISOString();
+			}
+
+			data[key] = value;
+		});
+
+		return data;
+	});
+
+	return database.Fn('items.transform.translate', records, query);
+});

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

@@ -0,0 +1,142 @@
+import onetype from '#framework/load.js';
+import database from '#database/addon.js';
+
+database.Fn('items.methods', function(query, context = null, groupId = 'default')
+{
+	const validation = database.Fn('items.validation');
+	const methods = {};
+
+	methods.limit = limit =>
+	{
+		validation.limit(limit);
+		query.limit = limit;
+		return methods;
+	};
+
+	methods.page = page =>
+	{
+		validation.page(page);
+		query.page = page;
+		return methods;
+	};
+
+	methods.sort = (field, direction = 'asc') =>
+	{
+		validation.field(field);
+		direction = validation.direction(direction);
+
+		query.sort = { field, direction };
+		return methods;
+	};
+
+	methods.select = fields =>
+	{
+		fields = Array.isArray(fields) ? fields : [fields];
+		validation.fields(fields);
+
+		query.select = fields;
+		return methods;
+	};
+
+	methods.distinct = (value = true) =>
+	{
+		query.distinct = Boolean(value);
+		return methods;
+	};
+
+	methods.filter = (field, value, operator = 'EQUALS') =>
+	{
+		return database.Fn('items.filter', query, field, value, operator, 'AND', groupId, methods);
+	};
+
+	methods.orFilter = (field, value, operator = 'EQUALS') =>
+	{
+		return database.Fn('items.filter', query, field, value, operator, 'OR', groupId, methods);
+	};
+
+	methods.group = (type = 'AND') =>
+	{
+		const TID = onetype.GenerateTID();
+
+		if(!query.filters)
+		{
+			query.filters = [];
+		}
+
+		query.filters.push({ groupStart: true, group: TID, type });
+
+		const groupMethods = database.Fn('items.methods', query, methods, TID);
+		groupMethods.end = () => context || methods;
+
+		return groupMethods;
+	};
+
+	methods.join = (addon, field, output = null) =>
+	{
+		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;
+	};
+
+	methods.many = async (set = false) =>
+	{
+		return database.Fn('items.methods.many', query, set);
+	};
+
+	methods.plain = async () =>
+	{
+		return database.Fn('items.methods.plain', query);
+	};
+
+	methods.count = async () =>
+	{
+		return database.Fn('items.methods.count', query);
+	};
+
+	methods.one = async (set = false) =>
+	{
+		return database.Fn('items.methods.one', query, set);
+	};
+
+	methods.exists = async () =>
+	{
+		return database.Fn('items.methods.exists', query);
+	};
+
+	methods.sum = async (field) =>
+	{
+		return database.Fn('items.methods.aggregate', query, 'sum', field);
+	};
+
+	methods.avg = async (field) =>
+	{
+		return database.Fn('items.methods.aggregate', query, 'avg', field);
+	};
+
+	methods.min = async (field) =>
+	{
+		return database.Fn('items.methods.aggregate', query, 'min', field);
+	};
+
+	methods.max = async (field) =>
+	{
+		return database.Fn('items.methods.aggregate', query, 'max', field);
+	};
+
+	if(context)
+	{
+		methods.end = () => context;
+	}
+
+	return methods;
+});

package/addons/core/database/back/functions/items/transform/join.js

@@ -0,0 +1,63 @@
+import onetype from '#framework/load.js';
+import database from '#database/addon.js';
+
+database.Fn('items.transform.join', async function(records, joins)
+{
+	if(!joins.length || !records.length)
+	{
+		return records;
+	}
+
+	for(const join of joins)
+	{
+		const addon = onetype.AddonGet(join.addon);
+
+		if(!addon)
+		{
+			throw new Error(`Join addon '${join.addon}' not found`);
+		}
+
+		const ids = [];
+
+		records.forEach(record =>
+		{
+			const value = record[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().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); });
+
+		records.forEach(record =>
+		{
+			const value = record[join.field];
+
+			if(join.many && Array.isArray(value))
+			{
+				record[join.output] = value.map(id => map[String(id)]).filter(Boolean);
+			}
+			else if(value)
+			{
+				record[join.output] = map[String(value)] || null;
+			}
+		});
+	}
+
+	return records;
+});

package/addons/core/database/back/functions/items/transform/translate.js

@@ -0,0 +1,57 @@
+import database from '#database/addon.js';
+
+database.Fn('items.transform.translate', async function(records, query)
+{
+	const translations = query.addon.database.translations;
+
+	if(!translations || !records.length)
+	{
+		return records;
+	}
+
+	const ids = records.map(record => String(record.id)).filter(Boolean);
+
+	if(!ids.length)
+	{
+		return records;
+	}
+
+	const rows = await query.knex('translations')
+		.where({entity: query.addon.name, language: query.translation})
+		.whereIn('entity_id', ids);
+
+	if(!rows.length)
+	{
+		return records;
+	}
+
+	const map = {};
+
+	rows.forEach(row =>
+	{
+		if(!map[row.entity_id])
+		{
+			map[row.entity_id] = {};
+		}
+
+		map[row.entity_id][row.field] = row.value;
+	});
+
+	records.forEach(record =>
+	{
+		const translated = map[String(record.id)];
+
+		if(translated)
+		{
+			for(const field of translations)
+			{
+				if(translated[field] !== undefined)
+				{
+					record[field] = translated[field];
+				}
+			}
+		}
+	});
+
+	return records;
+});

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

@@ -0,0 +1,125 @@
+import database from '#database/addon.js';
+
+database.Fn('items.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}'.`);
+		}
+
+		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++)
+		{
+			validation.field(fields[i]);
+		}
+
+		return true;
+	};
+
+	validation.limit = limit =>
+	{
+		if(typeof limit !== 'number' || !Number.isInteger(limit) || limit <= 0)
+		{
+			throw new Error(`Limit must be a positive integer, received: ${limit}`);
+		}
+
+		return true;
+	};
+
+	validation.page = page =>
+	{
+		if(typeof page !== 'number' || !Number.isInteger(page) || page < 1)
+		{
+			throw new Error(`Page must be an integer >= 1, received: ${page}`);
+		}
+
+		return true;
+	};
+
+	validation.direction = direction =>
+	{
+		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}'.`);
+		}
+
+		return direction;
+	};
+
+	validation.operator = (operator, operators) =>
+	{
+		if(!operators.includes(operator.toUpperCase()))
+		{
+			throw new Error(`Invalid operator: '${operator}'.`);
+		}
+
+		return true;
+	};
+
+	validation.value = value =>
+	{
+		if(value !== null && !['number', 'string', 'boolean'].includes(typeof value))
+		{
+			throw new Error(`Value must be a string, number, or boolean. Received: ${typeof value}`);
+		}
+
+		return true;
+	};
+
+	validation.between = value =>
+	{
+		if(!Array.isArray(value) || value.length !== 2)
+		{
+			throw new Error('BETWEEN requires an array of exactly 2 elements.');
+		}
+
+		return true;
+	};
+
+	validation.inList = value =>
+	{
+		if(!Array.isArray(value) || value.length === 0)
+		{
+			throw new Error('IN requires a non-empty array.');
+		}
+
+		return true;
+	};
+
+	return validation;
+});

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

@@ -22,4 +22,4 @@ database.ItemOn('add', function(item)
     });
 
     item.Set('connection', knex);
-});
+});

package/addons/core/database/back/items/commands/create.js

@@ -0,0 +1,54 @@
+import onetype from '#framework/load.js';
+
+onetype.AddonReady('commands', (commands) =>
+{
+	commands.Item({
+		id: 'database:create',
+		exposed: true,
+		method: 'POST',
+		endpoint: '/api/database/create',
+		in: {
+			addon: ['string', null, true],
+			data: ['object', null, true],
+			translation: ['string']
+		},
+		out: {
+			item: ['object']
+		},
+		callback: async function(properties, resolve)
+		{
+			const addon = onetype.AddonGet(properties.addon);
+
+			if(!addon)
+			{
+				return resolve(null, 'Addon not found.', 404);
+			}
+
+			const expose = addon.database?.expose;
+
+			if(!expose)
+			{
+				return resolve(null, 'Addon is not exposed.', 403);
+			}
+
+			if(!expose.create)
+			{
+				return resolve(null, 'Create is not allowed.', 403);
+			}
+
+			const item = addon.Item(properties.data);
+
+			const allowed = expose.create.call({http: this.http, properties, item});
+
+			if(allowed !== true)
+			{
+				return resolve(null, typeof allowed === 'string' ? allowed : 'Create not allowed.', 400);
+			}
+
+			const created = await item.Create({translation: properties.translation});
+			const fields = expose.select || Object.keys(addon.Fields().data);
+
+			resolve({item: created.Get(fields)});
+		}
+	});
+});

package/addons/core/database/back/items/commands/delete.js

@@ -0,0 +1,62 @@
+import onetype from '#framework/load.js';
+
+onetype.AddonReady('commands', (commands) =>
+{
+	commands.Item({
+		id: 'database:delete',
+		exposed: true,
+		method: 'POST',
+		endpoint: '/api/database/delete',
+		in: {
+			addon: ['string', null, true],
+			id: ['string', null, true]
+		},
+		out: {
+			success: ['boolean']
+		},
+		callback: async function(properties, resolve)
+		{
+			const addon = onetype.AddonGet(properties.addon);
+
+			if(!addon)
+			{
+				return resolve(null, 'Addon not found.', 404);
+			}
+
+			const expose = addon.database?.expose;
+
+			if(!expose)
+			{
+				return resolve(null, 'Addon is not exposed.', 403);
+			}
+
+			if(!expose.delete)
+			{
+				return resolve(null, 'Delete is not allowed.', 403);
+			}
+
+			if(!properties.data?.id || (typeof properties.data.id !== 'string' && typeof properties.data.id !== 'number'))
+			{
+				return resolve(null, 'Invalid or missing id.', 400);
+			}
+
+			const item = await addon.Find().filter('id', properties.data.id).one(true);
+
+			if(!item)
+			{
+				return resolve(null, 'Item not found.', 404);
+			}
+
+			const allowed = expose.delete.call({http: this.http, properties, item});
+
+			if(allowed !== true)
+			{
+				return resolve(null, typeof allowed === 'string' ? allowed : 'Delete not allowed.', 400);
+			}
+
+			await item.Delete();
+
+			resolve({success: true});
+		}
+	});
+});

package/addons/core/database/back/items/commands/find.js

@@ -0,0 +1,118 @@
+import onetype from '#framework/load.js';
+
+onetype.AddonReady('commands', (commands) =>
+{
+	commands.Item({
+		id: 'database:find',
+		exposed: true,
+		method: 'POST',
+		endpoint: '/api/database/find',
+		in: {
+			addon: ['string', null, true],
+			filters: {
+				type: 'array',
+				each: {
+					type: 'object',
+					config: 'filter'
+				}
+			},
+			sort_field: ['string'],
+			sort_direction: ['string', 'asc'],
+			select: {
+				type: 'array',
+				each: {
+					type: 'string'
+				}
+			},
+			page: ['number', 1],
+			limit: ['number', 50],
+			translation: ['string']
+		},
+		out: {
+			items: {
+				type: 'array',
+				each: {
+					type: 'object'
+				}
+			},
+			total: ['number'],
+			page: ['number'],
+			limit: ['number']
+		},
+		callback: async function(properties, resolve)
+		{
+			const addon = onetype.AddonGet(properties.addon);
+
+			if(!addon)
+			{
+				return resolve(null, 'Addon not found.', 404);
+			}
+
+			const expose = addon.database?.expose;
+
+			if(!expose)
+			{
+				return resolve(null, 'Addon is not exposed.', 403);
+			}
+
+			let query = addon.Find({translation: properties.translation});
+
+			if(properties.filters)
+			{
+				for(const filter of properties.filters)
+				{
+					if(!expose.filter.includes(filter.field))
+					{
+						return resolve(null, 'Filter field "' + filter.field + '" is not allowed.', 400);
+					}
+
+					query = query.filter(filter.field, filter.value, filter.operator || 'EQUALS');
+				}
+			}
+
+			if(properties.sort_field)
+			{
+				if(!expose.sort.includes(properties.sort_field))
+				{
+					return resolve(null, 'Sort field "' + properties.sort_field + '" is not allowed.', 400);
+				}
+
+				query = query.sort(properties.sort_field, properties.sort_direction || 'asc');
+			}
+
+			if(expose.find)
+			{
+				const allowed = expose.find.call({http: this.http, properties}, query);
+
+				if(allowed !== true)
+				{
+					return resolve(null, typeof allowed === 'string' ? allowed : 'Find not allowed.', 400);
+				}
+			}
+
+			const limit = Math.min(properties.limit || 50, 500);
+			const page = properties.page || 1;
+
+			const result = await query.page(page).limit(limit).plain();
+
+			if(expose.select)
+			{
+				const allowed = properties.select?.length ? properties.select.filter(field => expose.select.includes(field)) : expose.select;
+
+				result.items = result.items.map(item =>
+				{
+					const data = {};
+
+					for(const field of allowed)
+					{
+						data[field] = item[field];
+					}
+
+					return data;
+				});
+			}
+
+			resolve(result);
+		}
+	});
+});