@cloudbase/database 1.3.0 → 1.4.1

package/dist/esm/utils/error.d.ts

@@ -1,37 +1,37 @@
-export interface ICloudSDKError extends Error {
-    errCode: number;
-    errMsg: string;
-}
-export declare class CloudSDKError extends Error {
-    errCode: string;
-    errMsg: string;
-    requestID?: string;
-    constructor(options: IErrorConstructorOptions);
-    message: string;
-}
-interface IErrorConstructorOptions {
-    errCode?: string;
-    errMsg: string;
-}
-export declare function isSDKError(error: any): error is CloudSDKError;
-export interface IGenericError<T extends string, P = any> extends Error {
-    type: T;
-    payload: P;
-    generic: boolean;
-}
-export declare const isGenericError: <T extends string, P>(e: any) => e is IGenericError<T, P>;
-export declare class TimeoutError extends Error implements IGenericError<'timeout', null> {
-    type: "timeout";
-    payload: any;
-    generic: boolean;
-    constructor(message: string);
-}
-export declare const isTimeoutError: (e: any) => e is TimeoutError;
-export declare class CancelledError extends Error implements IGenericError<'cancelled', null> {
-    type: "cancelled";
-    payload: any;
-    generic: boolean;
-    constructor(message: string);
-}
-export declare const isCancelledError: (e: any) => e is CancelledError;
-export {};
+export interface ICloudSDKError extends Error {
+    errCode: number;
+    errMsg: string;
+}
+export declare class CloudSDKError extends Error {
+    errCode: string;
+    errMsg: string;
+    requestID?: string;
+    constructor(options: IErrorConstructorOptions);
+    message: string;
+}
+interface IErrorConstructorOptions {
+    errCode?: string;
+    errMsg: string;
+}
+export declare function isSDKError(error: any): error is CloudSDKError;
+export interface IGenericError<T extends string, P = any> extends Error {
+    type: T;
+    payload: P;
+    generic: boolean;
+}
+export declare const isGenericError: <T extends string, P>(e: any) => e is IGenericError<T, P>;
+export declare class TimeoutError extends Error implements IGenericError<'timeout', null> {
+    type: "timeout";
+    payload: any;
+    generic: boolean;
+    constructor(message: string);
+}
+export declare const isTimeoutError: (e: any) => e is TimeoutError;
+export declare class CancelledError extends Error implements IGenericError<'cancelled', null> {
+    type: "cancelled";
+    payload: any;
+    generic: boolean;
+    constructor(message: string);
+}
+export declare const isCancelledError: (e: any) => e is CancelledError;
+export {};

package/dist/esm/utils/error.js

@@ -1,49 +1,49 @@
-import { isString } from './type';
-import { ERR_CODE } from '../config/error.config';
-export class CloudSDKError extends Error {
-    constructor(options) {
-        super(options.errMsg);
-        this.errCode = 'UNKNOWN_ERROR';
-        Object.defineProperties(this, {
-            message: {
-                get() {
-                    return (`errCode: ${this.errCode} ${ERR_CODE[this.errCode] ||
-                        ''} | errMsg: ` + this.errMsg);
-                },
-                set(msg) {
-                    this.errMsg = msg;
-                }
-            }
-        });
-        this.errCode = options.errCode || 'UNKNOWN_ERROR';
-        this.errMsg = options.errMsg;
-    }
-    get message() {
-        return `errCode: ${this.errCode} | errMsg: ` + this.errMsg;
-    }
-    set message(msg) {
-        this.errMsg = msg;
-    }
-}
-export function isSDKError(error) {
-    return (error && error instanceof Error && isString(error.errMsg));
-}
-export const isGenericError = (e) => e.generic;
-export class TimeoutError extends Error {
-    constructor(message) {
-        super(message);
-        this.type = 'timeout';
-        this.payload = null;
-        this.generic = true;
-    }
-}
-export const isTimeoutError = (e) => e.type === 'timeout';
-export class CancelledError extends Error {
-    constructor(message) {
-        super(message);
-        this.type = 'cancelled';
-        this.payload = null;
-        this.generic = true;
-    }
-}
-export const isCancelledError = (e) => e.type === 'cancelled';
+import { isString } from './type';
+import { ERR_CODE } from '../config/error.config';
+export class CloudSDKError extends Error {
+    constructor(options) {
+        super(options.errMsg);
+        this.errCode = 'UNKNOWN_ERROR';
+        Object.defineProperties(this, {
+            message: {
+                get() {
+                    return (`errCode: ${this.errCode} ${ERR_CODE[this.errCode] ||
+                        ''} | errMsg: ` + this.errMsg);
+                },
+                set(msg) {
+                    this.errMsg = msg;
+                }
+            }
+        });
+        this.errCode = options.errCode || 'UNKNOWN_ERROR';
+        this.errMsg = options.errMsg;
+    }
+    get message() {
+        return `errCode: ${this.errCode} | errMsg: ` + this.errMsg;
+    }
+    set message(msg) {
+        this.errMsg = msg;
+    }
+}
+export function isSDKError(error) {
+    return (error && error instanceof Error && isString(error.errMsg));
+}
+export const isGenericError = (e) => e.generic;
+export class TimeoutError extends Error {
+    constructor(message) {
+        super(message);
+        this.type = 'timeout';
+        this.payload = null;
+        this.generic = true;
+    }
+}
+export const isTimeoutError = (e) => e.type === 'timeout';
+export class CancelledError extends Error {
+    constructor(message) {
+        super(message);
+        this.type = 'cancelled';
+        this.payload = null;
+        this.generic = true;
+    }
+}
+export const isCancelledError = (e) => e.type === 'cancelled';

