@amityco/ts-sdk 7.22.1-fa4a2e0.0 → 7.23.0

package/dist/userRepository/api/getAllBlockedUsers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getAllBlockedUsers.d.ts","sourceRoot":"","sources":["../../../src/userRepository/api/getAllBlockedUsers.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,kBAAkB,QAAa,QAAQ,MAAM,IAAI,EAAE,CAW/D,CAAC"}
+{"version":3,"file":"getAllBlockedUsers.d.ts","sourceRoot":"","sources":["../../../src/userRepository/api/getAllBlockedUsers.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,kBAAkB,QAAa,QAAQ,MAAM,IAAI,EAAE,CAU/D,CAAC"}

package/dist/userRepository/api/getAllBlockingUsers.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ```js
+ * import { UserRepository } from '@amityco/ts-sdk'
+ * const blockingUsers = await UserRepository.getAllBlockingUsers()
+ * ```
+ *
+ * Returns all users who have blocked the current user
+ * non-paginated list (limit 100) with TTL-based caching (5-minute window). Within the
+ * TTL window, subsequent calls resolve instantly from the local store without any
+ * server call. After the TTL expires, the next call triggers a fresh server fetch.
+ *
+ * The directional inverse of {@link getAllBlockedUsers}.
+ *
+ * @returns A promise that resolves to an array of blocking {@link Amity.User} objects
+ *
+ * @category Block API
+ * @async
+ */
+export declare const getAllBlockingUsers: () => Promise<Amity.User[]>;
+//# sourceMappingURL=getAllBlockingUsers.d.ts.map

package/dist/userRepository/api/getAllBlockingUsers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getAllBlockingUsers.d.ts","sourceRoot":"","sources":["../../../src/userRepository/api/getAllBlockingUsers.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,mBAAmB,QAAa,QAAQ,MAAM,IAAI,EAAE,CAWhE,CAAC"}

package/dist/userRepository/api/index.d.ts

@@ -4,4 +4,5 @@ export { flagUser } from './flagUser';
 export { unflagUser } from './unflagUser';
 export { isUserFlaggedByMe } from './isUserFlaggedByMe';
 export { getAllBlockedUsers } from './getAllBlockedUsers';
+export { getAllBlockingUsers } from './getAllBlockingUsers';
 //# sourceMappingURL=index.d.ts.map

package/dist/userRepository/api/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/userRepository/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/userRepository/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/userRepository/api/tests/integration/getAllBlockingUsers.integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=getAllBlockingUsers.integration.test.d.ts.map

package/dist/userRepository/api/tests/integration/getAllBlockingUsers.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getAllBlockingUsers.integration.test.d.ts","sourceRoot":"","sources":["../../../../../src/userRepository/api/tests/integration/getAllBlockingUsers.integration.test.ts"],"names":[],"mappings":""}

package/dist/userRepository/relationship/block/utils/blockRealtimeOnLoginHandler.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Keeps the follow cache current for incoming/outgoing block changes for the
+ * whole session — the ingest happens as a side effect inside
+ * createBlockEventSubscriber, so the one-shot `getAllBlockedUsers()` /
+ * `getAllBlockingUsers()` reflect RTE block/unblock within the TTL window.
+ *
+ * Registered via `setupLoginSubscriptions`; the returned unsubscriber is torn
+ * down on logout.
+ */
+declare const _default: () => Amity.Unsubscriber;
+export default _default;
+//# sourceMappingURL=blockRealtimeOnLoginHandler.d.ts.map

package/dist/userRepository/relationship/block/utils/blockRealtimeOnLoginHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockRealtimeOnLoginHandler.d.ts","sourceRoot":"","sources":["../../../../../src/userRepository/relationship/block/utils/blockRealtimeOnLoginHandler.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;8BACgB,MAAM,YAAY;AAArC,wBAGE"}

package/dist/userRepository/services/BlockedUserSyncEngine/blockedUserSyncEngine.d.ts

@@ -4,19 +4,18 @@
  * `getAllBlockedUsers()` API.
  *
  * Key behaviours:
- * - `establish()` is a no-op — fetch is lazy, triggered only by consumer call
- * - `destroy()` resets `lastFetchedAt` to null (ensures fresh fetch on next session)
+ * - `onSessionEstablished()` is a no-op — fetch is lazy, triggered only by consumer call
+ * - `onSessionDestroyed()` resets `lastFetchedAt` to null (ensures fresh fetch on next session)
  * - `ensureFetched()` fetches from server only when cache is expired or never fetched
  * - `lastFetchedAt` is only updated on successful fetch
- * - `blockedUserIds` is kept in sync with each successful fetch
+ * - reads query the follow cache live, so block/unblock changes are reflected
+ *   even within the TTL window
  *
  * @internal
  */
 declare class BlockedUserSyncEngine {
     /** Epoch ms of last successful fetch. null = never fetched in this session. */
     private lastFetchedAt;
-    /** Ordered list of userId strings from the most recent successful fetch. */
-    private blockedUserIds;
     /** No-op — fetch is lazy, triggered by consumer calling getAllBlockedUsers(). */
     onSessionEstablished(): void;
     /** Resets state so the next session starts with a cold cache. */
@@ -37,16 +36,17 @@ declare class BlockedUserSyncEngine {
      */
     ensureFetched(): Promise<void>;
     /**
-     * Returns blocked {@link Amity.InternalUser} objects from the in-memory cache.
+     * Returns the blocked users by querying the follow cache live — the outgoing
+     * direction (`from === me`, `status === 'blocked'`). Reading the cache (not a
+     * fetched snapshot) means `blockUser()` / `unblockUser()` changes are reflected
+     * even within the TTL window.
      *
-     * Applies the spec-mandated filter:
-     *  - Only users whose `isDeleted` is false or null
-     *  - Hard limit of 100 results
-     *
-     * This always reads the latest local state, so changes made by `blockUser()`
-     * and `unblockUser()` are reflected even within the TTL window.
+     * Applies the spec-mandated query:
+     *  - filter `from === currentUserId`, `status === 'blocked'`, blocked user not deleted
+     *  - sort by `updatedAt` DESC
+     *  - hard limit of 100 results
      */
-    getCachedUsers(): Amity.InternalUser[];
+    getCachedUsers(): Amity.User[];
 }
 declare const _default: {
     getInstance: () => BlockedUserSyncEngine;

package/dist/userRepository/services/BlockedUserSyncEngine/blockedUserSyncEngine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"blockedUserSyncEngine.d.ts","sourceRoot":"","sources":["../../../../src/userRepository/services/BlockedUserSyncEngine/blockedUserSyncEngine.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;GAaG;AACH,cAAM,qBAAqB;IACzB,+EAA+E;IAC/E,OAAO,CAAC,aAAa,CAAuB;IAE5C,4EAA4E;IAC5E,OAAO,CAAC,cAAc,CAAgB;IAMtC,iFAAiF;IAEjF,oBAAoB,IAAI,IAAI;IAI5B,iEAAiE;IACjE,kBAAkB,IAAI,IAAI;IAK1B,6BAA6B;IAE7B,cAAc,IAAI,IAAI;IAQtB,OAAO,CAAC,cAAc;IAStB;;;;;;;;;;OAUG;IACG,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IA6BpC;;;;;;;;;OASG;IACH,cAAc,IAAI,KAAK,CAAC,YAAY,EAAE;CAYvC;;uBASkB,qBAAqB;;AADxC,wBAKE"}
+{"version":3,"file":"blockedUserSyncEngine.d.ts","sourceRoot":"","sources":["../../../../src/userRepository/services/BlockedUserSyncEngine/blockedUserSyncEngine.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;GAcG;AACH,cAAM,qBAAqB;IACzB,+EAA+E;IAC/E,OAAO,CAAC,aAAa,CAAuB;IAE5C,iFAAiF;IAEjF,oBAAoB,IAAI,IAAI;IAI5B,iEAAiE;IACjE,kBAAkB,IAAI,IAAI;IAI1B,6BAA6B;IAE7B,cAAc,IAAI,IAAI;IAItB,OAAO,CAAC,cAAc;IAKtB;;;;;;;;;;OAUG;IACG,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAsBpC;;;;;;;;;;OAUG;IAEH,cAAc,IAAI,KAAK,CAAC,IAAI,EAAE;CAe/B;;uBAKkB,qBAAqB;;AADxC,wBAKE"}

package/dist/userRepository/services/BlockingUserSyncEngine/blockingUserSyncEngine.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Session-scoped singleton engine that manages TTL-based fetching and caching
+ * of blocking users (the "blocked-by" list — users who blocked the current
+ * user). Provides a lazy `ensureFetched()` gate for the `getAllBlockingUsers()`
+ * API. Directional inverse of {@link BlockedUserSyncEngine}.
+ *
+ * Key behaviours:
+ * - `onSessionEstablished()` is a no-op — fetch is lazy, triggered only by consumer call
+ * - `onSessionDestroyed()` resets `lastFetchedAt` to null (ensures fresh fetch on next session)
+ * - `ensureFetched()` fetches from server only when cache is expired or never fetched
+ * - `lastFetchedAt` is only updated on successful fetch
+ * - reads query the follow cache live, so block/unblock changes are reflected
+ *   even within the TTL window
+ *
+ * @internal
+ */
+declare class BlockingUserSyncEngine {
+    /** Epoch ms of last successful fetch. null = never fetched in this session. */
+    private lastFetchedAt;
+    /** No-op — fetch is lazy, triggered by consumer calling getAllBlockingUsers(). */
+    onSessionEstablished(): void;
+    /** Resets state so the next session starts with a cold cache. */
+    onSessionDestroyed(): void;
+    /** No-op for this engine. */
+    onTokenExpired(): void;
+    private isCacheExpired;
+    /**
+     * Ensures the local store is populated with fresh blocking-user data.
+     *
+     * - If the cache is still within the 5-minute TTL window: resolves immediately
+     *   (no server call).
+     * - If the cache is expired (or never fetched): fetches from the server,
+     *   persists the payload to the cache, and updates `lastFetchedAt`.
+     *
+     * On failure the error propagates to the caller and `lastFetchedAt` is NOT
+     * updated, so the next call will retry.
+     */
+    ensureFetched(): Promise<void>;
+    /**
+     * Returns the "blocked-by" users by querying the follow cache live — the
+     * incoming direction (`to === me`, `status === 'blocked'`). Reading the cache
+     * (not a fetched snapshot) means RTE `user.didBlock` / `user.didUnblock`
+     * changes are reflected even within the TTL window.
+     *
+     * Applies the spec-mandated query (REQ-012/013/014):
+     *  - filter `to === currentUserId`, `status === 'blocked'`, blocker not deleted
+     *  - sort by `updatedAt` DESC
+     *  - hard limit of 100 results
+     */
+    getCachedUsers(): Amity.User[];
+}
+declare const _default: {
+    getInstance: () => BlockingUserSyncEngine;
+};
+export default _default;
+//# sourceMappingURL=blockingUserSyncEngine.d.ts.map

package/dist/userRepository/services/BlockingUserSyncEngine/blockingUserSyncEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockingUserSyncEngine.d.ts","sourceRoot":"","sources":["../../../../src/userRepository/services/BlockingUserSyncEngine/blockingUserSyncEngine.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;GAeG;AACH,cAAM,sBAAsB;IAC1B,+EAA+E;IAC/E,OAAO,CAAC,aAAa,CAAuB;IAE5C,kFAAkF;IAElF,oBAAoB,IAAI,IAAI;IAI5B,iEAAiE;IACjE,kBAAkB,IAAI,IAAI;IAI1B,6BAA6B;IAE7B,cAAc,IAAI,IAAI;IAItB,OAAO,CAAC,cAAc;IAKtB;;;;;;;;;;OAUG;IACG,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAsBpC;;;;;;;;;;OAUG;IAEH,cAAc,IAAI,KAAK,CAAC,IAAI,EAAE;CAe/B;;uBAKkB,sBAAsB;;AADzC,wBAKE"}

package/dist/userRepository/services/BlockingUserSyncEngine/blockingUserSyncEngineOnLoginHandler.d.ts

@@ -0,0 +1,3 @@
+declare const _default: () => () => void;
+export default _default;
+//# sourceMappingURL=blockingUserSyncEngineOnLoginHandler.d.ts.map

package/dist/userRepository/services/BlockingUserSyncEngine/blockingUserSyncEngineOnLoginHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockingUserSyncEngineOnLoginHandler.d.ts","sourceRoot":"","sources":["../../../../src/userRepository/services/BlockingUserSyncEngine/blockingUserSyncEngineOnLoginHandler.ts"],"names":[],"mappings":";AAGA,wBAgBE"}

package/dist/utils/tests/dummy/block.d.ts

@@ -25,4 +25,20 @@ export declare const generateBlockedUsers: (...blockedUser: Amity.InternalUser[]
         };
     };
 };
+export declare const generateBlockingUsers: (...blockingUser: Amity.InternalUser[]) => {
+    data: {
+        users: Amity.InternalUser[];
+        files: never[];
+        follows: {
+            status: "blocked";
+            from: string;
+            to: string;
+            createdAt: string;
+            updatedAt: string;
+        }[];
+        paging: {
+            total: number;
+        };
+    };
+};
 //# sourceMappingURL=block.d.ts.map

package/dist/utils/tests/dummy/block.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"block.d.ts","sourceRoot":"","sources":["../../../../src/utils/tests/dummy/block.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB,SAAU,MAAM,YAAY;;;;;CAO3D,CAAC;AAEF,eAAO,MAAM,mBAAmB,cACnB,MAAM,YAAY,UACrB,QAAQ,MAAM,gBAAgB,EAAE,KAAK,CAAC;;;;;;;;;;CAQ/C,CAAC;AAEF,eAAO,MAAM,oBAAoB,mBAAoB,MAAM,YAAY,EAAE;;;;;;;;;CAWxE,CAAC"}
+{"version":3,"file":"block.d.ts","sourceRoot":"","sources":["../../../../src/utils/tests/dummy/block.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB,SAAU,MAAM,YAAY;;;;;CAO3D,CAAC;AAEF,eAAO,MAAM,mBAAmB,cACnB,MAAM,YAAY,UACrB,QAAQ,MAAM,gBAAgB,EAAE,KAAK,CAAC;;;;;;;;;;CAQ/C,CAAC;AAEF,eAAO,MAAM,oBAAoB,mBAAoB,MAAM,YAAY,EAAE;;;;;;;;;CAWxE,CAAC;AAEF,eAAO,MAAM,qBAAqB,oBAAqB,MAAM,YAAY,EAAE;;;;;;;;;;;;;;;CAqB1E,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk",
-  "version": "7.22.1-fa4a2e0.0",
+  "version": "7.23.0",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",