oox 0.3.0-beta8 → 0.3.1

package/modules/http/index.js

@@ -1,186 +1,234 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HTTPConfig = void 0;
-const http = require("node:http");
-const utils_1 = require("./utils");
-const oox = require("../../index");
-const module_1 = require("../module");
-class HTTPConfig extends module_1.ModuleConfig {
-    // listen port
-    port = 0;
-    // service path
-    path = '/';
-    // browser cross origin
-    origin = '';
-}
-exports.HTTPConfig = HTTPConfig;
-class HTTPModule extends module_1.default {
-    name = 'http';
-    config = new HTTPConfig;
-    server = null;
-    setConfig(config) {
-        Object.assign(this.config, config);
-        if (!config.hasOwnProperty('port')) {
-            this.config.port = oox.config.port;
-        }
-        if (!config.hasOwnProperty('origin')) {
-            this.config.origin = oox.config.origin;
-        }
-    }
-    getConfig() {
-        return this.config;
-    }
-    /**
-     * start http service
-     */
-    async serve() {
-        await this.stop();
-        const { port } = this.config;
-        this.server = http.createServer(this.call.bind(this));
-        this.server.listen(port);
-        const address = this.server.address();
-        if (!address || 'object' !== typeof address)
-            throw new Error('Cannot read http server port');
-        this.config.port = address.port;
-    }
-    /**
-     * stop http service
-     */
-    stop() {
-        if (this.server && this.server.listening)
-            return new Promise((resolve, reject) => {
-                this.server.close(function (error) {
-                    if (error)
-                        reject(error);
-                    else
-                        resolve();
-                });
-            });
-    }
-    /**
-     * browser cross origin
-     */
-    cors(request, response) {
-        // origin checking
-        const origin = this.config.origin;
-        const requestOrigin = request.headers.origin;
-        if (origin && requestOrigin) {
-            if (origin === '*' || origin === requestOrigin || Array.isArray(origin) && origin.includes(requestOrigin)) {
-                response.setHeader('Access-Control-Allow-Origin', requestOrigin);
-                response.setHeader('Vary', 'Origin');
-            }
-            else {
-                response.statusCode = 403;
-                response.end();
-                return false;
-            }
-            response.setHeader('Access-Control-Max-Age', 3600);
-            response.setHeader('Access-Control-Allow-Headers', 'x-caller,content-type');
-            response.setHeader('Access-Control-Allow-Methods', '*');
-        }
-        if (request.method === 'OPTIONS') {
-            response.statusCode = 204;
-            response.end();
-            return false;
-        }
-        return true;
-    }
-    /**
-     * HTTP-RPC服务器请求监听方法
-     */
-    async call(request, response) {
-        if (request.url !== this.config.path) {
-            const error = {
-                message: 'Invalid URL',
-                stack: ''
-            };
-            Error.captureStackTrace(error);
-            return this.respond(request, response, {
-                success: false,
-                error
-            });
-        }
-        if (!this.cors(request, response))
-            return;
-        let body = Object.create(null);
-        try {
-            body = await (0, utils_1.parseHTTPBody)(request);
-            if (!body || 'object' !== typeof body)
-                throw new Error('Content Invalid');
-        }
-        catch (error) {
-            return this.respond(request, response, {
-                success: false,
-                error: {
-                    message: error.message,
-                    stack: error.stack
-                }
-            });
-        }
-        // global unique id
-        const traceId = String(request.headers['x-trace-id'] || '');
-        // service name, required
-        const caller = String(request.headers['x-caller'] || 'anonymous');
-        // client ip or caller service ip
-        const ip = String(request.headers['x-ip'] || request.socket.remoteAddress || '');
-        // startup client ip
-        const sourceIP = String(request.headers['x-real-ip'] || '');
-        const { action, params = [] } = body;
-        const context = oox.genContext({ traceId, caller, sourceIP, ip, callerId: '' });
-        const format = await oox.call(action, params, context);
-        this.respond(request, response, format);
-    }
-    /**
-     * HTTP Response Catch
-     */
-    respond(request, response, format) {
-        let formatString = '';
-        try {
-            formatString = JSON.stringify(format);
-        }
-        catch ({ message, stack }) {
-            delete format.body;
-            format.success = false;
-            format.error = {
-                message,
-                stack
-            };
-            formatString = JSON.stringify(format);
-        }
-        response.setHeader('Content-Type', 'application/json');
-        response.setHeader('Content-Length', Buffer.byteLength(formatString));
-        response.end(formatString);
-    }
-    /**
-     * HTTP RPC
-     */
-    async rpc(url, action, params, context) {
-        if (!context || !context.traceId) {
-            context = oox.getContext();
-        }
-        const { traceId, caller, sourceIP } = context;
-        const headers = {
-            'Content-Type': 'application/json',
-            'x-trace-id': String(traceId),
-        };
-        if (caller)
-            headers['x-caller'] = String(caller);
-        if (sourceIP)
-            headers['x-real-ip'] = sourceIP;
-        // headers [ 'x-ip' ] = getIPAddress ( 4 ) [ 0 ]
-        const format = await (0, utils_1.httpRequest)(url, {
-            headers
-        }, JSON.stringify({ action, params }));
-        if ('string' === typeof format)
-            throw new Error(format);
-        const { error, body } = format;
-        if (error) {
-            const asyncError = new Error(error.message);
-            throw asyncError;
-        }
-        else {
-            return body;
-        }
-    }
-}
-exports.default = HTTPModule;
+import * as http from 'node:http';
+import * as https from 'node:https';
+import { httpRequest, parseHTTPBody } from './utils.js';
+import * as oox from '../../index.js';
+import Module, { ModuleConfig } from '../module.js';
+export class HTTPConfig extends ModuleConfig {
+    // listen port
+    port = 0;
+    // service path
+    path = '/';
+    // browser cross origin
+    origin = '';
+    // https options
+    ssl = {
+        // enable https
+        enabled: false,
+        // ssl certificate path
+        cert: '',
+        // ssl private key path
+        key: '',
+        // ssl ca path
+        ca: ''
+    };
+}
+export default class HTTPModule extends Module {
+    name = 'http';
+    config = new HTTPConfig;
+    server = null;
+    getUrl() {
+        const { host } = oox.config;
+        const { port, path } = this.config;
+        const protocol = this.config.ssl.enabled ? `https:` : `http:`;
+        return `${protocol}//${host}:${port}${path}`;
+    }
+    setConfig(config) {
+        Object.assign(this.config, config);
+        if (!config.hasOwnProperty('port')) {
+            this.config.port = oox.config.port;
+        }
+        if (!config.hasOwnProperty('origin')) {
+            this.config.origin = oox.config.origin;
+        }
+    }
+    getConfig() {
+        return this.config;
+    }
+    /**
+     * start http service
+     */
+    async serve() {
+        await this.stop();
+        const { port, ssl } = this.config;
+        if (ssl.enabled) {
+            const fs = await import('node:fs');
+            const options = {
+                key: ssl.key ? fs.readFileSync(ssl.key) : null,
+                cert: ssl.cert ? fs.readFileSync(ssl.cert) : null,
+                ca: ssl.ca ? fs.readFileSync(ssl.ca) : null
+            };
+            if (!options.key || !options.cert) {
+                throw new Error('HTTPS enabled but missing key or cert');
+            }
+            this.server = https.createServer(options, this.requestHandler.bind(this));
+        }
+        else {
+            this.server = http.createServer(this.requestHandler.bind(this));
+        }
+        this.server.listen(port);
+        const address = this.server.address();
+        if (!address || 'object' !== typeof address)
+            throw new Error('Cannot read http server port');
+        this.config.port = address.port;
+    }
+    /**
+     * stop http service
+     */
+    stop() {
+        if (this.server && this.server.listening)
+            return new Promise((resolve, reject) => {
+                this.server.close(function (error) {
+                    if (error)
+                        reject(error);
+                    else
+                        resolve();
+                });
+            });
+    }
+    /**
+     * browser cross origin
+     */
+    cors(request, response) {
+        // origin checking
+        const origin = this.config.origin;
+        const requestOrigin = request.headers.origin;
+        if (origin && requestOrigin) {
+            if (origin === '*' ||
+                origin === requestOrigin ||
+                (Array.isArray(origin) && origin.includes(requestOrigin))) {
+                response.setHeader('Access-Control-Allow-Origin', requestOrigin);
+                response.setHeader('Vary', 'Origin');
+            }
+            else {
+                response.statusCode = 403;
+                response.end();
+                return false;
+            }
+            response.setHeader('Access-Control-Max-Age', 3600);
+            response.setHeader('Access-Control-Allow-Headers', 'x-caller,content-type');
+            response.setHeader('Access-Control-Allow-Methods', '*');
+        }
+        if (request.method === 'OPTIONS') {
+            response.statusCode = 204;
+            response.end();
+            return false;
+        }
+        return true;
+    }
+    async requestHandler(request, response) {
+        if (!this.cors(request, response))
+            return;
+        const url = new URL(request.url, request.headers.origin || 'http://localhost');
+        if (url.pathname === this.config.path) {
+            await this.call(request, response);
+        }
+        else {
+            const error = new Error('Invalid URL');
+            return this.respond(request, response, {
+                success: false,
+                error: {
+                    message: error.message,
+                    stack: error.stack
+                }
+            });
+        }
+    }
+    /**
+     * 从请求里获取调用的接口和参数
+     */
+    async getCallArgsFromRequest(request) {
+        const args = await parseHTTPBody(request);
+        if (!args || 'object' !== typeof args || !args.action)
+            throw new Error('Content Invalid');
+        else
+            return args;
+    }
+    /**
+     * HTTP-RPC服务器请求监听方法
+     */
+    async call(request, response) {
+        let callArgs = Object.create(null);
+        try {
+            callArgs = await this.getCallArgsFromRequest(request);
+        }
+        catch (error) {
+            return this.respond(request, response, {
+                success: false,
+                error: {
+                    message: error.message,
+                    stack: error.stack
+                }
+            });
+        }
+        // global unique id
+        const traceId = String(request.headers['x-trace-id'] || '');
+        // service name, required
+        const caller = String(request.headers['x-caller'] || 'anonymous');
+        // client ip or caller service ip
+        const ip = String(request.headers['x-ip'] || request.socket.remoteAddress || '');
+        // startup client ip
+        const sourceIP = String(request.headers['x-real-ip'] || '');
+        const { action, params = [] } = callArgs;
+        const context = oox.genContext({ traceId, caller, sourceIP, ip, callerId: '' });
+        const format = await oox.call(action, params, context);
+        this.respond(request, response, format);
+    }
+    /**
+     * HTTP Response Catch
+     */
+    respond(_request, response, returns) {
+        let returnsString = '';
+        if (!oox.config.errorStack && returns.error) {
+            // 不返回错误调用栈信息
+            delete returns.error.stack;
+        }
+        try {
+            returnsString = JSON.stringify(returns);
+        }
+        catch ({ message, stack }) {
+            delete returns.body;
+            returns.success = false;
+            returns.error = {
+                message
+            };
+            if (oox.config.errorStack) {
+                // 返回错误调用栈信息
+                returns.error.stack = stack;
+            }
+            returnsString = JSON.stringify(returns);
+        }
+        response.setHeader('Content-Type', 'application/json');
+        response.setHeader('Content-Length', Buffer.byteLength(returnsString));
+        response.end(returnsString);
+    }
+    /**
+     * HTTP RPC
+     */
+    async rpc(url, action, params, context) {
+        if (!context || !context.traceId) {
+            context = oox.getContext();
+        }
+        const { traceId, caller, sourceIP } = context;
+        const headers = {
+            'Content-Type': 'application/json',
+            'x-trace-id': String(traceId),
+        };
+        if (caller)
+            headers['x-caller'] = String(caller);
+        if (sourceIP)
+            headers['x-real-ip'] = sourceIP;
+        // headers [ 'x-ip' ] = getIPAddress ( 4 ) [ 0 ]
+        const format = await httpRequest(url, {
+            headers
+        }, JSON.stringify({ action, params }));
+        if ('string' === typeof format)
+            throw new Error(format);
+        const { success, error, body } = format;
+        if (success)
+            return body;
+        else if (error)
+            throw new Error(error.message);
+        else
+            throw new Error('[RPC] Unknown Error');
+    }
+}

