@cloudbase/database 1.4.2 → 1.4.3-alpha.0

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

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

package/dist/esm/regexp/index.js

@@ -0,0 +1,26 @@
+import { SYMBOL_REGEXP } from '../helper/symbol';
+export class RegExp {
+    constructor({ regexp, options }) {
+        if (!regexp) {
+            throw new TypeError('regexp must be a string');
+        }
+        this.$regularExpression = {
+            pattern: regexp || '',
+            options: options || ''
+        };
+    }
+    parse() {
+        return {
+            $regularExpression: {
+                pattern: this.$regularExpression.pattern,
+                options: this.$regularExpression.options
+            }
+        };
+    }
+    get _internalType() {
+        return SYMBOL_REGEXP;
+    }
+}
+export function RegExpConstructor(param) {
+    return new RegExp(param);
+}

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

@@ -0,0 +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;

package/dist/esm/serializer/common.js

@@ -0,0 +1,82 @@
+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) {
+    const cloned = Object.assign({}, query);
+    for (const key in query) {
+        if (/^\$/.test(key))
+            continue;
+        const value = query[key];
+        if (value === undefined) {
+            delete cloned[key];
+            continue;
+        }
+        if (!value)
+            continue;
+        if (isObject(value) && !shouldPreserverObject(value)) {
+            if (visited.indexOf(value) > -1) {
+                throw new Error('Cannot convert circular structure to JSON');
+            }
+            const newParents = [...parents, key];
+            const newVisited = [...visited, value];
+            const flattenedChild = flatten(value, shouldPreserverObject, newParents, newVisited);
+            cloned[key] = flattenedChild;
+            let hasKeyNotCombined = false;
+            for (const 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, (_) => false, [], [object]);
+}
+export function mergeConditionAfterEncode(query, condition, key) {
+    if (!condition[key]) {
+        delete query[key];
+    }
+    for (const 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

@@ -0,0 +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;

package/dist/esm/serializer/datatype.js

@@ -0,0 +1,95 @@
+import { SYMBOL_GEO_POINT, SYMBOL_SERVER_DATE, SYMBOL_OBJECTID, SYMBOL_REGEXP } from '../helper/symbol';
+import { getType, isObject, isArray, isDate, isNumber, isInternalObject, isRegExp } from '../utils/type';
+import { Point } from '../geo/index';
+import { ServerDate } from '../serverDate/index';
+export function serialize(val) {
+    return serializeHelper(val, [val]);
+}
+function serializeHelper(val, visited) {
+    if (isInternalObject(val)) {
+        switch (val._internalType) {
+            case SYMBOL_GEO_POINT: {
+                return val.toJSON();
+            }
+            case SYMBOL_SERVER_DATE: {
+                return val.parse();
+            }
+            case SYMBOL_REGEXP: {
+                return val.parse();
+            }
+            case SYMBOL_OBJECTID: {
+                return val.parse();
+            }
+            default: {
+                return val.toJSON ? val.toJSON() : val;
+            }
+        }
+    }
+    else if (isDate(val)) {
+        return val;
+    }
+    else if (isRegExp(val)) {
+        return {
+            $regularExpression: {
+                pattern: val.source,
+                options: val.flags
+            }
+        };
+    }
+    else if (isArray(val)) {
+        return val.map(item => {
+            if (visited.indexOf(item) > -1) {
+                throw new Error('Cannot convert circular structure to JSON');
+            }
+            return serializeHelper(item, [...visited, item]);
+        });
+    }
+    else if (isObject(val)) {
+        const rawRet = Object.assign({}, val);
+        const finalRet = {};
+        for (const key in rawRet) {
+            if (visited.indexOf(rawRet[key]) > -1) {
+                throw new Error('Cannot convert circular structure to JSON');
+            }
+            if (rawRet[key] !== undefined) {
+                finalRet[key] = serializeHelper(rawRet[key], [...visited, rawRet[key]]);
+            }
+        }
+        return finalRet;
+    }
+    else {
+        return val;
+    }
+}
+export function deserialize(object) {
+    const ret = Object.assign({}, object);
+    for (const key in ret) {
+        switch (key) {
+            case '$date': {
+                switch (getType(ret[key])) {
+                    case 'number': {
+                        return new Date(ret[key]);
+                    }
+                    case 'object': {
+                        return new ServerDate(ret[key]);
+                    }
+                }
+                break;
+            }
+            case 'type': {
+                switch (ret.type) {
+                    case 'Point': {
+                        if (isArray(ret.coordinates) &&
+                            isNumber(ret.coordinates[0]) &&
+                            isNumber(ret.coordinates[1])) {
+                            return new Point(ret.coordinates[0], ret.coordinates[1]);
+                        }
+                        break;
+                    }
+                }
+                break;
+            }
+        }
+    }
+    return object;
+}

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

@@ -0,0 +1,8 @@
+import { QueryCommand } from '../commands/query';
+import { LogicCommand } from '../commands/logic';
+export declare type IQueryCondition = Record<string, any> | LogicCommand;
+export declare class QuerySerializer {
+    constructor();
+    static encode(query: IQueryCondition | QueryCommand | LogicCommand): IQueryCondition;
+    static encodeEJSON(query: IQueryCondition | QueryCommand | LogicCommand, raw: boolean): string;
+}