@cloudbase/database 1.4.3 → 1.5.0

package/tests/index.test.ts

@@ -0,0 +1,283 @@
+import { EJSON } from 'bson'
+import { Db } from '../src/index'
+
+describe('数据库请求参数测试', function() {
+  // 模拟请求类，用于捕获和验证请求参数
+  class MockRequest {
+    private config: any;
+
+    constructor(config: any) {
+      this.config = config;
+    }
+
+    async send(action: string, data: any) {
+      // 验证 instance 和 database 参数是否正确传递
+      if (this.config.instance) {
+        expect(data).toHaveProperty('instance', this.config.instance);
+      }
+      if (this.config.database) {
+        expect(data).toHaveProperty('database', this.config.database);
+      }
+
+      // 返回符合各操作期望的数据结构
+      switch (action) {
+        case 'database.getDocument':
+          return {
+            data: {
+              list: [
+                EJSON.stringify({ _id: 'doc1', name: '测试文档1', value: 100 }),
+                EJSON.stringify({ _id: 'doc2', name: '测试文档2', value: 200 })
+              ]
+            },
+            requestId: 'mock-request-id-123456',
+            total: 2,
+            limit: 100,
+            offset: 5
+          };
+        case 'database.insertDocument':
+          return {
+            data: { insertedIds: ['doc-new'] },
+            requestId: 'mock-request-id-insert'
+          };
+        case 'database.modifyDocument':
+          return {
+            data: { updated: 1, upsert_id: 'doc1' },
+            requestId: 'mock-request-id-modify'
+          };
+        case 'database.aggregateDocuments':
+          return {
+            data: { list: [] },
+            requestId: 'mock-request-id-aggregate'
+          };
+        default:
+          return { data: { ok: 1 } };
+      }
+    }
+  }
+
+  // 测试配置
+  const testConfig = {
+    env: 'test-env',
+    instance: 'test-instance',
+    database: 'test-database'
+  };
+
+  // 在每个测试前配置
+  beforeEach(function() {
+    Db.reqClass = MockRequest;
+  });
+
+  it('集合查询操作应包含 instance 和 database 参数', async function() {
+    const db = new Db(testConfig);
+    const coll = db.collection('test-collection');
+    await coll.where({}).get();
+  });
+
+  it('集合添加操作应包含 instance 和 database 参数', async function() {
+    const db = new Db(testConfig);
+    const coll = db.collection('test-collection');
+    await coll.add({ name: '新文档', value: 300 });
+  });
+
+  it('文档更新操作应包含 instance 和 database 参数', async function() {
+    const db = new Db(testConfig);
+    const coll = db.collection('test-collection');
+    const doc = coll.doc('doc1');
+    await doc.update({ value: 150 });
+  });
+
+  it('聚合操作应包含 instance 和 database 参数', async function() {
+    const db = new Db(testConfig);
+    const coll = db.collection('test-collection');
+    const aggregate = coll
+      .aggregate()
+      .match({ value: { $gt: 50 } })
+      .group({ _id: null, total: { $sum: '$value' } });
+    await aggregate.end();
+  });
+
+  it('创建集合操作应包含 instance 和 database 参数', async function() {
+    const db = new Db(testConfig);
+    await db.createCollection('new-collection');
+  });
+
+  it('应支持 const res = await db.collection(\'xxx\').get() 方式调用', async function() {
+    const db = new Db(testConfig);
+    const coll = db.collection('test-collection');
+
+    // 测试直接调用 get() 而不传递 where 条件
+    const res = await coll.get();
+
+    // 验证返回结果的结构
+    expect(res).toHaveProperty('data');
+    expect(res).toHaveProperty('requestId');
+    expect(res).toHaveProperty('total');
+    expect(res).toHaveProperty('limit');
+    expect(res).toHaveProperty('offset');
+
+    // 验证返回的数据
+    expect(Array.isArray(res.data)).toBe(true);
+    expect(res.data.length).toBe(2);
+    expect(res.data[0]).toHaveProperty('_id', 'doc1');
+    expect(res.data[0]).toHaveProperty('name', '测试文档1');
+    expect(res.data[1]).toHaveProperty('_id', 'doc2');
+    expect(res.data[1]).toHaveProperty('name', '测试文档2');
+  });
+
+  // ---------- timeout 透传（per-request，经 createRequest 第三参数） ----------
+  describe('timeout 透传', function() {
+    it('options({timeout}) 应把 timeout 作为 send 第三参透传', async function() {
+      let capturedArgs: any[] = [];
+      class TimeoutReq {
+        constructor(_config: any) {}
+        async send(...args: any[]) {
+          capturedArgs = args;
+          return { data: { list: [] }, requestId: 'req-timeout' };
+        }
+      }
+      Db.reqClass = TimeoutReq as any;
+
+      const db = new Db({ env: 'test-env' });
+      await db.collection('users').options({ timeout: 500 }).get();
+
+      expect(capturedArgs[0]).toBe('database.getDocument');
+      expect(capturedArgs[2]).toEqual({ timeout: 500 });
+    });
+
+    it('未设置 timeout 时第三参应为空对象', async function() {
+      let capturedArgs: any[] = [];
+      class TimeoutReq {
+        constructor(_config: any) {}
+        async send(...args: any[]) {
+          capturedArgs = args;
+          return { data: { list: [] }, requestId: 'req-no-timeout' };
+        }
+      }
+      Db.reqClass = TimeoutReq as any;
+
+      const db = new Db({ env: 'test-env' });
+      await db.collection('users').get();
+
+      expect(capturedArgs[2]).toEqual({});
+    });
+
+    it('timeout 与 instance/database 注入应共存', async function() {
+      let capturedArgs: any[] = [];
+      class TimeoutReq {
+        constructor(_config: any) {}
+        async send(...args: any[]) {
+          capturedArgs = args;
+          return { data: { list: [] }, requestId: 'req-mix' };
+        }
+      }
+      Db.reqClass = TimeoutReq as any;
+
+      const db = new Db({ env: 'test-env', instance: 'inst-1', database: 'db-1' });
+      await db.collection('users').options({ timeout: 1000 }).get();
+
+      expect(capturedArgs[1]).toMatchObject({ instance: 'inst-1', database: 'db-1' });
+      expect(capturedArgs[2]).toEqual({ timeout: 1000 });
+    });
+  });
+
+  // ---------- callback 兼容（对齐 0.12.x 旧调用风格） ----------
+  describe('callback 兼容', function() {
+    it('collection().get(callback) 应调用 callback(0, result) 且返回 undefined', async function() {
+      const db = new Db(testConfig);
+      const coll = db.collection('test-collection');
+
+      const callback = jest.fn();
+      const retVal = coll.get(callback);
+
+      // 对齐 master 行为：传 callback 时返回 undefined
+      expect(retVal).toBeUndefined();
+
+      // 等 callback 被调用
+      await new Promise<void>(resolve => {
+        const timer = setInterval(() => {
+          if (callback.mock.calls.length > 0) {
+            clearInterval(timer);
+            resolve();
+          }
+        }, 10);
+      });
+
+      expect(callback).toHaveBeenCalledTimes(1);
+      const [err, result] = callback.mock.calls[0];
+      expect(err).toBe(0);
+      expect(result).toHaveProperty('data');
+      expect(result.data.length).toBe(2);
+      expect(result).toHaveProperty('requestId');
+    });
+
+    it('collection().add(data, callback) 应调用 callback(0, result)', async function() {
+      const db = new Db(testConfig);
+      const coll = db.collection('test-collection');
+
+      const callback = jest.fn();
+      coll.add({ name: 'cb-doc' }, callback);
+
+      await new Promise<void>(resolve => {
+        const timer = setInterval(() => {
+          if (callback.mock.calls.length > 0) {
+            clearInterval(timer);
+            resolve();
+          }
+        }, 10);
+      });
+
+      const [err, result] = callback.mock.calls[0];
+      expect(err).toBe(0);
+      expect(result).toHaveProperty('id', 'doc-new');
+      expect(result).toHaveProperty('requestId');
+    });
+
+    it('doc().get(callback) 应调用 callback(0, result)', async function() {
+      const db = new Db(testConfig);
+      const doc = db.collection('test-collection').doc('doc1');
+
+      const callback = jest.fn();
+      doc.get(callback);
+
+      await new Promise<void>(resolve => {
+        const timer = setInterval(() => {
+          if (callback.mock.calls.length > 0) {
+            clearInterval(timer);
+            resolve();
+          }
+        }, 10);
+      });
+
+      const [err, result] = callback.mock.calls[0];
+      expect(err).toBe(0);
+      expect(result).toHaveProperty('data');
+      expect(result).toHaveProperty('requestId');
+    });
+
+    it('请求异常时应调用 callback(err)', async function() {
+      class FailRequest {
+        async send() {
+          throw new Error('network down');
+        }
+      }
+      Db.reqClass = FailRequest as any;
+
+      const db = new Db(testConfig);
+      const callback = jest.fn();
+      db.collection('test-collection').get(callback);
+
+      await new Promise<void>(resolve => {
+        const timer = setInterval(() => {
+          if (callback.mock.calls.length > 0) {
+            clearInterval(timer);
+            resolve();
+          }
+        }, 10);
+      });
+
+      const [err] = callback.mock.calls[0];
+      expect(err).toBeInstanceOf(Error);
+      expect(err.message).toBe('network down');
+    });
+  });
+});

