oak-domain 3.0.3 → 4.0.0

package/lib/utils/SimpleConnector.d.ts

@@ -1,50 +1,64 @@
-/// <reference types="node" />
-import { IncomingHttpHeaders } from "http";
-import { AsyncContext, AsyncRowStore } from '../store/AsyncRowStore';
-import { SyncContext } from '../store/SyncRowStore';
-import { Connector, EntityDict, OakException } from "../types";
-export declare class SimpleConnector<ED extends EntityDict, BackCxt extends AsyncContext<ED>, FrontCxt extends SyncContext<ED>> extends Connector<ED, BackCxt, FrontCxt> {
-    static ASPECT_ROUTER: string;
-    static BRIDGE_ROUTER: string;
-    static SUBSCRIBE_ROUTER: string;
-    private serverAspectUrl;
-    private serverBridgeUrl;
-    private makeException;
-    private contextBuilder;
-    constructor(serverUrl: string, makeException: (exceptionData: any) => OakException<ED>, contextBuilder: (str: string | undefined) => (store: AsyncRowStore<ED, BackCxt>) => Promise<BackCxt>);
-    callAspect(name: string, params: any, context: FrontCxt): Promise<{
-        result: any;
-        opRecords: any;
-        message: string | null;
-    } | {
-        result: ArrayBuffer;
-        message: string | null;
-        opRecords?: undefined;
-    }>;
-    getRouter(): string;
-    getSubscribeRouter(): string;
-    parseRequest(headers: IncomingHttpHeaders, body: any, store: AsyncRowStore<ED, BackCxt>): Promise<{
-        name: string;
-        params: any;
-        context: BackCxt;
-    }>;
-    serializeResult(result: any, context: BackCxt, headers: IncomingHttpHeaders, body: any): Promise<{
-        body: any;
-        headers?: Record<string, any> | undefined;
-    }>;
-    serializeException(exception: OakException<ED>, headers: IncomingHttpHeaders, body: any): {
-        body: any;
-        headers?: Record<string, any> | undefined;
-    };
-    getBridgeRouter(): string;
-    /**
-     * 通过本地服务器桥接访问外部资源的url
-     * @param url
-     * @param headers
-     */
-    makeBridgeUrl(url: string, headers?: Record<string, string>): string;
-    parseBridgeRequestQuery(urlParams: string): {
-        url: string;
-        headers?: Record<string, string> | undefined;
-    };
-}
+/// <reference types="node" />
+import { IncomingHttpHeaders } from "http";
+import { SyncContext } from '../store/SyncRowStore';
+import { Connector, EntityDict, OakException, OpRecord } from "../types";
+type ServerOption = {
+    protocol: string;
+    hostname: string;
+    port?: number;
+    apiPath?: string;
+};
+export declare class SimpleConnector<ED extends EntityDict, FrontCxt extends SyncContext<ED>> implements Connector<ED, FrontCxt> {
+    static ASPECT_ROUTER: string;
+    static BRIDGE_ROUTER: string;
+    static SUBSCRIBE_ROUTER: string;
+    static SUBSCRIBE_POINT_ROUTER: string;
+    static ENDPOINT_ROUTER: string;
+    private serverAspectUrl;
+    private serverBridgeUrl;
+    private serverSubscribePointUrl;
+    private option;
+    private makeException;
+    constructor(option: ServerOption, makeException: (exceptionData: any) => OakException<ED>);
+    callAspect(name: string, params: any, context: FrontCxt): Promise<{
+        result: any;
+        opRecords: any;
+        message: string | null;
+    } | {
+        result: ArrayBuffer;
+        message: string | null;
+        opRecords?: undefined;
+    }>;
+    getRouter(): string;
+    getSubscribeRouter(): string;
+    getSubscribePointRouter(): string;
+    getSubscribePoint(): Promise<{
+        url: any;
+        path: any;
+    }>;
+    getEndpointRouter(): string;
+    parseRequestHeaders(headers: IncomingHttpHeaders): {
+        contextString: string | undefined;
+        aspectName: string;
+    };
+    serializeResult(result: any, opRecords: OpRecord<ED>[], headers: IncomingHttpHeaders, body: any, message?: string): Promise<{
+        body: any;
+        headers?: Record<string, any> | undefined;
+    }>;
+    serializeException(exception: OakException<ED>, headers: IncomingHttpHeaders, body: any): {
+        body: any;
+        headers?: Record<string, any> | undefined;
+    };
+    getBridgeRouter(): string;
+    /**
+     * 通过本地服务器桥接访问外部资源的url
+     * @param url
+     * @param headers
+     */
+    makeBridgeUrl(url: string, headers?: Record<string, string>): string;
+    parseBridgeRequestQuery(urlParams: string): {
+        url: string;
+        headers?: Record<string, string> | undefined;
+    };
+}
+export {};

