@jskit-ai/workspaces-web 0.2.9 → 0.2.11
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/fixtures/workspaces-components/index.html +2 -0
- package/fixtures/workspaces-components/main.js +90 -0
- package/fixtures/workspaces-components/vite.config.mjs +9 -0
- package/package.json +8 -8
- package/patterns/workspace-surfaces/example/src/composables/useWorkspaceNotFoundState.js +2 -2
- package/src/client/account-settings/accountSettingsInvitesRuntime.js +25 -7
- package/src/client/account-settings/useAccountSettingsInvitesSectionRuntime.js +11 -54
- package/src/client/browser.js +54 -0
- package/src/client/components/MembersAdminClientElement.vue +41 -111
- package/src/client/components/WorkspaceMembersClientElement.vue +17 -701
- package/src/client/components/WorkspaceSelector.vue +4 -18
- package/src/client/components/WorkspacesClientElement.vue +21 -392
- package/src/client/composables/useWorkspaceMembersActions.js +309 -0
- package/src/client/composables/useWorkspaceMembersPage.js +401 -0
- package/src/client/composables/useWorkspaceRouteContext.js +8 -3
- package/src/client/composables/useWorkspaceSurfaceId.js +15 -17
- package/src/client/composables/useWorkspacesLanding.js +386 -0
- package/src/client/lib/bootstrap.js +4 -9
- package/src/client/lib/lastWorkspace.js +7 -19
- package/src/client/lib/pendingInvites.js +53 -0
- package/src/client/lib/profileSurfaceMenuLinks.js +6 -5
- package/src/client/lib/surfaceAccessPolicy.js +18 -32
- package/src/client/lib/theme.js +8 -69
- package/src/client/lib/workspaceLinkResolver.js +9 -2
- package/src/client/lib/workspaceMembersPayloads.js +98 -0
- package/src/client/lib/workspaceSurfacePaths.js +3 -8
- package/src/client/providers/WorkspacesWebClientProvider.js +23 -22
- package/src/client/runtime/bootstrapPlacementRouteGuards.js +44 -41
- package/src/client/runtime/bootstrapPlacementRuntime.js +49 -76
- package/src/client/runtime/bootstrapPlacementRuntimeHelpers.js +6 -12
- package/src/client/support/realtimeWorkspace.js +6 -2
- package/src/client/support/runtimeNormalization.js +1 -8
- package/src/client/support/workspaceScopeSupport.js +10 -7
- package/src/client/types.js +168 -0
- package/test/bootstrapPlacementRuntime.test.js +25 -1
- package/test/pendingInvites.test.js +34 -0
- package/test/settingsPlacementContract.test.js +7 -3
- package/test/workspaceMembersPayloads.test.js +52 -0
- package/test/workspacesComponents.browser.test.js +285 -0
|
@@ -0,0 +1,309 @@
|
|
|
1
|
+
import { ref } from "vue";
|
|
2
|
+
import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
|
|
3
|
+
import { ROUTE_VISIBILITY_WORKSPACE } from "@jskit-ai/kernel/shared/support/visibility";
|
|
4
|
+
import {
|
|
5
|
+
WORKSPACE_INVITES_TRANSPORT,
|
|
6
|
+
WORKSPACE_INVITE_CREATE_TRANSPORT,
|
|
7
|
+
WORKSPACE_MEMBER_ROLE_UPDATE_TRANSPORT,
|
|
8
|
+
WORKSPACE_MEMBERS_TRANSPORT
|
|
9
|
+
} from "@jskit-ai/workspaces-core/shared/jsonApiTransports";
|
|
10
|
+
import { useCommand } from "@jskit-ai/http-web/client/composables/useCommand";
|
|
11
|
+
import { useUiFeedback } from "@jskit-ai/http-web/client/composables/useUiFeedback";
|
|
12
|
+
import { pageClipboard } from "../browser.js";
|
|
13
|
+
import { useJskitText } from "../i18n.js";
|
|
14
|
+
|
|
15
|
+
const OWNERSHIP_WORKSPACE = ROUTE_VISIBILITY_WORKSPACE;
|
|
16
|
+
|
|
17
|
+
/**
|
|
18
|
+
* What the members page lets a person do: invite, revoke an invitation, change a member's role, remove a member, and
|
|
19
|
+
* the feedback and progress of each.
|
|
20
|
+
* @param {object} options
|
|
21
|
+
* @param {import("../types.js").MembersAdminForms} options.forms
|
|
22
|
+
* @param {import("vue").Ref<string>} options.workspaceMembersApiPath
|
|
23
|
+
* @param {import("vue").Ref<string>} options.workspaceInvitesApiPath
|
|
24
|
+
* @param {import("vue").Ref<boolean>} options.canInviteMembers
|
|
25
|
+
* @param {import("vue").Ref<boolean>} options.canManageMembers
|
|
26
|
+
* @param {import("vue").Ref<boolean>} options.canRevokeInvites
|
|
27
|
+
* @param {{ refresh: () => Promise<unknown> }} options.workspaceRolesView
|
|
28
|
+
* @param {{ reload: () => Promise<unknown> }} options.workspaceMembersList
|
|
29
|
+
* @param {{ reload: () => Promise<unknown> }} options.workspaceInvitesList
|
|
30
|
+
*/
|
|
31
|
+
function useWorkspaceMembersActions({
|
|
32
|
+
forms,
|
|
33
|
+
workspaceMembersApiPath,
|
|
34
|
+
workspaceInvitesApiPath,
|
|
35
|
+
canInviteMembers,
|
|
36
|
+
canManageMembers,
|
|
37
|
+
canRevokeInvites,
|
|
38
|
+
workspaceRolesView,
|
|
39
|
+
workspaceMembersList,
|
|
40
|
+
workspaceInvitesList
|
|
41
|
+
}) {
|
|
42
|
+
const { t } = useJskitText();
|
|
43
|
+
const inviteFeedback = useUiFeedback();
|
|
44
|
+
const membersFeedback = useUiFeedback();
|
|
45
|
+
const teamFeedback = useUiFeedback();
|
|
46
|
+
const revokeInviteId = ref("");
|
|
47
|
+
const removeMemberUserId = ref("");
|
|
48
|
+
const createdInviteUrl = ref("");
|
|
49
|
+
const createdInviteDeliveryStatus = ref("");
|
|
50
|
+
const isCopyingInviteLink = ref(false);
|
|
51
|
+
|
|
52
|
+
function workspaceMembersPath(memberId) {
|
|
53
|
+
const normalizedMemberId = encodeURIComponent(String(memberId || "").trim());
|
|
54
|
+
return `${workspaceMembersApiPath.value}/${normalizedMemberId}`;
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
function workspaceInvitePath(inviteId) {
|
|
58
|
+
const encodedInviteId = encodeURIComponent(String(inviteId || ""));
|
|
59
|
+
return `${workspaceInvitesApiPath.value}/${encodedInviteId}`;
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
const inviteCreateCommand = useCommand({
|
|
63
|
+
ownershipFilter: OWNERSHIP_WORKSPACE,
|
|
64
|
+
apiSuffix: "/invites",
|
|
65
|
+
runPermissions: ["workspace.members.invite"],
|
|
66
|
+
writeMethod: "POST",
|
|
67
|
+
transport: WORKSPACE_INVITE_CREATE_TRANSPORT,
|
|
68
|
+
fallbackRunError: t("jskit.workspaces.members.createInviteFailed"),
|
|
69
|
+
suppressSuccessMessage: true,
|
|
70
|
+
buildRawPayload: () => ({
|
|
71
|
+
email: forms.invite.email,
|
|
72
|
+
roleSid: forms.invite.roleSid
|
|
73
|
+
}),
|
|
74
|
+
messages: {
|
|
75
|
+
error: t("jskit.workspaces.members.createInviteFailed")
|
|
76
|
+
}
|
|
77
|
+
});
|
|
78
|
+
|
|
79
|
+
const revokeInviteCommand = useCommand({
|
|
80
|
+
ownershipFilter: OWNERSHIP_WORKSPACE,
|
|
81
|
+
apiSuffix: "/invites",
|
|
82
|
+
runPermissions: ["workspace.invites.revoke"],
|
|
83
|
+
writeMethod: "DELETE",
|
|
84
|
+
transport: WORKSPACE_INVITES_TRANSPORT,
|
|
85
|
+
fallbackRunError: t("jskit.workspaces.members.revokeInviteFailed"),
|
|
86
|
+
buildCommandOptions: (_parsed, { context }) => {
|
|
87
|
+
return {
|
|
88
|
+
method: "DELETE",
|
|
89
|
+
path: workspaceInvitePath(context?.inviteId)
|
|
90
|
+
};
|
|
91
|
+
},
|
|
92
|
+
messages: {
|
|
93
|
+
success: t("jskit.workspaces.members.inviteRevoked"),
|
|
94
|
+
error: t("jskit.workspaces.members.revokeInviteFailed")
|
|
95
|
+
}
|
|
96
|
+
});
|
|
97
|
+
|
|
98
|
+
const memberRoleCommand = useCommand({
|
|
99
|
+
ownershipFilter: OWNERSHIP_WORKSPACE,
|
|
100
|
+
apiSuffix: "/members",
|
|
101
|
+
runPermissions: ["workspace.members.manage"],
|
|
102
|
+
writeMethod: "PATCH",
|
|
103
|
+
transport: WORKSPACE_MEMBER_ROLE_UPDATE_TRANSPORT,
|
|
104
|
+
fallbackRunError: t("jskit.workspaces.members.updateRoleFailed"),
|
|
105
|
+
buildRawPayload: (_model, { context }) => ({
|
|
106
|
+
roleSid: String(context?.roleSid || "").trim().toLowerCase()
|
|
107
|
+
}),
|
|
108
|
+
buildCommandOptions: (_parsed, { context }) => {
|
|
109
|
+
return {
|
|
110
|
+
method: "PATCH",
|
|
111
|
+
path: `${workspaceMembersPath(context?.memberUserId)}/role`
|
|
112
|
+
};
|
|
113
|
+
},
|
|
114
|
+
messages: {
|
|
115
|
+
success: t("jskit.workspaces.members.roleUpdated"),
|
|
116
|
+
error: t("jskit.workspaces.members.updateRoleFailed")
|
|
117
|
+
}
|
|
118
|
+
});
|
|
119
|
+
|
|
120
|
+
const memberRemoveCommand = useCommand({
|
|
121
|
+
ownershipFilter: OWNERSHIP_WORKSPACE,
|
|
122
|
+
apiSuffix: "/members",
|
|
123
|
+
runPermissions: ["workspace.members.manage"],
|
|
124
|
+
writeMethod: "DELETE",
|
|
125
|
+
transport: WORKSPACE_MEMBERS_TRANSPORT,
|
|
126
|
+
fallbackRunError: t("jskit.workspaces.members.removeFailed"),
|
|
127
|
+
buildCommandOptions: (_parsed, { context }) => {
|
|
128
|
+
return {
|
|
129
|
+
method: "DELETE",
|
|
130
|
+
path: workspaceMembersPath(context?.memberUserId)
|
|
131
|
+
};
|
|
132
|
+
},
|
|
133
|
+
messages: {
|
|
134
|
+
success: t("jskit.workspaces.members.removed"),
|
|
135
|
+
error: t("jskit.workspaces.members.removeFailed")
|
|
136
|
+
}
|
|
137
|
+
});
|
|
138
|
+
|
|
139
|
+
function clearMessages() {
|
|
140
|
+
inviteFeedback.clear();
|
|
141
|
+
membersFeedback.clear();
|
|
142
|
+
teamFeedback.clear();
|
|
143
|
+
}
|
|
144
|
+
|
|
145
|
+
function clearProgress() {
|
|
146
|
+
revokeInviteId.value = "";
|
|
147
|
+
removeMemberUserId.value = "";
|
|
148
|
+
createdInviteUrl.value = "";
|
|
149
|
+
createdInviteDeliveryStatus.value = "";
|
|
150
|
+
}
|
|
151
|
+
|
|
152
|
+
async function submitInvite() {
|
|
153
|
+
if (inviteCreateCommand.isRunning || !canInviteMembers.value) {
|
|
154
|
+
return;
|
|
155
|
+
}
|
|
156
|
+
|
|
157
|
+
inviteFeedback.clear();
|
|
158
|
+
createdInviteUrl.value = "";
|
|
159
|
+
createdInviteDeliveryStatus.value = "";
|
|
160
|
+
|
|
161
|
+
try {
|
|
162
|
+
const result = await inviteCreateCommand.run();
|
|
163
|
+
const delivery = result?.inviteDelivery && typeof result.inviteDelivery === "object"
|
|
164
|
+
? result.inviteDelivery
|
|
165
|
+
: {};
|
|
166
|
+
createdInviteUrl.value = String(result?.inviteUrl || "").trim();
|
|
167
|
+
createdInviteDeliveryStatus.value = String(delivery.status || "").trim().toLowerCase();
|
|
168
|
+
forms.invite.email = "";
|
|
169
|
+
await Promise.all([
|
|
170
|
+
workspaceInvitesList.reload(),
|
|
171
|
+
workspaceRolesView.refresh()
|
|
172
|
+
]);
|
|
173
|
+
if (createdInviteDeliveryStatus.value === "sent") {
|
|
174
|
+
inviteFeedback.success(t("jskit.workspaces.members.inviteSent"));
|
|
175
|
+
} else if (createdInviteDeliveryStatus.value === "failed") {
|
|
176
|
+
inviteFeedback.success(t("jskit.workspaces.members.inviteCreatedDeliveryFailed"));
|
|
177
|
+
} else {
|
|
178
|
+
inviteFeedback.success(t("jskit.workspaces.members.inviteCreated"));
|
|
179
|
+
}
|
|
180
|
+
} catch (error) {
|
|
181
|
+
inviteFeedback.error(error, t("jskit.workspaces.members.createInviteFailed"));
|
|
182
|
+
}
|
|
183
|
+
}
|
|
184
|
+
|
|
185
|
+
async function copyCreatedInviteLink() {
|
|
186
|
+
const inviteUrl = String(createdInviteUrl.value || "").trim();
|
|
187
|
+
if (!inviteUrl || isCopyingInviteLink.value) {
|
|
188
|
+
return;
|
|
189
|
+
}
|
|
190
|
+
|
|
191
|
+
isCopyingInviteLink.value = true;
|
|
192
|
+
try {
|
|
193
|
+
const clipboard = pageClipboard();
|
|
194
|
+
if (!clipboard) {
|
|
195
|
+
inviteFeedback.success(t("jskit.workspaces.members.linkReady"));
|
|
196
|
+
return;
|
|
197
|
+
}
|
|
198
|
+
|
|
199
|
+
await clipboard.writeText(inviteUrl);
|
|
200
|
+
inviteFeedback.success(t("jskit.workspaces.members.linkCopied"));
|
|
201
|
+
} catch (error) {
|
|
202
|
+
inviteFeedback.error(error, t("jskit.workspaces.members.copyLinkFailed"));
|
|
203
|
+
} finally {
|
|
204
|
+
isCopyingInviteLink.value = false;
|
|
205
|
+
}
|
|
206
|
+
}
|
|
207
|
+
|
|
208
|
+
async function submitRevokeInvite(inviteId) {
|
|
209
|
+
if (revokeInviteCommand.isRunning || !canRevokeInvites.value) {
|
|
210
|
+
return;
|
|
211
|
+
}
|
|
212
|
+
|
|
213
|
+
revokeInviteId.value = normalizeRecordId(inviteId, { fallback: "" });
|
|
214
|
+
teamFeedback.clear();
|
|
215
|
+
|
|
216
|
+
try {
|
|
217
|
+
await revokeInviteCommand.run({
|
|
218
|
+
inviteId
|
|
219
|
+
});
|
|
220
|
+
await Promise.all([
|
|
221
|
+
workspaceInvitesList.reload(),
|
|
222
|
+
workspaceRolesView.refresh()
|
|
223
|
+
]);
|
|
224
|
+
teamFeedback.success(t("jskit.workspaces.members.inviteRevoked"));
|
|
225
|
+
} catch (error) {
|
|
226
|
+
teamFeedback.error(error, t("jskit.workspaces.members.revokeInviteFailed"));
|
|
227
|
+
} finally {
|
|
228
|
+
revokeInviteId.value = "";
|
|
229
|
+
}
|
|
230
|
+
}
|
|
231
|
+
|
|
232
|
+
async function submitMemberRoleUpdate(member, roleSid) {
|
|
233
|
+
if (!canManageMembers.value) {
|
|
234
|
+
return;
|
|
235
|
+
}
|
|
236
|
+
|
|
237
|
+
membersFeedback.clear();
|
|
238
|
+
|
|
239
|
+
try {
|
|
240
|
+
const memberUserId = normalizeRecordId(member?.userId, { fallback: null });
|
|
241
|
+
if (!memberUserId) {
|
|
242
|
+
throw new Error(t("jskit.workspaces.members.memberIdInvalid"));
|
|
243
|
+
}
|
|
244
|
+
|
|
245
|
+
await memberRoleCommand.run({
|
|
246
|
+
memberUserId,
|
|
247
|
+
roleSid
|
|
248
|
+
});
|
|
249
|
+
await Promise.all([
|
|
250
|
+
workspaceMembersList.reload(),
|
|
251
|
+
workspaceRolesView.refresh()
|
|
252
|
+
]);
|
|
253
|
+
membersFeedback.success(t("jskit.workspaces.members.roleUpdated"));
|
|
254
|
+
} catch (error) {
|
|
255
|
+
membersFeedback.error(error, t("jskit.workspaces.members.updateRoleFailed"));
|
|
256
|
+
}
|
|
257
|
+
}
|
|
258
|
+
|
|
259
|
+
async function submitRemoveMember(member) {
|
|
260
|
+
if (memberRemoveCommand.isRunning || !canManageMembers.value) {
|
|
261
|
+
return;
|
|
262
|
+
}
|
|
263
|
+
|
|
264
|
+
membersFeedback.clear();
|
|
265
|
+
|
|
266
|
+
try {
|
|
267
|
+
const memberUserId = normalizeRecordId(member?.userId, { fallback: null });
|
|
268
|
+
if (!memberUserId) {
|
|
269
|
+
throw new Error(t("jskit.workspaces.members.memberIdInvalid"));
|
|
270
|
+
}
|
|
271
|
+
|
|
272
|
+
removeMemberUserId.value = normalizeRecordId(memberUserId, { fallback: "" });
|
|
273
|
+
await memberRemoveCommand.run({
|
|
274
|
+
memberUserId
|
|
275
|
+
});
|
|
276
|
+
await Promise.all([
|
|
277
|
+
workspaceMembersList.reload(),
|
|
278
|
+
workspaceRolesView.refresh()
|
|
279
|
+
]);
|
|
280
|
+
membersFeedback.success(t("jskit.workspaces.members.removed"));
|
|
281
|
+
} catch (error) {
|
|
282
|
+
membersFeedback.error(error, t("jskit.workspaces.members.removeFailed"));
|
|
283
|
+
} finally {
|
|
284
|
+
removeMemberUserId.value = "";
|
|
285
|
+
}
|
|
286
|
+
}
|
|
287
|
+
|
|
288
|
+
return {
|
|
289
|
+
inviteCreateCommand,
|
|
290
|
+
revokeInviteCommand,
|
|
291
|
+
memberRemoveCommand,
|
|
292
|
+
revokeInviteId,
|
|
293
|
+
removeMemberUserId,
|
|
294
|
+
createdInviteUrl,
|
|
295
|
+
createdInviteDeliveryStatus,
|
|
296
|
+
isCopyingInviteLink,
|
|
297
|
+
clearMessages,
|
|
298
|
+
clearProgress,
|
|
299
|
+
actions: Object.freeze({
|
|
300
|
+
submitInvite,
|
|
301
|
+
copyCreatedInviteLink,
|
|
302
|
+
submitRevokeInvite,
|
|
303
|
+
submitMemberRoleUpdate,
|
|
304
|
+
submitRemoveMember
|
|
305
|
+
})
|
|
306
|
+
};
|
|
307
|
+
}
|
|
308
|
+
|
|
309
|
+
export { useWorkspaceMembersActions };
|
|
@@ -0,0 +1,401 @@
|
|
|
1
|
+
import { computed, reactive, watch } from "vue";
|
|
2
|
+
import { ROUTE_VISIBILITY_WORKSPACE } from "@jskit-ai/kernel/shared/support/visibility";
|
|
3
|
+
import {
|
|
4
|
+
WORKSPACE_INVITES_TRANSPORT,
|
|
5
|
+
WORKSPACE_MEMBERS_TRANSPORT,
|
|
6
|
+
WORKSPACE_ROLE_CATALOG_TRANSPORT,
|
|
7
|
+
WORKSPACE_SETTINGS_TRANSPORT
|
|
8
|
+
} from "@jskit-ai/workspaces-core/shared/jsonApiTransports";
|
|
9
|
+
import { useList } from "@jskit-ai/http-web/client/composables/useList";
|
|
10
|
+
import { useView } from "@jskit-ai/http-web/client/composables/useView";
|
|
11
|
+
import { usePaths } from "@jskit-ai/shell-web/client/navigation/usePaths";
|
|
12
|
+
import { useAccess } from "@jskit-ai/http-web/client/composables/useAccess";
|
|
13
|
+
import { useJskitText } from "../i18n.js";
|
|
14
|
+
import { latestPage, normalizeInvites, normalizeMembers, normalizeRoleCatalog } from "../lib/workspaceMembersPayloads.js";
|
|
15
|
+
import { createWorkspaceRealtimeMatcher } from "../support/realtimeWorkspace.js";
|
|
16
|
+
import { buildWorkspaceQueryKey } from "../support/workspaceQueryKeys.js";
|
|
17
|
+
import { useWorkspaceMembersActions } from "./useWorkspaceMembersActions.js";
|
|
18
|
+
import { useWorkspaceRouteContext } from "./useWorkspaceRouteContext.js";
|
|
19
|
+
|
|
20
|
+
const OWNERSHIP_WORKSPACE = ROUTE_VISIBILITY_WORKSPACE;
|
|
21
|
+
|
|
22
|
+
/** The workspace members page: what it loads for the workspace on the route, and what it shows while loading. */
|
|
23
|
+
function useWorkspaceMembersPage() {
|
|
24
|
+
const { t, formatDateTime } = useJskitText();
|
|
25
|
+
|
|
26
|
+
const forms = reactive({
|
|
27
|
+
invite: {
|
|
28
|
+
email: "",
|
|
29
|
+
roleSid: "member"
|
|
30
|
+
},
|
|
31
|
+
workspace: {
|
|
32
|
+
invitesEnabled: false,
|
|
33
|
+
invitesAvailable: false
|
|
34
|
+
}
|
|
35
|
+
});
|
|
36
|
+
|
|
37
|
+
const options = reactive({
|
|
38
|
+
inviteRoleOptions: [],
|
|
39
|
+
memberRoleOptions: [],
|
|
40
|
+
roleLabels: Object.create(null),
|
|
41
|
+
formatRole(roleSid, fallback = roleSid) {
|
|
42
|
+
return options.roleLabels[roleSid] || fallback;
|
|
43
|
+
},
|
|
44
|
+
formatDateTime(value) {
|
|
45
|
+
return formatDateTime(value) || t("jskit.workspaces.common.unknownDate");
|
|
46
|
+
}
|
|
47
|
+
});
|
|
48
|
+
|
|
49
|
+
const collections = reactive({
|
|
50
|
+
members: [],
|
|
51
|
+
invites: []
|
|
52
|
+
});
|
|
53
|
+
|
|
54
|
+
const { route, currentSurfaceId, workspaceSlugFromRoute } = useWorkspaceRouteContext();
|
|
55
|
+
const usersPaths = usePaths();
|
|
56
|
+
|
|
57
|
+
const hasRouteWorkspaceSlug = computed(() => Boolean(workspaceSlugFromRoute.value));
|
|
58
|
+
const workspaceMembersApiPath = computed(() =>
|
|
59
|
+
usersPaths.api("/members", {
|
|
60
|
+
params: {
|
|
61
|
+
workspaceSlug: workspaceSlugFromRoute.value
|
|
62
|
+
}
|
|
63
|
+
})
|
|
64
|
+
);
|
|
65
|
+
const workspaceInvitesApiPath = computed(() =>
|
|
66
|
+
usersPaths.api("/invites", {
|
|
67
|
+
params: {
|
|
68
|
+
workspaceSlug: workspaceSlugFromRoute.value
|
|
69
|
+
}
|
|
70
|
+
})
|
|
71
|
+
);
|
|
72
|
+
|
|
73
|
+
const access = useAccess({
|
|
74
|
+
enabled: hasRouteWorkspaceSlug
|
|
75
|
+
});
|
|
76
|
+
|
|
77
|
+
const matchesWorkspaceRealtime = createWorkspaceRealtimeMatcher(workspaceSlugFromRoute);
|
|
78
|
+
|
|
79
|
+
const canViewMembers = computed(() => {
|
|
80
|
+
return access.canAny(["workspace.members.view", "workspace.members.manage"]);
|
|
81
|
+
});
|
|
82
|
+
|
|
83
|
+
const canInviteMembers = computed(() => {
|
|
84
|
+
return access.can("workspace.members.invite");
|
|
85
|
+
});
|
|
86
|
+
|
|
87
|
+
const canManageMembers = computed(() => {
|
|
88
|
+
return access.can("workspace.members.manage");
|
|
89
|
+
});
|
|
90
|
+
|
|
91
|
+
const canRevokeInvites = computed(() => {
|
|
92
|
+
return access.can("workspace.invites.revoke");
|
|
93
|
+
});
|
|
94
|
+
|
|
95
|
+
const permissionState = computed(() => {
|
|
96
|
+
return {
|
|
97
|
+
canViewMembers: canViewMembers.value,
|
|
98
|
+
canInviteMembers: canInviteMembers.value,
|
|
99
|
+
canManageMembers: canManageMembers.value,
|
|
100
|
+
canRevokeInvites: canRevokeInvites.value
|
|
101
|
+
};
|
|
102
|
+
});
|
|
103
|
+
|
|
104
|
+
function clearRoleOptions() {
|
|
105
|
+
options.inviteRoleOptions = [];
|
|
106
|
+
options.memberRoleOptions = [];
|
|
107
|
+
options.roleLabels = Object.create(null);
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
function applyRoleCatalog(payload) {
|
|
111
|
+
const normalizedCatalog = normalizeRoleCatalog(payload);
|
|
112
|
+
options.roleLabels = normalizedCatalog.roleLabels;
|
|
113
|
+
options.inviteRoleOptions = [...normalizedCatalog.roleOptions];
|
|
114
|
+
options.memberRoleOptions = [...normalizedCatalog.roleOptions];
|
|
115
|
+
|
|
116
|
+
const selectedInviteRole = String(forms.invite.roleSid || "").trim().toLowerCase();
|
|
117
|
+
const hasSelectedInviteRole = normalizedCatalog.roleOptions.some((entry) => entry.value === selectedInviteRole);
|
|
118
|
+
|
|
119
|
+
if (
|
|
120
|
+
normalizedCatalog.defaultInviteRole &&
|
|
121
|
+
normalizedCatalog.roleOptions.some((entry) => entry.value === normalizedCatalog.defaultInviteRole)
|
|
122
|
+
) {
|
|
123
|
+
forms.invite.roleSid = normalizedCatalog.defaultInviteRole;
|
|
124
|
+
return;
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
if (!hasSelectedInviteRole && normalizedCatalog.roleOptions.length > 0) {
|
|
128
|
+
forms.invite.roleSid = normalizedCatalog.roleOptions[0].value;
|
|
129
|
+
}
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
function applyWorkspaceSettingsPolicy(payload) {
|
|
133
|
+
const settings = payload?.settings && typeof payload.settings === "object" ? payload.settings : {};
|
|
134
|
+
forms.workspace.invitesEnabled = settings.invitesEnabled !== false;
|
|
135
|
+
forms.workspace.invitesAvailable = settings.invitesAvailable !== false;
|
|
136
|
+
}
|
|
137
|
+
|
|
138
|
+
const workspaceSettingsView = useView({
|
|
139
|
+
ownershipFilter: OWNERSHIP_WORKSPACE,
|
|
140
|
+
apiSuffix: "/settings",
|
|
141
|
+
queryKeyFactory: (surfaceId = "", workspaceSlug = "") =>
|
|
142
|
+
buildWorkspaceQueryKey("settings", surfaceId, workspaceSlug),
|
|
143
|
+
viewPermissions: ["workspace.members.invite"],
|
|
144
|
+
realtime: {
|
|
145
|
+
event: "workspace.settings.changed",
|
|
146
|
+
matches: matchesWorkspaceRealtime
|
|
147
|
+
},
|
|
148
|
+
transport: WORKSPACE_SETTINGS_TRANSPORT,
|
|
149
|
+
fallbackLoadError: t("jskit.workspaces.members.loadSettingsFailed")
|
|
150
|
+
});
|
|
151
|
+
|
|
152
|
+
const workspaceRolesView = useView({
|
|
153
|
+
ownershipFilter: OWNERSHIP_WORKSPACE,
|
|
154
|
+
apiSuffix: "/roles",
|
|
155
|
+
queryKeyFactory: (surfaceId = "", workspaceSlug = "") => buildWorkspaceQueryKey("roles", surfaceId, workspaceSlug),
|
|
156
|
+
viewPermissions: ["workspace.members.view", "workspace.members.invite", "workspace.members.manage"],
|
|
157
|
+
transport: WORKSPACE_ROLE_CATALOG_TRANSPORT,
|
|
158
|
+
fallbackLoadError: t("jskit.workspaces.members.loadRolesFailed")
|
|
159
|
+
});
|
|
160
|
+
|
|
161
|
+
const workspaceMembersList = useList({
|
|
162
|
+
ownershipFilter: OWNERSHIP_WORKSPACE,
|
|
163
|
+
apiSuffix: "/members",
|
|
164
|
+
queryKeyFactory: (surfaceId = "", workspaceSlug = "") =>
|
|
165
|
+
buildWorkspaceQueryKey("members", surfaceId, workspaceSlug),
|
|
166
|
+
viewPermissions: ["workspace.members.view", "workspace.members.manage"],
|
|
167
|
+
realtime: {
|
|
168
|
+
event: "workspace.members.changed",
|
|
169
|
+
matches: matchesWorkspaceRealtime
|
|
170
|
+
},
|
|
171
|
+
transport: WORKSPACE_MEMBERS_TRANSPORT,
|
|
172
|
+
selectItems: (payload) => normalizeMembers(payload?.members),
|
|
173
|
+
fallbackLoadError: t("jskit.workspaces.members.loadMembersFailed")
|
|
174
|
+
});
|
|
175
|
+
|
|
176
|
+
const workspaceInvitesList = useList({
|
|
177
|
+
ownershipFilter: OWNERSHIP_WORKSPACE,
|
|
178
|
+
apiSuffix: "/invites",
|
|
179
|
+
queryKeyFactory: (surfaceId = "", workspaceSlug = "") =>
|
|
180
|
+
buildWorkspaceQueryKey("invites", surfaceId, workspaceSlug),
|
|
181
|
+
viewPermissions: ["workspace.members.view", "workspace.members.manage"],
|
|
182
|
+
realtime: {
|
|
183
|
+
event: "workspace.invites.changed",
|
|
184
|
+
matches: matchesWorkspaceRealtime
|
|
185
|
+
},
|
|
186
|
+
transport: WORKSPACE_INVITES_TRANSPORT,
|
|
187
|
+
selectItems: (payload) => normalizeInvites(payload?.invites),
|
|
188
|
+
fallbackLoadError: t("jskit.workspaces.members.loadInvitesFailed")
|
|
189
|
+
});
|
|
190
|
+
|
|
191
|
+
const {
|
|
192
|
+
inviteCreateCommand,
|
|
193
|
+
revokeInviteCommand,
|
|
194
|
+
memberRemoveCommand,
|
|
195
|
+
revokeInviteId,
|
|
196
|
+
removeMemberUserId,
|
|
197
|
+
createdInviteUrl,
|
|
198
|
+
createdInviteDeliveryStatus,
|
|
199
|
+
isCopyingInviteLink,
|
|
200
|
+
clearMessages,
|
|
201
|
+
clearProgress,
|
|
202
|
+
actions
|
|
203
|
+
} = useWorkspaceMembersActions({
|
|
204
|
+
forms,
|
|
205
|
+
workspaceMembersApiPath,
|
|
206
|
+
workspaceInvitesApiPath,
|
|
207
|
+
canInviteMembers,
|
|
208
|
+
canManageMembers,
|
|
209
|
+
canRevokeInvites,
|
|
210
|
+
workspaceRolesView,
|
|
211
|
+
workspaceMembersList,
|
|
212
|
+
workspaceInvitesList
|
|
213
|
+
});
|
|
214
|
+
|
|
215
|
+
function resetViewState() {
|
|
216
|
+
clearMessages();
|
|
217
|
+
forms.invite.email = "";
|
|
218
|
+
forms.invite.roleSid = "member";
|
|
219
|
+
forms.workspace.invitesEnabled = false;
|
|
220
|
+
forms.workspace.invitesAvailable = false;
|
|
221
|
+
collections.members = [];
|
|
222
|
+
collections.invites = [];
|
|
223
|
+
clearRoleOptions();
|
|
224
|
+
clearProgress();
|
|
225
|
+
}
|
|
226
|
+
|
|
227
|
+
const status = computed(() => {
|
|
228
|
+
return {
|
|
229
|
+
isCreatingInvite: Boolean(inviteCreateCommand.isRunning),
|
|
230
|
+
isRevokingInvite: Boolean(revokeInviteCommand.isRunning),
|
|
231
|
+
isRemovingMember: Boolean(memberRemoveCommand.isRunning),
|
|
232
|
+
isCopyingInviteLink: Boolean(isCopyingInviteLink.value),
|
|
233
|
+
createdInviteUrl: createdInviteUrl.value,
|
|
234
|
+
createdInviteDeliveryStatus: createdInviteDeliveryStatus.value,
|
|
235
|
+
hasLoadedWorkspaceSettings: !canInviteMembers.value || !workspaceSettingsView.isLoading,
|
|
236
|
+
hasLoadedMembersList: !canViewMembers.value || !workspaceMembersList.isInitialLoading,
|
|
237
|
+
hasLoadedInviteList: !canViewMembers.value || !workspaceInvitesList.isInitialLoading,
|
|
238
|
+
isRefreshingWorkspaceSettings: canInviteMembers.value && Boolean(workspaceSettingsView.isRefetching),
|
|
239
|
+
isRefreshingMembersList: canViewMembers.value && Boolean(workspaceMembersList.isRefetching),
|
|
240
|
+
isRefreshingInviteList: canViewMembers.value && Boolean(workspaceInvitesList.isRefetching)
|
|
241
|
+
};
|
|
242
|
+
});
|
|
243
|
+
|
|
244
|
+
const loadError = computed(() => {
|
|
245
|
+
if (!hasRouteWorkspaceSlug.value) {
|
|
246
|
+
return t("jskit.workspaces.members.slugRequired");
|
|
247
|
+
}
|
|
248
|
+
|
|
249
|
+
return (
|
|
250
|
+
access.permissionsUnavailableError.value ||
|
|
251
|
+
workspaceSettingsView.loadError ||
|
|
252
|
+
workspaceRolesView.loadError ||
|
|
253
|
+
workspaceMembersList.loadError ||
|
|
254
|
+
workspaceInvitesList.loadError ||
|
|
255
|
+
""
|
|
256
|
+
);
|
|
257
|
+
});
|
|
258
|
+
const canRetryLoad = computed(() => Boolean(hasRouteWorkspaceSlug.value && !access.permissionsUnavailableError.value));
|
|
259
|
+
const isRetryingLoad = computed(() =>
|
|
260
|
+
Boolean(
|
|
261
|
+
workspaceSettingsView.isFetching ||
|
|
262
|
+
workspaceRolesView.isFetching ||
|
|
263
|
+
workspaceMembersList.isFetching ||
|
|
264
|
+
workspaceInvitesList.isFetching
|
|
265
|
+
)
|
|
266
|
+
);
|
|
267
|
+
|
|
268
|
+
async function refreshLoad() {
|
|
269
|
+
if (!canRetryLoad.value) {
|
|
270
|
+
return;
|
|
271
|
+
}
|
|
272
|
+
|
|
273
|
+
const jobs = [];
|
|
274
|
+
if (canInviteMembers.value) {
|
|
275
|
+
jobs.push(workspaceSettingsView.refresh());
|
|
276
|
+
}
|
|
277
|
+
if (canInviteMembers.value || canViewMembers.value) {
|
|
278
|
+
jobs.push(workspaceRolesView.refresh());
|
|
279
|
+
}
|
|
280
|
+
if (canViewMembers.value) {
|
|
281
|
+
jobs.push(workspaceMembersList.reload());
|
|
282
|
+
jobs.push(workspaceInvitesList.reload());
|
|
283
|
+
}
|
|
284
|
+
await Promise.all(jobs);
|
|
285
|
+
}
|
|
286
|
+
|
|
287
|
+
watch(
|
|
288
|
+
() => `${currentSurfaceId.value}:${workspaceSlugFromRoute.value}`,
|
|
289
|
+
() => {
|
|
290
|
+
resetViewState();
|
|
291
|
+
},
|
|
292
|
+
{ immediate: true }
|
|
293
|
+
);
|
|
294
|
+
|
|
295
|
+
watch(
|
|
296
|
+
() => workspaceSettingsView.record,
|
|
297
|
+
(payload) => {
|
|
298
|
+
if (!payload) {
|
|
299
|
+
return;
|
|
300
|
+
}
|
|
301
|
+
applyWorkspaceSettingsPolicy(payload);
|
|
302
|
+
},
|
|
303
|
+
{ immediate: true }
|
|
304
|
+
);
|
|
305
|
+
|
|
306
|
+
watch(
|
|
307
|
+
() => workspaceSettingsView.loadError,
|
|
308
|
+
(nextLoadError) => {
|
|
309
|
+
if (!nextLoadError) {
|
|
310
|
+
return;
|
|
311
|
+
}
|
|
312
|
+
forms.workspace.invitesEnabled = false;
|
|
313
|
+
forms.workspace.invitesAvailable = false;
|
|
314
|
+
}
|
|
315
|
+
);
|
|
316
|
+
|
|
317
|
+
watch(
|
|
318
|
+
() => workspaceRolesView.record,
|
|
319
|
+
(payload) => {
|
|
320
|
+
if (!payload) {
|
|
321
|
+
return;
|
|
322
|
+
}
|
|
323
|
+
applyRoleCatalog(payload);
|
|
324
|
+
},
|
|
325
|
+
{ immediate: true }
|
|
326
|
+
);
|
|
327
|
+
|
|
328
|
+
watch(
|
|
329
|
+
() => workspaceRolesView.loadError,
|
|
330
|
+
(nextLoadError) => {
|
|
331
|
+
if (!nextLoadError) {
|
|
332
|
+
return;
|
|
333
|
+
}
|
|
334
|
+
clearRoleOptions();
|
|
335
|
+
}
|
|
336
|
+
);
|
|
337
|
+
|
|
338
|
+
watch(
|
|
339
|
+
() => workspaceMembersList.items,
|
|
340
|
+
(nextMembers) => {
|
|
341
|
+
collections.members = Array.isArray(nextMembers) ? [...nextMembers] : [];
|
|
342
|
+
},
|
|
343
|
+
{ immediate: true }
|
|
344
|
+
);
|
|
345
|
+
|
|
346
|
+
watch(
|
|
347
|
+
() => workspaceMembersList.pages,
|
|
348
|
+
(pages) => {
|
|
349
|
+
const payload = latestPage(pages);
|
|
350
|
+
if (!payload) {
|
|
351
|
+
return;
|
|
352
|
+
}
|
|
353
|
+
applyRoleCatalog(payload);
|
|
354
|
+
},
|
|
355
|
+
{ immediate: true }
|
|
356
|
+
);
|
|
357
|
+
|
|
358
|
+
watch(
|
|
359
|
+
() => workspaceInvitesList.items,
|
|
360
|
+
(nextInvites) => {
|
|
361
|
+
collections.invites = Array.isArray(nextInvites) ? [...nextInvites] : [];
|
|
362
|
+
},
|
|
363
|
+
{ immediate: true }
|
|
364
|
+
);
|
|
365
|
+
|
|
366
|
+
watch(
|
|
367
|
+
() => workspaceInvitesList.pages,
|
|
368
|
+
(pages) => {
|
|
369
|
+
const payload = latestPage(pages);
|
|
370
|
+
if (!payload) {
|
|
371
|
+
return;
|
|
372
|
+
}
|
|
373
|
+
applyRoleCatalog(payload);
|
|
374
|
+
},
|
|
375
|
+
{ immediate: true }
|
|
376
|
+
);
|
|
377
|
+
|
|
378
|
+
watch(
|
|
379
|
+
() => route.fullPath,
|
|
380
|
+
() => {
|
|
381
|
+
clearMessages();
|
|
382
|
+
}
|
|
383
|
+
);
|
|
384
|
+
|
|
385
|
+
return {
|
|
386
|
+
forms,
|
|
387
|
+
options,
|
|
388
|
+
collections,
|
|
389
|
+
permissionState,
|
|
390
|
+
revokeInviteId,
|
|
391
|
+
removeMemberUserId,
|
|
392
|
+
status,
|
|
393
|
+
actions,
|
|
394
|
+
loadError,
|
|
395
|
+
canRetryLoad,
|
|
396
|
+
isRetryingLoad,
|
|
397
|
+
refreshLoad
|
|
398
|
+
};
|
|
399
|
+
}
|
|
400
|
+
|
|
401
|
+
export { useWorkspaceMembersPage };
|