package/tests/transaction-query.test.ts

@@ -0,0 +1,207 @@
+import { EJSON } from 'bson'
+import { Db } from '../src/index'
+import { Transaction } from '../src/transaction/index'
+
+describe('Transaction（新事务 API）', () => {
+  let sendFn: jest.Mock
+
+  class MockRequest {
+    send(action: string, data: any) {
+      return sendFn(action, data)
+    }
+  }
+
+  beforeEach(() => {
+    sendFn = jest.fn()
+    Db.reqClass = MockRequest as any
+  })
+
+  function createDb() {
+    return new Db({ env: 'test-env' })
+  }
+
+  async function createInitedTransaction(db: Db, txId = 'tx-001') {
+    const tx = new Transaction(db)
+    sendFn.mockResolvedValueOnce({ transactionId: txId })
+    await tx.init()
+    return tx
+  }
+
+  function findCall(action: string) {
+    return sendFn.mock.calls.find(c => c[0] === action)
+  }
+
+  // ---------- 初始化 ----------
+  describe('init()', () => {
+    it('应调用 database.startTransaction 并记录 transactionId', async () => {
+      const db = createDb()
+      const tx = await createInitedTransaction(db, 'tx-init')
+
+      expect(findCall('database.startTransaction')).toBeDefined()
+      expect(tx.getTransactionId()).toBe('tx-init')
+    })
+
+    it('init 不带 data 参数时（send(START) 单参）在配置 instance/database 下不应崩溃', async () => {
+      class NoDataReq {
+        async send(...args: any[]) {
+          if (args[0] === 'database.startTransaction') {
+            return { transactionId: 'tx-nodata' }
+          }
+          return { data: { list: [] }, requestId: 'r' }
+        }
+      }
+      Db.reqClass = NoDataReq as any
+
+      const db = new Db({ env: 'test-env', instance: 'inst-1', database: 'db-1' })
+      const tx = new Transaction(db)
+      await tx.init() // 不应抛 TypeError
+
+      expect(tx.getTransactionId()).toBe('tx-nodata')
+    })
+  })
+
+  // ---------- 事务内查询 ----------
+  describe('collection() + where().get()', () => {
+    it('应把 transactionId 传给 database.getDocument', async () => {
+      const db = createDb()
+      const tx = await createInitedTransaction(db)
+
+      sendFn.mockResolvedValueOnce({ data: { list: [] }, requestId: 'req-1' })
+
+      await tx.collection('users').where({ age: 18 }).get()
+
+      const call = findCall('database.getDocument')
+      expect(call).toBeDefined()
+      expect(call![1]).toMatchObject({
+        collectionName: 'users',
+        transactionId: 'tx-001'
+      })
+    })
+
+    it('get() 应解析 EJSON list 并返回文档数组', async () => {
+      const db = createDb()
+      const tx = await createInitedTransaction(db)
+
+      const list = [
+        EJSON.stringify({ _id: 'doc1', name: 'Alice' }),
+        EJSON.stringify({ _id: 'doc2', name: 'Bob' })
+      ]
+      sendFn.mockResolvedValueOnce({ data: { list }, requestId: 'req-2', total: 2 })
+
+      const result = await tx.collection('users').where({}).get()
+
+      expect(result.data.length).toBe(2)
+      expect(result.data[0]).toMatchObject({ _id: 'doc1', name: 'Alice' })
+      expect(result.total).toBe(2)
+      expect(result.requestId).toBe('req-2')
+    })
+  })
+
+  // ---------- 事务内更新 ----------
+  describe('collection() + where().update()', () => {
+    it('应把 transactionId 传给 database.modifyDocument', async () => {
+      const db = createDb()
+      const tx = await createInitedTransaction(db)
+
+      sendFn.mockResolvedValueOnce({ data: { updated: 1 }, requestId: 'req-3' })
+
+      const result = await tx.collection('users').where({ name: 'Alice' }).update({ age: 25 })
+
+      const call = findCall('database.modifyDocument')
+      expect(call).toBeDefined()
+      expect(call![1]).toMatchObject({
+        collectionName: 'users',
+        transactionId: 'tx-001'
+      })
+      expect(result.updated).toBe(1)
+    })
+  })
+
+  // ---------- 事务内删除 ----------
+  describe('collection() + where().remove()', () => {
+    it('应把 transactionId 传给 database.removeDocument', async () => {
+      const db = createDb()
+      const tx = await createInitedTransaction(db)
+
+      sendFn.mockResolvedValueOnce({ data: { deleted: 3 }, requestId: 'req-4' })
+
+      const result = await tx.collection('users').where({ status: 'inactive' }).remove()
+
+      const call = findCall('database.removeDocument')
+      expect(call).toBeDefined()
+      expect(call![1]).toMatchObject({
+        collectionName: 'users',
+        transactionId: 'tx-001'
+      })
+      expect(result.deleted).toBe(3)
+    })
+  })
+
+  // ---------- 事务内计数 ----------
+  describe('collection() + where().count()', () => {
+    it('应调用 database.calculateDocument 并返回 total', async () => {
+      const db = createDb()
+      const tx = await createInitedTransaction(db)
+
+      sendFn.mockResolvedValueOnce({ data: { total: 5 }, requestId: 'req-5' })
+
+      const result = await tx.collection('users').where({ age: { $gt: 18 } }).count()
+
+      expect(findCall('database.calculateDocument')).toBeDefined()
+      expect(result.total).toBe(5)
+    })
+  })
+
+  // ---------- 事务内插入 ----------
+  describe('collection().add()', () => {
+    it('应把 transactionId 传给 database.insertDocument，并返回事务兼容结果', async () => {
+      const db = createDb()
+      const tx = await createInitedTransaction(db)
+
+      sendFn.mockResolvedValueOnce({ data: { insertedIds: ['new-id'] }, requestId: 'req-6' })
+
+      const result = await tx.collection('users').add({ name: 'New' })
+
+      const call = findCall('database.insertDocument')
+      expect(call).toBeDefined()
+      expect(call![1]).toMatchObject({
+        collectionName: 'users',
+        transactionId: 'tx-001'
+      })
+      expect(result).toMatchObject({ inserted: 1, ok: 1, id: 'new-id' })
+    })
+  })
+
+  // ---------- 事务内文档操作 ----------
+  describe('collection().doc().set()', () => {
+    it('应把 transactionId 传给 database.modifyDocument', async () => {
+      const db = createDb()
+      const tx = await createInitedTransaction(db)
+
+      sendFn.mockResolvedValueOnce({ data: { updated: 1, upsert_id: 'doc1' }, requestId: 'req-7' })
+
+      await tx.collection('users').doc('doc1').set({ name: 'Set' })
+
+      const call = findCall('database.modifyDocument')
+      expect(call).toBeDefined()
+      expect(call![1]).toMatchObject({
+        collectionName: 'users',
+        transactionId: 'tx-001'
+      })
+    })
+  })
+
+  // ---------- 提交 ----------
+  describe('commit()', () => {
+    it('应调用 database.commitTransaction 并携带 transactionId', async () => {
+      const db = createDb()
+      const tx = await createInitedTransaction(db, 'tx-cmt')
+
+      sendFn.mockResolvedValueOnce({ requestId: 'req-cmt' })
+      await tx.commit()
+
+      const call = findCall('database.commitTransaction')
+      expect(call![1]).toEqual({ transactionId: 'tx-cmt' })
+    })
+  })
+})

