cal.pub0.org/packages/app-store/routing-forms/trpc/formMutation.handler.ts

import type { PrismaClient } from "@prisma/client";
import type { App_RoutingForms_Form } from "@prisma/client";
import { Prisma } from "@prisma/client";

import { entityPrismaWhereClause, canEditEntity } from "@calcom/lib/entityPermissionUtils";
import { TRPCError } from "@calcom/trpc/server";
import type { TrpcSessionUser } from "@calcom/trpc/server/trpc";

import { createFallbackRoute } from "../lib/createFallbackRoute";
import { getSerializableForm } from "../lib/getSerializableForm";
import { isFallbackRoute } from "../lib/isFallbackRoute";
import { isFormCreateEditAllowed } from "../lib/isFormCreateEditAllowed";
import isRouter from "../lib/isRouter";
import isRouterLinkedField from "../lib/isRouterLinkedField";
import type { SerializableForm } from "../types/types";
import { zodFields, zodRouterRoute, zodRoutes } from "../zod";
import type { TFormMutationInputSchema } from "./formMutation.schema";

interface FormMutationHandlerOptions {
  ctx: {
    prisma: PrismaClient;
    user: NonNullable<TrpcSessionUser>;
  };
  input: TFormMutationInputSchema;
}
export const formMutationHandler = async ({ ctx, input }: FormMutationHandlerOptions) => {
  const { user, prisma } = ctx;
  const { name, id, description, settings, disabled, addFallback, duplicateFrom, shouldConnect } = input;
  let teamId = input.teamId;
  if (!(await isFormCreateEditAllowed({ userId: user.id, formId: id, targetTeamId: teamId }))) {
    throw new TRPCError({
      code: "FORBIDDEN",
    });
  }
  let { routes: inputRoutes } = input;
  let { fields: inputFields } = input;
  inputFields = inputFields || [];
  inputRoutes = inputRoutes || [];
  type InputFields = typeof inputFields;
  type InputRoutes = typeof inputRoutes;
  let routes: InputRoutes;
  let fields: InputFields;
  type DuplicateFrom = NonNullable<typeof duplicateFrom>;

  const dbForm = await prisma.app_RoutingForms_Form.findUnique({
    where: {
      id: id,
    },
    select: {
      id: true,
      user: true,
      name: true,
      description: true,
      userId: true,
      disabled: true,
      createdAt: true,
      updatedAt: true,
      routes: true,
      fields: true,
      settings: true,
      teamId: true,
    },
  });

  const dbSerializedForm = dbForm
    ? await getSerializableForm({ form: dbForm, withDeletedFields: true })
    : null;

  if (duplicateFrom) {
    ({ teamId, routes, fields } = await getRoutesAndFieldsForDuplication({ duplicateFrom, userId: user.id }));
  } else {
    [fields, routes] = [inputFields, inputRoutes];
    if (dbSerializedForm) {
      fields = markMissingFieldsDeleted(dbSerializedForm, fields);
    }
  }

  if (dbSerializedForm) {
    // If it's an existing form being mutated, update fields in the connected forms(if any).
    await updateFieldsInConnectedForms(dbSerializedForm, inputFields);
  }

  fields = await getUpdatedRouterLinkedFields(fields, routes);

  if (addFallback) {
    // Add a fallback route if there is none
    if (!routes.find(isFallbackRoute)) {
      routes.push(createFallbackRoute());
    }
  }

  return await prisma.app_RoutingForms_Form.upsert({
    where: {
      id: id,
    },
    create: {
      user: {
        connect: {
          id: user.id,
        },
      },
      fields,
      name: name,
      description,
      // Prisma doesn't allow setting null value directly for JSON. It recommends using JsonNull for that case.
      routes: routes === null ? Prisma.JsonNull : routes,
      id: id,
      ...(teamId
        ? {
            team: {
              connect: {
                id: teamId ?? undefined,
              },
            },
          }
        : null),
    },
    update: {
      disabled: disabled,
      fields,
      name: name,
      description,
      settings: settings === null ? Prisma.JsonNull : settings,
      routes: routes === null ? Prisma.JsonNull : routes,
    },
  });

  /**
   * If Form has Router Linked fields, enrich them with the latest info from the Router
   * If Form doesn't have Router fields but there is a Router used in routes, add all the fields from the Router
   */
  async function getUpdatedRouterLinkedFields(fields: InputFields, routes: InputRoutes) {
    const routerLinkedFields: Record<string, boolean> = {};
    for (const [, field] of Object.entries(fields)) {
      if (!isRouterLinkedField(field)) {
        continue;
      }
      routerLinkedFields[field.routerId] = true;

      if (!routes.some((route) => route.id === field.routerId)) {
        // If the field is from a router that is not available anymore, mark it as deleted
        field.deleted = true;
        continue;
      }
      // Get back deleted field as now the Router is there for it.
      if (field.deleted) field.deleted = false;
      const router = await prisma.app_RoutingForms_Form.findFirst({
        where: {
          id: field.routerId,
          userId: user.id,
        },
      });
      if (router) {
        assertIfInvalidRouter(router);
        const parsedRouterFields = zodFields.parse(router.fields);

        // There is a field from some router available, make sure that the field has up-to-date info from the router
        const routerField = parsedRouterFields?.find((f) => f.id === field.id);
        // Update local field(cache) with router field on every mutation
        Object.assign(field, routerField);
      }
    }

    for (const [, route] of Object.entries(routes)) {
      if (!isRouter(route)) {
        continue;
      }

      // If there is a field that belongs to router, then all fields must be there already. So, need to add Router fields
      if (routerLinkedFields[route.id]) {
        continue;
      }

      const router = await prisma.app_RoutingForms_Form.findFirst({
        where: {
          id: route.id,
          userId: user.id,
        },
      });
      if (router) {
        assertIfInvalidRouter(router);
        const parsedRouterFields = zodFields.parse(router.fields);
        const fieldsFromRouter = parsedRouterFields
          ?.filter((f) => !f.deleted)
          .map((f) => {
            return {
              ...f,
              routerId: route.id,
            };
          });

        if (fieldsFromRouter) {
          fields = fields.concat(fieldsFromRouter);
        }
      }
    }
    return fields;
  }

  function findFieldWithId(id: string, fields: InputFields) {
    return fields.find((field) => field.id === id);
  }

  /**
   * Update fields in connected forms as per the inputFields
   */
  async function updateFieldsInConnectedForms(
    serializedForm: SerializableForm<App_RoutingForms_Form>,
    inputFields: InputFields
  ) {
    for (const [, connectedForm] of Object.entries(serializedForm.connectedForms)) {
      const connectedFormDb = await prisma.app_RoutingForms_Form.findFirst({
        where: {
          id: connectedForm.id,
        },
      });
      if (!connectedFormDb) {
        continue;
      }
      const connectedFormFields = zodFields.parse(connectedFormDb.fields);

      const fieldsThatAreNotInConnectedForm = (
        inputFields?.filter((f) => !findFieldWithId(f.id, connectedFormFields || [])) || []
      ).map((f) => ({
        ...f,
        routerId: serializedForm.id,
      }));

      const updatedConnectedFormFields = connectedFormFields
        // Update fields that are already in connected form
        ?.map((field) => {
          if (isRouterLinkedField(field) && field.routerId === serializedForm.id) {
            return {
              ...field,
              ...findFieldWithId(field.id, inputFields || []),
            };
          }
          return field;
        })
        // Add fields that are not there
        .concat(fieldsThatAreNotInConnectedForm);

      await prisma.app_RoutingForms_Form.update({
        where: {
          id: connectedForm.id,
        },
        data: {
          fields: updatedConnectedFormFields,
        },
      });
    }
  }

  async function getRoutesAndFieldsForDuplication({
    duplicateFrom,
    userId,
  }: {
    duplicateFrom: DuplicateFrom;
    userId: number;
  }) {
    const sourceForm = await prisma.app_RoutingForms_Form.findFirst({
      where: {
        ...entityPrismaWhereClause({ userId }),
        id: duplicateFrom,
      },
      select: {
        id: true,
        fields: true,
        routes: true,
        userId: true,
        teamId: true,
        team: {
          select: {
            id: true,
            members: true,
          },
        },
      },
    });

    if (!sourceForm) {
      throw new TRPCError({
        code: "BAD_REQUEST",
        message: `Form to duplicate: ${duplicateFrom} not found`,
      });
    }

    if (!canEditEntity(sourceForm, userId)) {
      throw new TRPCError({
        code: "NOT_FOUND",
        message: `Form to duplicate: ${duplicateFrom} not found or you are unauthorized`,
      });
    }

    //TODO: Instead of parsing separately, use getSerializableForm. That would automatically remove deleted fields as well.
    const fieldsParsed = zodFields.safeParse(sourceForm.fields);
    const routesParsed = zodRoutes.safeParse(sourceForm.routes);
    if (!fieldsParsed.success || !routesParsed.success) {
      throw new TRPCError({
        code: "INTERNAL_SERVER_ERROR",
        message: "Could not parse source form's fields or routes",
      });
    }

    let fields, routes;
    if (shouldConnect) {
      routes = [
        // This connected route would automatically link the fields
        zodRouterRoute.parse({
          id: sourceForm.id,
          isRouter: true,
        }),
      ];
      fields =
        fieldsParsed.data
          // Deleted fields in the form shouldn't be added to the new form
          ?.filter((f) => !f.deleted)
          .map((f) => {
            return {
              id: f.id,
              routerId: sourceForm.id,
              label: "",
              type: "",
            };
          }) || [];
    } else {
      // Duplicate just routes and fields
      // We don't want name, description and responses to be copied
      routes = routesParsed.data || [];
      // FIXME: Deleted fields shouldn't come in duplicate
      fields = fieldsParsed.data ? fieldsParsed.data.filter((f) => !f.deleted) : [];
    }
    return { teamId: sourceForm.teamId, routes, fields };
  }

  function markMissingFieldsDeleted(
    serializedForm: SerializableForm<App_RoutingForms_Form>,
    fields: InputFields
  ) {
    // Find all fields that are in DB(including deleted) but not in the mutation
    // e.g. inputFields is [A,B,C]. DB is [A,B,C,D,E,F]. It means D,E,F got deleted
    const deletedFields =
      serializedForm.fields?.filter((f) => !fields.find((field) => field.id === f.id)) || [];

    // Add back deleted fields in the end and mark them deleted.
    // Fields mustn't be deleted, to make sure columns never decrease which hugely simplifies CSV generation
    fields = fields.concat(
      deletedFields.map((f) => {
        f.deleted = true;
        return f;
      })
    );
    return fields;
  }
  function assertIfInvalidRouter(router: App_RoutingForms_Form) {
    const routesOfRouter = zodRoutes.parse(router.routes);
    if (routesOfRouter) {
      if (routesOfRouter.find(isRouter)) {
        throw new TRPCError({
          code: "BAD_REQUEST",
          message:
            "A form being used as a Router must be a Origin form. It must not be using any other Router.",
        });
      }
    }
  }
};

export default formMutationHandler;