mirror of
https://github.com/outline/outline.git
synced 2026-11-22 22:02:35 +03:00
* feat: Personal collections backend Adds an owner to collections. A personal collection is private, one per user per team, created lazily through collections.personal, and only its owner can see or manage it. Admin bypasses in policies, lists, exports, events, webhooks and file operations exclude the personal collections of other users. Turning off the PersonalDocs preference makes the collection read-only. * test: Access matrix for personal collections Checks that collection and document endpoints, list and search results, MCP tools, collaboration and websocket rooms agree with the read policy for the owner, collaborators, members, admins, guests and other teams. * feat: Personal collection in the sidebar Adds a Personal sidebar section that renders the personal collection with the collection document tree, creates the collection on the first new document, and keeps it out of the Collections section. Adds the workspace setting, the personal sidebar context, and hides collection sharing and membership UI for personal collections. * fix: Drag and drop in shared with me trees Anchors the reorder drop cursor inside the row, and prefetches documents on hover so that nested rows that were never opened can be dragged. * feat: Personal collection owner for collaborators, no collection page Presents the owner of the personal collection on documents, so that collaborators see the owner in the share popover. Root rows in the Personal section show the default document icon. A personal collection has no page: the scene shows not found, and the breadcrumb, command bar and delete redirect no longer link to it. * fix: Personal sidebar indent and breadcrumb items without a link Children of rows at depth 0 skip a level so that they start beyond the row icon. Breadcrumb items without a destination, such as the personal and deleted collection, are shown as plain text. * test: Reduce personal collection tests to list paths Endpoints that authorize a single model are already covered by the policy tests. Keeps the lists and searches, which filter in queries, and the presenter. * test: Move personal collection list tests into collections tests * feat: Create documents in the personal collection by alias documents.create, documents.import and the MCP create_document tool accept the collectionId "personal", which refers to the personal collection of the user and creates it when it does not exist yet. * refactor: Remove collections.personal route The sidebar creates its first personal document with the personal collectionId alias, so documents.create is the only path that creates the personal collection. * feat: Personal collection name, starring, templates and default Personal collections cannot be starred, renamed or hold templates, and the PersonalDocs preference is on by default. The app shows collections through a displayName getter, which is the translated "Personal" for a personal collection. * fix: Use the same policy for starring and unstarring collections * fix: No pins or viewer insights for personal documents * revert: Show personal collection events in the audit log Admins with audit access should see events in personal collections, even when they cannot open the documents. * fix: Load collection owner in share scopes * fix: Keep personal collections out of workspace exports and webhooks Workspace exports skip all personal collections, while an explicit export of a personal collection stays available to its owner. Events in personal collections, including attachments and documents moved after queueing, are never delivered to workspace webhooks. Personal collections cannot be renamed or made public through any path, cannot hold pins, and are not offered as mentions. * Change icon to avatar * fix: Personal documents cannot be unpublished * feat: Personal collection context for MCP Collections are presented with an isPersonal flag, the server instructions explain the personal collection, and move_document and update_document accept the personal collectionId alias. * fix: Keep moved personal exports private and remove pins on move Document exports record the owner of the personal collection they came from, so they stay private after the document moves. Moving documents into a personal collection removes their pins, including pins to home. * fix: Only create the personal collection in MCP when it is used
1049 lines
26 KiB
TypeScript
1049 lines
26 KiB
TypeScript
import crypto from "node:crypto";
|
|
import { addHours, addMinutes, subMinutes } from "date-fns";
|
|
import JWT from "jsonwebtoken";
|
|
import type { Context } from "koa";
|
|
import type {
|
|
Transaction,
|
|
SaveOptions,
|
|
FindOptions,
|
|
InferAttributes,
|
|
InferCreationAttributes,
|
|
} from "sequelize";
|
|
import { QueryTypes, Op } from "sequelize";
|
|
import { type InstanceUpdateOptions } from "sequelize";
|
|
import {
|
|
Table,
|
|
Column,
|
|
IsIP,
|
|
IsEmail,
|
|
Default,
|
|
IsIn,
|
|
BeforeDestroy,
|
|
BeforeCreate,
|
|
BelongsTo,
|
|
ForeignKey,
|
|
DataType,
|
|
HasMany,
|
|
Scopes,
|
|
IsDate,
|
|
AllowNull,
|
|
AfterUpdate,
|
|
BeforeUpdate,
|
|
} from "sequelize-typescript";
|
|
import { UserPreferenceDefaults } from "@shared/constants";
|
|
import { languages } from "@shared/i18n";
|
|
import type {
|
|
NotificationSettings,
|
|
UserPreference,
|
|
UserPreferences,
|
|
NotificationEventType,
|
|
} from "@shared/types";
|
|
import {
|
|
CollectionPermission,
|
|
NotificationEventDefaults,
|
|
UserRole,
|
|
DocumentPermission,
|
|
} from "@shared/types";
|
|
import { UserRoleHelper } from "@shared/utils/UserRoleHelper";
|
|
import { stringToColor } from "@shared/utils/color";
|
|
import type { locales } from "@shared/utils/date";
|
|
import { UserValidation } from "@shared/validations";
|
|
import env from "@server/env";
|
|
import DeleteAttachmentTask from "@server/queues/tasks/DeleteAttachmentTask";
|
|
import { LockHelper } from "@server/storage/LockHelper";
|
|
import type { APIContext } from "@server/types";
|
|
import { VerificationCode } from "@server/utils/VerificationCode";
|
|
import parseAttachmentIds from "@server/utils/parseAttachmentIds";
|
|
import { CacheHelper } from "@server/utils/CacheHelper";
|
|
import { normalizeIp } from "@server/utils/ip";
|
|
import { RedisPrefixHelper } from "@server/utils/RedisPrefixHelper";
|
|
import { ValidationError } from "../errors";
|
|
import Attachment from "./Attachment";
|
|
import AuthenticationProvider from "./AuthenticationProvider";
|
|
import Collection from "./Collection";
|
|
import Group from "./Group";
|
|
import GroupUser from "./GroupUser";
|
|
import Team from "./Team";
|
|
import UserAuthentication from "./UserAuthentication";
|
|
import UserMembership from "./UserMembership";
|
|
import UserPasskey from "./UserPasskey";
|
|
import ParanoidModel from "./base/ParanoidModel";
|
|
import Encrypted from "./decorators/Encrypted";
|
|
import IsUrlOrRelativePath from "./validators/IsUrlOrRelativePath";
|
|
import Length from "./validators/Length";
|
|
import NotContainsUrl from "./validators/NotContainsUrl";
|
|
import { SkipChangeset } from "./decorators/Changeset";
|
|
|
|
/**
|
|
* Flags that are available for setting on the user.
|
|
*/
|
|
export enum UserFlag {
|
|
InviteSent = "inviteSent",
|
|
InviteReminderSent = "inviteReminderSent",
|
|
Desktop = "desktop",
|
|
DesktopWeb = "desktopWeb",
|
|
MobileWeb = "mobileWeb",
|
|
MCP = "mcp",
|
|
AvatarUpdated = "avatarUpdated",
|
|
}
|
|
|
|
@Scopes(() => ({
|
|
withAuthentications: {
|
|
include: [
|
|
{
|
|
separate: true,
|
|
model: UserAuthentication,
|
|
as: "authentications",
|
|
include: [
|
|
{
|
|
model: AuthenticationProvider,
|
|
as: "authenticationProvider",
|
|
where: {
|
|
enabled: true,
|
|
},
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
withTeam: {
|
|
include: [
|
|
{
|
|
model: Team,
|
|
as: "team",
|
|
required: true,
|
|
},
|
|
],
|
|
},
|
|
withInvitedBy: {
|
|
include: [
|
|
{
|
|
model: User,
|
|
as: "invitedBy",
|
|
required: true,
|
|
},
|
|
],
|
|
},
|
|
invited: {
|
|
where: {
|
|
lastActiveAt: {
|
|
[Op.is]: null,
|
|
},
|
|
},
|
|
},
|
|
}))
|
|
@Table({ tableName: "users", modelName: "user" })
|
|
class User extends ParanoidModel<
|
|
InferAttributes<User>,
|
|
Partial<InferCreationAttributes<User>>
|
|
> {
|
|
@IsEmail
|
|
@Length({
|
|
min: 1,
|
|
max: UserValidation.maxEmailLength,
|
|
msg: `User email must be between 1 and ${UserValidation.maxEmailLength} characters`,
|
|
})
|
|
@Column(DataType.STRING)
|
|
email: string | null;
|
|
|
|
@NotContainsUrl
|
|
@Length({
|
|
min: 1,
|
|
max: UserValidation.maxNameLength,
|
|
msg: `User name must be between 1 and ${UserValidation.maxNameLength} characters`,
|
|
})
|
|
@Column(DataType.STRING)
|
|
name: string;
|
|
|
|
@Default(UserRole.Member)
|
|
@Column(DataType.ENUM(...Object.values(UserRole)))
|
|
role: UserRole;
|
|
|
|
@Column(DataType.BLOB)
|
|
@Encrypted
|
|
jwtSecret: string;
|
|
|
|
@IsDate
|
|
@Column(DataType.DATE)
|
|
@SkipChangeset
|
|
lastActiveAt: Date | null;
|
|
|
|
@IsIP
|
|
@SkipChangeset
|
|
@Column(DataType.STRING)
|
|
get lastActiveIp(): string | null {
|
|
return this.getDataValue("lastActiveIp");
|
|
}
|
|
|
|
set lastActiveIp(value: string | null) {
|
|
this.setDataValue("lastActiveIp", normalizeIp(value));
|
|
}
|
|
|
|
@IsDate
|
|
@Column(DataType.DATE)
|
|
@SkipChangeset
|
|
lastSignedInAt: Date | null;
|
|
|
|
@IsIP
|
|
@SkipChangeset
|
|
@Column(DataType.STRING)
|
|
get lastSignedInIp(): string | null {
|
|
return this.getDataValue("lastSignedInIp");
|
|
}
|
|
|
|
set lastSignedInIp(value: string | null) {
|
|
this.setDataValue("lastSignedInIp", normalizeIp(value));
|
|
}
|
|
|
|
@IsDate
|
|
@Column(DataType.DATE)
|
|
@SkipChangeset
|
|
lastSigninEmailSentAt: Date | null;
|
|
|
|
@IsDate
|
|
@Column(DataType.DATE)
|
|
suspendedAt: Date | null;
|
|
|
|
@Column(DataType.JSONB)
|
|
flags: { [key in UserFlag]?: number } | null;
|
|
|
|
@AllowNull
|
|
@Column(DataType.JSONB)
|
|
preferences: UserPreferences | null;
|
|
|
|
@Column(DataType.JSONB)
|
|
notificationSettings: NotificationSettings;
|
|
|
|
@Default(env.DEFAULT_LANGUAGE)
|
|
@IsIn([languages])
|
|
@Column(DataType.STRING)
|
|
language: keyof typeof locales | null;
|
|
|
|
@AllowNull
|
|
@Column(DataType.STRING)
|
|
timezone: string | null;
|
|
|
|
@AllowNull
|
|
@IsUrlOrRelativePath
|
|
@Length({ max: 4096, msg: "avatarUrl must be less than 4096 characters" })
|
|
@Column(DataType.STRING)
|
|
get avatarUrl() {
|
|
const original = this.getDataValue("avatarUrl");
|
|
|
|
if (original && !original.startsWith("https://tiley.herokuapp.com")) {
|
|
return original;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
set avatarUrl(value: string | null) {
|
|
this.setDataValue("avatarUrl", value);
|
|
}
|
|
|
|
// associations
|
|
@BelongsTo(() => User, "suspendedById")
|
|
suspendedBy: User | null;
|
|
|
|
@ForeignKey(() => User)
|
|
@Column(DataType.UUID)
|
|
suspendedById: string | null;
|
|
|
|
@BelongsTo(() => User, "invitedById")
|
|
invitedBy: User | null;
|
|
|
|
@ForeignKey(() => User)
|
|
@Column(DataType.UUID)
|
|
invitedById: string | null;
|
|
|
|
@BelongsTo(() => Team)
|
|
team: Team;
|
|
|
|
@ForeignKey(() => Team)
|
|
@Column(DataType.UUID)
|
|
teamId: string;
|
|
|
|
@HasMany(() => UserAuthentication)
|
|
authentications: UserAuthentication[];
|
|
|
|
@HasMany(() => UserPasskey)
|
|
passkeys: UserPasskey[];
|
|
|
|
// getters
|
|
|
|
get isSuspended(): boolean {
|
|
return !!this.suspendedAt || !!this.team?.isSuspended;
|
|
}
|
|
|
|
/**
|
|
* Whether the user has been invited but not yet signed in.
|
|
*/
|
|
get isInvited() {
|
|
return !this.lastActiveAt;
|
|
}
|
|
|
|
/**
|
|
* Whether the user is an admin.
|
|
*/
|
|
get isAdmin() {
|
|
return this.role === UserRole.Admin;
|
|
}
|
|
|
|
/**
|
|
* Whether the user is a member (editor).
|
|
*/
|
|
get isMember() {
|
|
return this.role === UserRole.Member;
|
|
}
|
|
|
|
/**
|
|
* Whether the user is a viewer.
|
|
*/
|
|
get isViewer() {
|
|
return this.role === UserRole.Viewer;
|
|
}
|
|
|
|
/**
|
|
* Whether the user is a guest.
|
|
*/
|
|
get isGuest() {
|
|
return this.role === UserRole.Guest;
|
|
}
|
|
|
|
get color() {
|
|
return stringToColor(this.id);
|
|
}
|
|
|
|
get defaultCollectionPermission(): CollectionPermission {
|
|
return this.isViewer
|
|
? CollectionPermission.Read
|
|
: CollectionPermission.ReadWrite;
|
|
}
|
|
|
|
get defaultDocumentPermission(): DocumentPermission {
|
|
return this.isViewer
|
|
? DocumentPermission.Read
|
|
: DocumentPermission.ReadWrite;
|
|
}
|
|
|
|
/**
|
|
* Returns a code that can be used to delete this user account. The code will
|
|
* be rotated when the user signs out.
|
|
*
|
|
* @returns The deletion code.
|
|
*/
|
|
get deleteConfirmationCode() {
|
|
return crypto
|
|
.createHash("md5")
|
|
.update(this.jwtSecret)
|
|
.digest("hex")
|
|
.replace(/[l1IoO0]/gi, "")
|
|
.slice(0, 8)
|
|
.toUpperCase();
|
|
}
|
|
|
|
// instance methods
|
|
|
|
/**
|
|
* Sets a preference for the users notification settings.
|
|
*
|
|
* @param type The type of notification event
|
|
* @param value Set the preference to true/false
|
|
*/
|
|
public setNotificationEventType = (
|
|
type: NotificationEventType,
|
|
value = true
|
|
) => {
|
|
this.notificationSettings = {
|
|
...this.notificationSettings,
|
|
[type]: value,
|
|
};
|
|
};
|
|
|
|
/**
|
|
* Returns the current preference for the given notification event type taking
|
|
* into account the default system value.
|
|
*
|
|
* @param type The type of notification event
|
|
* @returns The current preference
|
|
*/
|
|
public subscribedToEventType = (type: NotificationEventType) =>
|
|
this.notificationSettings[type] ?? NotificationEventDefaults[type] ?? false;
|
|
|
|
/**
|
|
* User flags are for storing information on a user record that is not visible
|
|
* to the user itself.
|
|
*
|
|
* @param flag The flag to set
|
|
* @param value Set the flag to true/false
|
|
* @returns The current user flags
|
|
*/
|
|
public setFlag = (flag: UserFlag, value = true) => {
|
|
if (!this.flags) {
|
|
this.flags = {};
|
|
}
|
|
const binary = value ? 1 : 0;
|
|
if (this.flags[flag] !== binary) {
|
|
this.flags = {
|
|
...this.flags,
|
|
[flag]: binary,
|
|
};
|
|
}
|
|
|
|
return this.flags;
|
|
};
|
|
|
|
/**
|
|
* Returns the content of the given user flag.
|
|
*
|
|
* @param flag The flag to retrieve
|
|
* @returns The flag value
|
|
*/
|
|
public getFlag = (flag: UserFlag) => this.flags?.[flag] ?? 0;
|
|
|
|
/**
|
|
* User flags are for storing information on a user record that is not visible
|
|
* to the user itself.
|
|
*
|
|
* @param flag The flag to set
|
|
* @param value The amount to increment by, defaults to 1
|
|
* @returns The current user flags
|
|
*/
|
|
public incrementFlag = (flag: UserFlag, value = 1) => {
|
|
if (!this.flags) {
|
|
this.flags = {};
|
|
}
|
|
this.flags = {
|
|
...this.flags,
|
|
[flag]: (this.flags[flag] ?? 0) + value,
|
|
};
|
|
return this.flags;
|
|
};
|
|
|
|
/**
|
|
* Preferences set by the user that decide application behavior and ui.
|
|
*
|
|
* @param preference The user preference to set
|
|
* @param value Sets the preference value
|
|
* @returns The current user preferences
|
|
*/
|
|
public setPreference = <K extends UserPreference>(
|
|
preference: K,
|
|
value: NonNullable<UserPreferences[K]>
|
|
) => {
|
|
if (!this.preferences) {
|
|
this.preferences = {};
|
|
}
|
|
this.preferences = {
|
|
...this.preferences,
|
|
[preference]: value,
|
|
};
|
|
return this.preferences;
|
|
};
|
|
|
|
/**
|
|
* Returns the value of the given preference
|
|
*
|
|
* @param preference The user preference to retrieve
|
|
* @returns The preference value if set, else the default value.
|
|
*/
|
|
public getPreference = <K extends UserPreference>(
|
|
preference: K
|
|
): NonNullable<UserPreferences[K]> =>
|
|
(this.preferences?.[preference] ??
|
|
UserPreferenceDefaults[preference] ??
|
|
false) as NonNullable<UserPreferences[K]>;
|
|
|
|
/**
|
|
* Returns the user's active groups.
|
|
*
|
|
* @param options Additional options to pass to the find
|
|
* @returns An array of groups
|
|
*/
|
|
public groups = (options: FindOptions<Group> = {}) =>
|
|
Group.scope({
|
|
method: ["withMembership", this.id],
|
|
}).findAll({
|
|
where: {
|
|
teamId: this.teamId,
|
|
},
|
|
...options,
|
|
});
|
|
|
|
/**
|
|
* Returns the user's active group ids.
|
|
*
|
|
* @param options Additional options to pass to the find
|
|
* @returns An array of group ids
|
|
*/
|
|
public groupIds = async (options: FindOptions<Group> = {}) =>
|
|
(await this.groups(options)).map((g) => g.id);
|
|
|
|
/**
|
|
* Returns the user's active collection ids. This includes collections the user
|
|
* has access to through group memberships.
|
|
*
|
|
* @param options Additional options to pass to the find, set `skipCache` to bypass the cached response
|
|
* @returns An array of collection ids
|
|
*/
|
|
public collectionIds = async (
|
|
options: FindOptions<Collection> & { skipCache?: boolean } = {}
|
|
) => {
|
|
const { skipCache, ...findOptions } = options;
|
|
const hasOptions =
|
|
findOptions.transaction ||
|
|
findOptions.paranoid === false ||
|
|
findOptions.lock;
|
|
|
|
const fetchCollectionIds = async () => {
|
|
const collectionStubs = await Collection.findAll({
|
|
attributes: ["id"],
|
|
where: {
|
|
teamId: this.teamId,
|
|
// Only the owner can access a personal collection.
|
|
ownerId: {
|
|
[Op.or]: [{ [Op.is]: null }, { [Op.eq]: this.id }],
|
|
},
|
|
[Op.or]: [
|
|
...(this.isGuest
|
|
? []
|
|
: [
|
|
{
|
|
permission: {
|
|
[Op.in]: Object.values(CollectionPermission),
|
|
},
|
|
},
|
|
]),
|
|
{
|
|
"$memberships.id$": { [Op.ne]: null },
|
|
},
|
|
{
|
|
"$groupMemberships.id$": { [Op.ne]: null },
|
|
},
|
|
],
|
|
},
|
|
include: [
|
|
{
|
|
association: "memberships",
|
|
attributes: [],
|
|
required: false,
|
|
where: {
|
|
userId: this.id,
|
|
},
|
|
},
|
|
{
|
|
association: "groupMemberships",
|
|
attributes: [],
|
|
required: false,
|
|
include: [
|
|
{
|
|
association: "group",
|
|
attributes: [],
|
|
required: true,
|
|
include: [
|
|
{
|
|
association: "groupUsers",
|
|
attributes: [],
|
|
required: true,
|
|
where: {
|
|
userId: this.id,
|
|
},
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
paranoid: true,
|
|
...findOptions,
|
|
});
|
|
|
|
return Array.from(new Set(collectionStubs.map((c) => c.id)));
|
|
};
|
|
|
|
if (hasOptions || skipCache) {
|
|
return fetchCollectionIds();
|
|
}
|
|
|
|
return (
|
|
(await CacheHelper.getDataOrSet<string[]>(
|
|
RedisPrefixHelper.getUserCollectionIdsKey(this.id),
|
|
fetchCollectionIds,
|
|
10
|
|
)) ?? []
|
|
);
|
|
};
|
|
|
|
updateActiveAt = async (ctx: Context, force = false) => {
|
|
const { ip } = ctx.request;
|
|
const fiveMinutesAgo = subMinutes(new Date(), 5);
|
|
|
|
// ensure this is updated only every few minutes otherwise
|
|
// we'll be constantly writing to the DB as API requests happen
|
|
if (!this.lastActiveAt || this.lastActiveAt < fiveMinutesAgo || force) {
|
|
this.lastActiveAt = new Date();
|
|
this.lastActiveIp = ip;
|
|
}
|
|
|
|
// Track the clients each user is using
|
|
if (ctx.userAgent?.source.includes("Outline/")) {
|
|
this.setFlag(UserFlag.Desktop);
|
|
} else if (ctx.userAgent?.isDesktop) {
|
|
this.setFlag(UserFlag.DesktopWeb);
|
|
} else if (ctx.userAgent?.isMobile) {
|
|
this.setFlag(UserFlag.MobileWeb);
|
|
}
|
|
|
|
// Save only writes to the database if there are changes
|
|
return this.save({
|
|
hooks: false,
|
|
});
|
|
};
|
|
|
|
updateSignedIn = (ctx: Context | APIContext) => {
|
|
const now = new Date();
|
|
this.lastActiveAt = now;
|
|
this.lastActiveIp = ctx.request.ip;
|
|
this.lastSignedInAt = now;
|
|
this.lastSignedInIp = ctx.request.ip;
|
|
return this.save({ hooks: false, transaction: ctx.state.transaction });
|
|
};
|
|
|
|
/**
|
|
* Rotate's the users JWT secret. This has the effect of invalidating ALL
|
|
* previously issued tokens.
|
|
*
|
|
* @param options Save options
|
|
* @returns Promise that resolves when database persisted
|
|
*/
|
|
rotateJwtSecret = (options: SaveOptions) => {
|
|
User.setRandomJwtSecret(this);
|
|
return this.save(options);
|
|
};
|
|
|
|
/**
|
|
* Returns a session token that is used to make API requests and is stored
|
|
* in the client browser cookies to remain logged in.
|
|
*
|
|
* @param expiresAt The time the token will expire at
|
|
* @param service The authentication service used to generate the token, if applicable
|
|
* @returns The session token
|
|
*/
|
|
getSessionToken = (expiresAt?: Date, service?: string) =>
|
|
JWT.sign(
|
|
{
|
|
id: this.id,
|
|
expiresAt: expiresAt ? expiresAt.toISOString() : undefined,
|
|
type: "session",
|
|
service,
|
|
},
|
|
this.jwtSecret
|
|
);
|
|
|
|
/**
|
|
* Returns a session token that is used to make collaboration requests and is
|
|
* stored in the client memory.
|
|
*
|
|
* @returns The session token
|
|
*/
|
|
getCollaborationToken = () =>
|
|
JWT.sign(
|
|
{
|
|
id: this.id,
|
|
expiresAt: addHours(new Date(), 24).toISOString(),
|
|
type: "collaboration",
|
|
},
|
|
this.jwtSecret
|
|
);
|
|
|
|
/**
|
|
* Returns a temporary token that is only used for transferring a session
|
|
* between subdomains or domains. It has a short expiry and can only be used
|
|
* once.
|
|
*
|
|
* @param The authentication service used to generate the token, if applicable
|
|
* @returns The transfer token
|
|
*/
|
|
getTransferToken = (service?: string) =>
|
|
JWT.sign(
|
|
{
|
|
id: this.id,
|
|
createdAt: new Date().toISOString(),
|
|
expiresAt: addMinutes(new Date(), 1).toISOString(),
|
|
type: "transfer",
|
|
service,
|
|
},
|
|
this.jwtSecret
|
|
);
|
|
|
|
/**
|
|
* Returns a temporary token that is only used for logging in from an email
|
|
* It can only be used to sign in once and has a medium length expiry
|
|
*
|
|
* @param ctx The request context, used to get the IP address of the request
|
|
* @returns The email signin token
|
|
*/
|
|
getEmailSigninToken = (ctx: Context) =>
|
|
JWT.sign(
|
|
{
|
|
id: this.id,
|
|
ip: ctx.request.ip,
|
|
createdAt: new Date().toISOString(),
|
|
type: "email-signin",
|
|
},
|
|
this.jwtSecret
|
|
);
|
|
|
|
/**
|
|
* Generate a 6-digit verification code for email authentication
|
|
* and store it in Redis with a 10-minute TTL.
|
|
*
|
|
* @returns The 6-digit verification code
|
|
*/
|
|
getEmailVerificationCode = async (): Promise<string> => {
|
|
if (!this.email) {
|
|
throw ValidationError("Email is required");
|
|
}
|
|
|
|
const code = VerificationCode.generate();
|
|
await VerificationCode.store(this.teamId, this.email, code);
|
|
return code;
|
|
};
|
|
|
|
/**
|
|
* Returns a temporary token that can be used to update the users
|
|
* email address.
|
|
*
|
|
* @param email The new email address
|
|
* @returns The token
|
|
*/
|
|
getEmailUpdateToken = (email: string) =>
|
|
JWT.sign(
|
|
{
|
|
id: this.id,
|
|
createdAt: new Date().toISOString(),
|
|
email,
|
|
type: "email-update",
|
|
},
|
|
this.jwtSecret
|
|
);
|
|
|
|
/**
|
|
* Returns a list of teams that have a user matching this user's email.
|
|
*
|
|
* @returns A promise resolving to a list of teams
|
|
*/
|
|
availableTeams = async () =>
|
|
Team.findAll({
|
|
include: [
|
|
{
|
|
model: this.constructor as typeof User,
|
|
required: true,
|
|
where: { email: this.email },
|
|
},
|
|
],
|
|
order: [["createdAt", "ASC"]],
|
|
});
|
|
|
|
// hooks
|
|
|
|
@BeforeDestroy
|
|
static async checkLastUser(
|
|
model: User,
|
|
{ transaction }: { transaction: Transaction }
|
|
) {
|
|
// Serialize concurrent deletion within the team, otherwise every request
|
|
// can read the same count and pass the check.
|
|
await LockHelper.acquire(
|
|
model.sequelize,
|
|
`users:${model.teamId}`,
|
|
transaction
|
|
);
|
|
|
|
const usersCount = await this.count({
|
|
where: {
|
|
teamId: model.teamId,
|
|
},
|
|
transaction,
|
|
});
|
|
|
|
if (usersCount === 1) {
|
|
throw ValidationError(
|
|
"Cannot delete last user on the team, delete the workspace instead."
|
|
);
|
|
}
|
|
}
|
|
|
|
@BeforeDestroy
|
|
static async checkLastAdmin(
|
|
model: User,
|
|
{ transaction }: { transaction: Transaction }
|
|
) {
|
|
if (model.role !== UserRole.Admin) {
|
|
return;
|
|
}
|
|
|
|
// Shares the lock name with the check above, so both counts are taken
|
|
// against a settled team.
|
|
await LockHelper.acquire(
|
|
model.sequelize,
|
|
`users:${model.teamId}`,
|
|
transaction
|
|
);
|
|
|
|
const otherAdminsCount = await this.count({
|
|
where: {
|
|
teamId: model.teamId,
|
|
role: UserRole.Admin,
|
|
id: {
|
|
[Op.ne]: model.id,
|
|
},
|
|
},
|
|
transaction,
|
|
});
|
|
|
|
if (otherAdminsCount === 0) {
|
|
throw ValidationError(
|
|
"Cannot delete account as only admin. Please make another user admin and try again."
|
|
);
|
|
}
|
|
}
|
|
|
|
@BeforeDestroy
|
|
static removeIdentifyingInfo = async (
|
|
model: User,
|
|
options: { transaction: Transaction }
|
|
) => {
|
|
model.email = null;
|
|
model.name = "Unknown";
|
|
model.avatarUrl = null;
|
|
model.lastActiveIp = null;
|
|
model.lastSignedInIp = null;
|
|
|
|
// this shouldn't be needed once this issue is resolved:
|
|
// https://github.com/sequelize/sequelize/issues/9318
|
|
await model.save({
|
|
hooks: false,
|
|
transaction: options.transaction,
|
|
});
|
|
};
|
|
|
|
@BeforeCreate
|
|
static setRandomJwtSecret = (model: User) => {
|
|
model.jwtSecret = crypto.randomBytes(64).toString("hex");
|
|
};
|
|
|
|
@BeforeUpdate
|
|
static async checkRoleChange(
|
|
model: User,
|
|
options: InstanceUpdateOptions<InferAttributes<User>>
|
|
) {
|
|
const previousRole = model.previous("role");
|
|
|
|
if (
|
|
model.changed("role") &&
|
|
previousRole === UserRole.Admin &&
|
|
UserRoleHelper.isRoleLower(model.role, UserRole.Admin)
|
|
) {
|
|
// Shares the lock name with the deletion checks, so a demotion and a
|
|
// deletion cannot each count the other account as the remaining admin.
|
|
await LockHelper.acquire(
|
|
model.sequelize,
|
|
`users:${model.teamId}`,
|
|
options.transaction
|
|
);
|
|
|
|
const { count } = await this.findAndCountAll({
|
|
where: {
|
|
teamId: model.teamId,
|
|
role: UserRole.Admin,
|
|
id: {
|
|
[Op.ne]: model.id,
|
|
},
|
|
},
|
|
limit: 1,
|
|
transaction: options.transaction,
|
|
});
|
|
if (count === 0) {
|
|
throw ValidationError("At least one admin is required");
|
|
}
|
|
}
|
|
}
|
|
|
|
@AfterUpdate
|
|
static async updateMembershipPermissions(
|
|
model: User,
|
|
options: InstanceUpdateOptions<InferAttributes<User>>
|
|
) {
|
|
const previousRole = model.previous("role");
|
|
|
|
if (
|
|
previousRole &&
|
|
model.changed("role") &&
|
|
UserRoleHelper.isRoleLower(model.role, UserRole.Member) &&
|
|
!UserRoleHelper.isRoleLower(previousRole, UserRole.Viewer)
|
|
) {
|
|
await UserMembership.update(
|
|
{
|
|
permission: CollectionPermission.Read,
|
|
},
|
|
{
|
|
transaction: options.transaction,
|
|
where: {
|
|
userId: model.id,
|
|
},
|
|
}
|
|
);
|
|
}
|
|
}
|
|
|
|
// When a user's role changes their set of accessible collections may also
|
|
// change, so invalidate the cached collection ids.
|
|
@AfterUpdate
|
|
static async invalidateCollectionIdsAfterRoleChange(
|
|
model: User,
|
|
options: InstanceUpdateOptions<InferAttributes<User>>
|
|
) {
|
|
if (!model.changed("role")) {
|
|
return;
|
|
}
|
|
|
|
const invalidate = () =>
|
|
CacheHelper.removeData(
|
|
RedisPrefixHelper.getUserCollectionIdsKey(model.id)
|
|
);
|
|
|
|
if (options.transaction) {
|
|
const transaction = options.transaction.parent || options.transaction;
|
|
transaction.afterCommit(invalidate);
|
|
} else {
|
|
await invalidate();
|
|
}
|
|
}
|
|
|
|
// When a user's suspension state changes, invalidate the cached member count
|
|
// for every group they belong to so the count reflects only active members.
|
|
@AfterUpdate
|
|
static async invalidateGroupMemberCount(
|
|
model: User,
|
|
options: InstanceUpdateOptions<InferAttributes<User>>
|
|
) {
|
|
if (!model.changed("suspendedAt")) {
|
|
return;
|
|
}
|
|
|
|
const groupUsers = await GroupUser.findAll({
|
|
attributes: ["groupId"],
|
|
where: { userId: model.id },
|
|
transaction: options.transaction,
|
|
raw: true,
|
|
});
|
|
|
|
const groupIds = [
|
|
...new Set(groupUsers.map((groupUser) => groupUser.groupId)),
|
|
];
|
|
|
|
if (!groupIds.length) {
|
|
return;
|
|
}
|
|
|
|
const invalidate = async () => {
|
|
await Promise.all(
|
|
groupIds.map((groupId) =>
|
|
CacheHelper.removeData(
|
|
RedisPrefixHelper.getCounterCacheKey("Group", "members", groupId)
|
|
)
|
|
)
|
|
);
|
|
};
|
|
|
|
if (options.transaction) {
|
|
const transaction = options.transaction.parent || options.transaction;
|
|
transaction.afterCommit(invalidate);
|
|
} else {
|
|
await invalidate();
|
|
}
|
|
}
|
|
|
|
@AfterUpdate
|
|
static deletePreviousAvatar = async (model: User) => {
|
|
const previousAvatarUrl = model.previous("avatarUrl");
|
|
if (previousAvatarUrl && previousAvatarUrl !== model.avatarUrl) {
|
|
const attachmentIds = parseAttachmentIds(previousAvatarUrl, true);
|
|
if (!attachmentIds.length) {
|
|
return;
|
|
}
|
|
|
|
const attachment = await Attachment.findOne({
|
|
where: {
|
|
id: attachmentIds[0],
|
|
teamId: model.teamId,
|
|
userId: model.id,
|
|
},
|
|
});
|
|
|
|
if (attachment) {
|
|
await new DeleteAttachmentTask().schedule({
|
|
attachmentId: attachment.id,
|
|
teamId: model.teamId,
|
|
});
|
|
}
|
|
}
|
|
};
|
|
|
|
static findByEmail = async function (
|
|
this: typeof User,
|
|
ctx: APIContext,
|
|
email: string
|
|
) {
|
|
return this.findOne({
|
|
where: {
|
|
teamId: ctx.state.auth.user.teamId,
|
|
email: email.trim().toLowerCase(),
|
|
},
|
|
...ctx.context,
|
|
});
|
|
};
|
|
|
|
static getCounts = async function (this: typeof User, teamId: string) {
|
|
const countSql = `
|
|
SELECT
|
|
COUNT(CASE WHEN "suspendedAt" IS NOT NULL THEN 1 END) as "suspendedCount",
|
|
COUNT(CASE WHEN "role" = :roleAdmin THEN 1 END) as "adminCount",
|
|
COUNT(CASE WHEN "role" = :roleViewer THEN 1 END) as "viewerCount",
|
|
COUNT(CASE WHEN "lastActiveAt" IS NULL THEN 1 END) as "invitedCount",
|
|
COUNT(CASE WHEN "suspendedAt" IS NULL AND "lastActiveAt" IS NOT NULL THEN 1 END) as "activeCount",
|
|
COUNT(*) as count
|
|
FROM users
|
|
WHERE "deletedAt" IS NULL
|
|
AND "teamId" = :teamId
|
|
`;
|
|
const [counts] = await this.sequelize!.query<{
|
|
activeCount: string;
|
|
adminCount: string;
|
|
invitedCount: string;
|
|
suspendedCount: string;
|
|
viewerCount: string;
|
|
count: string;
|
|
}>(countSql, {
|
|
type: QueryTypes.SELECT,
|
|
replacements: {
|
|
teamId,
|
|
roleAdmin: UserRole.Admin,
|
|
roleViewer: UserRole.Viewer,
|
|
},
|
|
});
|
|
|
|
return {
|
|
active: parseInt(counts.activeCount),
|
|
admins: parseInt(counts.adminCount),
|
|
viewers: parseInt(counts.viewerCount),
|
|
all: parseInt(counts.count),
|
|
invited: parseInt(counts.invitedCount),
|
|
suspended: parseInt(counts.suspendedCount),
|
|
};
|
|
};
|
|
}
|
|
|
|
export default User;
|