package/dist/esm/utils/symbol.d.ts

@@ -1,8 +1,8 @@
-declare class HiddenSymbol {
-    constructor(target: any);
-}
-export declare class InternalSymbol extends HiddenSymbol {
-    constructor(target: any, __mark__: any);
-    static for(target: any): InternalSymbol;
-}
-export default InternalSymbol;
+declare class HiddenSymbol {
+    constructor(target: any);
+}
+export declare class InternalSymbol extends HiddenSymbol {
+    constructor(target: any, __mark__: any);
+    static for(target: any): InternalSymbol;
+}
+export default InternalSymbol;

package/dist/esm/utils/symbol.js

@@ -1,36 +1,36 @@
-const _symbols = [];
-const __internalMark__ = {};
-class HiddenSymbol {
-    constructor(target) {
-        Object.defineProperties(this, {
-            target: {
-                enumerable: false,
-                writable: false,
-                configurable: false,
-                value: target,
-            },
-        });
-    }
-}
-export class InternalSymbol extends HiddenSymbol {
-    constructor(target, __mark__) {
-        if (__mark__ !== __internalMark__) {
-            throw new TypeError('InternalSymbol cannot be constructed with new operator');
-        }
-        super(target);
-    }
-    static for(target) {
-        for (let i = 0, len = _symbols.length; i < len; i++) {
-            if (_symbols[i].target === target) {
-                return _symbols[i].instance;
-            }
-        }
-        const symbol = new InternalSymbol(target, __internalMark__);
-        _symbols.push({
-            target,
-            instance: symbol,
-        });
-        return symbol;
-    }
-}
-export default InternalSymbol;
+const _symbols = [];
+const __internalMark__ = {};
+class HiddenSymbol {
+    constructor(target) {
+        Object.defineProperties(this, {
+            target: {
+                enumerable: false,
+                writable: false,
+                configurable: false,
+                value: target,
+            },
+        });
+    }
+}
+export class InternalSymbol extends HiddenSymbol {
+    constructor(target, __mark__) {
+        if (__mark__ !== __internalMark__) {
+            throw new TypeError('InternalSymbol cannot be constructed with new operator');
+        }
+        super(target);
+    }
+    static for(target) {
+        for (let i = 0, len = _symbols.length; i < len; i++) {
+            if (_symbols[i].target === target) {
+                return _symbols[i].instance;
+            }
+        }
+        const symbol = new InternalSymbol(target, __internalMark__);
+        _symbols.push({
+            target,
+            instance: symbol,
+        });
+        return symbol;
+    }
+}
+export default InternalSymbol;

package/dist/esm/utils/type.d.ts

