geonix 1.12.2 → 1.20.0

package/src/Util.js

@@ -1,19 +1,18 @@
-import { createHash, randomBytes } from 'crypto'
-import { URL, fileURLToPath } from 'url'
-import { readFile } from 'fs/promises'
-import { join } from 'path'
-import { Transform } from 'node:stream'
-import { networkInterfaces } from 'os'
-import http from 'http'
-import https from 'http'
-import net from 'net'
+import { createHash, randomBytes } from "crypto";
+import { URL, fileURLToPath } from "url";
+import { readFile } from "fs/promises";
+import { join } from "path";
+import { Transform } from "node:stream";
+import * as http from "http";
+import * as https from "https";
+import * as net from "net";
 
 /**
  * Wait for {delay} ms
  * @param {number} delay 
  * @returns 
  */
-export const sleep = delay => new Promise(resolve => setTimeout(resolve, delay))
+export const sleep = delay => new Promise(resolve => setTimeout(resolve, delay));
 
 /**
  * Parse nats:// URL
@@ -21,14 +20,19 @@ export const sleep = delay => new Promise(resolve => setTimeout(resolve, delay))
  * @returns 
  */
 export function parseURL(url) {
-    const parsed = new URL(url)
+    const parsed = new URL(url);
 
-    return {
+    const basic = {
         servers: `${parsed.hostname}:${parsed.port || 4222}`,
-        user: parsed.password ? parsed.username : '',
+        user: parsed.password ? parsed.username : "",
         pass: parsed.password,
         token: parsed.username && !parsed.password ? parsed.username : undefined
-    }
+    };
+
+    return {
+        ...basic,
+        ...Object.fromEntries(parsed.searchParams)
+    };
 }
 
 /**
@@ -36,14 +40,14 @@ export function parseURL(url) {
  * @param {number} size 
  * @returns 
  */
-export const picoid = (size = 12) => randomBytes(size).toString('base64')
+export const picoid = (size = 12) => randomBytes(size).toString("base64");
 
 /**
  * Get SHA256 hash of a string or a buffer
  * @param {string|Buffer} data 
  * @returns 
  */
-export const hash = (data) => createHash('sha256').update(data).digest('hex')
+export const hash = (data) => createHash("sha256").update(data).digest("hex");
 
 /**
  * Create TCP or HTTP server at specified port
@@ -53,17 +57,17 @@ export const hash = (data) => createHash('sha256').update(data).digest('hex')
  * @returns 
  */
 export const createServerAtPort = (port, pkg, handler) =>
-    new Promise((resolve, reject) => {
-        const server = pkg.createServer(handler)
-        server.on('error', (error) => {
+    new Promise((resolve) => {
+        const server = pkg.createServer(handler);
+        server.on("error", (_error) => {
             // console.log('error', error.message)
-            resolve(null)
-        })
+            resolve(null);
+        });
         server.listen(port, () => {
-            const { port } = server.address()
-            resolve({ server, port })
-        })
-    })
+            const { port } = server.address();
+            resolve({ server, port });
+        });
+    });
 
 /**
  * Create TCP or HTTP server at first free port in rage
@@ -76,34 +80,36 @@ export const createServerAtPort = (port, pkg, handler) =>
 export const createServerAtFreePort = async (pkg, handler, start = 30000, poolSize = 20000) => {
     for (let port = start; port < start + poolSize; port++)
         try {
-            const result = await createServerAtPort(port, pkg, handler)
+            const result = await createServerAtPort(port, pkg, handler);
             // console.log(port, '=', result)
-            if (result) return result
-        } catch (e) { }
-}
+            if (result) return result;
+        } catch {
+            // silenty ignore errors
+        }
+};
 
 /**
  * Create TCP server at random port
  * @param {Function} handler 
  * @returns 
  */
