@qmuse/appwrite-runtime-sdk 0.0.1-dev.1

package/LEGAL.md

@@ -0,0 +1,7 @@
+Legal Disclaimer
+
+Within this source code, the comments in Chinese shall be the original, governing version. Any comment in other languages are for reference only. In the event of any conflict between the Chinese language version comments and other language version comments, the Chinese language version shall prevail.
+
+法律免责声明
+
+关于代码注释部分，中文注释为官方版本，其它语言注释仅做参考。中文注释可能与其它语言注释存在不一致，当中文注释与其它语言注释存在不一致时，请以中文注释为准。

package/README.md

@@ -0,0 +1,81 @@
+# QMuse Appwrite Runtime SDK
+
+浏览器端 QMuse Appwrite Runtime SDK。应用仍在 `src/services/appwrite.ts` 创建唯一的 Appwrite `Client`、`Account` 和 `TablesDB`，本包负责 Runtime 配置、Session 协调、单次 401 刷新和带审计字段保护的 TablesDB CRUD。
+
+## 使用
+
+```ts
+import { Account, Client, TablesDB } from 'appwrite';
+import { createQmuseAppwriteRuntime } from '@alipay/appwrite-runtime-sdk';
+
+export const client = new Client();
+export const account = new Account(client);
+export const tablesDB = new TablesDB(client);
+
+const runtime = createQmuseAppwriteRuntime({
+  client,
+  account,
+  tablesDB,
+  getMuseRuntime: () => window.__MUSE__,
+  getQmuseLoginUserId: () => {
+    const userId = window.__TERN__?.user?.clientUser?.userId;
+    return typeof userId === 'string' && userId.trim() ? userId : null;
+  },
+});
+
+export const initAppwrite = runtime.init;
+export const getAppwriteClients = runtime.getClients;
+export const createQmuseRow = runtime.createRow;
+export const updateQmuseRow = runtime.updateRow;
+```
+
+不要在页面、hook 或业务服务中直接创建 Appwrite SDK 实例，或绕过 `createRow` / `updateRow` 写入审计字段。
+
+新增、更新和删除会由 SDK 内置地异步上报最小审计事件；上报不阻塞 CRUD，也不向业务代码暴露 hook、开关或 API Key。SDK 不上传业务 data、custom-token 或 Session。项目内置的 Appwrite 事件云函数仍负责成功 mutation 的可靠服务端审计与重试；浏览器侧上报只用于补充安全信号。
+
+## Badges
+
+[![TNPM version][tnpm-image]][tnpm-url]
+[![TNPM downloads][tnpm-downloads-image]][tnpm-url]
+![install-node 20](https://hitu.alipay.com/badge/tnpm?title=install-node&value=20)
+
+[tnpm-image]: https://npm.alibaba-inc.com/badge/v/@alipay/appwrite-runtime-sdk.svg
+[tnpm-url]: https://npm.alibaba-inc.com/package/@alipay/appwrite-runtime-sdk
+[tnpm-downloads-image]: https://npm.alibaba-inc.com/badge/d/@alipay/appwrite-runtime-sdk.svg
+
+---
+
+## 准备工作
+
+- 安装 [nodejs](https://nodejs.org/en/)
+- 使用最新版本的 [tnpm](http://web.npm.alibaba-inc.com/)
+
+## 开发
+
+```bash
+# 安装依赖
+$ tnpm install
+
+# 构建与检查
+$ npm run build
+$ npm run lint
+$ npm test
+```
+
+## 发布
+
+该 SDK 不发布为海兔资产；构建、测试和公网 npm 发布均使用独立工具链。
+
+### 公网 `@qmuse` 包
+
+先在 `package.json` 设定未发布的正式语义化版本，再执行：
+
+```bash
+npm run publish:dev
+```
+
+脚本会验证 npmjs 登录态、检查版本是否已存在，并运行 CI 与构建。确认后，它只在发布期间把包名临时改为 `@qmuse/appwrite-runtime-sdk`，发布到 npmjs 的 `dev` tag，退出时恢复本地 `package.json`。验证通过后，可将该版本转为 `latest`：
+
+```bash
+npm dist-tag add @qmuse/appwrite-runtime-sdk@<version> latest --registry https://registry.npmjs.org/
+```

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { createQmuseAppwriteRuntime } from './runtime';
+export type { AppwriteAccountLike, AppwriteClientLike, AppwriteError, AppwriteRuntimeConfig, AppwriteSession, AppwriteTablesDBLike, AppwriteUser, BusinessRowData, QmuseAppwriteClients, QmuseAppwriteRuntimeOptions, QmuseEnvironment, QmuseRuntimeContext, } from './types';

package/dist/index.js

@@ -0,0 +1 @@
+export { createQmuseAppwriteRuntime } from "./runtime";

package/dist/runtime.d.ts

@@ -0,0 +1,31 @@
+import type { AppwriteUser, BusinessRowData, QmuseAppwriteClients, QmuseAppwriteRuntimeOptions } from './types';
+export declare function createQmuseAppwriteRuntime(options: QmuseAppwriteRuntimeOptions): {
+    init: () => Promise<void>;
+    getClients: () => Promise<QmuseAppwriteClients>;
+    getCurrentUser: () => AppwriteUser;
+    refreshSession: () => Promise<void>;
+    listRows: ({ tableId, queries, limit, cursor, }: {
+        tableId: string;
+        queries?: string[] | undefined;
+        limit?: number | undefined;
+        cursor?: string | undefined;
+    }) => Promise<unknown>;
+    getRow: ({ tableId, rowId, }: {
+        tableId: string;
+        rowId: string;
+    }) => Promise<unknown>;
+    createRow: ({ tableId, data, rowId, }: {
+        tableId: string;
+        data: BusinessRowData;
+        rowId?: string | undefined;
+    }) => Promise<unknown>;
+    updateRow: ({ tableId, rowId, data, }: {
+        tableId: string;
+        rowId: string;
+        data: BusinessRowData;
+    }) => Promise<unknown>;
+    deleteRow: ({ tableId, rowId, }: {
+        tableId: string;
+        rowId: string;
+    }) => Promise<unknown>;
+};

package/dist/runtime.js

@@ -0,0 +1,939 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import { ID, Permission, Query, Role } from 'appwrite';
+var BLOCKED_MUTATION_FIELDS = new Set(['code', 'creatorId', 'modifierId', 'gmtCreate', 'gmtModified']);
+function isRecord(value) {
+  return Boolean(value) && _typeof(value) === 'object' && !Array.isArray(value);
+}
+function getErrorCode(error) {
+  if (!isRecord(error)) {
+    return null;
+  }
+  var code = Number(error.code);
+  return Number.isFinite(code) ? code : null;
+}
+function createResponseError(_ref) {
+  var _payload$code, _payload$type;
+  var payload = _ref.payload,
+    status = _ref.status,
+    fallbackMessage = _ref.fallbackMessage,
+    fallbackType = _ref.fallbackType;
+  var error = new Error(typeof (payload === null || payload === void 0 ? void 0 : payload.message) === 'string' && payload.message ? payload.message : fallbackMessage);
+  Object.assign(error, {
+    code: (_payload$code = payload === null || payload === void 0 ? void 0 : payload.code) !== null && _payload$code !== void 0 ? _payload$code : status,
+    type: (_payload$type = payload === null || payload === void 0 ? void 0 : payload.type) !== null && _payload$type !== void 0 ? _payload$type : fallbackType
+  });
+  return error;
+}
+function readResponsePayload(_x) {
+  return _readResponsePayload.apply(this, arguments);
+}
+function _readResponsePayload() {
+  _readResponsePayload = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee21(response) {
+    var payload;
+    return _regeneratorRuntime().wrap(function _callee21$(_context21) {
+      while (1) switch (_context21.prev = _context21.next) {
+        case 0:
+          _context21.next = 2;
+          return response.json().catch(function () {
+            return null;
+          });
+        case 2:
+          payload = _context21.sent;
+          return _context21.abrupt("return", isRecord(payload) ? payload : null);
+        case 4:
+        case "end":
+          return _context21.stop();
+      }
+    }, _callee21);
+  }));
+  return _readResponsePayload.apply(this, arguments);
+}
+function sanitizeBusinessRowData(data) {
+  return Object.fromEntries(Object.entries(data).filter(function (_ref2) {
+    var _ref3 = _slicedToArray(_ref2, 1),
+      key = _ref3[0];
+    return !key.startsWith('$') && !BLOCKED_MUTATION_FIELDS.has(key);
+  }));
+}
+export function createQmuseAppwriteRuntime(options) {
+  var _options$fetch;
+  var client = options.client,
+    account = options.account,
+    tablesDB = options.tablesDB;
+  var request = (_options$fetch = options.fetch) !== null && _options$fetch !== void 0 ? _options$fetch : globalThis.fetch;
+  if (!request) {
+    throw new Error('A fetch implementation is required');
+  }
+  var state = {
+    runtimeConfig: null,
+    currentUser: null,
+    currentSessionProvider: null,
+    confirmedQmuseUserId: null
+  };
+  var initPromise = null;
+  var sessionSyncPromise = null;
+  var refreshPromise = null;
+  function getMuseRuntime() {
+    var runtime = options.getMuseRuntime();
+    if (!runtime || runtime.env !== 'dev' && runtime.env !== 'prod') {
+      throw new Error('QMuse runtime env must be dev or prod');
+    }
+    return runtime;
+  }
+  function getRuntimeConfig() {
+    if (!state.runtimeConfig) {
+      throw new Error('Appwrite is not initialized');
+    }
+    return state.runtimeConfig;
+  }
+  function clearCurrentSession() {
+    state.currentUser = null;
+    state.currentSessionProvider = null;
+    state.confirmedQmuseUserId = null;
+  }
+  function loadAppwriteRuntimeConfig() {
+    return _loadAppwriteRuntimeConfig.apply(this, arguments);
+  }
+  function _loadAppwriteRuntimeConfig() {
+    _loadAppwriteRuntimeConfig = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+      var runtime, response, payload, data, config;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            runtime = getMuseRuntime();
+            _context.next = 3;
+            return request(new URL('/runtime/appwrite/config', runtime.domain).toString(), {
+              method: 'POST',
+              credentials: 'include',
+              headers: {
+                'Content-Type': 'application/json'
+              },
+              body: JSON.stringify({
+                appId: runtime.appId,
+                env: runtime.env
+              })
+            });
+          case 3:
+            response = _context.sent;
+            _context.next = 6;
+            return readResponsePayload(response);
+          case 6:
+            payload = _context.sent;
+            data = isRecord(payload === null || payload === void 0 ? void 0 : payload.data) ? payload.data : null;
+            if (!(!response.ok || (payload === null || payload === void 0 ? void 0 : payload.success) !== true || !data)) {
+              _context.next = 10;
+              break;
+            }
+            throw createResponseError({
+              payload: payload,
+              status: response.status,
+              fallbackMessage: "Appwrite config request failed: ".concat(response.status),
+              fallbackType: 'appwrite_config_error'
+            });
+          case 10:
+            config = {
+              endpoint: data.endpoint,
+              projectId: data.projectId,
+              databaseId: data.databaseId,
+              authTokenEndpoint: data.authTokenEndpoint
+            };
+            if (!(typeof config.endpoint !== 'string' || !config.endpoint || typeof config.projectId !== 'string' || !config.projectId || typeof config.databaseId !== 'string' || !config.databaseId || typeof config.authTokenEndpoint !== 'string' || !config.authTokenEndpoint)) {
+              _context.next = 13;
+              break;
+            }
+            throw new Error('Appwrite runtime config is incomplete');
+          case 13:
+            return _context.abrupt("return", config);
+          case 14:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return _loadAppwriteRuntimeConfig.apply(this, arguments);
+  }
+  function cacheCurrentSession() {
+    return _cacheCurrentSession.apply(this, arguments);
+  }
+  function _cacheCurrentSession() {
+    _cacheCurrentSession = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+      var _yield$Promise$all, _yield$Promise$all2, user, session;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.next = 2;
+            return Promise.all([account.get(), account.getSession({
+              sessionId: 'current'
+            })]);
+          case 2:
+            _yield$Promise$all = _context2.sent;
+            _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 2);
+            user = _yield$Promise$all2[0];
+            session = _yield$Promise$all2[1];
+            state.currentUser = user;
+            state.currentSessionProvider = session.provider;
+          case 8:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }));
+    return _cacheCurrentSession.apply(this, arguments);
+  }
+  function tryCacheCurrentSession() {
+    return _tryCacheCurrentSession.apply(this, arguments);
+  }
+  function _tryCacheCurrentSession() {
+    _tryCacheCurrentSession = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.prev = 0;
+            _context3.next = 3;
+            return cacheCurrentSession();
+          case 3:
+            return _context3.abrupt("return", true);
+          case 6:
+            _context3.prev = 6;
+            _context3.t0 = _context3["catch"](0);
+            if (!(getErrorCode(_context3.t0) !== 401)) {
+              _context3.next = 10;
+              break;
+            }
+            throw _context3.t0;
+          case 10:
+            clearCurrentSession();
+            return _context3.abrupt("return", false);
+          case 12:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3, null, [[0, 6]]);
+    }));
+    return _tryCacheCurrentSession.apply(this, arguments);
+  }
+  function deleteCurrentSession() {
+    return _deleteCurrentSession.apply(this, arguments);
+  }
+  function _deleteCurrentSession() {
+    _deleteCurrentSession = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4() {
+      return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            if (state.currentUser) {
+              _context4.next = 2;
+              break;
+            }
+            return _context4.abrupt("return");
+          case 2:
+            _context4.prev = 2;
+            _context4.next = 5;
+            return account.deleteSession({
+              sessionId: 'current'
+            });
+          case 5:
+            _context4.next = 11;
+            break;
+          case 7:
+            _context4.prev = 7;
+            _context4.t0 = _context4["catch"](2);
+            if (!(getErrorCode(_context4.t0) !== 401)) {
+              _context4.next = 11;
+              break;
+            }
+            throw _context4.t0;
+          case 11:
+            _context4.prev = 11;
+            clearCurrentSession();
+            return _context4.finish(11);
+          case 14:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4, null, [[2, 7, 11, 14]]);
+    }));
+    return _deleteCurrentSession.apply(this, arguments);
+  }
+  function ensureAnonymousSession() {
+    return _ensureAnonymousSession.apply(this, arguments);
+  }
+  function _ensureAnonymousSession() {
+    _ensureAnonymousSession = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
+      var forceReplace,
+        _args5 = arguments;
+      return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            forceReplace = _args5.length > 0 && _args5[0] !== undefined ? _args5[0] : false;
+            if (state.currentUser) {
+              _context5.next = 4;
+              break;
+            }
+            _context5.next = 4;
+            return tryCacheCurrentSession();
+          case 4:
+            if (!(!forceReplace && state.currentUser && state.currentSessionProvider === 'anonymous')) {
+              _context5.next = 7;
+              break;
+            }
+            state.confirmedQmuseUserId = null;
+            return _context5.abrupt("return");
+          case 7:
+            _context5.next = 9;
+            return deleteCurrentSession();
+          case 9:
+            _context5.next = 11;
+            return account.createAnonymousSession();
+          case 11:
+            _context5.next = 13;
+            return cacheCurrentSession();
+          case 13:
+            state.confirmedQmuseUserId = null;
+          case 14:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5);
+    }));
+    return _ensureAnonymousSession.apply(this, arguments);
+  }
+  function requestCustomToken() {
+    return _requestCustomToken.apply(this, arguments);
+  }
+  function _requestCustomToken() {
+    _requestCustomToken = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6() {
+      var runtime, config, response, payload, data;
+      return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+        while (1) switch (_context6.prev = _context6.next) {
+          case 0:
+            runtime = getMuseRuntime();
+            config = getRuntimeConfig();
+            _context6.next = 4;
+            return request(new URL(config.authTokenEndpoint, runtime.domain).toString(), {
+              method: 'POST',
+              credentials: 'include',
+              headers: {
+                'Content-Type': 'application/json'
+              },
+              body: JSON.stringify({
+                appId: runtime.appId,
+                appVersionId: runtime.appVersionId,
+                env: runtime.env,
+                projectId: config.projectId
+              })
+            });
+          case 4:
+            response = _context6.sent;
+            if (!(response.status === 401)) {
+              _context6.next = 7;
+              break;
+            }
+            return _context6.abrupt("return", null);
+          case 7:
+            _context6.next = 9;
+            return readResponsePayload(response);
+          case 9:
+            payload = _context6.sent;
+            data = isRecord(payload === null || payload === void 0 ? void 0 : payload.data) ? payload.data : null;
+            if (!(!response.ok || (payload === null || payload === void 0 ? void 0 : payload.success) !== true || !data)) {
+              _context6.next = 13;
+              break;
+            }
+            throw createResponseError({
+              payload: payload,
+              status: response.status,
+              fallbackMessage: "Custom token request failed: ".concat(response.status),
+              fallbackType: 'custom_token_error'
+            });
+          case 13:
+            if (!(typeof data.userId !== 'string' || !data.userId || typeof data.secret !== 'string' || !data.secret)) {
+              _context6.next = 15;
+              break;
+            }
+            throw new Error('Custom token response is incomplete');
+          case 15:
+            return _context6.abrupt("return", {
+              userId: data.userId,
+              secret: data.secret
+            });
+          case 16:
+          case "end":
+            return _context6.stop();
+        }
+      }, _callee6);
+    }));
+    return _requestCustomToken.apply(this, arguments);
+  }
+  function ensureAuthenticatedSession(_x2) {
+    return _ensureAuthenticatedSession.apply(this, arguments);
+  }
+  function _ensureAuthenticatedSession() {
+    _ensureAuthenticatedSession = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(_ref4) {
+      var qmuseUserId, userId, secret, _ref4$forceReplace, forceReplace;
+      return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+        while (1) switch (_context7.prev = _context7.next) {
+          case 0:
+            qmuseUserId = _ref4.qmuseUserId, userId = _ref4.userId, secret = _ref4.secret, _ref4$forceReplace = _ref4.forceReplace, forceReplace = _ref4$forceReplace === void 0 ? false : _ref4$forceReplace;
+            if (state.currentUser) {
+              _context7.next = 4;
+              break;
+            }
+            _context7.next = 4;
+            return tryCacheCurrentSession();
+          case 4:
+            if (!(!forceReplace && state.currentUser && state.currentSessionProvider !== 'anonymous' && state.currentUser.$id === userId)) {
+              _context7.next = 7;
+              break;
+            }
+            state.confirmedQmuseUserId = qmuseUserId;
+            return _context7.abrupt("return");
+          case 7:
+            _context7.next = 9;
+            return deleteCurrentSession();
+          case 9:
+            _context7.next = 11;
+            return account.createSession({
+              userId: userId,
+              secret: secret
+            });
+          case 11:
+            _context7.next = 13;
+            return cacheCurrentSession();
+          case 13:
+            state.confirmedQmuseUserId = qmuseUserId;
+          case 14:
+          case "end":
+            return _context7.stop();
+        }
+      }, _callee7);
+    }));
+    return _ensureAuthenticatedSession.apply(this, arguments);
+  }
+  function coordinateAppwriteSession() {
+    return _coordinateAppwriteSession.apply(this, arguments);
+  }
+  function _coordinateAppwriteSession() {
+    _coordinateAppwriteSession = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8() {
+      var force,
+        qmuseUserId,
+        sessionMatchesRuntime,
+        token,
+        _args8 = arguments;
+      return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+        while (1) switch (_context8.prev = _context8.next) {
+          case 0:
+            force = _args8.length > 0 && _args8[0] !== undefined ? _args8[0] : false;
+            qmuseUserId = options.getQmuseLoginUserId();
+            sessionMatchesRuntime = state.currentUser !== null && (qmuseUserId ? state.currentSessionProvider !== 'anonymous' && state.confirmedQmuseUserId === qmuseUserId : state.currentSessionProvider === 'anonymous' && state.confirmedQmuseUserId === null);
+            if (!(!force && sessionMatchesRuntime)) {
+              _context8.next = 5;
+              break;
+            }
+            return _context8.abrupt("return");
+          case 5:
+            if (state.currentUser) {
+              _context8.next = 8;
+              break;
+            }
+            _context8.next = 8;
+            return tryCacheCurrentSession();
+          case 8:
+            if (qmuseUserId) {
+              _context8.next = 12;
+              break;
+            }
+            _context8.next = 11;
+            return ensureAnonymousSession(force);
+          case 11:
+            return _context8.abrupt("return");
+          case 12:
+            if (!(!force && state.currentUser && state.currentSessionProvider !== 'anonymous' && state.confirmedQmuseUserId === qmuseUserId)) {
+              _context8.next = 14;
+              break;
+            }
+            return _context8.abrupt("return");
+          case 14:
+            _context8.next = 16;
+            return requestCustomToken();
+          case 16:
+            token = _context8.sent;
+            if (token) {
+              _context8.next = 21;
+              break;
+            }
+            _context8.next = 20;
+            return ensureAnonymousSession(force);
+          case 20:
+            return _context8.abrupt("return");
+          case 21:
+            _context8.next = 23;
+            return ensureAuthenticatedSession(_objectSpread(_objectSpread({
+              qmuseUserId: qmuseUserId
+            }, token), {}, {
+              forceReplace: force
+            }));
+          case 23:
+          case "end":
+            return _context8.stop();
+        }
+      }, _callee8);
+    }));
+    return _coordinateAppwriteSession.apply(this, arguments);
+  }
+  function synchronizeAppwriteSession() {
+    return _synchronizeAppwriteSession.apply(this, arguments);
+  }
+  function _synchronizeAppwriteSession() {
+    _synchronizeAppwriteSession = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9() {
+      return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+        while (1) switch (_context9.prev = _context9.next) {
+          case 0:
+            if (!sessionSyncPromise) {
+              sessionSyncPromise = coordinateAppwriteSession().finally(function () {
+                sessionSyncPromise = null;
+              });
+            }
+            return _context9.abrupt("return", sessionSyncPromise);
+          case 2:
+          case "end":
+            return _context9.stop();
+        }
+      }, _callee9);
+    }));
+    return _synchronizeAppwriteSession.apply(this, arguments);
+  }
+  function initializeAppwrite() {
+    return _initializeAppwrite.apply(this, arguments);
+  }
+  function _initializeAppwrite() {
+    _initializeAppwrite = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10() {
+      var config;
+      return _regeneratorRuntime().wrap(function _callee10$(_context10) {
+        while (1) switch (_context10.prev = _context10.next) {
+          case 0:
+            _context10.next = 2;
+            return loadAppwriteRuntimeConfig();
+          case 2:
+            config = _context10.sent;
+            client.setEndpoint(config.endpoint).setProject(config.projectId);
+            state.runtimeConfig = config;
+            _context10.next = 7;
+            return synchronizeAppwriteSession();
+          case 7:
+          case "end":
+            return _context10.stop();
+        }
+      }, _callee10);
+    }));
+    return _initializeAppwrite.apply(this, arguments);
+  }
+  function init() {
+    if (!initPromise) {
+      initPromise = initializeAppwrite().catch(function (error) {
+        initPromise = null;
+        state.runtimeConfig = null;
+        clearCurrentSession();
+        throw error;
+      });
+    }
+    return initPromise;
+  }
+  function getClients() {
+    return _getClients.apply(this, arguments);
+  }
+  function _getClients() {
+    _getClients = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11() {
+      return _regeneratorRuntime().wrap(function _callee11$(_context11) {
+        while (1) switch (_context11.prev = _context11.next) {
+          case 0:
+            _context11.next = 2;
+            return init();
+          case 2:
+            return _context11.abrupt("return", {
+              client: client,
+              account: account,
+              tablesDB: tablesDB,
+              databaseId: getRuntimeConfig().databaseId
+            });
+          case 3:
+          case "end":
+            return _context11.stop();
+        }
+      }, _callee11);
+    }));
+    return _getClients.apply(this, arguments);
+  }
+  function getCurrentUser() {
+    if (!state.currentUser) {
+      throw new Error('Appwrite user is not authenticated');
+    }
+    return state.currentUser;
+  }
+  function refreshSession() {
+    return _refreshSession.apply(this, arguments);
+  }
+  function _refreshSession() {
+    _refreshSession = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee13() {
+      return _regeneratorRuntime().wrap(function _callee13$(_context13) {
+        while (1) switch (_context13.prev = _context13.next) {
+          case 0:
+            _context13.next = 2;
+            return init();
+          case 2:
+            if (!refreshPromise) {
+              refreshPromise = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12() {
+                return _regeneratorRuntime().wrap(function _callee12$(_context12) {
+                  while (1) switch (_context12.prev = _context12.next) {
+                    case 0:
+                      if (!sessionSyncPromise) {
+                        _context12.next = 3;
+                        break;
+                      }
+                      _context12.next = 3;
+                      return sessionSyncPromise;
+                    case 3:
+                      _context12.next = 5;
+                      return coordinateAppwriteSession(true);
+                    case 5:
+                    case "end":
+                      return _context12.stop();
+                  }
+                }, _callee12);
+              }))().finally(function () {
+                refreshPromise = null;
+              });
+            }
+            return _context13.abrupt("return", refreshPromise);
+          case 4:
+          case "end":
+            return _context13.stop();
+        }
+      }, _callee13);
+    }));
+    return _refreshSession.apply(this, arguments);
+  }
+  function withSessionRetry(_x3) {
+    return _withSessionRetry.apply(this, arguments);
+  }
+  function _withSessionRetry() {
+    _withSessionRetry = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee14(operation) {
+      return _regeneratorRuntime().wrap(function _callee14$(_context14) {
+        while (1) switch (_context14.prev = _context14.next) {
+          case 0:
+            _context14.next = 2;
+            return init();
+          case 2:
+            _context14.next = 4;
+            return synchronizeAppwriteSession();
+          case 4:
+            _context14.prev = 4;
+            _context14.next = 7;
+            return operation();
+          case 7:
+            return _context14.abrupt("return", _context14.sent);
+          case 10:
+            _context14.prev = 10;
+            _context14.t0 = _context14["catch"](4);
+            if (!(getErrorCode(_context14.t0) !== 401)) {
+              _context14.next = 14;
+              break;
+            }
+            throw _context14.t0;
+          case 14:
+            _context14.next = 16;
+            return refreshSession();
+          case 16:
+            return _context14.abrupt("return", operation());
+          case 17:
+          case "end":
+            return _context14.stop();
+        }
+      }, _callee14, null, [[4, 10]]);
+    }));
+    return _withSessionRetry.apply(this, arguments);
+  }
+  function scheduleMutationAudit(_ref5) {
+    var operation = _ref5.operation,
+      tableId = _ref5.tableId,
+      rowId = _ref5.rowId,
+      outcome = _ref5.outcome,
+      durationMs = _ref5.durationMs,
+      errorCode = _ref5.errorCode;
+    var runtime = getMuseRuntime();
+    globalThis.setTimeout(function () {
+      try {
+        void Promise.resolve(request(new URL('/runtime/appwrite/mutation-events', runtime.domain).toString(), {
+          method: 'POST',
+          credentials: 'include',
+          keepalive: true,
+          headers: {
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify(_objectSpread({
+            schemaVersion: 1,
+            operation: operation,
+            outcome: outcome,
+            appId: runtime.appId,
+            env: runtime.env,
+            tableId: tableId,
+            rowId: rowId,
+            durationMs: durationMs
+          }, errorCode === undefined ? {} : {
+            errorCode: errorCode
+          }))
+        })).catch(function () {
+          return undefined;
+        });
+      } catch (_unused) {
+        // Security telemetry is best-effort and cannot alter mutation semantics.
+      }
+    }, 0);
+  }
+  function observeMutation(_x4) {
+    return _observeMutation.apply(this, arguments);
+  }
+  function _observeMutation() {
+    _observeMutation = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee15(_ref6) {
+      var operation, tableId, rowId, task, startedAt, result, _getErrorCode;
+      return _regeneratorRuntime().wrap(function _callee15$(_context15) {
+        while (1) switch (_context15.prev = _context15.next) {
+          case 0:
+            operation = _ref6.operation, tableId = _ref6.tableId, rowId = _ref6.rowId, task = _ref6.task;
+            startedAt = Date.now();
+            _context15.prev = 2;
+            _context15.next = 5;
+            return task();
+          case 5:
+            result = _context15.sent;
+            scheduleMutationAudit({
+              operation: operation,
+              tableId: tableId,
+              rowId: rowId,
+              outcome: 'success',
+              durationMs: Date.now() - startedAt
+            });
+            return _context15.abrupt("return", result);
+          case 10:
+            _context15.prev = 10;
+            _context15.t0 = _context15["catch"](2);
+            scheduleMutationAudit({
+              operation: operation,
+              tableId: tableId,
+              rowId: rowId,
+              outcome: 'failure',
+              durationMs: Date.now() - startedAt,
+              errorCode: (_getErrorCode = getErrorCode(_context15.t0)) !== null && _getErrorCode !== void 0 ? _getErrorCode : undefined
+            });
+            throw _context15.t0;
+          case 14:
+          case "end":
+            return _context15.stop();
+        }
+      }, _callee15, null, [[2, 10]]);
+    }));
+    return _observeMutation.apply(this, arguments);
+  }
+  function listRows(_x5) {
+    return _listRows.apply(this, arguments);
+  }
+  function _listRows() {
+    _listRows = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee16(_ref7) {
+      var tableId, _ref7$queries, queries, _ref7$limit, limit, cursor, _yield$getClients, databaseId;
+      return _regeneratorRuntime().wrap(function _callee16$(_context16) {
+        while (1) switch (_context16.prev = _context16.next) {
+          case 0:
+            tableId = _ref7.tableId, _ref7$queries = _ref7.queries, queries = _ref7$queries === void 0 ? [] : _ref7$queries, _ref7$limit = _ref7.limit, limit = _ref7$limit === void 0 ? 20 : _ref7$limit, cursor = _ref7.cursor;
+            if (!(!Number.isInteger(limit) || limit < 1 || limit > 20)) {
+              _context16.next = 3;
+              break;
+            }
+            throw new RangeError('listRows limit must be an integer from 1 to 20');
+          case 3:
+            _context16.next = 5;
+            return getClients();
+          case 5:
+            _yield$getClients = _context16.sent;
+            databaseId = _yield$getClients.databaseId;
+            return _context16.abrupt("return", withSessionRetry(function () {
+              return tablesDB.listRows({
+                databaseId: databaseId,
+                tableId: tableId,
+                queries: [Query.orderDesc('$createdAt')].concat(_toConsumableArray(queries), [Query.limit(limit)], _toConsumableArray(cursor ? [Query.cursorAfter(cursor)] : []))
+              });
+            }));
+          case 8:
+          case "end":
+            return _context16.stop();
+        }
+      }, _callee16);
+    }));
+    return _listRows.apply(this, arguments);
+  }
+  function getRow(_x6) {
+    return _getRow.apply(this, arguments);
+  }
+  function _getRow() {
+    _getRow = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee17(_ref8) {
+      var tableId, rowId, _yield$getClients2, databaseId;
+      return _regeneratorRuntime().wrap(function _callee17$(_context17) {
+        while (1) switch (_context17.prev = _context17.next) {
+          case 0:
+            tableId = _ref8.tableId, rowId = _ref8.rowId;
+            _context17.next = 3;
+            return getClients();
+          case 3:
+            _yield$getClients2 = _context17.sent;
+            databaseId = _yield$getClients2.databaseId;
+            return _context17.abrupt("return", withSessionRetry(function () {
+              return tablesDB.getRow({
+                databaseId: databaseId,
+                tableId: tableId,
+                rowId: rowId
+              });
+            }));
+          case 6:
+          case "end":
+            return _context17.stop();
+        }
+      }, _callee17);
+    }));
+    return _getRow.apply(this, arguments);
+  }
+  function createRow(_x7) {
+    return _createRow.apply(this, arguments);
+  }
+  function _createRow() {
+    _createRow = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee18(_ref9) {
+      var tableId, data, _ref9$rowId, rowId, _yield$getClients3, databaseId;
+      return _regeneratorRuntime().wrap(function _callee18$(_context18) {
+        while (1) switch (_context18.prev = _context18.next) {
+          case 0:
+            tableId = _ref9.tableId, data = _ref9.data, _ref9$rowId = _ref9.rowId, rowId = _ref9$rowId === void 0 ? ID.unique() : _ref9$rowId;
+            _context18.next = 3;
+            return getClients();
+          case 3:
+            _yield$getClients3 = _context18.sent;
+            databaseId = _yield$getClients3.databaseId;
+            return _context18.abrupt("return", observeMutation({
+              operation: 'create',
+              tableId: tableId,
+              rowId: rowId,
+              task: function task() {
+                return withSessionRetry(function () {
+                  var currentUserId = getCurrentUser().$id;
+                  var owner = Role.user(currentUserId);
+                  return tablesDB.createRow({
+                    databaseId: databaseId,
+                    tableId: tableId,
+                    rowId: rowId,
+                    data: _objectSpread(_objectSpread({}, sanitizeBusinessRowData(data)), {}, {
+                      creatorId: currentUserId,
+                      modifierId: currentUserId
+                    }),
+                    permissions: [Permission.read(owner), Permission.update(owner), Permission.delete(owner)]
+                  });
+                });
+              }
+            }));
+          case 6:
+          case "end":
+            return _context18.stop();
+        }
+      }, _callee18);
+    }));
+    return _createRow.apply(this, arguments);
+  }
+  function updateRow(_x8) {
+    return _updateRow.apply(this, arguments);
+  }
+  function _updateRow() {
+    _updateRow = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee19(_ref10) {
+      var tableId, rowId, data, _yield$getClients4, databaseId;
+      return _regeneratorRuntime().wrap(function _callee19$(_context19) {
+        while (1) switch (_context19.prev = _context19.next) {
+          case 0:
+            tableId = _ref10.tableId, rowId = _ref10.rowId, data = _ref10.data;
+            _context19.next = 3;
+            return getClients();
+          case 3:
+            _yield$getClients4 = _context19.sent;
+            databaseId = _yield$getClients4.databaseId;
+            return _context19.abrupt("return", observeMutation({
+              operation: 'update',
+              tableId: tableId,
+              rowId: rowId,
+              task: function task() {
+                return withSessionRetry(function () {
+                  return tablesDB.updateRow({
+                    databaseId: databaseId,
+                    tableId: tableId,
+                    rowId: rowId,
+                    data: _objectSpread(_objectSpread({}, sanitizeBusinessRowData(data)), {}, {
+                      modifierId: getCurrentUser().$id
+                    })
+                  });
+                });
+              }
+            }));
+          case 6:
+          case "end":
+            return _context19.stop();
+        }
+      }, _callee19);
+    }));
+    return _updateRow.apply(this, arguments);
+  }
+  function deleteRow(_x9) {
+    return _deleteRow.apply(this, arguments);
+  }
+  function _deleteRow() {
+    _deleteRow = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee20(_ref11) {
+      var tableId, rowId, _yield$getClients5, databaseId;
+      return _regeneratorRuntime().wrap(function _callee20$(_context20) {
+        while (1) switch (_context20.prev = _context20.next) {
+          case 0:
+            tableId = _ref11.tableId, rowId = _ref11.rowId;
+            _context20.next = 3;
+            return getClients();
+          case 3:
+            _yield$getClients5 = _context20.sent;
+            databaseId = _yield$getClients5.databaseId;
+            return _context20.abrupt("return", observeMutation({
+              operation: 'delete',
+              tableId: tableId,
+              rowId: rowId,
+              task: function task() {
+                return withSessionRetry(function () {
+                  return tablesDB.deleteRow({
+                    databaseId: databaseId,
+                    tableId: tableId,
+                    rowId: rowId
+                  });
+                });
+              }
+            }));
+          case 6:
+          case "end":
+            return _context20.stop();
+        }
+      }, _callee20);
+    }));
+    return _deleteRow.apply(this, arguments);
+  }
+  return {
+    init: init,
+    getClients: getClients,
+    getCurrentUser: getCurrentUser,
+    refreshSession: refreshSession,
+    listRows: listRows,
+    getRow: getRow,
+    createRow: createRow,
+    updateRow: updateRow,
+    deleteRow: deleteRow
+  };
+}

