@cloudbase/database 1.4.1 → 1.4.3-alpha.0

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);
+    }
+}

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

@@ -0,0 +1,5 @@
+import { Transaction } from './index';
+export declare class Query {
+    protected _transaction: Transaction;
+    constructor(transaction: Transaction, coll: string);
+}

package/dist/esm/transaction/query.js

@@ -0,0 +1,8 @@
+var Query = (function () {
+    function Query(transaction, coll) {
+        this._coll = coll;
+        this._transaction = transaction;
+    }
+    return Query;
+}());
+export { Query };

package/dist/esm/transaction.d.ts

@@ -1,42 +1,42 @@
-import { DocumentReference } from './document';
-import { Db } from './index';
-declare class DocumentSnapshot {
-    private _data;
-    requestId: string;
-    constructor(data: any, requestId: any);
-    data(): any;
-}
-export declare class Transaction {
-    private _id;
-    private _db;
-    private _request;
-    constructor(db: Db);
-    init(): Promise<void>;
-    get(documentRef: DocumentReference): Promise<DocumentSnapshot>;
-    set(documentRef: DocumentReference, data: Object): Promise<SetResult>;
-    update(documentRef: DocumentReference, data: Object): Promise<UpdateResult>;
-    delete(documentRef: DocumentReference): Promise<DeleteResult>;
-    commit(): Promise<CommitResult>;
-    rollback(): Promise<RollbackResult>;
-}
-export declare function startTransaction(): Promise<Transaction>;
-export declare function runTransaction(callback: (transaction: Transaction) => void | Promise<any>, times?: number): Promise<void>;
-declare type JsonString = string;
-interface CommitResult {
-    requestId: string;
-}
-interface RollbackResult {
-    requestId: string;
-}
-interface UpdateResult {
-    requestId: string;
-    updated: number;
-}
-interface SetResult extends UpdateResult {
-    upserted: JsonString;
-}
-interface DeleteResult {
-    requestId: string;
-    deleted: number | string;
-}
-export {};
+import { DocumentReference } from './document';
+import { Db } from './index';
+declare class DocumentSnapshot {
+    private _data;
+    requestId: string;
+    constructor(data: any, requestId: any);
+    data(): any;
+}
+export declare class Transaction {
+    private _id;
+    private _db;
+    private _request;
+    constructor(db: Db);
+    init(): Promise<void>;
+    get(documentRef: DocumentReference): Promise<DocumentSnapshot>;
+    set(documentRef: DocumentReference, data: Object): Promise<SetResult>;
+    update(documentRef: DocumentReference, data: Object): Promise<UpdateResult>;
+    delete(documentRef: DocumentReference): Promise<DeleteResult>;
+    commit(): Promise<CommitResult>;
+    rollback(): Promise<RollbackResult>;
+}
+export declare function startTransaction(): Promise<Transaction>;
+export declare function runTransaction(callback: (transaction: Transaction) => void | Promise<any>, times?: number): Promise<void>;
+declare type JsonString = string;
+interface CommitResult {
+    requestId: string;
+}
+interface RollbackResult {
+    requestId: string;
+}
+interface UpdateResult {
+    requestId: string;
+    updated: number;
+}
+interface SetResult extends UpdateResult {
+    upserted: JsonString;
+}
+interface DeleteResult {
+    requestId: string;
+    deleted: number | string;
+}
+export {};

package/dist/esm/transaction.js