-export const createTCPServer = (handler, start = 30000, poolSize = 20000) => createServerAtFreePort(net, handler, start, poolSize)
+export const createTCPServer = (handler, start = 30000, poolSize = 20000) => createServerAtFreePort(net, handler, start, poolSize);
 
 /**
  * Create HTTP server at random port
  * @param {Function} handler 
  * @returns 
  */
-export const createHTTPServer = (handler, start = 30000, poolSize = 20000) => createServerAtFreePort(net, handler, start, poolSize)
+export const createHTTPServer = (handler, start = 30000, poolSize = 20000) => createServerAtFreePort(net, handler, start, poolSize);
 
 /**
  * Return number of seconds passed from the start of the day (0-86399)
  * @returns Number
  */
 export const getSecondsSinceMidnight = () => {
-    const date = new Date()
-    return Math.floor((date.getTime() - date.setHours(0, 0, 0, 0)) / 1000)
-}
+    const date = new Date();
+    return Math.floor((date.getTime() - date.setHours(0, 0, 0, 0)) / 1000);
+};
 
 /**
  * Parse function body and return array of param names
@@ -111,51 +117,51 @@ export const getSecondsSinceMidnight = () => {
  * @returns string[]
  */
 export const getFunctionParams = (fn) => {
-    const code = fn.toString()
-    const endParenthesisPosition = code.indexOf(')')
-    let params
+    const code = fn.toString();
+    const endParenthesisPosition = code.indexOf(")");
+    let params;
 
     if (endParenthesisPosition != -1)
-        params = code.substring(code.indexOf('(') + 1, endParenthesisPosition)
+        params = code.substring(code.indexOf("(") + 1, endParenthesisPosition);
     else
-        params = code.substring(0, code.indexOf('=>'))
+        params = code.substring(0, code.indexOf("=>"));
 
     params = params
         // cleanup spaces
-        .replaceAll(' ', '')
+        .replaceAll(" ", "")
         // split into array
-        .split(',')
+        .split(",");
 
     // remove potential default values
     for (let index = 0; index < params.length; index++) {
-        const defaultValueAssignmentPosition = params[index].indexOf('=')
+        const defaultValueAssignmentPosition = params[index].indexOf("=");
         if (defaultValueAssignmentPosition != -1)
-            params[index] = params[index].substring(0, defaultValueAssignmentPosition - 1)
+            params[index] = params[index].substring(0, defaultValueAssignmentPosition - 1);
     }
 
-    return params
-}
+    return params;
+};
 
 export const proxyHttp = (target, req, res) =>
     new Promise((resolve, reject) => {
-        const remoteTarget = `${target}${req.originalUrl}`
+        const remoteTarget = `${target}${req.originalUrl}`;
         const options = {
             method: req.method,
             headers: req.headers
-        }
+        };
 
-        const protocol = req.protocol === 'https' ? https : http
+        const protocol = req.protocol === "https" ? https : http;
         const proxyReq = protocol.request(remoteTarget, options, (proxyRes) => {
-            res.status(proxyRes.statusCode)
+            res.status(proxyRes.statusCode);
             for (const header in proxyRes.headers)
-                res.set(header, proxyRes.headers[header])
-            proxyRes.pipe(res)
-        })
-        proxyReq.on('error', (error) => reject(error))
-        req.pipe(proxyReq)
-        req.on('error', (error) => reject(error))
-        req.on('end', () => resolve())
-    })
+                res.set(header, proxyRes.headers[header]);
+            proxyRes.pipe(res);
+        });
+        proxyReq.on("error", (error) => reject(error));
+        req.pipe(proxyReq);
+        req.on("error", (error) => reject(error));
+        req.on("end", () => resolve());
+    });
 
 /**
  * Create a object proxy that overlays overlay object
@@ -163,87 +169,42 @@ export const proxyHttp = (target, req, res) =>
  * @param {*} overlay 
  * @returns 
  */
-export const OverlayObject = (object, overlay) => new Proxy(object, { get: (t, p) => overlay[p] !== undefined ? overlay[p] : t[p] })
+export const OverlayObject = (object, overlay) => new Proxy(object, { get: (t, p) => overlay[p] !== undefined ? overlay[p] : t[p] });
 
