divhunt 2.0.0

package/addons/core/commands/front/items/elements/table/table.js

@@ -0,0 +1,254 @@
+divhunt.AddonReady('elements', (elements) => 
+{
+	elements.ItemAdd({
+		id: 'command-table',
+		icon: 'terminal',
+		name: 'Command Table',
+		description: 'Table that auto-generates columns and fetches data from a command.',
+		category: 'Display',
+		author: 'Divhunt',
+		config: {
+			command: {
+				type: 'string',
+				value: 'commands:get:many'
+			},
+			key: {
+				type: 'string',
+				value: 'commands'
+			},
+			params: {
+				type: 'object',
+				value: {}
+			},
+			variant: {
+				type: 'array',
+				value: ['border', 'hover', 'size-m'],
+				options: ['border', 'bg-1', 'bg-2', 'bg-3', 'striped', 'compact', 'hover', 'size-s', 'size-m', 'size-l']
+			},
+			sortable: {
+				type: 'boolean',
+				value: false
+			},
+			onRowClick: {
+				type: 'function'
+			},
+			onLoad: {
+				type: 'function'
+			},
+			onError: {
+				type: 'function'
+			}
+		},
+		render: function()
+		{
+			this.columns = [];
+			this.rows = [];
+			this.loading = true;
+			this.error = null;
+
+			// Helpers
+			this.label = (key) =>
+			{
+				return key.replace(/_/g, ' ').replace(/([A-Z])/g, ' $1').replace(/^./, s => s.toUpperCase()).trim();
+			};
+
+			// Schema parsing
+			this.parse = (schema) =>
+			{
+				if (!schema)
+				{
+					return { valid: false, columns: [] };
+				}
+
+				const target = this.key
+					? schema[this.key]
+					: Object.values(schema).find(f => f?.type === 'array');
+
+				if (!target || target.type !== 'array')
+				{
+					return { valid: false, columns: [] };
+				}
+
+				const config = target.each?.config || target.config || {};
+				const columns = [];
+
+				for (const [id, field] of Object.entries(config))
+				{
+					const type = Array.isArray(field) ? field[0] : field?.type;
+
+					if (type && type !== 'object' && type !== 'array')
+					{
+						columns.push({ id, label: this.label(id) });
+					}
+				}
+
+				return { valid: true, columns };
+			};
+
+			// Data extraction
+			this.extract = (data) =>
+			{
+				if (!data)
+				{
+					return [];
+				}
+
+				if (this.key)
+				{
+					return Array.isArray(data[this.key]) ? data[this.key] : [];
+				}
+
+				if (Array.isArray(data))
+				{
+					return data;
+				}
+
+				for (const value of Object.values(data))
+				{
+					if (Array.isArray(value))
+					{
+						return value;
+					}
+				}
+
+				return [];
+			};
+
+			// API calls
+			this.fetch = async (url, options = {}) =>
+			{
+				const response = await fetch(url, options);
+				return response.json();
+			};
+
+			this.info = async () =>
+			{
+				const data = await this.fetch('/api/commands/' + encodeURIComponent(this.command));
+
+				if (data.code !== 200)
+				{
+					throw new Error(data.message || 'Command not found');
+				}
+
+				if (!data.data.command.exposed)
+				{
+					throw new Error('Command is not exposed');
+				}
+
+				return data.data.command;
+			};
+
+			this.run = async () =>
+			{
+				const response = await this.fetch('/api/commands/run', {
+					method: 'POST',
+					headers: { 'Content-Type': 'application/json' },
+					body: JSON.stringify({ id: this.command, in: this.params || {} })
+				});
+
+				if (response.code !== 200)
+				{
+					throw new Error(response.message || 'Command failed');
+				}
+
+				return response.data;
+			};
+
+			// Local command
+			this.local = async () =>
+			{
+				const commands = divhunt.Addon('commands');
+				const command = commands.ItemGet(this.command);
+
+				if (!command)
+				{
+					return null;
+				}
+
+				const schema = command.Get('out');
+				const parsed = this.parse(schema);
+
+				if (!parsed.valid)
+				{
+					throw new Error('Command does not return array data');
+				}
+
+				this.columns = parsed.columns;
+
+				const result = await command.Fn('run', this.params || {});
+
+				return result;
+			};
+
+			// Remote command
+			this.remote = async () =>
+			{
+				const command = await this.info();
+				const schema = command.data.out;
+				const parsed = this.parse(schema);
+
+				if (!parsed.valid)
+				{
+					throw new Error('Command does not return array data');
+				}
+
+				this.columns = parsed.columns;
+
+				const result = await this.run();
+
+				return result;
+			};
+
+			// Main loader
+			this.load = async () =>
+			{
+				if (!this.command)
+				{
+					this.error = 'No command specified';
+					this.loading = false;
+					return;
+				}
+
+				try
+				{
+					const result = await this.local() || await this.remote();
+
+					this.rows = this.extract(result?.data);
+					this.loading = false;
+
+					if (this.onLoad)
+					{
+						this.onLoad({ columns: this.columns, rows: this.rows });
+					}
+				}
+				catch (err)
+				{
+					this.error = err.message;
+					this.loading = false;
+
+					if (this.onError)
+					{
+						this.onError({ error: err.message });
+					}
+				}
+			};
+
+			this.load();
+
+			return `
+				<div class="holder">
+					<e-loader dh-if="loading"></e-loader>
+					<div dh-if="error" class="error">{{ error }}</div>
+					<e-table
+						dh-if="!loading && !error"
+						:columns="columns"
+						:rows="rows"
+						:variant="variant"
+						:sortable="sortable"
+						:onRowClick="onRowClick"
+					></e-table>
+				</div>
+			`;
+		}
+	});
+})

