⚡ Project management that doesn't become the project. Boards, Gantt charts, and GitHub integration. Self-host it or use Kaneo Cloud.
TypeScript honoissue-managementissue-trackerjira-alternativekanbanlinear-alternativemcpproject-managementreactself-hostedtypescript
import { and, eq, gt, isNull } from "drizzle-orm";
import db from "../database";
import { invitationTable, userTable, workspaceTable } from "../database/schema";
import { getInstanceSettings } from "../instance-settings/get-instance-settings";
type RegistrationCheckResult = {
allowed: boolean;
reason: string;
invitation?: {
id: string;
email: string;
workspaceId: string;
workspaceName: string;
inviterName: string;
expiresAt: Date;
status: string;
};
};
export async function checkRegistrationAllowed(
email?: string,
invitationId?: string,
options?: { allowInvitationByEmail?: boolean; emailVerified?: boolean },
): Promise<RegistrationCheckResult> {
if ((await getInstanceSettings()).registrationEnabled) {
return {
allowed: true,
reason: "Registration is enabled",
};
}
const canMatchByEmail = Boolean(
options?.allowInvitationByEmail && options.emailVerified === true && email,
);
if (!invitationId && !canMatchByEmail) {
return {
allowed: false,
reason:
"Registration is currently disabled. Please use a valid invitation link to create an account.",
};
}
const invitation = await findValidInvitation(email, invitationId);
if (!invitation) {
return {
allowed: false,
reason:
"Registration is currently disabled. You need a valid invitation to create an account.",
};
}
return {
allowed: true,
reason: "Valid invitation found",
invitation,
};
}
async function findValidInvitation(
email?: string,
invitationId?: string,
): Promise<RegistrationCheckResult["invitation"] | null> {
const now = new Date();
const conditions = [
eq(invitationTable.status, "pending"),
gt(invitationTable.expiresAt, now),
];
if (invitationId) {
conditions.push(eq(invitationTable.id, invitationId));
}
if (email) {
conditions.push(eq(invitationTable.email, email.toLowerCase()));
}
if (!invitationId && !email) {
return null;
}
const result = await db
.select({
id: invitationTable.id,
email: invitationTable.email,
workspaceId: invitationTable.workspaceId,
workspaceName: workspaceTable.name,
inviterName: userTable.name,
expiresAt: invitationTable.expiresAt,
status: invitationTable.status,
})
.from(invitationTable)
.innerJoin(
workspaceTable,
and(
eq(invitationTable.workspaceId, workspaceTable.id),
// Invitations to archived workspaces cannot be used.
isNull(workspaceTable.archivedAt),
),
)
.innerJoin(userTable, eq(invitationTable.inviterId, userTable.id))
.where(and(...conditions))
.limit(1);
const row = result[0];
if (!row) {
return null;
}
return row;
}
type InvitationDetails = {
id: string;
email: string;
workspaceName: string;
inviterName: string;
expiresAt: Date;
status: string;
expired: boolean;
};
type InvitationDetailsResult = {
valid: boolean;
invitation?: InvitationDetails;
error?: string;
};
export async function getInvitationDetails(
invitationId: string,
): Promise<InvitationDetailsResult> {
const now = new Date();
const result = await db
.select({
id: invitationTable.id,
email: invitationTable.email,
workspaceName: workspaceTable.name,
inviterName: userTable.name,
expiresAt: invitationTable.expiresAt,
status: invitationTable.status,
})
.from(invitationTable)
.innerJoin(
workspaceTable,
and(
eq(invitationTable.workspaceId, workspaceTable.id),
// Invitations to archived workspaces cannot be used.
isNull(workspaceTable.archivedAt),
),
)
.innerJoin(userTable, eq(invitationTable.inviterId, userTable.id))
.where(eq(invitationTable.id, invitationId))
.limit(1);
const row = result[0];
if (!row) {
return {
valid: false,
error: "Invitation not found",
};
}
const expired = row.expiresAt < now;
const isAccepted = row.status === "accepted";
const isCanceled = row.status === "canceled";
const baseInvitation: InvitationDetails = {
id: row.id,
email: row.email,
workspaceName: row.workspaceName,
inviterName: row.inviterName,
expiresAt: row.expiresAt,
status: row.status,
expired,
};
if (isAccepted) {
return {
valid: false,
error: "This invitation has already been accepted",
};
}
if (isCanceled) {
return {
valid: false,
error: "This invitation has been canceled",
};
}
if (expired) {
return {
valid: false,
invitation: baseInvitation,
error: "This invitation has expired",
};
}
return {
valid: true,
invitation: baseInvitation,
};
}
export async function userExistsByEmail(email: string): Promise<boolean> {
const [user] = await db
.select({ id: userTable.id })
.from(userTable)
.where(eq(userTable.email, email.toLowerCase()))
.limit(1);
return Boolean(user);
}
export async function canSendSignInEmail(email: string): Promise<boolean> {
if (await userExistsByEmail(email)) {
return true;
}
return (await getUserPendingInvitations(email)).length > 0;
}
export async function getUserPendingInvitations(userEmail: string) {
const now = new Date();
const result = await db
.select({
id: invitationTable.id,
email: invitationTable.email,
workspaceId: invitationTable.workspaceId,
workspaceName: workspaceTable.name,
inviterName: userTable.name,
expiresAt: invitationTable.expiresAt,
createdAt: invitationTable.createdAt,
status: invitationTable.status,
})
.from(invitationTable)
.innerJoin(
workspaceTable,
and(
eq(invitationTable.workspaceId, workspaceTable.id),
// Invitations to archived workspaces cannot be used.
isNull(workspaceTable.archivedAt),
),
)
.innerJoin(userTable, eq(invitationTable.inviterId, userTable.id))
.where(
and(
eq(invitationTable.email, userEmail.toLowerCase()),
eq(invitationTable.status, "pending"),
gt(invitationTable.expiresAt, now),
),
)
.orderBy(invitationTable.createdAt);
return result;
}