@cloudbase/database 1.4.3 → 1.5.0

package/src/realtime/ws-event.ts

@@ -1,163 +0,0 @@
-import { CloudSDKError } from '../utils/error'
-import { ERR_CODE } from '../config/error.config'
-
-export const CLOSE_EVENT_CODE_INFO = {
-  1000: {
-    code: 1000,
-    name: 'Normal Closure',
-    description:
-      'Normal closure; the connection successfully completed whatever purpose for which it was created.'
-  },
-  1001: {
-    code: 1001,
-    name: 'Going Away',
-    description:
-      'The endpoint is going away, either because of a server failure or because the browser is navigating away from the page that opened the connection.'
-  },
-  1002: {
-    code: 1002,
-    name: 'Protocol Error',
-    description:
-      'The endpoint is terminating the connection due to a protocol error.'
-  },
-  1003: {
-    code: 1003,
-    name: 'Unsupported Data',
-    description:
-      'The connection is being terminated because the endpoint received data of a type it cannot accept (for example, a text-only endpoint received binary data).'
-  },
-  1005: {
-    code: 1005,
-    name: 'No Status Received',
-    description:
-      'Indicates that no status code was provided even though one was expected.'
-  },
-  1006: {
-    code: 1006,
-    name: 'Abnormal Closure',
-    description:
-      'Used to indicate that a connection was closed abnormally (that is, with no close frame being sent) when a status code is expected.'
-  },
-  1007: {
-    code: 1007,
-    name: 'Invalid frame payload data',
-    description:
-      'The endpoint is terminating the connection because a message was received that contained inconsistent data (e.g., non-UTF-8 data within a text message).'
-  },
-  1008: {
-    code: 1008,
-    name: 'Policy Violation',
-    description:
-      'The endpoint is terminating the connection because it received a message that violates its policy. This is a generic status code, used when codes 1003 and 1009 are not suitable.'
-  },
-  1009: {
-    code: 1009,
-    name: 'Message too big',
-    description:
-      'The endpoint is terminating the connection because a data frame was received that is too large.'
-  },
-  1010: {
-    code: 1010,
-    name: 'Missing Extension',
-    description:
-      "The client is terminating the connection because it expected the server to negotiate one or more extension, but the server didn't."
-  },
-  1011: {
-    code: 1011,
-    name: 'Internal Error',
-    description:
-      'The server is terminating the connection because it encountered an unexpected condition that prevented it from fulfilling the request.'
-  },
-  1012: {
-    code: 1012,
-    name: 'Service Restart',
-    description:
-      'The server is terminating the connection because it is restarting.'
-  },
-  1013: {
-    code: 1013,
-    name: 'Try Again Later',
-    description:
-      'The server is terminating the connection due to a temporary condition, e.g. it is overloaded and is casting off some of its clients.'
-  },
-  1014: {
-    code: 1014,
-    name: 'Bad Gateway',
-    description:
-      'The server was acting as a gateway or proxy and received an invalid response from the upstream server. This is similar to 502 HTTP Status Code.'
-  },
-  1015: {
-    code: 1015,
-    name: 'TLS Handshake',
-    description:
-      "Indicates that the connection was closed due to a failure to perform a TLS handshake (e.g., the server certificate can't be verified)."
-  },
-  // custom
-  3000: {
-    code: 3000,
-    name: 'Reconnect WebSocket',
-    description:
-      'The client is terminating the connection because it wants to reconnect'
-  },
-  3001: {
-    code: 3001,
-    name: 'No Realtime Listeners',
-    description:
-      'The client is terminating the connection because no more realtime listeners exist'
-  },
-  3002: {
-    code: 3002,
-    name: 'Heartbeat Ping Error',
-    description:
-      'The client is terminating the connection due to its failure in sending heartbeat messages'
-  },
-  3003: {
-    code: 3003,
-    name: 'Heartbeat Pong Timeout Error',
-    description:
-      'The client is terminating the connection because no heartbeat response is received from the server'
-  },
-  3050: {
-    code: 3050,
-    name: 'Server Close',
-    description:
-      'The client is terminating the connection because no heartbeat response is received from the server'
-  }
-}
-
-export enum CLOSE_EVENT_CODE {
-  // spec
-  NormalClosure = 1000,
-  GoingAway = 1001,
-  ProtocolError = 1002,
-  UnsupportedData = 1003,
-  NoStatusReceived = 1005,
-  AbnormalClosure = 1006,
-  InvalidFramePayloadData = 1007,
-  PolicyViolation = 1008,
-  MessageTooBig = 1009,
-  MissingExtension = 1010,
-  InternalError = 1011,
-  ServiceRestart = 1012,
-  TryAgainLater = 1013,
-  BadGateway = 1014,
-  TLSHandshake = 1015,
-  // custom - client close itself
-  ReconnectWebSocket = 3000,
-  NoRealtimeListeners = 3001,
-  HeartbeatPingError = 3002,
-  HeartbeatPongTimeoutError = 3003,
-  // custom - server close
-  NoAuthentication = 3050
-}
-
-export const getWSCloseError = (code: CLOSE_EVENT_CODE, reason?: string) => {
-  const info = CLOSE_EVENT_CODE_INFO[code]
-  const errMsg = !info
-    ? `code ${code}`
-    : `${info.name}, code ${code}, reason ${reason || info.description}`
-  return new CloudSDKError({
-    errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_WEBSOCKET_CONNECTION_CLOSED as string,
-    errMsg
-  })
-}

