feat: migrate contact export to edge function (#2812)

Author: malek10xdev

backend/src/controllers/contacts.controller.ts

@@ -1,275 +1,3 @@
-import { User } from '@supabase/supabase-js';
-import { NextFunction, Request, Response } from 'express';
-import { Contacts } from '../db/interfaces/Contacts';
-import { Contact, ExportService } from '../db/types';
-import Billing from '../utils/billing-plugin';
-import { ExportOptions, ExportType } from '../services/export/types';
-import ExportFactory from '../services/export';
-import {
-  MiningSources,
-  OAuthMiningSourceCredentials
-} from '../db/interfaces/MiningSources';
-
-async function validateRequest(
-  req: Request,
-  res: Response,
-  miningSourceService: MiningSources
-) {
-  const user = res.locals.user as User;
-  const partialExport = req.body.partialExport ?? false;
-  const updateEmptyFieldsOnly = req.body.updateEmptyFieldsOnly ?? false;
-  const exportType = (req.params.exportType ?? ExportType.CSV) as ExportType;
-
-  const localeFromHeader = req.headers['accept-language'];
-  const delimiterOption = req.query.delimiter?.toString();
-
-  const validExportType = Object.values(ExportType).includes(
-    exportType as ExportType
-  );
-
-  if (!validExportType) {
-    throw new Error(`Invalid export type: ${exportType}`);
-  }
-
-  let googleContactsOptions: ExportOptions['googleContactsOptions'] = {
-    userId: user.id,
-    accessToken: undefined,
-    refreshToken: undefined,
-    updateEmptyFieldsOnly
-  };
-
-  if (exportType === ExportType.GOOGLE_CONTACTS) {
-    const targetEmail = req.body.targetEmail || user.email;
-    const sources = await miningSourceService.getSourcesForUser(
-      user.id,
-      targetEmail as string
-    );
-    const oauthCredentials = sources?.find((e) => e.email === targetEmail)
-      ?.credentials as OAuthMiningSourceCredentials;
-
-    googleContactsOptions = {
-      ...googleContactsOptions,
-      accessToken: oauthCredentials?.accessToken,
-      refreshToken: oauthCredentials?.refreshToken
-    };
-  }
-
-  const {
-    ids,
-    exportAllContacts
-  }: { ids?: string[]; exportAllContacts: boolean } = req.body;
-
-  if (!exportAllContacts && (!Array.isArray(ids) || !ids.length)) {
-    return {
-      userId: user.id,
-      exportType,
-      contactsToExport: null,
-      partialExport,
-      exportOptions: {
-        locale: localeFromHeader,
-        delimiter: undefined,
-        googleContactsOptions
-      }
-    };
-  }
-
-  const contactsToExport = exportAllContacts ? undefined : ids;
-
-  return {
-    userId: user.id,
-    exportType,
-    contactsToExport,
-    partialExport,
-    exportOptions: {
-      locale: localeFromHeader,
-      delimiter: delimiterOption,
-      googleContactsOptions
-    }
-  };
-}
-
-async function respondWithContacts(
-  res: Response,
-  userId: string,
-  contacts: Contacts,
-  exportType: ExportType,
-  contactsToExport?: string[],
-  exportOption?: ExportOptions
-) {
-  const selectedContacts = await contacts.getContacts(userId, contactsToExport);
-
-  if (!selectedContacts.length) {
-    return res.sendStatus(204); // 204 No Content
-  }
-
-  try {
-    const { content, contentType } = await ExportFactory.get(exportType).export(
-      selectedContacts,
-      exportOption
-    );
-
-    return res.header('Content-Type', contentType).status(200).send(content);
-  } catch (err) {
-    if ((err as Error).message === 'Invalid credentials.') {
-      return res.sendStatus(401);
-    }
-    throw err;
-  }
-}
-
-async function verifyCredits(
-  userId: string,
-  contacts: Contacts,
-  contactsToExport?: string[]
-) {
-  const newContacts = await contacts.getNonExportedContacts(
-    userId,
-    contactsToExport
-  );
-  const previousExportedContacts = await contacts.getExportedContacts(
-    userId,
-    contactsToExport
-  );
-  const creditsInfo = await Billing!.validateCustomerCredits(
-    userId,
-    newContacts.length
-  );
-  const response = {
-    total: newContacts.length + previousExportedContacts.length,
-    available: Math.floor(creditsInfo.availableUnits),
-    availableAlready: previousExportedContacts.length
-  };
-  return {
-    newContacts,
-    previousExportedContacts,
-    creditsInfo,
-    response
-  };
-}
-
-async function registerAndDeductCredits(
-  userId: string,
-  exportType: ExportType,
-  availableUnits: number,
-  contacts: Contacts,
-  availableContacts: Contact[]
-) {
-  if (availableContacts.length) {
-    await contacts.registerExportedContacts(
-      availableContacts.map(({ id }) => id),
-      exportType as unknown as ExportService,
-      userId
-    );
-    await Billing!.deductCustomerCredits(userId, availableUnits);
-  }
-}
-
-async function respondWithConfirmedContacts(
-  res: Response,
-  userId: string,
-  exportType: ExportType,
-  contacts: Contacts,
-  newContacts: Contact[],
-  previousExportedContacts: Contact[],
-  availableUnits: number,
-  statusCode: number,
-  exportOptions?: ExportOptions
-) {
-  const availableContacts = newContacts.slice(0, availableUnits);
-  const selectedContacts = [...previousExportedContacts, ...availableContacts];
-
-  try {
-    const { content, contentType } = await ExportFactory.get(exportType).export(
-      selectedContacts,
-      exportOptions
-    );
-
-    await registerAndDeductCredits(
-      userId,
-      exportType,
-      availableUnits,
-      contacts,
-      selectedContacts
-    );
-
-    return res
-      .header('Content-Type', contentType)
-      .status(statusCode)
-      .send(content);
-  } catch (err) {
-    if ((err as Error).message === 'Invalid credentials.') {
-      return res.sendStatus(401);
-    }
-    throw err;
-  }
-}
-
-export default function initializeContactsController(
-  contacts: Contacts,
-  miningSources: MiningSources
-) {
-  return {
-    async exportContactsCSV(req: Request, res: Response, next: NextFunction) {
-      const {
-        userId,
-        contactsToExport,
-        partialExport,
-        exportType,
-        exportOptions
-      } = await validateRequest(req, res, miningSources);
-      if (contactsToExport === null) {
-        return res.status(400).json({
-          message: 'Parameter "ids" must be a non-empty list of person ids'
-        });
-      }
-
-      let statusCode = 200;
-      try {
-        if (!Billing) {
-          // No need to Verify Credits, Export.
-          return await respondWithContacts(
-            res,
-            userId,
-            contacts,
-            exportType,
-            contactsToExport,
-            exportOptions
-          );
-        }
-
-        const { newContacts, previousExportedContacts, creditsInfo, response } =
-          await verifyCredits(userId, contacts, contactsToExport);
-
-        if (
-          creditsInfo.hasDeficientCredits &&
-          !previousExportedContacts.length
-        ) {
-          return res.status(402).json(response);
-        }
-
-        if (creditsInfo.hasInsufficientCredits && newContacts.length) {
-          if (!partialExport) {
-            res.statusMessage = 'Confirm Partial Content';
-            return res.status(266).json(response); // 266 Confirm Partial Content
-          }
-          statusCode = 206; // 206 Partial Content
-        }
-
-        // Export confirmed contacts.
-        return await respondWithConfirmedContacts(
-          res,
-          userId,
-          exportType,
-          contacts,
-          newContacts,
-          previousExportedContacts,
-          creditsInfo.availableUnits,
-          statusCode,
-          exportOptions
-        );
-      } catch (error) {
-        return next(error);
-      }
-    }
-  };
+export default function initializeContactsController() {
+  return {};
 }

backend/src/routes/contacts.routes.ts

@@ -1,38 +1,24 @@
 import { Router } from 'express';
 import rateLimit from 'express-rate-limit';
-import initializeContactsController from '../controllers/contacts.controller';
 import initializeContactsVerificationController from '../controllers/contacts-verification.controller';
 import { Contacts } from '../db/interfaces/Contacts';
 import initializeAuthMiddleware from '../middleware/auth';
 import AuthResolver from '../services/auth/AuthResolver';
-import { MiningSources } from '../db/interfaces/MiningSources';
 
 export default function initializeContactsRoutes(
   contacts: Contacts,
   authResolver: AuthResolver,
-  miningSources: MiningSources
+  miningSources: unknown
 ) {
   const router = Router();
   const contactsRouteLimiter = rateLimit({
     windowMs: 15 * 60 * 1000,
     max: 100
   });
 
-  const { exportContactsCSV } = initializeContactsController(
-    contacts,
-    miningSources
-  );
-
   const { verifyEmailStatus } =
     initializeContactsVerificationController(contacts);
 
-  router.post(
-    '/contacts/export/:exportType',
-    initializeAuthMiddleware(authResolver),
-    contactsRouteLimiter,
-    exportContactsCSV
-  );
-
   router.post(
     '/contacts/verify',
     initializeAuthMiddleware(authResolver),