refactor applicableGroups type

apps/app/src/components/PageAlert/FixPageGrantAlert.tsx

@@ -1,6 +1,6 @@
 import React, { useEffect, useState, useCallback } from 'react';
 
-import { GroupType, PageGrant } from '@growi/core';
+import { PageGrant } from '@growi/core';
 import { useTranslation } from 'react-i18next';
 import {
   Modal, ModalHeader, ModalBody, ModalFooter,
@@ -8,10 +8,8 @@ import {
 
 import { apiv3Put } from '~/client/util/apiv3-client';
 import { toastError, toastSuccess } from '~/client/util/toastr';
-import { ExternalUserGroupDocument } from '~/features/external-user-group/server/models/external-user-group';
 import { IPageGrantData } from '~/interfaces/page';
-import { IRecordApplicableGrant, IResIsGrantNormalizedGrantData } from '~/interfaces/page-grant';
-import { UserGroupDocument } from '~/server/models/user-group';
+import { ApplicableGroup, IRecordApplicableGrant, IResIsGrantNormalizedGrantData } from '~/interfaces/page-grant';
 import { useCurrentUser } from '~/stores/context';
 import { useSWRxApplicableGrant, useSWRxIsGrantNormalized, useSWRxCurrentPage } from '~/stores/page';
 
@@ -31,7 +29,7 @@ const FixPageGrantModal = (props: ModalProps): JSX.Element => {
   } = props;
 
   const [selectedGrant, setSelectedGrant] = useState<PageGrant>(PageGrant.GRANT_RESTRICTED);
-  const [selectedGroup, setSelectedGroup] = useState<{type: GroupType, item: UserGroupDocument | ExternalUserGroupDocument} | undefined>(undefined);
+  const [selectedGroup, setSelectedGroup] = useState<ApplicableGroup | undefined>(undefined);
 
   // Alert message state
   const [shouldShowModalAlert, setShowModalAlert] = useState<boolean>(false);

apps/app/src/features/external-user-group/server/models/external-user-group-relation.integ.ts

@@ -107,24 +107,20 @@ describe('ExternalUserGroupRelation model', () => {
     });
   });
 
