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

package/dist/runtime/MutationAuditReporter.js

@@ -0,0 +1,110 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+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 { getErrorCode } from "./utils";
+export var MutationAuditReporter = /*#__PURE__*/function () {
+  function MutationAuditReporter(request, getMuseRuntime) {
+    _classCallCheck(this, MutationAuditReporter);
+    this.request = request;
+    this.getMuseRuntime = getMuseRuntime;
+  }
+  _createClass(MutationAuditReporter, [{
+    key: "observe",
+    value: function () {
+      var _observe = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref) {
+        var operation, tableId, rowId, mutationData, task, startedAt, result, _getErrorCode;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              operation = _ref.operation, tableId = _ref.tableId, rowId = _ref.rowId, mutationData = _ref.mutationData, task = _ref.task;
+              startedAt = Date.now();
+              _context.prev = 2;
+              _context.next = 5;
+              return task();
+            case 5:
+              result = _context.sent;
+              this.schedule({
+                operation: operation,
+                tableId: tableId,
+                rowId: rowId,
+                outcome: 'success',
+                durationMs: Date.now() - startedAt,
+                mutationData: mutationData
+              });
+              return _context.abrupt("return", result);
+            case 10:
+              _context.prev = 10;
+              _context.t0 = _context["catch"](2);
+              this.schedule({
+                operation: operation,
+                tableId: tableId,
+                rowId: rowId,
+                outcome: 'failure',
+                durationMs: Date.now() - startedAt,
+                errorCode: (_getErrorCode = getErrorCode(_context.t0)) !== null && _getErrorCode !== void 0 ? _getErrorCode : undefined,
+                mutationData: mutationData
+              });
+              throw _context.t0;
+            case 14:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[2, 10]]);
+      }));
+      function observe(_x) {
+        return _observe.apply(this, arguments);
+      }
+      return observe;
+    }()
+  }, {
+    key: "schedule",
+    value: function schedule(_ref2) {
+      var _this = this;
+      var operation = _ref2.operation,
+        tableId = _ref2.tableId,
+        rowId = _ref2.rowId,
+        outcome = _ref2.outcome,
+        durationMs = _ref2.durationMs,
+        errorCode = _ref2.errorCode,
+        mutationData = _ref2.mutationData;
+      try {
+        var runtime = this.getMuseRuntime();
+        globalThis.setTimeout(function () {
+          try {
+            void Promise.resolve(_this.request(new URL('/api/runtime/appwrite/mutation-events', runtime.domain).toString(), {
+              method: 'POST',
+              credentials: 'include',
+              keepalive: true,
+              headers: {
+                'Content-Type': 'application/json'
+              },
+              body: JSON.stringify(_objectSpread(_objectSpread({
+                schemaVersion: 1,
+                operation: operation,
+                outcome: outcome,
+                appId: runtime.appId,
+                env: runtime.env,
+                tableId: tableId,
+                rowId: rowId,
+                durationMs: durationMs
+              }, errorCode === undefined ? {} : {
+                errorCode: errorCode
+              }), mutationData === undefined ? {} : {
+                mutationData: mutationData
+              }))
+            })).catch(function () {
+              return undefined;
+            });
+          } catch (_unused) {
+            // Security telemetry is best-effort and cannot alter mutation semantics.
+          }
+        }, 0);
+      } catch (_unused2) {
+        // Security telemetry is best-effort and cannot alter mutation semantics.
+      }
+    }
+  }]);
+  return MutationAuditReporter;
+}();

package/dist/runtime/QmuseAppwriteRuntime.d.ts

