Andreas/wekan
1
0
Fork 0
mirror of https://github.com/wekan/wekan.git synced 2026-01-23 09:46:09 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Replace cottz:publish-relations with reywood:publish-composite

Browse source
This commit is contained in:
Harry Adel 2026-01-21 07:52:04 +02:00
parent a528a411da
commit a5444e08ab
4 changed files with 289 additions and 268 deletions
Download patch file Download diff file Expand all files Collapse all files

2
.meteor/packages
View file

@ -16,7 +16,7 @@ es5-shim@4.8.0
# Collections
aldeed:collection2
cottz:publish-relations
reywood:publish-composite
dburles:collection-helpers
idmontie:migrations
mongo@1.16.8

2
.meteor/versions
View file

@ -23,7 +23,6 @@ check@1.4.1
coffeescript@2.7.0
coffeescript-compiler@2.4.1
communitypackages:picker@1.1.1
cottz:publish-relations@2.0.8
dburles:collection-helpers@1.1.0
ddp@1.4.1
ddp-client@2.6.2
@ -116,6 +115,7 @@ reactive-dict@1.3.1
reactive-var@1.0.12
reload@1.3.1
retry@1.1.0
reywood:publish-composite@1.9.0
routepolicy@1.1.1
service-configuration@1.3.4
session@1.2.1

506
server/publications/boards.js
View file

