@cloudbase/database 1.4.0 → 1.4.1-alpha.0

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

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

@@ -1,45 +1,45 @@
-import { Point } from '../geo/index';
-export declare type DataType = 'init' | 'update' | 'add' | 'remove' | 'replace' | 'limit';
-export declare type QueueType = 'init' | 'enqueue' | 'dequeue' | 'update';
-export interface IDatabaseServiceContext extends IServiceContext {
-    appConfig: IAppConfig;
-    ws?: any;
-}
-export interface IAppConfig {
-    docSizeLimit: number;
-    realtimePingInterval: number;
-    realtimePongWaitTimeout: number;
-    request: any;
-}
-export interface IWatchOptions {
-    onChange: (snapshot: ISnapshot) => void;
-    onError: (error: any) => void;
-}
-export interface ISnapshot {
-    id: number;
-    docChanges: ISingleDBEvent[];
-    docs: Record<string, any>;
-    type?: SnapshotType;
-}
-export interface ISingleDBEvent {
-    id: number;
-    dataType: DataType;
-    queueType: QueueType;
-    docId: string;
-    doc: Record<string, any>;
-    updatedFields?: any;
-    removedFields?: any;
-}
-export declare type SnapshotType = 'init';
-export interface DBRealtimeListener {
-    close: () => void;
-}
-export interface IRealtimeListenerConstructorOptions extends IWatchOptions {
-}
-export interface IServiceContext {
-    env?: string;
-}
-export interface IReqOpts {
-    timeout: number;
-}
-export declare type CenterSphere = [Point, number] | [[number, number], number];
+import { Point } from '../geo/index';
+export declare type DataType = 'init' | 'update' | 'add' | 'remove' | 'replace' | 'limit';
+export declare type QueueType = 'init' | 'enqueue' | 'dequeue' | 'update';
+export interface IDatabaseServiceContext extends IServiceContext {
+    appConfig: IAppConfig;
+    ws?: any;
+}
+export interface IAppConfig {
+    docSizeLimit: number;
+    realtimePingInterval: number;
+    realtimePongWaitTimeout: number;
+    request: any;
+}
+export interface IWatchOptions {
+    onChange: (snapshot: ISnapshot) => void;
+    onError: (error: any) => void;
+}
+export interface ISnapshot {
+    id: number;
+    docChanges: ISingleDBEvent[];
+    docs: Record<string, any>;
+    type?: SnapshotType;
+}
+export interface ISingleDBEvent {
+    id: number;
+    dataType: DataType;
+    queueType: QueueType;
+    docId: string;
+    doc: Record<string, any>;
+    updatedFields?: any;
+    removedFields?: any;
+}
+export declare type SnapshotType = 'init';
+export interface DBRealtimeListener {
+    close: () => void;
+}
+export interface IRealtimeListenerConstructorOptions extends IWatchOptions {
+}
+export interface IServiceContext {
+    env?: string;
+}
+export interface IReqOpts {
+    timeout: number;
+}
+export declare type CenterSphere = [Point, number] | [[number, number], number];