@cloudbase/database 1.3.0 → 1.4.1

package/dist/esm/serializer/update.js

@@ -1,139 +1,139 @@
-import { UpdateCommand, isUpdateCommand, UPDATE_COMMANDS_LITERAL } from '../commands/update';
-import { SYMBOL_UNSET_FIELD_NAME } from '../helper/symbol';
-import { getType, isArray } from '../utils/type';
-import { operatorToString } from '../operator-map';
-import { flattenQueryObject, encodeInternalDataType, mergeConditionAfterEncode } from './common';
-import { stringifyByEJSON } from '../utils/utils';
-export class UpdateSerializer {
-    constructor() { }
-    static encode(query) {
-        const stringifier = new UpdateSerializer();
-        return stringifier.encodeUpdate(query);
-    }
-    static encodeEJSON(query, raw) {
-        const stringifier = new UpdateSerializer();
-        return stringifyByEJSON(raw ? query : stringifier.encodeUpdate(query));
-    }
-    encodeUpdate(query) {
-        if (isUpdateCommand(query)) {
-            return this.encodeUpdateCommand(query);
-        }
-        else if (getType(query) === 'object') {
-            return this.encodeUpdateObject(query);
-        }
-        else {
-            return query;
-        }
-    }
-    encodeUpdateCommand(query) {
-        if (query.fieldName === SYMBOL_UNSET_FIELD_NAME) {
-            throw new Error('Cannot encode a comparison command with unset field name');
-        }
-        switch (query.operator) {
-            case UPDATE_COMMANDS_LITERAL.PUSH:
-            case UPDATE_COMMANDS_LITERAL.PULL:
-            case UPDATE_COMMANDS_LITERAL.PULL_ALL:
-            case UPDATE_COMMANDS_LITERAL.POP:
-            case UPDATE_COMMANDS_LITERAL.SHIFT:
-            case UPDATE_COMMANDS_LITERAL.UNSHIFT:
-            case UPDATE_COMMANDS_LITERAL.ADD_TO_SET: {
-                return this.encodeArrayUpdateCommand(query);
-            }
-            default: {
-                return this.encodeFieldUpdateCommand(query);
-            }
-        }
-    }
-    encodeFieldUpdateCommand(query) {
-        const $op = operatorToString(query.operator);
-        switch (query.operator) {
-            case UPDATE_COMMANDS_LITERAL.REMOVE: {
-                return {
-                    [$op]: {
-                        [query.fieldName]: ''
-                    }
-                };
-            }
-            default: {
-                return {
-                    [$op]: {
-                        [query.fieldName]: query.operands[0]
-                    }
-                };
-            }
-        }
-    }
-    encodeArrayUpdateCommand(query) {
-        const $op = operatorToString(query.operator);
-        switch (query.operator) {
-            case UPDATE_COMMANDS_LITERAL.PUSH: {
-                let modifiers;
-                if (isArray(query.operands)) {
-                    modifiers = {
-                        $each: query.operands.map(encodeInternalDataType)
-                    };
-                }
-                else {
-                    modifiers = query.operands;
-                }
-                return {
-                    [$op]: {
-                        [query.fieldName]: modifiers
-                    }
-                };
-            }
-            case UPDATE_COMMANDS_LITERAL.UNSHIFT: {
-                const modifiers = {
-                    $each: query.operands.map(encodeInternalDataType),
-                    $position: 0
-                };
-                return {
-                    [$op]: {
-                        [query.fieldName]: modifiers
-                    }
-                };
-            }
-            case UPDATE_COMMANDS_LITERAL.POP: {
-                return {
-                    [$op]: {
-                        [query.fieldName]: 1
-                    }
-                };
-            }
-            case UPDATE_COMMANDS_LITERAL.SHIFT: {
-                return {
-                    [$op]: {
-                        [query.fieldName]: -1
-                    }
-                };
-            }
-            default: {
-                return {
-                    [$op]: {
-                        [query.fieldName]: encodeInternalDataType(query.operands)
-                    }
-                };
-            }
-        }
-    }
-    encodeUpdateObject(query) {
-        const flattened = flattenQueryObject(query);
-        for (const key in flattened) {
-            if (/^\$/.test(key))
-                continue;
-            let val = flattened[key];
-            if (isUpdateCommand(val)) {
-                flattened[key] = val._setFieldName(key);
-                const condition = this.encodeUpdateCommand(flattened[key]);
-                mergeConditionAfterEncode(flattened, condition, key);
-            }
-            else {
-                flattened[key] = val = encodeInternalDataType(val);
-                const $setCommand = new UpdateCommand(UPDATE_COMMANDS_LITERAL.SET, [val], key);
-                const condition = this.encodeUpdateCommand($setCommand);
-                mergeConditionAfterEncode(flattened, condition, key);
-            }
-        }
-        return flattened;
-    }
-}
+import { UpdateCommand, isUpdateCommand, UPDATE_COMMANDS_LITERAL } from '../commands/update';
+import { SYMBOL_UNSET_FIELD_NAME } from '../helper/symbol';
+import { getType, isArray } from '../utils/type';
+import { operatorToString } from '../operator-map';
+import { flattenQueryObject, encodeInternalDataType, mergeConditionAfterEncode } from './common';
+import { stringifyByEJSON } from '../utils/utils';
+export class UpdateSerializer {
+    constructor() { }
+    static encode(query) {
+        const stringifier = new UpdateSerializer();
+        return stringifier.encodeUpdate(query);
+    }
+    static encodeEJSON(query, raw) {
+        const stringifier = new UpdateSerializer();
+        return stringifyByEJSON(raw ? query : stringifier.encodeUpdate(query));
+    }
+    encodeUpdate(query) {
+        if (isUpdateCommand(query)) {
+            return this.encodeUpdateCommand(query);
+        }
+        else if (getType(query) === 'object') {
+            return this.encodeUpdateObject(query);
+        }
+        else {
+            return query;
+        }
+    }
+    encodeUpdateCommand(query) {
+        if (query.fieldName === SYMBOL_UNSET_FIELD_NAME) {
+            throw new Error('Cannot encode a comparison command with unset field name');
+        }
+        switch (query.operator) {
+            case UPDATE_COMMANDS_LITERAL.PUSH:
+            case UPDATE_COMMANDS_LITERAL.PULL:
+            case UPDATE_COMMANDS_LITERAL.PULL_ALL:
+            case UPDATE_COMMANDS_LITERAL.POP:
+            case UPDATE_COMMANDS_LITERAL.SHIFT:
+            case UPDATE_COMMANDS_LITERAL.UNSHIFT:
+            case UPDATE_COMMANDS_LITERAL.ADD_TO_SET: {
+                return this.encodeArrayUpdateCommand(query);
+            }
+            default: {
+                return this.encodeFieldUpdateCommand(query);
+            }
+        }
+    }
+    encodeFieldUpdateCommand(query) {
+        const $op = operatorToString(query.operator);
+        switch (query.operator) {
+            case UPDATE_COMMANDS_LITERAL.REMOVE: {
+                return {
+                    [$op]: {
+                        [query.fieldName]: ''
+                    }
+                };
+            }
+            default: {
+                return {
+                    [$op]: {
+                        [query.fieldName]: query.operands[0]
+                    }
+                };
+            }
+        }
+    }
+    encodeArrayUpdateCommand(query) {
+        const $op = operatorToString(query.operator);
+        switch (query.operator) {
+            case UPDATE_COMMANDS_LITERAL.PUSH: {
+                let modifiers;
+                if (isArray(query.operands)) {
+                    modifiers = {
+                        $each: query.operands.map(encodeInternalDataType)
+                    };
+                }
+                else {
+                    modifiers = query.operands;
+                }
+                return {
+                    [$op]: {
+                        [query.fieldName]: modifiers
+                    }
+                };
+            }
+            case UPDATE_COMMANDS_LITERAL.UNSHIFT: {
+                const modifiers = {
+                    $each: query.operands.map(encodeInternalDataType),
+                    $position: 0
+                };
+                return {
+                    [$op]: {
+                        [query.fieldName]: modifiers
+                    }
+                };
+            }
+            case UPDATE_COMMANDS_LITERAL.POP: {
+                return {
+                    [$op]: {
+                        [query.fieldName]: 1
+                    }
+                };
+            }
+            case UPDATE_COMMANDS_LITERAL.SHIFT: {
+                return {
+                    [$op]: {
+                        [query.fieldName]: -1
+                    }
+                };
+            }
+            default: {
+                return {
+                    [$op]: {
+                        [query.fieldName]: encodeInternalDataType(query.operands)
+                    }
+                };
+            }
+        }
+    }
+    encodeUpdateObject(query) {
+        const flattened = flattenQueryObject(query);
+        for (const key in flattened) {
+            if (/^\$/.test(key))
+                continue;
+            let val = flattened[key];
+            if (isUpdateCommand(val)) {
+                flattened[key] = val._setFieldName(key);
+                const condition = this.encodeUpdateCommand(flattened[key]);
+                mergeConditionAfterEncode(flattened, condition, key);
+            }
+            else {
+                flattened[key] = val = encodeInternalDataType(val);
+                const $setCommand = new UpdateCommand(UPDATE_COMMANDS_LITERAL.SET, [val], key);
+                const condition = this.encodeUpdateCommand($setCommand);
+                mergeConditionAfterEncode(flattened, condition, key);
+            }
+        }
+        return flattened;
+    }
+}

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