package/addons/core/database/README.md

@@ -0,0 +1,276 @@
+# Database Service
+
+A comprehensive database abstraction layer built on top of Knex.js providing a powerful query builder, CRUD operations, and relationship management for PostgreSQL databases.
+
+## Features
+
+- **Advanced Query Builder** - Fluent API for complex queries with filtering, sorting, pagination
+- **CRUD Operations** - Create, read, update, delete with automatic timestamp management
+- **Relationship Management** - One-to-one and one-to-many relationship handling
+- **Transaction Support** - Database transaction wrapper for atomic operations
+- **Validation** - Built-in field and parameter validation
+- **Connection Management** - Automatic PostgreSQL connection pooling via Knex.js
+- **Middleware Integration** - Seamless integration with framework middleware system
+
+## Installation
+
+```javascript
+import database from '#database/load.js';
+```
+
+## Configuration
+
+Create a database connection item:
+
+```javascript
+const dbConnection = database.ItemAdd({
+    hostname: 'localhost',
+    port: 5432,
+    username: 'postgres',
+    password: 'password',
+    database: 'myapp'
+});
+```
+
+## Framework Integration
+
+The database service integrates seamlessly with the framework's middleware system. Each addon automatically gets `Find()` method, and each item gets `Create()`, `Update()`, `Delete()` methods that call middleware interceptors.
+
+### Addon Methods
+
+```javascript
+// Every addon has a Find() method
+const users = await userAddon.Find()
+    .filter('status', 'active')
+    .many();
+```
+
+### Item Methods
+
+```javascript
+// Every item has CRUD methods
+await userItem.Create('primary');    // Creates new record
+await userItem.Update('primary');    // Updates existing record  
+await userItem.Delete('primary');    // Deletes record
+```
+
+These methods work by calling middleware interceptors:
+
+```javascript
+// How item methods work internally
+const AddonItemCrud = {
+    async Create(connection = 'primary') {
+        const value = {item: this, table: this.addon.TableGet(), response: null, connection};
+        await this.addon.divhunt.Middleware('item.crud.create', value);
+        return value.response;
+    },
+
+    async Update(connection = 'primary') {
+        const value = {item: this, table: this.addon.TableGet(), response: null, connection};
+        await this.addon.divhunt.Middleware('item.crud.update', value);
+        return value.response;
+    },
+
+    async Delete(connection = 'primary') {
+        const value = {item: this, table: this.addon.TableGet(), response: null, connection};
+        await this.addon.divhunt.Middleware('item.crud.delete', value);
+        return value.response;
+    }
+};
+```
+
+The database service intercepts these middleware calls:
+- `item.crud.create` → `database.Fn('create')`
+- `item.crud.update` → `database.Fn('update')`  
+- `item.crud.delete` → `database.Fn('delete')`
+- `addon.items.find` → `database.Fn('find')`
+
+## Basic Usage
+
+### Finding Records
+
+```javascript
+// Simple find
+const users = await database.Fn('find', connection, table, addon)
+    .filter('status', 'active')
+    .many();
+
+// Complex filtering
+const results = await database.Fn('find', connection, table, addon)
+    .filter('age', 18, 'GREATER EQUALS')
+    .filter('name', 'John%', 'LIKE')
+    .sort('created_at', 'desc')
+    .limit(10)
+    .page(2)
+    .many();
+
+// Grouped conditions
+const users = await database.Fn('find', connection, table, addon)
+    .group('OR')
+        .filter('status', 'premium')
+        .filter('trial_expires', new Date(), 'GREATER')
+    .end()
+    .filter('active', true)
+    .many();
+```
+
+### CRUD Operations
+
+```javascript
+// Framework integration - automatic methods on items
+await userItem.Create('primary');
+await userItem.Update('primary');  
+await userItem.Delete('primary');
+
+// Direct database service usage
+await database.Fn('create', connection, table, item);
+await database.Fn('update', connection, table, item);
+await database.Fn('delete', connection, table, item);
+
+// Item-level functions (bypassing middleware)
+await item.save();
+await item.create(addon);
+await item.update();
+await item.delete();
+```
+
+### Framework vs Direct Usage
+
+```javascript
+// Framework way (goes through middleware)
+const user = userAddon.ItemAdd({name: 'John', email: 'john@example.com'});
+await user.Create('primary');
+
+// Direct way (bypasses middleware)  
+const user = userAddon.ItemAdd({name: 'John', email: 'john@example.com'});
+await user.save();
+
+// Both achieve the same result, framework way allows middleware interception
+```
+
+### Item-Level Operations
+
+```javascript
+// Direct item operations
+await item.create(addon);
+await item.update();
+await item.delete();
+await item.save();
+
+// Find related items
+const user = await item.relation('user_id', userAddon);
+const comments = await item.relations('post_id', commentAddon);
+```
+
+## Query Methods
+
+### Filters
+
+| Operator | Description | Example |
+|----------|-------------|---------|
+| `EQUALS` | Exact match (default) | `.filter('status', 'active')` |
+| `NOT EQUALS` | Not equal | `.filter('status', 'inactive', 'NOT EQUALS')` |
+| `GREATER` | Greater than | `.filter('age', 18, 'GREATER')` |
+| `LESS` | Less than | `.filter('price', 100, 'LESS')` |
+| `LIKE` | Pattern matching | `.filter('name', 'John%', 'LIKE')` |
+| `IN` | Value in list | `.filter('status', ['active', 'pending'], 'IN')` |
+| `BETWEEN` | Between values | `.filter('age', [18, 65], 'BETWEEN')` |
+| `NULL` | Is null | `.filter('deleted_at', null, 'NULL')` |
+
+### Query Builder Methods
+
+```javascript
+const query = database.Fn('find', connection, table, addon);
+
+// Filtering
+query.filter(field, value, operator)
+query.orFilter(field, value, operator)
+
+// Grouping
+query.group('AND|OR')
+    .filter(...)
+    .filter(...)
+.end()
+
+// Sorting & Pagination
+query.sort(field, 'asc|desc')
+query.limit(count)
+query.page(number)
+
+// Selection
+query.select(['field1', 'field2'])
+query.distinct()
+
+// Execution
+await query.many()      // Get multiple records
+await query.one()       // Get single record
+await query.count()     // Get count
+await query.exists()    // Check if exists
+```
+
+## Transactions
+
+```javascript
+await item.transaction(async (trx) => {
+    await database.Fn('create', trx, table1, item1);
+    await database.Fn('update', trx, table2, item2);
+    // Auto-commit on success, auto-rollback on error
+});
+```
+
+## Relationships
+
+```javascript
+// One-to-one relationship
+const user = await post.relation('user_id', userAddon);
+
+// One-to-many relationship  
+const comments = await post.relations('post_id', commentAddon);
+```
+
+## Validation
+
+The service includes automatic validation for:
+- Field names (alphanumeric + underscore + dot, max 64 chars)
+- Operators (must be from supported list)
+- Values (string, number, boolean, or null)
+- Pagination parameters (positive integers)
+- Sort directions ('asc' or 'desc')
+
+## Error Handling
+
+All operations include comprehensive error handling with descriptive messages:
+
+```javascript
+try {
+    const results = await query.filter('invalid-field!', 'value').many();
+} catch (error) {
+    // Error: Invalid field name format: 'invalid-field!'...
+}
+```
+
+## Architecture
+
+The service uses a layered architecture:
+
+1. **Item Functions** - Core database operations
+2. **Main Functions** - Thin wrappers calling item functions  
+3. **Middleware** - Framework integration layer
+4. **Query Builder** - Fluent API for complex queries
+
+This design ensures code reuse and maintains consistency across all access patterns.
+
+## Connection Management
+
+Connections are automatically managed with:
+- Connection pooling (0-25 connections)
+- 1-second timeouts for acquisition and idle
+- Automatic cleanup and error handling
+
+## Data Schemas
+
+The service defines validation schemas for:
+- `filter` - Query filter structure
+- `query` - Complete query parameters
+
+These ensure type safety and parameter validation throughout the system.

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

