Open-Source API Development Ecosystem • https://hoppscotch.io • Offline, On-Prem & Cloud • Web, Desktop & CLI • Open-Source Alternative to Postman, Insomnia
TypeScript apiapi-clientapi-restapi-testingdeveloper-toolsgraphqlhttphttp-clientpwarestrest-apispatestingtesting-toolstoolsvuevuejswebsocket
feat: implement collections syncing for selfhosted (#42)
Akash K86a12e2d2835
diff --git a/packages/hoppscotch-selfhost-web/package.json b/packages/hoppscotch-selfhost-web/package.jsonindex 1d02524f2..7e86b6251 100644--- a/packages/hoppscotch-selfhost-web/package.json+++ b/packages/hoppscotch-selfhost-web/package.json@@ -21,6 +21,7 @@},"dependencies": {"@hoppscotch/common": "workspace:^",+ "@hoppscotch/data": "workspace:^","axios": "^0.21.4","buffer": "^6.0.3","firebase": "^9.8.4",@@ -66,6 +67,7 @@"vite-plugin-static-copy": "^0.12.0","vite-plugin-vue-layouts": "^0.7.0","vite-plugin-windicss": "^1.8.8",+ "vitest": "^0.29.3","vue-tsc": "^1.0.9","windicss": "^3.5.6"}diff --git a/packages/hoppscotch-selfhost-web/src/api/mutations/CreateGQLChildUserCollection.graphql b/packages/hoppscotch-selfhost-web/src/api/mutations/CreateGQLChildUserCollection.graphqlnew file mode 100644index 000000000..54dc80c48--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/mutations/CreateGQLChildUserCollection.graphql@@ -0,0 +1,11 @@+mutation CreateGQLChildUserCollection(+ $title: String!+ $parentUserCollectionID: ID!+) {+ createGQLChildUserCollection(+ title: $title+ parentUserCollectionID: $parentUserCollectionID+ ) {+ id+ }+}diff --git a/packages/hoppscotch-selfhost-web/src/api/mutations/CreateGQLRootUserCollection.graphql b/packages/hoppscotch-selfhost-web/src/api/mutations/CreateGQLRootUserCollection.graphqlnew file mode 100644index 000000000..eecdebe17--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/mutations/CreateGQLRootUserCollection.graphql@@ -0,0 +1,5 @@+mutation CreateGQLRootUserCollection($title: String!) {+ createGQLRootUserCollection(title: $title) {+ id+ }+}diff --git a/packages/hoppscotch-selfhost-web/src/api/mutations/CreateGQLUserRequest.graphql b/packages/hoppscotch-selfhost-web/src/api/mutations/CreateGQLUserRequest.graphqlnew file mode 100644index 000000000..02423e864--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/mutations/CreateGQLUserRequest.graphql@@ -0,0 +1,13 @@+mutation CreateGQLUserRequest(+ $title: String!+ $request: String!+ $collectionID: ID!+) {+ createGQLUserRequest(+ title: $title+ request: $request+ collectionID: $collectionID+ ) {+ id+ }+}diff --git a/packages/hoppscotch-selfhost-web/src/api/mutations/CreateRESTChildUserCollection.graphql b/packages/hoppscotch-selfhost-web/src/api/mutations/CreateRESTChildUserCollection.graphqlnew file mode 100644index 000000000..40b38aca7--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/mutations/CreateRESTChildUserCollection.graphql@@ -0,0 +1,11 @@+mutation CreateRESTChildUserCollection(+ $title: String!+ $parentUserCollectionID: ID!+) {+ createRESTChildUserCollection(+ title: $title+ parentUserCollectionID: $parentUserCollectionID+ ) {+ id+ }+}diff --git a/packages/hoppscotch-selfhost-web/src/api/mutations/CreateRESTRootUserCollection.graphql b/packages/hoppscotch-selfhost-web/src/api/mutations/CreateRESTRootUserCollection.graphqlnew file mode 100644index 000000000..8c54f0c2b--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/mutations/CreateRESTRootUserCollection.graphql@@ -0,0 +1,5 @@+mutation CreateRESTRootUserCollection($title: String!) {+ createRESTRootUserCollection(title: $title) {+ id+ }+}diff --git a/packages/hoppscotch-selfhost-web/src/api/mutations/CreateRESTUserRequest.graphql b/packages/hoppscotch-selfhost-web/src/api/mutations/CreateRESTUserRequest.graphqlnew file mode 100644index 000000000..01d51b0c0--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/mutations/CreateRESTUserRequest.graphql@@ -0,0 +1,13 @@+mutation CreateRESTUserRequest(+ $collectionID: ID!+ $title: String!+ $request: String!+) {+ createRESTUserRequest(+ collectionID: $collectionID+ title: $title+ request: $request+ ) {+ id+ }+}diff --git a/packages/hoppscotch-selfhost-web/src/api/mutations/DeleteUserCollection.graphql b/packages/hoppscotch-selfhost-web/src/api/mutations/DeleteUserCollection.graphqlnew file mode 100644index 000000000..cafa7b08a--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/mutations/DeleteUserCollection.graphql@@ -0,0 +1,3 @@+mutation DeleteUserCollection($userCollectionID: ID!) {+ deleteUserCollection(userCollectionID: $userCollectionID)+}diff --git a/packages/hoppscotch-selfhost-web/src/api/mutations/DeleteUserRequest.graphql b/packages/hoppscotch-selfhost-web/src/api/mutations/DeleteUserRequest.graphqlnew file mode 100644index 000000000..c4855e807--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/mutations/DeleteUserRequest.graphql@@ -0,0 +1,3 @@+mutation DeleteUserRequest($requestID: ID!) {+ deleteUserRequest(id: $requestID)+}diff --git a/packages/hoppscotch-selfhost-web/src/api/mutations/MoveUserCollection.graphql b/packages/hoppscotch-selfhost-web/src/api/mutations/MoveUserCollection.graphqlnew file mode 100644index 000000000..ac280122f--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/mutations/MoveUserCollection.graphql@@ -0,0 +1,8 @@+mutation MoveUserCollection($destCollectionID: ID, $userCollectionID: ID!) {+ moveUserCollection(+ destCollectionID: $destCollectionID+ userCollectionID: $userCollectionID+ ) {+ id+ }+}diff --git a/packages/hoppscotch-selfhost-web/src/api/mutations/MoveUserRequest.graphql b/packages/hoppscotch-selfhost-web/src/api/mutations/MoveUserRequest.graphqlnew file mode 100644index 000000000..38f8e6ca7--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/mutations/MoveUserRequest.graphql@@ -0,0 +1,15 @@+mutation MoveUserRequest(+ $sourceCollectionID: ID!+ $requestID: ID!+ $destinationCollectionID: ID!+ $nextRequestID: ID+) {+ moveUserRequest(+ sourceCollectionID: $sourceCollectionID+ requestID: $requestID+ destinationCollectionID: $destinationCollectionID+ nextRequestID: $nextRequestID+ ) {+ id+ }+}diff --git a/packages/hoppscotch-selfhost-web/src/api/mutations/RenameUserCollection.graphql b/packages/hoppscotch-selfhost-web/src/api/mutations/RenameUserCollection.graphqlnew file mode 100644index 000000000..35603cea6--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/mutations/RenameUserCollection.graphql@@ -0,0 +1,8 @@+mutation RenameUserCollection($userCollectionID: ID!, $newTitle: String!) {+ renameUserCollection(+ userCollectionID: $userCollectionID+ newTitle: $newTitle+ ) {+ id+ }+}diff --git a/packages/hoppscotch-selfhost-web/src/api/mutations/UpdateGQLUserRequest.graphql b/packages/hoppscotch-selfhost-web/src/api/mutations/UpdateGQLUserRequest.graphqlnew file mode 100644index 000000000..253fed7db--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/mutations/UpdateGQLUserRequest.graphql@@ -0,0 +1,5 @@+mutation UpdateGQLUserRequest($id: ID!, $request: String!, $title: String) {+ updateGQLUserRequest(id: $id, request: $request, title: $title) {+ id+ }+}diff --git a/packages/hoppscotch-selfhost-web/src/api/mutations/UpdateRESTUserRequest.graphql b/packages/hoppscotch-selfhost-web/src/api/mutations/UpdateRESTUserRequest.graphqlnew file mode 100644index 000000000..b7899df9e--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/mutations/UpdateRESTUserRequest.graphql@@ -0,0 +1,7 @@+mutation UpdateRESTUserRequest($id: ID!, $title: String!, $request: String!) {+ updateRESTUserRequest(id: $id, title: $title, request: $request) {+ id+ collectionID+ request+ }+}diff --git a/packages/hoppscotch-selfhost-web/src/api/mutations/UpdateUserCollectionOrder.graphql b/packages/hoppscotch-selfhost-web/src/api/mutations/UpdateUserCollectionOrder.graphqlnew file mode 100644index 000000000..c9e665be0--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/mutations/UpdateUserCollectionOrder.graphql@@ -0,0 +1,6 @@+mutation UpdateUserCollectionOrder($collectionID: ID!, $nextCollectionID: ID) {+ updateUserCollectionOrder(+ collectionID: $collectionID+ nextCollectionID: $nextCollectionID+ )+}diff --git a/packages/hoppscotch-selfhost-web/src/api/queries/ExportUserCollectionsToJSON.graphql b/packages/hoppscotch-selfhost-web/src/api/queries/ExportUserCollectionsToJSON.graphqlnew file mode 100644index 000000000..09f54adb9--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/queries/ExportUserCollectionsToJSON.graphql@@ -0,0 +1,12 @@+query ExportUserCollectionsToJSON(+ $collectionID: ID+ $collectionType: ReqType!+) {+ exportUserCollectionsToJSON(+ collectionID: $collectionID+ collectionType: $collectionType+ ) {+ collectionType+ exportedCollection+ }+}diff --git a/packages/hoppscotch-selfhost-web/src/api/queries/GetRootGQLUserCollections.graphql b/packages/hoppscotch-selfhost-web/src/api/queries/GetRootGQLUserCollections.graphqlnew file mode 100644index 000000000..fcc80d993--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/queries/GetRootGQLUserCollections.graphql@@ -0,0 +1,13 @@+query GetGQLRootUserCollections {+ # the frontend doesnt paginate right now, so giving take a big enough value to get all collections at once+ rootGQLUserCollections(take: 99999) {+ id+ title+ type+ childrenGQL {+ id+ title+ type+ }+ }+}diff --git a/packages/hoppscotch-selfhost-web/src/api/queries/GetUserRootCollections.graphql b/packages/hoppscotch-selfhost-web/src/api/queries/GetUserRootCollections.graphqlnew file mode 100644index 000000000..0b6842339--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/queries/GetUserRootCollections.graphql@@ -0,0 +1,13 @@+query GetUserRootCollections {+ # the frontend doesnt paginate right now, so giving take a big enough value to get all collections at once+ rootRESTUserCollections(take: 99999) {+ id+ title+ type+ childrenREST {+ id+ title+ type+ }+ }+}diff --git a/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserCollectionCreated.graphql b/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserCollectionCreated.graphqlnew file mode 100644index 000000000..99870281c--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserCollectionCreated.graphql@@ -0,0 +1,10 @@+subscription UserCollectionCreated {+ userCollectionCreated {+ parent {+ id+ }+ id+ title+ type+ }+}diff --git a/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserCollectionMoved.graphql b/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserCollectionMoved.graphqlnew file mode 100644index 000000000..ed69fa99b--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserCollectionMoved.graphql@@ -0,0 +1,9 @@+subscription UserCollectionMoved {+ userCollectionMoved {+ id+ parent {+ id+ }+ type+ }+}diff --git a/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserCollectionOrderUpdated.graphql b/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserCollectionOrderUpdated.graphqlnew file mode 100644index 000000000..6b181af88--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserCollectionOrderUpdated.graphql@@ -0,0 +1,17 @@+subscription UserCollectionOrderUpdated {+ userCollectionOrderUpdated {+ userCollection {+ id+ parent {+ id+ }+ }++ nextUserCollection {+ id+ parent {+ id+ }+ }+ }+}diff --git a/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserCollectionRemoved.graphql b/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserCollectionRemoved.graphqlnew file mode 100644index 000000000..a3deba560--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserCollectionRemoved.graphql@@ -0,0 +1,6 @@+subscription UserCollectionRemoved {+ userCollectionRemoved {+ id+ type+ }+}diff --git a/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserCollectionUpdated.graphql b/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserCollectionUpdated.graphqlnew file mode 100644index 000000000..3fd8487d0--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserCollectionUpdated.graphql@@ -0,0 +1,10 @@+subscription userCollectionUpdated {+ userCollectionUpdated {+ id+ title+ type+ parent {+ id+ }+ }+}diff --git a/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserRequestCreated.graphql b/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserRequestCreated.graphqlnew file mode 100644index 000000000..462bc2461--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserRequestCreated.graphql@@ -0,0 +1,9 @@+subscription UserRequestCreated {+ userRequestCreated {+ id+ collectionID+ title+ request+ type+ }+}diff --git a/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserRequestDeleted.graphql b/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserRequestDeleted.graphqlnew file mode 100644index 000000000..6ef26f14c--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserRequestDeleted.graphql@@ -0,0 +1,9 @@+subscription UserRequestDeleted {+ userRequestDeleted {+ id+ collectionID+ title+ request+ type+ }+}diff --git a/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserRequestMoved.graphql b/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserRequestMoved.graphqlnew file mode 100644index 000000000..01a0fb24a--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserRequestMoved.graphql@@ -0,0 +1,13 @@+subscription UserRequestMoved {+ userRequestMoved {+ request {+ id+ collectionID+ type+ }+ nextRequest {+ id+ collectionID+ }+ }+}diff --git a/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserRequestUpdated.graphql b/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserRequestUpdated.graphqlnew file mode 100644index 000000000..b8c7f6e27--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/api/subscriptions/UserRequestUpdated.graphql@@ -0,0 +1,9 @@+subscription UserRequestUpdated {+ userRequestUpdated {+ id+ collectionID+ title+ request+ type+ }+}diff --git a/packages/hoppscotch-selfhost-web/src/lib/sync/index.ts b/packages/hoppscotch-selfhost-web/src/lib/sync/index.tsindex 64ad4b712..aa5e9d294 100644--- a/packages/hoppscotch-selfhost-web/src/lib/sync/index.ts+++ b/packages/hoppscotch-selfhost-web/src/lib/sync/index.ts@@ -79,7 +79,7 @@ export const getSyncInitFunction = <T extends DispatchingStore<any, any>>()}- startSubscriptions()+ stopSubscriptions = startSubscriptions()}function stopListeningToSubscriptions() {diff --git a/packages/hoppscotch-selfhost-web/src/lib/sync/mapper.ts b/packages/hoppscotch-selfhost-web/src/lib/sync/mapper.tsindex 19d93cc1b..b303243a6 100644--- a/packages/hoppscotch-selfhost-web/src/lib/sync/mapper.ts+++ b/packages/hoppscotch-selfhost-web/src/lib/sync/mapper.ts@@ -1,32 +1,41 @@-export const createMapper = () => {- const indexBackendIDMap = new Map<number, string | undefined>()- const backendIdIndexMap = new Map<string, number | undefined>()+export const createMapper = <+ LocalIDType extends string | number,+ BackendIDType extends string | number+>() => {+ const backendIDByLocalIDMap = new Map<+ LocalIDType,+ BackendIDType | undefined+ >()+ const localIDByBackendIDMap = new Map<+ BackendIDType,+ LocalIDType | undefined+ >()return {- addEntry(localIndex: number, backendId: string) {- indexBackendIDMap.set(localIndex, backendId)- backendIdIndexMap.set(backendId, localIndex)+ addEntry(localIdentifier: LocalIDType, backendIdentifier: BackendIDType) {+ backendIDByLocalIDMap.set(localIdentifier, backendIdentifier)+ localIDByBackendIDMap.set(backendIdentifier, localIdentifier)},getValue() {- return indexBackendIDMap+ return backendIDByLocalIDMap},- getBackendIdByIndex(localIndex: number) {- return indexBackendIDMap.get(localIndex)+ getBackendIDByLocalID(localIdentifier: LocalIDType) {+ return backendIDByLocalIDMap.get(localIdentifier)},- getIndexByBackendId(backendId: string) {- return backendIdIndexMap.get(backendId)+ getLocalIDByBackendID(backendId: BackendIDType) {+ return localIDByBackendIDMap.get(backendId)},- removeEntry(backendId?: string, index?: number) {+ removeEntry(backendId?: BackendIDType, index?: LocalIDType) {if (backendId) {- const index = backendIdIndexMap.get(backendId)+ const index = localIDByBackendIDMap.get(backendId)- backendIdIndexMap.delete(backendId)- index && indexBackendIDMap.delete(index)+ localIDByBackendIDMap.delete(backendId)+ index && backendIDByLocalIDMap.delete(index)} else if (index) {- const backendId = indexBackendIDMap.get(index)+ const backendId = backendIDByLocalIDMap.get(index)- indexBackendIDMap.delete(index)- backendId && backendIdIndexMap.delete(backendId)+ backendIDByLocalIDMap.delete(index)+ backendId && localIDByBackendIDMap.delete(backendId)}},}diff --git a/packages/hoppscotch-selfhost-web/src/main.ts b/packages/hoppscotch-selfhost-web/src/main.tsindex 5ece10f56..93a663532 100644--- a/packages/hoppscotch-selfhost-web/src/main.ts+++ b/packages/hoppscotch-selfhost-web/src/main.ts@@ -1,10 +1,12 @@import { createHoppApp } from "@hoppscotch/common"import { def as authDef } from "./platform/auth"import { def as environmentsDef } from "./platform/environments/environments.platform"+import { def as collectionsDef } from "./platform/collections/collections.platform"createHoppApp("#app", {auth: authDef,sync: {environments: environmentsDef,+ collections: collectionsDef,},})diff --git a/packages/hoppscotch-selfhost-web/src/platform/collections/collections.api.ts b/packages/hoppscotch-selfhost-web/src/platform/collections/collections.api.tsnew file mode 100644index 000000000..b29de53ea--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/platform/collections/collections.api.ts@@ -0,0 +1,302 @@+import {+ runGQLQuery,+ runGQLSubscription,+ runMutation,+} from "@hoppscotch/common/helpers/backend/GQLClient"+import {+ CreateRestRootUserCollectionDocument,+ CreateRestRootUserCollectionMutation,+ CreateRestRootUserCollectionMutationVariables,+ CreateRestUserRequestMutation,+ CreateRestUserRequestMutationVariables,+ CreateRestUserRequestDocument,+ CreateRestChildUserCollectionMutation,+ CreateRestChildUserCollectionMutationVariables,+ CreateRestChildUserCollectionDocument,+ DeleteUserCollectionMutation,+ DeleteUserCollectionMutationVariables,+ DeleteUserCollectionDocument,+ RenameUserCollectionMutation,+ RenameUserCollectionMutationVariables,+ RenameUserCollectionDocument,+ MoveUserCollectionMutation,+ MoveUserCollectionMutationVariables,+ MoveUserCollectionDocument,+ DeleteUserRequestMutation,+ DeleteUserRequestMutationVariables,+ DeleteUserRequestDocument,+ MoveUserRequestDocument,+ MoveUserRequestMutation,+ MoveUserRequestMutationVariables,+ UpdateUserCollectionOrderMutation,+ UpdateUserCollectionOrderMutationVariables,+ UpdateUserCollectionOrderDocument,+ GetUserRootCollectionsQuery,+ GetUserRootCollectionsQueryVariables,+ GetUserRootCollectionsDocument,+ UserCollectionCreatedDocument,+ UserCollectionUpdatedDocument,+ UserCollectionRemovedDocument,+ UserCollectionMovedDocument,+ UserCollectionOrderUpdatedDocument,+ ExportUserCollectionsToJsonQuery,+ ExportUserCollectionsToJsonQueryVariables,+ ExportUserCollectionsToJsonDocument,+ UserRequestCreatedDocument,+ UserRequestUpdatedDocument,+ UserRequestMovedDocument,+ UserRequestDeletedDocument,+ UpdateRestUserRequestMutation,+ UpdateRestUserRequestMutationVariables,+ UpdateRestUserRequestDocument,+ CreateGqlRootUserCollectionMutation,+ CreateGqlRootUserCollectionMutationVariables,+ CreateGqlRootUserCollectionDocument,+ CreateGqlUserRequestMutation,+ CreateGqlUserRequestMutationVariables,+ CreateGqlUserRequestDocument,+ CreateGqlChildUserCollectionMutation,+ CreateGqlChildUserCollectionMutationVariables,+ CreateGqlChildUserCollectionDocument,+ UpdateGqlUserRequestMutation,+ UpdateGqlUserRequestMutationVariables,+ UpdateGqlUserRequestDocument,+ GetGqlRootUserCollectionsQuery,+ GetGqlRootUserCollectionsQueryVariables,+ GetGqlRootUserCollectionsDocument,+ ReqType,+} from "../../api/generated/graphql"++export const createRESTRootUserCollection = (title: string) =>+ runMutation<+ CreateRestRootUserCollectionMutation,+ CreateRestRootUserCollectionMutationVariables,+ ""+ >(CreateRestRootUserCollectionDocument, {+ title,+ })()++export const createGQLRootUserCollection = (title: string) =>+ runMutation<+ CreateGqlRootUserCollectionMutation,+ CreateGqlRootUserCollectionMutationVariables,+ ""+ >(CreateGqlRootUserCollectionDocument, {+ title,+ })()++export const createRESTUserRequest = (+ title: string,+ request: string,+ collectionID: string+) =>+ runMutation<+ CreateRestUserRequestMutation,+ CreateRestUserRequestMutationVariables,+ ""+ >(CreateRestUserRequestDocument, {+ title,+ request,+ collectionID,+ })()++export const createGQLUserRequest = (+ title: string,+ request: string,+ collectionID: string+) =>+ runMutation<+ CreateGqlUserRequestMutation,+ CreateGqlUserRequestMutationVariables,+ ""+ >(CreateGqlUserRequestDocument, {+ title,+ request,+ collectionID,+ })()++export const createRESTChildUserCollection = (+ title: string,+ parentUserCollectionID: string+) =>+ runMutation<+ CreateRestChildUserCollectionMutation,+ CreateRestChildUserCollectionMutationVariables,+ ""+ >(CreateRestChildUserCollectionDocument, {+ title,+ parentUserCollectionID,+ })()++export const createGQLChildUserCollection = (+ title: string,+ parentUserCollectionID: string+) =>+ runMutation<+ CreateGqlChildUserCollectionMutation,+ CreateGqlChildUserCollectionMutationVariables,+ ""+ >(CreateGqlChildUserCollectionDocument, {+ title,+ parentUserCollectionID,+ })()++export const deleteUserCollection = (userCollectionID: string) =>+ runMutation<+ DeleteUserCollectionMutation,+ DeleteUserCollectionMutationVariables,+ ""+ >(DeleteUserCollectionDocument, {+ userCollectionID,+ })()++export const renameUserCollection = (+ userCollectionID: string,+ newTitle: string+) =>+ runMutation<+ RenameUserCollectionMutation,+ RenameUserCollectionMutationVariables,+ ""+ >(RenameUserCollectionDocument, { userCollectionID, newTitle })()++export const moveUserCollection = (+ sourceCollectionID: string,+ destinationCollectionID?: string+) =>+ runMutation<+ MoveUserCollectionMutation,+ MoveUserCollectionMutationVariables,+ ""+ >(MoveUserCollectionDocument, {+ userCollectionID: sourceCollectionID,+ destCollectionID: destinationCollectionID,+ })()++export const editUserRequest = (+ requestID: string,+ title: string,+ request: string+) =>+ runMutation<+ UpdateRestUserRequestMutation,+ UpdateRestUserRequestMutationVariables,+ ""+ >(UpdateRestUserRequestDocument, {+ id: requestID,+ request,+ title,+ })()++export const editGQLUserRequest = (+ requestID: string,+ title: string,+ request: string+) =>+ runMutation<+ UpdateGqlUserRequestMutation,+ UpdateGqlUserRequestMutationVariables,+ ""+ >(UpdateGqlUserRequestDocument, {+ id: requestID,+ request,+ title,+ })()++export const deleteUserRequest = (requestID: string) =>+ runMutation<+ DeleteUserRequestMutation,+ DeleteUserRequestMutationVariables,+ ""+ >(DeleteUserRequestDocument, {+ requestID,+ })()++export const moveUserRequest = (+ sourceCollectionID: string,+ destinationCollectionID: string,+ requestID: string,+ nextRequestID?: string+) =>+ runMutation<MoveUserRequestMutation, MoveUserRequestMutationVariables, "">(+ MoveUserRequestDocument,+ {+ sourceCollectionID,+ destinationCollectionID,+ requestID,+ nextRequestID,+ }+ )()++export const updateUserCollectionOrder = (+ collectionID: string,+ nextCollectionID?: string+) =>+ runMutation<+ UpdateUserCollectionOrderMutation,+ UpdateUserCollectionOrderMutationVariables,+ ""+ >(UpdateUserCollectionOrderDocument, {+ collectionID,+ nextCollectionID,+ })()++export const getUserRootCollections = () =>+ runGQLQuery<+ GetUserRootCollectionsQuery,+ GetUserRootCollectionsQueryVariables,+ ""+ >({+ query: GetUserRootCollectionsDocument,+ })++export const getGQLRootUserCollections = () =>+ runGQLQuery<+ GetGqlRootUserCollectionsQuery,+ GetGqlRootUserCollectionsQueryVariables,+ ""+ >({+ query: GetGqlRootUserCollectionsDocument,+ })++export const exportUserCollectionsToJSON = (+ collectionID?: string,+ collectionType: ReqType.Rest | ReqType.Gql = ReqType.Rest+) =>+ runGQLQuery<+ ExportUserCollectionsToJsonQuery,+ ExportUserCollectionsToJsonQueryVariables,+ ""+ >({+ query: ExportUserCollectionsToJsonDocument,+ variables: { collectionID, collectionType },+ })++export const runUserCollectionCreatedSubscription = () =>+ runGQLSubscription({ query: UserCollectionCreatedDocument })++export const runUserCollectionUpdatedSubscription = () =>+ runGQLSubscription({ query: UserCollectionUpdatedDocument })++export const runUserCollectionRemovedSubscription = () =>+ runGQLSubscription({ query: UserCollectionRemovedDocument })++export const runUserCollectionMovedSubscription = () =>+ runGQLSubscription({ query: UserCollectionMovedDocument })++export const runUserCollectionOrderUpdatedSubscription = () =>+ runGQLSubscription({+ query: UserCollectionOrderUpdatedDocument,+ })++export const runUserRequestCreatedSubscription = () =>+ runGQLSubscription({ query: UserRequestCreatedDocument })++export const runUserRequestUpdatedSubscription = () =>+ runGQLSubscription({ query: UserRequestUpdatedDocument })++export const runUserRequestMovedSubscription = () =>+ runGQLSubscription({ query: UserRequestMovedDocument })++export const runUserRequestDeletedSubscription = () =>+ runGQLSubscription({ query: UserRequestDeletedDocument })diff --git a/packages/hoppscotch-selfhost-web/src/platform/collections/collections.mapper.ts b/packages/hoppscotch-selfhost-web/src/platform/collections/collections.mapper.tsnew file mode 100644index 000000000..3316426dc--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/platform/collections/collections.mapper.ts@@ -0,0 +1,456 @@+import {+ graphqlCollectionStore,+ navigateToFolderWithIndexPath,+ restCollectionStore,+} from "@hoppscotch/common/newstore/collections"+import { createMapper } from "../../lib/sync/mapper"+import {+ restCollectionsMapper,+ collectionReorderOrMovingOperations,+ restRequestsMapper,+} from "./collections.sync"+import { gqlCollectionsMapper, gqlRequestsMapper } from "./gqlCollections.sync"++function reorderItems(array: unknown[], from: number, to: number) {+ const item = array.splice(from, 1)[0]+ if (from < to) {+ array.splice(to - 1, 0, item)+ } else {+ array.splice(to, 0, item)+ }+}++type RequestType = "REST" | "GQL"++export function moveCollectionInMapper(+ folderPath: string,+ destinationPath?: string,+ collectionType: RequestType = "REST"+) {+ const indexes = folderPath.split("/")+ indexes.pop()+ const collectionPath = indexes.join("/")++ const { collectionsMapper, requestsMapper, collectionStore } =+ getMappersAndStoreByType(collectionType)++ // Store the backend id of the folder to move for adding it to the destinationPath+ const collectionToMoveBackendID =+ collectionsMapper.getBackendIDByLocalID(folderPath)++ // Remove the request from its current position+ collectionsMapper.removeEntry(undefined, folderPath)++ // We are assuming moveRequestInMapper is called after the item is moved in the store,+ // so we'll fetch the index of the last added item + 1 to add to the mapper+ // but in the case of the same parent, the destinationPath will change+ // eg:+ // 0. Collection 0+ // 1. Collection 1+ // in the above example, if we move Collection 0 to Collection 1 ( folderPath: 0, destinationPath: 1 ),+ // the effective index of Collection 1, when using navigateToFolderWithIndexPath will be 0+ // so we check if the moving is between same parent folders / collections and adds a workaround for this+ const isSameParentPath =+ getParentPathFromPath(folderPath) == getParentPathFromPath(destinationPath)++ let changedDestinationPath: string | undefined++ if (isSameParentPath) {+ const lastFolderPathIndex = folderPath.split("/").pop()+ const folderIndex = lastFolderPathIndex && parseInt(lastFolderPathIndex)++ const lastDestinationPathIndex =+ destinationPath && destinationPath.split("/").pop()+ const destinationIndex =+ destinationPath &&+ lastDestinationPathIndex &&+ parseInt(lastDestinationPathIndex)++ if (+ (folderIndex == 0 || folderIndex) &&+ (destinationIndex == 0 || destinationIndex) &&+ folderIndex < destinationIndex+ ) {+ const destinationParentPath = getParentPathFromPath(destinationPath)+ changedDestinationPath = destinationParentPath+ ? `${destinationParentPath}/${destinationIndex - 1}`+ : `${destinationIndex - 1}`+ }+ }++ const destinationFolder =+ changedDestinationPath &&+ navigateToFolderWithIndexPath(+ collectionStore.value.state,+ changedDestinationPath.split("/").map((pathIndex) => parseInt(pathIndex))+ )++ const destinationCollectionID =+ destinationPath && collectionsMapper.getBackendIDByLocalID(destinationPath)++ if (destinationFolder && collectionToMoveBackendID) {+ const destinationIndex = destinationFolder.folders.length++ const newPath = `${destinationPath}/${destinationIndex}`+ collectionsMapper.addEntry(newPath, collectionToMoveBackendID)++ changeParentForAllChildrenFromMapper(folderPath, newPath, collectionType)++ collectionToMoveBackendID &&+ collectionReorderOrMovingOperations.push({+ sourceCollectionID: collectionToMoveBackendID,+ destinationCollectionID,+ reorderOperation: {+ fromPath: folderPath,+ toPath: `${changedDestinationPath}/${destinationIndex}`,+ },+ })+ }++ // destinationPath won't be there, when moving to the root+ if (!destinationPath && collectionToMoveBackendID) {+ const destinationIndex = collectionStore.value.state.length+ const newPath = `${destinationIndex}`++ collectionsMapper.addEntry(newPath, collectionToMoveBackendID)++ changeParentForAllChildrenFromMapper(folderPath, newPath, collectionType)+ }++ reorderIndexesAfterEntryRemoval(+ collectionPath,+ collectionsMapper,+ collectionType+ )+ reorderIndexesAfterEntryRemoval(+ collectionPath,+ requestsMapper,+ collectionType+ )+}++export function moveRequestInMapper(+ requestIndex: number,+ path: string,+ destinationPath: string,+ requestType: RequestType+) {+ const { collectionStore, requestsMapper } =+ getMappersAndStoreByType(requestType)++ // Store the backend id of the request to move for adding it to the destinationPath+ const requestToMoveBackendID = requestsMapper.getBackendIDByLocalID(+ `${path}/${requestIndex}`+ )++ // Remove the request from its current position+ requestsMapper.removeEntry(undefined, `${path}/${requestIndex}`)+ reorderIndexesAfterEntryRemoval(path, requestsMapper, requestType)++ // We are assuming moveRequestInMapper is called after the item is moved in the store,+ // so we'll fetch the index of the last added item + 1 to add to the mapper+ const destinationFolder = navigateToFolderWithIndexPath(+ collectionStore.value.state,+ destinationPath.split("/").map((pathIndex) => parseInt(pathIndex))+ )++ if (destinationFolder && requestToMoveBackendID) {+ const destinationIndex = destinationFolder.requests.length++ requestsMapper.addEntry(+ `${destinationPath}/${destinationIndex}`,+ requestToMoveBackendID+ )+ }+}++// we allow reordering in the same parent collection right now+export function reorderRequestsMapper(+ requestIndex: number,+ path: string,+ nextRequestIndex: number,+ requestType: RequestType+) {+ const { requestsMapper } = getMappersAndStoreByType(requestType)++ const directChildren = getDirectChildrenEntriesFromMapper(+ path,+ requestsMapper+ )++ reorderItems(directChildren, requestIndex, nextRequestIndex)++ directChildren.forEach((item, index) => {+ item[1] && requestsMapper.addEntry(`${path}/${index}`, item[1])+ })+}+// we allow reordering in the same parent collection right now++export function reorderCollectionsInMapper(+ collectionPath: string,+ destinationCollectionPath: string,+ requestType: RequestType+) {+ const { requestsMapper, collectionsMapper } =+ getMappersAndStoreByType(requestType)++ const indexes = collectionPath.split("/")+ indexes.pop()+ const parentCollectionPath = indexes.join("/")++ const directChildren = getDirectChildrenEntriesFromMapper(+ parentCollectionPath,+ collectionsMapper+ )++ const collectionIndex = collectionPath.split("/").pop()+ const destinationIndex = destinationCollectionPath.split("/").pop()++ collectionIndex &&+ destinationIndex &&+ reorderItems(+ directChildren,+ parentCollectionPath+ ? parseInt(collectionIndex)+ : parseInt(collectionPath),+ parentCollectionPath+ ? parseInt(destinationIndex)+ : parseInt(destinationCollectionPath)+ )++ const previousCollectionEntries: Record<+ string,+ [string, string | undefined][]+ > = {}++ const previousRequestEntries: Record<string, [string, string | undefined][]> =+ {}++ directChildren.forEach(([path, backendID], index) => {+ const newPath = parentCollectionPath+ ? `${parentCollectionPath}/${index}`+ : `${index}`++ const indexes = path.split("/")+ const childIndex = indexes.pop()++ if (childIndex && index != parseInt(childIndex)) {+ backendID && collectionsMapper.addEntry(newPath, backendID)++ const existingCollectionsOnNewPath = getChildrenEntriesFromMapper(+ newPath,+ collectionsMapper+ )++ const existingRequestsOnNewPath = getChildrenEntriesFromMapper(+ newPath,+ requestsMapper+ )++ previousCollectionEntries[newPath] = existingCollectionsOnNewPath+ previousRequestEntries[newPath] = existingRequestsOnNewPath++ removeAllChildCollectionsFromMapper(newPath, requestType)+ removeAllChildRequestsFromMapper(newPath, requestType)++ if (path in previousCollectionEntries && path in previousRequestEntries) {+ previousCollectionEntries[path].forEach(([previousPath, backendID]) => {+ const pattern = new RegExp(`^(${path})\/`)++ const updatedPath = previousPath.replace(pattern, `${newPath}/`)++ backendID && collectionsMapper.addEntry(updatedPath, backendID)+ })++ previousRequestEntries[path].forEach(([previousPath, backendID]) => {+ const pattern = new RegExp(`^(${path})\/`)++ const updatedPath = previousPath.replace(pattern, `${newPath}/`)++ backendID && requestsMapper.addEntry(updatedPath, backendID)+ })+ } else {+ changeParentForAllChildrenFromMapper(path, newPath, requestType)+ }+ }+ })+}++export function removeAndReorderEntries(+ localIndex: string,+ collectionType: RequestType+) {+ const { collectionsMapper, requestsMapper } =+ getMappersAndStoreByType(collectionType)++ // get the collectionPath from the localIndex+ const indexes = localIndex.split("/")+ indexes.pop()+ const collectionPath = indexes.join("/")++ collectionsMapper.removeEntry(undefined, localIndex)++ removeAllChildCollectionsFromMapper(localIndex, collectionType)+ removeAllChildRequestsFromMapper(localIndex, collectionType)++ reorderIndexesAfterEntryRemoval(+ collectionPath,+ collectionsMapper,+ collectionType+ )+ reorderIndexesAfterEntryRemoval(+ collectionPath,+ requestsMapper,+ collectionType+ )+}++export function removeAllChildRequestsFromMapper(+ collectionPath: string,+ requestType: RequestType+) {+ const { requestsMapper } = getMappersAndStoreByType(requestType)++ const childRequestMapperEntries = getChildrenEntriesFromMapper(+ collectionPath,+ requestsMapper+ )++ childRequestMapperEntries.forEach(([path]) => {+ typeof path == "string" && requestsMapper.removeEntry(undefined, path)+ })+}++export function removeAllChildCollectionsFromMapper(+ collectionPath: string,+ collectionType: RequestType+) {+ const { collectionsMapper } = getMappersAndStoreByType(collectionType)++ const childCollectionMapperEntries = getChildrenEntriesFromMapper(+ collectionPath,+ collectionsMapper+ )++ childCollectionMapperEntries.forEach(([path]) => {+ typeof path == "string" && collectionsMapper.removeEntry(undefined, path)+ })+}++export function changeParentForAllChildrenFromMapper(+ currentParentPath: string,+ newParentPath: string,+ collectionType: RequestType+) {+ const { collectionsMapper, requestsMapper } =+ getMappersAndStoreByType(collectionType)++ const childCollectionsMapperEntries = getChildrenEntriesFromMapper(+ currentParentPath,+ collectionsMapper+ )++ const childRequestsMapperEntries = getChildrenEntriesFromMapper(+ currentParentPath,+ requestsMapper+ )++ const pattern = new RegExp(`^(${currentParentPath})`)++ childCollectionsMapperEntries.forEach(([path, backendID]) => {+ const newPath =+ typeof path == "string" && path.replace(pattern, newParentPath)++ if (newPath && typeof backendID == "string") {+ collectionsMapper.removeEntry(undefined, path)+ collectionsMapper.addEntry(newPath, backendID)+ }+ })++ childRequestsMapperEntries.forEach(([path, backendID]) => {+ const newPath =+ typeof path == "string" && path.replace(pattern, newParentPath)++ if (newPath && typeof backendID == "string") {+ requestsMapper.removeEntry(undefined, path)+ requestsMapper.addEntry(newPath, backendID)+ }+ })+}++export function getChildrenEntriesFromMapper(+ path: string,+ mapper: ReturnType<typeof createMapper<string, string>>+) {+ let mapperEntries = Array.from(mapper.getValue().entries())++ // if there are no path( eg: "" ), all the entries are children, so return the entire mapperEntries without filtering+ if (!path) return mapperEntries++ mapperEntries = mapperEntries.filter((entry) => {+ const pattern = new RegExp(`^${path}\/(\\w+)\/?.*$`)++ return !!(typeof entry[0] == "string" && entry[0].match(pattern))+ })++ return mapperEntries+}++export function getDirectChildrenEntriesFromMapper(+ path: string,+ mapper: ReturnType<typeof createMapper<string, string>>+) {+ let mapperEntries = Array.from(mapper.getValue().entries())++ mapperEntries = mapperEntries.filter((entry) => {+ const pattern = new RegExp(path ? `^${path}\/\\d+$` : `^\\d+$`)++ return !!(typeof entry[0] == "string" && entry[0].match(pattern))+ })++ return mapperEntries+}++export function reorderIndexesAfterEntryRemoval(+ pathToReorder: string,+ mapper: ReturnType<typeof createMapper<string, string>>,+ requestType: RequestType+) {+ const directChildren = getDirectChildrenEntriesFromMapper(+ pathToReorder,+ mapper+ )++ directChildren.forEach(([path, backendID], index) => {+ const indexes = path.split("/").map((index) => parseInt(index))+ const childIndex = indexes.pop()+ const collectionPath = indexes.join("/")++ if (childIndex != index && backendID) {+ const newPath = collectionPath ? `${collectionPath}/${index}` : `${index}`++ mapper.removeEntry(undefined, path)+ mapper.addEntry(newPath, backendID)+ changeParentForAllChildrenFromMapper(path, newPath, requestType)+ }+ })+}++function getParentPathFromPath(path: string | undefined) {+ const indexes = path ? path.split("/") : []+ indexes.pop()++ return indexes.join("/")+}++export function getMappersAndStoreByType(type: "GQL" | "REST") {+ const isGQL = type == "GQL"++ const collectionsMapper = isGQL ? gqlCollectionsMapper : restCollectionsMapper++ const requestsMapper = isGQL ? gqlRequestsMapper : restRequestsMapper++ const collectionStore = isGQL ? graphqlCollectionStore : restCollectionStore++ return { collectionsMapper, requestsMapper, collectionStore }+}diff --git a/packages/hoppscotch-selfhost-web/src/platform/collections/collections.platform.ts b/packages/hoppscotch-selfhost-web/src/platform/collections/collections.platform.tsnew file mode 100644index 000000000..118bc326d--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/platform/collections/collections.platform.ts@@ -0,0 +1,824 @@+import { authEvents$, def as platformAuth } from "@platform/auth"+import { CollectionsPlatformDef } from "@hoppscotch/common/platform/collections"+import { runDispatchWithOutSyncing } from "../../lib/sync"++import {+ exportUserCollectionsToJSON,+ runUserCollectionCreatedSubscription,+ runUserCollectionMovedSubscription,+ runUserCollectionOrderUpdatedSubscription,+ runUserCollectionRemovedSubscription,+ runUserCollectionUpdatedSubscription,+ runUserRequestCreatedSubscription,+ runUserRequestDeletedSubscription,+ runUserRequestMovedSubscription,+ runUserRequestUpdatedSubscription,+} from "./collections.api"+import {+ collectionReorderOrMovingOperations,+ collectionsSyncer,+ restCollectionsOperations,+ restCollectionsMapper,+ restRequestsMapper,+} from "./collections.sync"+import {+ moveCollectionInMapper,+ removeAndReorderEntries,+ reorderIndexesAfterEntryRemoval,+ reorderCollectionsInMapper,+ getMappersAndStoreByType,+} from "./collections.mapper"++import * as E from "fp-ts/Either"+import {+ addRESTCollection,+ setRESTCollections,+ editRESTCollection,+ removeRESTCollection,+ moveRESTFolder,+ updateRESTCollectionOrder,+ saveRESTRequestAs,+ navigateToFolderWithIndexPath,+ editRESTRequest,+ removeRESTRequest,+ moveRESTRequest,+ updateRESTRequestOrder,+ addRESTFolder,+ editRESTFolder,+ removeRESTFolder,+ addGraphqlFolder,+ addGraphqlCollection,+ editGraphqlFolder,+ editGraphqlCollection,+ removeGraphqlFolder,+ removeGraphqlCollection,+ saveGraphqlRequestAs,+ editGraphqlRequest,+ moveGraphqlRequest,+ removeGraphqlRequest,+ setGraphqlCollections,+} from "@hoppscotch/common/newstore/collections"+import { runGQLSubscription } from "@hoppscotch/common/helpers/backend/GQLClient"+import {+ HoppCollection,+ HoppGQLRequest,+ HoppRESTRequest,+} from "@hoppscotch/data"+import {+ gqlCollectionsOperations,+ gqlCollectionsSyncer,+} from "./gqlCollections.sync"+import { ReqType } from "../../api/generated/graphql"++function initCollectionsSync() {+ const currentUser$ = platformAuth.getCurrentUserStream()+ collectionsSyncer.startStoreSync()+ collectionsSyncer.setupSubscriptions(setupSubscriptions)++ gqlCollectionsSyncer.startStoreSync()++ loadUserRootCollections("REST")+ loadUserRootCollections("GQL")++ // TODO: test & make sure the auth thing is working properly+ currentUser$.subscribe(async (user) => {+ if (user) {+ loadUserRootCollections("REST")+ loadUserRootCollections("GQL")+ }+ })++ authEvents$.subscribe((event) => {+ if (event.event == "login" || event.event == "token_refresh") {+ collectionsSyncer.startListeningToSubscriptions()+ }++ if (event.event == "logout") {+ collectionsSyncer.stopListeningToSubscriptions()+ }+ })+}++type ExportedUserCollectionREST = {+ id?: string+ folders: ExportedUserCollectionREST[]+ requests: Array<HoppRESTRequest & { id: string }>+ name: string+}++type ExportedUserCollectionGQL = {+ id?: string+ folders: ExportedUserCollectionGQL[]+ requests: Array<HoppGQLRequest & { id: string }>+ name: string+}++function exportedCollectionToHoppCollection(+ collection: ExportedUserCollectionREST | ExportedUserCollectionGQL,+ collectionType: "REST" | "GQL"+): HoppCollection<HoppRESTRequest | HoppGQLRequest> {+ if (collectionType == "REST") {+ const restCollection = collection as ExportedUserCollectionREST++ return {+ v: 1,+ name: restCollection.name,+ folders: restCollection.folders.map((folder) =>+ exportedCollectionToHoppCollection(folder, collectionType)+ ),+ requests: restCollection.requests.map(+ ({+ v,+ auth,+ body,+ endpoint,+ headers,+ method,+ name,+ params,+ preRequestScript,+ testScript,+ }) => ({+ v,+ auth,+ body,+ endpoint,+ headers,+ method,+ name,+ params,+ preRequestScript,+ testScript,+ })+ ),+ }+ } else {+ const gqlCollection = collection as ExportedUserCollectionGQL++ return {+ v: 1,+ name: gqlCollection.name,+ folders: gqlCollection.folders.map((folder) =>+ exportedCollectionToHoppCollection(folder, collectionType)+ ),+ requests: gqlCollection.requests.map(({ v, auth, headers, name }) => ({+ v,+ auth,+ headers,+ name,+ })) as HoppGQLRequest[],+ }+ }+}++function addMapperEntriesForExportedCollection(+ collection: ExportedUserCollectionREST | ExportedUserCollectionGQL,+ localPath: string,+ collectionType: "REST" | "GQL"+) {+ const { collectionsMapper, requestsMapper } =+ getMappersAndStoreByType(collectionType)++ if (collection.id) {+ collectionsMapper.addEntry(localPath, collection.id)++ collection.folders.forEach((folder, index) => {+ addMapperEntriesForExportedCollection(+ folder,+ `${localPath}/${index}`,+ collectionType+ )+ })++ collection.requests.forEach((request, index) => {+ const requestID = request.id++ requestID && requestsMapper.addEntry(`${localPath}/${index}`, requestID)+ })+ }+}++async function loadUserRootCollections(collectionType: "REST" | "GQL") {+ const res = await exportUserCollectionsToJSON(+ undefined,+ collectionType == "REST" ? ReqType.Rest : ReqType.Gql+ )++ if (E.isRight(res)) {+ const collectionsJSONString =+ res.right.exportUserCollectionsToJSON.exportedCollection+ const exportedCollections = (+ JSON.parse(collectionsJSONString) as Array<+ ExportedUserCollectionGQL | ExportedUserCollectionREST+ >+ ).map((collection) => ({ v: 1, ...collection }))++ runDispatchWithOutSyncing(() => {+ collectionType == "REST"+ ? setRESTCollections(+ exportedCollections.map(+ (collection) =>+ exportedCollectionToHoppCollection(+ collection,+ "REST"+ ) as HoppCollection<HoppRESTRequest>+ )+ )+ : setGraphqlCollections(+ exportedCollections.map(+ (collection) =>+ exportedCollectionToHoppCollection(+ collection,+ "GQL"+ ) as HoppCollection<HoppGQLRequest>+ )+ )++ exportedCollections.forEach((collection, index) =>+ addMapperEntriesForExportedCollection(+ collection,+ `${index}`,+ collectionType+ )+ )+ })+ }+}++function setupSubscriptions() {+ let subs: ReturnType<typeof runGQLSubscription>[1][] = []++ const userCollectionCreatedSub = setupUserCollectionCreatedSubscription()+ const userCollectionUpdatedSub = setupUserCollectionUpdatedSubscription()+ const userCollectionRemovedSub = setupUserCollectionRemovedSubscription()+ const userCollectionMovedSub = setupUserCollectionMovedSubscription()+ const userCollectionOrderUpdatedSub =+ setupUserCollectionOrderUpdatedSubscription()+ const userRequestCreatedSub = setupUserRequestCreatedSubscription()+ const userRequestUpdatedSub = setupUserRequestUpdatedSubscription()+ const userRequestDeletedSub = setupUserRequestDeletedSubscription()+ const userRequestMovedSub = setupUserRequestMovedSubscription()++ subs = [+ userCollectionCreatedSub,+ userCollectionUpdatedSub,+ userCollectionRemovedSub,+ userCollectionMovedSub,+ userCollectionOrderUpdatedSub,+ userRequestCreatedSub,+ userRequestUpdatedSub,+ userRequestDeletedSub,+ userRequestMovedSub,+ ]++ return () => {+ subs.forEach((sub) => sub.unsubscribe())+ }+}++function setupUserCollectionCreatedSubscription() {+ const [userCollectionCreated$, userCollectionCreatedSub] =+ runUserCollectionCreatedSubscription()++ userCollectionCreated$.subscribe((res) => {+ if (E.isRight(res)) {+ const collectionType = res.right.userCollectionCreated.type++ const { collectionsMapper, collectionStore } =+ getMappersAndStoreByType(collectionType)++ const userCollectionBackendID = res.right.userCollectionCreated.id+ const parentCollectionID = res.right.userCollectionCreated.parent?.id++ const userCollectionLocalID = collectionsMapper.getLocalIDByBackendID(+ userCollectionBackendID+ )++ // collection already exists in store ( this instance created it )+ if (userCollectionLocalID) {+ return+ }++ const parentCollectionPath =+ parentCollectionID &&+ collectionsMapper.getLocalIDByBackendID(parentCollectionID)++ // only folders will have parent collection id+ if (parentCollectionID && parentCollectionPath) {+ runDispatchWithOutSyncing(() => {+ collectionType == "GQL"+ ? addGraphqlFolder(+ res.right.userCollectionCreated.title,+ parentCollectionPath+ )+ : addRESTFolder(+ res.right.userCollectionCreated.title,+ parentCollectionPath+ )++ const parentCollection = navigateToFolderWithIndexPath(+ collectionStore.value.state,+ parentCollectionPath+ .split("/")+ .map((pathIndex) => parseInt(pathIndex))+ )++ if (parentCollection) {+ const folderIndex = parentCollection.folders.length - 1+ collectionsMapper.addEntry(+ `${parentCollectionPath}/${folderIndex}`,+ userCollectionBackendID+ )+ }+ })+ } else {+ // root collections won't have parentCollectionID+ runDispatchWithOutSyncing(() => {+ collectionType == "GQL"+ ? addGraphqlCollection({+ name: res.right.userCollectionCreated.title,+ folders: [],+ requests: [],+ v: 1,+ })+ : addRESTCollection({+ name: res.right.userCollectionCreated.title,+ folders: [],+ requests: [],+ v: 1,+ })++ const localIndex = collectionStore.value.state.length - 1+ collectionsMapper.addEntry(`${localIndex}`, userCollectionBackendID)+ })+ }+ }+ })++ return userCollectionCreatedSub+}++function setupUserCollectionUpdatedSubscription() {+ const [userCollectionUpdated$, userCollectionUpdatedSub] =+ runUserCollectionUpdatedSubscription()++ userCollectionUpdated$.subscribe((res) => {+ if (E.isRight(res)) {+ const collectionType = res.right.userCollectionUpdated.type++ const { collectionsMapper } = getMappersAndStoreByType(collectionType)++ const updatedCollectionBackendID = res.right.userCollectionUpdated.id+ const updatedCollectionLocalPath =+ collectionsMapper.getLocalIDByBackendID(updatedCollectionBackendID)++ const isFolder =+ updatedCollectionLocalPath &&+ updatedCollectionLocalPath.split("/").length > 1++ // updated collection is a folder+ if (isFolder) {+ runDispatchWithOutSyncing(() => {+ collectionType == "REST"+ ? editRESTFolder(updatedCollectionLocalPath, {+ name: res.right.userCollectionUpdated.title,+ })+ : editGraphqlFolder(updatedCollectionLocalPath, {+ name: res.right.userCollectionUpdated.title,+ })+ })+ }++ // updated collection is a root collection+ if (updatedCollectionLocalPath && !isFolder) {+ runDispatchWithOutSyncing(() => {+ collectionType == "REST"+ ? editRESTCollection(parseInt(updatedCollectionLocalPath), {+ name: res.right.userCollectionUpdated.title,+ })+ : editGraphqlCollection(parseInt(updatedCollectionLocalPath), {+ name: res.right.userCollectionUpdated.title,+ })+ })+ }+ }+ })++ return userCollectionUpdatedSub+}++function setupUserCollectionMovedSubscription() {+ const [userCollectionMoved$, userCollectionMovedSub] =+ runUserCollectionMovedSubscription()++ userCollectionMoved$.subscribe((res) => {+ if (E.isRight(res)) {+ const movedMetadata = res.right.userCollectionMoved++ const sourcePath = restCollectionsMapper.getLocalIDByBackendID(+ movedMetadata.id+ )++ let destinationPath: string | undefined++ if (movedMetadata.parent?.id) {+ destinationPath = restCollectionsMapper.getLocalIDByBackendID(+ movedMetadata.parent?.id+ )+ }++ const hasAlreadyHappened = hasReorderingOrMovingAlreadyHappened(+ {+ sourceCollectionID: movedMetadata.id,+ destinationCollectionID: movedMetadata.parent?.id,+ sourcePath,+ destinationPath,+ },+ "MOVING"+ )++ if (!hasAlreadyHappened) {+ sourcePath &&+ runDispatchWithOutSyncing(() => {+ moveRESTFolder(sourcePath, destinationPath ?? null)+ })++ sourcePath &&+ moveCollectionInMapper(sourcePath, destinationPath, "REST")+ }+ }+ })++ return userCollectionMovedSub+}++function setupUserCollectionRemovedSubscription() {+ const [userCollectionRemoved$, userCollectionRemovedSub] =+ runUserCollectionRemovedSubscription()++ userCollectionRemoved$.subscribe((res) => {+ if (E.isRight(res)) {+ const removedCollectionBackendID = res.right.userCollectionRemoved.id+ const collectionType = res.right.userCollectionRemoved.type++ const { collectionsMapper } = getMappersAndStoreByType(collectionType)++ const collectionsOperations =+ collectionType == "REST"+ ? restCollectionsOperations+ : gqlCollectionsOperations++ const removedCollectionLocalPath =+ collectionsMapper.getLocalIDByBackendID(removedCollectionBackendID)++ // TODO: seperate operations for rest and gql+ const isInOperations = !!collectionsOperations.find(+ (operation) =>+ operation.type == "COLLECTION_REMOVED" &&+ operation.collectionBackendID == removedCollectionBackendID+ )++ // the collection is already removed+ if (!removedCollectionLocalPath || isInOperations) {+ return+ }++ const isFolder =+ removedCollectionLocalPath &&+ removedCollectionLocalPath.split("/").length > 1++ if (removedCollectionLocalPath && isFolder) {+ runDispatchWithOutSyncing(() => {+ collectionType == "REST"+ ? removeRESTFolder(removedCollectionLocalPath)+ : removeGraphqlFolder(removedCollectionLocalPath)+ })+ }++ if (removedCollectionLocalPath && !isFolder) {+ runDispatchWithOutSyncing(() => {+ collectionType == "REST"+ ? removeRESTCollection(parseInt(removedCollectionLocalPath))+ : removeGraphqlCollection(parseInt(removedCollectionLocalPath))+ })+ }++ removedCollectionLocalPath &&+ removeAndReorderEntries(removedCollectionLocalPath, collectionType)+ }+ })++ return userCollectionRemovedSub+}++function setupUserCollectionOrderUpdatedSubscription() {+ const [userCollectionOrderUpdated$, userCollectionOrderUpdatedSub] =+ runUserCollectionOrderUpdatedSubscription()++ userCollectionOrderUpdated$.subscribe((res) => {+ if (E.isRight(res)) {+ const { userCollection, nextUserCollection } =+ res.right.userCollectionOrderUpdated++ const sourceCollectionID = userCollection.id+ const destinationCollectionID = nextUserCollection?.id++ const sourcePath =+ restCollectionsMapper.getLocalIDByBackendID(sourceCollectionID)++ let destinationPath: string | undefined++ if (destinationCollectionID) {+ destinationPath = restCollectionsMapper.getLocalIDByBackendID(+ destinationCollectionID+ )+ }++ const hasAlreadyHappened = hasReorderingOrMovingAlreadyHappened(+ {+ sourceCollectionID,+ destinationCollectionID,+ sourcePath,+ destinationPath,+ },+ "REORDERING"+ )++ if (!hasAlreadyHappened) {+ runDispatchWithOutSyncing(() => {+ if (+ sourcePath &&+ destinationPath &&+ sourceCollectionID &&+ destinationCollectionID+ ) {+ updateRESTCollectionOrder(sourcePath, destinationPath)+ reorderCollectionsInMapper(sourcePath, destinationPath, "REST")+ }+ })+ }+ }+ })++ return userCollectionOrderUpdatedSub+}++function setupUserRequestCreatedSubscription() {+ const [userRequestCreated$, userRequestCreatedSub] =+ runUserRequestCreatedSubscription()++ userRequestCreated$.subscribe((res) => {+ if (E.isRight(res)) {+ const collectionID = res.right.userRequestCreated.collectionID+ const request = JSON.parse(res.right.userRequestCreated.request)+ const requestID = res.right.userRequestCreated.id++ const requestType = res.right.userRequestCreated.type++ const { collectionsMapper, requestsMapper, collectionStore } =+ getMappersAndStoreByType(requestType)++ const hasAlreadyHappened =+ !!requestsMapper.getLocalIDByBackendID(requestID)++ if (hasAlreadyHappened) {+ return+ }++ const collectionPath =+ collectionsMapper.getLocalIDByBackendID(collectionID)++ if (collectionID && collectionPath) {+ runDispatchWithOutSyncing(() => {+ requestType == "REST"+ ? saveRESTRequestAs(collectionPath, request)+ : saveGraphqlRequestAs(collectionPath, request)++ const target = navigateToFolderWithIndexPath(+ collectionStore.value.state,+ collectionPath.split("/").map((index) => parseInt(index))+ )++ const requestPath =+ target && `${collectionPath}/${target?.requests.length - 1}`++ requestPath && requestsMapper.addEntry(requestPath, requestID)+ })+ }+ }+ })++ return userRequestCreatedSub+}++function setupUserRequestUpdatedSubscription() {+ const [userRequestUpdated$, userRequestUpdatedSub] =+ runUserRequestUpdatedSubscription()++ userRequestUpdated$.subscribe((res) => {+ if (E.isRight(res)) {+ const requestType = res.right.userRequestUpdated.type++ const { requestsMapper, collectionsMapper } =+ getMappersAndStoreByType(requestType)++ const requestPath = requestsMapper.getLocalIDByBackendID(+ res.right.userRequestUpdated.id+ )++ const indexes = requestPath?.split("/")+ const requestIndex = indexes && indexes[indexes?.length - 1]+ const requestParentPath = collectionsMapper.getLocalIDByBackendID(+ res.right.userRequestUpdated.collectionID+ )++ requestIndex &&+ requestParentPath &&+ runDispatchWithOutSyncing(() => {+ requestType == "REST"+ ? editRESTRequest(+ requestParentPath,+ parseInt(requestIndex),+ JSON.parse(res.right.userRequestUpdated.request)+ )+ : editGraphqlRequest(+ requestParentPath,+ parseInt(requestIndex),+ JSON.parse(res.right.userRequestUpdated.request)+ )+ })+ }+ })++ return userRequestUpdatedSub+}++function setupUserRequestMovedSubscription() {+ const [userRequestMoved$, userRequestMovedSub] =+ runUserRequestMovedSubscription()++ userRequestMoved$.subscribe((res) => {+ if (E.isRight(res)) {+ const requestType = res.right.userRequestMoved.request.type++ const { collectionsMapper } = getMappersAndStoreByType(requestType)++ const requestID = res.right.userRequestMoved.request.id+ const requestIndex = getRequestIndexFromRequestID(requestID)++ const sourceCollectionPath = getCollectionPathFromRequestID(requestID)++ const destinationCollectionID =+ res.right.userRequestMoved.request.collectionID+ const destinationCollectionPath = collectionsMapper.getLocalIDByBackendID(+ destinationCollectionID+ )++ const nextRequest = res.right.userRequestMoved.nextRequest++ // there is no nextRequest, so request is moved+ if (+ requestIndex &&+ sourceCollectionPath &&+ destinationCollectionPath &&+ !nextRequest+ ) {+ runDispatchWithOutSyncing(() => {+ requestType == "REST"+ ? moveRESTRequest(+ sourceCollectionPath,+ parseInt(requestIndex),+ destinationCollectionPath+ )+ : moveGraphqlRequest(+ sourceCollectionPath,+ parseInt(requestIndex),+ destinationCollectionPath+ )+ })+ }++ // there is nextRequest, so request is reordered+ if (+ requestIndex &&+ sourceCollectionPath &&+ destinationCollectionPath &&+ nextRequest &&+ // we don't have request reordering for graphql yet+ requestType == "REST"+ ) {+ const nextRequestIndex = getRequestIndexFromRequestID(nextRequest.id)++ nextRequestIndex &&+ runDispatchWithOutSyncing(() => {+ updateRESTRequestOrder(+ parseInt(requestIndex),+ parseInt(nextRequestIndex),+ destinationCollectionPath+ )+ })+ }+ }+ })++ return userRequestMovedSub+}++function setupUserRequestDeletedSubscription() {+ const [userRequestDeleted$, userRequestDeletedSub] =+ runUserRequestDeletedSubscription()++ userRequestDeleted$.subscribe((res) => {+ if (E.isRight(res)) {+ const requestType = res.right.userRequestDeleted.type++ const { requestsMapper, collectionsMapper } =+ getMappersAndStoreByType(requestType)++ const deletedRequestPath = requestsMapper.getLocalIDByBackendID(+ res.right.userRequestDeleted.id+ )++ const indexes = deletedRequestPath?.split("/")+ const requestIndex = indexes && indexes[indexes?.length - 1]+ const requestParentPath = collectionsMapper.getLocalIDByBackendID(+ res.right.userRequestDeleted.collectionID+ )++ requestIndex &&+ requestParentPath &&+ runDispatchWithOutSyncing(() => {+ requestType == "REST"+ ? removeRESTRequest(requestParentPath, parseInt(requestIndex))+ : removeGraphqlRequest(requestParentPath, parseInt(requestIndex))+ })++ deletedRequestPath &&+ reorderIndexesAfterEntryRemoval(+ deletedRequestPath,+ requestsMapper,+ requestType+ )+ }+ })++ return userRequestDeletedSub+}++export const def: CollectionsPlatformDef = {+ initCollectionsSync,+}++function getRequestIndexFromRequestID(requestID: string) {+ const requestPath = restRequestsMapper.getLocalIDByBackendID(requestID)++ /**+ * requestPath is in the form collectionPath/requestIndex,+ * so to get requestIndex we just split the requestPath with / and get the last element+ */+ const requestPathIndexes = requestPath?.split("/")+ const requestIndex =+ requestPathIndexes && requestPathIndexes[requestPathIndexes?.length - 1]++ return requestIndex+}++function getCollectionPathFromRequestID(requestID: string) {+ const requestPath = restRequestsMapper.getLocalIDByBackendID(requestID)+ const requestPathIndexes = requestPath?.split("/")++ // requestIndex will be the last element, remove it+ requestPathIndexes?.pop()++ return requestPathIndexes?.join("/")+}++function hasReorderingOrMovingAlreadyHappened(+ incomingOperation: {+ sourceCollectionID: string+ destinationCollectionID: string | undefined+ sourcePath: string | undefined+ destinationPath: string | undefined+ },+ type: "REORDERING" | "MOVING"+) {+ const {+ sourcePath,+ sourceCollectionID,+ destinationCollectionID,+ destinationPath,+ } = incomingOperation++ // TODO: implement this as a module+ // Something like, SyncOperations.hasAlreadyHappened( type: "REORDER_COLLECTIONS", payload )+ return !!collectionReorderOrMovingOperations.find((reorderOperation) =>+ reorderOperation.sourceCollectionID == sourceCollectionID &&+ reorderOperation.destinationCollectionID == destinationCollectionID &&+ type == "MOVING"+ ? reorderOperation.reorderOperation.fromPath == destinationPath+ : reorderOperation.reorderOperation.fromPath == sourcePath &&+ type == "MOVING"+ ? reorderOperation.reorderOperation.toPath == sourcePath+ : reorderOperation.reorderOperation.toPath == destinationPath+ )+}diff --git a/packages/hoppscotch-selfhost-web/src/platform/collections/collections.sync.ts b/packages/hoppscotch-selfhost-web/src/platform/collections/collections.sync.tsnew file mode 100644index 000000000..321a91bcb--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/platform/collections/collections.sync.ts@@ -0,0 +1,462 @@+import {+ navigateToFolderWithIndexPath,+ removeGraphqlCollection,+ removeRESTCollection,+ removeRESTRequest,+ restCollectionStore,+} from "@hoppscotch/common/newstore/collections"+import {+ getSettingSubject,+ settingsStore,+} from "@hoppscotch/common/newstore/settings"++import { HoppCollection, HoppRESTRequest } from "@hoppscotch/data"++import { getSyncInitFunction, runDispatchWithOutSyncing } from "../../lib/sync"++import { StoreSyncDefinitionOf } from "../../lib/sync"+import { createMapper } from "../../lib/sync/mapper"+import {+ createRESTChildUserCollection,+ createRESTRootUserCollection,+ createRESTUserRequest,+ deleteUserCollection,+ deleteUserRequest,+ editUserRequest,+ moveUserCollection,+ moveUserRequest,+ renameUserCollection,+ updateUserCollectionOrder,+} from "./collections.api"++import * as E from "fp-ts/Either"+import {+ removeAndReorderEntries,+ moveCollectionInMapper,+ reorderIndexesAfterEntryRemoval,+ reorderCollectionsInMapper,+ reorderRequestsMapper,+ moveRequestInMapper,+} from "./collections.mapper"+import { gqlCollectionsMapper } from "./gqlCollections.sync"++// restCollectionsMapper uses the collectionPath as the local identifier+export const restCollectionsMapper = createMapper<string, string>()++// restRequestsMapper uses the collectionPath/requestIndex as the local identifier+export const restRequestsMapper = createMapper<string, string>()++// temp implementation untill the backend implements an endpoint that accepts an entire collection+// TODO: use importCollectionsJSON to do this+const recursivelySyncCollections = async (+ collection: HoppCollection<HoppRESTRequest>,+ collectionPath: string,+ parentUserCollectionID?: string+) => {+ let parentCollectionID = parentUserCollectionID++ // if parentUserCollectionID does not exist, create the collection as a root collection+ if (!parentUserCollectionID) {+ const res = await createRESTRootUserCollection(collection.name)++ if (E.isRight(res)) {+ parentCollectionID = res.right.createRESTRootUserCollection.id+ restCollectionsMapper.addEntry(collectionPath, parentCollectionID)+ } else {+ parentCollectionID = undefined+ }+ } else {+ // if parentUserCollectionID exists, create the collection as a child collection+ const res = await createRESTChildUserCollection(+ collection.name,+ parentUserCollectionID+ )++ if (E.isRight(res)) {+ const childCollectionId = res.right.createRESTChildUserCollection.id+ restCollectionsMapper.addEntry(collectionPath, childCollectionId)+ }+ }++ // create the requests+ if (parentCollectionID) {+ collection.requests.forEach(async (request, index) => {+ const res =+ parentCollectionID &&+ (await createRESTUserRequest(+ request.name,+ JSON.stringify(request),+ parentCollectionID+ ))++ if (res && E.isRight(res)) {+ const requestId = res.right.createRESTUserRequest.id+ restRequestsMapper.addEntry(`${collectionPath}/${index}`, requestId)+ }+ })+ }++ // create the folders aka child collections+ if (parentCollectionID)+ collection.folders.forEach(async (folder, index) => {+ recursivelySyncCollections(+ folder,+ `${collectionPath}/${index}`,+ parentCollectionID+ )+ })+}++// TODO: generalize this+// TODO: ask backend to send enough info on the subscription to not need this+export const collectionReorderOrMovingOperations: {+ sourceCollectionID: string+ destinationCollectionID?: string+ reorderOperation: {+ fromPath: string+ toPath?: string+ }+}[] = []++type OperationStatus = "pending" | "completed"++type OperationCollectionRemoved = {+ type: "COLLECTION_REMOVED"+ collectionBackendID: string+ status: OperationStatus+}++export const restCollectionsOperations: Array<OperationCollectionRemoved> = []++export const storeSyncDefinition: StoreSyncDefinitionOf<+ typeof restCollectionStore+> = {+ appendCollections({ entries }) {+ let indexStart = restCollectionStore.value.state.length - entries.length++ entries.forEach((collection) => {+ recursivelySyncCollections(collection, `${indexStart}`)+ indexStart+++ })+ },+ async addCollection({ collection }) {+ const lastCreatedCollectionIndex =+ restCollectionStore.value.state.length - 1++ await recursivelySyncCollections(+ collection,+ `${lastCreatedCollectionIndex}`+ )++ removeDuplicateCollectionsFromStore("REST")+ },+ async removeCollection({ collectionIndex }) {+ const backendIdentifier = restCollectionsMapper.getBackendIDByLocalID(+ `${collectionIndex}`+ )++ if (backendIdentifier) {+ restCollectionsOperations.push({+ collectionBackendID: backendIdentifier,+ type: "COLLECTION_REMOVED",+ status: "pending",+ })+ await deleteUserCollection(backendIdentifier)+ removeAndReorderEntries(`${collectionIndex}`, "REST")+ }+ },+ editCollection({ partialCollection: collection, collectionIndex }) {+ const backendIdentifier = restCollectionsMapper.getBackendIDByLocalID(+ `${collectionIndex}`+ )++ if (backendIdentifier && collection.name) {+ renameUserCollection(backendIdentifier, collection.name)+ }+ },+ async addFolder({ name, path }) {+ const parentCollectionBackendID =+ restCollectionsMapper.getBackendIDByLocalID(path)++ if (parentCollectionBackendID) {+ // TODO: remove this replaceAll thing when updating the mapper+ const res = await createRESTChildUserCollection(+ name,+ parentCollectionBackendID+ )++ // after the folder is created add the path of the folder with its backend id to the mapper+ if (E.isRight(res)) {+ const folderBackendID = res.right.createRESTChildUserCollection.id+ const parentCollection = navigateToFolderWithIndexPath(+ restCollectionStore.value.state,+ path.split("/").map((index) => parseInt(index))+ )++ if (parentCollection && parentCollection.folders.length > 0) {+ const folderIndex = parentCollection.folders.length - 1+ restCollectionsMapper.addEntry(+ `${path}/${folderIndex}`,+ folderBackendID+ )+ }+ }+ }+ },+ editFolder({ folder, path }) {+ const folderBackendId = restCollectionsMapper.getBackendIDByLocalID(+ `${path}`+ )++ const folderName = folder.name++ if (folderBackendId && folderName) {+ renameUserCollection(folderBackendId, folderName)+ }+ },+ async removeFolder({ path }) {+ const folderBackendId = restCollectionsMapper.getBackendIDByLocalID(+ `${path}`+ )++ if (folderBackendId) {+ await deleteUserCollection(folderBackendId)+ removeAndReorderEntries(path, "REST")+ }+ },+ async moveFolder({ destinationPath, path }) {+ const sourceCollectionBackendID =+ restCollectionsMapper.getBackendIDByLocalID(path)++ const destinationCollectionBackendID = destinationPath+ ? restCollectionsMapper.getBackendIDByLocalID(destinationPath)+ : undefined++ if (sourceCollectionBackendID) {+ await moveUserCollection(+ sourceCollectionBackendID,+ destinationCollectionBackendID+ )++ moveCollectionInMapper(path, destinationPath ?? undefined, "REST")+ }+ },+ editRequest({ path, requestIndex, requestNew }) {+ const requestPath = `${path}/${requestIndex}`++ const requestBackendID =+ restRequestsMapper.getBackendIDByLocalID(requestPath)++ if (requestBackendID) {+ editUserRequest(+ requestBackendID,+ (requestNew as HoppRESTRequest).name,+ JSON.stringify(requestNew)+ )+ }+ },+ async saveRequestAs({ path, request }) {+ const parentCollectionBackendID =+ restCollectionsMapper.getBackendIDByLocalID(path)++ if (parentCollectionBackendID) {+ const res = await createRESTUserRequest(+ (request as HoppRESTRequest).name,+ JSON.stringify(request),+ parentCollectionBackendID+ )++ const existingPath =+ E.isRight(res) &&+ restRequestsMapper.getLocalIDByBackendID(+ res.right.createRESTUserRequest.id+ )++ // remove the request if it is already existing ( can happen when the subscription fired before the mutation is resolved )+ if (existingPath) {+ const indexes = existingPath.split("/")+ const existingRequestIndex = indexes.pop()+ const existingRequestParentPath = indexes.join("/")++ runDispatchWithOutSyncing(() => {+ existingRequestIndex &&+ removeRESTRequest(+ existingRequestParentPath,+ parseInt(existingRequestIndex)+ )+ })+ }++ const parentCollection = navigateToFolderWithIndexPath(+ restCollectionStore.value.state,+ path.split("/").map((index) => parseInt(index))+ )++ if (parentCollection) {+ const lastCreatedRequestIndex = parentCollection.requests.length - 1++ if (E.isRight(res)) {+ restRequestsMapper.addEntry(+ `${path}/${lastCreatedRequestIndex}`,+ res.right.createRESTUserRequest.id+ )+ }+ }+ }+ },+ async removeRequest({ path, requestIndex }) {+ const requestPath = `${path}/${requestIndex}`+ const requestBackendID =+ restRequestsMapper.getBackendIDByLocalID(requestPath)++ if (requestBackendID) {+ await deleteUserRequest(requestBackendID)+ restRequestsMapper.removeEntry(requestPath)+ reorderIndexesAfterEntryRemoval(path, restRequestsMapper, "REST")+ }+ },+ moveRequest({ destinationPath, path, requestIndex }) {+ moveOrReorderRequests(requestIndex, path, destinationPath)+ },+ updateRequestOrder({+ destinationCollectionPath,+ destinationRequestIndex,+ requestIndex,+ }) {+ /**+ * currently the FE implementation only supports reordering requests between the same collection,+ * so destinationCollectionPath and sourceCollectionPath will be same+ */+ moveOrReorderRequests(+ requestIndex,+ destinationCollectionPath,+ destinationCollectionPath,+ destinationRequestIndex+ )+ },+ async updateCollectionOrder({+ collectionIndex: collectionPath,+ destinationCollectionIndex: destinationCollectionPath,+ }) {+ const sourceBackendID =+ restCollectionsMapper.getBackendIDByLocalID(collectionPath)++ const destinationBackendID = restCollectionsMapper.getBackendIDByLocalID(+ destinationCollectionPath+ )++ if (sourceBackendID) {+ collectionReorderOrMovingOperations.push({+ sourceCollectionID: sourceBackendID,+ destinationCollectionID: destinationBackendID,+ reorderOperation: {+ fromPath: `${parseInt(destinationCollectionPath) - 1}`,+ toPath: destinationCollectionPath,+ },+ })++ await updateUserCollectionOrder(sourceBackendID, destinationBackendID)++ const currentSourcePath =+ restCollectionsMapper.getLocalIDByBackendID(sourceBackendID)++ const hasAlreadyHappened = !!(+ currentSourcePath == `${parseInt(destinationCollectionPath) - 1}`+ )++ if (!hasAlreadyHappened) {+ reorderCollectionsInMapper(+ collectionPath,+ destinationCollectionPath,+ "REST"+ )+ }+ }+ },+}++export const collectionsSyncer = getSyncInitFunction(+ restCollectionStore,+ storeSyncDefinition,+ () => settingsStore.value.syncCollections,+ getSettingSubject("syncCollections")+)++async function moveOrReorderRequests(+ requestIndex: number,+ path: string,+ destinationPath: string,+ nextRequestIndex?: number+) {+ const sourceCollectionBackendID =+ restCollectionsMapper.getBackendIDByLocalID(path)+ const destinationCollectionBackendID =+ restCollectionsMapper.getBackendIDByLocalID(destinationPath)++ const requestBackendID = restRequestsMapper.getBackendIDByLocalID(+ `${path}/${requestIndex}`+ )++ let nextRequestBackendID: string | undefined++ // we only need this for reordering requests, not for moving requests+ if (nextRequestIndex) {+ nextRequestBackendID = restRequestsMapper.getBackendIDByLocalID(+ `${destinationPath}/${nextRequestIndex}`+ )+ }++ if (+ sourceCollectionBackendID &&+ destinationCollectionBackendID &&+ requestBackendID+ ) {+ await moveUserRequest(+ sourceCollectionBackendID,+ destinationCollectionBackendID,+ requestBackendID,+ nextRequestBackendID+ )++ if (nextRequestBackendID && nextRequestIndex) {+ reorderRequestsMapper(requestIndex, path, nextRequestIndex, "REST")+ } else {+ moveRequestInMapper(requestIndex, path, destinationPath, "REST")+ }+ }+}++export function removeDuplicateCollectionsFromStore(+ collectionType: "REST" | "GQL"+) {+ const collectionsMapper =+ collectionType === "REST" ? restCollectionsMapper : gqlCollectionsMapper++ const mapperEntries = Array.from(collectionsMapper.getValue().entries())++ const seenBackendIDs = new Set<string>()++ const localIDsToRemove = new Set<string>()++ mapperEntries.forEach(([localID, backendID]) => {+ if (backendID && seenBackendIDs.has(backendID)) {+ localIDsToRemove.add(localID)+ } else {+ backendID && seenBackendIDs.add(backendID)+ }+ })++ localIDsToRemove.forEach((localID) => {+ collectionType === "REST"+ ? removeRESTCollection(parseInt(localID))+ : removeGraphqlCollection(parseInt(localID))++ collectionsMapper.removeEntry(undefined, localID)++ const indexes = localID.split("/")+ indexes.pop()+ const parentPath = indexes.join("/")++ reorderIndexesAfterEntryRemoval(parentPath, collectionsMapper, "REST")+ })+}diff --git a/packages/hoppscotch-selfhost-web/src/platform/collections/gqlCollections.sync.ts b/packages/hoppscotch-selfhost-web/src/platform/collections/gqlCollections.sync.tsnew file mode 100644index 000000000..99a37867b--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/platform/collections/gqlCollections.sync.ts@@ -0,0 +1,347 @@+import {+ graphqlCollectionStore,+ navigateToFolderWithIndexPath,+ removeGraphqlRequest,+} from "@hoppscotch/common/newstore/collections"+import {+ getSettingSubject,+ settingsStore,+} from "@hoppscotch/common/newstore/settings"++import { HoppCollection, HoppRESTRequest } from "@hoppscotch/data"++import { getSyncInitFunction, runDispatchWithOutSyncing } from "../../lib/sync"++import { StoreSyncDefinitionOf } from "../../lib/sync"+import { createMapper } from "../../lib/sync/mapper"+import {+ createGQLChildUserCollection,+ createGQLRootUserCollection,+ createGQLUserRequest,+ deleteUserCollection,+ deleteUserRequest,+ editGQLUserRequest,+ moveUserRequest,+ renameUserCollection,+} from "./collections.api"++import * as E from "fp-ts/Either"+import {+ moveRequestInMapper,+ removeAndReorderEntries,+ reorderIndexesAfterEntryRemoval,+ reorderRequestsMapper,+} from "./collections.mapper"+import { removeDuplicateCollectionsFromStore } from "./collections.sync"++// gqlCollectionsMapper uses the collectionPath as the local identifier+export const gqlCollectionsMapper = createMapper<string, string>()++// gqlRequestsMapper uses the collectionPath/requestIndex as the local identifier+export const gqlRequestsMapper = createMapper<string, string>()++// temp implementation untill the backend implements an endpoint that accepts an entire collection+// TODO: use importCollectionsJSON to do this+const recursivelySyncCollections = async (+ collection: HoppCollection<HoppRESTRequest>,+ collectionPath: string,+ parentUserCollectionID?: string+) => {+ let parentCollectionID = parentUserCollectionID++ // if parentUserCollectionID does not exist, create the collection as a root collection+ if (!parentUserCollectionID) {+ const res = await createGQLRootUserCollection(collection.name)++ if (E.isRight(res)) {+ parentCollectionID = res.right.createGQLRootUserCollection.id+ gqlCollectionsMapper.addEntry(collectionPath, parentCollectionID)+ } else {+ parentCollectionID = undefined+ }+ } else {+ // if parentUserCollectionID exists, create the collection as a child collection+ const res = await createGQLChildUserCollection(+ collection.name,+ parentUserCollectionID+ )++ if (E.isRight(res)) {+ const childCollectionId = res.right.createGQLChildUserCollection.id+ gqlCollectionsMapper.addEntry(collectionPath, childCollectionId)+ }+ }++ // create the requests+ if (parentCollectionID) {+ collection.requests.forEach(async (request, index) => {+ const res =+ parentCollectionID &&+ (await createGQLUserRequest(+ request.name,+ JSON.stringify(request),+ parentCollectionID+ ))++ if (res && E.isRight(res)) {+ const requestId = res.right.createGQLUserRequest.id+ gqlRequestsMapper.addEntry(`${collectionPath}/${index}`, requestId)+ }+ })+ }++ // create the folders aka child collections+ if (parentCollectionID)+ collection.folders.forEach(async (folder, index) => {+ recursivelySyncCollections(+ folder,+ `${collectionPath}/${index}`,+ parentCollectionID+ )+ })+}++// TODO: generalize this+// TODO: ask backend to send enough info on the subscription to not need this+export const collectionReorderOrMovingOperations: {+ sourceCollectionID: string+ destinationCollectionID?: string+ reorderOperation: {+ fromPath: string+ toPath?: string+ }+}[] = []++type OperationStatus = "pending" | "completed"++type OperationCollectionRemoved = {+ type: "COLLECTION_REMOVED"+ collectionBackendID: string+ status: OperationStatus+}++export const gqlCollectionsOperations: Array<OperationCollectionRemoved> = []++export const storeSyncDefinition: StoreSyncDefinitionOf<+ typeof graphqlCollectionStore+> = {+ appendCollections({ entries }) {+ let indexStart = graphqlCollectionStore.value.state.length - entries.length++ entries.forEach((collection) => {+ recursivelySyncCollections(collection, `${indexStart}`)+ indexStart+++ })+ },+ async addCollection({ collection }) {+ const lastCreatedCollectionIndex =+ graphqlCollectionStore.value.state.length - 1++ await recursivelySyncCollections(+ collection,+ `${lastCreatedCollectionIndex}`+ )++ removeDuplicateCollectionsFromStore("GQL")+ },+ async removeCollection({ collectionIndex }) {+ const backendIdentifier = gqlCollectionsMapper.getBackendIDByLocalID(+ `${collectionIndex}`+ )++ if (backendIdentifier) {+ gqlCollectionsOperations.push({+ collectionBackendID: backendIdentifier,+ type: "COLLECTION_REMOVED",+ status: "pending",+ })+ await deleteUserCollection(backendIdentifier)+ removeAndReorderEntries(`${collectionIndex}`, "GQL")+ }+ },+ editCollection({ collection, collectionIndex }) {+ const backendIdentifier = gqlCollectionsMapper.getBackendIDByLocalID(+ `${collectionIndex}`+ )++ if (backendIdentifier && collection.name) {+ renameUserCollection(backendIdentifier, collection.name)+ }+ },+ async addFolder({ name, path }) {+ const parentCollectionBackendID =+ gqlCollectionsMapper.getBackendIDByLocalID(path)++ if (parentCollectionBackendID) {+ // TODO: remove this replaceAll thing when updating the mapper+ const res = await createGQLChildUserCollection(+ name,+ parentCollectionBackendID+ )++ // after the folder is created add the path of the folder with its backend id to the mapper+ if (E.isRight(res)) {+ const folderBackendID = res.right.createGQLChildUserCollection.id+ const parentCollection = navigateToFolderWithIndexPath(+ graphqlCollectionStore.value.state,+ path.split("/").map((index) => parseInt(index))+ )++ if (parentCollection && parentCollection.folders.length > 0) {+ const folderIndex = parentCollection.folders.length - 1+ gqlCollectionsMapper.addEntry(+ `${path}/${folderIndex}`,+ folderBackendID+ )+ }+ }+ }+ },+ editFolder({ folder, path }) {+ const folderBackendId = gqlCollectionsMapper.getBackendIDByLocalID(+ `${path}`+ )++ if (folderBackendId) {+ renameUserCollection(folderBackendId, folder.name)+ }+ },+ async removeFolder({ path }) {+ const folderBackendId = gqlCollectionsMapper.getBackendIDByLocalID(+ `${path}`+ )++ if (folderBackendId) {+ await deleteUserCollection(folderBackendId)+ removeAndReorderEntries(path, "GQL")+ }+ },+ editRequest({ path, requestIndex, requestNew }) {+ const requestPath = `${path}/${requestIndex}`++ const requestBackendID =+ gqlRequestsMapper.getBackendIDByLocalID(requestPath)++ if (requestBackendID) {+ editGQLUserRequest(+ requestBackendID,+ (requestNew as HoppRESTRequest).name,+ JSON.stringify(requestNew)+ )+ }+ },+ async saveRequestAs({ path, request }) {+ const parentCollectionBackendID =+ gqlCollectionsMapper.getBackendIDByLocalID(path)++ if (parentCollectionBackendID) {+ const res = await createGQLUserRequest(+ (request as HoppRESTRequest).name,+ JSON.stringify(request),+ parentCollectionBackendID+ )++ const existingPath =+ E.isRight(res) &&+ gqlRequestsMapper.getLocalIDByBackendID(+ res.right.createGQLUserRequest.id+ )++ // remove the request if it is already existing ( can happen when the subscription fired before the mutation is resolved )+ if (existingPath) {+ const indexes = existingPath.split("/")+ const existingRequestIndex = indexes.pop()+ const existingRequestParentPath = indexes.join("/")++ runDispatchWithOutSyncing(() => {+ existingRequestIndex &&+ removeGraphqlRequest(+ existingRequestParentPath,+ parseInt(existingRequestIndex)+ )+ })+ }++ const parentCollection = navigateToFolderWithIndexPath(+ graphqlCollectionStore.value.state,+ path.split("/").map((index) => parseInt(index))+ )++ if (parentCollection) {+ const lastCreatedRequestIndex = parentCollection.requests.length - 1++ if (E.isRight(res)) {+ gqlRequestsMapper.addEntry(+ `${path}/${lastCreatedRequestIndex}`,+ res.right.createGQLUserRequest.id+ )+ }+ }+ }+ },+ async removeRequest({ path, requestIndex }) {+ const requestPath = `${path}/${requestIndex}`+ const requestBackendID =+ gqlRequestsMapper.getBackendIDByLocalID(requestPath)++ if (requestBackendID) {+ await deleteUserRequest(requestBackendID)+ gqlRequestsMapper.removeEntry(requestPath)+ reorderIndexesAfterEntryRemoval(path, gqlRequestsMapper, "GQL")+ }+ },+ moveRequest({ destinationPath, path, requestIndex }) {+ moveOrReorderRequests(requestIndex, path, destinationPath)+ },+}++export const gqlCollectionsSyncer = getSyncInitFunction(+ graphqlCollectionStore,+ storeSyncDefinition,+ () => settingsStore.value.syncCollections,+ getSettingSubject("syncCollections")+)++async function moveOrReorderRequests(+ requestIndex: number,+ path: string,+ destinationPath: string,+ nextRequestIndex?: number+) {+ const sourceCollectionBackendID =+ gqlCollectionsMapper.getBackendIDByLocalID(path)+ const destinationCollectionBackendID =+ gqlCollectionsMapper.getBackendIDByLocalID(destinationPath)++ const requestBackendID = gqlRequestsMapper.getBackendIDByLocalID(+ `${path}/${requestIndex}`+ )++ let nextRequestBackendID: string | undefined++ // we only need this for reordering requests, not for moving requests+ if (nextRequestIndex) {+ nextRequestBackendID = gqlRequestsMapper.getBackendIDByLocalID(+ `${destinationPath}/${nextRequestIndex}`+ )+ }++ if (+ sourceCollectionBackendID &&+ destinationCollectionBackendID &&+ requestBackendID+ ) {+ await moveUserRequest(+ sourceCollectionBackendID,+ destinationCollectionBackendID,+ requestBackendID,+ nextRequestBackendID+ )++ if (nextRequestBackendID && nextRequestIndex) {+ reorderRequestsMapper(requestIndex, path, nextRequestIndex, "GQL")+ } else {+ moveRequestInMapper(requestIndex, path, destinationPath, "GQL")+ }+ }+}diff --git a/packages/hoppscotch-selfhost-web/src/platform/environments/environments.platform.ts b/packages/hoppscotch-selfhost-web/src/platform/environments/environments.platform.tsindex 3258f1308..df5d29b38 100644--- a/packages/hoppscotch-selfhost-web/src/platform/environments/environments.platform.ts+++ b/packages/hoppscotch-selfhost-web/src/platform/environments/environments.platform.ts@@ -166,7 +166,7 @@ function setupUserEnvironmentUpdatedSubscription() {} else {// handle the case for normal environments- const localIndex = environmentsMapper.getIndexByBackendId(id)+ const localIndex = environmentsMapper.getLocalIDByBackendID(id)if (localIndex && name) {runDispatchWithOutSyncing(() => {@@ -197,7 +197,7 @@ function setupUserEnvironmentDeletedSubscription() {if (E.isRight(res)) {const { id } = res.right.userEnvironmentDeleted- const localIndex = environmentsMapper.getIndexByBackendId(id)+ const localIndex = environmentsMapper.getLocalIDByBackendID(id)if (localIndex) {runDispatchWithOutSyncing(() => {diff --git a/packages/hoppscotch-selfhost-web/src/platform/environments/environments.sync.ts b/packages/hoppscotch-selfhost-web/src/platform/environments/environments.sync.tsindex 32b80238b..8bc8db1c9 100644--- a/packages/hoppscotch-selfhost-web/src/platform/environments/environments.sync.ts+++ b/packages/hoppscotch-selfhost-web/src/platform/environments/environments.sync.ts@@ -17,8 +17,8 @@ import {updateUserEnvironment,} from "./environments.api"-export const environmentsMapper = createMapper()-export const globalEnvironmentMapper = createMapper()+export const environmentsMapper = createMapper<number, string>()+export const globalEnvironmentMapper = createMapper<number, string>()export const storeSyncDefinition: StoreSyncDefinitionOf<typeof environmentsStore@@ -73,7 +73,7 @@ export const storeSyncDefinition: StoreSyncDefinitionOf<}},updateEnvironment({ envIndex, updatedEnv }) {- const backendId = environmentsMapper.getBackendIdByIndex(envIndex)+ const backendId = environmentsMapper.getBackendIDByLocalID(envIndex)console.log(environmentsMapper)if (backendId) {@@ -81,7 +81,7 @@ export const storeSyncDefinition: StoreSyncDefinitionOf<}},async deleteEnvironment({ envIndex }) {- const backendId = environmentsMapper.getBackendIdByIndex(envIndex)+ const backendId = environmentsMapper.getBackendIDByLocalID(envIndex)if (backendId) {await deleteUserEnvironment(backendId)()@@ -89,14 +89,14 @@ export const storeSyncDefinition: StoreSyncDefinitionOf<}},setGlobalVariables({ entries }) {- const backendId = globalEnvironmentMapper.getBackendIdByIndex(0)+ const backendId = globalEnvironmentMapper.getBackendIDByLocalID(0)if (backendId) {updateUserEnvironment(backendId, { name: "", variables: entries })()}},clearGlobalVariables() {- const backendId = globalEnvironmentMapper.getBackendIdByIndex(0)+ const backendId = globalEnvironmentMapper.getBackendIDByLocalID(0)if (backendId) {clearGlobalEnvironmentVariables(backendId)diff --git a/packages/hoppscotch-selfhost-web/src/tests/collections.sync.spec.ts b/packages/hoppscotch-selfhost-web/src/tests/collections.sync.spec.tsnew file mode 100644index 000000000..5c75d45d8--- /dev/null+++ b/packages/hoppscotch-selfhost-web/src/tests/collections.sync.spec.ts@@ -0,0 +1,1516 @@+import { describe, it, beforeEach, expect } from "vitest"+import {+ changeParentForAllChildrenFromMapper,+ getChildrenEntriesFromMapper,+ getDirectChildrenEntriesFromMapper,+ moveCollectionInMapper,+ moveRequestInMapper,+ removeAllChildCollectionsFromMapper,+ removeAllChildRequestsFromMapper,+ removeAndReorderEntries,+ reorderCollectionsInMapper,+ reorderIndexesAfterEntryRemoval,+ reorderRequestsMapper,+} from "@platform/collections/collections.mapper"++import {+ restCollectionsMapper,+ restRequestsMapper,+} from "@platform/collections/collections.sync"+import { createMapper } from "@lib/sync/mapper"+import {+ addRESTCollection,+ // moveRESTFolder,+ setRESTCollections,+} from "@hoppscotch/common/newstore/collections"++import { HoppRESTRequest, makeCollection } from "@hoppscotch/data"++const getEntriesArrayFromMapper = (+ mapper: ReturnType<typeof createMapper<string, string>>+) => Array.from(mapper.getValue().entries())++describe("getChildrenEntriesFromMapper", () => {+ beforeEach(cleanUpAndSeedMappers)++ it("getChildrenEntriesFromMapper - get children of root collection", () => {+ const childrenCollections = getChildrenEntriesFromMapper(+ "0",+ restCollectionsMapper+ )++ const childrenRequests = getChildrenEntriesFromMapper(+ "0",+ restRequestsMapper+ )++ expect(childrenCollections).toMatchInlineSnapshot(`+ [+ [+ "0/0",+ "Folder 1",+ ],+ [+ "0/1",+ "Folder 2",+ ],+ [+ "0/1/0",+ "Folder 3",+ ],+ ]+ `)++ expect(childrenRequests).toMatchInlineSnapshot(`+ [+ [+ "0/0/0",+ "Request 1",+ ],+ [+ "0/1/0/0",+ "Request 2",+ ],+ [+ "0/0",+ "Request 3",+ ],+ ]+ `)+ })++ it("getChildrenEntriesFromMapper - get children of folder", () => {+ const childrenCollections = getChildrenEntriesFromMapper(+ "0/1",+ restCollectionsMapper+ )++ const childrenRequests = getChildrenEntriesFromMapper(+ "0/1",+ restRequestsMapper+ )++ expect(childrenCollections).toMatchInlineSnapshot(`+ [+ [+ "0/1/0",+ "Folder 3",+ ],+ ]+ `)++ expect(childrenRequests).toMatchInlineSnapshot(`+ [+ [+ "0/1/0/0",+ "Request 2",+ ],+ ]+ `)+ })++ it("getChildrenEntriesFromMapper - get children when the path is empty aka rootlevel", () => {+ const childrenCollections = getChildrenEntriesFromMapper(+ "",+ restCollectionsMapper+ )++ const childrenRequests = getChildrenEntriesFromMapper(+ "",+ restRequestsMapper+ )++ expect(childrenCollections).toMatchInlineSnapshot(`+ [+ [+ "0",+ "Collection 1",+ ],+ [+ "0/0",+ "Folder 1",+ ],+ [+ "0/1",+ "Folder 2",+ ],+ [+ "0/1/0",+ "Folder 3",+ ],+ [+ "1",+ "Collection 2",+ ],+ [+ "1/0",+ "Folder 4",+ ],+ [+ "1/0/0",+ "Folder 5",+ ],+ ]+ `)++ expect(childrenRequests).toMatchInlineSnapshot(`+ [+ [+ "0/0/0",+ "Request 1",+ ],+ [+ "0/1/0/0",+ "Request 2",+ ],+ [+ "0/0",+ "Request 3",+ ],+ [+ "1/0/0/0",+ "Request 4",+ ],+ [+ "1/0",+ "Request 6",+ ],+ [+ "1/1",+ "Request 7",+ ],+ ]+ `)+ })+})++describe("getDirectChildrenEntriesFromMapper", () => {+ beforeEach(cleanUpAndSeedMappers)++ it("getDirectChildrenEntriesFromMapper - get direct children of root collection", () => {+ const childrenCollections = getDirectChildrenEntriesFromMapper(+ "0",+ restCollectionsMapper+ )++ const childrenRequests = getDirectChildrenEntriesFromMapper(+ "0",+ restRequestsMapper+ )++ expect(childrenCollections).toMatchInlineSnapshot(`+ [+ [+ "0/0",+ "Folder 1",+ ],+ [+ "0/1",+ "Folder 2",+ ],+ ]+ `)++ expect(childrenRequests).toMatchInlineSnapshot(`+ [+ [+ "0/0",+ "Request 3",+ ],+ ]+ `)+ })++ it("getDirectChildrenEntriesFromMapper - get direct children of folder", () => {+ const childrenCollections = getDirectChildrenEntriesFromMapper(+ "0/1",+ restCollectionsMapper+ )++ const childrenRequests = getDirectChildrenEntriesFromMapper(+ "0/1",+ restRequestsMapper+ )++ expect(childrenCollections).toMatchInlineSnapshot(`+ [+ [+ "0/1/0",+ "Folder 3",+ ],+ ]+ `)++ expect(childrenRequests).toMatchInlineSnapshot("[]")+ })++ it("getDirectChildrenEntriesFromMapper - get direct children when the path is empty aka rootlevel", () => {+ const childrenCollections = getDirectChildrenEntriesFromMapper(+ "",+ restCollectionsMapper+ )++ const childrenRequests = getDirectChildrenEntriesFromMapper(+ "",+ restRequestsMapper+ )++ expect(childrenCollections).toMatchInlineSnapshot(`+ [+ [+ "0",+ "Collection 1",+ ],+ [+ "1",+ "Collection 2",+ ],+ ]+ `)++ // we do not have root level requests, so this will always be empty+ expect(childrenRequests).toMatchInlineSnapshot("[]")+ })+})++describe("removeAllChildCollectionsFromMapper", () => {+ beforeEach(cleanUpAndSeedMappers)++ it("removeAllChildCollectionsFromMapper - remove all child collections of a root collection", () => {+ removeAllChildCollectionsFromMapper("0", "REST")++ expect(getEntriesArrayFromMapper(restCollectionsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0",+ "Collection 1",+ ],+ [+ "1",+ "Collection 2",+ ],+ [+ "1/0",+ "Folder 4",+ ],+ [+ "1/0/0",+ "Folder 5",+ ],+ ]+ `)+ })++ it("removeAllChildCollectionsFromMapper - remove all child collections of a folder", () => {+ removeAllChildCollectionsFromMapper("1/0", "REST")++ expect(getEntriesArrayFromMapper(restCollectionsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0",+ "Collection 1",+ ],+ [+ "0/0",+ "Folder 1",+ ],+ [+ "0/1",+ "Folder 2",+ ],+ [+ "0/1/0",+ "Folder 3",+ ],+ [+ "1",+ "Collection 2",+ ],+ [+ "1/0",+ "Folder 4",+ ],+ ]+ `)+ })++ it("removeAllChildCollectionsFromMapper - remove all child collections when the path is empty aka rootlevel", () => {+ removeAllChildCollectionsFromMapper("", "REST")++ expect(+ getEntriesArrayFromMapper(restCollectionsMapper)+ ).toMatchInlineSnapshot("[]")+ })+})++describe("removeAllChildRequestsFromMapper", () => {+ beforeEach(cleanUpAndSeedMappers)++ it("removeAllChildRequestsFromMapper - remove all child requests of a root collection", () => {+ removeAllChildRequestsFromMapper("0", "REST")++ expect(getEntriesArrayFromMapper(restRequestsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "1/0/0/0",+ "Request 4",+ ],+ [+ "1/0",+ "Request 6",+ ],+ [+ "1/1",+ "Request 7",+ ],+ ]+ `)+ })++ it("removeAllChildRequestsFromMapper - remove all child requests of a folder", () => {+ removeAllChildRequestsFromMapper("1/0", "REST")++ expect(getEntriesArrayFromMapper(restRequestsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0/0/0",+ "Request 1",+ ],+ [+ "0/1/0/0",+ "Request 2",+ ],+ [+ "0/0",+ "Request 3",+ ],+ [+ "1/0",+ "Request 6",+ ],+ [+ "1/1",+ "Request 7",+ ],+ ]+ `)+ })++ it("removeAllChildRequestsFromMapper - remove all child requests when the path is empty aka rootlevel", () => {+ removeAllChildRequestsFromMapper("", "REST")++ expect(getEntriesArrayFromMapper(restRequestsMapper)).toMatchInlineSnapshot(+ "[]"+ )+ })+})++describe("changeParentForAllChildrenFromMapper", () => {+ beforeEach(cleanUpAndSeedMappers)++ it("changes parent for all children", () => {+ restCollectionsMapper.removeEntry(undefined, "0")+ removeAllChildCollectionsFromMapper("0", "REST")+ removeAllChildRequestsFromMapper("0", "REST")++ // for our usecases we assume that the newParentPath does not exist+ // so we are not caring about children that are already present in the newParentPath+ // also remember this function does not rename the parent, in this case, parentCollection "1" will still be named 1, but it won't have any children+ changeParentForAllChildrenFromMapper("1", "0", "REST")++ expect(getEntriesArrayFromMapper(restCollectionsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "1",+ "Collection 2",+ ],+ [+ "0/0",+ "Folder 4",+ ],+ [+ "0/0/0",+ "Folder 5",+ ],+ ]+ `)++ expect(getEntriesArrayFromMapper(restRequestsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0/0/0/0",+ "Request 4",+ ],+ [+ "0/0",+ "Request 6",+ ],+ [+ "0/1",+ "Request 7",+ ],+ ]+ `)+ })+})++describe("reorderIndexesAfterEntryRemoval", () => {+ beforeEach(cleanUpAndSeedMappers)++ it("reorderIndexesAfterEntryRemoval - reorder a collection", () => {+ restCollectionsMapper.removeEntry(undefined, "0/0")+ removeAllChildCollectionsFromMapper("0/0", "REST")+ removeAllChildRequestsFromMapper("0/0", "REST")++ reorderIndexesAfterEntryRemoval("0", restCollectionsMapper, "REST")+ reorderIndexesAfterEntryRemoval("0", restRequestsMapper, "REST")++ expect(getEntriesArrayFromMapper(restCollectionsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0",+ "Collection 1",+ ],+ [+ "1",+ "Collection 2",+ ],+ [+ "1/0",+ "Folder 4",+ ],+ [+ "1/0/0",+ "Folder 5",+ ],+ [+ "0/0",+ "Folder 2",+ ],+ [+ "0/0/0",+ "Folder 3",+ ],+ ]+ `)++ expect(getEntriesArrayFromMapper(restRequestsMapper)).toMatchInlineSnapshot(+ `+ [+ [+ "0/0",+ "Request 3",+ ],+ [+ "1/0/0/0",+ "Request 4",+ ],+ [+ "1/0",+ "Request 6",+ ],+ [+ "1/1",+ "Request 7",+ ],+ [+ "0/0/0/0",+ "Request 2",+ ],+ ]+ `+ )+ })++ it("reorderIndexesAfterEntryRemoval - reorder when the path is empty aka rootlevel", () => {+ restCollectionsMapper.removeEntry(undefined, "0")+ removeAllChildCollectionsFromMapper("0", "REST")+ removeAllChildRequestsFromMapper("0", "REST")++ reorderIndexesAfterEntryRemoval("", restCollectionsMapper, "REST")+ reorderIndexesAfterEntryRemoval("", restRequestsMapper, "REST")++ expect(getEntriesArrayFromMapper(restCollectionsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0",+ "Collection 2",+ ],+ [+ "0/0",+ "Folder 4",+ ],+ [+ "0/0/0",+ "Folder 5",+ ],+ ]+ `)++ expect(getEntriesArrayFromMapper(restRequestsMapper)).toMatchInlineSnapshot(+ `+ [+ [+ "0/0/0/0",+ "Request 4",+ ],+ [+ "0/0",+ "Request 6",+ ],+ [+ "0/1",+ "Request 7",+ ],+ ]+ `+ )+ })+})++describe("removeAndReorderEntries", () => {+ beforeEach(cleanUpAndSeedMappers)++ it("removeAndReorderEntries - removing a collection", () => {+ removeAndReorderEntries("0", "REST")++ expect(getEntriesArrayFromMapper(restCollectionsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0",+ "Collection 2",+ ],+ [+ "0/0",+ "Folder 4",+ ],+ [+ "0/0/0",+ "Folder 5",+ ],+ ]+ `)++ expect(getEntriesArrayFromMapper(restRequestsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0/0/0/0",+ "Request 4",+ ],+ [+ "0/0",+ "Request 6",+ ],+ [+ "0/1",+ "Request 7",+ ],+ ]+ `)+ })++ it("removeAndReorderEntries - removing a folder", () => {+ removeAndReorderEntries("0/0", "REST")++ expect(getEntriesArrayFromMapper(restCollectionsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0",+ "Collection 1",+ ],+ [+ "1",+ "Collection 2",+ ],+ [+ "1/0",+ "Folder 4",+ ],+ [+ "1/0/0",+ "Folder 5",+ ],+ [+ "0/0",+ "Folder 2",+ ],+ [+ "0/0/0",+ "Folder 3",+ ],+ ]+ `)++ expect(getEntriesArrayFromMapper(restRequestsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0/0",+ "Request 3",+ ],+ [+ "1/0/0/0",+ "Request 4",+ ],+ [+ "1/0",+ "Request 6",+ ],+ [+ "1/1",+ "Request 7",+ ],+ [+ "0/0/0/0",+ "Request 2",+ ],+ ]+ `)+ })+})++describe("moveRequestsInMapper", () => {+ beforeEach(() => {+ cleanUpAndSeedMappers()+ // the moveRequestInMapper function uses the collections store+ cleanUpAndSeedStore()+ })++ it("moveRequestsInMapper - move request from collection to collection", () => {+ moveRequestInMapper(0, "1", "0", "REST")++ expect(getEntriesArrayFromMapper(restRequestsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0/0/0",+ "Request 1",+ ],+ [+ "0/1/0/0",+ "Request 2",+ ],+ [+ "0/0",+ "Request 3",+ ],+ [+ "1/0/0/0",+ "Request 4",+ ],+ [+ "1/0",+ "Request 7",+ ],+ [+ "0/1",+ "Request 6",+ ],+ ]+ `)+ })++ it("moveRequestsInMapper - move request from folder to collection", () => {+ moveRequestInMapper(0, "0/1/0", "1", "REST")++ expect(getEntriesArrayFromMapper(restRequestsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0/0/0",+ "Request 1",+ ],+ [+ "0/0",+ "Request 3",+ ],+ [+ "1/0/0/0",+ "Request 4",+ ],+ [+ "1/0",+ "Request 6",+ ],+ [+ "1/1",+ "Request 7",+ ],+ [+ "1/2",+ "Request 2",+ ],+ ]+ `)+ })++ it("moveRequestsInMapper - move request from folder to folder", () => {+ moveRequestInMapper(0, "0/1/0", "1/0/0", "REST")++ expect(getEntriesArrayFromMapper(restRequestsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0/0/0",+ "Request 1",+ ],+ [+ "0/0",+ "Request 3",+ ],+ [+ "1/0/0/0",+ "Request 4",+ ],+ [+ "1/0",+ "Request 6",+ ],+ [+ "1/1",+ "Request 7",+ ],+ [+ "1/0/0/1",+ "Request 2",+ ],+ ]+ `)+ })+})++describe("moveCollectionInMapper", () => {+ beforeEach(() => {+ cleanUpAndSeedMappers()+ // the moveCollectionInMapper function uses the collections store+ cleanUpAndSeedStore()+ })++ it("moveCollectionInMapper - move folder form collection to collection", () => {+ // moveRESTFolder("1/0/0", "0")+ moveCollectionInMapper("1/0/0", "0", "REST")++ expect(getEntriesArrayFromMapper(restCollectionsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0",+ "Collection 1",+ ],+ [+ "0/0",+ "Folder 1",+ ],+ [+ "0/1",+ "Folder 2",+ ],+ [+ "0/1/0",+ "Folder 3",+ ],+ [+ "1",+ "Collection 2",+ ],+ [+ "1/0",+ "Folder 4",+ ],+ [+ "0/2",+ "Folder 5",+ ],+ ]+ `)++ expect(getEntriesArrayFromMapper(restRequestsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0/0/0",+ "Request 1",+ ],+ [+ "0/1/0/0",+ "Request 2",+ ],+ [+ "0/0",+ "Request 3",+ ],+ [+ "1/0",+ "Request 6",+ ],+ [+ "1/1",+ "Request 7",+ ],+ [+ "0/2/0",+ "Request 4",+ ],+ ]+ `)+ })++ it("moveCollectionsInMapper - move folder from folder to folder", () => {+ // moveRESTFolder("1/0/0", "0/1/0")+ moveCollectionInMapper("1/0/0", "0/1/0", "REST")++ expect(getEntriesArrayFromMapper(restCollectionsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0",+ "Collection 1",+ ],+ [+ "0/0",+ "Folder 1",+ ],+ [+ "0/1",+ "Folder 2",+ ],+ [+ "0/1/0",+ "Folder 3",+ ],+ [+ "1",+ "Collection 2",+ ],+ [+ "1/0",+ "Folder 4",+ ],+ [+ "0/1/0/0",+ "Folder 5",+ ],+ ]+ `)++ expect(getEntriesArrayFromMapper(restRequestsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0/0/0",+ "Request 1",+ ],+ [+ "0/1/0/0",+ "Request 2",+ ],+ [+ "0/0",+ "Request 3",+ ],+ [+ "1/0",+ "Request 6",+ ],+ [+ "1/1",+ "Request 7",+ ],+ [+ "0/1/0/0/0",+ "Request 4",+ ],+ ]+ `)+ })++ it("moveCollectionsInMapper - move folder in same collection to another folder in same collection", () => {+ moveCollectionInMapper("0/1/0", "0/0", "REST")++ expect(getEntriesArrayFromMapper(restCollectionsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0",+ "Collection 1",+ ],+ [+ "0/0",+ "Folder 1",+ ],+ [+ "0/1",+ "Folder 2",+ ],+ [+ "1",+ "Collection 2",+ ],+ [+ "1/0",+ "Folder 4",+ ],+ [+ "1/0/0",+ "Folder 5",+ ],+ [+ "0/0/0",+ "Folder 3",+ ],+ ]+ `)++ expect(getEntriesArrayFromMapper(restRequestsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0/0/0",+ "Request 1",+ ],+ [+ "0/0",+ "Request 3",+ ],+ [+ "1/0/0/0",+ "Request 4",+ ],+ [+ "1/0",+ "Request 6",+ ],+ [+ "1/1",+ "Request 7",+ ],+ [+ "0/0/0/0",+ "Request 2",+ ],+ ]+ `)+ })+})++describe("reorderRequestsMapper", () => {+ beforeEach(() => {+ cleanUpAndSeedMappers()++ // just adding some extra requests specifically for testing this function+ restRequestsMapper.addEntry("1/2", "Requests 8")+ restRequestsMapper.addEntry("1/3", "Requests 9")+ restRequestsMapper.addEntry("1/4", "Requests 10")+ })++ it("reorderRequestsMapper - reorders a request up down", () => {+ reorderRequestsMapper(0, "1", 3, "REST")++ expect(getEntriesArrayFromMapper(restRequestsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0/0/0",+ "Request 1",+ ],+ [+ "0/1/0/0",+ "Request 2",+ ],+ [+ "0/0",+ "Request 3",+ ],+ [+ "1/0/0/0",+ "Request 4",+ ],+ [+ "1/0",+ "Request 7",+ ],+ [+ "1/1",+ "Requests 8",+ ],+ [+ "1/2",+ "Request 6",+ ],+ [+ "1/3",+ "Requests 9",+ ],+ [+ "1/4",+ "Requests 10",+ ],+ ]+ `)+ })++ it("reorderRequestsMapper - reorders a request down up", () => {+ reorderRequestsMapper(3, "1", 2, "REST")++ expect(getEntriesArrayFromMapper(restRequestsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0/0/0",+ "Request 1",+ ],+ [+ "0/1/0/0",+ "Request 2",+ ],+ [+ "0/0",+ "Request 3",+ ],+ [+ "1/0/0/0",+ "Request 4",+ ],+ [+ "1/0",+ "Request 6",+ ],+ [+ "1/1",+ "Request 7",+ ],+ [+ "1/2",+ "Requests 9",+ ],+ [+ "1/3",+ "Requests 8",+ ],+ [+ "1/4",+ "Requests 10",+ ],+ ]+ `)+ })+})++describe("reorderCollectionsMapper", () => {+ beforeEach(() => {+ cleanUpAndSeedMappers()++ // adding some extra collections specifically for testing this function+ restCollectionsMapper.addEntry("2", "Collection 3")+ restCollectionsMapper.addEntry("3", "Collection 4")+ restCollectionsMapper.addEntry("4", "Collection 5")+ restCollectionsMapper.addEntry("5", "Collection 6")+ })++ it("reorderCollectionsMapper - reorders a collection up down", () => {+ reorderCollectionsInMapper("2", "5", "REST")++ expect(getEntriesArrayFromMapper(restCollectionsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0",+ "Collection 1",+ ],+ [+ "0/0",+ "Folder 1",+ ],+ [+ "0/1",+ "Folder 2",+ ],+ [+ "0/1/0",+ "Folder 3",+ ],+ [+ "1",+ "Collection 2",+ ],+ [+ "1/0",+ "Folder 4",+ ],+ [+ "1/0/0",+ "Folder 5",+ ],+ [+ "2",+ "Collection 4",+ ],+ [+ "3",+ "Collection 5",+ ],+ [+ "4",+ "Collection 3",+ ],+ [+ "5",+ "Collection 6",+ ],+ ]+ `)++ expect(getEntriesArrayFromMapper(restRequestsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0/0/0",+ "Request 1",+ ],+ [+ "0/1/0/0",+ "Request 2",+ ],+ [+ "0/0",+ "Request 3",+ ],+ [+ "1/0/0/0",+ "Request 4",+ ],+ [+ "1/0",+ "Request 6",+ ],+ [+ "1/1",+ "Request 7",+ ],+ ]+ `)+ })++ it("reorderCollectionsMapper - reorders a folder up down", () => {+ // add extra folders to test this case+ restCollectionsMapper.addEntry("1/1", "Folder 6")+ restCollectionsMapper.addEntry("1/1/0", "Child Folder 1")+ restCollectionsMapper.addEntry("1/2", "Folder 7")+ restCollectionsMapper.addEntry("1/2/0", "Child Folder 2")+ restCollectionsMapper.addEntry("1/3", "Folder 8")+ restCollectionsMapper.addEntry("1/3/0", "Child Folder 3")+ restCollectionsMapper.addEntry("1/4", "Folder 9")+ restCollectionsMapper.addEntry("1/4/0", "Child Folder 4")++ reorderCollectionsInMapper("1/2", "1/4", "REST")++ expect(getEntriesArrayFromMapper(restCollectionsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0",+ "Collection 1",+ ],+ [+ "0/0",+ "Folder 1",+ ],+ [+ "0/1",+ "Folder 2",+ ],+ [+ "0/1/0",+ "Folder 3",+ ],+ [+ "1",+ "Collection 2",+ ],+ [+ "1/0",+ "Folder 4",+ ],+ [+ "1/0/0",+ "Folder 5",+ ],+ [+ "2",+ "Collection 3",+ ],+ [+ "3",+ "Collection 4",+ ],+ [+ "4",+ "Collection 5",+ ],+ [+ "5",+ "Collection 6",+ ],+ [+ "1/1",+ "Folder 6",+ ],+ [+ "1/1/0",+ "Child Folder 1",+ ],+ [+ "1/2",+ "Folder 8",+ ],+ [+ "1/3",+ "Folder 7",+ ],+ [+ "1/4",+ "Folder 9",+ ],+ [+ "1/4/0",+ "Child Folder 4",+ ],+ [+ "1/2/0",+ "Child Folder 3",+ ],+ [+ "1/3/0",+ "Child Folder 2",+ ],+ ]+ `)++ expect(getEntriesArrayFromMapper(restRequestsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0/0/0",+ "Request 1",+ ],+ [+ "0/1/0/0",+ "Request 2",+ ],+ [+ "0/0",+ "Request 3",+ ],+ [+ "1/0/0/0",+ "Request 4",+ ],+ [+ "1/0",+ "Request 6",+ ],+ [+ "1/1",+ "Request 7",+ ],+ ]+ `)+ })++ it("reorderRequestsMapper - reorders a collection down up", () => {+ reorderCollectionsInMapper("3", "1", "REST")++ expect(getEntriesArrayFromMapper(restCollectionsMapper))+ .toMatchInlineSnapshot(`+ [+ [+ "0",+ "Collection 1",+ ],+ [+ "0/0",+ "Folder 1",+ ],+ [+ "0/1",+ "Folder 2",+ ],+ [+ "0/1/0",+ "Folder 3",+ ],+ [+ "1",+ "Collection 4",+ ],+ [+ "2",+ "Collection 2",+ ],+ [+ "3",+ "Collection 3",+ ],+ [+ "4",+ "Collection 5",+ ],+ [+ "5",+ "Collection 6",+ ],+ [+ "2/0",+ "Folder 4",+ ],+ [+ "2/0/0",+ "Folder 5",+ ],+ ]+ `)+ })+})++function cleanUpAndSeedMappers() {+ // remove all collections+ Array.from(restCollectionsMapper.getValue().entries()).forEach(([path]) => {+ restCollectionsMapper.removeEntry(undefined, path)+ })++ // remove all requests+ Array.from(restRequestsMapper.getValue().entries()).forEach(([path]) => {+ restRequestsMapper.removeEntry(undefined, path)+ })++ // populate sample collections and requests+ /**+ * 0. Collection 1+ * 0. Folder 1+ * 0. Request 1+ * 1. Folder 2+ * 0. Folder 3+ * 0.Request 2+ * 0. Request 3+ * 1. Collection 2+ * 0. Folder 4+ * 0. Folder 5+ * 0. Request 4+ * 0. Request 6+ * 1. Request 7+ */+ restCollectionsMapper.addEntry("0", "Collection 1")++ restCollectionsMapper.addEntry("0/0", "Folder 1")+ restCollectionsMapper.addEntry("0/1", "Folder 2")+ restCollectionsMapper.addEntry("0/1/0", "Folder 3")++ restRequestsMapper.addEntry("0/0/0", "Request 1")+ restRequestsMapper.addEntry("0/1/0/0", "Request 2")+ restRequestsMapper.addEntry("0/0", "Request 3")+ restCollectionsMapper.addEntry("1", "Collection 2")+ restCollectionsMapper.addEntry("1/0", "Folder 4")+ restCollectionsMapper.addEntry("1/0/0", "Folder 5")++ restRequestsMapper.addEntry("1/0/0/0", "Request 4")+ restRequestsMapper.addEntry("1/0", "Request 6")+ restRequestsMapper.addEntry("1/1", "Request 7")+}++function cleanUpAndSeedStore() {+ // reset the store+ setRESTCollections([])++ /**+ * * 0. Collection 1+ * 0. Folder 1+ * 0. Request 1+ * 1. Folder 2+ * 0. Folder 3+ * 0.Request 2+ * 0. Request 3+ * 1. Collection 2+ * 0. Folder 4+ * 0. Folder 5+ * 0. Request 4+ * 0. Request 6+ * 1. Request 7+ */++ addRESTCollection(+ makeCollection({+ name: "Collection 1",+ folders: [+ makeCollection({+ name: "Folder 1",+ folders: [],+ requests: [makeEmptyRequest("Request 1")],+ }),+ makeCollection({+ name: "Folder 2",+ folders: [+ makeCollection({+ name: "Folder 3",+ folders: [],+ requests: [makeEmptyRequest("Request 2")],+ }),+ ],+ requests: [],+ }),+ ],+ requests: [makeEmptyRequest("Request 3")],+ })+ )++ addRESTCollection(+ makeCollection({+ name: "Collection 2",+ folders: [+ makeCollection({+ name: "Folder 4",+ folders: [+ makeCollection({+ name: "Folder 5",+ folders: [],+ requests: [makeEmptyRequest("Request 4")],+ }),+ ],+ requests: [],+ }),+ ],+ requests: [makeEmptyRequest("Request 6"), makeEmptyRequest("Request 7")],+ })+ )+}++function makeEmptyRequest(name: string): HoppRESTRequest {+ return {+ name,+ auth: {+ authType: "none",+ authActive: false,+ },+ endpoint: "",+ body: {+ contentType: null,+ body: null,+ },+ headers: [],+ params: [],+ method: "GET",+ preRequestScript: "",+ v: "1",+ testScript: "",+ }+}