@@ -1,13 +1,13 @@
-export declare class ServerDate {
-    readonly offset: number;
-    constructor({ offset }?: {
-        offset?: number;
-    });
-    readonly _internalType: import("../utils/symbol").InternalSymbol;
-    parse(): {
-        $tcb_server_date: {
-            offset: number;
-        };
-    };
-}
-export declare function ServerDateConstructor(opt: any): ServerDate;
+export declare class ServerDate {
+    readonly offset: number;
+    constructor({ offset }?: {
+        offset?: number;
+    });
+    readonly _internalType: import("../utils/symbol").InternalSymbol;
+    parse(): {
+        $tcb_server_date: {
+            offset: number;
+        };
+    };
+}
+export declare function ServerDateConstructor(opt: any): ServerDate;

package/dist/esm/serverDate/index.js

@@ -1,19 +1,19 @@
-import { SYMBOL_SERVER_DATE } from '../helper/symbol';
-export class ServerDate {
-    constructor({ offset = 0 } = {}) {
-        this.offset = offset;
-    }
-    get _internalType() {
-        return SYMBOL_SERVER_DATE;
-    }
-    parse() {
-        return {
-            $tcb_server_date: {
-                offset: this.offset
-            }
-        };
-    }
-}
-export function ServerDateConstructor(opt) {
-    return new ServerDate(opt);
-}
+import { SYMBOL_SERVER_DATE } from '../helper/symbol';
+export class ServerDate {
+    constructor({ offset = 0 } = {}) {
+        this.offset = offset;
+    }
+    get _internalType() {
+        return SYMBOL_SERVER_DATE;
+    }
+    parse() {
+        return {
+            $tcb_server_date: {
+                offset: this.offset
+            }
+        };
+    }
+}
+export function ServerDateConstructor(opt) {
+    return new ServerDate(opt);
+}

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

