@cloudbase/database 0.9.18-next → 0.9.19

package/dist/esm/realtime/ws-event.d.ts

@@ -0,0 +1,126 @@
+import { CloudSDKError } from '../utils/error';
+export declare const CLOSE_EVENT_CODE_INFO: {
+    1000: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1001: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1002: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1003: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1005: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1006: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1007: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1008: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1009: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1010: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1011: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1012: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1013: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1014: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1015: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    3000: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    3001: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    3002: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    3003: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    3050: {
+        code: number;
+        name: string;
+        description: string;
+    };
+};
+export declare enum CLOSE_EVENT_CODE {
+    NormalClosure = 1000,
+    GoingAway = 1001,
+    ProtocolError = 1002,
+    UnsupportedData = 1003,
+    NoStatusReceived = 1005,
+    AbnormalClosure = 1006,
+    InvalidFramePayloadData = 1007,
+    PolicyViolation = 1008,
+    MessageTooBig = 1009,
+    MissingExtension = 1010,
+    InternalError = 1011,
+    ServiceRestart = 1012,
+    TryAgainLater = 1013,
+    BadGateway = 1014,
+    TLSHandshake = 1015,
+    ReconnectWebSocket = 3000,
+    NoRealtimeListeners = 3001,
+    HeartbeatPingError = 3002,
+    HeartbeatPongTimeoutError = 3003,
+    NoAuthentication = 3050
+}
+export declare const getWSCloseError: (code: CLOSE_EVENT_CODE, reason?: string) => CloudSDKError;

package/dist/esm/realtime/ws-event.js