package/dist/types.d.ts

@@ -0,0 +1,85 @@
+export type QmuseEnvironment = 'dev' | 'prod';
+export interface QmuseRuntimeContext {
+    appId: string;
+    appVersionId: string;
+    env: QmuseEnvironment;
+    domain: string;
+}
+export interface AppwriteRuntimeConfig {
+    endpoint: string;
+    projectId: string;
+    databaseId: string;
+    authTokenEndpoint: string;
+}
+export interface AppwriteUser {
+    $id: string;
+}
+export interface AppwriteSession {
+    provider: string;
+}
+export interface AppwriteError {
+    code?: number | string;
+}
+export type BusinessRowData = Record<string, unknown>;
+export interface AppwriteClientLike {
+    setEndpoint(endpoint: string): AppwriteClientLike;
+    setProject(projectId: string): AppwriteClientLike;
+}
+export interface AppwriteAccountLike {
+    get(): Promise<AppwriteUser>;
+    getSession(input: {
+        sessionId: 'current';
+    }): Promise<AppwriteSession>;
+    deleteSession(input: {
+        sessionId: 'current';
+    }): Promise<void>;
+    createAnonymousSession(): Promise<unknown>;
+    createSession(input: {
+        userId: string;
+        secret: string;
+    }): Promise<unknown>;
+}
+export interface AppwriteTablesDBLike {
+    listRows(input: {
+        databaseId: string;
+        tableId: string;
+        queries: string[];
+    }): Promise<unknown>;
+    getRow(input: {
+        databaseId: string;
+        tableId: string;
+        rowId: string;
+    }): Promise<unknown>;
+    createRow(input: {
+        databaseId: string;
+        tableId: string;
+        rowId: string;
+        data: BusinessRowData;
+        permissions: string[];
+    }): Promise<unknown>;
+    updateRow(input: {
+        databaseId: string;
+        tableId: string;
+        rowId: string;
+        data: BusinessRowData;
+    }): Promise<unknown>;
+    deleteRow(input: {
+        databaseId: string;
+        tableId: string;
+        rowId: string;
+    }): Promise<unknown>;
+}
+export interface QmuseAppwriteRuntimeOptions {
+    client: AppwriteClientLike;
+    account: AppwriteAccountLike;
+    tablesDB: AppwriteTablesDBLike;
+    getMuseRuntime(): QmuseRuntimeContext;
+    getQmuseLoginUserId(): string | null;
+    fetch?: typeof globalThis.fetch;
+}
+export interface QmuseAppwriteClients {
+    client: AppwriteClientLike;
+    account: AppwriteAccountLike;
+    tablesDB: AppwriteTablesDBLike;
+    databaseId: string;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@qmuse/appwrite-runtime-sdk",
+  "version": "0.0.1-dev.1",
+  "description": "QMuse Appwrite browser runtime SDK",
+  "repository": {
+    "type": "git",
+    "url": "https://code.alipay.com/yfd-air/appwrite-runtime-sdk"
+  },
+  "author": "fuxiao.yp",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "icons",
+    "LEGAL.md"
+  ],
+  "scripts": {
+    "build": "father build",
+    "build:watch": "father build --watch",
+    "ci": "npm run lint && jest --coverage --passWithNoTests",
+    "cov": "jest --coverage",
+    "doctor": "father doctor",
+    "lint": "eslint . --ext .js,.jsx,.ts,.tsx && stylelint \"src/**/*.{css,less,scss,sass}\" --allow-empty-input",
+    "prepare": "husky install",
+    "prepublishOnly": "npm run build",
+    "publish:dev": "bash scripts/publish-dev.sh",
+    "test": "jest"
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "lint-staged": {
+    "*.{md,json}": [
+      "prettier --cache --write --no-error-on-unmatched-pattern"
+    ],
+    "*.{js,jsx}": [
+      "eslint --fix",
+      "prettier --cache --write"
+    ],
+    "*.{css,less}": [
+      "stylelint --fix",
+      "prettier --cache --write"
+    ],
+    "*.{ts,tsx}": [
+      "eslint --fix",
+      "prettier --cache --parser=typescript --write"
+    ]
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.18.0"
+  },
+  "devDependencies": {
+    "@ali/ci": "^4.26.0",
+    "@umijs/lint": "^4.0.34",
+    "@umijs/test": "^4.0.34",
+    "@commitlint/cli": "^17.3.0",
+    "@commitlint/config-conventional": "^17.3.0",
+    "@types/jest": "^29.4.0",
+    "appwrite": "24.1.1",
+    "eslint": "8.15.0",
+    "father": "^4.3.8",
+    "husky": "^8.0.0",
+    "jest": "^29.4.3",
+    "jest-environment-jsdom": "^29.4.3",
+    "lint-staged": "^13.0.0",
+    "prettier": "^2.0.0",
+    "stylelint": "14.8.2"
+  },
+  "peerDependencies": {
+    "appwrite": "24.1.1"
+  },
+  "engines": {
+    "install-node": "20"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "ci": {
+    "type": "aci"
+  },
+  "libType": "UTIL",
+  "tnpm": {
+    "mode": "npm"
+  },
+  "yuyanId": "180020010101342753"
+}