@cloudbase/database 1.4.3 → 1.5.1

package/dist/esm/index.d.ts

@@ -1,13 +1,14 @@
 import { Point } from './geo/point';
 import { CollectionReference } from './collection';
 import { Command } from './command';
+export type IDbConfig = ICloudBaseConfig;
 interface GeoTeyp {
     Point: typeof Point;
 }
 export { Query } from './query';
 export { CollectionReference } from './collection';
 export { DocumentReference } from './document';
-interface ICloudBaseConfig {
+export interface ICloudBaseConfig {
     timeout?: number;
     isHttp?: boolean;
     secretId?: string;
@@ -37,16 +38,21 @@ export declare class Db {
     ObjectId: any;
     startTransaction: any;
     runTransaction: any;
+    logicCommand: any;
+    updateCommand: any;
+    queryCommand: any;
     config: ICloudBaseConfig;
     static ws: any;
     static reqClass: any;
     static wsClass: any;
+    static wsClientClass: any;
     static createSign: Function;
     static getAccessToken: Function;
     static dataVersion: string;
     static runtime: string;
     static appSecretInfo: any;
-    constructor(config?: any);
+    static createRequest(config: ICloudBaseConfig): any;
+    constructor(config?: ICloudBaseConfig);
     collection(collName: string): CollectionReference;
     createCollection(collName: string): any;
 }

package/dist/esm/index.js

@@ -1,15 +1,43 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 import * as Geo from './geo/index';
 import { CollectionReference } from './collection';
 import { Command } from './command';
 import { ServerDateConstructor } from './serverDate/index';
 import { RegExpConstructor } from './regexp/index';
 import { startTransaction, runTransaction } from './transaction/index';
+import { LogicCommand } from './commands/logic';
+import { QueryCommand } from './commands/query';
+import { UpdateCommand } from './commands/update';
 import { ObjectIdConstructor } from './ObjectId/index';
 export { Query } from './query';
 export { CollectionReference } from './collection';
 export { DocumentReference } from './document';
-export class Db {
-    constructor(config) {
+var Db = (function () {
+    function Db(config) {
         this.config = config;
         this.Geo = Geo;
         this.serverDate = ServerDateConstructor;
@@ -18,18 +46,43 @@ export class Db {
         this.ObjectId = ObjectIdConstructor;
         this.startTransaction = startTransaction;
         this.runTransaction = runTransaction;
+        this.logicCommand = LogicCommand;
+        this.updateCommand = UpdateCommand;
+        this.queryCommand = QueryCommand;
     }
-    collection(collName) {
+    Db.createRequest = function (config) {
+        var request = new Db.reqClass(config);
+        var originalSend = request.send;
+        request.send = function (action, data) {
+            var args = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                args[_i - 2] = arguments[_i];
+            }
+            if (data) {
+                if (config.instance) {
+                    data.instance = config.instance;
+                }
+                if (config.database) {
+                    data.database = config.database;
+                }
+            }
+            return originalSend.call.apply(originalSend, __spreadArray([this, action, data], __read(args), false));
+        };
+        return request;
+    };
+    Db.prototype.collection = function (collName) {
         if (!collName) {
             throw new Error('Collection name is required');
         }
         return new CollectionReference(this, collName);
-    }
-    createCollection(collName) {
-        let request = new Db.reqClass(this.config);
-        const params = {
+    };
+    Db.prototype.createCollection = function (collName) {
+        var request = Db.createRequest(this.config);
+        var params = {
             collectionName: collName
         };
         return request.send('database.addCollection', params);
-    }
-}
+    };
+    return Db;
+}());
+export { Db };

package/dist/esm/lib/util.d.ts

@@ -0,0 +1 @@
+export declare const createPromiseCallback: () => any;

package/dist/esm/lib/util.js

@@ -0,0 +1,22 @@
+export var createPromiseCallback = function () {
+    var cb = function () { };
+    if (!Promise) {
+        cb.promise = {};
+        var throwPromiseNotDefined = function () {
+            throw new Error('Your Node runtime does support ES6 Promises. ' +
+                'Set "global.Promise" to your preferred implementation of promises.');
+        };
+        Object.defineProperty(cb.promise, 'then', { get: throwPromiseNotDefined });
+        Object.defineProperty(cb.promise, 'catch', { get: throwPromiseNotDefined });
+        return cb;
+    }
+    var promise = new Promise(function (resolve, reject) {
+        cb = function (err, data) {
+            if (err)
+                return reject(err);
+            return resolve(data);
+        };
+    });
+    cb.promise = promise;
+    return cb;
+};

package/dist/esm/operator-map.js

@@ -1,14 +1,14 @@
 import { QUERY_COMMANDS_LITERAL } from './commands/query';
 import { LOGIC_COMMANDS_LITERAL } from './commands/logic';
 import { UPDATE_COMMANDS_LITERAL } from './commands/update';
-export const OperatorMap = {};
-for (const key in QUERY_COMMANDS_LITERAL) {
+export var OperatorMap = {};
+for (var key in QUERY_COMMANDS_LITERAL) {
     OperatorMap[key] = '$' + key;
 }
-for (const key in LOGIC_COMMANDS_LITERAL) {
+for (var key in LOGIC_COMMANDS_LITERAL) {
     OperatorMap[key] = '$' + key;
 }
-for (const key in UPDATE_COMMANDS_LITERAL) {
+for (var key in UPDATE_COMMANDS_LITERAL) {
     OperatorMap[key] = '$' + key;
 }
 OperatorMap[QUERY_COMMANDS_LITERAL.NEQ] = '$ne';

package/dist/esm/query.d.ts

@@ -15,23 +15,27 @@ export interface QueryOption extends BaseOption {
     limit?: number;
     offset?: number;
     projection?: Object;
-    order?: Record<string, any>[];
+    order?: Record<string, any>;
 }
 export interface UpdateOption extends BaseOption {
     multiple?: boolean;
 }
 export declare class Query {
     protected _transactionId: string;
-    get(): Promise<GetRes>;
-    count(): Promise<any>;
+    get(callback?: any): Promise<GetRes>;
+    private _get;
+    count(callback?: any): Promise<any>;
+    private _count;
     where(query: object): Query;
     options(apiOptions: QueryOption | UpdateOption): Query;
     orderBy(fieldPath: string, directionStr: OrderByDirection): Query;
     limit(limit: number): Query;
     skip(offset: number): Query;
-    update(data: Object): Promise<any>;
+    update(data: Object, callback?: any): Promise<any>;
+    private _update;
     field(projection: any): Query;
-    remove(): Promise<any>;
+    remove(callback?: any): Promise<any>;
+    private _remove;
     updateAndReturn(data: Object): Promise<any>;
     watch: (options: IWatchOptions) => DBRealtimeListener;
 }