-let _geonix_version = 'N/A'
+let _geonix_version = "N/A";
 try {
-    const __dirname = fileURLToPath(new URL('..', import.meta.url));
-    const local = JSON.parse(await readFile(join(__dirname, 'package.json')))
-    _geonix_version = local.version
-} catch (e) {
+    const __dirname = fileURLToPath(new URL("..", import.meta.url));
+    const local = JSON.parse(await readFile(join(__dirname, "package.json")));
+    _geonix_version = local.version;
+} catch {
+    // ignore errors
 }
-export const GeonixVersion = _geonix_version
 
-export const StreamChunker = (chunkSize = 65536) => {
-    let buffer = Buffer.alloc(chunkSize)
+export const GeonixVersion = _geonix_version;
 
+export const StreamChunker = (chunkSize = 65536) => {
     let chunker = new Transform();
 
     chunker._transform = function (chunk, encoding, done) {
-        let offset = 0
+        let offset = 0;
         while (offset < chunk.length) {
-            const sliceSize = Math.min(chunkSize, chunk.length - offset)
-            this.push(chunk.slice(offset, offset + sliceSize))
-            offset += sliceSize
+            const sliceSize = Math.min(chunkSize, chunk.length - offset);
+            this.push(chunk.slice(offset, offset + sliceSize));
+            offset += sliceSize;
         }
 
-        done()
-    }
+        done();
+    };
 
     chunker._flush = function (done) {
-        done()
-    }
+        done();
+    };
 
     return chunker;
-}
-
-export async function* timeoutAsyncGenerator(target, ms) {
-    const iterator = target[Symbol.asyncIterator]()
-
-    while (true) {
-        const { value, done } = await Promise.race([iterator.next(), sleep(ms)]) || {};
-        if (done || (value === undefined && done === undefined)) {
-            break;
-        }
-
-        yield value;
-    }
-}
-
-export async function waitForAbort(abortSignal, result) {
-    return new Promise(resolve => {
-        if (abortSignal.aborted) {
-            resolve(result)
-        }
-
-        abortSignal.addEventListener('abort', () => {
-            console.log('aborted')
-            resolve(result)
-        })
-    })
-}
-
-export async function* abortableAsyncGenerator(target, abortSignal) {
-    const iterator = target[Symbol.asyncIterator]()
-
-    while (true) {
-        const { value, done } = await Promise.race([iterator.next(), waitForAbort(abortSignal)]) || {};
-        if (done || (value === undefined && done === undefined)) {
-            break;
-        }
-
-        yield value;
-    }
-}
-
-export function getNetworkAddresses() {
-    const list = []
-    const interfaces = networkInterfaces()
-
-    for (let interfaceAddresses of Object.values(interfaces))
-        for (let addressObject of interfaceAddresses)
-            if (addressObject.family === 'IPv4')
-                list.push(addressObject.address)
+};
 
-    return list
+export async function getFirstItemFromAsyncIterable(asyncIterable) {
+    const iterator = asyncIterable[Symbol.asyncIterator]();
+    const result = await iterator.next();
+    return result.value;
 }

package/src/WebServer.js

@@ -1,81 +1,72 @@
-import 'express-async-errors'
-import express, { Router } from 'express'
-import expressWs from 'express-ws'
-import { networkInterfaces } from 'os'
-import { createServerAtFreePort, createServerAtPort, sleep } from './Util.js'
-import * as http from 'http'
-import { Service } from './Service.js'
-import * as path from 'path'
+import "express-async-errors";
+import express, { Router } from "express";
+import expressWs from "express-ws";
+import { networkInterfaces } from "os";
+import { createServerAtFreePort, createServerAtPort, sleep } from "./Util.js";
+import * as http from "http";
+import { Service } from "./Service.js";
+import * as path from "path";
 