package/tsconfig.esm.json

@@ -20,10 +20,11 @@
     "pretty": true,
     "removeComments": true,
     "stripInternal": true,
+    "downlevelIteration": true,
     "skipDefaultLibCheck": true,
     "skipLibCheck": true,
     "moduleResolution": "node",
-    "target": "es2017",
+    "target": "es5",
     "lib": [
       "es2015",
       "es6",
@@ -35,6 +36,7 @@
   ],
   "exclude": [
     // "node_modules",
-    "test"
+    "test",
+    "tests"
   ]
 }

package/tsconfig.json

@@ -4,7 +4,6 @@
     "allowJs": false,
     "allowUnreachableCode": false,
     "allowUnusedLabels": false,
-    "charset": "utf8",
     "declaration": true,
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
@@ -21,10 +20,21 @@
     "removeComments": true,
     "stripInternal": true,
     "skipDefaultLibCheck": true,
+    "downlevelIteration": true,
     "skipLibCheck": true,
-    "target": "es2017",
-    "lib": ["es2015", "es6", "dom"]
+    "target": "es5",
+    "lib": [
+      "es2015",
+      "es6",
+      "dom"
+    ]
   },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "test"]
-}
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "test",
+    "tests"
+  ]
+}

package/tsconfig.test.json

@@ -0,0 +1,15 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "target": "es6",
+    "module": "commonjs",
+    "isolatedModules": true,
+    "skipLibCheck": true,
+    "strict": false,
+    "esModuleInterop": true,
+    "moduleResolution": "node",
+    "allowJs": true
+  },
+  "include": ["tests/**/*.ts", "src/**/*.ts"],
+  "exclude": ["node_modules"]
+}