@@ -1,30 +1,30 @@
-import { Db } from '../index';
-import { CollectionReference } from '../collection';
-interface TransactionAPI {
-    send(interfaceName: string, param?: any): any;
-}
-export declare class Transaction {
-    private _id;
-    private _db;
-    private _request;
-    aborted: boolean;
-    abortReason: any;
-    commited: boolean;
-    inited: boolean;
-    constructor(db: Db);
-    init(): Promise<void>;
-    collection(collName: string): CollectionReference;
-    getTransactionId(): string;
-    getRequestMethod(): TransactionAPI;
-    commit(): Promise<CommitResult>;
-    rollback(customRollbackRes: any): Promise<RollbackResult>;
-}
-export declare function startTransaction(): Promise<Transaction>;
-export declare function runTransaction(callback: (transaction: Transaction) => void | Promise<any>, times?: number): Promise<any>;
-interface CommitResult {
-    requestId: string;
-}
-interface RollbackResult {
-    requestId: string;
-}
-export {};
+import { Db } from '../index';
+import { CollectionReference } from '../collection';
+interface TransactionAPI {
+    send(interfaceName: string, param?: any): any;
+}
+export declare class Transaction {
+    private _id;
+    private _db;
+    private _request;
+    aborted: boolean;
+    abortReason: any;
+    commited: boolean;
+    inited: boolean;
+    constructor(db: Db);
+    init(): Promise<void>;
+    collection(collName: string): CollectionReference;
+    getTransactionId(): string;
+    getRequestMethod(): TransactionAPI;
+    commit(): Promise<CommitResult>;
+    rollback(customRollbackRes: any): Promise<RollbackResult>;
+}
+export declare function startTransaction(): Promise<Transaction>;
+export declare function runTransaction(callback: (transaction: Transaction) => void | Promise<any>, times?: number): Promise<any>;
+interface CommitResult {
+    requestId: string;
+}
+interface RollbackResult {
+    requestId: string;
+}
+export {};

package/dist/esm/transaction/index.js