package/lib/utils/SimpleConnector.js

@@ -1,184 +1,206 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimpleConnector = void 0;
-var tslib_1 = require("tslib");
-var assert_1 = tslib_1.__importDefault(require("assert"));
-var stream_1 = require("stream");
-var url_1 = tslib_1.__importDefault(require("url"));
-var types_1 = require("../types");
-function makeContentTypeAndBody(data) {
-    //
-    if (process.env.OAK_PLATFORM !== 'wechatMp') {
-        if (data instanceof FormData) {
-            return {
-                // contentType: 'multipart/form-data',
-                body: data,
-            };
-        }
-    }
-    return {
-        contentType: 'application/json',
-        body: JSON.stringify(data),
-    };
-}
-var SimpleConnector = /** @class */ (function (_super) {
-    tslib_1.__extends(SimpleConnector, _super);
-    function SimpleConnector(serverUrl, makeException, contextBuilder) {
-        var _this = _super.call(this) || this;
-        _this.serverAspectUrl = "".concat(serverUrl).concat(SimpleConnector.ASPECT_ROUTER);
-        _this.serverBridgeUrl = "".concat(serverUrl).concat(SimpleConnector.BRIDGE_ROUTER);
-        _this.makeException = makeException;
-        _this.contextBuilder = contextBuilder;
-        return _this;
-    }
-    SimpleConnector.prototype.callAspect = function (name, params, context) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var cxtStr, _a, contentType, body, response, err, message, responseType, _b, exception, result, opRecords, result;
-            return tslib_1.__generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        cxtStr = context.toString();
-                        _a = makeContentTypeAndBody(params), contentType = _a.contentType, body = _a.body;
-                        return [4 /*yield*/, global.fetch(this.serverAspectUrl, {
-                                method: 'POST',
-                                headers: Object.assign({
-                                    'oak-cxt': cxtStr,
-                                    'oak-aspect': name,
-                                }, contentType && {
-                                    'Content-Type': contentType,
-                                }),
-                                body: body,
-                            })];
-                    case 1:
-                        response = _c.sent();
-                        if (response.status > 299) {
-                            err = new types_1.OakExternalException("\u7F51\u7EDC\u8BF7\u6C42\u8FD4\u56DE\u5F02\u5E38\uFF0Cstatus\u662F".concat(response.status));
-                            throw err;
-                        }
-                        message = response.headers.get('oak-message');
-                        responseType = response.headers.get('Content-Type') || response.headers.get('content-type');
-                        if (!(responseType === null || responseType === void 0 ? void 0 : responseType.toLocaleLowerCase().match(/application\/json/i))) return [3 /*break*/, 3];
-                        return [4 /*yield*/, response.json()];
-                    case 2:
-                        _b = _c.sent(), exception = _b.exception, result = _b.result, opRecords = _b.opRecords;
-                        if (exception) {
-                            throw this.makeException(exception);
-                        }
-                        return [2 /*return*/, {
-                                result: result,
-                                opRecords: opRecords,
-                                message: message,
-                            }];
-                    case 3:
-                        if (!(responseType === null || responseType === void 0 ? void 0 : responseType.toLocaleLowerCase().match(/application\/octet-stream/i))) return [3 /*break*/, 5];
-                        return [4 /*yield*/, response.arrayBuffer()];
-                    case 4:
-                        result = _c.sent();
-                        return [2 /*return*/, {
-                                result: result,
-                                message: message,
-                            }];
-                    case 5: throw new Error("\u5C1A\u4E0D\u652F\u6301\u7684content-type\u7C7B\u578B".concat(responseType));
-                }
-            });
-        });
-    };
-    SimpleConnector.prototype.getRouter = function () {
-        return SimpleConnector.ASPECT_ROUTER;
-    };
-    SimpleConnector.prototype.getSubscribeRouter = function () {
-        return SimpleConnector.SUBSCRIBE_ROUTER;
-    };
-    SimpleConnector.prototype.parseRequest = function (headers, body, store) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var oakCxtStr, aspectName, context;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        oakCxtStr = headers["oak-cxt"], aspectName = headers["oak-aspect"];
-                        (0, assert_1.default)(typeof oakCxtStr === 'string' || oakCxtStr === undefined);
-                        (0, assert_1.default)(typeof aspectName === 'string');
-                        return [4 /*yield*/, this.contextBuilder(oakCxtStr)(store)];
-                    case 1:
-                        context = _a.sent();
-                        context.setHeaders(headers);
-                        return [2 /*return*/, {
-                                name: aspectName,
-                                params: body,
-                                context: context,
-                            }];
-                }
-            });
-        });
-    };
-    SimpleConnector.prototype.serializeResult = function (result, context, headers, body) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (result instanceof stream_1.Stream || result instanceof Buffer) {
-                            return [2 /*return*/, {
-                                    body: result,
-                                }];
-                        }
-                        return [4 /*yield*/, context.refineOpRecords()];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, {
-                                body: {
-                                    result: result,
-                                    opRecords: context.opRecords,
-                                },
-                                headers: {
-                                    'oak-message': context.getMessage(),
-                                },
-                            }];
-                }
-            });
-        });
-    };
-    SimpleConnector.prototype.serializeException = function (exception, headers, body) {
-        return {
-            body: {
-                exception: exception.toString(),
-            },
-        };
-    };
-    SimpleConnector.prototype.getBridgeRouter = function () {
-        return SimpleConnector.BRIDGE_ROUTER;
-    };
-    /**
-     * 通过本地服务器桥接访问外部资源的url
-     * @param url
-     * @param headers
-     */
-    SimpleConnector.prototype.makeBridgeUrl = function (url, headers) {
-        // if (process.env.PROD !== 'true') {
-        //     console.warn('在development下无法通过bridge访问资源，将直接访问，可能失败', url);
-        //     return url;
-        // }
-        var encodeUrl = encodeURIComponent(url);
-        // const urlParse = URL.parse(url, true);
-        // const { search } = urlParse as {
-        //     search: string;
-        // };
-        // if (headers) {
-        //     search.append('headers', JSON.stringify(headers));
-        // }
-        return "".concat(this.serverBridgeUrl, "?url=").concat(encodeUrl);
-    };
-    SimpleConnector.prototype.parseBridgeRequestQuery = function (urlParams) {
-        var search = new url_1.default.URLSearchParams(urlParams);
-        var url = search.get('url');
-        var headers = search.get('headers');
-        return {
-            url: url,
-            headers: headers && JSON.parse(headers),
-        };
-    };
-    SimpleConnector.ASPECT_ROUTER = '/aspect';
-    SimpleConnector.BRIDGE_ROUTER = '/bridge';
-    SimpleConnector.SUBSCRIBE_ROUTER = '/subscribe';
-    return SimpleConnector;
-}(types_1.Connector));
-exports.SimpleConnector = SimpleConnector;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleConnector = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const stream_1 = require("stream");
+const url_1 = tslib_1.__importDefault(require("url"));
+const types_1 = require("../types");
+function makeContentTypeAndBody(data) {
+    if (process.env.OAK_PLATFORM !== 'wechatMp') {
+        if (data instanceof FormData) {
+            return {
+                // contentType: 'multipart/form-data',
+                body: data,
+            };
+        }
+    }
+    return {
+        contentType: 'application/json',
+        body: JSON.stringify(data),
+    };
+}
+class SimpleConnector {
+    static ASPECT_ROUTER = '/aspect';
+    static BRIDGE_ROUTER = '/bridge';
+    static SUBSCRIBE_ROUTER = '/subscribe';
+    static SUBSCRIBE_POINT_ROUTER = '/subscribePoint';
+    static ENDPOINT_ROUTER = '/endpoint';
+    serverAspectUrl;
+    serverBridgeUrl;
+    serverSubscribePointUrl;
+    option;
+    makeException;
+    constructor(option, makeException) {
+        this.option = option;
+        const { protocol, hostname, port, apiPath } = option;
+        let serverUrl = `${protocol}//${hostname}`;
+        if (typeof port === 'number') {
+            serverUrl += `:${port}`;
+        }
+        if (apiPath) {
+            (0, assert_1.default)(apiPath.startsWith('/'), 'apiPath前缀必须存在/');
+            serverUrl += apiPath;
+        }
+        this.serverAspectUrl = `${serverUrl}${SimpleConnector.ASPECT_ROUTER}`;
+        this.serverBridgeUrl = `${serverUrl}${SimpleConnector.BRIDGE_ROUTER}`;
+        this.serverSubscribePointUrl = `${serverUrl}${SimpleConnector.SUBSCRIBE_POINT_ROUTER}`;
+        this.makeException = makeException;
+    }
+    async callAspect(name, params, context) {
+        const cxtStr = context.toString();
+        const { contentType, body } = makeContentTypeAndBody(params);
+        let response;
+        try {
+            response = await global.fetch(this.serverAspectUrl, {
+                method: 'POST',
+                headers: Object.assign({
+                    'oak-cxt': cxtStr,
+                    'oak-aspect': name,
+                }, contentType && {
+                    'Content-Type': contentType,
+                }),
+                body,
+            });
+        }
+        catch (err) {
+            // fetch返回异常一定是网络异常
+            throw new types_1.OakNetworkException();
+        }
+        if (response.status > 299) {
+            const err = new types_1.OakServerProxyException(`网络请求返回status是${response.status}`);
+            throw err;
+        }
+        const message = response.headers.get('oak-message');
+        const responseType = response.headers.get('Content-Type') ||
+            response.headers.get('content-type');
+        if (responseType?.toLocaleLowerCase().match(/application\/json/i)) {
+            const { exception, result, opRecords } = await response.json();
+            if (exception) {
+                throw this.makeException(exception);
+            }
+            return {
+                result,
+                opRecords,
+                message,
+            };
+        }
+        else if (responseType
+            ?.toLocaleLowerCase()
+            .match(/application\/octet-stream/i)) {
+            const result = await response.arrayBuffer();
+            return {
+                result,
+                message,
+            };
+        }
+        else {
+            throw new Error(`尚不支持的content-type类型${responseType}`);
+        }
+    }
+    getRouter() {
+        return SimpleConnector.ASPECT_ROUTER;
+    }
+    getSubscribeRouter() {
+        return SimpleConnector.SUBSCRIBE_ROUTER;
+    }
+    getSubscribePointRouter() {
+        return SimpleConnector.SUBSCRIBE_POINT_ROUTER;
+    }
+    async getSubscribePoint() {
+        let response;
+        try {
+            response = await global.fetch(this.serverSubscribePointUrl);
+        }
+        catch (err) {
+            throw new types_1.OakNetworkException();
+        }
+        if (response.status > 299) {
+            const err = new types_1.OakServerProxyException(`网络请求返回status是${response.status}`);
+            throw err;
+        }
+        const message = response.headers.get('oak-message');
+        const responseType = response.headers.get('Content-Type') ||
+            response.headers.get('content-type');
+        if (responseType?.toLocaleLowerCase().match(/application\/json/i)) {
+            const { url, path, port, namespace } = await response.json();
+            let url2 = url || `${this.option.protocol}//${this.option.hostname}`;
+            (0, assert_1.default)(port);
+            url2 += `:${port}`;
+            if (namespace) {
+                url2 += namespace;
+            }
+            return {
+                url: url2,
+                path,
+            };
+        }
+        else {
+            throw new Error(`尚不支持的content-type类型${responseType}`);
+        }
+    }
+    getEndpointRouter() {
+        return SimpleConnector.ENDPOINT_ROUTER;
+    }
+    parseRequestHeaders(headers) {
+        const { 'oak-cxt': oakCxtStr, 'oak-aspect': aspectName } = headers;
+        (0, assert_1.default)(typeof oakCxtStr === 'string' || oakCxtStr === undefined);
+        (0, assert_1.default)(typeof aspectName === 'string');
+        return {
+            contextString: oakCxtStr,
+            aspectName,
+        };
+    }
+    async serializeResult(result, opRecords, headers, body, message) {
+        if (result instanceof stream_1.Stream || result instanceof Buffer) {
+            return {
+                body: result,
+                headers: {
+                    'oak-message': message,
+                },
+            };
+        }
+        return {
+            body: {
+                result,
+                opRecords,
+            },
+            headers: {
+                'oak-message': message,
+            },
+        };
+    }
+    serializeException(exception, headers, body) {
+        return {
+            body: {
+                exception: exception.toString(),
+            },
+        };
+    }
+    getBridgeRouter() {
+        return SimpleConnector.BRIDGE_ROUTER;
+    }
+    /**
+     * 通过本地服务器桥接访问外部资源的url
+     * @param url
+     * @param headers
+     */
+    makeBridgeUrl(url, headers) {
+        // if (process.env.PROD !== 'true') {
+        //     console.warn('在development下无法通过bridge访问资源，将直接访问，可能失败', url);
+        //     return url;
+        // }
+        const encodeUrl = encodeURIComponent(url);
+        return `${this.serverBridgeUrl}?url=${encodeUrl}`;
+    }
+    parseBridgeRequestQuery(urlParams) {
+        const search = new url_1.default.URLSearchParams(urlParams);
+        const url = search.get('url');
+        const headers = search.get('headers');
+        return {
+            url,
+            headers: headers && JSON.parse(headers),
+        };
+    }
+}
+exports.SimpleConnector = SimpleConnector;