@ -3,12 +3,13 @@
// 1. that the user is a member of
// 2. the user has starred
import { ReactiveCache } from '/imports/reactiveCache';
import { publishComposite } from 'meteor/reywood:publish-composite';
import Users from "../../models/users";
import Org from "../../models/org";
import Team from "../../models/team";
import Attachments from '../../models/attachments';
Meteor.publishRelations('boards', function() {
publishComposite('boards', function() {
const userId = this.userId;
// Ensure that the user is connected. If it is not, we need to return an empty
// array to tell the client to remove the previously published docs.
@ -16,95 +17,61 @@ Meteor.publishRelations('boards', function() {
return [];
}
// Defensive programming to verify that starredBoards has the expected
// format -- since the field is in the `profile` a user can modify it.
// const { starredBoards = [] } = (ReactiveCache.getUser(userId) || {}).profile || {};
// check(starredBoards, [String]);
// let currUser = ReactiveCache.getUser(userId);
// let orgIdsUserBelongs = currUser!== 'undefined' && currUser.teams !== 'undefined' ? currUser.orgIdsUserBelongs() : '';
// let teamIdsUserBelongs = currUser!== 'undefined' && currUser.teams !== 'undefined' ? currUser.teamIdsUserBelongs() : '';
// let orgsIds = [];
// let teamsIds = [];
// if(orgIdsUserBelongs && orgIdsUserBelongs != ''){
// orgsIds = orgIdsUserBelongs.split(',');
// }
// if(teamIdsUserBelongs && teamIdsUserBelongs != ''){
// teamsIds = teamIdsUserBelongs.split(',');
// }
this.cursor(ReactiveCache.getBoards(
{
archived: false,
_id: { $in: Boards.userBoardIds(userId, false) },
// $or: [
// {
// // _id: { $in: starredBoards }, // Commented out, to get a list of all public boards
// permission: 'public',
// },
// { members: { $elemMatch: { userId, isActive: true } } },
// {'orgs.orgId': {$in : orgsIds}},
// {'teams.teamId': {$in : teamsIds}},
// ],
return {
find() {
return ReactiveCache.getBoards(
{
archived: false,
_id: { $in: Boards.userBoardIds(userId, false) },
},
{
sort: { sort: 1 /* boards default sorting */ },
},
true,
);
},
{
sort: { sort: 1 /* boards default sorting */ },
},
true,
),
function(boardId, board) {
this.cursor(
ReactiveCache.getLists(
{ boardId, archived: false },
{ fields:
children: [
{
find(board) {
// Publish lists with extended fields for proper sync
// Including swimlaneId, modifiedAt, and _updatedAt for list order changes
return ReactiveCache.getLists(
{ boardId: board._id, archived: false },
{
_id: 1,
title: 1,
boardId: 1,
archived: 1,
sort: 1
}
},
true,
)
);
// Publish list order changes immediately
// Include swimlaneId and modifiedAt for proper sync
this.cursor(
ReactiveCache.getLists(
{ boardId, archived: false },
{ fields:
{
_id: 1,
title: 1,
boardId: 1,
swimlaneId: 1,
archived: 1,
sort: 1,
modifiedAt: 1,
_updatedAt: 1, // Hidden field to trigger updates
}
},
true,
)
);
this.cursor(
ReactiveCache.getCards(
{ boardId, archived: false },
{ fields: {
_id: 1,
boardId: 1,
listId: 1,
archived: 1,
sort: 1
}},
true,
)
);
}
);
const ret = this.ready();
return ret;
fields: {
_id: 1,
title: 1,
boardId: 1,
swimlaneId: 1,
archived: 1,
sort: 1,
modifiedAt: 1,
_updatedAt: 1, // Hidden field to trigger updates
}
},
true,
);
}
},
{
find(board) {
return ReactiveCache.getCards(
{ boardId: board._id, archived: false },
{
fields: {
_id: 1,
boardId: 1,
listId: 1,
archived: 1,
sort: 1
}
},
true,
);
}
}
]
};
});
Meteor.publish('boardsReport', function() {
@ -203,183 +170,232 @@ Meteor.publish('archivedBoards', function() {
// If isArchived = false, this will only return board elements which are not archived.
// If isArchived = true, this will only return board elements which are archived.
Meteor.publishRelations('board', function(boardId, isArchived) {
this.unblock();
publishComposite('board', function(boardId, isArchived) {
check(boardId, String);
check(isArchived, Boolean);
const thisUserId = this.userId;
const $or = [{ permission: 'public' }];
let currUser = (!Match.test(thisUserId, String) || !thisUserId) ? 'undefined' : ReactiveCache.getUser(thisUserId);
let orgIdsUserBelongs = currUser!== 'undefined' && currUser.teams !== 'undefined' ? currUser.orgIdsUserBelongs() : '';
let teamIdsUserBelongs = currUser!== 'undefined' && currUser.teams !== 'undefined' ? currUser.teamIdsUserBelongs() : '';
let currUser = (!Match.test(thisUserId, String) || !thisUserId) ? 'undefined' : ReactiveCache.getUser(thisUserId);
let orgIdsUserBelongs = currUser !== 'undefined' && currUser.teams !== 'undefined' ? currUser.orgIdsUserBelongs() : '';
let teamIdsUserBelongs = currUser !== 'undefined' && currUser.teams !== 'undefined' ? currUser.teamIdsUserBelongs() : '';
let orgsIds = [];
let teamsIds = [];
if(orgIdsUserBelongs && orgIdsUserBelongs != ''){
if (orgIdsUserBelongs && orgIdsUserBelongs != '') {
orgsIds = orgIdsUserBelongs.split(',');
}
if(teamIdsUserBelongs && teamIdsUserBelongs != ''){
if (teamIdsUserBelongs && teamIdsUserBelongs != '') {
teamsIds = teamIdsUserBelongs.split(',');
}
if (thisUserId) {
$or.push({members: { $elemMatch: { userId: thisUserId, isActive: true } }});
$or.push({'orgs.orgId': {$in : orgsIds}});
$or.push({'teams.teamId': {$in : teamsIds}});
$or.push({ members: { $elemMatch: { userId: thisUserId, isActive: true } } });
$or.push({ 'orgs.orgId': { $in: orgsIds } });
$or.push({ 'teams.teamId': { $in: teamsIds } });
}
this.cursor(
ReactiveCache.getBoards(
{
_id: boardId,
archived: false,
// If the board is not public the user has to be a member of it to see
// it.
$or,
// Sort required to ensure oplog usage
},
{ limit: 1, sort: { sort: 1 /* boards default sorting */ } },
true,
),
function(boardId, board) {
this.cursor(ReactiveCache.getLists({ boardId, archived: isArchived }, {}, true));
this.cursor(ReactiveCache.getSwimlanes({ boardId, archived: isArchived }, {}, true));
this.cursor(ReactiveCache.getIntegrations({ boardId }, {}, true));
this.cursor(ReactiveCache.getCardCommentReactions({ boardId }, {}, true));
this.cursor(
ReactiveCache.getCustomFields(
{ boardIds: { $in: [boardId] } },
{ sort: { name: 1 } },
true,
),
return {
find() {
return ReactiveCache.getBoards(
{
_id: boardId,
archived: false,
// If the board is not public the user has to be a member of it to see it.
$or,
},
{ limit: 1, sort: { sort: 1 /* boards default sorting */ } },
true,
);
},
children: [
// Lists
{
find(board) {
return ReactiveCache.getLists({ boardId: board._id, archived: isArchived }, {}, true);
}
},
// Swimlanes
{
find(board) {
return ReactiveCache.getSwimlanes({ boardId: board._id, archived: isArchived }, {}, true);
}
},
// Integrations
{
find(board) {
return ReactiveCache.getIntegrations({ boardId: board._id }, {}, true);
}
},
// CardCommentReactions at board level
{
find(board) {
return ReactiveCache.getCardCommentReactions({ boardId: board._id }, {}, true);
}
},
// CustomFields
{
find(board) {
return ReactiveCache.getCustomFields(
{ boardIds: { $in: [board._id] } },
{ sort: { name: 1 } },
true,
);
}
},
// Cards and their related data
{
find(board) {
const cardSelector = {
boardId: { $in: [board._id, board.subtasksDefaultBoardId] },
archived: isArchived,
};
// Cards and cards comments
// XXX Originally we were publishing the card documents as a child of the
// list publication defined above using the following selector `{ listId:
// list._id }`. But it was causing a race condition in publish-composite,
// that I documented here:
//
// https://github.com/englue/meteor-publish-composite/issues/29
//
// cottz:publish had a similar problem:
//
// https://github.com/Goluis/cottz-publish/issues/4
//
// The current state of relational publishing in meteor is a bit sad,
// there are a lot of various packages, with various APIs, some of them
// are unmaintained. Fortunately this is something that will be fixed by
// meteor-core at some point:
//
// https://trello.com/c/BGvIwkEa/48-easy-joins-in-subscriptions
//
// And in the meantime our code below works pretty well -- it's not even a
// hack!
// Check if current user has assigned-only permissions
if (thisUserId && board.members) {
const member = _.findWhere(board.members, { userId: thisUserId, isActive: true });
if (member && (member.isNormalAssignedOnly || member.isCommentAssignedOnly || member.isReadAssignedOnly)) {
// User with assigned-only permissions should only see cards assigned to them
cardSelector.assignees = { $in: [thisUserId] };
}
}
// Gather queries and send in bulk
const cardComments = this.join(CardComments);
cardComments.selector = _ids => ({ cardId: _ids });
const cardCommentsLinkedBoard = this.join(CardComments);
cardCommentsLinkedBoard.selector = _ids => ({ boardId: _ids });
const cardCommentReactions = this.join(CardCommentReactions);
cardCommentReactions.selector = _ids => ({ cardId: _ids });
const attachments = this.join(Attachments.collection);
attachments.selector = _ids => ({ 'meta.cardId': _ids });
const checklists = this.join(Checklists);
checklists.selector = _ids => ({ cardId: _ids });
const checklistItems = this.join(ChecklistItems);
checklistItems.selector = _ids => ({ cardId: _ids });
const parentCards = this.join(Cards);
parentCards.selector = _ids => ({ parentId: _ids });
const boards = this.join(Boards);
const subCards = this.join(Cards);
subCards.selector = _ids => ({ _id: _ids, archived: isArchived });
const linkedBoardCards = this.join(Cards);
linkedBoardCards.selector = _ids => ({ boardId: _ids });
return ReactiveCache.getCards(cardSelector, {}, true);
},
children: [
// CardComments for each card
{
find(card) {
return CardComments.find({ cardId: card._id });
}
},
// CardCommentReactions for each card
{
find(card) {
return CardCommentReactions.find({ cardId: card._id });
}
},
// Attachments for each card
{
find(card) {
return Attachments.collection.find({ 'meta.cardId': card._id });
}
},
// Checklists for each card
{
find(card) {
return Checklists.find({ cardId: card._id });
}
},
// ChecklistItems for each card
{
find(card) {
return ChecklistItems.find({ cardId: card._id });
}
},
// Parent cards (cards that have this card as parentId)
{
find(card) {
return Cards.find({ parentId: card._id });
}
},
// Linked card data (for cardType-linkedCard)
{
find(card) {
if (card.type === 'cardType-linkedCard' && card.linkedId) {
return Cards.find({ _id: card.linkedId, archived: isArchived });
}
return null;
},
children: [
// Comments for linked card
{
find(linkedCard) {
return CardComments.find({ cardId: linkedCard._id });
}
},
// Attachments for linked card
{
find(linkedCard) {
return Attachments.collection.find({ 'meta.cardId': linkedCard._id });
}
},
// Checklists for linked card
{
find(linkedCard) {
return Checklists.find({ cardId: linkedCard._id });
}
},
// ChecklistItems for linked card
{
find(linkedCard) {
return ChecklistItems.find({ cardId: linkedCard._id });
}
}
]
},
// Linked board (for cardType-linkedBoard)
{
find(card) {
if (card.type === 'cardType-linkedBoard' && card.linkedId) {
return Boards.find({ _id: card.linkedId });
}
return null;
}
},
// Cards in linked board (for cardType-linkedBoard)
{
find(card) {
if (card.type === 'cardType-linkedBoard' && card.linkedId) {
return Cards.find({ boardId: card.linkedId });
}
return null;
}
},
// Comments for linked board cards (for cardType-linkedBoard)
{
find(card) {
if (card.type === 'cardType-linkedBoard' && card.linkedId) {
return CardComments.find({ boardId: card.linkedId });
}
return null;
}
}
]
},
// Board members/Users
{
find(board) {
if (board.members) {
// Board members. This publication also includes former board members that
// aren't members anymore but may have some activities attached to them in
// the history.
const memberIds = _.pluck(board.members, 'userId');
// Build card selector based on user's permissions
const cardSelector = {
boardId: { $in: [boardId, board.subtasksDefaultBoardId] },
archived: isArchived,
};
// Check if current user has assigned-only permissions
if (thisUserId && board.members) {
const member = _.findWhere(board.members, { userId: thisUserId, isActive: true });
if (member && (member.isNormalAssignedOnly || member.isCommentAssignedOnly || member.isReadAssignedOnly)) {
// User with assigned-only permissions should only see cards assigned to them
cardSelector.assignees = { $in: [thisUserId] };
// We omit the current user because the client should already have that data,
// and sending it triggers a subtle bug:
// https://github.com/wefork/wekan/issues/15
return ReactiveCache.getUsers(
{
_id: { $in: _.without(memberIds, thisUserId) },
},
{
fields: {
username: 1,
'profile.fullname': 1,
'profile.avatarUrl': 1,
'profile.initials': 1,
},
},
true,
);
}
return null;
}
}
this.cursor(
ReactiveCache.getCards(cardSelector, {}, true),
function(cardId, card) {
if (card.type === 'cardType-linkedCard') {
const impCardId = card.linkedId;
subCards.push(impCardId); // GitHub issue #2688 and #2693
cardComments.push(impCardId);
attachments.push(impCardId);
checklists.push(impCardId);
checklistItems.push(impCardId);
} else if (card.type === 'cardType-linkedBoard') {
boards.push(card.linkedId);
linkedBoardCards.push(card.linkedId);
cardCommentsLinkedBoard.push(card.linkedId);
}
cardComments.push(cardId);
attachments.push(cardId);
checklists.push(cardId);
checklistItems.push(cardId);
parentCards.push(cardId);
cardCommentReactions.push(cardId);
},
);
// Send bulk queries for all found ids
subCards.send();
cardComments.send();
cardCommentReactions.send();
attachments.send();
checklists.send();
checklistItems.send();
boards.send();
parentCards.send();
linkedBoardCards.send();
cardCommentsLinkedBoard.send();
if (board.members) {
// Board members. This publication also includes former board members that
// aren't members anymore but may have some activities attached to them in
// the history.
const memberIds = _.pluck(board.members, 'userId');
// We omit the current user because the client should already have that data,
// and sending it triggers a subtle bug:
// https://github.com/wefork/wekan/issues/15
this.cursor(
ReactiveCache.getUsers(
{
_id: { $in: _.without(memberIds, thisUserId) },
},
{
fields: {
username: 1,
'profile.fullname': 1,
'profile.avatarUrl': 1,
'profile.initials': 1,
},
},
true,
),
);
//this.cursor(presences.find({ userId: { $in: memberIds } }));
}
},
);
const ret = this.ready();
return ret;
]
};
});
Meteor.methods({

47
server/publications/cards.js
View file

@ -1,4 +1,5 @@
import { ReactiveCache } from '/imports/reactiveCache';
import { publishComposite } from 'meteor/reywood:publish-composite';
import escapeForRegex from 'escape-string-regexp';
import Users from '../../models/users';
import {
@ -110,45 +111,49 @@ Meteor.publish('card', cardId => {
/** publish all data which is necessary to display card details as popup
* @returns array of cursors
*/
Meteor.publishRelations('popupCardData', function(cardId) {
publishComposite('popupCardData', function(cardId) {
check(cardId, String);
const userId = this.userId;
const card = ReactiveCache.getCard({ _id: cardId });
if (!card || !card.boardId) {
return this.ready();
return [];
}
const board = ReactiveCache.getBoard({ _id: card.boardId });
if (!board || !board.isVisibleBy(userId)) {
return this.ready();
return [];
}
// If user has assigned-only permissions, check if they're assigned to this card
if (userId && board.members) {
const member = _.findWhere(board.members, { userId: userId, isActive: true });
if (member && (member.isNormalAssignedOnly || member.isCommentAssignedOnly || member.isReadAssignedOnly)) {
// User with assigned-only permissions can only view cards assigned to them
if (!card.assignees || !card.assignees.includes(userId)) {
return this.ready(); // Don't publish if user is not assigned
return []; // Don't publish if user is not assigned
}
}
}
this.cursor(
ReactiveCache.getCards(
{ _id: cardId },
{},
true,
),
function(cardId, card) {
this.cursor(ReactiveCache.getBoards({_id: card.boardId}, {}, true));
this.cursor(ReactiveCache.getLists({boardId: card.boardId}, {}, true));
return {
find() {
return ReactiveCache.getCards({ _id: cardId }, {}, true);
},
);
const ret = this.ready()
return ret;
children: [
{
find(card) {
return ReactiveCache.getBoards({ _id: card.boardId }, {}, true);
}
},
{
find(card) {
return ReactiveCache.getLists({ boardId: card.boardId }, {}, true);
}
}
]
};
});
Meteor.publish('myCards', function(sessionId) {