Removes group_ids array from topic

libs/model/src/aggregates/community/CreateCommunity.command.ts

@@ -170,7 +170,6 @@ export function CreateCommunity(): Command<typeof schemas.CreateCommunity> {
             description: 'General discussions',
             featured_in_sidebar: true,
             featured_in_new_post: false,
-            group_ids: [],
             allow_tokenized_threads: false,
           },
           { transaction },

libs/model/src/aggregates/community/CreateGroup.command.ts

@@ -55,20 +55,6 @@ export function CreateGroup(): Command<typeof schemas.CreateGroup> {
           );
           if (topics.length > 0) {
             // add group to all specified topics
-            await models.Topic.update(
-              {
-                group_ids: sequelize.fn(
-                  'array_append',
-                  sequelize.col('group_ids'),
-                  group.id,
-                ),
-              },
-              {
-                where: { id: { [Op.in]: topics.map(({ id }) => id!) } },
-                transaction,
-              },
-            );
-
             if (group.id) {
               // add topic level interaction permissions for current group
               const groupPermissions = (payload.topics || []).map((t) => {

libs/model/src/aggregates/community/CreateTopic.command.ts

@@ -41,7 +41,6 @@ export function CreateTopic(): Command<typeof schemas.CreateTopic> {
         featured_in_new_post,
         default_offchain_template,
         community_id: community_id!,
-        group_ids: [],
         allow_tokenized_threads: allow_tokenized_threads ?? false,
       };
 

libs/model/src/aggregates/community/DeleteGroup.command.ts

@@ -1,7 +1,6 @@
 import { InvalidInput, type Command } from '@hicommonwealth/core';
 import * as schemas from '@hicommonwealth/schemas';
-import { Op } from 'sequelize';
-import { models, sequelize } from '../../database';
+import { models } from '../../database';
 import { authRoles } from '../../middleware';
 import { mustExist } from '../../middleware/guards';
 
@@ -26,19 +25,6 @@ export function DeleteGroup(): Command<typeof schemas.DeleteGroup> {
         throw new InvalidInput(DeleteGroupErrors.SystemManaged);
 
       await models.sequelize.transaction(async (transaction) => {
-        await models.Topic.update(
-          {
-            group_ids: sequelize.fn(
-              'array_remove',
-              sequelize.col('group_ids'),
-              group_id,
-            ),
-          },
-          {
-            where: { community_id, group_ids: { [Op.contains]: [group_id] } },
-            transaction,
-          },
-        );
         await models.Membership.destroy({
           where: { group_id },
           transaction,

libs/model/src/aggregates/community/GetGroups.query.ts

@@ -3,6 +3,7 @@ import * as schemas from '@hicommonwealth/schemas';
 import { Op } from 'sequelize';
 import { z } from 'zod';
 import { models } from '../../database';
+import { buildTopicPermissionsMap } from './GetMemberships.query';
 
 export function GetGroups(): Query<typeof schemas.GetGroups> {
   return {
@@ -26,9 +27,10 @@ export function GetGroups(): Query<typeof schemas.GetGroups> {
         ],
       });
       const ids = groups.map((g) => g.id!);
-      const map = new Map<number, z.infer<typeof schemas.GroupView>>();
+
+      const output = new Map<number, z.infer<typeof schemas.GroupView>>();
       groups.forEach((g) =>
-        map.set(g.id!, {
+        output.set(g.id!, {
           ...g.toJSON(),
           id: g.id!,
           name: g.metadata.name,
@@ -43,35 +45,42 @@ export function GetGroups(): Query<typeof schemas.GetGroups> {
           include: [{ model: models.Address, as: 'address' }],
         });
         members.forEach((m) => {
-          const group = map.get(m.group_id);
+          const group = output.get(m.group_id);
           group && group.memberships.concat(m);
         });
       }
 
       if (include_topics) {
+        const topic_ids = groups
+          .map((g) => g.GroupPermissions || [])
+          .flat()
+          .map((p) => p.topic_id);
         const topics = await models.Topic.findAll({
           where: {
             ...(community_id && { community_id }),
-            group_ids: { [Op.overlap]: ids },
+            id: topic_ids,
           },
         });
-        groups.forEach((g) => {
-          const group = map.get(g.id!);
-          group &&
-            group.topics.concat(
-              topics
-                .filter((t) => t.group_ids.includes(group.id))
-                .map((t) => ({
-                  ...t.toJSON(),
-                  permissions: (g.GroupPermissions || []).find(
-                    (gtp) => gtp.topic_id === t.id,
-                  )?.allowed_actions as schemas.PermissionEnum[],
-                })),
-            );
+
+        const topics_map = new Map<number, z.infer<typeof schemas.Topic>>();
+        topics.forEach((t) => topics_map.set(t.id!, t.toJSON()));
+
+        const topic_permissions = buildTopicPermissionsMap(groups);
+
+        output.forEach((g) => {
+          const perm = topic_permissions.get(g.id!);
+          perm &&
+            perm.forEach((p) => {
+              const topic = topics_map.get(p.id);
+              g.topics.push({
+                ...topic!,
+                permissions: p.permissions,
+              });
+            });
         });
       }
 
-      return Array.from(map.values());
+      return Array.from(output.values());
     },
   };
 }

libs/model/src/aggregates/community/GetMemberships.query.ts

@@ -1,11 +1,37 @@
 import { command, Query } from '@hicommonwealth/core';
 import * as schemas from '@hicommonwealth/schemas';
 import { Op } from 'sequelize';
+import { z } from 'zod';
 import { models } from '../../database';
 import { systemActor } from '../../middleware';
 import { mustExist } from '../../middleware/guards';
+import { GroupAttributes } from '../../models';
 import { RefreshCommunityMemberships } from './RefreshCommunityMemberships.command';
 
+/**
+ * Builds a map of topic permissions indexed by group id
+ */
+export function buildTopicPermissionsMap(groups: GroupAttributes[]) {
+  const permissions = groups.map((g) => g.GroupPermissions || []).flat();
+  const map = new Map<number, z.infer<typeof schemas.TopicPermissionsView>[]>();
+  permissions.forEach((p) => {
+    const entry = map.get(p.group_id);
+    if (entry)
+      entry.push({
+        id: p.topic_id,
+        permissions: p.allowed_actions,
+      });
+    else
+      map.set(p.group_id, [
+        {
+          id: p.topic_id,
+          permissions: p.allowed_actions,
+        },
+      ]);
+  });
+  return map;
+}
+
 export function GetMemberships(): Query<typeof schemas.GetMemberships> {
   return {
     ...schemas.GetMemberships,
@@ -21,6 +47,7 @@ export function GetMemberships(): Query<typeof schemas.GetMemberships> {
 
       const groups = await models.Group.findAll({
         where: { community_id },
+        attributes: ['id'],
         include: [
           {
             model: models.GroupPermission,
@@ -29,6 +56,7 @@ export function GetMemberships(): Query<typeof schemas.GetMemberships> {
           },
         ],
       });
+      const ids = groups.map((g) => g.id!);
 
       // TODO: resolve stale community memberships in a separate job
       await command(RefreshCommunityMemberships(), {
@@ -37,31 +65,15 @@ export function GetMemberships(): Query<typeof schemas.GetMemberships> {
       });
 
       const memberships = await models.Membership.findAll({
-        where: {
-          group_id: { [Op.in]: groups.map((g) => g.id!) },
-          address_id: addr.id!,
-        },
-        include: [{ model: models.Group, as: 'group' }],
+        where: { group_id: { [Op.in]: ids }, address_id: addr.id! },
       });
 
-      const topics = await models.Topic.findAll({
-        where: { group_ids: { [Op.overlap]: groups.map((g) => g.id!) } },
-        attributes: ['id', 'group_ids'],
-      });
+      const topic_permissions = buildTopicPermissionsMap(groups);
 
       // transform memberships to result shape
       return memberships.map(({ group_id, reject_reason }) => ({
         groupId: group_id,
-        topics: topics
-          .filter((t) => t.group_ids!.includes(group_id))
-          .map((t) => ({
-            id: t.id!,
-            permissions:
-              groups
-                .find((g) => g.id === group_id)
-                ?.GroupPermissions?.find((gtp) => gtp.topic_id === t.id)
-                ?.allowed_actions || [],
-          })),
+        topics: topic_permissions.get(group_id) || [],
         isAllowed: !reject_reason,
         rejectReason: reject_reason || undefined,
       }));

libs/model/src/aggregates/community/GetTopics.query.ts

@@ -80,7 +80,6 @@ export function GetTopics(): Query<typeof schemas.GetTopics> {
                                      t.default_offchain_template,
                                      t."order",
                                      t.channel_id,
-                                     t.group_ids,
                                      t.weighted_voting,
                                      t.token_symbol,
                                      t.vote_weight_multiplier,

libs/model/src/aggregates/community/UpdateGroup.command.ts

@@ -1,7 +1,7 @@
 import { InvalidInput, type Command } from '@hicommonwealth/core';
 import * as schemas from '@hicommonwealth/schemas';
 import { Op } from 'sequelize';
-import { models, sequelize } from '../../database';
+import { models } from '../../database';
 import { authRoles } from '../../middleware';
 import { mustExist } from '../../middleware/guards';
 import { GroupAttributes } from '../../models';
@@ -51,42 +51,6 @@ export function UpdateGroup(): Command<typeof schemas.UpdateGroup> {
         await group.update(updates, { transaction });
 
         if (topics.length > 0) {
-          const ids = topics.map(({ id }) => id!);
-          await models.Topic.update(
-            {
-              group_ids: sequelize.fn(
-                'array_append',
-                sequelize.col('group_ids'),
-                group_id,
-              ),
-            },
-            {
-              where: {
-                id: { [Op.in]: ids },
-                [Op.not]: { group_ids: { [Op.contains]: [group_id] } },
-              },
-              transaction,
-            },
-          );
-
-          // remove group from existing group topics
-          await models.Topic.update(
-            {
-              group_ids: sequelize.fn(
-                'array_remove',
-                sequelize.col('group_ids'),
-                group_id,
-              ),
-            },
-            {
-              where: {
-                id: { [Op.notIn]: ids },
-                group_ids: { [Op.contains]: [group_id] },
-              },
-              transaction,
-            },
-          );
-
           // update topic level interaction permissions for current group
           await Promise.all(
             (payload.topics || [])?.map(async (t) => {
@@ -101,7 +65,7 @@ export function UpdateGroup(): Command<typeof schemas.UpdateGroup> {
                   VALUES (:group_id, :topic_id, ${allowed_actions}, NOW(), NOW())
                   ON CONFLICT(group_id, topic_id) DO UPDATE
                     SET allowed_actions = EXCLUDED.allowed_actions,
-                        updated_at      = NOW();
+                        updated_at = NOW();
                 `,
                   {
                     transaction,

libs/model/src/aggregates/community/UpdateTopic.command.ts

@@ -28,7 +28,6 @@ export function UpdateTopic(): Command<typeof schemas.UpdateTopic> {
         name,
         description,
         telegram,
-        group_ids,
         featured_in_sidebar,
         featured_in_new_post,
         allow_tokenized_threads,
@@ -55,9 +54,6 @@ export function UpdateTopic(): Command<typeof schemas.UpdateTopic> {
       if (typeof telegram !== 'undefined') {
         topic.telegram = telegram || '';
       }
-      if (Array.isArray(group_ids)) {
-        topic.group_ids = group_ids;
-      }
       if (typeof featured_in_sidebar !== 'undefined') {
         topic.featured_in_sidebar = featured_in_sidebar || false;
       }

libs/model/src/middleware/auth.ts

@@ -251,8 +251,6 @@ async function hasTopicPermissions(
   const topic = await models.Topic.findOne({ where: { id: topic_id } });
   if (!topic) throw new InvalidInput('Topic not found');
 
-  if (topic.group_ids?.length === 0) return;
-
   // check if user has permission to perform "action" in 'topic_id'
   // the 'topic_id' can belong to any group where user has membership
   // the group with 'topic_id' having higher permissions will take precedence
@@ -262,11 +260,16 @@ async function hasTopicPermissions(
     }
   >(
     `
-        SELECT g.*, gp.topic_id, gp.allowed_actions
-        FROM "Groups" as g
-                 JOIN "GroupPermissions" gp ON g.id = gp.group_id
-        WHERE g.community_id = :community_id
-          AND gp.topic_id = :topic_id
+    SELECT
+      g.*,
+      gp.topic_id,
+      gp.allowed_actions
+    FROM
+      "Groups" as g
+      JOIN "GroupPermissions" gp ON g.id = gp.group_id
+    WHERE
+      g.community_id = :community_id
+      AND gp.topic_id = :topic_id
     `,
     {
       type: QueryTypes.SELECT,
@@ -277,6 +280,7 @@ async function hasTopicPermissions(
       },
     },
   );
+  if (!groups || groups.length === 0) return;
 
   // There are 2 cases here. We either have the old group permission system where the group doesn't have
   // any group_allowed_actions, or we have the new fine-grained permission system where the action must be in

libs/model/src/models/topic.ts

@@ -44,11 +44,6 @@ export default (
         allowNull: true,
       },
       channel_id: { type: Sequelize.STRING, allowNull: true },
-      group_ids: {
-        type: Sequelize.ARRAY(Sequelize.INTEGER),
-        allowNull: false,
-        defaultValue: [],
-      },
       telegram: { type: Sequelize.STRING, allowNull: true },
       weighted_voting: { type: Sequelize.STRING, allowNull: true },
       chain_node_id: { type: Sequelize.INTEGER, allowNull: true },

libs/model/test/contest/check-contests.spec.ts

@@ -47,7 +47,6 @@ describe.skip('Check Contests', () => {
           id: topicId,
           name: 'hello',
           community_id: communityId,
-          group_ids: [],
         },
       ],
       contest_managers: [

libs/model/test/contest/contest-worker-policy-lifecycle.spec.ts

@@ -53,7 +53,6 @@ describe('Contest Worker Policy Lifecycle', () => {
           id: topicId,
           name: 'hello',
           community_id: communityId,
-          group_ids: [],
         },
       ],
       contest_managers: [