* chore: Upgrade prisma to 6.7.0 * Build fixes * type fixes Signed-off-by: Omar López <zomars@me.com> * Update schema.prisma * Patching * Revert "Update schema.prisma" This reverts commit 47d8618bf89ef4d007b30084df766f17281e21a1. * Revert "Patching" This reverts commit a1d2e3040e71690a44d4324db95d73b4d68c6adb. * Revert schema changes Signed-off-by: Omar López <zomars@me.com> * WIP Signed-off-by: Omar López <zomars@me.com> * Update getPublicEvent.ts * Update imports Signed-off-by: Omar López <zomars@me.com> * Update gitignore Signed-off-by: Omar López <zomars@me.com> * update remaining imports Signed-off-by: Omar López <zomars@me.com> * Delete .cursor/config.json * Discard changes to packages/features/eventtypes/lib/getPublicEvent.ts * Update _get.ts * Update user.ts * Update .gitignore * update * Update WorkflowStepContainer.tsx * Update next-auth-custom-adapter.ts * Update getPublicEvent.ts * Update workflow.ts * Update next-auth-custom-adapter.ts * Update next-auth-options.ts * Update bookingScenario.ts * fix missing imports * upgrades prismock Signed-off-by: Omar López <zomars@me.com> * patches prismock Signed-off-by: Omar López <zomars@me.com> * Update reschedule.test.ts * Update prisma.ts * patch prismock Signed-off-by: Omar López <zomars@me.com> * fix enums imports Signed-off-by: Omar López <zomars@me.com> * Revert "Update prisma.ts" This reverts commit 64edcf8db54171ff4456c209d563b5d431d99619. * Revert "patch prismock" This reverts commit e95819113dc9d88e7130947aa120cd42710977c8. * fix patch * Fix test that overrun the boundary, it shouldn't test too much * Move prisma import to changeSMSLockState * Bring back broken test without illegal imports * Merge with main and fix filter hosts by same round robin host * Fixed buildDryRunBooking fn tests * Fix and move ooo create or update handler test * Fix packages/features/eventtypes/lib/isCurrentlyAvailable.test.ts * Fix packages/trpc/server/routers/viewer/organizations/listMembers.handler.test.ts * Mock @calcom/prisma * Fix: verify-email.test.ts * fix: Moved WebhookService test and fixed default import mock * Fix: Added missing prisma mock, handleNewBooking uses that of course * We're not testing createContext here * fix: Prisma mock fix for listMembers.test.ts * More fixes to broken testcases * Forgot to remove borked test * Prevent the need to mock a lot of dependencies by moving out buildBaseWhereCondition to its own file * Temporarily skip getCalendarEvents, needs a rewrite * Fix: turns out you can access protected in testcases * fix further mocks * Added packages/features/insights/server/buildBaseWhereCondition.ts, types * Always great to have a mock and then not use it * And one less again. * fix: confirm.handler.test, didn't mock prisma * fix: Address minor nit by @eunjae & fix ImpersonationProvider test * Updated isPrismaAvailableCheck that doesn't crash on import * fix: Get Prisma directly from the client, it usually involves the Validator and does not need 'local' inclusion * Add zod-prisma-types without the generator enabled (commented out) * Uncomment and see what happens * Change method of import as imports did not work in Input Schemas * Remove custom 'zod' booking model, it does not belong with Prisma * Fix all other global Model imports * Rewrite most schema includes AND remove barrel file * Add bookingCreateBodySchema to features/bookings * Flurry of type fixes for compatibility with new zod gen * Refactor out the custom prisma type createEventTypeInput * Work around nullable eventTypeLocations * HandlePayment type fix * More fixes, final fix remaining is CompleteEventType * Should fix a bunch more booking related type errors * Missed one * Some props missing from BookingCreateBodySchema * Fix location type in handleChildrenEventTypes * Little bit hacky imo but it works * Final type error \o/ * Forgot to include Prisma * Do not include zod-utils in booker/types * Oops, was already including Booker/types * Fix membership type, also disallow updating createdAt/updatedAt, make part of patch/post * Fix api v1 type errors * Fix EventTypeDescription typings * Remove getParserWithGeneric, use userBodySchema with UserSchema * use centralized timeZoneSchema * Implement feedback by @zomars * Couple of WIP pushes * Fix tests * Type fixes in `handleChildrenEventTypes` test * Try and parse metadata before use * Change zod-prisma-types configuration for optimal performance * Fix prisma validator error in `prisma/selects/credential` * Disable seperate relations model, hits a bug * Import absolute - this makes rollup work in @platform/libraries * Attempt at removing resolutions override * Refactor using `Prisma.validator` to `satisfies` * Build atoms using @calcom/prisma/client * Build atoms using @calcom/prisma/client * fixes * Update eventTypeSelect.ts * Adjust `eventTypeMetaDataSchemaWithUntypedApps` from `unknown` to `record(any)` * `EventTypeDescription` rely on `descriptionAsSafeHTML` instead of `description` * Add `seatsPerTimeSlot` to event type public select * Fix typing in `users-public-view` getServerSide props * Add missing `schedulingType` to prop * chore: bump platform libraries * Function return type is illegal, not sure how this passed eslint (#21567) * Merged with main * Update updateTokenObject.ts * Update handleResponse.ts * Update index.ts * Update handleChildrenEventTypes.ts * Update booking-idempotency-key.ts * Update WebhookService.test.ts * Update events.test.ts * Update queued-response.test.ts * Update events.test.ts * Update getRoutedUrl.test.ts * fix: type checks Signed-off-by: Omar López <zomars@me.com> * fixes Signed-off-by: Omar López <zomars@me.com> * chore: bump platform libraries * Update yarn.lock * more fixes Signed-off-by: Omar López <zomars@me.com> * fixes Signed-off-by: Omar López <zomars@me.com> * biuld fixes * chore: bump platform libraries * Update conferencing.repository.ts * Update conferencing.repository.ts * Update getCalendarsEvents.test.ts * Update vite.config.js * chore: bump platform libraries * Update users.ts * Discard changes to docs/api-reference/v2/openapi.json * Update vite.config.ts * updated platform libraries * Update get.handler.test.ts * Update get.handler.test.ts * Update schema.prisma * Discard changes to docs/api-reference/v2/openapi.json * Update next-auth-custom-adapter.ts * Update team.ts * Flurry of type fixes * Fix majority of insight related type errors * Type fixes for unlink of account * Make user nullable again * Fixed a bunch of unit tests and one type error * Attempted mock fix * Attempted fix for Attribute type * Ensure default import becomes prisma, but not direct usage * Import default as prisma in prisma.module * Add attributeOption to attribute type * Fix calcom/prisma mock * Refactor Prisma client imports to @calcom/prisma/client Updated all imports from '@prisma/client' to '@calcom/prisma/client' across tests and repository files for consistency and to use the correct Prisma client package. This change improves maintainability and ensures the correct client is referenced throughout the codebase. * Undo removal of max-warnings=0 to get main to merge * Remove unit tests for e2e fixtures, provide new prisma mock * Mock @calcom/prisma in event manager * Mock @calcom/prisma in event manager * Add correct format even with --no-verify * Mock prisma in CalendarManager * Add mock for permission-check.service * Better injection in PrismaApiKeyRepository imports * More mock fixes :) * Fix listMembers.handler.test * Fix User import * Appropriately adjust all types to be imported as types, there were a lot of types imported as normal deps * Why was this a thing? * Strictly speaking; Not using prismock anymore * Ditched patch file for prismock * Fix output.service.ts platform type imports, need concrete for plainToClass * Better typing and tests for unlinkConnectedAccount.handler * Small type fix * Disable calendar cache tests as they are dependent on prismock * chore: bump platform lib * getRoutedUrl test remove of unused import * Extract select to external const on getEventTypesFromDB * Direct select of userSelect from selects/user * fix type error from merging 23653 * Fixed integration tests by removing hardcoded values that were possible due to mocking, but as its now directly hitting the db no longer * fix: vite config atoms prisma client type location * revert: example app prisma client * revert: example app prisma client * bump platform libs * fix: use class instead of type for DI of PlatformBookingsService * update platform libs * remove unused variable * chore: generate prisma client for api v2 * fix: api v2 e2e * fix: atoms e2e * fix: atoms e2e * fix: atoms e2e * fix: api v2 e2e * fix: tsconfig apiv2 enums * publish libraries * Simplify check for existence teamId --------- Signed-off-by: Omar López <zomars@me.com> Co-authored-by: Alex van Andel <me@alexvanandel.com> Co-authored-by: Joe Au-Yeung <j.auyeung419@gmail.com> Co-authored-by: supalarry <laurisskraucis@gmail.com> Co-authored-by: cal.com <morgan@cal.com> Co-authored-by: Morgan <33722304+ThyMinimalDev@users.noreply.github.com> Co-authored-by: Benny Joo <sldisek783@gmail.com>
356 lines
10 KiB
TypeScript
356 lines
10 KiB
TypeScript
import { getOrgFullOrigin } from "@calcom/ee/organizations/lib/orgDomains";
|
|
import stripe from "@calcom/features/ee/payments/server/stripe";
|
|
import logger from "@calcom/lib/logger";
|
|
import { safeStringify } from "@calcom/lib/safeStringify";
|
|
import { UserRepository } from "@calcom/lib/server/repository/user";
|
|
import slugify from "@calcom/lib/slugify";
|
|
import { prisma } from "@calcom/prisma";
|
|
import type { Prisma } from "@calcom/prisma/client";
|
|
import type { CreationSource } from "@calcom/prisma/enums";
|
|
import { MembershipRole, RedirectType } from "@calcom/prisma/enums";
|
|
import { teamMetadataSchema, teamMetadataStrictSchema } from "@calcom/prisma/zod-utils";
|
|
|
|
import { TRPCError } from "@trpc/server";
|
|
|
|
import { inviteMembersWithNoInviterPermissionCheck } from "../teams/inviteMember/inviteMember.handler";
|
|
import type { TCreateTeamsSchema } from "./createTeams.schema";
|
|
|
|
const log = logger.getSubLogger({ prefix: ["viewer/organizations/createTeams.handler"] });
|
|
type CreateTeamsOptions = {
|
|
ctx: {
|
|
user: {
|
|
id: number;
|
|
organizationId: number | null;
|
|
};
|
|
};
|
|
input: TCreateTeamsSchema;
|
|
};
|
|
|
|
export const createTeamsHandler = async ({ ctx, input }: CreateTeamsOptions) => {
|
|
// Whether self-serve or not, createTeams endpoint is accessed by Org Owner only.
|
|
// Even when instance admin creates an org, then by the time he reaches team creation steps, he has impersonated the org owner.
|
|
const organizationOwner = ctx.user;
|
|
|
|
const { orgId, moveTeams, creationSource } = input;
|
|
|
|
// Remove empty team names that could be there due to the default empty team name
|
|
const teamNames = input.teamNames.filter((name) => name.trim().length > 0);
|
|
|
|
if (orgId !== organizationOwner.organizationId) {
|
|
log.error("User is not the owner of the organization", safeStringify({ orgId, organizationOwner }));
|
|
throw new NotAuthorizedError();
|
|
}
|
|
|
|
// Validate user membership role
|
|
const userMembershipRole = await prisma.membership.findFirst({
|
|
where: {
|
|
userId: organizationOwner.id,
|
|
teamId: orgId,
|
|
role: {
|
|
in: ["OWNER", "ADMIN"],
|
|
},
|
|
// @TODO: not sure if this already setup earlier
|
|
// accepted: true,
|
|
},
|
|
select: {
|
|
role: true,
|
|
},
|
|
});
|
|
|
|
if (!userMembershipRole) {
|
|
log.error("User is not a member of the organization", safeStringify({ orgId, organizationOwner }));
|
|
throw new NotAuthorizedError();
|
|
}
|
|
|
|
const organization = await prisma.team.findUnique({
|
|
where: { id: orgId },
|
|
select: { slug: true, id: true, metadata: true },
|
|
});
|
|
|
|
if (!organization) throw new NoOrganizationError();
|
|
|
|
const parseTeams = teamMetadataSchema.safeParse(organization?.metadata);
|
|
|
|
if (!parseTeams.success) {
|
|
throw new InvalidMetadataError();
|
|
}
|
|
|
|
const metadata = parseTeams.success ? parseTeams.data : undefined;
|
|
|
|
if (!metadata?.requestedSlug && !organization?.slug) {
|
|
throw new NoOrganizationSlugError();
|
|
}
|
|
|
|
const [teamSlugs, userSlugs] = [
|
|
await prisma.team.findMany({ where: { parentId: orgId }, select: { slug: true } }),
|
|
await new UserRepository(prisma).findManyByOrganization({ organizationId: orgId }),
|
|
];
|
|
|
|
const existingSlugs = teamSlugs
|
|
.flatMap((ts) => ts.slug ?? [])
|
|
.concat(userSlugs.flatMap((us) => us.username ?? []));
|
|
|
|
const duplicatedSlugs = existingSlugs.filter((slug) =>
|
|
teamNames.map((item) => slugify(item)).includes(slug)
|
|
);
|
|
|
|
// Process team migrations sequentially to avoid race conditions - Moving a team invites members to the organization again and there are known unique constraints failure in membership and profile creation if done in parallel and a user happens to be part of more than one team
|
|
for (const team of moveTeams.filter((team) => team.shouldMove)) {
|
|
await moveTeam({
|
|
teamId: team.id,
|
|
newSlug: team.newSlug,
|
|
org: {
|
|
...organization,
|
|
ownerId: organizationOwner.id,
|
|
},
|
|
creationSource,
|
|
});
|
|
}
|
|
|
|
if (duplicatedSlugs.length === teamNames.length) {
|
|
return { duplicatedSlugs };
|
|
}
|
|
|
|
await prisma.$transaction(
|
|
teamNames.flatMap((name) => {
|
|
if (!duplicatedSlugs.includes(slugify(name))) {
|
|
return prisma.team.create({
|
|
data: {
|
|
name,
|
|
parentId: orgId,
|
|
slug: slugify(name),
|
|
members: {
|
|
create: { userId: ctx.user.id, role: MembershipRole.OWNER, accepted: true },
|
|
},
|
|
},
|
|
});
|
|
} else {
|
|
return [];
|
|
}
|
|
})
|
|
);
|
|
|
|
return { duplicatedSlugs };
|
|
};
|
|
|
|
class NotAuthorizedError extends TRPCError {
|
|
constructor() {
|
|
super({ code: "FORBIDDEN", message: "not_authorized" });
|
|
}
|
|
}
|
|
|
|
class InvalidMetadataError extends TRPCError {
|
|
constructor() {
|
|
super({ code: "BAD_REQUEST", message: "invalid_organization_metadata" });
|
|
}
|
|
}
|
|
|
|
class NoOrganizationError extends TRPCError {
|
|
constructor() {
|
|
super({ code: "BAD_REQUEST", message: "no_organization_found" });
|
|
}
|
|
}
|
|
|
|
class NoOrganizationSlugError extends TRPCError {
|
|
constructor() {
|
|
super({ code: "BAD_REQUEST", message: "no_organization_slug" });
|
|
}
|
|
}
|
|
|
|
export default createTeamsHandler;
|
|
|
|
async function moveTeam({
|
|
teamId,
|
|
newSlug,
|
|
org,
|
|
creationSource,
|
|
}: {
|
|
teamId: number;
|
|
newSlug?: string | null;
|
|
org: {
|
|
id: number;
|
|
slug: string | null;
|
|
ownerId: number;
|
|
metadata: Prisma.JsonValue;
|
|
};
|
|
creationSource: CreationSource;
|
|
}) {
|
|
const team = await prisma.team.findUnique({
|
|
where: {
|
|
id: teamId,
|
|
},
|
|
select: {
|
|
id: true,
|
|
slug: true,
|
|
metadata: true,
|
|
parent: {
|
|
select: {
|
|
id: true,
|
|
isPlatform: true,
|
|
},
|
|
},
|
|
members: {
|
|
select: {
|
|
role: true,
|
|
userId: true,
|
|
user: {
|
|
select: {
|
|
email: true,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
if (!team) {
|
|
log.warn(`Team with id: ${teamId} not found. Skipping migration.`, {
|
|
teamId,
|
|
orgId: org.id,
|
|
orgSlug: org.slug,
|
|
});
|
|
return;
|
|
}
|
|
|
|
if (team.parent?.isPlatform) {
|
|
log.info(
|
|
"Team belongs to a platform organization. Not moving to regular organization.",
|
|
safeStringify({ teamId, newSlug, org, oldSlug: team.slug, platformOrgId: team.parent.id })
|
|
);
|
|
return;
|
|
}
|
|
log.info("Moving team", safeStringify({ teamId, newSlug, oldSlug: team.slug }));
|
|
|
|
newSlug = newSlug ?? team.slug;
|
|
const orgMetadata = teamMetadataSchema.parse(org.metadata);
|
|
try {
|
|
await prisma.team.update({
|
|
where: {
|
|
id: teamId,
|
|
},
|
|
data: {
|
|
slug: newSlug,
|
|
parentId: org.id,
|
|
},
|
|
});
|
|
} catch (error) {
|
|
log.error(
|
|
"Error while moving team to organization",
|
|
safeStringify(error),
|
|
safeStringify({
|
|
teamId,
|
|
newSlug,
|
|
orgId: org.id,
|
|
})
|
|
);
|
|
throw error;
|
|
}
|
|
|
|
// Owner is already a member of the team. Inviting an existing member can throw error
|
|
const invitableMembers = team.members.filter(isMembershipNotWithOwner).map((membership) => ({
|
|
usernameOrEmail: membership.user.email,
|
|
role: membership.role,
|
|
}));
|
|
|
|
if (invitableMembers.length) {
|
|
// Invite team members to the new org. They are already members of the team.
|
|
await inviteMembersWithNoInviterPermissionCheck({
|
|
orgSlug: org.slug,
|
|
invitations: invitableMembers,
|
|
creationSource,
|
|
language: "en",
|
|
inviterName: null,
|
|
teamId: org.id,
|
|
// This is important so that if we re-invite existing users accidentally, we don't endup erroring out.
|
|
// Because this is a bulk action that could be taken from organization payment webhook, we could have cases where a user was just invited through another team migration in parallel.
|
|
isDirectUserAction: false,
|
|
});
|
|
}
|
|
|
|
await addTeamRedirect({
|
|
oldTeamSlug: team.slug,
|
|
teamSlug: newSlug,
|
|
orgSlug: org.slug || (orgMetadata?.requestedSlug ?? null),
|
|
});
|
|
|
|
function isMembershipNotWithOwner(membership: { userId: number }) {
|
|
// Org owner is already a member of the team
|
|
return membership.userId !== org.ownerId;
|
|
}
|
|
// Cancel existing stripe subscriptions once the team is migrated
|
|
const subscriptionId = getSubscriptionId(team.metadata);
|
|
if (subscriptionId) {
|
|
await tryToCancelSubscription(subscriptionId);
|
|
}
|
|
}
|
|
|
|
async function tryToCancelSubscription(subscriptionId: string) {
|
|
try {
|
|
log.debug("Canceling stripe subscription", safeStringify({ subscriptionId }));
|
|
return await stripe.subscriptions.cancel(subscriptionId);
|
|
} catch (error) {
|
|
log.error("Error while cancelling stripe subscription", error);
|
|
}
|
|
}
|
|
|
|
function getSubscriptionId(metadata: Prisma.JsonValue) {
|
|
const parsedMetadata = teamMetadataStrictSchema.safeParse(metadata);
|
|
if (parsedMetadata.success) {
|
|
const subscriptionId = parsedMetadata.data?.subscriptionId;
|
|
if (!subscriptionId) {
|
|
log.warn("No subscriptionId found in team metadata", safeStringify({ metadata, parsedMetadata }));
|
|
}
|
|
return subscriptionId;
|
|
} else {
|
|
log.warn(`There has been an error`, parsedMetadata.error);
|
|
}
|
|
}
|
|
|
|
async function addTeamRedirect({
|
|
oldTeamSlug,
|
|
teamSlug,
|
|
orgSlug,
|
|
}: {
|
|
oldTeamSlug: string | null;
|
|
teamSlug: string | null;
|
|
orgSlug: string | null;
|
|
}) {
|
|
logger.info(`Adding redirect for team: ${oldTeamSlug} -> ${teamSlug}`);
|
|
if (!oldTeamSlug) {
|
|
// This can happen for unpublished teams that don't have a slug yet
|
|
logger.warn(`No oldSlug for team. Not adding the redirect`);
|
|
return;
|
|
}
|
|
if (!teamSlug) {
|
|
// This should not happen as org onboarding ensures teams have slugs
|
|
throw new TRPCError({
|
|
code: "BAD_REQUEST",
|
|
message: "No slug for team. Not adding the redirect",
|
|
});
|
|
}
|
|
if (!orgSlug) {
|
|
logger.warn(`No slug for org. Not adding the redirect`);
|
|
return;
|
|
}
|
|
const orgUrlPrefix = getOrgFullOrigin(orgSlug);
|
|
|
|
await prisma.tempOrgRedirect.upsert({
|
|
where: {
|
|
from_type_fromOrgId: {
|
|
type: RedirectType.Team,
|
|
from: oldTeamSlug,
|
|
fromOrgId: 0,
|
|
},
|
|
},
|
|
create: {
|
|
type: RedirectType.Team,
|
|
from: oldTeamSlug,
|
|
fromOrgId: 0,
|
|
toUrl: `${orgUrlPrefix}/${teamSlug}`,
|
|
},
|
|
update: {
|
|
toUrl: `${orgUrlPrefix}/${teamSlug}`,
|
|
},
|
|
});
|
|
}
|