-export const HEALTH_CHECK_ENDPOINT = '/pA4vY7fT9oG5aI8cA4yV3qW5fP9qR1vI'
-
-const logger = (req, res, next) => {
-    console.log(`HTTP ${req.method} ${req.url}`)
-
-    next()
-}
+export const HEALTH_CHECK_ENDPOINT = "/pA4vY7fT9oG5aI8cA4yV3qW5fP9qR1vI";
 
 export const ServeStatic = (root, options = {}) => {
-    const router = Router()
-    const absoluteRoot = path.resolve(root)
+    const router = Router();
+    const absoluteRoot = path.resolve(root);
 
     router.use((req, res, next) => {
         if (options.root) {
             // remove trailing slash
-            if (options.root.endsWith('/'))
-                options.root = options.root.slice(0, -1)
+            if (options.root.endsWith("/"))
+                options.root = options.root.slice(0, -1);
 
             // replace root prefix
             if (req.url.startsWith(options.root))
-                req.url = req.url.replace(options.root, '')
+                req.url = req.url.replace(options.root, "");
         }
 
-        next()
-    })
+        next();
+    });
 
-    router.use(express.static(root, options))
+    router.use(express.static(root, options));
 
     if (options.indexOn404)
-        router.get('*', (req, res) => {
-            console.log(path.join(absoluteRoot, 'index.html'))
-            res.sendFile(path.join(absoluteRoot, 'index.html'))
-        })
+        router.get("*", (req, res) => {
+            console.log(path.join(absoluteRoot, "index.html"));
+            res.sendFile(path.join(absoluteRoot, "index.html"));
+        });
 
