@onetype/framework 2.0.49 → 2.0.51

package/addons/core/commands/front/directives/run.js

@@ -8,7 +8,7 @@ onetype.AddonReady('directives', function(directives)
 		category: 'data',
 		trigger: 'node',
 		order: 664,
-		strict: false,
+		strict: true,
 		tag: 'ot-command',
 		attributes: {
 			'command': ['string', null, true],

package/addons/core/commands/front/directives/submit.js

@@ -8,7 +8,7 @@ onetype.AddonReady('directives', function(directives)
 		category: 'data',
 		trigger: 'node',
 		order: 665,
-		strict: false,
+		strict: true,
 		tag: 'ot-command-submit',
 		attributes: {
 			'command': ['string', null, true],

package/addons/core/commands/front/functions/api.js

@@ -14,7 +14,7 @@ commands.Fn('api', async function(id, data = {})
 
         if(result.code !== 200)
         {
-            throw result.data;
+            throw new Error(result.message);
         }
 
         return { time: result.time, ...result.data };

package/addons/core/database/back/addon.js

@@ -9,6 +9,20 @@ const database = onetype.Addon('database', (addon) =>
     addon.Field('username', ['string']);
     addon.Field('password', ['string']);
     addon.Field('database', ['string']);
+
+    addon.translations = onetype.Addon('database.translations', (addon) =>
+    {
+        addon.Table('translations');
+
+        addon.Field('id', ['string']);
+        addon.Field('entity', ['string', null, true]);
+        addon.Field('entity_id', ['string', null, true]);
+        addon.Field('language', ['string', null, true]);
+        addon.Field('field', ['string', null, true]);
+        addon.Field('value', ['string']);
+        addon.Field('updated_at', ['string']);
+        addon.Field('created_at', ['string']);
+    });
 });
 
 export default database;

package/addons/core/database/back/events/addon.init.js

@@ -0,0 +1,42 @@
+import onetype from '#framework/load.js';
+
+onetype.EmitOn('@addon.init', (addon) =>
+{
+	addon.database =
+	{
+		expose: null,
+		table: null,
+		translations: null
+	};
+
+	addon.Table = function(name)
+	{
+		addon.database.table = { name };
+	};
+
+	addon.Expose = function(config)
+	{
+		addon.database.expose = onetype.DataDefine(config,
+		{
+			filter: ['array', []],
+			sort: ['array', []],
+			select: ['array', []],
+			find: ['function'],
+			create: ['function'],
+			update: ['function'],
+			delete: ['function']
+		});
+	};
+
+	addon.Translations = function(config)
+	{
+		addon.database.translations = config;
+	};
+
+	addon.Find = function({connection = 'primary', translation = null} = {})
+	{
+		translation = onetype.LanguageValidate(translation || onetype.Language());
+
+		return onetype.AddonGet('database').Fn('items.find', {connection, translation, table: addon.database.table, addon});
+	};
+});

package/addons/core/database/back/events/addon.item.init.js

@@ -0,0 +1,24 @@
+import onetype from '#framework/load.js';
+import database from '#database/addon.js';
+
+onetype.EmitOn('@addon.item.init', (item) =>
+{
+	item.Create = async function({connection = 'primary', translation = null} = {})
+	{
+		translation = onetype.LanguageValidate(translation || onetype.Language());
+
+		return database.Fn('item.create', item, {connection, translation});
+	};
+
+	item.Update = async function({connection = 'primary', translation = null} = {})
+	{
+		translation = onetype.LanguageValidate(translation || onetype.Language());
+
+		return database.Fn('item.update', item, {connection, translation});
+	};
+
+	item.Delete = async function({connection = 'primary'} = {})
+	{
+		return database.Fn('item.delete', item, {connection});
+	};
+});

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

@@ -0,0 +1,92 @@
+import onetype from '#framework/load.js';
+import database from '#database/addon.js';
+
+database.Fn('item.create', async function(item, {connection = 'primary', translation = 'en'} = {})
+{
+	const fields = {};
+	const id = item.Get('id');
+	const knex = database.ItemGet(connection)?.Get('connection');
+
+	const { table, translations } = item.addon.database;
+
+	if(!knex)
+	{
+		throw onetype.Error(400, 'Database :1 not found.', connection);
+	}
+
+	if(!table)
+	{
+		throw onetype.Error(400, 'Addon :1 must have table name set.', item.addon.name);
+	}
+
+	Object.values(item.addon.Fields().data).forEach((field) =>
+	{
+		if(field.name === 'id')
+		{
+			return;
+		}
+
+		try
+		{
+			fields[field.name] = item.Get(field.name);
+		}
+		catch(error)
+		{
+			throw onetype.Error(500, 'Error in field: ' + field.name + ': ' + error.message);
+		}
+	});
+
+	['updated', 'created', 'updated_at', 'created_at'].forEach((field) =>
+	{
+		if(item.addon.FieldGet(field))
+		{
+			fields[field] = new Date().toISOString();
+		}
+	});
+
+	return knex.transaction(async (trx) =>
+	{
+		const [record] = await trx(table.name).insert(fields).returning('*');
+
+		Object.entries(record).forEach(([key, value]) =>
+		{
+			if(value instanceof Date)
+			{
+				value = value.toISOString();
+			}
+
+			item.Set(key, value);
+		});
+
+		if(translations)
+		{
+			const rows = translations
+				.filter(field => item.Get(field) !== null && item.Get(field) !== undefined)
+				.map(field => ({
+					entity: item.addon.name,
+					entity_id: String(item.Get('id')),
+					language: translation,
+					field,
+					value: String(item.Get(field)),
+					updated_at: new Date().toISOString()
+				}));
+
+			if(rows.length)
+			{
+				await trx('translations')
+					.insert(rows)
+					.onConflict(['entity', 'entity_id', 'language', 'field'])
+					.merge(['value', 'updated_at']);
+			}
+		}
+
+		item.addon.ItemRemove(id, false);
+
+		const created = item.addon.ItemAdd({id: item.Get('id')}, null, false);
+
+		created.data = item.data;
+		created.store = item.store;
+
+		return created;
+	});
+});

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

@@ -0,0 +1,34 @@
+import onetype from '#framework/load.js';
+import database from '#database/addon.js';
+
+database.Fn('item.delete', async function(item, {connection = 'primary'} = {})
+{
+	const knex = database.ItemGet(connection)?.Get('connection');
+	const { table, translations } = item.addon.database;
+
+	if(!knex)
+	{
+		throw onetype.Error(400, 'Database :1 not found.', connection);
+	}
+
+	if(!table)
+	{
+		throw onetype.Error(400, 'Addon :1 must have table name set.', item.addon.name);
+	}
+
+	return knex.transaction(async (trx) =>
+	{
+		if(translations)
+		{
+			await trx('translations')
+				.where({entity: item.addon.name, entity_id: String(item.Get('id'))})
+				.del();
+		}
+
+		await trx(table.name).where('id', item.Get('id')).del();
+
+		item.Set('id', null);
+
+		return item;
+	});
+});

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

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

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

@@ -0,0 +1,90 @@
+import onetype from '#framework/load.js';
+import database from '#database/addon.js';
+
+database.Fn('item.update', async function(item, {connection = 'primary', translation = 'en'} = {})
+{
+	const fields = {};
+	const knex = database.ItemGet(connection)?.Get('connection');
+	const { table, translations } = item.addon.database;
+
+	if(!knex)
+	{
+		throw onetype.Error(400, 'Database :1 not found.', connection);
+	}
+
+	if(!table)
+	{
+		throw onetype.Error(400, 'Addon :1 must have table name set.', item.addon.name);
+	}
+
+	const isDefault = translation === onetype.Language();
+
+	Object.values(item.addon.Fields().data).forEach((field) =>
+	{
+		if(field.name === 'id')
+		{
+			return;
+		}
+
+		if(translations && !isDefault && translations.includes(field.name))
+		{
+			return;
+		}
+
+		try
+		{
+			fields[field.name] = item.Get(field.name);
+		}
+		catch(error)
+		{
+			throw onetype.Error(500, 'Error in field: ' + field.name + ': ' + error.message);
+		}
+	});
+
+	['updated', 'updated_at'].forEach((field) =>
+	{
+		if(item.addon.FieldGet(field))
+		{
+			fields[field] = new Date().toISOString();
+		}
+	});
+
+	return knex.transaction(async (trx) =>
+	{
+		const [record] = await trx(table.name).where('id', item.Get('id')).update(fields).returning('*');
+
+		Object.entries(record).forEach(([key, value]) =>
+		{
+			if(value instanceof Date)
+			{
+				value = value.toISOString();
+			}
+
+			item.Set(key, value);
+		});
+
+		if(translations)
+		{
+			const rows = translations
+				.filter(field => item.Get(field) !== null && item.Get(field) !== undefined)
+				.map(field => ({
+					entity: item.addon.name,
+					entity_id: String(item.Get('id')),
+					language: translation,
+					field,
+					value: String(item.Get(field)),
+					updated_at: new Date().toISOString()
+				}));
+
+			if(rows.length)
+			{
+				await trx('translations')
+					.insert(rows)
+					.onConflict(['entity', 'entity_id', 'language', 'field'])
+					.merge(['value', 'updated_at']);
+			}
+		}
+
+		return item;
+	});
+});

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

@@ -0,0 +1,160 @@
+import database from '#database/addon.js';
+
+database.Fn('items.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/items/filter.js

@@ -0,0 +1,32 @@
+import database from '#database/addon.js';
+
+database.Fn('items.filter', function(query, field, value, operator, type, group, returnMethods)
+{
+	const validation = database.Fn('items.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);
+	}
+
+	query.filters.push({ field, value, operator: normalizedOperator, type, group });
+	return returnMethods;
+});

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

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

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

@@ -0,0 +1,28 @@
+import database from '#database/addon.js';
+
+database.Fn('items.find', function({connection = 'primary', translation = 'en', table, addon})
+{
+	const knex = database.ItemGet(connection)?.Get('connection');
+
+	const query = {
+		filters: [],
+		joins: [],
+		sort: null,
+		limit: 10,
+		page: 1,
+		distinct: false,
+		select: null,
+		table,
+		addon,
+		knex,
+		translation,
+		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('items.methods', query);
+});

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

@@ -0,0 +1,15 @@
+import database from '#database/addon.js';
+
+database.Fn('items.methods.aggregate', async function(query, type, field)
+{
+	const validation = database.Fn('items.validation');
+	validation.field(field);
+
+	const builder = database.Fn('items.builder');
+	const knexQuery = query.knex(query.table.name)[type](`${field} as result`);
+
+	builder.applyFilters(knexQuery, query.filters);
+
+	const result = await knexQuery;
+	return parseFloat(result[0]?.result || 0);
+});

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

@@ -0,0 +1,12 @@
+import database from '#database/addon.js';
+
+database.Fn('items.methods.count', async function(query)
+{
+	const builder = database.Fn('items.builder');
+	const knexQuery = query.knex(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/items/methods/exists.js

@@ -0,0 +1,8 @@
+import database from '#database/addon.js';
+
+database.Fn('items.methods.exists', async function(query)
+{
+	query.limit = 1;
+	const count = await database.Fn('items.methods.count', query);
+	return count > 0;
+});

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

@@ -0,0 +1,13 @@
+import database from '#database/addon.js';
+
+database.Fn('items.methods.many', async function(query, set = false)
+{
+	let records = await database.Fn('items.methods.query', query);
+
+	if(query.joins.length)
+	{
+		records = await database.Fn('items.transform.join', records, query.joins);
+	}
+
+	return records.map(data => query.addon.ItemAdd(data, null, false, set));
+});

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

@@ -0,0 +1,8 @@
+import database from '#database/addon.js';
+
+database.Fn('items.methods.one', async function(query, set = false)
+{
+	query.limit = 1;
+	const results = await database.Fn('items.methods.many', query, set);
+	return results.length > 0 ? results[0] : null;
+});

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

@@ -0,0 +1,29 @@
+import database from '#database/addon.js';
+
+database.Fn('items.methods.plain', async function(query)
+{
+	const builder = database.Fn('items.builder');
+	const countQuery = query.knex(query.table.name).count('* as count');
+
+	builder.applyFilters(countQuery, query.filters);
+
+	let [records, countResult] = await Promise.all([
+		database.Fn('items.methods.query', query),
+		countQuery
+	]);
+
+	if(query.joins.length)
+	{
+		records = await database.Fn('items.transform.join', records, query.joins);
+	}
+
+	const total = parseInt(countResult[0]?.count || 0);
+
+	return {
+		items: records,
+		total,
+		page: query.page,
+		pages: query.limit > 0 ? Math.ceil(total / query.limit) : 1,
+		limit: query.limit
+	};
+});