@codingfactory/socialkit-vue 0.7.10 → 0.7.11

package/src/services/circles.ts

@@ -287,6 +287,19 @@ export interface CircleModerationReport {
   resolution_notes?: string | null
 }
 
+export interface CircleModerationReportSubmissionInput {
+  category: string
+  notes?: string | null
+  subject_user_id?: string | null
+  subject_type?: CircleModerationReportSubjectType
+  subject_id?: string | null
+}
+
+export interface CircleModerationReportSubmissionResult {
+  report_id: string
+  status: string
+}
+
 export interface CircleBanRecord {
   id: string
   user_id: string
@@ -880,6 +893,10 @@ function circleUserRole(circle: Circle | null | undefined): CircleRole | null {
   return isCircleRole(circle.user_role) ? circle.user_role : null
 }
 
+function hasValue(value: unknown): boolean {
+  return value !== undefined && value !== null
+}
+
 function normalizeCollectionResponse<T>(
   payload: unknown,
   normalizeItem: (value: unknown) => T | null,
@@ -925,6 +942,12 @@ function normalizeInlineCollection<T>(
   }
 }
 
+function normalizeBootstrapRoleCollection(value: unknown): PaginationResponse<CircleRoleDefinition> {
+  return Array.isArray(value)
+    ? normalizeInlineCollection(value, normalizeRoleDefinition)
+    : normalizeCollectionResponse(value ?? {}, normalizeRoleDefinition)
+}
+
 function normalizeCircle(value: unknown): Circle | null {
   if (!isRecord(value)) {
     return null
@@ -1714,6 +1737,73 @@ class CirclesService {
     return matchedCircle ? normalizeCircle(matchedCircle) : null
   }
 
+  private normalizeModerationReportSubmissionInput(
+    subjectOrInput: string | CircleModerationReportSubmissionInput,
+    category?: string,
+    notes?: string,
+  ): CircleModerationReportSubmissionInput {
+    if (typeof subjectOrInput !== 'string') {
+      return subjectOrInput
+    }
+
+    const input: CircleModerationReportSubmissionInput = {
+      category: category ?? '',
+      subject_user_id: subjectOrInput,
+      subject_type: 'user',
+      subject_id: subjectOrInput,
+    }
+
+    if (typeof notes === 'string') {
+      input.notes = notes
+    }
+
+    return input
+  }
+
+  private buildModerationReportPayload(input: CircleModerationReportSubmissionInput): Record<string, string> {
+    const category = this.sanitizeInput(input.category)
+    if (category.length === 0) {
+      throw new Error('Moderation report category is required.')
+    }
+
+    const subjectUserId = typeof input.subject_user_id === 'string' && input.subject_user_id.trim().length > 0
+      ? this.sanitizeInput(input.subject_user_id)
+      : null
+    const subjectType = input.subject_type ?? (subjectUserId !== null ? 'user' : undefined)
+    const derivedSubjectId = typeof input.subject_id === 'string' && input.subject_id.trim().length > 0
+      ? this.sanitizeInput(input.subject_id)
+      : subjectType === 'user'
+        ? subjectUserId
+        : null
+
+    if (subjectType !== undefined && derivedSubjectId === null) {
+      throw new Error('Moderation report subject_id is required when subject_type is provided.')
+    }
+
+    if (subjectType === undefined && subjectUserId === null) {
+      throw new Error('Moderation report subject details are required.')
+    }
+
+    const payload: Record<string, string> = {
+      category,
+    }
+
+    if (subjectUserId !== null) {
+      payload.subject_user_id = subjectUserId
+    }
+
+    if (subjectType !== undefined && derivedSubjectId !== null) {
+      payload.subject_type = subjectType
+      payload.subject_id = derivedSubjectId
+    }
+
+    if (typeof input.notes === 'string' && input.notes.trim().length > 0) {
+      payload.notes = this.sanitizeInput(input.notes)
+    }
+
+    return payload
+  }
+
   public async list(cursor?: string | null, filters?: CircleFilters): Promise<PaginationResponse<Circle>> {
     try {
       const params: Record<string, string> = {
@@ -2265,21 +2355,12 @@ class CirclesService {
     }
   }
 
-  public async reportMember(
+  public async submitModerationReport(
     circleId: string,
-    subjectUserId: string,
-    category: string,
-    notes?: string,
-  ): Promise<{ report_id: string; status: string }> {
+    input: CircleModerationReportSubmissionInput,
+  ): Promise<CircleModerationReportSubmissionResult> {
     try {
-      const payload: Record<string, string> = {
-        subject_user_id: subjectUserId,
-        category: this.sanitizeInput(category),
-      }
-      if (typeof notes === 'string' && notes.trim().length > 0) {
-        payload.notes = this.sanitizeInput(notes)
-      }
-
+      const payload = this.buildModerationReportPayload(input)
       const response = await this.client.post(`${this.baseURL}/${circleId}/moderation/reports`, payload)
       const data = readRecord(response.data, 'data') ?? {}
       const reportId = readString(data.report_id)
@@ -2303,6 +2384,28 @@ class CirclesService {
     }
   }
 
+  public async reportMember(
+    circleId: string,
+    subjectUserId: string,
+    category: string,
+    notes?: string,
+  ): Promise<CircleModerationReportSubmissionResult>
+  public async reportMember(
+    circleId: string,
+    input: CircleModerationReportSubmissionInput,
+  ): Promise<CircleModerationReportSubmissionResult>
+  public async reportMember(
+    circleId: string,
+    subjectOrInput: string | CircleModerationReportSubmissionInput,
+    category?: string,
+    notes?: string,
+  ): Promise<CircleModerationReportSubmissionResult> {
+    return await this.submitModerationReport(
+      circleId,
+      this.normalizeModerationReportSubmissionInput(subjectOrInput, category, notes),
+    )
+  }
+
   public async listModerationReports(
     circleId: string,
     cursor?: string | null,
@@ -2508,6 +2611,10 @@ class CirclesService {
   public async getManagementBootstrap(circleId: string): Promise<CircleManagementBootstrap> {
     const identifier = this.sanitizeInput(circleId)
     let resolvedCircle: Circle | null = null
+    let bootstrapPermissionCatalog = createEmptyPagination<CirclePermissionCatalogEntry>().data
+    let bootstrapManagementSections: CircleManagementSection[] = []
+    let bootstrapCounts = createEmptyManagementCounts()
+    let hasBootstrapCounts = false
     const bootstrapIdentifier = this.isUuid(identifier)
       ? identifier
       : await (async (): Promise<string> => {
@@ -2520,7 +2627,14 @@ class CirclesService {
       const data = readRecord(response.data, 'data')
       const bootstrapCircle = data?.circle
       const bootstrapActorCapabilities = readRecord(data, 'actor_capabilities')
-      const bootstrapManagementSections = normalizeManagementSections(data?.management_sections)
+      bootstrapManagementSections = normalizeManagementSections(data?.management_sections)
+      bootstrapPermissionCatalog = Array.isArray(data?.permission_catalog)
+        ? data.permission_catalog
+          .map((entry) => normalizePermissionCatalogEntry(entry))
+          .filter((entry): entry is CirclePermissionCatalogEntry => entry !== null)
+        : []
+      hasBootstrapCounts = hasValue(data?.counts)
+      bootstrapCounts = normalizeManagementCounts(data?.counts)
       const directCircle = normalizeCircle(bootstrapCircle ?? data)
       const directCircleRole = circleUserRole(directCircle)
       const fallbackRole = directCircleRole ?? circleUserRole(resolvedCircle)
@@ -2546,38 +2660,100 @@ class CirclesService {
       const circle = normalizeCircle(mergedCircleSource)
 
       if (circle !== null) {
-        const bootstrapHasCollections = data?.members !== undefined && data?.members !== null
-
-        if (bootstrapHasCollections) {
-          const actor = circle.actor ?? buildActorContext(circle)
+        const actor = circle.actor ?? buildActorContext(circle)
+        if (!actor.capabilities.canViewManagement) {
           return {
             circle,
             actor,
             management_sections: bootstrapManagementSections.length > 0
               ? bootstrapManagementSections
               : actor.managementSections,
-            members: normalizeCollectionResponse(data?.members ?? {}, normalizeCircleMember),
-            requests: normalizeCollectionResponse(data?.requests ?? {}, normalizeJoinRequest),
-            roles: Array.isArray(data?.roles)
-              ? normalizeInlineCollection(data.roles, normalizeRoleDefinition)
-              : normalizeCollectionResponse(data?.roles ?? {}, normalizeRoleDefinition),
-            counts: normalizeManagementCounts(data?.counts),
-            permission_catalog: Array.isArray(data?.permission_catalog)
-              ? data.permission_catalog
-                .map((entry) => normalizePermissionCatalogEntry(entry))
-                .filter((entry): entry is CirclePermissionCatalogEntry => entry !== null)
-              : [],
-            reports: normalizeCollectionResponse(data?.reports ?? {}, normalizeModerationReport),
-            bans: normalizeCollectionResponse(data?.bans ?? {}, normalizeBanRecord),
-            mutes: normalizeCollectionResponse(data?.mutes ?? {}, normalizeMuteRecord),
-            audit: normalizeCollectionResponse(data?.audit ?? {}, normalizeAuditLogEntry),
-            automod: normalizeCollectionResponse(data?.automod ?? {}, normalizeAutomodRule),
+            members: createEmptyPagination<CircleMember>(),
+            requests: createEmptyPagination<JoinRequest>(),
+            roles: createEmptyPagination<CircleRoleDefinition>(),
+            counts: createEmptyManagementCounts(),
+            permission_catalog: [],
+            reports: createEmptyPagination<CircleModerationReport>(),
+            bans: createEmptyPagination<CircleBanRecord>(),
+            mutes: createEmptyPagination<CircleMuteRecord>(),
+            audit: createEmptyPagination<CircleModerationAuditLogEntry>(),
+            automod: createEmptyPagination<CircleAutomodRule>(),
           }
         }
 
-        // Bootstrap returned circle + counts but no collection data arrays.
-        // Save the circle so the individual-fetch fallback path below can use it.
-        resolvedCircle = circle
+        const caps = actor.capabilities
+        const emptyJoinRequests = createEmptyPagination<JoinRequest>()
+        const emptyRoles = createEmptyPagination<CircleRoleDefinition>()
+        const emptyReports = createEmptyPagination<CircleModerationReport>()
+        const emptyBans = createEmptyPagination<CircleBanRecord>()
+        const emptyMutes = createEmptyPagination<CircleMuteRecord>()
+        const emptyAudit = createEmptyPagination<CircleModerationAuditLogEntry>()
+        const emptyAutomod = createEmptyPagination<CircleAutomodRule>()
+        const members = hasValue(data?.members)
+          ? normalizeCollectionResponse(data?.members ?? {}, normalizeCircleMember)
+          : await this.getMembers(circle.id)
+        const requests = hasValue(data?.requests)
+          ? normalizeCollectionResponse(data?.requests ?? {}, normalizeJoinRequest)
+          : caps.canReviewRequests
+            ? await this.listJoinRequests(circle.id, null, 'pending')
+            : emptyJoinRequests
+        const roles = hasValue(data?.roles)
+          ? normalizeBootstrapRoleCollection(data?.roles)
+          : caps.canManageRoles
+            ? await this.listRoles(circle.id)
+            : emptyRoles
+        const reports = hasValue(data?.reports)
+          ? normalizeCollectionResponse(data?.reports ?? {}, normalizeModerationReport)
+          : caps.canManageReports
+            ? await this.listModerationReports(circle.id, null, 'pending')
+            : emptyReports
+        const bans = hasValue(data?.bans)
+          ? normalizeCollectionResponse(data?.bans ?? {}, normalizeBanRecord)
+          : caps.canManageBans
+            ? await this.listBans(circle.id)
+            : emptyBans
+        const mutes = hasValue(data?.mutes)
+          ? normalizeCollectionResponse(data?.mutes ?? {}, normalizeMuteRecord)
+          : caps.canManageMutes
+            ? await this.listMutes(circle.id)
+            : emptyMutes
+        const audit = hasValue(data?.audit)
+          ? normalizeCollectionResponse(data?.audit ?? {}, normalizeAuditLogEntry)
+          : caps.canViewAuditLog
+            ? await this.getModerationAuditLog(circle.id)
+            : emptyAudit
+        const automod = hasValue(data?.automod)
+          ? normalizeCollectionResponse(data?.automod ?? {}, normalizeAutomodRule)
+          : caps.canManageAutomod
+            ? await this.listAutomodRules(circle.id)
+            : emptyAutomod
+
+        return {
+          circle,
+          actor,
+          management_sections: bootstrapManagementSections.length > 0
+            ? bootstrapManagementSections
+            : actor.managementSections,
+          members,
+          requests,
+          roles,
+          counts: hasBootstrapCounts
+            ? bootstrapCounts
+            : {
+                members: circle.member_count ?? members.data.length,
+                requests_pending: requests.data.length,
+                reports_pending: reports.data.length,
+                roles: roles.data.length,
+                bans_active: bans.data.length,
+                mutes_active: mutes.data.length,
+              },
+          permission_catalog: bootstrapPermissionCatalog,
+          reports,
+          bans,
+          mutes,
+          audit,
+          automod,
+        }
       }
     } catch (error: unknown) {
       if (!this.isHttpStatus(error, 404)) {
@@ -2597,7 +2773,7 @@ class CirclesService {
         requests: createEmptyPagination<JoinRequest>(),
         roles: createEmptyPagination<CircleRoleDefinition>(),
         counts: createEmptyManagementCounts(),
-        permission_catalog: [],
+        permission_catalog: bootstrapPermissionCatalog,
         reports: createEmptyPagination<CircleModerationReport>(),
         bans: createEmptyPagination<CircleBanRecord>(),
         mutes: createEmptyPagination<CircleMuteRecord>(),
@@ -2664,7 +2840,7 @@ class CirclesService {
         bans_active: bans.data.length,
         mutes_active: mutes.data.length,
       },
-      permission_catalog: [],
+      permission_catalog: bootstrapPermissionCatalog,
       reports,
       bans,
       mutes,

package/src/stores/circles.ts

@@ -460,10 +460,27 @@ const deriveRoleAssignmentsFromMembers = (members: CircleMemberState[]): CircleR
       roleAssignment.user = member.user
     }
 
-    return roleAssignment
+  return roleAssignment
   })
 }
 
+const resolveCircleActorContext = (
+  state: Pick<CirclesState, 'managementActors' | 'currentCircle' | 'circles'>,
+  circleId: string,
+): CircleActorContext | null => {
+  const managementActor = state.managementActors[circleId]
+  if (managementActor) {
+    return managementActor
+  }
+
+  if (state.currentCircle?.id === circleId || state.currentCircle?.slug === circleId) {
+    return state.currentCircle.actor ?? null
+  }
+
+  const matchingCircle = state.circles.find((candidate) => candidate.id === circleId || candidate.slug === circleId)
+  return matchingCircle?.actor ?? null
+}
+
 const getRoleStoreService = (circlesService: CirclesServiceInstance): Partial<CircleRoleStoreService> => {
   // The shared service layer is mid-migration; runtime method checks let the store
   // support both the legacy member-role API and the new RBAC role-definition API.
@@ -1669,10 +1686,20 @@ export function createCirclesStoreDefinition(config: CirclesStoreConfig) {
 
         try {
           await circlesService.reportMember(circleId, subjectUserId, category, notes)
-          await Promise.allSettled([
-            this.fetchModerationReports(circleId, true),
-            this.fetchAuditLog(circleId, true),
-          ])
+          const actor = resolveCircleActorContext(this, circleId)
+          const followUpTasks: Promise<unknown>[] = []
+
+          if (actor?.capabilities.canManageReports === true) {
+            followUpTasks.push(this.fetchModerationReports(circleId, true))
+          }
+
+          if (actor?.capabilities.canViewAuditLog === true) {
+            followUpTasks.push(this.fetchAuditLog(circleId, true))
+          }
+
+          if (followUpTasks.length > 0) {
+            await Promise.allSettled(followUpTasks)
+          }
         } catch (error: unknown) {
           this.error = getErrorMessage(error)
           throw error