@@ -0,0 +1,22 @@
+import type { QmuseAppwriteRuntimeApi, QmuseAppwriteRuntimeOptions } from '../types';
+export declare class QmuseAppwriteRuntime implements QmuseAppwriteRuntimeApi {
+    private readonly options;
+    readonly init: QmuseAppwriteRuntimeApi['init'];
+    readonly getClients: QmuseAppwriteRuntimeApi['getClients'];
+    readonly getCurrentUser: QmuseAppwriteRuntimeApi['getCurrentUser'];
+    readonly refreshSession: QmuseAppwriteRuntimeApi['refreshSession'];
+    readonly listRows: QmuseAppwriteRuntimeApi['listRows'];
+    readonly getRow: QmuseAppwriteRuntimeApi['getRow'];
+    readonly createRow: QmuseAppwriteRuntimeApi['createRow'];
+    readonly updateRow: QmuseAppwriteRuntimeApi['updateRow'];
+    readonly deleteRow: QmuseAppwriteRuntimeApi['deleteRow'];
+    private readonly session;
+    private readonly auditReporter;
+    constructor(options: QmuseAppwriteRuntimeOptions);
+    private getClientsInternal;
+    private listRowsInternal;
+    private getRowInternal;
+    private createRowInternal;
+    private updateRowInternal;
+    private deleteRowInternal;
+}

package/dist/runtime/QmuseAppwriteRuntime.js