@@ -1,13 +1,13 @@
-export declare const getType: (x: any) => string;
-export declare const isObject: <T extends object>(x: any) => x is T;
-export declare const isString: (x: any) => x is string;
-export declare const isNumber: (x: any) => x is number;
-export declare const isPromise: <T extends Promise<any> = Promise<any>>(x: any) => x is T;
-declare type AnyFn = (...args: any[]) => any;
-export declare const isFunction: <T extends AnyFn = AnyFn>(x: any) => x is T;
-export declare const isArray: <T extends any[] = any[]>(x: any) => x is T;
-export declare const isDate: (x: any) => x is Date;
-export declare const isRegExp: (x: any) => x is RegExp;
-export declare const isInternalObject: (x: any) => boolean;
-export declare const isPlainObject: (obj: any) => obj is object;
-export {};
+export declare const getType: (x: any) => string;
+export declare const isObject: <T extends object>(x: any) => x is T;
+export declare const isString: (x: any) => x is string;
+export declare const isNumber: (x: any) => x is number;
+export declare const isPromise: <T extends Promise<any> = Promise<any>>(x: any) => x is T;
+declare type AnyFn = (...args: any[]) => any;
+export declare const isFunction: <T extends AnyFn = AnyFn>(x: any) => x is T;
+export declare const isArray: <T extends any[] = any[]>(x: any) => x is T;
+export declare const isDate: (x: any) => x is Date;
+export declare const isRegExp: (x: any) => x is RegExp;
+export declare const isInternalObject: (x: any) => boolean;
+export declare const isPlainObject: (obj: any) => obj is object;
+export {};

package/dist/esm/utils/type.js

@@ -1,20 +1,20 @@
-import { InternalSymbol } from './symbol';
-export const getType = (x) => Object.prototype.toString.call(x).slice(8, -1).toLowerCase();
-export const isObject = (x) => getType(x) === 'object';
-export const isString = (x) => getType(x) === 'string';
-export const isNumber = (x) => getType(x) === 'number';
-export const isPromise = (x) => getType(x) === 'promise';
-export const isFunction = (x) => typeof x === 'function';
-export const isArray = (x) => Array.isArray(x);
-export const isDate = (x) => getType(x) === 'date';
-export const isRegExp = (x) => getType(x) === 'regexp';
-export const isInternalObject = (x) => x && (x._internalType instanceof InternalSymbol);
-export const isPlainObject = (obj) => {
-    if (typeof obj !== 'object' || obj === null)
-        return false;
-    let proto = obj;
-    while (Object.getPrototypeOf(proto) !== null) {
-        proto = Object.getPrototypeOf(proto);
-    }
-    return Object.getPrototypeOf(obj) === proto;
-};
+import { InternalSymbol } from './symbol';
+export const getType = (x) => Object.prototype.toString.call(x).slice(8, -1).toLowerCase();
+export const isObject = (x) => getType(x) === 'object';
+export const isString = (x) => getType(x) === 'string';
+export const isNumber = (x) => getType(x) === 'number';
+export const isPromise = (x) => getType(x) === 'promise';
+export const isFunction = (x) => typeof x === 'function';
+export const isArray = (x) => Array.isArray(x);
+export const isDate = (x) => getType(x) === 'date';
+export const isRegExp = (x) => getType(x) === 'regexp';
+export const isInternalObject = (x) => x && (x._internalType instanceof InternalSymbol);
+export const isPlainObject = (obj) => {
+    if (typeof obj !== 'object' || obj === null)
+        return false;
+    let proto = obj;
+    while (Object.getPrototypeOf(proto) !== null) {
+        proto = Object.getPrototypeOf(proto);
+    }
+    return Object.getPrototypeOf(obj) === proto;
+};

package/dist/esm/utils/utils.d.ts