-    return router
-}
+    return router;
+};
 
 class WebServer {
 
-    #app = express()
-    #server
-    #port
-    #ready = false
-    #started = false
-
-    constructor() {
-    }
+    #app = express();
+    #server;
+    #port;
+    #ready = false;
+    #started = false;
 
     async start() {
         if (this.#started)
-            return
+            return;
 
-        this.#started = true
+        this.#started = true;
 
-        let port, server
+        let port, server;
         if (process.env.LOCAL_PORT) {
-            ({ server, port } = await createServerAtPort(process.env.LOCAL_PORT, http, this.#app))
+            ({ server, port } = await createServerAtPort(process.env.LOCAL_PORT, http, this.#app));
         } else {
-            ({ server, port } = await createServerAtFreePort(http, this.#app))
+            ({ server, port } = await createServerAtFreePort(http, this.#app));
         }
 
-        this.#server = server
-        this.#port = port
+        this.#server = server;
+        this.#port = port;
 
-        expressWs(this.#app, server)
+        expressWs(this.#app, server);
 
         this.#app.get(HEALTH_CHECK_ENDPOINT, (req, res) => {
-            res.send({ status: 'healthy', services: Service.serviceClasses })
-        })
+            res.send({ status: "healthy", services: Service.serviceClasses });
+        });
 
         // this.#app.use((req, res, next) => {
         //     next()
@@ -85,47 +76,59 @@ class WebServer {
         // this should provide more than enough time to start all the services
         setTimeout(() => {
             // default answer
-            this.#app.all('*', (req, res) => {
+            this.#app.all("*", (req, res) => {
                 res.status(404).send({
                     error: 404,
-                    source: 'ws'
-                })
-            })
-        }, 2000)
+                    source: "ws"
+                });
+            });
+        }, 2000);
 
         // config
-        this.#app.disable('x-powered-by')
-        this.#app.disable('etag')
+        this.#app.disable("x-powered-by");
+        this.#app.disable("etag");
+
+        console.log(`gx.webserver.start: listening on http://127.0.0.1:${this.#port}`);
+
+        this.#ready = true;
+    }
+
+    getAddresses() {
+        const list = [];
+        const interfaces = networkInterfaces();
 
-        console.log(`gx.webserver.start: listening on http://127.0.0.1:${this.#port}`)
+        for (let interfaceAddresses of Object.values(interfaces))
+            for (let addressObject of interfaceAddresses)
+                if (addressObject.family === "IPv4")
+                    list.push(addressObject.address);
 
-        this.#ready = true
+        return list;
     }
 
     getPort() {
-        return this.#port
+        return this.#port;
     }
 
     router() {
-        const router = Router()
-        this.#app.use(router)
-        return router
+        const router = Router();
+        this.#app.use(router);
+        return router;
     }
 
     async waitUntilReady() {
-        await this.start()
+        await this.start();
 
         while (!this.#ready)
-            await sleep(100)
+            await sleep(100);
     }
 
     stop() {
         if (this.#server) {
-            this.#server.close()
-            console.log('gx.webserver.stop')
+            this.#server.close();
+            console.log("gx.webserver.stop");
         }
     }
 
 }
 
-export const webserver = new WebServer()
+export const webserver = new WebServer();

package/test/gateway.js

@@ -0,0 +1,15 @@
+import { Gateway, Service } from "../exports.js";
+
+class TestService extends Service {
+
+    'GET /'(req, res) {
+        res.send('Hello World')
+    }
+}
+
+TestService.start()
+Gateway.start({
+    beforeRequest: (req, res) => {
+        res.set('X-Test', 'Test')
+    }
+})

package/test/package.json

@@ -0,0 +1,16 @@
+{
+    "name": "test",
+    "version": "1.0.0",
+    "description": "",
+    "type": "module",
+    "main": "stream.js",
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "keywords": [],
+    "author": "",
+    "license": "ISC",
+    "dependencies": {
+        "geonix": "file:.."
+    }
+}

package/test/stream.js

@@ -0,0 +1,38 @@
+import { randomBytes } from 'node:crypto'
+import { Stream, getReadable, connection } from 'geonix'
+import { createWriteStream, readFileSync } from 'node:fs'
+import { createHash } from 'node:crypto'
+import { pipeline } from 'node:stream/promises'
+
+await connection.waitUntilReady()
+
+const hash = data => createHash('sha512').update(data).digest('base64')
+
+const PAYLOAD_SIZE = 1024 * 1024 * 1024
+const TEMP_FILE = '/tmp/geonix.stream_test'
+
+console.time('test')
+try {
+    const payload = randomBytes(PAYLOAD_SIZE)
+    const sourceHash = hash(payload)
+
+    const source = await getReadable(Stream(payload))
+    const dest = createWriteStream(TEMP_FILE)
+
+    await pipeline(source, dest)
+
+    const check = readFileSync(TEMP_FILE)
+    const destHash = hash(check)
+
+    if (sourceHash == destHash) {
+        console.log('MATCH')
+    } else {
+        console.error('Destination does not match the source!')
+        console.log(payload)
+        console.log(check)
+    }
+} catch (e) {
+    console.error(e)
+} finally {
+    console.timeEnd('test')
+}

package/tsconfig.json

@@ -6,15 +6,15 @@
         "src/status/**"
     ],
     "compilerOptions": {
-        "target": "es2016", /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
-        "module": "commonjs", /* Specify what module code is generated. */
-        "allowJs": true, /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
-        "declaration": true, /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
-        "emitDeclarationOnly": true, /* Only output d.ts files and not JavaScript files. */
-        "outDir": "./build", /* Specify an output folder for all emitted files. */
-        "esModuleInterop": true, /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
-        "forceConsistentCasingInFileNames": true, /* Ensure that casing is correct in imports. */
-        "strict": true, /* Enable all strict type-checking options. */
-        "skipLibCheck": true /* Skip type checking all .d.ts files. */
+        "target": "es2016",
+        "module": "commonjs",
+        "allowJs": true,
+        "declaration": true,
+        "emitDeclarationOnly": true,
+        "outDir": "./build",
+        "esModuleInterop": true,
+        "forceConsistentCasingInFileNames": true,
+        "strict": true,
+        "skipLibCheck": true
     }
 }