@poolse/sdk 1.0.0-beta.0 → 1.0.0-rc.0

package/README.md

@@ -48,12 +48,14 @@ chat.destroy();
 
 ## What it covers
 
-- **REST resources**: `me`, `conversations` (incl. members), `messages` (send / edit / delete / replies / reactions / mark-read), `attachments` (presigned upload + download + delete).
+- **REST resources**: `me`, `conversations` (incl. members), `messages` (send / edit / delete / replies / reactions / mark-read / quote-replies), `attachments` (presigned upload + download + delete with upload progress), `users` (customer-supplied profile cache).
 - **Realtime channels**: `message:new`, `message:updated`, `message:deleted`, `typing:start/stop`, `reaction:added/removed`, presence state + diff, per-user `mention:new` + `conversation:created`.
 - **Token caching** — `getToken` is called once per JWT lifetime, not per request. Auto-invalidates on 401 and re-issues.
 - **Idempotency** — every non-GET request carries an auto-generated `Idempotency-Key`, so retries (network or 5xx) never insert duplicates.
 - **Backoff** — exponential with full jitter, honors `Retry-After` on 429, never retries `AbortError`.
 - **Typed errors** — `AuthError` / `ApiError` / `NetworkError` / `RateLimitedError`, all `instanceof`-checkable.
+- **Upload progress** — pass `onProgress` to `attachments.upload(...)` and the SDK switches to XHR for the PUT so byte-level progress events fire during the upload to your storage backend.
+- **User resolution** — pass `userResolver(userId)` and `chat.users.get(userId)` returns customer-supplied `{ displayName, avatarUrl }` (in-memory cached + dedup'd). The React UI components pick this up automatically; vanilla callers can read it directly.
 
 ## Architecture pattern
 

package/dist/index.cjs

@@ -28,7 +28,8 @@ function resolveConfig(config) {
     generateIdempotencyKey: config.generateIdempotencyKey ?? defaultIdempotencyKey,
     wsUrl: config.wsUrl,
     socketPath: config.socketPath ?? "/socket",
-    onSocketError: config.onSocketError
+    onSocketError: config.onSocketError,
+    userResolver: config.userResolver
   };
 }
 function trimTrailingSlash(s) {
@@ -420,6 +421,14 @@ var AttachmentsResource = class {
       ...input.filename !== void 0 ? { original_filename: input.filename } : {}
     };
     const { attachment, upload } = await this.requestUpload(req, opts);
+    if (opts.onProgress && typeof XMLHttpRequest !== "undefined") {
+      await xhrPut(upload.url, upload.method.toUpperCase(), upload.headers, input.body, {
+        byteSize: input.byteSize,
+        onProgress: opts.onProgress,
+        ...opts.signal ? { signal: opts.signal } : {}
+      });
+      return attachment;
+    }
     const putInit = {
       method: upload.method.toUpperCase(),
       headers: upload.headers,
@@ -471,6 +480,39 @@ var AttachmentHandle = class {
     });
   }
 };
+function xhrPut(url, method, headers, body, opts) {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open(method, url);
+    for (const [k, v] of Object.entries(headers)) {
+      try {
+        xhr.setRequestHeader(k, v);
+      } catch {
+      }
+    }
+    xhr.upload.onprogress = (e) => {
+      const total = e.lengthComputable ? e.total : opts.byteSize;
+      opts.onProgress({ loaded: e.loaded, total });
+    };
+    xhr.onload = () => {
+      if (xhr.status >= 200 && xhr.status < 300) resolve();
+      else
+        reject(new Error(`Poolse: presigned upload PUT failed (${xhr.status} ${xhr.statusText})`));
+    };
+    xhr.onerror = () => reject(new Error("Poolse: presigned upload PUT failed (network error)"));
+    xhr.onabort = () => {
+      reject(new DOMException("Upload aborted", "AbortError"));
+    };
+    if (opts.signal) {
+      if (opts.signal.aborted) {
+        xhr.abort();
+        return;
+      }
+      opts.signal.addEventListener("abort", () => xhr.abort(), { once: true });
+    }
+    xhr.send(body);
+  });
+}
 
 // src/resources/messages.ts
 var ConversationMessages = class {
@@ -723,6 +765,100 @@ var MeResource = class {
   }
 };
 
