@qmuse/appwrite-runtime-sdk 1.0.1 → 1.0.3-dev.1

package/dist/runtime/AppwriteSessionCoordinator.js

@@ -0,0 +1,647 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { createResponseError, getErrorCode, isRecord, readResponsePayload } from "./utils";
+export var AppwriteSessionCoordinator = /*#__PURE__*/function () {
+  function AppwriteSessionCoordinator(options, request) {
+    _classCallCheck(this, AppwriteSessionCoordinator);
+    _defineProperty(this, "state", {
+      runtimeConfig: null,
+      currentUser: null,
+      currentSessionProvider: null,
+      confirmedQmuseUserId: null
+    });
+    _defineProperty(this, "initPromise", null);
+    _defineProperty(this, "sessionSyncPromise", null);
+    _defineProperty(this, "refreshPromise", null);
+    this.options = options;
+    this.request = request;
+  }
+  _createClass(AppwriteSessionCoordinator, [{
+    key: "init",
+    value: function init() {
+      var _this = this;
+      if (!this.initPromise) {
+        this.initPromise = this.initialize().catch(function (error) {
+          _this.initPromise = null;
+          _this.state.runtimeConfig = null;
+          _this.clearCurrentSession();
+          throw error;
+        });
+      }
+      return this.initPromise;
+    }
+  }, {
+    key: "getDatabaseId",
+    value: function () {
+      var _getDatabaseId = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return this.init();
+            case 2:
+              return _context.abrupt("return", this.requireRuntimeConfig().databaseId);
+            case 3:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function getDatabaseId() {
+        return _getDatabaseId.apply(this, arguments);
+      }
+      return getDatabaseId;
+    }()
+  }, {
+    key: "getCurrentUser",
+    value: function () {
+      var _getCurrentUser = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return this.init();
+            case 2:
+              return _context2.abrupt("return", this.requireCurrentUser());
+            case 3:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function getCurrentUser() {
+        return _getCurrentUser.apply(this, arguments);
+      }
+      return getCurrentUser;
+    }()
+  }, {
+    key: "requireCurrentUser",
+    value: function requireCurrentUser() {
+      if (!this.state.currentUser) {
+        throw new Error('Appwrite user is not authenticated');
+      }
+      return this.state.currentUser;
+    }
+  }, {
+    key: "refreshSession",
+    value: function () {
+      var _refreshSession = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4() {
+        var _this2 = this;
+        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.next = 2;
+              return this.init();
+            case 2:
+              if (!this.refreshPromise) {
+                this.refreshPromise = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
+                  return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+                    while (1) switch (_context3.prev = _context3.next) {
+                      case 0:
+                        if (!_this2.sessionSyncPromise) {
+                          _context3.next = 3;
+                          break;
+                        }
+                        _context3.next = 3;
+                        return _this2.sessionSyncPromise;
+                      case 3:
+                        _context3.next = 5;
+                        return _this2.coordinateSession(true);
+                      case 5:
+                      case "end":
+                        return _context3.stop();
+                    }
+                  }, _callee3);
+                }))().finally(function () {
+                  _this2.refreshPromise = null;
+                });
+              }
+              return _context4.abrupt("return", this.refreshPromise);
+            case 4:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function refreshSession() {
+        return _refreshSession.apply(this, arguments);
+      }
+      return refreshSession;
+    }()
+  }, {
+    key: "withSessionRetry",
+    value: function () {
+      var _withSessionRetry = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(operation) {
+        return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              _context5.next = 2;
+              return this.init();
+            case 2:
+              _context5.next = 4;
+              return this.synchronizeSession();
+            case 4:
+              _context5.prev = 4;
+              _context5.next = 7;
+              return operation();
+            case 7:
+              return _context5.abrupt("return", _context5.sent);
+            case 10:
+              _context5.prev = 10;
+              _context5.t0 = _context5["catch"](4);
+              if (!(getErrorCode(_context5.t0) !== 401)) {
+                _context5.next = 14;
+                break;
+              }
+              throw _context5.t0;
+            case 14:
+              _context5.next = 16;
+              return this.refreshSession();
+            case 16:
+              return _context5.abrupt("return", operation());
+            case 17:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this, [[4, 10]]);
+      }));
+      function withSessionRetry(_x) {
+        return _withSessionRetry.apply(this, arguments);
+      }
+      return withSessionRetry;
+    }()
+  }, {
+    key: "getMuseRuntime",
+    value: function getMuseRuntime() {
+      var runtime = this.options.getMuseRuntime();
+      if (!runtime || runtime.env !== 'dev' && runtime.env !== 'prod') {
+        throw new Error('QMuse runtime env must be dev or prod');
+      }
+      return runtime;
+    }
+  }, {
+    key: "requireRuntimeConfig",
+    value: function requireRuntimeConfig() {
+      if (!this.state.runtimeConfig) {
+        throw new Error('Appwrite is not initialized');
+      }
+      return this.state.runtimeConfig;
+    }
+  }, {
+    key: "clearCurrentSession",
+    value: function clearCurrentSession() {
+      this.state.currentUser = null;
+      this.state.currentSessionProvider = null;
+      this.state.confirmedQmuseUserId = null;
+    }
+  }, {
+    key: "loadRuntimeConfig",
+    value: function () {
+      var _loadRuntimeConfig = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6() {
+        var runtime, response, payload, data, config;
+        return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              runtime = this.getMuseRuntime();
+              _context6.next = 3;
+              return this.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 = _context6.sent;
+              _context6.next = 6;
+              return readResponsePayload(response);
+            case 6:
+              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 = 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)) {
+                _context6.next = 13;
+                break;
+              }
+              throw new Error('Appwrite runtime config is incomplete');
+            case 13:
+              return _context6.abrupt("return", config);
+            case 14:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this);
+      }));
+      function loadRuntimeConfig() {
+        return _loadRuntimeConfig.apply(this, arguments);
+      }
+      return loadRuntimeConfig;
+    }()
+  }, {
+    key: "cacheCurrentSession",
+    value: function () {
+      var _cacheCurrentSession = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7() {
+        var _yield$Promise$all, _yield$Promise$all2, user, session;
+        return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              _context7.next = 2;
+              return Promise.all([this.options.account.get(), this.options.account.getSession({
+                sessionId: 'current'
+              })]);
+            case 2:
+              _yield$Promise$all = _context7.sent;
+              _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 2);
+              user = _yield$Promise$all2[0];
+              session = _yield$Promise$all2[1];
+              this.state.currentUser = user;
+              this.state.currentSessionProvider = session.provider;
+            case 8:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this);
+      }));
+      function cacheCurrentSession() {
+        return _cacheCurrentSession.apply(this, arguments);
+      }
+      return cacheCurrentSession;
+    }()
+  }, {
+    key: "tryCacheCurrentSession",
+    value: function () {
+      var _tryCacheCurrentSession = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8() {
+        return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              _context8.prev = 0;
+              _context8.next = 3;
+              return this.cacheCurrentSession();
+            case 3:
+              return _context8.abrupt("return", true);
+            case 6:
+              _context8.prev = 6;
+              _context8.t0 = _context8["catch"](0);
+              if (!(getErrorCode(_context8.t0) !== 401)) {
+                _context8.next = 10;
+                break;
+              }
+              throw _context8.t0;
+            case 10:
+              this.clearCurrentSession();
+              return _context8.abrupt("return", false);
+            case 12:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8, this, [[0, 6]]);
+      }));
+      function tryCacheCurrentSession() {
+        return _tryCacheCurrentSession.apply(this, arguments);
+      }
+      return tryCacheCurrentSession;
+    }()
+  }, {
+    key: "deleteCurrentSession",
+    value: function () {
+      var _deleteCurrentSession = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9() {
+        return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              if (this.state.currentUser) {
+                _context9.next = 2;
+                break;
+              }
+              return _context9.abrupt("return");
+            case 2:
+              _context9.prev = 2;
+              _context9.next = 5;
+              return this.options.account.deleteSession({
+                sessionId: 'current'
+              });
+            case 5:
+              _context9.next = 11;
+              break;
+            case 7:
+              _context9.prev = 7;
+              _context9.t0 = _context9["catch"](2);
+              if (!(getErrorCode(_context9.t0) !== 401)) {
+                _context9.next = 11;
+                break;
+              }
+              throw _context9.t0;
+            case 11:
+              _context9.prev = 11;
+              this.clearCurrentSession();
+              return _context9.finish(11);
+            case 14:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9, this, [[2, 7, 11, 14]]);
+      }));
+      function deleteCurrentSession() {
+        return _deleteCurrentSession.apply(this, arguments);
+      }
+      return deleteCurrentSession;
+    }()
+  }, {
+    key: "ensureAnonymousSession",
+    value: function () {
+      var _ensureAnonymousSession = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10() {
+        var forceReplace,
+          _args10 = arguments;
+        return _regeneratorRuntime().wrap(function _callee10$(_context10) {
+          while (1) switch (_context10.prev = _context10.next) {
+            case 0:
+              forceReplace = _args10.length > 0 && _args10[0] !== undefined ? _args10[0] : false;
+              if (this.state.currentUser) {
+                _context10.next = 4;
+                break;
+              }
+              _context10.next = 4;
+              return this.tryCacheCurrentSession();
+            case 4:
+              if (!(!forceReplace && this.state.currentUser && this.state.currentSessionProvider === 'anonymous')) {
+                _context10.next = 7;
+                break;
+              }
+              this.state.confirmedQmuseUserId = null;
+              return _context10.abrupt("return");
+            case 7:
+              _context10.next = 9;
+              return this.deleteCurrentSession();
+            case 9:
+              _context10.next = 11;
+              return this.options.account.createAnonymousSession();
+            case 11:
+              _context10.next = 13;
+              return this.cacheCurrentSession();
+            case 13:
+              this.state.confirmedQmuseUserId = null;
+            case 14:
+            case "end":
+              return _context10.stop();
+          }
+        }, _callee10, this);
+      }));
+      function ensureAnonymousSession() {
+        return _ensureAnonymousSession.apply(this, arguments);
+      }
+      return ensureAnonymousSession;
+    }()
+  }, {
+    key: "requestCustomToken",
+    value: function () {
+      var _requestCustomToken = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11() {
+        var runtime, config, response, payload, data;
+        return _regeneratorRuntime().wrap(function _callee11$(_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
+            case 0:
+              runtime = this.getMuseRuntime();
+              config = this.requireRuntimeConfig();
+              _context11.next = 4;
+              return this.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 = _context11.sent;
+              if (!(response.status === 401)) {
+                _context11.next = 7;
+                break;
+              }
+              return _context11.abrupt("return", null);
+            case 7:
+              _context11.next = 9;
+              return readResponsePayload(response);
+            case 9:
+              payload = _context11.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)) {
+                _context11.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)) {
+                _context11.next = 15;
+                break;
+              }
+              throw new Error('Custom token response is incomplete');
+            case 15:
+              return _context11.abrupt("return", {
+                userId: data.userId,
+                secret: data.secret
+              });
+            case 16:
+            case "end":
+              return _context11.stop();
+          }
+        }, _callee11, this);
+      }));
+      function requestCustomToken() {
+        return _requestCustomToken.apply(this, arguments);
+      }
+      return requestCustomToken;
+    }()
+  }, {
+    key: "ensureAuthenticatedSession",
+    value: function () {
+      var _ensureAuthenticatedSession = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12(_ref2) {
+        var qmuseUserId, userId, secret, _ref2$forceReplace, forceReplace;
+        return _regeneratorRuntime().wrap(function _callee12$(_context12) {
+          while (1) switch (_context12.prev = _context12.next) {
+            case 0:
+              qmuseUserId = _ref2.qmuseUserId, userId = _ref2.userId, secret = _ref2.secret, _ref2$forceReplace = _ref2.forceReplace, forceReplace = _ref2$forceReplace === void 0 ? false : _ref2$forceReplace;
+              if (this.state.currentUser) {
+                _context12.next = 4;
+                break;
+              }
+              _context12.next = 4;
+              return this.tryCacheCurrentSession();
+            case 4:
+              if (!(!forceReplace && this.state.currentUser && this.state.currentSessionProvider !== 'anonymous' && this.state.currentUser.$id === userId)) {
+                _context12.next = 7;
+                break;
+              }
+              this.state.confirmedQmuseUserId = qmuseUserId;
+              return _context12.abrupt("return");
+            case 7:
+              _context12.next = 9;
+              return this.deleteCurrentSession();
+            case 9:
+              _context12.next = 11;
+              return this.options.account.createSession({
+                userId: userId,
+                secret: secret
+              });
+            case 11:
+              _context12.next = 13;
+              return this.cacheCurrentSession();
+            case 13:
+              this.state.confirmedQmuseUserId = qmuseUserId;
+            case 14:
+            case "end":
+              return _context12.stop();
+          }
+        }, _callee12, this);
+      }));
+      function ensureAuthenticatedSession(_x2) {
+        return _ensureAuthenticatedSession.apply(this, arguments);
+      }
+      return ensureAuthenticatedSession;
+    }()
+  }, {
+    key: "coordinateSession",
+    value: function () {
+      var _coordinateSession = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee13() {
+        var force,
+          qmuseUserId,
+          sessionMatchesRuntime,
+          token,
+          _args13 = arguments;
+        return _regeneratorRuntime().wrap(function _callee13$(_context13) {
+          while (1) switch (_context13.prev = _context13.next) {
+            case 0:
+              force = _args13.length > 0 && _args13[0] !== undefined ? _args13[0] : false;
+              qmuseUserId = this.options.getQmuseLoginUserId();
+              sessionMatchesRuntime = this.state.currentUser !== null && (qmuseUserId ? this.state.currentSessionProvider !== 'anonymous' && this.state.confirmedQmuseUserId === qmuseUserId : this.state.currentSessionProvider === 'anonymous' && this.state.confirmedQmuseUserId === null);
+              if (!(!force && sessionMatchesRuntime)) {
+                _context13.next = 5;
+                break;
+              }
+              return _context13.abrupt("return");
+            case 5:
+              if (this.state.currentUser) {
+                _context13.next = 8;
+                break;
+              }
+              _context13.next = 8;
+              return this.tryCacheCurrentSession();
+            case 8:
+              if (qmuseUserId) {
+                _context13.next = 12;
+                break;
+              }
+              _context13.next = 11;
+              return this.ensureAnonymousSession(force);
+            case 11:
+              return _context13.abrupt("return");
+            case 12:
+              if (!(!force && this.state.currentUser && this.state.currentSessionProvider !== 'anonymous' && this.state.confirmedQmuseUserId === qmuseUserId)) {
+                _context13.next = 14;
+                break;
+              }
+              return _context13.abrupt("return");
+            case 14:
+              _context13.next = 16;
+              return this.requestCustomToken();
+            case 16:
+              token = _context13.sent;
+              if (token) {
+                _context13.next = 21;
+                break;
+              }
+              _context13.next = 20;
+              return this.ensureAnonymousSession(force);
+            case 20:
+              return _context13.abrupt("return");
+            case 21:
+              _context13.next = 23;
+              return this.ensureAuthenticatedSession(_objectSpread(_objectSpread({
+                qmuseUserId: qmuseUserId
+              }, token), {}, {
+                forceReplace: force
+              }));
+            case 23:
+            case "end":
+              return _context13.stop();
+          }
+        }, _callee13, this);
+      }));
+      function coordinateSession() {
+        return _coordinateSession.apply(this, arguments);
+      }
+      return coordinateSession;
+    }()
+  }, {
+    key: "synchronizeSession",
+    value: function synchronizeSession() {
+      var _this3 = this;
+      if (!this.sessionSyncPromise) {
+        this.sessionSyncPromise = this.coordinateSession().finally(function () {
+          _this3.sessionSyncPromise = null;
+        });
+      }
+      return this.sessionSyncPromise;
+    }
+  }, {
+    key: "initialize",
+    value: function () {
+      var _initialize = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee14() {
+        var config;
+        return _regeneratorRuntime().wrap(function _callee14$(_context14) {
+          while (1) switch (_context14.prev = _context14.next) {
+            case 0:
+              _context14.next = 2;
+              return this.loadRuntimeConfig();
+            case 2:
+              config = _context14.sent;
+              this.options.client.setEndpoint(config.endpoint).setProject(config.projectId);
+              this.state.runtimeConfig = config;
+              _context14.next = 7;
+              return this.synchronizeSession();
+            case 7:
+            case "end":
+              return _context14.stop();
+          }
+        }, _callee14, this);
+      }));
+      function initialize() {
+        return _initialize.apply(this, arguments);
+      }
+      return initialize;
+    }()
+  }]);
+  return AppwriteSessionCoordinator;
+}();

package/dist/runtime/MutationAuditReporter.d.ts

@@ -0,0 +1,18 @@
+import type { BusinessRowData, QmuseRuntimeContext } from '../types';
+type MutationOperation = 'create' | 'update' | 'delete';
+interface MutationContext {
+    operation: MutationOperation;
+    tableId: string;
+    rowId: string;
+    mutationData?: BusinessRowData;
+}
+export declare class MutationAuditReporter {
+    private readonly request;
+    private readonly getMuseRuntime;
+    constructor(request: typeof globalThis.fetch, getMuseRuntime: () => QmuseRuntimeContext);
+    observe<T>({ operation, tableId, rowId, mutationData, task, }: MutationContext & {
+        task: () => Promise<T>;
+    }): Promise<T>;
+    private schedule;
+}
+export {};