package/modules/http/utils.js

@@ -1,73 +1,74 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.httpRequest = exports.parseHTTPBody = exports.stream2buffer = void 0;
-const http = require("node:http");
-/**
- * Stream => Buffer
- */
-function stream2buffer(stream, totalLength = 0) {
-    return new Promise(function (resolve, reject) {
-        let buffers = [];
-        stream.on('error', reject);
-        if (totalLength) {
-            stream.on('data', function (data) { buffers.push(data); });
-        }
-        else {
-            stream.on('data', function (data) {
-                buffers.push(data);
-                totalLength += data.length;
-            });
-        }
-        stream.on('end', function () { resolve(Buffer.concat(buffers, totalLength)); });
-    });
-}
-exports.stream2buffer = stream2buffer;
-/**
- * Request => JSONObject
- */
-async function parseHTTPBody(request) {
-    if (request.method === 'GET')
-        return null;
-    let contentType = request.headers['content-type'];
-    // application/json; charset=utf-8
-    if (contentType)
-        contentType = contentType.split(';')[0].trim();
-    const contentSize = request.headers['content-length'];
-    const buffer = await stream2buffer(request, +contentSize || 0);
-    if (contentSize && buffer.length !== +contentSize)
-        throw new Error('Content-Length Incorrect');
-    const bodyString = buffer.toString();
-    if ('application/json' === contentType) {
-        return JSON.parse(bodyString);
-    }
-    else {
-        return bodyString;
-    }
-}
-exports.parseHTTPBody = parseHTTPBody;
-/**
- * http request
- */
-function httpRequest(url, options, body) {
-    return new Promise(function (resolve, reject) {
-        const request = http.request(url, options, async function (response) {
-            try {
-                const result = await parseHTTPBody(response);
-                resolve(result);
-            }
-            catch (error) {
-                const decoration = new Error(`${response.statusCode} - ${error.message}`);
-                reject(decoration);
-            }
-        });
-        request.on('error', reject);
-        if (body) {
-            request.method = 'POST';
-            request.setHeader('Content-Type', 'application/json');
-            request.setHeader('Content-Length', Buffer.byteLength(body));
-            request.write(body);
-        }
-        request.end();
-    });
-}
-exports.httpRequest = httpRequest;
+import * as http from 'node:http';
+import * as https from 'node:https';
+/**
+ * Stream => Buffer
+ */
+export function stream2buffer(stream, totalLength = 0) {
+    return new Promise(function (resolve, reject) {
+        let buffers = [];
+        stream.on('error', reject);
+        if (totalLength) {
+            stream.on('data', function (data) { buffers.push(data); });
+        }
+        else {
+            stream.on('data', function (data) {
+                buffers.push(data);
+                totalLength += data.length;
+            });
+        }
+        stream.on('end', function () { resolve(Buffer.concat(buffers, totalLength)); });
+    });
+}
+/**
+ * Request => JSONObject
+ */
+export async function parseHTTPBody(request) {
+    if (request.method === 'GET')
+        return null;
+    let contentType = request.headers['content-type'];
+    // application/json; charset=utf-8
+    if (contentType)
+        contentType = contentType.split(';')[0].trim();
+    const contentSize = request.headers['content-length'];
+    if (!contentSize)
+        return null;
+    const buffer = await stream2buffer(request, +contentSize || 0);
+    if (contentSize && buffer.length !== +contentSize)
+        throw new Error('Content-Length Incorrect');
+    switch (contentType) {
+        case 'application/json':
+            return JSON.parse(buffer.toString());
+        case 'text/plain':
+            return buffer.toString();
+        default:
+            return buffer;
+    }
+}
+/**
+ * http request
+ */
+export function httpRequest(url, options, body) {
+    return new Promise(function (resolve, reject) {
+        const urlObj = typeof url === 'string' ? new URL(url) : url;
+        const protocol = urlObj.protocol;
+        const client = protocol === 'https:' ? https : http;
+        const request = client.request(url, options, async function (response) {
+            try {
+                const result = await parseHTTPBody(response);
+                resolve(result);
+            }
+            catch (error) {
+                const decoration = new Error(`${response.statusCode} - ${error.message}`);
+                reject(decoration);
+            }
+        });
+        request.on('error', reject);
+        if (body) {
+            request.method = 'POST';
+            request.setHeader('Content-Type', 'application/json');
+            request.setHeader('Content-Length', Buffer.byteLength(body));
+            request.write(body);
+        }
+        request.end();
+    });
+}