[ENGG-1646] feat: collection support for mocks

app/src/backend/mocks/createCollection.ts

@@ -0,0 +1,55 @@
+import firebaseApp from "../../firebase";
+import { getFirestore, Timestamp, updateDoc, addDoc, collection } from "firebase/firestore";
+import { getOwnerId } from "backend/utils";
+import Logger from "lib/logger";
+import { MockRecordType, RQMockCollection } from "components/features/mocksV2/types";
+
+type MockCollectionData = Pick<RQMockCollection, "name" | "desc" | "type">;
+
+export const createCollection = async (
+ uid: string,
+ mockCollectionData: MockCollectionData,
+ teamId?: string
+): Promise<RQMockCollection | null> => {
+ if (!uid) {
+ return null;
+ }
+
+ const mockCollection = await createCollectionInFirebase(uid, mockCollectionData, teamId);
+
+ return mockCollection;
+};
+
+const createCollectionInFirebase = async (
+ uid: string,
+ mockCollectionData: MockCollectionData,
+ teamId?: string
+): Promise<RQMockCollection | null> => {
+ const db = getFirestore(firebaseApp);
+ const mocksRef = collection(db, "mocks");
+ const ownerId = getOwnerId(uid, teamId);
+
+ try {
+ const collectionData: RQMockCollection = {
+ ...mockCollectionData,
+ recordType: MockRecordType.COLLECTION,
+ ownerId: ownerId,
+ deleted: false,
+ createdBy: uid,
+ lastUpdatedBy: uid,
+ createdTs: Timestamp.now().toMillis(),
+ updatedTs: Timestamp.now().toMillis(),
+ };
+
+ const docRef = await addDoc(mocksRef, collectionData);
+
+ Logger.log(`Mock collection document created ${docRef.id}`);
+
+ await updateDoc(docRef, { id: docRef.id });
+
+ return { ...collectionData, id: docRef.id } as RQMockCollection;
+ } catch (err) {
+ Logger.error("Error while creating mock collection", err);
+ return null;
+ }
+};

app/src/backend/mocks/createMock.ts

@@ -1,6 +1,6 @@
 import firebaseApp from "../../firebase";
 import { getFirestore, Timestamp, updateDoc, addDoc, collection } from "firebase/firestore";
-import { RQMockSchema } from "components/features/mocksV2/types";
+import { MockRecordType, RQMockSchema } from "components/features/mocksV2/types";
 import { getOwnerId } from "backend/utils";
 import { updateUserMockSelectorsMap, uploadResponseBodyFiles } from "./common";
 import { BODY_IN_BUCKET_ENABLED } from "./constants";
