@enterprisestandard/react 0.0.5-beta.20260114.3 → 0.0.5-beta.20260115.2

package/dist/group-store.js

@@ -0,0 +1,127 @@
+/**
+ * Group storage for persisting group data.
+ *
+ * Group stores are an optional extension for the IAM Groups functionality.
+ * They enable:
+ * - Caching group data locally for fast lookups
+ * - Receiving group provisioning from external IAM providers (SCIM server)
+ * - Storing groups close to your application (in-memory, Redis, database)
+ *
+ * ## Example Usage
+ *
+ * ```typescript
+ * import { InMemoryGroupStore } from '@enterprisestandard/react';
+ *
+ * const groupStore = new InMemoryGroupStore();
+ *
+ * // Store a group
+ * await groupStore.upsert({
+ *   id: 'group-123',
+ *   displayName: 'Administrators',
+ *   createdAt: new Date(),
+ *   updatedAt: new Date(),
+ * });
+ *
+ * // Look up groups
+ * const group = await groupStore.get('group-123');
+ * const allGroups = await groupStore.list();
+ * ```
+ */
+/**
+ * In-memory group store implementation using Maps.
+ *
+ * Suitable for:
+ * - Development and testing
+ * - Single-server deployments
+ * - Applications without high availability requirements
+ *
+ * NOT suitable for:
+ * - Multi-server deployments (groups not shared)
+ * - High availability scenarios (groups lost on restart)
+ * - Production applications with distributed architecture
+ *
+ * For production, implement GroupStore with Redis or a database.
+ *
+ * @template TExtended - Type-safe custom data that consumers can add to groups
+ */
+export class InMemoryGroupStore {
+    constructor() {
+        /** Primary storage: id -> group */
+        this.groups = new Map();
+        /** Secondary index: externalId -> id */
+        this.externalIdIndex = new Map();
+        /** Secondary index: displayName (lowercase) -> id */
+        this.displayNameIndex = new Map();
+    }
+    async get(id) {
+        return this.groups.get(id) ?? null;
+    }
+    async getByExternalId(externalId) {
+        const id = this.externalIdIndex.get(externalId);
+        if (!id)
+            return null;
+        return this.groups.get(id) ?? null;
+    }
+    async getByDisplayName(displayName) {
+        const id = this.displayNameIndex.get(displayName.toLowerCase());
+        if (!id)
+            return null;
+        return this.groups.get(id) ?? null;
+    }
+    async list() {
+        return Array.from(this.groups.values());
+    }
+    async upsert(group) {
+        const existing = this.groups.get(group.id);
+        // Clean up old indexes if externalId or displayName changed
+        if (existing) {
+            if (existing.externalId && existing.externalId !== group.externalId) {
+                this.externalIdIndex.delete(existing.externalId);
+            }
+            if (existing.displayName.toLowerCase() !== group.displayName.toLowerCase()) {
+                this.displayNameIndex.delete(existing.displayName.toLowerCase());
+            }
+        }
+        // Store the group
+        this.groups.set(group.id, group);
+        // Update indexes
+        if (group.externalId) {
+            this.externalIdIndex.set(group.externalId, group.id);
+        }
+        this.displayNameIndex.set(group.displayName.toLowerCase(), group.id);
+    }
+    async delete(id) {
+        const group = this.groups.get(id);
+        if (group) {
+            // Clean up indexes
+            if (group.externalId) {
+                this.externalIdIndex.delete(group.externalId);
+            }
+            this.displayNameIndex.delete(group.displayName.toLowerCase());
+        }
+        this.groups.delete(id);
+    }
+    async addMember(groupId, member) {
+        const group = this.groups.get(groupId);
+        if (!group) {
+            throw new Error(`Group ${groupId} not found`);
+        }
+        const members = group.members ?? [];
+        // Check if member already exists
+        if (!members.some((m) => m.value === member.value)) {
+            members.push(member);
+            group.members = members;
+            group.updatedAt = new Date();
+        }
+    }
+    async removeMember(groupId, memberId) {
+        const group = this.groups.get(groupId);
+        if (!group) {
+            throw new Error(`Group ${groupId} not found`);
+        }
+        if (group.members) {
+            group.members = group.members.filter((m) => m.value !== memberId);
+            group.updatedAt = new Date();
+        }
+    }
+}