divhunt 2.0.10 → 2.0.11

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/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/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.11",
     "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, {