@@ -0,0 +1,137 @@
+import { CloudSDKError } from '../utils/error';
+import { ERR_CODE } from '../config/error.config';
+export const CLOSE_EVENT_CODE_INFO = {
+    1000: {
+        code: 1000,
+        name: 'Normal Closure',
+        description: 'Normal closure; the connection successfully completed whatever purpose for which it was created.'
+    },
+    1001: {
+        code: 1001,
+        name: 'Going Away',
+        description: 'The endpoint is going away, either because of a server failure or because the browser is navigating away from the page that opened the connection.'
+    },
+    1002: {
+        code: 1002,
+        name: 'Protocol Error',
+        description: 'The endpoint is terminating the connection due to a protocol error.'
+    },
+    1003: {
+        code: 1003,
+        name: 'Unsupported Data',
+        description: 'The connection is being terminated because the endpoint received data of a type it cannot accept (for example, a text-only endpoint received binary data).'
+    },
+    1005: {
+        code: 1005,
+        name: 'No Status Received',
+        description: 'Indicates that no status code was provided even though one was expected.'
+    },
+    1006: {
+        code: 1006,
+        name: 'Abnormal Closure',
+        description: 'Used to indicate that a connection was closed abnormally (that is, with no close frame being sent) when a status code is expected.'
+    },
+    1007: {
+        code: 1007,
+        name: 'Invalid frame payload data',
+        description: 'The endpoint is terminating the connection because a message was received that contained inconsistent data (e.g., non-UTF-8 data within a text message).'
+    },
+    1008: {
+        code: 1008,
+        name: 'Policy Violation',
+        description: 'The endpoint is terminating the connection because it received a message that violates its policy. This is a generic status code, used when codes 1003 and 1009 are not suitable.'
+    },
+    1009: {
+        code: 1009,
+        name: 'Message too big',
+        description: 'The endpoint is terminating the connection because a data frame was received that is too large.'
+    },
+    1010: {
+        code: 1010,
+        name: 'Missing Extension',
+        description: "The client is terminating the connection because it expected the server to negotiate one or more extension, but the server didn't."
+    },
+    1011: {
+        code: 1011,
+        name: 'Internal Error',
+        description: 'The server is terminating the connection because it encountered an unexpected condition that prevented it from fulfilling the request.'
+    },
+    1012: {
+        code: 1012,
+        name: 'Service Restart',
+        description: 'The server is terminating the connection because it is restarting.'
+    },
+    1013: {
+        code: 1013,
+        name: 'Try Again Later',
+        description: 'The server is terminating the connection due to a temporary condition, e.g. it is overloaded and is casting off some of its clients.'
+    },
+    1014: {
+        code: 1014,
+        name: 'Bad Gateway',
+        description: 'The server was acting as a gateway or proxy and received an invalid response from the upstream server. This is similar to 502 HTTP Status Code.'
+    },
+    1015: {
+        code: 1015,
+        name: 'TLS Handshake',
+        description: "Indicates that the connection was closed due to a failure to perform a TLS handshake (e.g., the server certificate can't be verified)."
+    },
+    3000: {
+        code: 3000,
+        name: 'Reconnect WebSocket',
+        description: 'The client is terminating the connection because it wants to reconnect'
+    },
+    3001: {
+        code: 3001,
+        name: 'No Realtime Listeners',
+        description: 'The client is terminating the connection because no more realtime listeners exist'
+    },
+    3002: {
+        code: 3002,
+        name: 'Heartbeat Ping Error',
+        description: 'The client is terminating the connection due to its failure in sending heartbeat messages'
+    },
+    3003: {
+        code: 3003,
+        name: 'Heartbeat Pong Timeout Error',
+        description: 'The client is terminating the connection because no heartbeat response is received from the server'
+    },
+    3050: {
+        code: 3050,
+        name: 'Server Close',
+        description: 'The client is terminating the connection because no heartbeat response is received from the server'
+    }
+};
+export var CLOSE_EVENT_CODE;
+(function (CLOSE_EVENT_CODE) {
+    CLOSE_EVENT_CODE[CLOSE_EVENT_CODE["NormalClosure"] = 1000] = "NormalClosure";
+    CLOSE_EVENT_CODE[CLOSE_EVENT_CODE["GoingAway"] = 1001] = "GoingAway";
+    CLOSE_EVENT_CODE[CLOSE_EVENT_CODE["ProtocolError"] = 1002] = "ProtocolError";
+    CLOSE_EVENT_CODE[CLOSE_EVENT_CODE["UnsupportedData"] = 1003] = "UnsupportedData";
+    CLOSE_EVENT_CODE[CLOSE_EVENT_CODE["NoStatusReceived"] = 1005] = "NoStatusReceived";
+    CLOSE_EVENT_CODE[CLOSE_EVENT_CODE["AbnormalClosure"] = 1006] = "AbnormalClosure";
+    CLOSE_EVENT_CODE[CLOSE_EVENT_CODE["InvalidFramePayloadData"] = 1007] = "InvalidFramePayloadData";
+    CLOSE_EVENT_CODE[CLOSE_EVENT_CODE["PolicyViolation"] = 1008] = "PolicyViolation";
+    CLOSE_EVENT_CODE[CLOSE_EVENT_CODE["MessageTooBig"] = 1009] = "MessageTooBig";
+    CLOSE_EVENT_CODE[CLOSE_EVENT_CODE["MissingExtension"] = 1010] = "MissingExtension";
+    CLOSE_EVENT_CODE[CLOSE_EVENT_CODE["InternalError"] = 1011] = "InternalError";
+    CLOSE_EVENT_CODE[CLOSE_EVENT_CODE["ServiceRestart"] = 1012] = "ServiceRestart";
+    CLOSE_EVENT_CODE[CLOSE_EVENT_CODE["TryAgainLater"] = 1013] = "TryAgainLater";
+    CLOSE_EVENT_CODE[CLOSE_EVENT_CODE["BadGateway"] = 1014] = "BadGateway";
+    CLOSE_EVENT_CODE[CLOSE_EVENT_CODE["TLSHandshake"] = 1015] = "TLSHandshake";
+    CLOSE_EVENT_CODE[CLOSE_EVENT_CODE["ReconnectWebSocket"] = 3000] = "ReconnectWebSocket";
+    CLOSE_EVENT_CODE[CLOSE_EVENT_CODE["NoRealtimeListeners"] = 3001] = "NoRealtimeListeners";
+    CLOSE_EVENT_CODE[CLOSE_EVENT_CODE["HeartbeatPingError"] = 3002] = "HeartbeatPingError";
+    CLOSE_EVENT_CODE[CLOSE_EVENT_CODE["HeartbeatPongTimeoutError"] = 3003] = "HeartbeatPongTimeoutError";
+    CLOSE_EVENT_CODE[CLOSE_EVENT_CODE["NoAuthentication"] = 3050] = "NoAuthentication";
+})(CLOSE_EVENT_CODE || (CLOSE_EVENT_CODE = {}));
+export const getWSCloseError = (code, reason) => {
+    const info = CLOSE_EVENT_CODE_INFO[code];
+    const errMsg = !info
+        ? `code ${code}`
+        : `${info.name}, code ${code}, reason ${reason || info.description}`;
+    return new CloudSDKError({
+        errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_WEBSOCKET_CONNECTION_CLOSED,
+        errMsg
+    });
+};