package/dist/commonjs/realtime/error.d.ts

@@ -1,7 +0,0 @@
-import { IResponseMessageErrorMsg } from '../typings/realtime';
-export declare class RealtimeErrorMessageError extends Error {
-    isRealtimeErrorMessageError: boolean;
-    payload: IResponseMessageErrorMsg;
-    constructor(serverErrorMsg: IResponseMessageErrorMsg);
-}
-export declare const isRealtimeErrorMessageError: (e: any) => e is RealtimeErrorMessageError;

package/dist/commonjs/realtime/error.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class RealtimeErrorMessageError extends Error {
-    constructor(serverErrorMsg) {
-        super(`Watch Error ${JSON.stringify(serverErrorMsg.msgData)} (requestid: ${serverErrorMsg.requestId})`);
-        this.isRealtimeErrorMessageError = true;
-        this.payload = serverErrorMsg;
-    }
-}
-exports.RealtimeErrorMessageError = RealtimeErrorMessageError;
-exports.isRealtimeErrorMessageError = (e) => e && e.isRealtimeErrorMessageError;

package/dist/commonjs/realtime/listener.d.ts

@@ -1,14 +0,0 @@
-import { VirtualWebSocketClient } from './virtual-websocket-client';
-import { IRealtimeListenerConstructorOptions, DBRealtimeListener } from '../typings/index';
-interface IRealtimeListenerOptions extends IRealtimeListenerConstructorOptions {
-    close: () => void;
-    debug?: boolean;
-    virtualClient?: VirtualWebSocketClient;
-}
-export declare class RealtimeListener implements DBRealtimeListener {
-    close: () => void;
-    onChange: (res: any) => void;
-    onError: (error: any) => void;
-    constructor(options: IRealtimeListenerOptions);
-}
-export {};