package/src/transaction.ts

@@ -1,190 +0,0 @@
-import { EJSON } from 'bson'
-import { DocumentReference } from './document'
-import { Db } from './index'
-
-class DocumentSnapshot {
-  private _data: any
-  requestId: string
-  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'
-
-interface TransactionAPI {
-  send(interfaceName: string, param?: any)
-}
-
-export class Transaction {
-  private _id: string
-
-  private _db: Db
-
-  private _request: TransactionAPI
-
-  public constructor(db: Db) {
-    this._db = db
-    this._request = new Db.reqClass(this._db.config)
-  }
-
-  async init(): Promise<void> {
-    const res = await this._request.send(START, {})
-    if (res.code) {
-      throw res
-    }
-    this._id = res.transactionId
-  }
-
-  async get(documentRef: DocumentReference): Promise<DocumentSnapshot> {
-    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: DocumentReference, data: Object): Promise<SetResult> {
-    const param = {
-      collectionName: documentRef._coll,
-      transactionId: this._id,
-      _id: documentRef.id,
-      data: EJSON.stringify(data, { relaxed: false }),
-      upsert: true
-    }
-
-    const res: SetResult | TcbError = await this._request.send(UPDATE_DOC, param)
-    if ((res as TcbError).code) throw res
-    return {
-      ...res,
-      updated: EJSON.parse((res as SetResult).updated),
-      upserted: (res as SetResult).upserted
-        ? JSON.parse((res as SetResult).upserted as string)
-        : null
-    }
-  }
-
-  async update(documentRef: DocumentReference, data: Object): Promise<UpdateResult> {
-    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 {
-      ...res,
-      updated: EJSON.parse(res.updated)
-    }
-  }
-
-  async delete(documentRef: DocumentReference): Promise<DeleteResult> {
-    const param = {
-      collectionName: documentRef._coll,
-      transactionId: this._id,
-      _id: documentRef.id
-    }
-
-    const res: DeleteResult | TcbError = await this._request.send(DELETE_DOC, param)
-    if ((res as TcbError).code) throw res
-    return {
-      ...res,
-      deleted: EJSON.parse((res as DeleteResult).deleted)
-    }
-  }
-
-  async commit(): Promise<CommitResult> {
-    const param = {
-      transactionId: this._id
-    }
-    const res: CommitResult | TcbError = await this._request.send(COMMIT, param)
-    if ((res as TcbError).code) throw res
-    return res as CommitResult
-  }
-
-  async rollback(): Promise<RollbackResult> {
-    const param = {
-      transactionId: this._id
-    }
-    const res: RollbackResult | TcbError = await this._request.send(ABORT, param)
-    if ((res as TcbError).code) throw res
-    return res as RollbackResult
-  }
-}
-
-export async function startTransaction(): Promise<Transaction> {
-  const transaction = new Transaction(this)
-  await transaction.init()
-  return transaction
-}
-
-export async function runTransaction(
-  callback: (transaction: Transaction) => void | Promise<any>,
-  times: number = 3
-): Promise<void> {
-  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)
-  }
-}
-
-type JsonString = string
-
-interface CommitResult {
-  requestId: string
-}
-
-interface RollbackResult {
-  requestId: string
-}
-
-interface TcbError {
-  requestId: string
-  code: string
-  message: string
-  stack?: string
-}
-
-interface UpdateResult {
-  requestId: string
-  updated: number
-}
-
-interface SetResult extends UpdateResult {
-  upserted: JsonString
-}
-
-interface DeleteResult {
-  requestId: string
-  deleted: number | string
-}