package/lib/utils/assert.d.ts

@@ -1,5 +1,5 @@
-/**
- * 防止assert打包体积过大，从这里引用
- */
-import assert from 'assert';
-export { assert, };
+/**
+ * 防止assert打包体积过大，从这里引用
+ */
+import assert from 'assert';
+export { assert, };

package/lib/utils/assert.js

@@ -1,9 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assert = void 0;
-var tslib_1 = require("tslib");
-/**
- * 防止assert打包体积过大，从这里引用
- */
-var assert_1 = tslib_1.__importDefault(require("assert"));
-exports.assert = assert_1.default;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = void 0;
+const tslib_1 = require("tslib");
+/**
+ * 防止assert打包体积过大，从这里引用
+ */
+const assert_1 = tslib_1.__importDefault(require("assert"));
+exports.assert = assert_1.default;

package/lib/utils/concurrent.d.ts

@@ -1,15 +1,15 @@
-declare type Mode = 'S' | 'X';
-/**
- * 模拟一个读写锁，用于同步。
- * 注意，千万不要发生自己等自己
- */
-export declare class RWLock {
-    private readNumber;
-    private writeNumber;
-    private readWaiter;
-    private writeWaiter;
-    constructor();
-    acquire(mode: Mode): Promise<void>;
-    release(): void;
-}
-export {};
+type Mode = 'S' | 'X';
+/**
+ * 模拟一个读写锁，用于同步。
+ * 注意，千万不要发生自己等自己
+ */
+export declare class RWLock {
+    private readNumber;
+    private writeNumber;
+    private readWaiter;
+    private writeWaiter;
+    constructor();
+    acquire(mode: Mode): Promise<void>;
+    release(): void;
+}
+export {};