divhunt 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dejan Tomic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,86 @@
+# Divhunt Framework
+
+Full-stack isomorphic JavaScript framework built from scratch. No React, no Express, no Vue — original architecture from zero.
+
+One universal abstraction — the **addon** — powers databases, servers, commands, pages, directives, queues, and more. Define an addon with fields, and you get: data validation, event system, middleware chains, CRUD with PostgreSQL, automatic API exposure, frontend reactivity, and DOM manipulation — all from a single definition.
+
+Built by [Dejan Tomic](https://github.com/tomic-d). Powers multiple production applications including a cloud SaaS platform serving thousands of users, a travel agency website with 27 addons and 50+ frontend components, a distributed function execution gateway, and a multi-tenant CMS.
+
+## Quick Look
+
+```js
+import divhunt from '#framework/load.js';
+import database from '#database/load.js';
+import commands from '#commands/load.js';
+
+// Define an addon — typed, persistent, full CRUD
+const users = divhunt.Addon('users', (addon) => {
+    addon.Table('users');
+    addon.Field('id', ['string']);
+    addon.Field('name', ['string', null, true]);
+    addon.Field('email', ['string', null, true]);
+    addon.Field('created_at', ['string']);
+});
+
+// Connect database — all addons with Table() persist automatically
+database.Item({
+    id: 'primary',
+    hostname: process.env.DB_HOSTNAME,
+    username: process.env.DB_USERNAME,
+    database: process.env.DB_DATABASE,
+    password: process.env.DB_PASSWORD
+});
+
+// Start HTTP server
+commands.Fn('http.server', 3000, {
+    onStart: () => console.log('Server started on port 3000')
+});
+
+// Define an API endpoint with typed input/output
+divhunt.AddonReady('commands', (commands) => {
+    commands.Item({
+        id: 'users:get:many',
+        method: 'GET',
+        endpoint: '/api/users',
+        exposed: true,
+        callback: async function(properties, resolve) {
+            const items = await users.Find()
+                .sort('created_at', 'desc')
+                .page(properties.page || 1)
+                .limit(properties.limit || 20)
+                .many();
+
+            resolve({
+                users: items.map(u => u.Get(['id', 'name', 'email', 'created_at']))
+            });
+        }
+    });
+});
+```
+
+## Documentation
+
+| Topic | What's covered |
+|---|---|
+| [Addons](docs/addons.md) | Addon definition, fields, functions, lifecycle events, preloading |
+| [Database](docs/database.md) | Connection, fluent ORM, query builder, 17+ operators, joins |
+| [Commands](docs/commands.md) | API endpoints, typed input/output, CRUD patterns, dynamic registration |
+| [Servers](docs/servers.md) | HTTP setup, gRPC streaming, binary transport, Store API |
+| [Frontend](docs/frontend.md) | Pages, components, directives, asset bundling, reactivity |
+| [Architecture](docs/architecture.md) | File structure, design decisions, mixin composition |
+
+## Install
+
+```bash
+npm install divhunt
+```
+
+Requires Node.js >= 18.
+
+## Origin
+
+Originally built as the core of [Divhunt](https://divhunt.com), a cloud SaaS platform. The framework (v1) powered the entire platform — backend and frontend — serving thousands of users for 4+ years. This is v2: rebuilt with Proxy-based reactivity, improved addon architecture, gRPC transport, and a complete render system.
+
+## License
+
+[MIT](LICENSE)

package/addons/core/clients/LICENSE.txt

@@ -0,0 +1,40 @@
+Copyright © 2025 Divhunt GmbH
+
+This License governs use of the Divhunt framework (the "Software"). By accessing or using the Software, you agree to be bound by the terms of this License.
+
+1. GRANT OF LICENSE  
+   You are granted a limited, non-exclusive, non-transferable, non-sublicensable license to use the Software solely for:
+   - personal projects;
+   - internal business purposes;
+   - client work, provided the client is not reselling or redistributing the Software.
+
+2. ATTRIBUTION AND BRANDING  
+   a. All uses of the Software must retain visible attribution to “Divhunt”.  
+   b. You must not remove, obscure, alter, or suppress any branding, notices, or credits related to Divhunt.  
+   c. Any public project using the Software must clearly state that it uses the “Divhunt Framework”.
+
+3. PROHIBITED USES  
+   The following are strictly prohibited:  
+   a. Rebranding, renaming, or representing the Software as your own work;  
+   b. Creating derivative frameworks or similar software tools based on the Software with the intent of distribution;  
+   c. Redistributing, sublicensing, or selling the Software or any modified version thereof;  
+   d. Using the Software in any commercial product, service, or offering without explicit, written permission from Divhunt GmbH.
+
+4. MODIFICATIONS  
+   You may modify the Software for personal or internal use only. Modified versions may not be:  
+   - redistributed;  
+   - rebranded or marketed as original work;  
+   - offered as a service or product.
+
+5. ENFORCEMENT AND TERMINATION  
+   Any violation of this License will result in the immediate termination of all rights granted herein. Divhunt GmbH reserves the right to pursue legal remedies including but not limited to damages, injunctions, and recovery of profits obtained through unauthorized use.
+
+6. NO WARRANTY  
+   THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. IN NO EVENT SHALL JOVANAT GMBH BE LIABLE FOR ANY DAMAGES ARISING FROM THE USE OR INABILITY TO USE THE SOFTWARE.
+
+7. GOVERNING LAW  
+   This License shall be governed by and construed in accordance with the laws of Switzerland. All disputes shall be subject to the exclusive jurisdiction of the courts of Zug, Switzerland.
+
+---
+
+For commercial licensing or other questions, please contact: **dejan@divhunt.com**

package/addons/core/clients/README.md

@@ -0,0 +1,123 @@
+## Built with the Divhunt Framework – non-commercial use only. For commercial use, contact dejan@divhunt.com.
+
+# Clients Addon
+
+HTTP and gRPC client connectivity for Divhunt applications.
+
+## Features
+
+- **HTTP Client**: REST API communication with timeout, retries, and middleware
+- **gRPC Client**: High-performance streaming and unary calls
+- **Event Callbacks**: Connection, request, response, and error handling
+- **Auto-retry**: Configurable timeout and connection management
+
+## HTTP Client
+
+```javascript
+import clients from '#clients/load.js';
+
+clients.Item({
+    id: 'api',
+    type: 'http',
+    host: 'localhost',
+    port: 3000,
+    timeout: 15,
+    onConnect: (client) => console.log('HTTP client connected'),
+    onError: (error) => console.error('HTTP error:', error)
+});
+
+// Usage
+const api = clients.Item('api');
+const result = await api.Fn('http.get', '/users', {page: 1});
+await api.Fn('http.post', '/users', {name: 'John'});
+```
+
+## gRPC Client
+
+```javascript
+import clientsGRPC from '#clients/grpc/load.js';
+
+clientsGRPC.Item({
+    id: 'service',
+    host: 'localhost',
+    port: 50000,
+    timeout: 15,
+    metadata: {authorization: 'Bearer token'},
+    onConnect: (client) => console.log('gRPC client connected'),
+    onStreamData: (stream, payload) => console.log('Received:', payload)
+});
+
+// Streaming
+const service = clientsGRPC.Item('service');
+const stream = await service.Fn('stream');
+const response = await stream.request('users', 'findAll', {limit: 10});
+```
+
+## Commands Integration
+
+```javascript
+import commands from '#commands/load.js';
+import clients from '#clients/load.js';
+
+commands.Item({
+    id: 'proxy:users',
+    method: 'GET',
+    endpoint: '/api/users',
+    callback: async function(properties, resolve)
+    {
+        const api = clients.Item('api');
+        const result = await api.Fn('http.get', '/users', properties);
+        
+        resolve(result.data, result.message, result.code);
+    }
+});
+
+commands.Item({
+    id: 'grpc:analytics',
+    method: 'POST',
+    endpoint: '/analytics/process',
+    callback: async function(properties, resolve)
+    {
+        const service = clientsGRPC.Item('analytics');
+        const stream = await service.Fn('stream');
+        const result = await stream.request('analytics', 'process', properties);
+        
+        resolve(result.data);
+    }
+});
+```
+
+## Error Handling
+
+```javascript
+clients.Item({
+    id: 'resilient-api',
+    type: 'http',
+    host: 'api.example.com',
+    port: 443,
+    onError: (error, context) =>
+    {
+        console.error(`Request failed: ${error}`);
+        // Implement retry logic, fallback, or alerting
+    },
+    onComplete: (result, context) =>
+    {
+        console.log(`Request completed in ${result.duration}ms`);
+    }
+});
+```
+
+## Events
+
+```javascript
+divhunt.EmitOn('clients.http.request.before', (http) =>
+{
+    http.data.timestamp = Date.now();
+    http.headers = {'X-Client-Version': '1.0.0'};
+});
+
+divhunt.EmitOn('clients.grpc.connect', (client) =>
+{
+    console.log('gRPC client ready for requests');
+});
+```

package/addons/core/clients/back/grpc/addon.js

@@ -0,0 +1,25 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import divhunt from '#framework/load.js';
+
+const clientsGRPC = divhunt.Addon('clients.grpc', (addon) =>
+{
+    addon.Field('id', ['string|number']);
+    addon.Field('instance', ['object']);
+    addon.Field('host', ['string', 'localhost']);
+    addon.Field('port', ['number', 50000]);
+    addon.Field('timeout', ['number', 5]);
+    addon.Field('metadata', ['object', {}]);
+    
+    addon.Field('onError', ['function']);
+    addon.Field('onConnect', ['function']);
+
+    addon.Field('onStream', ['function']);
+    addon.Field('onStreamError', ['function']);
+    addon.Field('onStreamEnd', ['function']);
+    addon.Field('onStreamData', ['function']);
+    addon.Field('onStreamRequest', ['function']);
+    addon.Field('onStreamRespond', ['function']);
+});
+
+export default clientsGRPC;

package/addons/core/clients/back/grpc/item/catch/add.js

@@ -0,0 +1,8 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import clientsGRPC from '#clients/grpc/addon.js';
+
+clientsGRPC.ItemOn('add', function(item)
+{
+    item.Fn('connect');
+});

package/addons/core/clients/back/grpc/item/functions/connect.js

@@ -0,0 +1,73 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import { fileURLToPath } from 'url'
+import { dirname, join } from 'path'
+
+import clientsGRPC from '#clients/grpc/addon.js';
+
+clientsGRPC.Fn('item.connect', async function(item)
+{
+    if(item.Get('instance'))
+    {
+        return item.Get('instance');
+    }
+
+    try
+    {
+        const grpcModule = await import('@grpc/grpc-js');
+        const protoLoaderModule = await import('@grpc/proto-loader');
+
+        const grpc = grpcModule.default || grpcModule;
+        const protoLoader = protoLoaderModule.default || protoLoaderModule;
+
+        const protoPath = join(dirname(fileURLToPath(import.meta.url)), '/../../service.proto');
+
+        const definition = protoLoader.loadSync(protoPath, 
+        {
+            keepCase: true,
+            longs: String,
+            enums: String,
+            defaults: true,
+            oneofs: true
+        });
+
+        const universalPackage = grpc.loadPackageDefinition(definition).universal;
+        
+        const client = new universalPackage.UniversalService(`${item.Get('host')}:${item.Get('port')}`, grpc.credentials.createSsl(), {
+            'grpc.max_send_message_length': 1024 * 1024 * 100,
+            'grpc.max_receive_message_length': 1024 * 1024 * 100,
+            'grpc.keepalive_time_ms': 30000,
+            'grpc.keepalive_timeout_ms': 10000,
+            'grpc.keepalive_permit_without_calls': 1
+        });
+
+        item.Set('instance', client);
+
+        await new Promise((resolve, reject) => 
+        {
+            client.waitForReady(new Date(Date.now() + item.Get('timeout') * 1000), (error) => 
+            {
+                if(error) 
+                {
+                    reject(error);
+                } 
+                else 
+                {
+                    resolve();
+                }
+            });
+        });
+
+        
+        item.Get('onConnect') && item.Get('onConnect').call(item, client);
+
+        return client;
+    }
+    catch(error)
+    {
+        item.Get('instance')?.close();
+        item.Set('instance', null);
+        
+        item.Get('onError') && item.Get('onError').call(item, error.message);
+    }
+});

package/addons/core/clients/back/grpc/item/functions/resolve.js

@@ -0,0 +1,41 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import clientsGRPC from '#clients/grpc/addon.js';
+
+const promises = {};
+
+clientsGRPC.Fn('item.resolve', function(item, id, payload = null, onChunk = null)
+{
+    if(payload === null)
+    {
+        const timeout = setTimeout(() =>
+        {
+            promises[id].resolve({data: null, message: 'Request timed out after 60 seconds. No response received.', code: 500, id, time: 60000});
+            delete(promises[id]);
+        }, 60000);
+
+        return new Promise((resolve) =>
+        {
+            promises[id] = { resolve, timeout, onChunk, time: performance.now() };
+        });
+    }
+
+    if(!promises[id])
+    {
+        return;
+    }
+
+    if(promises[id].onChunk && !payload.end)
+    {
+        promises[id].onChunk(payload);
+    }
+
+    if(payload.end)
+    {
+        payload.time = (performance.now() - promises[id].time).toFixed(2);
+        promises[id].resolve(payload);
+        clearTimeout(promises[id].timeout);
+
+        delete promises[id];
+    }
+});

package/addons/core/clients/back/grpc/item/functions/stream.js

@@ -0,0 +1,103 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import clientsGRPC from '#clients/grpc/addon.js';
+import divhunt from '#framework/load.js';
+
+clientsGRPC.Fn('item.stream', async function(item)
+{
+    const client = item.Get('instance');
+
+    if(!client)
+    {
+        return;
+    }
+
+    try
+    {
+        const grpcModule = await import('@grpc/grpc-js');
+        const grpc = grpcModule.default || grpcModule;
+
+        const metadata = new grpc.Metadata();
+
+        Object.entries(item.Get('metadata')).forEach(([key, value]) => 
+        {
+            metadata.add(key, value);
+        });
+
+        const stream = client.Stream(metadata);
+
+        stream.request = function(name, data, onChunk = null, id = null)
+        {
+            id = id || divhunt.GenerateUID();
+
+            const extracted = divhunt.BinariesExtract(data);
+
+            stream.write({
+                data: JSON.stringify({type: 'request', name, data: extracted.data, id}),
+                binaries: extracted.binaries
+            });
+
+            item.Get('onStreamRequest') && item.Get('onStreamRequest').call(item, stream, {type: 'request', name, data, binaries: extracted.binaries, id});
+
+            return item.Fn('resolve', id, null, onChunk);
+        };
+
+        stream.respond = function(data, message, code, end = true, id = null)
+        {
+            id = id || divhunt.GenerateUID();
+
+            const extracted = divhunt.BinariesExtract(data);
+
+            stream.write({
+                data: JSON.stringify({type: 'respond', data: extracted.data, message, code, id, end}),
+                binaries: extracted.binaries
+            });
+
+            item.Get('onStreamRespond') && item.Get('onStreamRespond').call(item, stream, {type: 'respond', data, binaries: extracted.binaries, message, code, id, end});
+        };
+
+        item.Get('onStream') && item.Get('onStream').call(item, stream);
+
+        stream.on('data', (response) =>
+        {
+            const payload = JSON.parse(response.data);
+
+            if(payload.data && response.binaries)
+            {
+                payload.data = divhunt.BinariesInject(payload.data, response.binaries);
+            }
+
+            if(payload.type === 'respond')
+            {
+                item.Fn('resolve', payload.id, payload);
+            }
+
+            item.Get('onStreamData') && item.Get('onStreamData').call(item, stream, payload);
+        });
+
+        stream.on('error', (error) => 
+        {
+            item.Get('onStreamError') && item.Get('onStreamError').call(item, stream, error.message);
+        });
+
+        stream.on('end', () => 
+        {
+            item.Get('onStreamEnd') && item.Get('onStreamEnd').call(item, stream);
+
+            item.Get('instance').close();
+            item.Set('instance', null);
+        });
+
+        return stream;
+    }
+    catch(error)
+    {
+        if(item.Get('instance'))
+        {
+            item.Get('instance').close();
+            item.Set('instance', null);
+        }
+
+        item.Get('onError') && item.Get('onError').call(item, error.message);
+    }
+});

package/addons/core/clients/back/grpc/load.js

@@ -0,0 +1,11 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import clientsGRPC from '#clients/grpc/addon.js';
+
+import '#clients/grpc/item/catch/add.js';
+
+import '#clients/grpc/item/functions/connect.js';
+import '#clients/grpc/item/functions/stream.js';
+import '#clients/grpc/item/functions/resolve.js';
+
+export default clientsGRPC;

package/addons/core/clients/back/grpc/service.proto

@@ -0,0 +1,20 @@
+syntax = "proto3";
+
+package universal;
+
+service UniversalService 
+{
+    rpc Stream (stream Request) returns (stream Response);
+}
+
+message Request
+{
+    string data = 1;
+    map<string, bytes> binaries = 2;
+}
+
+message Response
+{
+    string data = 1;
+    map<string, bytes> binaries = 2;
+}

package/addons/core/clients/back/http/addon.js

@@ -0,0 +1,21 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import divhunt from '#framework/load.js';
+
+const clients = divhunt.Addon('clients', (addon) =>
+{
+    addon.Field('id', ['string']);
+    addon.Field('instance', ['object']);
+    addon.Field('type', ['string', 'http']);
+    addon.Field('host', ['string', 'localhost']);
+    addon.Field('port', ['number', 3000]);
+    addon.Field('timeout', ['number', 15]);
+    
+    addon.Field('onConnect', ['function']);
+    addon.Field('onRequest', ['function']);
+    addon.Field('onResponse', ['function']);
+    addon.Field('onError', ['function']);
+    addon.Field('onComplete', ['function']);
+});
+
+export default clients;

package/addons/core/clients/back/http/item/catch/add.js

@@ -0,0 +1,18 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import clients from '#clients/addon.js';
+
+clients.ItemOn('add', function(item)
+{
+    switch(item.Get('type').toLowerCase())
+    {
+        case 'http':
+            item.Fn('http.create');
+            break;
+        case 'grpc':
+            item.Fn('gRPC.create');
+            break;
+        default:
+            item.Get('onError') && item.Get('onError')('Client type does not exist.');
+    }
+});