@@ -0,0 +1,321 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+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 { ID, Permission, Query, Role } from 'appwrite';
+import { AppwriteSessionCoordinator } from "./AppwriteSessionCoordinator";
+import { MutationAuditReporter } from "./MutationAuditReporter";
+import { sanitizeBusinessRowData, sanitizeMutationAuditData } from "./rowData";
+import { createFetchRequest, isRecord, observePublicPromise } from "./utils";
+export var QmuseAppwriteRuntime = /*#__PURE__*/function () {
+  function QmuseAppwriteRuntime(options) {
+    var _this = this;
+    _classCallCheck(this, QmuseAppwriteRuntime);
+    _defineProperty(this, "init", void 0);
+    _defineProperty(this, "getClients", void 0);
+    _defineProperty(this, "getCurrentUser", void 0);
+    _defineProperty(this, "refreshSession", void 0);
+    _defineProperty(this, "listRows", void 0);
+    _defineProperty(this, "getRow", void 0);
+    _defineProperty(this, "createRow", void 0);
+    _defineProperty(this, "updateRow", void 0);
+    _defineProperty(this, "deleteRow", void 0);
+    _defineProperty(this, "session", void 0);
+    _defineProperty(this, "auditReporter", void 0);
+    this.options = options;
+    var request = createFetchRequest(options.fetch);
+    this.session = new AppwriteSessionCoordinator(options, request);
+    this.auditReporter = new MutationAuditReporter(request, function () {
+      return options.getMuseRuntime();
+    });
+    this.init = observePublicPromise(function () {
+      return _this.session.init();
+    });
+    this.getClients = observePublicPromise(function () {
+      return _this.getClientsInternal();
+    });
+    this.getCurrentUser = observePublicPromise(function () {
+      return _this.session.getCurrentUser();
+    });
+    this.refreshSession = observePublicPromise(function () {
+      return _this.session.refreshSession();
+    });
+    this.listRows = observePublicPromise(function (input) {
+      return _this.listRowsInternal(input);
+    });
+    this.getRow = observePublicPromise(function (input) {
+      return _this.getRowInternal(input);
+    });
+    this.createRow = observePublicPromise(function (input) {
+      return _this.createRowInternal(input);
+    });
+    this.updateRow = observePublicPromise(function (input) {
+      return _this.updateRowInternal(input);
+    });
+    this.deleteRow = observePublicPromise(function (input) {
+      return _this.deleteRowInternal(input);
+    });
+    void this.init();
+  }
+  _createClass(QmuseAppwriteRuntime, [{
+    key: "getClientsInternal",
+    value: function () {
+      var _getClientsInternal = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        var databaseId;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return this.session.getDatabaseId();
+            case 2:
+              databaseId = _context.sent;
+              return _context.abrupt("return", {
+                client: this.options.client,
+                account: this.options.account,
+                tablesDB: this.options.tablesDB,
+                databaseId: databaseId
+              });
+            case 4:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function getClientsInternal() {
+        return _getClientsInternal.apply(this, arguments);
+      }
+      return getClientsInternal;
+    }()
+  }, {
+    key: "listRowsInternal",
+    value: function () {
+      var _listRowsInternal = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(_ref) {
+        var _this2 = this;
+        var tableId, _ref$queries, queries, _ref$limit, limit, cursor, _yield$this$getClient, databaseId;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              tableId = _ref.tableId, _ref$queries = _ref.queries, queries = _ref$queries === void 0 ? [] : _ref$queries, _ref$limit = _ref.limit, limit = _ref$limit === void 0 ? 20 : _ref$limit, cursor = _ref.cursor;
+              if (!(!Number.isInteger(limit) || limit < 1 || limit > 20)) {
+                _context2.next = 3;
+                break;
+              }
+              throw new RangeError('listRows limit must be an integer from 1 to 20');
+            case 3:
+              _context2.next = 5;
+              return this.getClientsInternal();
+            case 5:
+              _yield$this$getClient = _context2.sent;
+              databaseId = _yield$this$getClient.databaseId;
+              return _context2.abrupt("return", this.session.withSessionRetry(function () {
+                return _this2.options.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 _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function listRowsInternal(_x) {
+        return _listRowsInternal.apply(this, arguments);
+      }
+      return listRowsInternal;
+    }()
+  }, {
+    key: "getRowInternal",
+    value: function () {
+      var _getRowInternal = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(_ref2) {
+        var _this3 = this;
+        var tableId, rowId, _yield$this$getClient2, databaseId;
+        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              tableId = _ref2.tableId, rowId = _ref2.rowId;
+              _context3.next = 3;
+              return this.getClientsInternal();
+            case 3:
+              _yield$this$getClient2 = _context3.sent;
+              databaseId = _yield$this$getClient2.databaseId;
+              return _context3.abrupt("return", this.session.withSessionRetry(function () {
+                return _this3.options.tablesDB.getRow({
+                  databaseId: databaseId,
+                  tableId: tableId,
+                  rowId: rowId
+                });
+              }));
+            case 6:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function getRowInternal(_x2) {
+        return _getRowInternal.apply(this, arguments);
+      }
+      return getRowInternal;
+    }()
+  }, {
+    key: "createRowInternal",
+    value: function () {
+      var _createRowInternal = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(_ref3) {
+        var _this4 = this;
+        var tableId, data, _ref3$rowId, rowId, _yield$this$getClient3, databaseId, mutationData;
+        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              tableId = _ref3.tableId, data = _ref3.data, _ref3$rowId = _ref3.rowId, rowId = _ref3$rowId === void 0 ? ID.unique() : _ref3$rowId;
+              _context4.next = 3;
+              return this.getClientsInternal();
+            case 3:
+              _yield$this$getClient3 = _context4.sent;
+              databaseId = _yield$this$getClient3.databaseId;
+              mutationData = sanitizeBusinessRowData(data);
+              return _context4.abrupt("return", this.auditReporter.observe({
+                operation: 'create',
+                tableId: tableId,
+                rowId: rowId,
+                mutationData: sanitizeMutationAuditData(mutationData),
+                task: function task() {
+                  return _this4.session.withSessionRetry(function () {
+                    var currentUserId = _this4.session.requireCurrentUser().$id;
+                    var owner = Role.user(currentUserId);
+                    return _this4.options.tablesDB.createRow({
+                      databaseId: databaseId,
+                      tableId: tableId,
+                      rowId: rowId,
+                      data: _objectSpread(_objectSpread({}, mutationData), {}, {
+                        creatorId: currentUserId,
+                        modifierId: currentUserId
+                      }),
+                      permissions: [Permission.read(owner), Permission.update(owner), Permission.delete(owner)]
+                    });
+                  });
+                }
+              }));
+            case 7:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function createRowInternal(_x3) {
+        return _createRowInternal.apply(this, arguments);
+      }
+      return createRowInternal;
+    }()
+  }, {
+    key: "updateRowInternal",
+    value: function () {
+      var _updateRowInternal = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(_ref4) {
+        var _this5 = this;
+        var tableId, rowId, data, _yield$this$getClient4, databaseId, mutationData;
+        return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              tableId = _ref4.tableId, rowId = _ref4.rowId, data = _ref4.data;
+              _context5.next = 3;
+              return this.getClientsInternal();
+            case 3:
+              _yield$this$getClient4 = _context5.sent;
+              databaseId = _yield$this$getClient4.databaseId;
+              mutationData = sanitizeBusinessRowData(data);
+              return _context5.abrupt("return", this.auditReporter.observe({
+                operation: 'update',
+                tableId: tableId,
+                rowId: rowId,
+                mutationData: sanitizeMutationAuditData(mutationData),
+                task: function task() {
+                  return _this5.session.withSessionRetry(function () {
+                    return _this5.options.tablesDB.updateRow({
+                      databaseId: databaseId,
+                      tableId: tableId,
+                      rowId: rowId,
+                      data: _objectSpread(_objectSpread({}, mutationData), {}, {
+                        modifierId: _this5.session.requireCurrentUser().$id
+                      })
+                    });
+                  });
+                }
+              }));
+            case 7:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function updateRowInternal(_x4) {
+        return _updateRowInternal.apply(this, arguments);
+      }
+      return updateRowInternal;
+    }()
+  }, {
+    key: "deleteRowInternal",
+    value: function () {
+      var _deleteRowInternal = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(_ref5) {
+        var _this6 = this;
+        var tableId, rowId, _yield$this$getClient5, databaseId, mutationData, existingRow;
+        return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              tableId = _ref5.tableId, rowId = _ref5.rowId;
+              _context6.next = 3;
+              return this.getClientsInternal();
+            case 3:
+              _yield$this$getClient5 = _context6.sent;
+              databaseId = _yield$this$getClient5.databaseId;
+              _context6.prev = 5;
+              _context6.next = 8;
+              return this.session.withSessionRetry(function () {
+                return _this6.options.tablesDB.getRow({
+                  databaseId: databaseId,
+                  tableId: tableId,
+                  rowId: rowId
+                });
+              });
+            case 8:
+              existingRow = _context6.sent;
+              if (isRecord(existingRow)) {
+                mutationData = sanitizeMutationAuditData(sanitizeBusinessRowData(existingRow));
+              }
+              _context6.next = 14;
+              break;
+            case 12:
+              _context6.prev = 12;
+              _context6.t0 = _context6["catch"](5);
+            case 14:
+              return _context6.abrupt("return", this.auditReporter.observe({
+                operation: 'delete',
+                tableId: tableId,
+                rowId: rowId,
+                mutationData: mutationData,
+                task: function task() {
+                  return _this6.session.withSessionRetry(function () {
+                    return _this6.options.tablesDB.deleteRow({
+                      databaseId: databaseId,
+                      tableId: tableId,
+                      rowId: rowId
+                    });
+                  });
+                }
+              }));
+            case 15:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this, [[5, 12]]);
+      }));
+      function deleteRowInternal(_x5) {
+        return _deleteRowInternal.apply(this, arguments);
+      }
+      return deleteRowInternal;
+    }()
+  }]);
+  return QmuseAppwriteRuntime;
+}();

package/dist/runtime/rowData.d.ts

@@ -0,0 +1,3 @@
+import type { BusinessRowData } from '../types';
+export declare function sanitizeBusinessRowData(data: BusinessRowData): BusinessRowData;
+export declare function sanitizeMutationAuditData(data: BusinessRowData): BusinessRowData;

package/dist/runtime/rowData.js

@@ -0,0 +1,60 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { isRecord } from "./utils";
+var BLOCKED_MUTATION_FIELDS = new Set(['code', 'creatorId', 'modifierId', 'gmtCreate', 'gmtModified']);
+var SENSITIVE_AUDIT_FIELD_PATTERN = /(?:password|passwd|secret|token|authorization|cookie|api[-_]?key|access[-_]?key|private[-_]?key)/i;
+var REDACTED_AUDIT_VALUE = '[REDACTED]';
+var MAX_AUDIT_DEPTH = 5;
+var MAX_AUDIT_KEYS = 100;
+var MAX_AUDIT_ARRAY_ITEMS = 100;
+var MAX_AUDIT_STRING_LENGTH = 2048;
+export function sanitizeBusinessRowData(data) {
+  return Object.fromEntries(Object.entries(data).filter(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 1),
+      key = _ref2[0];
+    return !key.startsWith('$') && !BLOCKED_MUTATION_FIELDS.has(key);
+  }));
+}
+function sanitizeAuditValue(value, depth, ancestors) {
+  if (typeof value === 'string') {
+    return value.length > MAX_AUDIT_STRING_LENGTH ? "".concat(value.slice(0, MAX_AUDIT_STRING_LENGTH), "[TRUNCATED]") : value;
+  }
+  if (depth >= MAX_AUDIT_DEPTH && (Array.isArray(value) || isRecord(value))) {
+    return '[MAX_DEPTH]';
+  }
+  if (Array.isArray(value)) {
+    if (ancestors.has(value)) {
+      return '[CIRCULAR]';
+    }
+    ancestors.add(value);
+    var _result = value.slice(0, MAX_AUDIT_ARRAY_ITEMS).map(function (item) {
+      return sanitizeAuditValue(item, depth + 1, ancestors);
+    });
+    ancestors.delete(value);
+    if (value.length > MAX_AUDIT_ARRAY_ITEMS) {
+      _result.push('[TRUNCATED]');
+    }
+    return _result;
+  }
+  if (!isRecord(value)) {
+    return value;
+  }
+  if (ancestors.has(value)) {
+    return '[CIRCULAR]';
+  }
+  ancestors.add(value);
+  var entries = Object.entries(value).slice(0, MAX_AUDIT_KEYS);
+  var result = Object.fromEntries(entries.map(function (_ref3) {
+    var _ref4 = _slicedToArray(_ref3, 2),
+      key = _ref4[0],
+      childValue = _ref4[1];
+    return [key, SENSITIVE_AUDIT_FIELD_PATTERN.test(key) ? REDACTED_AUDIT_VALUE : sanitizeAuditValue(childValue, depth + 1, ancestors)];
+  }));
+  ancestors.delete(value);
+  if (Object.keys(value).length > MAX_AUDIT_KEYS) {
+    result.__auditTruncated = true;
+  }
+  return result;
+}
+export function sanitizeMutationAuditData(data) {
+  return sanitizeAuditValue(data, 0, new WeakSet());
+}

package/dist/runtime/utils.d.ts

@@ -0,0 +1,11 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function getErrorCode(error: unknown): number | null;
+export declare function createResponseError({ payload, status, fallbackMessage, fallbackType, }: {
+    payload: Record<string, unknown> | null;
+    status: number;
+    fallbackMessage: string;
+    fallbackType: string;
+}): Error;
+export declare function readResponsePayload(response: Response): Promise<Record<string, unknown> | null>;
+export declare function createFetchRequest(configuredFetch?: typeof globalThis.fetch): typeof globalThis.fetch;
+export declare function observePublicPromise<TArgs extends unknown[], TResult>(operation: (...args: TArgs) => Promise<TResult>): (...args: TArgs) => Promise<TResult>;

package/dist/runtime/utils.js

@@ -0,0 +1,68 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+export function isRecord(value) {
+  return Boolean(value) && _typeof(value) === 'object' && !Array.isArray(value);
+}
+export function getErrorCode(error) {
+  if (!isRecord(error)) {
+    return null;
+  }
+  var code = Number(error.code);
+  return Number.isFinite(code) ? code : null;
+}
+export 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;
+}
+export function readResponsePayload(_x) {
+  return _readResponsePayload.apply(this, arguments);
+}
+function _readResponsePayload() {
+  _readResponsePayload = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(response) {
+    var payload;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return response.json().catch(function () {
+            return null;
+          });
+        case 2:
+          payload = _context.sent;
+          return _context.abrupt("return", isRecord(payload) ? payload : null);
+        case 4:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _readResponsePayload.apply(this, arguments);
+}
+export function createFetchRequest(configuredFetch) {
+  return function (input, init) {
+    var fetchImplementation = configuredFetch !== null && configuredFetch !== void 0 ? configuredFetch : globalThis.fetch;
+    if (!fetchImplementation) {
+      return Promise.reject(new Error('A fetch implementation is required'));
+    }
+    return fetchImplementation(input, init);
+  };
+}
+export function observePublicPromise(operation) {
+  return function () {
+    var promise = operation.apply(void 0, arguments);
+    void promise.catch(function () {
+      return undefined;
+    });
+    return promise;
+  };
+}

package/dist/runtime.d.ts

@@ -1,31 +1,2 @@
-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>;
-};
+import type { QmuseAppwriteRuntimeApi, QmuseAppwriteRuntimeOptions } from './types';
+export declare function createQmuseAppwriteRuntime(options: QmuseAppwriteRuntimeOptions): QmuseAppwriteRuntimeApi;