+// src/resources/users.ts
+var UsersResource = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  cache = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Map();
+  /**
+   * Get the cached value if present. Returns `undefined` to mean
+   * "not in cache yet" (different from `null`, which means "resolver
+   * ran and the user wasn't found").
+   */
+  peek(userId) {
+    return this.cache.get(userId);
+  }
+  /**
+   * Resolve a user, hitting the customer's `userResolver` on cache
+   * miss. Concurrent calls for the same id share one Promise.
+   */
+  async get(userId) {
+    if (this.cache.has(userId)) {
+      return this.cache.get(userId) ?? null;
+    }
+    const existingPending = this.pending.get(userId);
+    if (existingPending) return existingPending;
+    const resolver = this.config.userResolver;
+    if (!resolver) {
+      this.cache.set(userId, null);
+      this.notify(userId);
+      return null;
+    }
+    const promise = Promise.resolve().then(() => resolver(userId)).then(
+      (profile) => {
+        this.cache.set(userId, profile ?? null);
+        this.pending.delete(userId);
+        this.notify(userId);
+        return profile ?? null;
+      },
+      (err) => {
+        console.error("[poolse] userResolver failed for", userId, err);
+        this.cache.set(userId, null);
+        this.pending.delete(userId);
+        this.notify(userId);
+        return null;
+      }
+    );
+    this.pending.set(userId, promise);
+    return promise;
+  }
+  /**
+   * Subscribe to changes for a single user id. The listener fires
+   * when the resolver lands (or when the entry is invalidated).
+   * Returns an unsubscribe.
+   *
+   * `useUser` in @poolse/react uses this with `useSyncExternalStore`.
+   */
+  subscribe(userId, listener) {
+    let set = this.listeners.get(userId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(userId, set);
+    }
+    set.add(listener);
+    return () => {
+      set?.delete(listener);
+    };
+  }
+  /** Drop a single cached entry — next `get` re-fetches via the resolver. */
+  invalidate(userId) {
+    this.cache.delete(userId);
+    this.pending.delete(userId);
+    this.notify(userId);
+  }
+  /**
+   * Drop the entire cache. Use after a sign-out, tenant swap, or any
+   * other event that invalidates every cached profile (e.g., the
+   * customer just renamed every user in bulk).
+   */
+  invalidateAll() {
+    this.cache.clear();
+    this.pending.clear();
+    for (const userId of this.listeners.keys()) {
+      this.notify(userId);
+    }
+  }
+  notify(userId) {
+    const set = this.listeners.get(userId);
+    if (!set) return;
+    for (const l of set) l();
+  }
+};
+
 // src/rest-client.ts
 var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET"]);
 var RestClient = class {
@@ -944,6 +1080,17 @@ var Poolse = class {
   messages;
   /** `/v1/attachments/*` — presigned-URL uploads/downloads. */
   attachments;
+  /**
+   * Customer-supplied user metadata, cached + dedup'd.
+   * `chat.users.get(userId)` returns `{ displayName, avatarUrl }`
+   * via the optional `config.userResolver`. UI components
+   * (`MessageBubble`, `MemberList`, `TypingIndicator`) pick this up
+   * automatically via the `useUser` hook in `@poolse/react`.
+   *
+   * If no resolver is configured, `get` always returns `null` and
+   * UI falls back to the userId slice + initials avatar.
+   */
+  users;
   /**
    * Low-level REST client. Exposed for advanced use cases (custom endpoints,
    * raw retry/headers control). Most callers should use the resources above.
@@ -971,6 +1118,7 @@ var Poolse = class {
     this.conversations = new ConversationsResource(this.rest);
     this.messages = new MessagesResource(this.rest);
     this.attachments = new AttachmentsResource(this.rest, cachedConfig.fetch);
+    this.users = new UsersResource(cachedConfig);
     this.realtime = new PoolseRealtime(cachedConfig, this.tokenCache, {
       ...this.resolved.wsUrl !== void 0 ? { wsUrl: this.resolved.wsUrl } : {},
       socketPath: this.resolved.socketPath
@@ -988,7 +1136,7 @@ var Poolse = class {
 };
 
 // src/version.ts
-var version = "0.0.1";
+var version = "1.0.0-rc.0";
 
 exports.ApiError = ApiError;
 exports.AttachmentHandle = AttachmentHandle;
@@ -1008,6 +1156,7 @@ exports.PoolseError = PoolseError;
 exports.PoolseRealtime = PoolseRealtime;
 exports.RateLimitedError = RateLimitedError;
 exports.UserChannel = UserChannel;
+exports.UsersResource = UsersResource;
 exports.version = version;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map