package/dist/commonjs/realtime/listener.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class RealtimeListener {
-    constructor(options) {
-        this.close = options.close;
-        this.onChange = options.onChange;
-        this.onError = options.onError;
-        if (options.debug) {
-            Object.defineProperty(this, 'virtualClient', {
-                get: () => {
-                    return options.virtualClient;
-                }
-            });
-        }
-    }
-}
-exports.RealtimeListener = RealtimeListener;

package/dist/commonjs/realtime/message.d.ts

@@ -1,3 +0,0 @@
-import { IResponseMessage, IResponseMessageInitEventMsg } from '../typings/realtime';
-export declare function genRequestId(prefix?: string): string;
-export declare function isInitEventMessage(msg: IResponseMessage): msg is IResponseMessageInitEventMsg;

package/dist/commonjs/realtime/message.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-function genRequestId(prefix = '') {
-    return `${prefix ? `${prefix}_` : ''}${+new Date()}_${Math.random()}`;
-}
-exports.genRequestId = genRequestId;
-function isInitEventMessage(msg) {
-    return msg.msgType === 'INIT_EVENT';
-}
-exports.isInitEventMessage = isInitEventMessage;

package/dist/commonjs/realtime/snapshot.d.ts

@@ -1,16 +0,0 @@
-import { ISingleDBEvent, SnapshotType, ISnapshot } from '../typings/index';
-interface ISnapshotConstructorOptions {
-    id: number;
-    docChanges: ISingleDBEvent[];
-    docs: Record<string, any>[];
-    type?: SnapshotType;
-    msgType?: String;
-}
-export declare class Snapshot implements ISnapshot {
-    id: number;
-    docChanges: ISingleDBEvent[];
-    docs: Record<string, any>[];
-    type?: 'init';
-    constructor(options: ISnapshotConstructorOptions);
-}
-export {};