@@ -1,19 +1,19 @@
-import { QueryOption, UpdateOption } from '../query';
-export declare const sleep: (ms?: number) => Promise<unknown>;
-export declare const autoCount: (domain?: string) => number;
-export declare const getReqOpts: (apiOptions: QueryOption | UpdateOption) => any;
-export declare const filterUndefined: (o: any) => any;
-export declare const stringifyByEJSON: (params: any) => any;
-export declare const parseByEJSON: (params: any) => any;
-export declare class TcbError extends Error {
-    readonly code: string;
-    readonly message: string;
-    constructor(error: IErrorInfo);
-}
-export declare const E: (errObj: IErrorInfo) => TcbError;
-export declare function processReturn(throwOnCode: boolean, res: any): any;
-interface IErrorInfo {
-    code?: string;
-    message?: string;
-}
-export {};
+import { QueryOption, UpdateOption } from '../query';
+export declare const sleep: (ms?: number) => Promise<unknown>;
+export declare const autoCount: (domain?: string) => number;
+export declare const getReqOpts: (apiOptions: QueryOption | UpdateOption) => any;
+export declare const filterUndefined: (o: any) => any;
+export declare const stringifyByEJSON: (params: any) => any;
+export declare const parseByEJSON: (params: any) => any;
+export declare class TcbError extends Error {
+    readonly code: string;
+    readonly message: string;
+    constructor(error: IErrorInfo);
+}
+export declare const E: (errObj: IErrorInfo) => TcbError;
+export declare function processReturn(throwOnCode: boolean, res: any): any;
+interface IErrorInfo {
+    code?: string;
+    message?: string;
+}
+export {};

package/dist/esm/utils/utils.js

@@ -1,55 +1,55 @@
-import { EJSON } from 'bson';
-import { isObject } from './type';
-export const sleep = (ms = 0) => new Promise(r => setTimeout(r, ms));
-const counters = {};
-export const autoCount = (domain = 'any') => {
-    if (!counters[domain]) {
-        counters[domain] = 0;
-    }
-    return counters[domain]++;
-};
-export const getReqOpts = (apiOptions) => {
-    if (apiOptions.timeout !== undefined) {
-        return {
-            timeout: apiOptions.timeout
-        };
-    }
-    return {};
-};
-export const filterUndefined = o => {
-    if (!isObject(o)) {
-        return o;
-    }
-    for (let key in o) {
-        if (o[key] === undefined) {
-            delete o[key];
-        }
-        else if (isObject(o[key])) {
-            o[key] = filterUndefined(o[key]);
-        }
-    }
-    return o;
-};
-export const stringifyByEJSON = params => {
-    params = filterUndefined(params);
-    return EJSON.stringify(params, { relaxed: false });
-};
-export const parseByEJSON = params => {
-    return EJSON.parse(params);
-};
-export class TcbError extends Error {
-    constructor(error) {
-        super(error.message);
-        this.code = error.code;
-        this.message = error.message;
-    }
-}
-export const E = (errObj) => {
-    return new TcbError(errObj);
-};
-export function processReturn(throwOnCode, res) {
-    if (throwOnCode === false) {
-        return res;
-    }
-    throw E(Object.assign({}, res));
-}
+import { EJSON } from 'bson';
+import { isObject } from './type';
+export const sleep = (ms = 0) => new Promise(r => setTimeout(r, ms));
+const counters = {};
+export const autoCount = (domain = 'any') => {
+    if (!counters[domain]) {
+        counters[domain] = 0;
+    }
+    return counters[domain]++;
+};
+export const getReqOpts = (apiOptions) => {
+    if (apiOptions.timeout !== undefined) {
+        return {
+            timeout: apiOptions.timeout
+        };
+    }
+    return {};
+};
+export const filterUndefined = o => {
+    if (!isObject(o)) {
+        return o;
+    }
+    for (let key in o) {
+        if (o[key] === undefined) {
+            delete o[key];
+        }
+        else if (isObject(o[key])) {
+            o[key] = filterUndefined(o[key]);
+        }
+    }
+    return o;
+};
+export const stringifyByEJSON = params => {
+    params = filterUndefined(params);
+    return EJSON.stringify(params, { relaxed: false });
+};
+export const parseByEJSON = params => {
+    return EJSON.parse(params);
+};
+export class TcbError extends Error {
+    constructor(error) {
+        super(error.message);
+        this.code = error.code;
+        this.message = error.message;
+    }
+}
+export const E = (errObj) => {
+    return new TcbError(errObj);
+};
+export function processReturn(throwOnCode, res) {
+    if (throwOnCode === false) {
+        return res;
+    }
+    throw E(Object.assign({}, res));
+}

package/dist/esm/validate.d.ts

@@ -1 +1 @@
-export {};
+export {};