@@ -0,0 +1,14 @@
+import divhunt from '#framework/load.js';
+
+const database = divhunt.Addon('database', (addon) =>
+{
+    addon.Field('id', ['string']);
+    addon.Field('port', ['number', 5432]);
+    addon.Field('connection', ['function|object']);
+    addon.Field('hostname', ['string']);
+    addon.Field('username', ['string']);
+    addon.Field('password', ['string']);
+    addon.Field('database', ['string']);
+});
+
+export default database;

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

@@ -0,0 +1,18 @@
+import divhunt from '#framework/load.js';
+
+divhunt.EmitOn('addon.add', (addon) =>
+{
+    addon.expose = null;
+
+    addon.Expose = function(config)
+    {
+        config = divhunt.DataDefine(config, {
+            filter: ['array', []],
+            sort: ['array', []],
+            select: ['array', []],
+            callback: ['function']
+        });
+
+        addon.expose = config;
+    };
+});

package/addons/core/database/back/events/middleware/addon.items.find.js

@@ -0,0 +1,24 @@
+import divhunt from '#framework/load.js';
+import database from '#database/addon.js';
+
+divhunt.MiddlewareIntercept('addon.items.find', (middleware) =>
+{
+    let { addon, table, connection } = middleware.value;
+
+    if(!table.name)
+    {
+        throw new Error('Addon must have table name set.');
+    }
+
+    if(typeof connection === 'string')
+    {
+        connection = database.ItemGet(connection)?.Get('connection');
+    }
+
+    if(!connection)
+    {
+        throw new Error('Database connection is not present.');
+    }
+
+    middleware.value.response = database.Fn('find', connection, table, addon);
+});