package/dist/esm/regexp/index.d.ts

@@ -1,14 +1,14 @@
-export declare class RegExp {
-    $regex: string;
-    $options: string;
-    constructor({ regexp, options }: {
-        regexp: any;
-        options: any;
-    });
-    parse(): {
-        $regex: string;
-        $options: string;
-    };
-    readonly _internalType: import("../utils/symbol").InternalSymbol;
-}
-export declare function RegExpConstructor(param: any): RegExp;
+export declare class RegExp {
+    $regex: string;
+    $options: string;
+    constructor({ regexp, options }: {
+        regexp: any;
+        options: any;
+    });
+    parse(): {
+        $regex: string;
+        $options: string;
+    };
+    readonly _internalType: import("../utils/symbol").InternalSymbol;
+}
+export declare function RegExpConstructor(param: any): RegExp;

package/dist/esm/regexp/index.js

@@ -1,29 +1,29 @@
-import { SYMBOL_REGEXP } from '../helper/symbol';
-var RegExp = (function () {
-    function RegExp(_a) {
-        var regexp = _a.regexp, options = _a.options;
-        if (!regexp) {
-            throw new TypeError('regexp must be a string');
-        }
-        this.$regex = regexp;
-        this.$options = options;
-    }
-    RegExp.prototype.parse = function () {
-        return {
-            $regex: this.$regex,
-            $options: this.$options
-        };
-    };
-    Object.defineProperty(RegExp.prototype, "_internalType", {
-        get: function () {
-            return SYMBOL_REGEXP;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    return RegExp;
-}());
-export { RegExp };
-export function RegExpConstructor(param) {
-    return new RegExp(param);
-}
+import { SYMBOL_REGEXP } from '../helper/symbol';
+var RegExp = (function () {
+    function RegExp(_a) {
+        var regexp = _a.regexp, options = _a.options;
+        if (!regexp) {
+            throw new TypeError('regexp must be a string');
+        }
+        this.$regex = regexp;
+        this.$options = options;
+    }
+    RegExp.prototype.parse = function () {
+        return {
+            $regex: this.$regex,
+            $options: this.$options
+        };
+    };
+    Object.defineProperty(RegExp.prototype, "_internalType", {
+        get: function () {
+            return SYMBOL_REGEXP;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return RegExp;
+}());
+export { RegExp };
+export function RegExpConstructor(param) {
+    return new RegExp(param);
+}

package/dist/esm/serializer/common.d.ts

@@ -1,11 +1,11 @@
-import { LogicCommand } from '../commands/logic';
-export declare type IQueryCondition = Record<string, any> | LogicCommand;
-export declare type AnyObject = {
-    [x: string]: any;
-};
-export declare function flattenQueryObject(query: Record<string, any>): Record<string, any>;
-export declare function flattenObject(object: AnyObject): AnyObject;
-export declare function mergeConditionAfterEncode(query: Record<string, any>, condition: Record<string, any>, key: string): void;
-export declare function isConversionRequired(val: any): boolean;
-export declare function encodeInternalDataType(val: any): IQueryCondition;
-export declare function decodeInternalDataType(object: AnyObject): any;
+import { LogicCommand } from '../commands/logic';
+export declare type IQueryCondition = Record<string, any> | LogicCommand;
+export declare type AnyObject = {
+    [x: string]: any;
+};
+export declare function flattenQueryObject(query: Record<string, any>): Record<string, any>;
+export declare function flattenObject(object: AnyObject): AnyObject;
+export declare function mergeConditionAfterEncode(query: Record<string, any>, condition: Record<string, any>, key: string): void;
+export declare function isConversionRequired(val: any): boolean;
+export declare function encodeInternalDataType(val: any): IQueryCondition;
+export declare function decodeInternalDataType(object: AnyObject): any;

package/dist/esm/serializer/common.js

@@ -1,113 +1,113 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spread = (this && this.__spread) || function () {
-    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
-    return ar;
-};
-import { getType, isObject, isArray, isDate, isRegExp, isInternalObject } from '../utils/type';
-import { serialize as serializeInternalDataType, deserialize as deserializeInternalDataType } from './datatype';
-function flatten(query, shouldPreserverObject, parents, visited) {
-    var cloned = __assign({}, query);
-    for (var key in query) {
-        if (/^\$/.test(key))
-            continue;
-        var value = query[key];
-        if (!value)
-            continue;
-        if (isObject(value) && !shouldPreserverObject(value)) {
-            if (visited.indexOf(value) > -1) {
-                throw new Error('Cannot convert circular structure to JSON');
-            }
-            var newParents = __spread(parents, [
-                key,
-            ]);
-            var newVisited = __spread(visited, [
-                value,
-            ]);
-            var flattenedChild = flatten(value, shouldPreserverObject, newParents, newVisited);
-            cloned[key] = flattenedChild;
-            var hasKeyNotCombined = false;
-            for (var childKey in flattenedChild) {
-                if (!/^\$/.test(childKey)) {
-                    cloned[key + "." + childKey] = flattenedChild[childKey];
-                    delete cloned[key][childKey];
-                }
-                else {
-                    hasKeyNotCombined = true;
-                }
-            }
-            if (!hasKeyNotCombined) {
-                delete cloned[key];
-            }
-        }
-    }
-    return cloned;
-}
-export function flattenQueryObject(query) {
-    return flatten(query, isConversionRequired, [], [query]);
-}
-export function flattenObject(object) {
-    return flatten(object, function (_) { return false; }, [], [object]);
-}
-export function mergeConditionAfterEncode(query, condition, key) {
-    if (!condition[key]) {
-        delete query[key];
-    }
-    for (var conditionKey in condition) {
-        if (query[conditionKey]) {
-            if (isArray(query[conditionKey])) {
-                query[conditionKey].push(condition[conditionKey]);
-            }
-            else if (isObject(query[conditionKey])) {
-                if (isObject(condition[conditionKey])) {
-                    Object.assign(query[conditionKey], condition[conditionKey]);
-                }
-                else {
-                    console.warn("unmergable condition, query is object but condition is " + getType(condition) + ", can only overwrite", condition, key);
-                    query[conditionKey] = condition[conditionKey];
-                }
-            }
-            else {
-                console.warn("to-merge query is of type " + getType(query) + ", can only overwrite", query, condition, key);
-                query[conditionKey] = condition[conditionKey];
-            }
-        }
-        else {
-            query[conditionKey] = condition[conditionKey];
-        }
-    }
-}
-export function isConversionRequired(val) {
-    return isInternalObject(val) || isDate(val) || isRegExp(val);
-}
-export function encodeInternalDataType(val) {
-    return serializeInternalDataType(val);
-}
-export function decodeInternalDataType(object) {
-    return deserializeInternalDataType(object);
-}
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+import { getType, isObject, isArray, isDate, isRegExp, isInternalObject } from '../utils/type';
+import { serialize as serializeInternalDataType, deserialize as deserializeInternalDataType } from './datatype';
+function flatten(query, shouldPreserverObject, parents, visited) {
+    var cloned = __assign({}, query);
+    for (var key in query) {
+        if (/^\$/.test(key))
+            continue;
+        var value = query[key];
+        if (!value)
+            continue;
+        if (isObject(value) && !shouldPreserverObject(value)) {
+            if (visited.indexOf(value) > -1) {
+                throw new Error('Cannot convert circular structure to JSON');
+            }
+            var newParents = __spread(parents, [
+                key,
+            ]);
+            var newVisited = __spread(visited, [
+                value,
+            ]);
+            var flattenedChild = flatten(value, shouldPreserverObject, newParents, newVisited);
+            cloned[key] = flattenedChild;
+            var hasKeyNotCombined = false;
+            for (var childKey in flattenedChild) {
+                if (!/^\$/.test(childKey)) {
+                    cloned[key + "." + childKey] = flattenedChild[childKey];
+                    delete cloned[key][childKey];
+                }
+                else {
+                    hasKeyNotCombined = true;
+                }
+            }
+            if (!hasKeyNotCombined) {
+                delete cloned[key];
+            }
+        }
+    }
+    return cloned;
+}
+export function flattenQueryObject(query) {
+    return flatten(query, isConversionRequired, [], [query]);
+}
+export function flattenObject(object) {
+    return flatten(object, function (_) { return false; }, [], [object]);
+}
+export function mergeConditionAfterEncode(query, condition, key) {
+    if (!condition[key]) {
+        delete query[key];
+    }
+    for (var conditionKey in condition) {
+        if (query[conditionKey]) {
+            if (isArray(query[conditionKey])) {
+                query[conditionKey].push(condition[conditionKey]);
+            }
+            else if (isObject(query[conditionKey])) {
+                if (isObject(condition[conditionKey])) {
+                    Object.assign(query[conditionKey], condition[conditionKey]);
+                }
+                else {
+                    console.warn("unmergable condition, query is object but condition is " + getType(condition) + ", can only overwrite", condition, key);
+                    query[conditionKey] = condition[conditionKey];
+                }
+            }
+            else {
+                console.warn("to-merge query is of type " + getType(query) + ", can only overwrite", query, condition, key);
+                query[conditionKey] = condition[conditionKey];
+            }
+        }
+        else {
+            query[conditionKey] = condition[conditionKey];
+        }
+    }
+}
+export function isConversionRequired(val) {
+    return isInternalObject(val) || isDate(val) || isRegExp(val);
+}
+export function encodeInternalDataType(val) {
+    return serializeInternalDataType(val);
+}
+export function decodeInternalDataType(object) {
+    return deserializeInternalDataType(object);
+}

package/dist/esm/serializer/datatype.d.ts

@@ -1,7 +1,7 @@
-import { LogicCommand } from '../commands/logic';
-export declare type IQueryCondition = Record<string, any> | LogicCommand;
-export declare type AnyObject = {
-    [x: string]: any;
-};
-export declare function serialize(val: any): IQueryCondition;
-export declare function deserialize(object: AnyObject): any;
+import { LogicCommand } from '../commands/logic';
+export declare type IQueryCondition = Record<string, any> | LogicCommand;
+export declare type AnyObject = {
+    [x: string]: any;
+};
+export declare function serialize(val: any): IQueryCondition;
+export declare function deserialize(object: AnyObject): any;