-  describe('findAllRelationForUser', () => {
+  describe('findAllGroupsForUser', () => {
     beforeAll(async() => {
       await ExternalUserGroupRelation.createRelations([groupId1, groupId2], user1);
       await ExternalUserGroupRelation.create({ relatedGroup: groupId3, relatedUser: user2._id });
     });
 
-    it('finds all relations for user with group populated', async() => {
-      const relations = await ExternalUserGroupRelation.findAllRelationForUser(user1);
-      const populatedGroupIds = relations.map((relation) => {
-        return typeof relation.relatedGroup !== 'string' ? relation.relatedGroup._id : null;
-      });
-      expect(populatedGroupIds).toStrictEqual([groupId1, groupId2]);
+    it('finds all groups related to user', async() => {
+      const groups = await ExternalUserGroupRelation.findAllGroupsForUser(user1);
+      const groupIds = groups.map(group => group._id);
+      expect(groupIds).toStrictEqual([groupId1, groupId2]);
 
-      const relations2 = await ExternalUserGroupRelation.findAllRelationForUser(user2);
-      const populatedGroupIds2 = relations2.map((relation) => {
-        return typeof relation.relatedGroup !== 'string' ? relation.relatedGroup._id : null;
-      });
-      expect(populatedGroupIds2).toStrictEqual([groupId3]);
+      const groups2 = await ExternalUserGroupRelation.findAllGroupsForUser(user2);
+      const groupIds2 = groups2.map(group => group._id);
+      expect(groupIds2).toStrictEqual([groupId3]);
     });
   });
 });

apps/app/src/features/external-user-group/server/models/external-user-group-relation.ts

@@ -23,7 +23,7 @@ export interface ExternalUserGroupRelationModel extends Model<ExternalUserGroupR
 
   countByGroupIdsAndUser: (userGroupIds: ObjectIdLike[], userData) => Promise<number>
 
-  findAllRelationForUser: (user) => Promise<ExternalUserGroupRelationDocument[]>
+  findAllGroupsForUser: (user) => Promise<ExternalUserGroupDocument[]>
 }
 
 const schema = new Schema<ExternalUserGroupRelationDocument, ExternalUserGroupRelationModel>({
@@ -49,6 +49,6 @@ schema.statics.findAllUserIdsForUserGroups = UserGroupRelation.findAllUserIdsFor
 
 schema.statics.findAllUserGroupIdsRelatedToUser = UserGroupRelation.findAllUserGroupIdsRelatedToUser;
 
-schema.statics.findAllRelationForUser = UserGroupRelation.findAllRelationForUser;
+schema.statics.findAllGroupsForUser = UserGroupRelation.findAllGroupsForUser;
 
 export default getOrCreateModel<ExternalUserGroupRelationDocument, ExternalUserGroupRelationModel>('ExternalUserGroupRelation', schema);

apps/app/src/interfaces/page-grant.ts

@@ -5,8 +5,12 @@ import { UserGroupDocument } from '~/server/models/user-group';
 
 import { IPageGrantData } from './page';
 
+
+type UserGroupType = typeof GroupType.userGroup;
+type ExternalUserGroupType = typeof GroupType.externalUserGroup;
+export type ApplicableGroup = {type: UserGroupType, item: UserGroupDocument } | {type: ExternalUserGroupType, item: ExternalUserGroupDocument }
 export type IDataApplicableGroup = {
-  applicableGroups?: {type: GroupType, item: UserGroupDocument | ExternalUserGroupDocument }[]
+  applicableGroups?: ApplicableGroup[]
 }
 
 export type IDataApplicableGrant = null | IDataApplicableGroup;

apps/app/src/server/models/user-group-relation.ts

@@ -1,4 +1,4 @@
-import type { IUserGroupRelation } from '@growi/core';
+import { isPopulated, type IUserGroupHasId, type IUserGroupRelation } from '@growi/core';
 import mongoose, { Model, Schema, Document } from 'mongoose';
 
 import { ObjectIdLike } from '../interfaces/mongoose-utils';
@@ -27,7 +27,7 @@ export interface UserGroupRelationModel extends Model<UserGroupRelationDocument>
 
   countByGroupIdsAndUser: (userGroupIds: ObjectIdLike[], userData) => Promise<number>
 
-  findAllRelationForUser: (user) => Promise<UserGroupRelationDocument[]>
+  findAllGroupsForUser: (user) => Promise<UserGroupDocument[]>
 }
 
 /*
@@ -116,23 +116,19 @@ schema.statics.findAllRelationForUserGroups = function(userGroups) {
 };
 
 /**
- * find all user and group relation of User
+ * find all groups of User
  *
  * @static
  * @param {User} user
- * @returns {Promise<UserGroupRelation[]>}
+ * @returns {Promise<UserGroupDocument[]>}
  * @memberof UserGroupRelation
  */
-schema.statics.findAllRelationForUser = function(user): Promise<UserGroupRelationDocument[]> {
-  return this
-    .find({ relatedUser: user.id })
-    .populate('relatedGroup')
-    // filter documents only relatedGroup is not null
-    .then((userGroupRelations) => {
-      return userGroupRelations.filter((relation) => {
-        return relation.relatedGroup != null;
-      });
-    });
+schema.statics.findAllGroupsForUser = async function(user): Promise<UserGroupDocument[]> {
+  const userGroupRelations = await this.find({ relatedUser: user.id }).populate('relatedGroup');
+  const userGroups = userGroupRelations.map((relation) => {
+    return isPopulated(relation.relatedGroup) ? relation.relatedGroup as UserGroupDocument : null;
+  });
+  return userGroups.filter((group): group is NonNullable<UserGroupDocument> => group != null);
 };
 
 /**

apps/app/src/server/routes/apiv3/me.ts

@@ -1,4 +1,4 @@
-import { type IUserHasId, isPopulated } from '@growi/core';
+import { type IUserHasId } from '@growi/core';
 import { Router, Request } from 'express';
 
 import ExternalUserGroupRelation from '~/features/external-user-group/server/models/external-user-group-relation';
@@ -27,13 +27,7 @@ module.exports = function(crowi) {
    */
   router.get('/user-groups', accessTokenParser, loginRequiredStrictly, async(req: AuthorizedRequest, res: ApiV3Response) => {
     try {
-      const userGroupRelations = await UserGroupRelation.findAllRelationForUser(req.user);
-      const userGroups = userGroupRelations.map((relation) => {
-        // relation.relatedGroup should be populated
-        return isPopulated(relation.relatedGroup) ? relation.relatedGroup : undefined;
-      })
-        // exclude undefined elements
-        .filter(elem => elem != null);
+      const userGroups = await UserGroupRelation.findAllGroupsForUser(req.user);
       return res.json(ApiResponse.success({ userGroups }));
     }
     catch (e) {
@@ -47,13 +41,7 @@ module.exports = function(crowi) {
    */
   router.get('/external-user-groups', accessTokenParser, loginRequiredStrictly, async(req: AuthorizedRequest, res: ApiV3Response) => {
     try {
-      const userGroupRelations = await ExternalUserGroupRelation.findAllRelationForUser(req.user);
-      const userGroups = userGroupRelations.map((relation) => {
-        // relation.relatedGroup should be populated
-        return isPopulated(relation.relatedGroup) ? relation.relatedGroup : undefined;
-      })
-      // exclude undefined elements
-        .filter(elem => elem != null);
+      const userGroups = await ExternalUserGroupRelation.findAllGroupsForUser(req.user);
       return res.json(ApiResponse.success({ userGroups }));
     }
     catch (e) {

apps/app/src/server/service/page-grant.ts

@@ -568,11 +568,9 @@ class PageGrantService {
     return data;
   }
 
-  async getUserPossessedGroups(user): Promise<{type: GroupType, item: UserGroupDocument | ExternalUserGroupDocument}[]> {
-    const userPossessedUserGroupIds = await UserGroupRelation.findAllUserGroupIdsRelatedToUser(user);
-    const userPossessedExternalUserGroupIds = await ExternalUserGroupRelation.findAllUserGroupIdsRelatedToUser(user);
-    const userPossessedUserGroups = await UserGroup.find({ _id: { $in: userPossessedUserGroupIds } });
-    const userPossessedExternalUserGroups = await ExternalUserGroup.find({ _id: { $in: userPossessedExternalUserGroupIds } });
+  async getUserPossessedGroups(user) {
+    const userPossessedUserGroups = await UserGroupRelation.findAllGroupsForUser(user);
+    const userPossessedExternalUserGroups = await ExternalUserGroupRelation.findAllGroupsForUser(user);
     return [
       ...userPossessedUserGroups.map((group) => {
         return { type: GroupType.userGroup, item: group };