upcore-tcp 0.0.1

package/README.md

@@ -0,0 +1,318 @@
+# upcore
+
+Framework Node.js ขนาดเล็กสำหรับ **HTTP + WebSocket**  
+ออกแบบมาให้เร็ว เบา และควบคุม flow ได้เองทั้งหมด  
+ใช้ **CommonJS** และรองรับทั้ง **Node.js** และ **Bun.js**
+
+> Created by **R938**
+
+---
+
+## ✨ ความสามารถหลัก
+
+- สร้าง **HTTP Server + WebSocket Server** จาก instance เดียว
+- Routing ครบ:
+  - static path
+  - dynamic params (`:id`)
+  - wildcard (`*`)
+- Middleware chaining ด้วย `next()`
+- Domain-based routing (`app.domain(...)`)
+- Parse body ได้หลายรูปแบบ:
+  - `json`
+  - `formdata`
+  - `wwwform`
+  - `binary`
+- ระบบ **Type & Validation** ในตัว
+- Static file serving (`directory`)
+- Auto route loader จากไฟล์ (`routes`)
+- Helper ครบ:
+  - cookie
+  - query
+  - redirect
+  - file response
+- ใช้งานได้ทั้ง **Node.js** และ **Bun.js**
+
+
+## ติดตั้งใช้งาน
+```bash
+npm install upcore
+```
+
+## Quick Start
+```js
+const upcore = require('upcore');
+
+const app = new upcore({
+  dev: true,
+  logger: true
+});
+
+app.get('/', (req) => {
+  req.html('<h1>Hello upcore</h1>');
+});
+
+app.listen();
+```
+
+## โครงสร้างเริ่มต้น (แนะนำ)
+```text
+project/
+  routes/
+    get@.js
+    post@api-login.js
+    get@user-$id.js
+  public/
+    index.html
+    logo.png
+  app.js
+```
+
+ตัวอย่าง `app.js`:
+```js
+const upcore = require('upcore');
+
+const app = new upcore({ port: 3000, dev: true, logger: true });
+
+app
+  .add('json', ({ load, next }) => load('json', next))
+  .directory('./public', { pathname: '/static', type: ['png', 'jpg', 'html', 'css', 'js'] })
+  .routes('./routes');
+
+app.listen();
+```
+
+## การตั้งค่า `new upcore(options)`
+- `hostname` default: `0.0.0.0`
+- `port` default: `3000`
+- `keepAlive` default: `true`
+- `keepAliveInitialDelay` default: `5000`
+- `noDelay` default: `true`
+- `timeout` default: `30000`
+- `dev` default: `false` (ถ้า `true` จะพิมพ์ข้อความตอน listen)
+- `logger` default: `false` (ถ้า `true` จะ log traffic)
+- `use: 'https'` ใช้ `tls` แทน `net` (ต้องส่ง options ที่จำเป็นสำหรับ TLS)
+
+## API หลักของ App
+- `app.listen(callback?)`
+- `app.type(id, rule)`
+- `app.types(rules)`
+- `app.add(id, middleware)`
+- `app.domain(domain | string[])`
+- `app.next(...middlewareOrName)`
+- `app.all(path, ...handler)`
+- `app.get/post/put/patch/delete/options/head(path, ...handler)`
+- `app.websocket(path, onStart, onData?, onClose?, onPing?, onPong?)`
+- `app.directory(dir, options)`
+- `app.routes(dir)`
+
+## API ใน Handler (HTTP)
+- Response: `req.code()`, `req.set()`, `req.http()`, `req.send()`, `req.html()`, `req.json()`, `req.redirect()`, `req.file()`, `req.error()`
+- Request: `req.get(headerKey)`, `req.look(queryKeys)`, `req.u(queryKey)`, `req.load()`, `req.check()`, `req.q()`
+- Cookie: `req.gcookie()`, `req.scookie()`, `req.rcookie()`
+- Middleware flow: `req.next()`
+- Validation: `req.test({ type, data, core })`
+
+## API ใน Handler (WebSocket)
+- `req.start(uid)` เริ่ม handshake + ลงทะเบียนผู้ใช้
+- `req.stop()`
+- `req.send()`, `req.sends()`, `req.sendto()`, `req.sendc()`
+- `req.json()`, `req.jsons()`, `req.jsonto()`, `req.jsonc()`
+- `req.ping()`, `req.pong()`
+- `req.userEach()`, `req.userHas()`, `req.userLength()`
+
+## ระบบ Type/Validation
+รองรับ `type`:
+- `int`
+- `string`
+- `boolean`
+- `array`
+- `object`
+- `file` (object ที่มี `data` เป็น Buffer)
+- `timestamp` (`YYYY-MM-DDTHH:mm:ss.sssZ`)
+
+รองรับเงื่อนไขเสริม:
+- `length: [min, max]` หรือ `length: exact`
+- `format: 'user' | 'email' | 'hex' | 'decimal'`
+- `list: [...]`
+- `mime: [...]` (ใช้กับ `file`)
+
+ตัวอย่าง:
+```js
+app
+  .type('id', { type: 'int', length: [1, 1000000] })
+  .type('email', { type: 'string', format: 'email', length: [6, 300] })
+  .type('avatar', { type: 'file', mime: ['image/png', 'image/jpeg'] });
+  .types({
+    userid:{ type: 'int', length: [1, 1000000] }
+    no:{ type: 'int', length: [1, 1000] }
+  });
+```
+
+## ตัวอย่างการใช้งานทุกเคสหลัก
+
+### 1) GET/POST พื้นฐาน
+```js
+app.get('/', (req) => req.send('ok'));
+app.post('/echo', ({ load, json, body }) => {
+  load('json', () => json({ body }));
+});
+```
+
+### 2) Dynamic params และ wildcard
+```js
+app.get('/user/:id', ({ params, json }) => json({userid: params.id}));
+  // [GET] /user/1 
+  // {"userid":1}
+app.get('/files/*', ({ wildcard, send }) => send(wildcard));
+  // [GET] /files/asset/logo.svg
+  // /asset/logo.svg
+```
+
+### 3) Query
+```js
+app.get('/search', (req) => {
+  if (!req.look('q')) return req.code(400).send('missing q');
+  req.json({ q: req.u('q') });
+});
+  // [GET] /search?q=upcore
+  // {"q":"upcore"}
+```
+
+### 4) Middleware chain
+```js
+app.add('auth', (req) => {
+  if (!req.look('token')) return req.code(401).send('unauthorized');
+  req.next();
+});
+
+app.next('auth').get('/private', (req) => req.send('ok'));
+```
+
+### 5) Parse body หลายประเภท
+```js
+app.add('json', ({ load, next }) => load('json', next));
+app.add('form', ({ load, next }) => load(['wwwform', 'formdata'], next));
+```
+
+### 6) Validation ด้วย `req.test`
+```js
+app.type('id', { type: 'int', length: [1, 999999] });
+
+app.post('/user', 'json', (req) => {
+  const data = req.test({
+    type: 'json',
+    data: { id: { t: 'id', r: true } }
+  });
+
+  if (data !== false) req.json({ ok: true, data });
+});
+```
+
+### 7) Cookie
+```js
+app.get('/cookie/set', (req) => {
+  req.scookie('sid', 'abc123', { path: '/', httponly: true, 'max-age': 3600 });
+  req.send('set');
+});
+
+app.get('/cookie/get', (req) => req.json({ sid: req.gcookie('sid') || null }));
+app.get('/cookie/remove', (req) => { req.rcookie('sid', { path: '/' }); req.send('removed'); });
+```
+
+### 8) Redirect
+```js
+app.get('/go-doc', (req) => req.redirect('/docs'));      // 301
+app.get('/go-login', (req) => req.redirect(302, '/login'));
+```
+
+### 9) ส่งไฟล์ / template parameter
+```js
+app.get('/download', (req) => {
+  req.file({ file: './public/a.jpg', download: 'photo.jpg' });
+});
+
+app.get('/page', (req) => {
+  req.file({
+    file: './public/index.html',
+    parameter: { title: 'Hello', time: new Date().toISOString() }
+  });
+});
+```
+ตัวอย่างไฟล์ /public/index.html
+```html
+<h1>{{title}}</h1>
+<p>Time: {{time}}</p>
+```
+
+### 10) Static directory
+```js
+app.directory('./public', {
+  pathname: '/assets',
+  type: ['png', 'jpg', 'mp4', 'html', 'css', 'js']
+});
+```
+
+### 11) Auto routes จากไฟล์
+```js
+app.routes('./routes');
+```
+
+หลักการตั้งชื่อไฟล์ของ `app.routes`:
+- อ่านเฉพาะไฟล์ `.js` ในโฟลเดอร์นั้น (ไม่อ่านโฟลเดอร์ย่อย)
+- รูปแบบหลัก: `method@path.js`
+- ถ้าไม่มี `@` จะถือเป็น `GET` อัตโนมัติ เช่น `home.js` => `GET /home`
+- `method` ที่ใช้ได้ตาม API: `get`, `post`, `put`, `patch`, `delete`, `options`, `head`, `all`, `websocket`
+- `path` จะถูกแปลงอักขระพิเศษ:
+- `-` => `/`
+- `$` => `:` (path param)
+- `\"` จะถูกลบออกจาก path
+- ถ้าชื่อไฟล์มี `@` มากกว่า 1 ตัว (เช่น `get@a@b.js`) ระบบจะไม่ map route ไฟล์นั้น
+
+ตัวอย่างชื่อไฟล์ -> endpoint:
+- `get@home-admin.js` => `GET /home/admin`
+- `get@user-$id.js` => `GET /user/:id`
+- `post@auth-login.js` => `POST /auth/login`
+- `health.js` => `GET /health`
+- `all@api-v1-*.js` => `ALL /api/v1/*`
+
+ตัวอย่างไฟล์ route:
+```js
+// routes/post@user-login.js
+module.exports = (req) => {
+  req.json({ ok: true, body: req.body });
+};
+module.exports.next = 'json'; // ใช้ middleware ที่ add ไว้แล้ว
+// module.exports.next = ['auth', 'json'];
+// module.exports.next = ()=>{};
+```
+
+### 12) Domain-based routing
+```js
+app.domain(['api.local', 'localhost'])
+  .get('/health', (req) => req.json({ ok: true }));
+
+  // [GET] http://api.local/health
+  // [GET] http://localhost/health
+
+  // {"ok":true}
+```
+
+### 13) WebSocket
+```js
+app.websocket('/ws', async (req) => {
+  const ok = await req.start(req.u('uid') || String(Date.now()));
+  if (!ok) return req.stop();
+  req.send('connected');
+}, (req) => {
+  req.send(req.body.payload); // echo
+}, (req) => {
+  console.log('socket closed', req.uid);
+});
+
+// ws://127.0.0.1/ws?uid=upcore
+```
+## หมายเหตุสำคัญ
+- ค่า `Host` ต้องตรงกับ domain ที่ลง route (หรือใช้ `*` ถ้าต้องการรับทุก host)
+- ถ้า `req.load(...)` ประเภทไม่ตรงกับ `Content-Type` จะตอบ 400
+- `req.test(...)` จะตอบ error อัตโนมัติเมื่อ type/format ไม่ผ่าน
+- ถ้าใช้ `app.routes(dir)` โฟลเดอร์ต้องมีไฟล์ `.js` ตาม naming convention

