@imenam/mcp-organizer 0.0.0-stage → 1.0.1

package/dist/src/core/spaces.js

@@ -0,0 +1,252 @@
+import { ACCESS_LINK_TTL_MS, accessLinkPath, issueAccessLink, joinInvitedSpace, normalizeEmail } from "./accounts.js";
+import { ForbiddenError, InvariantError, NotFoundError } from "./errors.js";
+import { deriveKeyPrefix } from "../../shared/logic/spaces.js";
+// --- Droits ---------------------------------------------------------------------
+/** Espace dont `userId` est membre ; un non-membre reçoit la même réponse qu'un espace inexistant. */
+export function requireMember(store, spaceId, userId) {
+    const space = store.findSpace(spaceId);
+    const membership = space ? store.findMembership(spaceId, userId) : null;
+    if (!space || !membership)
+        throw new NotFoundError("Espace introuvable, ou vous n'en êtes pas membre.");
+    return { space, membership };
+}
+/** Espace commun dont `userId` est le propriétaire. */
+export function requireOwner(store, spaceId, userId, action) {
+    const { space, membership } = requireMember(store, spaceId, userId);
+    if (space.kind === "personal")
+        throw new ForbiddenError(`Impossible de ${action} : c'est un espace personnel.`);
+    if (membership.role !== "owner")
+        throw new ForbiddenError(`Seul le propriétaire de l'espace « ${space.name} » peut ${action}.`);
+    return space;
+}
+// --- Vues -----------------------------------------------------------------------
+function summary(space, membership) {
+    return { id: space.id, name: space.name, kind: space.kind, keyPrefix: space.keyPrefix, ownerId: space.ownerId, role: membership.role };
+}
+function memberView(user, membership) {
+    return { userId: user.id, email: user.email, displayName: user.displayName, role: membership.role };
+}
+function invitationView(invitation, now) {
+    return {
+        id: invitation.id,
+        email: invitation.email,
+        createdAt: invitation.createdAt,
+        expiresAt: invitation.expiresAt,
+        expired: isExpired(invitation, now),
+    };
+}
+function isExpired(invitation, now) {
+    return Date.parse(invitation.expiresAt) <= now.getTime();
+}
+function invitationLink(token, expiresAt) {
+    return { path: accessLinkPath(token), expiresAt };
+}
+function userName(user) {
+    return user ? (user.displayName ?? user.email) : "un ancien membre";
+}
+// --- Espaces --------------------------------------------------------------------
+/** Espaces de l'utilisateur : son espace personnel d'abord, puis les espaces communs par nom. */
+export function listSpaces(store, userId) {
+    return store.listSpacesOf(userId).map((space) => summary(space, store.findMembership(space.id, userId)));
+}
+/** Crée un espace commun dont l'utilisateur est propriétaire ; le préfixe est dérivé du nom s'il est omis. */
+export function createSharedSpace(store, userId, input) {
+    return store.mutate({ type: "user", userId }, (tx) => {
+        const space = tx.createSpace({ name: input.name, kind: "shared", ownerId: userId, keyPrefix: input.keyPrefix ?? deriveKeyPrefix(input.name) });
+        return summary(space, tx.store.findMembership(space.id, userId));
+    });
+}
+export function renameSpace(store, userId, spaceId, name) {
+    return store.mutate({ type: "user", userId }, (tx) => {
+        requireOwner(tx.store, spaceId, userId, "renommer l'espace");
+        return summary(tx.renameSpace(spaceId, name), tx.store.findMembership(spaceId, userId));
+    });
+}
+/** Supprime un espace commun, son contenu et les fichiers de ses pièces jointes. */
+export function deleteSpace(store, storage, userId, spaceId) {
+    const removed = store.mutate({ type: "user", userId }, (tx) => {
+        requireOwner(tx.store, spaceId, userId, "supprimer l'espace");
+        const attachments = tx.store.listAttachmentsInSpace(spaceId);
+        tx.deleteSpace(spaceId);
+        return attachments;
+    });
+    storage.remove(removed.map((attachment) => attachment.storagePath));
+}
+// --- Membres --------------------------------------------------------------------
+/** Membres (propriétaire d'abord) et invitations en attente d'un espace, pour un de ses membres. */
+export function listMembers(store, userId, spaceId, now = new Date()) {
+    const { space, membership } = requireMember(store, spaceId, userId);
+    const members = store
+        .listMemberships(spaceId)
+        .map((m) => memberView(store.getUser(m.userId), m))
+        .sort((a, b) => (a.role === b.role ? 0 : a.role === "owner" ? -1 : 1));
+    const invitations = store.listOpenInvitations(spaceId).map((invitation) => invitationView(invitation, now));
+    return { space: summary(space, membership), members, invitations };
+}
+/** Le propriétaire retire un membre d'un espace commun. */
+export function removeMember(store, userId, spaceId, memberId) {
+    store.mutate({ type: "user", userId }, (tx) => {
+        const space = requireOwner(tx.store, spaceId, userId, "retirer un membre");
+        if (memberId === userId)
+            throw new InvariantError("Le propriétaire ne peut pas se retirer de son espace : supprimez l'espace à la place.");
+        if (!tx.store.isMember(spaceId, memberId))
+            throw new NotFoundError(`Cette personne n'est pas membre de l'espace « ${space.name} ».`);
+        tx.removeMember(spaceId, memberId);
+    });
+}
+/** Un membre quitte un espace commun ; le propriétaire ne le peut pas. */
+export function leaveSpace(store, userId, spaceId) {
+    store.mutate({ type: "user", userId }, (tx) => {
+        const { space, membership } = requireMember(tx.store, spaceId, userId);
+        if (space.kind === "personal")
+            throw new ForbiddenError("On ne quitte pas son espace personnel.");
+        if (membership.role === "owner")
+            throw new ForbiddenError(`Vous êtes propriétaire de « ${space.name} » : supprimez l'espace au lieu de le quitter.`);
+        tx.removeMember(spaceId, userId);
+    });
+}
+// --- Invitations ----------------------------------------------------------------
+/** E-mail d'invitation ; sans URL publique, il ne peut pas contenir de lien et n'est pas envoyé. */
+async function sendInvitationEmail(deps, to, inviter, space, link) {
+    const base = deps.publicUrl?.trim().replace(/\/+$/, "");
+    if (!base) {
+        return {
+            emailSent: false,
+            reason: "E-mail non envoyé : ORGANIZER_PUBLIC_URL n'est pas défini, le lien complet ne peut pas figurer dans le message. Transmettez le lien vous-même.",
+        };
+    }
+    const url = `${base}/${link.path}`;
+    const outcome = await deps.mailer.send({
+        to,
+        subject: `${inviter.displayName ?? inviter.email} vous invite dans « ${space.name} »`,
+        text: `${inviter.displayName ?? inviter.email} vous invite à rejoindre l'espace « ${space.name} » sur mcp-organizer.\n\n` +
+            `Pour créer votre compte, ouvrez ce lien (valable jusqu'au ${new Date(link.expiresAt).toLocaleDateString("fr-FR")}) :\n${url}\n`,
+    });
+    return outcome.sent ? { emailSent: true, reason: null } : { emailSent: false, reason: outcome.reason };
+}
+/**
+ * Le propriétaire invite une adresse. Un compte actif devient membre
+ * directement ; une adresse inconnue reçoit un compte `invited` ; un compte
+ * `invited` reçoit l'invitation en plus des siennes. Dans ces deux derniers
+ * cas, un lien d'activation propre à cette invitation est émis, renvoyé à
+ * l'invitant et envoyé par e-mail ; les liens des autres invitations du compte
+ * restent valables.
+ */
+export async function inviteToSpace(store, deps, userId, spaceId, rawEmail) {
+    const now = deps.now?.() ?? new Date();
+    const email = normalizeEmail(rawEmail);
+    const expiresAt = new Date(now.getTime() + ACCESS_LINK_TTL_MS).toISOString();
+    const outcome = store.mutate({ type: "user", userId }, (tx) => {
+        const space = requireOwner(tx.store, spaceId, userId, "inviter quelqu'un");
+        const existing = tx.store.findUserByEmail(email);
+        if (existing?.status === "disabled")
+            throw new ForbiddenError(`Le compte ${email} est désactivé : il ne peut pas être invité.`);
+        if (existing && tx.store.isMember(spaceId, existing.id))
+            throw new InvariantError(`${email} est déjà membre de « ${space.name} ».`);
+        if (existing?.status === "active") {
+            return { kind: "added", member: memberView(existing, tx.addMember(spaceId, existing.id)) };
+        }
+        if (tx.store.listOpenInvitations(spaceId).some((invitation) => invitation.email === email)) {
+            throw new InvariantError(`${email} a déjà une invitation en attente pour « ${space.name} » : renvoyez-la plutôt.`);
+        }
+        const invited = existing ?? tx.createUser({ email, status: "invited" });
+        const invitation = tx.createInvitation({ spaceId, email, expiresAt });
+        return { kind: "invited", space, invitation, issued: issueAccessLink(tx, invited.id, "invite", invitation.id, now) };
+    });
+    if (outcome.kind === "added")
+        return { outcome: "member_added", member: outcome.member };
+    const link = invitationLink(outcome.issued.token, outcome.issued.expiresAt);
+    const emailOutcome = await sendInvitationEmail(deps, email, store.getUser(userId), outcome.space, link);
+    return { outcome: "invited", invitation: invitationView(outcome.invitation, now), link, email: emailOutcome };
+}
+/** Invitation en attente d'un espace dont l'utilisateur est propriétaire. */
+function ownedOpenInvitation(store, userId, spaceId, invitationId, action) {
+    const space = requireOwner(store, spaceId, userId, action);
+    const invitation = store.findInvitation(invitationId);
+    if (!invitation || invitation.spaceId !== spaceId || invitation.acceptedAt !== null || invitation.revokedAt !== null || invitation.declinedAt !== null) {
+        throw new NotFoundError("Cette invitation n'est plus en attente.");
+    }
+    return { space, invitation };
+}
+/**
+ * Renvoie une invitation avec une nouvelle échéance. Un compte encore à
+ * activer reçoit un nouveau lien, qui remplace le lien précédent de cette
+ * invitation seulement ; un compte déjà actif retrouve l'invitation dans ses
+ * « Invitations reçues », sans lien.
+ */
+export async function resendInvitation(store, deps, userId, spaceId, invitationId) {
+    const now = deps.now?.() ?? new Date();
+    const expiresAt = new Date(now.getTime() + ACCESS_LINK_TTL_MS).toISOString();
+    const { space, renewed, issued } = store.mutate({ type: "user", userId }, (tx) => {
+        const { space, invitation } = ownedOpenInvitation(tx.store, userId, spaceId, invitationId, "renvoyer une invitation");
+        const invited = tx.store.findUserByEmail(invitation.email);
+        if (!invited || invited.status === "disabled")
+            throw new InvariantError(`Le compte ${invitation.email} est désactivé : révoquez l'invitation.`);
+        const renewed = tx.renewInvitation(invitation.id, expiresAt);
+        const issued = invited.status === "invited" ? issueAccessLink(tx, invited.id, "invite", invitation.id, now) : null;
+        return { space, renewed, issued };
+    });
+    if (issued === null) {
+        return {
+            invitation: invitationView(renewed, now),
+            link: null,
+            email: {
+                emailSent: false,
+                reason: `${renewed.email} a déjà un compte actif : aucun lien n'est nécessaire, l'invitation l'attend dans ses « Invitations reçues ».`,
+            },
+        };
+    }
+    const link = invitationLink(issued.token, issued.expiresAt);
+    const emailOutcome = await sendInvitationEmail(deps, renewed.email, store.getUser(userId), space, link);
+    return { invitation: invitationView(renewed, now), link, email: emailOutcome };
+}
+/** Révoque une invitation ; son lien d'activation ne fonctionne plus. */
+export function revokeInvitation(store, userId, spaceId, invitationId) {
+    store.mutate({ type: "user", userId }, (tx) => {
+        const { invitation } = ownedOpenInvitation(tx.store, userId, spaceId, invitationId, "révoquer une invitation");
+        tx.revokeInvitation(invitation.id);
+    });
+}
+// --- Invitations reçues ---------------------------------------------------------
+/** Invitation en attente adressée à l'utilisateur ; toute autre reçoit la même réponse qu'une invitation inexistante. */
+function receivedInvitation(store, userId, invitationId) {
+    const user = store.getUser(userId);
+    const invitation = store.findInvitation(invitationId);
+    if (!invitation || invitation.email !== user.email || invitation.acceptedAt !== null || invitation.revokedAt !== null || invitation.declinedAt !== null) {
+        throw new NotFoundError("Invitation introuvable, ou elle n'est plus en attente.");
+    }
+    return invitation;
+}
+/** Invitations en attente et non expirées adressées à l'utilisateur, par date. */
+export function listReceivedInvitations(store, userId, now = new Date()) {
+    const user = store.getUser(userId);
+    const invitations = store
+        .listOpenInvitationsForEmail(user.email)
+        .filter((invitation) => !isExpired(invitation, now))
+        .map((invitation) => ({
+        id: invitation.id,
+        spaceId: invitation.spaceId,
+        spaceName: store.getSpace(invitation.spaceId).name,
+        invitedByName: userName(store.findUser(invitation.invitedBy)),
+        createdAt: invitation.createdAt,
+        expiresAt: invitation.expiresAt,
+    }));
+    return { invitations };
+}
+/** L'utilisateur accepte une invitation qui lui est adressée et rejoint l'espace. */
+export function acceptReceivedInvitation(store, userId, invitationId, now = new Date()) {
+    return store.mutate({ type: "user", userId }, (tx) => {
+        const invitation = receivedInvitation(tx.store, userId, invitationId);
+        if (isExpired(invitation, now)) {
+            throw new InvariantError(`Cette invitation a expiré : demandez à ${userName(tx.store.findUser(invitation.invitedBy))} de vous la renvoyer.`);
+        }
+        joinInvitedSpace(tx, userId, invitation.id);
+        return summary(tx.store.getSpace(invitation.spaceId), tx.store.findMembership(invitation.spaceId, userId));
+    });
+}
+/** L'utilisateur refuse une invitation qui lui est adressée. */
+export function declineReceivedInvitation(store, userId, invitationId) {
+    store.mutate({ type: "user", userId }, (tx) => {
+        tx.declineInvitation(receivedInvitation(tx.store, userId, invitationId).id);
+    });
+}