@@ -1,100 +1,100 @@
-import { Db } from '../index';
-import { CollectionReference } from '../collection';
-import { ERRORS } from '../const/code';
-const START = 'database.startTransaction';
-const COMMIT = 'database.commitTransaction';
-const ABORT = 'database.abortTransaction';
-export class Transaction {
-    constructor(db) {
-        this._db = db;
-        this._request = new Db.reqClass(this._db.config);
-        this.aborted = false;
-        this.commited = false;
-        this.inited = false;
-    }
-    async init() {
-        const res = await this._request.send(START);
-        if (res.code) {
-            throw res;
-        }
-        this.inited = true;
-        this._id = res.transactionId;
-    }
-    collection(collName) {
-        if (!collName) {
-            throw new Error('Collection name is required');
-        }
-        return new CollectionReference(this._db, collName, {}, this._id);
-    }
-    getTransactionId() {
-        return this._id;
-    }
-    getRequestMethod() {
-        return this._request;
-    }
-    async commit() {
-        const param = {
-            transactionId: this._id
-        };
-        const res = await this._request.send(COMMIT, param);
-        if (res.code)
-            throw res;
-        this.commited = true;
-        return res;
-    }
-    async rollback(customRollbackRes) {
-        const param = {
-            transactionId: this._id
-        };
-        const res = await this._request.send(ABORT, param);
-        if (res.code)
-            throw res;
-        this.aborted = true;
-        this.abortReason = customRollbackRes;
-        return res;
-    }
-}
-export async function startTransaction() {
-    const transaction = new Transaction(this);
-    await transaction.init();
-    return transaction;
-}
-export async function runTransaction(callback, times = 3) {
-    let transaction;
-    try {
-        transaction = new Transaction(this);
-        await transaction.init();
-        const callbackRes = await callback(transaction);
-        if (transaction.aborted === true) {
-            throw transaction.abortReason;
-        }
-        await transaction.commit();
-        return callbackRes;
-    }
-    catch (error) {
-        if (transaction.inited === false) {
-            throw error;
-        }
-        const throwWithRollback = async (error) => {
-            if (!transaction.aborted && !transaction.commited) {
-                try {
-                    await transaction.rollback();
-                }
-                catch (err) {
-                }
-                throw error;
-            }
-            if (transaction.aborted === true) {
-                throw transaction.abortReason;
-            }
-            throw error;
-        };
-        if (times <= 0) {
-            await throwWithRollback(error);
-        }
-        if (error && error.code === ERRORS.DATABASE_TRANSACTION_CONFLICT.code) {
-            return await runTransaction.bind(this)(callback, --times);
-        }
-        await throwWithRollback(error);
-    }
-}
+import { Db } from '../index';
+import { CollectionReference } from '../collection';
+import { ERRORS } from '../const/code';
+const START = 'database.startTransaction';
+const COMMIT = 'database.commitTransaction';
+const ABORT = 'database.abortTransaction';
+export class Transaction {
+    constructor(db) {
+        this._db = db;
+        this._request = new Db.reqClass(this._db.config);
+        this.aborted = false;
+        this.commited = false;
+        this.inited = false;
+    }
+    async init() {
+        const res = await this._request.send(START);
+        if (res.code) {
+            throw res;
+        }
+        this.inited = true;
+        this._id = res.transactionId;
+    }
+    collection(collName) {
+        if (!collName) {
+            throw new Error('Collection name is required');
+        }
+        return new CollectionReference(this._db, collName, {}, this._id);
+    }
+    getTransactionId() {
+        return this._id;
+    }
+    getRequestMethod() {
+        return this._request;
+    }
+    async commit() {
+        const param = {
+            transactionId: this._id
+        };
+        const res = await this._request.send(COMMIT, param);
+        if (res.code)
+            throw res;
+        this.commited = true;
+        return res;
+    }
+    async rollback(customRollbackRes) {
+        const param = {
+            transactionId: this._id
+        };
+        const res = await this._request.send(ABORT, param);
+        if (res.code)
+            throw res;
+        this.aborted = true;
+        this.abortReason = customRollbackRes;
+        return res;
+    }
+}
+export async function startTransaction() {
+    const transaction = new Transaction(this);
+    await transaction.init();
+    return transaction;
+}
+export async function runTransaction(callback, times = 3) {
+    let transaction;
+    try {
+        transaction = new Transaction(this);
+        await transaction.init();
+        const callbackRes = await callback(transaction);
+        if (transaction.aborted === true) {
+            throw transaction.abortReason;
+        }
+        await transaction.commit();
+        return callbackRes;
+    }
+    catch (error) {
+        if (transaction.inited === false) {
+            throw error;
+        }
+        const throwWithRollback = async (error) => {
+            if (!transaction.aborted && !transaction.commited) {
+                try {
+                    await transaction.rollback();
+                }
+                catch (err) {
+                }
+                throw error;
+            }
+            if (transaction.aborted === true) {
+                throw transaction.abortReason;
+            }
+            throw error;
+        };
+        if (times <= 0) {
+            await throwWithRollback(error);
+        }
+        if (error && error.code === ERRORS.DATABASE_TRANSACTION_CONFLICT.code) {
+            return await runTransaction.bind(this)(callback, --times);
+        }
+        await throwWithRollback(error);
+    }
+}