@@ -48,7 +48,9 @@ const createMockFromFirebase = async (uid: string, mockData: RQMockSchema, teamI
  const ownerId = getOwnerId(uid, teamId);
 
  const mockId: string | null = await addDoc(rootMocksCollectionRef, {
+ collectionId: "",
  ...mockData,
+ recordType: MockRecordType.MOCK,
  createdBy: uid,
  ownerId: ownerId,
  deleted: false,

app/src/backend/mocks/deleteMock.ts

@@ -22,6 +22,7 @@ const deleteMockFromFirebase = async (mockId: string): Promise<boolean> => {
 
  const success = await updateDoc(docRef, {
  deleted: true,
+ collectionId: "",
  updatedTs: Timestamp.now().toMillis(),
  })
  .then(() => {

app/src/backend/mocks/deleteMocks.ts

@@ -0,0 +1,47 @@
+import firebaseApp from "../../firebase";
+import { doc, getFirestore, Timestamp, writeBatch, collection, deleteField } from "firebase/firestore";
+import { getOwnerId } from "backend/utils";
+
+export const deleteMocks = async (uid: string, mockIds: string[], teamId?: string): Promise<boolean> => {
+ if (!uid) {
+ return false;
+ }
+
+ const ownerId = getOwnerId(uid, teamId);
+ const result = await deleteMocksFromFirebase(uid, ownerId, mockIds);
+ return result;
+};
+
+const deleteMocksFromFirebase = async (uid: string, ownerId: string, mockIds: string[]): Promise<boolean> => {
+ try {
+ const db = getFirestore(firebaseApp);
+ const mocksbatch = writeBatch(db);
+ const userMocksMetadataRef = collection(db, "user-mocks-metadata");
+ const userDocRef = doc(userMocksMetadataRef, ownerId);
+
+ mockIds.forEach((mockId) => {
+ const mockRef = doc(db, "mocks", mockId);
+
+ mocksbatch.set(
+ mockRef,
+ {
+ deleted: true,
+ collectionId: "",
+ lastUpdatedBy: uid,
+ updatedTs: Timestamp.now().toMillis(),
+ },
+ { merge: true }
+ );
+
+ mocksbatch.update(userDocRef, {
+ [`mockSelectors.${mockId}`]: deleteField(),
+ });
+ });
+
+ await mocksbatch.commit();
+
+ return true;
+ } catch (error) {
+ return false;
+ }
+};

app/src/backend/mocks/updateCollections.ts

@@ -0,0 +1,36 @@
+import firebaseApp from "../../firebase";
+import { doc, getFirestore, Timestamp, writeBatch } from "firebase/firestore";
+import { RQMockCollection } from "components/features/mocksV2/types";
+
+export const updateCollections = async (uid: string, collections: Partial<RQMockCollection>[]): Promise<boolean> => {
+ if (!uid) {
+ return null;
+ }
+
+ const result = await updateCollectionsInFirebase(uid, collections);
+
+ return result;
+};
+
+const updateCollectionsInFirebase = async (uid: string, collections: Partial<RQMockCollection>[]): Promise<boolean> => {
+ try {
+ const db = getFirestore(firebaseApp);
+ const collectionsBatch = writeBatch(db);
+
+ collections.forEach((collection) => {
+ const collectionRef = doc(db, "mocks", collection.id);
+
+ collectionsBatch.set(
+ collectionRef,
+ { ...collection, lastUpdatedBy: uid, updatedTs: Timestamp.now().toMillis() },
+ { merge: true }
+ );
+ });
+
+ await collectionsBatch.commit();
+
+ return true;
+ } catch (error) {
+ return false;
+ }
+};

app/src/backend/mocks/updateMock.ts

@@ -1,6 +1,6 @@
 import firebaseApp from "../../firebase";
 import { doc, getFirestore, Timestamp, updateDoc } from "firebase/firestore";
-import { RQMockSchema } from "components/features/mocksV2/types";
+import { MockRecordType, RQMockSchema } from "components/features/mocksV2/types";
 import { getOwnerId } from "backend/utils";
 import { updateUserMockSelectorsMap, uploadResponseBodyFiles } from "./common";
 import { BODY_IN_BUCKET_ENABLED } from "./constants";
@@ -53,6 +53,7 @@ export const updateMockFromFirebase = async (
  const success = await updateDoc(docRef, {
  lastUpdatedBy: updaterId,
  ...mockData,
+ recordType: MockRecordType.MOCK,
  updatedTs: Timestamp.now().toMillis(),
  })
  .then(() => {

app/src/backend/mocks/updateMocksCollectionId.ts

@@ -0,0 +1,41 @@
+import firebaseApp from "../../firebase";
+import { Timestamp, doc, getFirestore, writeBatch } from "firebase/firestore";
+
+export const updateMocksCollectionId = async (
+ uid: string,
+ mockIds: string[],
+ updatedCollectionId: string
+): Promise<boolean> => {
+ if (!uid) {
+ return null;
+ }
+
+ const result = await updateMocksCollectionIdInFirebase(uid, mockIds, updatedCollectionId);
+ return result;
+};
+
+const updateMocksCollectionIdInFirebase = async (
+ uid: string,
+ mockIds: string[],
+ updatedCollectionId: string
+): Promise<boolean> => {
+ try {
+ const db = getFirestore(firebaseApp);
+ const mocksbatch = writeBatch(db);
+
+ mockIds.forEach((id) => {
+ const mockRef = doc(db, "mocks", id);
+ mocksbatch.set(
+ mockRef,
+ { collectionId: updatedCollectionId, lastUpdatedBy: uid, updatedTs: Timestamp.now().toMillis() },
+ { merge: true }
+ );
+ });
+
+ await mocksbatch.commit();
+
+ return true;
+ } catch (error) {
+ return false;
+ }
+};

app/src/components/features/mocksV2/MockEditorIndex/MockEditorIndex.tsx

@@ -101,7 +101,7 @@ const MockEditorIndex: React.FC<Props> = ({
  setSavingInProgress(false);
  if (success) {
  toast.success("Mock Updated Successfully");
- trackUpdateMockEvent(mockId, mockType, finalMockData?.fileType);
+ trackUpdateMockEvent(mockId, mockType, finalMockData?.fileType, finalMockData?.collectionId);
  return setMockEditorData(data);
  }
  toast.error("Mock Update Error");