package/addons/core/database/back/events/middleware/item.crud.create.js

@@ -0,0 +1,24 @@
+import divhunt from '#framework/load.js';
+import database from '#database/addon.js';
+
+divhunt.MiddlewareIntercept('item.crud.create', async (middleware) =>
+{
+    let { item, table, connection } = middleware.value;
+
+    if(!table.name)
+    {
+        throw new Error('Addon must have table name set.');
+    }
+
+    if(typeof connection === 'string')
+    {
+        connection = database.ItemGet(connection)?.Get('connection');
+    }
+
+    if(!connection)
+    {
+        throw new Error('Database connection is not present.');
+    }
+
+    middleware.value.response = database.Fn('create', connection, table, item);
+});

package/addons/core/database/back/events/middleware/item.crud.delete.js

@@ -0,0 +1,24 @@
+import divhunt from '#framework/load.js';
+import database from '#database/addon.js';
+
+divhunt.MiddlewareIntercept('item.crud.delete', async (middleware) =>
+{
+    let { item, table, connection } = middleware.value;
+
+    if(!table.name)
+    {
+        throw new Error('Addon must have table name set.');
+    }
+
+    if(typeof connection === 'string')
+    {
+        connection = database.ItemGet(connection)?.Get('connection');
+    }
+
+    if(!connection)
+    {
+        throw new Error('Database connection is not present.');
+    }
+
+    middleware.value.response = database.Fn('delete', connection, table, item);
+});

package/addons/core/database/back/events/middleware/item.crud.update.js

@@ -0,0 +1,24 @@
+import divhunt from '#framework/load.js';
+import database from '#database/addon.js';
+
+divhunt.MiddlewareIntercept('item.crud.update', async (middleware) =>
+{
+    let { item, table, connection } = middleware.value;
+
+    if(!table.name)
+    {
+        throw new Error('Addon must have table name set.');
+    }
+
+    if(typeof connection === 'string')
+    {
+        connection = database.ItemGet(connection)?.Get('connection');
+    }
+
+    if(!connection)
+    {
+        throw new Error('Database connection is not present.');
+    }
+
+    middleware.value.response = database.Fn('update', connection, table, item);
+});

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

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

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

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