package/index.js

@@ -0,0 +1 @@
+module.exports = require('./lib/server');

package/lib/checkDirectory.js

@@ -0,0 +1,7 @@
+module.exports = function(name){
+    try{
+        name = decodeURIComponent(name);
+        return name.replace(/(\.\.)|[\[\n\r\t\*\?\"\<\>\|]/,'') == name ? name : false;
+    }catch(e){}
+    return false;
+}

package/lib/checkHeader.js

@@ -0,0 +1,120 @@
+module.exports = function(chunk){
+    const len = chunk.length;
+    if (len < 16) return false;
+    let p = 0;
+
+    // ---------- METHOD ----------
+    let method = false;
+    
+    switch((chunk[0] << 24) | (chunk[1] << 16) | (chunk[2] << 8) | chunk[3]){
+        case 0x47455420: method = 'get';     p = 4; break; // "GET "
+        case 0x504F5354: method = 'post';    p = 5; break; // "POST"
+        case 0x50555420: method = 'put';     p = 4; break; // "PUT "
+        case 0x48454144: method = 'head';    p = 5; break; // "HEAD"
+        case 0x44454C45: method = 'delete';  p = 7; break; // "DELE"
+        case 0x4F505449: method = 'options'; p = 8; break; // "OPTI"
+        case 0x50415443: method = 'patch';   p = 6; break; // "PATC"
+        default: return false;
+    }
+
+    // ---------- PATH ----------
+    const pathStart = p;
+    let searchPoint = -1;
+
+    while(p < len && chunk[p] !== 32){
+        if (chunk[p] === 63 && searchPoint === -1) searchPoint = p;
+        p++;
+    }
+    if (p >= len) return false;
+
+    const pathEnd = p++;
+
+    p += 10;
+
+    // ---------- HEADERS ----------
+    let header = [];
+    let host = false;
+    let port = false;
+    let length = 0;
+    let type = false;
+    let connection = 0;
+    
+
+    while(p + 3 < len){
+        const lineStart = p;
+
+        if (chunk[p] === 13 && chunk[p+1] === 10) {
+            p += 2;
+            break;
+        }
+
+        while(p < len && !(chunk[p] === 13 && chunk[p+1] === 10)) p++;
+
+        const h = chunk.subarray(lineStart, p);
+
+        switch((h[0] << 24) | (h[1] << 16) | (h[2] << 8) | h[3]){
+            case 0x436F6E74:{ // "Cont"
+                if(h[8] === 76 && h[14] === 58 && h[15] === 32){ // Content-Length: 
+                    length = parseInt(h.subarray(16));
+                    break;
+                }else if(h[8] === 84 && h[12] === 58 && h[13] === 32){ // Content-Type:
+                    type = h.subarray(14);
+                    break;
+                }
+            }
+            case 0x486F7374:{ // "Host"
+                if(h[4] === 58 && h[5] === 32){
+                    let colon = -1;
+                    for(let i = h.length - 1; i > 5; i--){
+                        if(h[i] === 58){ 
+                            colon = i;
+                            break;
+                        }
+                    }
+
+                    if(colon !== -1){
+                        host = h.subarray(6, colon).toString();
+                        port = h.subarray(colon + 1).toString();
+                    }else{
+                        host = h.subarray(6).toString();
+                    }
+                    break;
+                }
+            }
+            case 0x436F6E6E:{ // "Conn"
+                // Connection
+                if(h[10] === 58 && h[11] === 32){
+                    if(h[12] === 107 && h.length === 22){ // Connection: keep-alive
+                        connection = 1
+                    }else if(h[12] === 85 && h.length === 19){ // Connection: Upgrade
+                        connection = 2
+                    }
+                    break;
+                }
+            }
+            default:{
+                header.push(h);
+            }
+        }
+
+        p += 2;
+    }
+
+    if(!host) return false;
+
+    const body = length ? chunk.subarray(p, p + length) : null;
+    if(length && body.length > length) return false;
+
+    return {
+        success:!length || body.length === length,
+        connection,
+        method,
+        host,
+        pathname: chunk.subarray(pathStart, searchPoint === -1 ? pathEnd : searchPoint),
+        search: searchPoint === -1 ? null : chunk.subarray(searchPoint + 1, pathEnd),
+        type,
+        length,
+        header,
+        payload: body ? [body] : []
+    };
+}

package/lib/checkPath.js

@@ -0,0 +1,47 @@
+module.exports = function checkPath(tree, req) {
+    let hostTree = tree[req.host] || tree['*'];
+    if (!hostTree) return false;
+
+    let node = hostTree[req.connection === 2 ? 'websocket' : req.method] || hostTree['*'];
+    if (!node) return false;
+
+    const path = req.pathname;
+    let start = 1;
+    req.params = {};
+    req.wildcard = {};
+
+    let cacheWildcard = false;
+    while (true) {
+
+        if(node.wildcard){
+            cacheWildcard = {
+                wildcard: path.slice(start - 1),
+                node:node.wildcard
+            }
+        }
+
+        let end = path.indexOf('/', start);
+        if (end === -1) end = path.length;
+
+        const part = path.slice(start, end);
+
+        if(node.static && node.static[part]){
+            node = node.static[part];
+        }else if (node.param){
+            req.params[node.param.id] = part;
+            node = node.param;
+        }else if(cacheWildcard !== false){
+            req.wildcard = cacheWildcard.wildcard;
+            return cacheWildcard.node.handler;
+        }else{
+            return false;
+        }
+
+        if (end === path.length) break;
+        start = end + 1;
+    }
+
+    if (!node.handler) return false;
+
+    return node.handler;
+}

package/lib/checkType.js

@@ -0,0 +1,161 @@
+function isValidDecimal(s) {
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+
+        if (
+            (c >= 48 && c <= 57)   // 0-9
+        ) continue;
+
+        return false;
+    }
+    return s.length > 0;
+}
+function isValidHex(s) {
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+
+        if (
+            (c >= 48 && c <= 57) ||   // 0-9
+            (c >= 97 && c <= 102)  // a-f
+        ) continue;
+
+        return false;
+    }
+    return s.length > 0;
+}
+function isValidUser(s) {
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+
+        if (
+            (c >= 48 && c <= 57) ||   // 0-9
+            (c >= 65 && c <= 90) ||   // A-Z
+            (c >= 97 && c <= 122) ||  // a-z
+            c === 95 ||               // _
+            c === 45                  // -
+        ) continue;
+
+        return false;
+    }
+    return s.length > 0;
+}
+function isValidEmail(s){
+    let at = -1;
+    let dot = -1;
+
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+
+        if (c === 64) { // @
+            if (at !== -1) return false;
+            at = i;
+            continue;
+        }
+
+        if (c === 46) dot = i; // .
+
+        if (
+            (c >= 48 && c <= 57) ||   // 0-9
+            (c >= 65 && c <= 90) ||   // A-Z
+            (c >= 97 && c <= 122) ||  // a-z
+            c === 46 || c === 95 ||   // . _
+            c === 45 || c === 43 ||   // - +
+            c === 37                  // %
+        ) continue;
+
+        return false;
+    }
+
+    return at > 0 && dot > at + 1 && dot < s.length - 1;
+}
+
+module.exports = function({type, length, format, list, mime}, data){
+    let status = false;
+    let len = false;
+
+    if(type == 'int' && data === (data | 0)){
+        len = data;
+        status = true;
+    }else if(type == 'string' && typeof data === 'string'){
+        len = data.length;
+        status = true;
+    }else if(type == 'boolean' && typeof data === 'boolean'){
+        status = true;
+    }else if(type == 'array' && typeof data === 'object' && Array.isArray(data)){
+        status = true;
+    }else if(type == 'object' && typeof data === 'object' && !Array.isArray(data)){
+        status = true;
+    }else if(type == 'file' && typeof data === 'object' && Buffer.isBuffer(data?.data)){
+        len = data.data.length;
+        status = true;
+    }else if(type == 'timestamp' && typeof data === 'string' && data.length == 24 && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(data)){
+        len = new Date(data).getTime();
+        status = true;
+    }
+
+    if(status === false){
+        return false;
+    }
+
+    if(mime !== undefined){
+        status = false;
+        if(mime.includes(data.type)){
+            status = true;
+        }
+
+        if(status === false){
+            return false;
+        }
+    }
+
+    if(length !== undefined){
+        status = false;
+        if(Array.isArray(length) && length.length == 2){
+            if(length[0] <= len && length[1] >= len){
+                status = true;
+            }
+        }else if(length === (length | 0)){
+            if(len === length){
+                status = true;
+            }
+        }
+
+        if(status === false){
+            return false;
+        }
+    }
+
+    if(format !== undefined){
+        status = false;
+        if(format == 'user'){
+            if(isValidUser(data)){
+                status = true;
+            }
+        }else if(format == 'email'){
+            if(isValidEmail(data)){
+                status = true;
+            }
+        }else if(format == 'hex'){
+            if(isValidHex(data)){
+                status = true;
+            }
+        }else if(format == 'decimal'){
+            if(isValidDecimal(data)){
+                status = true;
+            }
+        }
+
+        if(status === false){
+            return false;
+        }
+    }
+
+    if(Array.isArray(list)){
+        if(!list.includes(data)){
+            return false;
+        }
+    }
+        
+
+    return true;
+}

package/lib/cookieDecode.js

@@ -0,0 +1,15 @@
+module.exports = function(cookie){
+    let output = [];
+
+    for(let i of cookie.split('; ')){
+        let index = i.indexOf('=');
+
+        try{
+            output[decodeURIComponent(i.slice(0, index))] = decodeURIComponent(i.slice(index + 1));
+        }catch(e){
+            console.log(e);
+        }        
+    }
+
+    return output;
+}