divhunt 2.0.10 → 2.0.12

package/addons/core/commands/back/functions/http/server.js

@@ -25,8 +25,8 @@ commands.Fn('http.server', async function(port = 3000, callbacks = {})
 
             if(!command || !command.Get('exposed'))
             {
-                http.response.code = 404;
-                http.response.message = 'Command not found.';
+                http.respond.code = 404;
+                http.respond.message = 'Command not found.';
 
                 callbacks['onResponse'] && callbacks['onResponse'](http);
                 return;
@@ -47,7 +47,7 @@ commands.Fn('http.server', async function(port = 3000, callbacks = {})
             {
                 http.data.streaming = 1;
                 http.prevent = true;
-                http.raw.writeHead(200, {
+                http.response.writeHead(200, {
                     'Content-Type': type.contentType,
                     'Transfer-Encoding': 'chunked'
                 });
@@ -58,7 +58,7 @@ commands.Fn('http.server', async function(port = 3000, callbacks = {})
                 if(http.data.streaming)
                 {
                     http.data.streaming++;
-                    http.raw.write(type.formatter(chunk.data) + '\n');
+                    http.response.write(type.formatter(chunk.data) + '\n');
                 }
 
                 callbacks['onChunk'] && callbacks['onChunk'](http, chunk);
@@ -68,16 +68,16 @@ commands.Fn('http.server', async function(port = 3000, callbacks = {})
             {
                 if(http.data.streaming === 1)
                 {
-                    http.raw.write(type.formatter(response.data) + '\n');
+                    http.response.write(type.formatter(response.data) + '\n');
                 }
 
-                http.raw.end();
+                http.response.end();
             }
 
-            http.response.type = command.Get('type');
-            http.response.data = response.data;
-            http.response.message = response.message;
-            http.response.code = response.code;
+            http.respond.type = command.Get('type');
+            http.respond.data = response.data;
+            http.respond.message = response.message;
+            http.respond.code = response.code;
 
             callbacks['onResponse'] && callbacks['onResponse'](http);
         },

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

@@ -1,90 +1,92 @@
-directives.ItemAdd({
-	id: 'dh-command',
-	icon: 'terminal',
-	name: 'Command',
-	description: 'Execute a command instantly on render',
-	category: 'data',
-	trigger: 'node',
-	order: 664,
-	strict: false,
-	tag: 'dh-command',
-	attributes: {
-		'command': ['string', null, true],
-		'bind': ['string', 'command'],
-		'_success': ['function'],
-		'_error': ['function'],
-		'data': ['object', {}],
-		'api': ['boolean', false]
-	},
-	code: function(data, item, compile, node, identifier)
-	{
-		if(node.tagName.toLowerCase() !== 'dh-command')
+divhunt.AddonReady('directives', function()
+{
+	directives.ItemAdd({
+		id: 'dh-command',
+		icon: 'terminal',
+		name: 'Command',
+		description: 'Execute a command instantly on render',
+		category: 'data',
+		trigger: 'node',
+		order: 664,
+		strict: false,
+		tag: 'dh-command',
+		attributes: {
+			'command': ['string', null, true],
+			'bind': ['string', 'command'],
+			'_success': ['function'],
+			'_error': ['function'],
+			'data': ['object', {}],
+			'api': ['boolean', false]
+		},
+		code: function(data, item, compile, node, identifier)
 		{
-			return;
-		}
-
-		const config = {};
-		const methods = {};
-
-		methods.init = () =>
-		{
-			methods.config();
-
-			if(compile.data[config.bind] !== undefined)
+			if(node.tagName.toLowerCase() !== 'dh-command')
 			{
 				return;
 			}
 
-			compile.data[config.bind] = null;
-			methods.run();
-		};
+			const config = {};
+			const methods = {};
 
-		methods.config = () =>
-		{
-			config.command = data['command'].value;
-			config.bind = data['bind'].value;
-			config.onSuccess = data['_success'].value;
-			config.onError = data['_error'].value;
-			config.data = data['data'].value;
-			config.api = data['api'].value;
-		};
+			methods.init = () =>
+			{
+				methods.config();
 
-		methods.run = async () =>
-		{
-			const state = {
-				response: null,
-				error: null,
-				loading: true
+				if(compile.data[config.bind] !== undefined)
+				{
+					return;
+				}
+
+				compile.data[config.bind] = null;
+				methods.run();
 			};
 
-			try
+			methods.config = () =>
 			{
-				const result = config.api
-					? await commands.Fn('api', config.command, config.data)
-					: await commands.Fn('run', config.command, config.data);
-
-				state.response = result;
-				state.error    = null;
-				state.loading  = false;
+				config.command = data['command'].value;
+				config.bind = data['bind'].value;
+				config.onSuccess = data['_success'].value;
+				config.onError = data['_error'].value;
+				config.data = data['data'].value;
+				config.api = data['api'].value;
+			};
 
-				config.onSuccess && config.onSuccess(state);
-			}
-			catch(error)
+			methods.run = async () =>
 			{
-				state.response = null;
-				state.error    = error.message;
-				state.loading  = false;
+				const state = {
+					response: null,
+					error: null,
+					loading: true
+				};
 
-				config.onError && config.onError(state);
-			}
-			finally
-			{
-				
-				compile.data[config.bind] = state;
-				compile.data.Update();
-			}
-		};
+				try
+				{
+					const result = config.api
+						? await commands.Fn('api', config.command, config.data)
+						: await commands.Fn('run', config.command, config.data);
 
-		methods.init();
-	}
+					state.response = result;
+					state.error    = null;
+					state.loading  = false;
+
+					config.onSuccess && config.onSuccess(state);
+				}
+				catch(error)
+				{
+					state.response = null;
+					state.error    = error.message;
+					state.loading  = false;
+
+					config.onError && config.onError(state);
+				}
+				finally
+				{
+					compile.data[config.bind] = state;
+					compile.data.Update();
+				}
+			};
+
+			methods.init();
+		}
+	});
 });

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

@@ -1,139 +1,139 @@
-directives.ItemAdd({
-	id: 'dh-command-submit',
-	icon: 'terminal',
-	name: 'Command Submit',
-	description: 'Submit form data to a command via commands.Fn',
-	category: 'data',
-	trigger: 'node',
-	order: 665,
-	strict: false,
-	tag: 'dh-command-submit',
-	attributes: {
-		'command': ['string', null, true],
-		'bind': ['string', 'command'],
-		'_success': ['function'],
-		'_error': ['function'],
-		'reset': ['boolean', false],
-		'stop': ['boolean', false],
-		'data': ['object', {}],
-		'api': ['boolean', false]
-	},
-	code: function(data, item, compile, node, identifier)
-	{
-		const config = {};
-		const methods = {};
-
-		methods.init = () =>
+divhunt.AddonReady('directives', function()
+{
+	directives.ItemAdd({
+		id: 'dh-command-submit',
+		icon: 'terminal',
+		name: 'Command Submit',
+		description: 'Submit form data to a command via commands.Fn',
+		category: 'data',
+		trigger: 'node',
+		order: 665,
+		strict: false,
+		tag: 'dh-command-submit',
+		attributes: {
+			'command': ['string', null, true],
+			'bind': ['string', 'command'],
+			'_success': ['function'],
+			'_error': ['function'],
+			'reset': ['boolean', false],
+			'stop': ['boolean', false],
+			'data': ['object', {}],
+			'api': ['boolean', false]
+		},
+		code: function(data, item, compile, node, identifier)
 		{
-			methods.config();
-			methods.state();
-			methods.element();
-			methods.handler();
-		};
+			const config = {};
+			const methods = {};
 
-		methods.state = () =>
-		{
-			if(!compile.data[config.bind])
+			methods.init = () =>
 			{
-				compile.data[config.bind] = {
-					response: null,
-					error: null,
-					loading: false
-				};
-			}
-		};
-
-		methods.config = () =>
-		{
-			config.command = data['command'].value;
-			config.bind = data['bind'].value;
-			config.onSuccess = data['_success'].value;
-			config.onError = data['_error'].value;
-			config.reset = data['reset'].value;
-			config.stop = data['stop'].value;
-			config.data = data['data'].value;
-			config.api = data['api'].value;
-		};
-
-		methods.element = () =>
-		{
-			config.form = document.createElement('form');
-			config.form.setAttribute('autocomplete', 'off');
+				methods.config();
+				methods.state();
+				methods.element();
+				methods.handler();
+			};
 
-			while(node.firstChild)
+			methods.state = () =>
 			{
-				config.form.appendChild(node.firstChild);
-			}
+				if(!compile.data[config.bind])
+				{
+					compile.data[config.bind] = {
+						response: null,
+						error: null,
+						loading: false
+					};
+				}
+			};
 
-			node.appendChild(config.form);
-			divhunt.FormSet(config.form, config.data);
-		};
+			methods.config = () =>
+			{
+				config.command = data['command'].value;
+				config.bind = data['bind'].value;
+				config.onSuccess = data['_success'].value;
+				config.onError = data['_error'].value;
+				config.reset = data['reset'].value;
+				config.stop = data['stop'].value;
+				config.data = data['data'].value;
+				config.api = data['api'].value;
+			};
 
-		methods.handler = () =>
-		{
-			config.form.dhCommandSubmit = async (event) =>
+			methods.element = () =>
 			{
-				event.preventDefault();
+				config.form = document.createElement('form');
+				config.form.setAttribute('autocomplete', 'off');
 
-				if(config.stop)
+				while(node.firstChild)
 				{
-					event.stopPropagation();
+					config.form.appendChild(node.firstChild);
 				}
 
-				await methods.submit();
+				node.appendChild(config.form);
+				divhunt.FormSet(config.form, config.data);
 			};
-		};
-
-		methods.submit = async () =>
-		{
-			compile.data[config.bind];
 
-			if(compile.data[config.bind].loading)
+			methods.handler = () =>
 			{
-				return;
-			}
-
-			compile.data[config.bind].loading = true;
-			compile.data[config.bind].error = null;
+				config.form.dhCommandSubmit = async (event) =>
+				{
+					event.preventDefault();
 
-			console.log(compile.data[config.bind]);
+					if(config.stop)
+					{
+						event.stopPropagation();
+					}
 
-			compile.data.Update();
+					await methods.submit();
+				};
+			};
 
-			try
+			methods.submit = async () =>
 			{
-				const formData = divhunt.FormGet(config.form);
-				const result = config.api
-					? await commands.Fn('api', config.command, formData)
-					: await commands.Fn('run', config.command, formData);
+				compile.data[config.bind];
 
-				compile.data[config.bind].response = result;
-				compile.data[config.bind].error    = null;
-				compile.data[config.bind].loading  = false;
+				if(compile.data[config.bind].loading)
+				{
+					return;
+				}
 
-				config.reset && config.form.reset();
-				config.onSuccess && config.onSuccess(compile.data[config.bind]);
-			}
-			catch(error)
-			{
-				compile.data[config.bind].response = null;
-				compile.data[config.bind].error    = error.message;
-				compile.data[config.bind].loading  = false;
+				compile.data[config.bind].loading = true;
+				compile.data[config.bind].error = null;
+
+				console.log(compile.data[config.bind]);
 
-				config.onError && config.onError(compile.data[config.bind]);
-			}
-			finally
-			{
 				compile.data.Update();
-			}
-		};
 
-		methods.init();
-	}
-});
+				try
+				{
+					const formData = divhunt.FormGet(config.form);
+					const result = config.api
+						? await commands.Fn('api', config.command, formData)
+						: await commands.Fn('run', config.command, formData);
+
+					compile.data[config.bind].response = result;
+					compile.data[config.bind].error    = null;
+					compile.data[config.bind].loading  = false;
+
+					config.reset && config.form.reset();
+					config.onSuccess && config.onSuccess(compile.data[config.bind]);
+				}
+				catch(error)
+				{
+					compile.data[config.bind].response = null;
+					compile.data[config.bind].error    = error.message;
+					compile.data[config.bind].loading  = false;
+
+					config.onError && config.onError(compile.data[config.bind]);
+				}
+				finally
+				{
+					compile.data.Update();
+				}
+			};
+
+			methods.init();
+		}
+	});
 
-divhunt.AddonReady('directives', function()
-{
 	document.addEventListener('submit', function(event)
 	{
 		let node = event.target;

package/addons/core/servers/back/http/item/functions/start.js

@@ -27,11 +27,11 @@ serversHTTP.Fn('item.start', function(item)
             user: this.methods.user(request),
             time: performance.now(),
             error: null,
-            raw: response,
+            response,
             streaming: false,
             types: this.methods.types,
             prevent: false,
-            response: {
+            respond: {
                 type: 'JSON',
                 data: null,
                 message: 'Request processed',
@@ -64,7 +64,7 @@ serversHTTP.Fn('item.start', function(item)
             return;
         }
 
-        const type = http.types[http.response.type] || http.types.JSON;
+        const type = http.types[http.respond.type] || http.types.JSON;
 
         http.time = (performance.now() - http.time).toFixed(2);
 
@@ -83,14 +83,14 @@ serversHTTP.Fn('item.start', function(item)
             return;
         }
 
-        const content = http.response.type === 'JSON' ? {
-            data: http.response.data || {},
-            message: http.response.message || 'No response message provided.',
-            code: http.response.code,
+        const content = http.respond.type === 'JSON' ? {
+            data: http.respond.data || {},
+            message: http.respond.message || 'No response message provided.',
+            code: http.respond.code,
             time: http.time
-        } : http.response.data || '';
+        } : http.respond.data || '';
 
-        response.writeHead(http.response.code, { 'Content-Type': type.contentType });
+        response.writeHead(http.respond.code, { 'Content-Type': type.contentType });
         response.end(type.formatter(content));
 
         item.Get('onComplete') && item.Get('onComplete')(http);

package/addons/render/pages/front/items/directives/change.js

@@ -1,38 +1,41 @@
-directives.ItemAdd({
-	id: 'dh-page',
-	icon: 'file',
-	name: 'Page',
-	description: 'Navigate to a page on render',
-	category: 'navigation',
-	trigger: 'node',
-	order: 666,
-	strict: false,
-	tag: 'dh-page',
-	attributes: {
-		'route': ['string', null, true],
-		'parameters': ['object', {}],
-		'history': ['boolean', true],
-		'timeout': ['number', 0]
-	},
-	code: function(data, item, compile, node, identifier)
-	{
-		const route = data['route'].value;
-		const parameters = data['parameters'].value;
-		const push = data['history'].value;
-		const timeout = data['timeout'].value;
-
-		const change = () =>
+divhunt.AddonReady('directives', function()
+{
+	directives.ItemAdd({
+		id: 'dh-page',
+		icon: 'file',
+		name: 'Page',
+		description: 'Navigate to a page on render',
+		category: 'navigation',
+		trigger: 'node',
+		order: 666,
+		strict: false,
+		tag: 'dh-page',
+		attributes: {
+			'route': ['string', null, true],
+			'parameters': ['object', {}],
+			'history': ['boolean', true],
+			'timeout': ['number', 0]
+		},
+		code: function(data, item, compile, node, identifier)
 		{
-			pages.Fn('change', route, parameters, { path: true, push });
-		};
+			const route = data['route'].value;
+			const parameters = data['parameters'].value;
+			const push = data['history'].value;
+			const timeout = data['timeout'].value;
 
-		if(timeout > 0)
-		{
-			setTimeout(change, timeout);
-		}
-		else
-		{
-			change();
+			const change = () =>
+			{
+				pages.Fn('change', route, parameters, { path: true, push });
+			};
+
+			if(timeout > 0)
+			{
+				setTimeout(change, timeout);
+			}
+			else
+			{
+				change();
+			}
 		}
-	}
+	});
 });

package/addons/render/transforms/front/js/items/directives/transform.js

@@ -1,40 +1,43 @@
-directives.ItemAdd({
-    id: 'dh-transform',
-    icon: 'auto_fix_high',
-    name: 'Transform',
-    description: 'Apply transform functions to elements for advanced functionality. Enables custom element behaviors and third-party integrations.',
-    trigger: 'node',
-    order: 1100,
-    type: '1',
-    code: async function(data, item, compile, node, identifier)
-    {
-        const transformer = transforms.ItemGet(node.tagName.toLowerCase());
-
-        if(!transformer)
+divhunt.AddonReady('directives', function()
+{
+    directives.ItemAdd({
+        id: 'dh-transform',
+        icon: 'auto_fix_high',
+        name: 'Transform',
+        description: 'Apply transform functions to elements for advanced functionality. Enables custom element behaviors and third-party integrations.',
+        trigger: 'node',
+        order: 1100,
+        type: '1',
+        code: async function(data, item, compile, node, identifier)
         {
-            return;
-        }
+            const transformer = transforms.ItemGet(node.tagName.toLowerCase());
 
-        // Don't stop children processing - let each transform handle itself
-        // compile.children = false;
+            if(!transformer)
+            {
+                return;
+            }
 
-        const html = node.outerHTML.replace(new RegExp(`^<${node.tagName.toLowerCase()}\\b`), `<div`) .replace(new RegExp(`</${node.tagName.toLowerCase()}>$`), `</div>`);
-        const compiled = item.Compile(html, compile.data);
+            // Don't stop children processing - let each transform handle itself
+            // compile.children = false;
 
-        data = directives.Fn('process.data', transformer.Get('config'), compiled.element.firstElementChild, compiled);
+            const html = node.outerHTML.replace(new RegExp(`^<${node.tagName.toLowerCase()}\\b`), `<div`) .replace(new RegExp(`</${node.tagName.toLowerCase()}>$`), `</div>`);
+            const compiled = item.Compile(html, compile.data);
 
-        node.style.display = 'none';
+            data = directives.Fn('process.data', transformer.Get('config'), compiled.element.firstElementChild, compiled);
 
-        await transforms.Fn('load.assets', transformer);
+            node.style.display = 'none';
 
-        // Use Promise to handle async properly
-        return new Promise((resolve) => {
-            setTimeout(() => {
-                const targetNode = compiled.element.firstElementChild;
-                transformer.Get('code').call({}, data, transformer, compile, targetNode, identifier);
-                node.replaceWith(targetNode);
-                resolve();
-            }, 0);
-        });
-    }
-});
+            await transforms.Fn('load.assets', transformer);
+
+            // Use Promise to handle async properly
+            return new Promise((resolve) => {
+                setTimeout(() => {
+                    const targetNode = compiled.element.firstElementChild;
+                    transformer.Get('code').call({}, data, transformer, compile, targetNode, identifier);
+                    node.replaceWith(targetNode);
+                    resolve();
+                }, 0);
+            });
+        }
+    });
+});

package/docs/architecture.md

@@ -3,12 +3,12 @@
 ## File structure
 
 ```
-lib/                     Core Divhunt class + 16 mixins
+lib/                     Core Divhunt class + 17 mixins
   load.js                Entry point — creates Divhunt instance, handles signals
   src/
     divhunt.js           Main class (mixin-composed)
     mixins/              Addons, Emitter, Middleware, Data, DOM, Route,
-                         Function, Generate, Binaries, Helper, and more
+                         Function, Generate, Binaries, Helper, Cookie, and more
     classes/
       addon/             DivhuntAddon + mixins (fields, items, functions, find, render, store)
         classes/

package/docs/servers.md

@@ -20,6 +20,60 @@ commands.Fn('http.server', 3000, {
 });
 ```
 
+## HTTP object
+
+Every request creates an `http` object passed to `onRequest` and command callbacks (via `this.http`):
+
+| Property | Type | Description |
+|---|---|---|
+| `request` | IncomingMessage | Node.js request (headers, method, url) |
+| `response` | ServerResponse | Node.js response (writeHead, setHeader, end) |
+| `data` | object | Parsed request data (query params + body) |
+| `url` | URL | Parsed request URL |
+| `user` | object | `{ ip, agent, forwarded, referrer }` |
+| `respond` | object | `{ type, data, message, code }` — response payload |
+| `prevent` | boolean | Set `true` to skip automatic response |
+
+## Cookies
+
+Built-in cookie support via `divhunt.Cookie*` methods. Works on both front (browser) and back (server) — detected via `divhunt.environment`.
+
+### Back (server)
+
+```js
+// Read from request
+const token = divhunt.CookieGet('token', this.http.request);
+
+// Set on response (HttpOnly + Secure by default)
+divhunt.CookieSet('token', value, {
+    path: '/',
+    maxAge: 86400,
+    sameSite: 'Strict'
+}, this.http.response);
+
+// Clear
+divhunt.CookieClear('token', { path: '/' }, this.http.response);
+```
+
+### Front (browser)
+
+```js
+divhunt.CookieSet('theme', 'dark', { path: '/', maxAge: 86400 });
+const theme = divhunt.CookieGet('theme');
+divhunt.CookieClear('theme');
+```
+
+### Options
+
+| Option | Back default | Front default | Description |
+|---|---|---|---|
+| `path` | — | — | Cookie path |
+| `maxAge` | — | — | Lifetime in seconds |
+| `domain` | — | — | Cookie domain |
+| `httpOnly` | `true` | N/A | JS can't read the cookie |
+| `secure` | `true` | `false` | HTTPS only |
+| `sameSite` | — | — | `Strict`, `Lax`, or `None` |
+
 ## gRPC server
 
 Bidirectional streaming with automatic reconnection and binary data transport.

package/lib/src/divhunt.js

@@ -17,11 +17,13 @@ import DivhuntRoute from './mixins/route.js';
 import DivhuntError from './mixins/error.js';
 import DivhuntCrypto from './mixins/crypto.js';
 import DivhuntForm from './mixins/form.js';
+import DivhuntCookie from './mixins/cookie.js';
 
 class Divhunt
 {
     constructor()
     {
+        this.environment = typeof window !== 'undefined' ? 'front' : 'back';
         this.emitters = {};
         this.middleware = {};
 
@@ -84,5 +86,6 @@ Object.assign(Divhunt.prototype, DivhuntRoute);
 Object.assign(Divhunt.prototype, DivhuntError);
 Object.assign(Divhunt.prototype, DivhuntCrypto);
 Object.assign(Divhunt.prototype, DivhuntForm);
+Object.assign(Divhunt.prototype, DivhuntCookie);
 
 export default Divhunt;

package/lib/src/mixins/cookie.js

@@ -0,0 +1,73 @@
+const DivhuntCookie =
+{
+    CookieGet(name, request)
+    {
+        const header = this.environment === 'front' ? document.cookie : (request?.headers?.cookie || '');
+        const match = header.match(new RegExp('(?:^|;\\s*)' + name + '=([^;]*)'));
+
+        if(!match)
+        {
+            return null;
+        }
+
+        return decodeURIComponent(match[1]);
+    },
+
+    CookieSet(name, value, options, response)
+    {
+        const parts = [encodeURIComponent(name) + '=' + encodeURIComponent(value)];
+
+        if(options?.path)
+        {
+            parts.push('Path=' + options.path);
+        }
+
+        if(options?.maxAge)
+        {
+            parts.push('Max-Age=' + options.maxAge);
+        }
+
+        if(options?.domain)
+        {
+            parts.push('Domain=' + options.domain);
+        }
+
+        if(options?.sameSite)
+        {
+            parts.push('SameSite=' + options.sameSite);
+        }
+
+        if(this.environment === 'front')
+        {
+            if(options?.secure)
+            {
+                parts.push('Secure');
+            }
+
+            document.cookie = parts.join('; ');
+            return;
+        }
+
+        if(options?.httpOnly !== false)
+        {
+            parts.push('HttpOnly');
+        }
+
+        if(options?.secure !== false)
+        {
+            parts.push('Secure');
+        }
+
+        const existing = response.getHeader('Set-Cookie') || [];
+        const cookies = Array.isArray(existing) ? existing : [existing];
+        cookies.push(parts.join('; '));
+        response.setHeader('Set-Cookie', cookies);
+    },
+
+    CookieClear(name, options, response)
+    {
+        this.CookieSet(name, '', { path: options?.path || '/', maxAge: 0 }, response);
+    }
+};
+
+export default DivhuntCookie;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "divhunt",
-    "version": "2.0.10",
+    "version": "2.0.12",
     "description": "Full-stack isomorphic JavaScript framework built from scratch. One addon abstraction powers databases, servers, commands, pages, directives, queues, and more.",
     "type": "module",
     "main": "lib/load.js",

package/test.js

@@ -42,7 +42,6 @@ commands.Item({
     }
 });
 
-
 commands.Fn('expose', 'commands:run', '/api/commands/run');
 
 await commands.Fn('http.server', 3000, {