@@ -1,121 +1,121 @@
-import { EJSON } from 'bson';
-import { Db } from './index';
-class DocumentSnapshot {
-    constructor(data, requestId) {
-        this._data = data;
-        this.requestId = requestId;
-    }
-    data() {
-        return this._data;
-    }
-}
-const START = 'database.startTransaction';
-const COMMIT = 'database.commitTransaction';
-const ABORT = 'database.abortTransaction';
-const GET_DOC = 'database.getInTransaction';
-const UPDATE_DOC = 'database.updateDocInTransaction';
-const DELETE_DOC = 'database.deleteDocInTransaction';
-export class Transaction {
-    constructor(db) {
-        this._db = db;
-        this._request = new Db.reqClass(this._db.config);
-    }
-    async init() {
-        const res = await this._request.send(START, {});
-        if (res.code) {
-            throw res;
-        }
-        this._id = res.transactionId;
-    }
-    async get(documentRef) {
-        const param = {
-            collectionName: documentRef._coll,
-            transactionId: this._id,
-            _id: documentRef.id
-        };
-        const res = await this._request.send(GET_DOC, param);
-        if (res.code)
-            throw res;
-        return new DocumentSnapshot(EJSON.parse(res.data), res.requestId);
-    }
-    async set(documentRef, data) {
-        const param = {
-            collectionName: documentRef._coll,
-            transactionId: this._id,
-            _id: documentRef.id,
-            data: EJSON.stringify(data, { relaxed: false }),
-            upsert: true
-        };
-        const res = await this._request.send(UPDATE_DOC, param);
-        if (res.code)
-            throw res;
-        return Object.assign(Object.assign({}, res), { updated: EJSON.parse(res.updated), upserted: res.upserted
-                ? JSON.parse(res.upserted)
-                : null });
-    }
-    async update(documentRef, data) {
-        const param = {
-            collectionName: documentRef._coll,
-            transactionId: this._id,
-            _id: documentRef.id,
-            data: EJSON.stringify({
-                $set: data
-            }, {
-                relaxed: false
-            })
-        };
-        const res = await this._request.send(UPDATE_DOC, param);
-        if (res.code)
-            throw res;
-        return Object.assign(Object.assign({}, res), { updated: EJSON.parse(res.updated) });
-    }
-    async delete(documentRef) {
-        const param = {
-            collectionName: documentRef._coll,
-            transactionId: this._id,
-            _id: documentRef.id
-        };
-        const res = await this._request.send(DELETE_DOC, param);
-        if (res.code)
-            throw res;
-        return Object.assign(Object.assign({}, res), { deleted: EJSON.parse(res.deleted) });
-    }
-    async commit() {
-        const param = {
-            transactionId: this._id
-        };
-        const res = await this._request.send(COMMIT, param);
-        if (res.code)
-            throw res;
-        return res;
-    }
-    async rollback() {
-        const param = {
-            transactionId: this._id
-        };
-        const res = await this._request.send(ABORT, param);
-        if (res.code)
-            throw res;
-        return res;
-    }
-}
-export async function startTransaction() {
-    const transaction = new Transaction(this);
-    await transaction.init();
-    return transaction;
-}
-export async function runTransaction(callback, times = 3) {
-    if (times <= 0) {
-        throw new Error('Transaction failed');
-    }
-    try {
-        const transaction = new Transaction(this);
-        await transaction.init();
-        await callback(transaction);
-        await transaction.commit();
-    }
-    catch (error) {
-        console.log(error);
-        return runTransaction.bind(this)(callback, --times);
-    }
-}
+import { EJSON } from 'bson';
+import { Db } from './index';
+class DocumentSnapshot {
+    constructor(data, requestId) {
+        this._data = data;
+        this.requestId = requestId;
+    }
+    data() {
+        return this._data;
+    }
+}
+const START = 'database.startTransaction';
+const COMMIT = 'database.commitTransaction';
+const ABORT = 'database.abortTransaction';
+const GET_DOC = 'database.getInTransaction';
+const UPDATE_DOC = 'database.updateDocInTransaction';
+const DELETE_DOC = 'database.deleteDocInTransaction';
+export class Transaction {
+    constructor(db) {
+        this._db = db;
+        this._request = new Db.reqClass(this._db.config);
+    }
+    async init() {
+        const res = await this._request.send(START, {});
+        if (res.code) {
+            throw res;
+        }
+        this._id = res.transactionId;
+    }
+    async get(documentRef) {
+        const param = {
+            collectionName: documentRef._coll,
+            transactionId: this._id,
+            _id: documentRef.id
+        };
+        const res = await this._request.send(GET_DOC, param);
+        if (res.code)
+            throw res;
+        return new DocumentSnapshot(EJSON.parse(res.data), res.requestId);
+    }
+    async set(documentRef, data) {
+        const param = {
+            collectionName: documentRef._coll,
+            transactionId: this._id,
+            _id: documentRef.id,
+            data: EJSON.stringify(data, { relaxed: false }),
+            upsert: true
+        };
+        const res = await this._request.send(UPDATE_DOC, param);
+        if (res.code)
+            throw res;
+        return Object.assign(Object.assign({}, res), { updated: EJSON.parse(res.updated), upserted: res.upserted
+                ? JSON.parse(res.upserted)
+                : null });
+    }
+    async update(documentRef, data) {
+        const param = {
+            collectionName: documentRef._coll,
+            transactionId: this._id,
+            _id: documentRef.id,
+            data: EJSON.stringify({
+                $set: data
+            }, {
+                relaxed: false
+            })
+        };
+        const res = await this._request.send(UPDATE_DOC, param);
+        if (res.code)
+            throw res;
+        return Object.assign(Object.assign({}, res), { updated: EJSON.parse(res.updated) });
+    }
+    async delete(documentRef) {
+        const param = {
+            collectionName: documentRef._coll,
+            transactionId: this._id,
+            _id: documentRef.id
+        };
+        const res = await this._request.send(DELETE_DOC, param);
+        if (res.code)
+            throw res;
+        return Object.assign(Object.assign({}, res), { deleted: EJSON.parse(res.deleted) });
+    }
+    async commit() {
+        const param = {
+            transactionId: this._id
+        };
+        const res = await this._request.send(COMMIT, param);
+        if (res.code)
+            throw res;
+        return res;
+    }
+    async rollback() {
+        const param = {
+            transactionId: this._id
+        };
+        const res = await this._request.send(ABORT, param);
+        if (res.code)
+            throw res;
+        return res;
+    }
+}
+export async function startTransaction() {
+    const transaction = new Transaction(this);
+    await transaction.init();
+    return transaction;
+}
+export async function runTransaction(callback, times = 3) {
+    if (times <= 0) {
+        throw new Error('Transaction failed');
+    }
+    try {
+        const transaction = new Transaction(this);
+        await transaction.init();
+        await callback(transaction);
+        await transaction.commit();
+    }
+    catch (error) {
+        console.log(error);
+        return runTransaction.bind(this)(callback, --times);
+    }
+}