@webiny/app-aco 0.0.0-unstable.eb196ccd2f → 0.0.0-unstable.eb81deee7e

package/features/folders/deleteFolder/DeleteFolderGqlGateway.js

@@ -1,5 +1,6 @@
-import gql from "graphql-tag";
-export const DELETE_FOLDER = gql`
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/index.js";
+import { DeleteFolderGateway } from "./abstractions.js";
+const DELETE_FOLDER = `
     mutation DeleteFolder($id: ID!) {
         aco {
             deleteFolder(id: $id) {
@@ -13,31 +14,28 @@ export const DELETE_FOLDER = gql`
         }
     }
 `;
-export class DeleteFolderGqlGateway {
-  constructor(client) {
-    this.client = client;
-  }
-  async execute(id) {
-    const {
-      data: response
-    } = await this.client.mutate({
-      mutation: DELETE_FOLDER,
-      variables: {
-        id
-      }
-    });
-    if (!response) {
-      throw new Error("Network error while deleting folder");
+class DeleteFolderGqlGatewayImpl {
+    constructor(client){
+        this.client = client;
     }
-    const {
-      data,
-      error
-    } = response.aco.deleteFolder;
-    if (!data) {
-      throw new Error(error?.message || "Could not delete folder");
+    async execute(id) {
+        const response = await this.client.execute({
+            query: DELETE_FOLDER,
+            variables: {
+                id
+            }
+        });
+        if (!response) throw new Error("Network error while deleting folder");
+        const { data, error } = response.aco.deleteFolder;
+        if (!data) throw new Error(error?.message || "Could not delete folder");
     }
-    return;
-  }
 }
+const DeleteFolderGqlGateway = DeleteFolderGateway.createImplementation({
+    implementation: DeleteFolderGqlGatewayImpl,
+    dependencies: [
+        MainGraphQLClient
+    ]
+});
+export { DELETE_FOLDER, DeleteFolderGqlGateway };
 
 //# sourceMappingURL=DeleteFolderGqlGateway.js.map

package/features/folders/deleteFolder/DeleteFolderGqlGateway.js.map

@@ -1 +1 @@
-{"version":3,"names":["gql","DELETE_FOLDER","DeleteFolderGqlGateway","constructor","client","execute","id","data","response","mutate","mutation","variables","Error","error","aco","deleteFolder","message"],"sources":["DeleteFolderGqlGateway.ts"],"sourcesContent":["import type ApolloClient from \"apollo-client\";\nimport gql from \"graphql-tag\";\nimport type { IDeleteFolderGateway } from \"./IDeleteFolderGateway\";\nimport type { AcoError } from \"~/types\";\n\nexport interface DeleteFolderVariables {\n    id: string;\n}\n\nexport interface DeleteFolderResponse {\n    aco: {\n        deleteFolder: {\n            data: boolean;\n            error: AcoError | null;\n        };\n    };\n}\n\nexport const DELETE_FOLDER = gql`\n    mutation DeleteFolder($id: ID!) {\n        aco {\n            deleteFolder(id: $id) {\n                data\n                error {\n                    code\n                    data\n                    message\n                }\n            }\n        }\n    }\n`;\n\nexport class DeleteFolderGqlGateway implements IDeleteFolderGateway {\n    private client: ApolloClient<any>;\n\n    constructor(client: ApolloClient<any>) {\n        this.client = client;\n    }\n\n    async execute(id: string) {\n        const { data: response } = await this.client.mutate<\n            DeleteFolderResponse,\n            DeleteFolderVariables\n        >({\n            mutation: DELETE_FOLDER,\n            variables: {\n                id\n            }\n        });\n\n        if (!response) {\n            throw new Error(\"Network error while deleting folder\");\n        }\n\n        const { data, error } = response.aco.deleteFolder;\n\n        if (!data) {\n            throw new Error(error?.message || \"Could not delete folder\");\n        }\n\n        return;\n    }\n}\n"],"mappings":"AACA,OAAOA,GAAG,MAAM,aAAa;AAiB7B,OAAO,MAAMC,aAAa,GAAGD,GAAG;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AAED,OAAO,MAAME,sBAAsB,CAAiC;EAGhEC,WAAWA,CAACC,MAAyB,EAAE;IACnC,IAAI,CAACA,MAAM,GAAGA,MAAM;EACxB;EAEA,MAAMC,OAAOA,CAACC,EAAU,EAAE;IACtB,MAAM;MAAEC,IAAI,EAAEC;IAAS,CAAC,GAAG,MAAM,IAAI,CAACJ,MAAM,CAACK,MAAM,CAGjD;MACEC,QAAQ,EAAET,aAAa;MACvBU,SAAS,EAAE;QACPL;MACJ;IACJ,CAAC,CAAC;IAEF,IAAI,CAACE,QAAQ,EAAE;MACX,MAAM,IAAII,KAAK,CAAC,qCAAqC,CAAC;IAC1D;IAEA,MAAM;MAAEL,IAAI;MAAEM;IAAM,CAAC,GAAGL,QAAQ,CAACM,GAAG,CAACC,YAAY;IAEjD,IAAI,CAACR,IAAI,EAAE;MACP,MAAM,IAAIK,KAAK,CAACC,KAAK,EAAEG,OAAO,IAAI,yBAAyB,CAAC;IAChE;IAEA;EACJ;AACJ","ignoreList":[]}
+{"version":3,"file":"features/folders/deleteFolder/DeleteFolderGqlGateway.js","sources":["../../../../src/features/folders/deleteFolder/DeleteFolderGqlGateway.ts"],"sourcesContent":["import { MainGraphQLClient } from \"@webiny/app/features/mainGraphQLClient/index.js\";\nimport { DeleteFolderGateway as GatewayAbstraction } from \"./abstractions.js\";\nimport type { AcoError } from \"~/types.js\";\n\nexport interface DeleteFolderVariables {\n    id: string;\n}\n\nexport interface DeleteFolderResponse {\n    aco: {\n        deleteFolder: {\n            data: boolean;\n            error: AcoError | null;\n        };\n    };\n}\n\nexport const DELETE_FOLDER = /* GraphQL */ `\n    mutation DeleteFolder($id: ID!) {\n        aco {\n            deleteFolder(id: $id) {\n                data\n                error {\n                    code\n                    data\n                    message\n                }\n            }\n        }\n    }\n`;\n\nclass DeleteFolderGqlGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(private client: MainGraphQLClient.Interface) {}\n\n    async execute(id: string) {\n        const response = await this.client.execute<DeleteFolderResponse, DeleteFolderVariables>({\n            query: DELETE_FOLDER,\n            variables: {\n                id\n            }\n        });\n\n        if (!response) {\n            throw new Error(\"Network error while deleting folder\");\n        }\n\n        const { data, error } = response.aco.deleteFolder;\n\n        if (!data) {\n            throw new Error(error?.message || \"Could not delete folder\");\n        }\n\n        return;\n    }\n}\n\nexport const DeleteFolderGqlGateway = GatewayAbstraction.createImplementation({\n    implementation: DeleteFolderGqlGatewayImpl,\n    dependencies: [MainGraphQLClient]\n});\n"],"names":["DELETE_FOLDER","DeleteFolderGqlGatewayImpl","client","id","response","Error","data","error","DeleteFolderGqlGateway","GatewayAbstraction","MainGraphQLClient"],"mappings":";;AAiBO,MAAMA,gBAA8B,CAAC;;;;;;;;;;;;;AAa5C,CAAC;AAED,MAAMC;IACF,YAAoBC,MAAmC,CAAE;aAArCA,MAAM,GAANA;IAAsC;IAE1D,MAAM,QAAQC,EAAU,EAAE;QACtB,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAA8C;YACpF,OAAOJ;YACP,WAAW;gBACPG;YACJ;QACJ;QAEA,IAAI,CAACC,UACD,MAAM,IAAIC,MAAM;QAGpB,MAAM,EAAEC,IAAI,EAAEC,KAAK,EAAE,GAAGH,SAAS,GAAG,CAAC,YAAY;QAEjD,IAAI,CAACE,MACD,MAAM,IAAID,MAAME,OAAO,WAAW;IAI1C;AACJ;AAEO,MAAMC,yBAAyBC,oBAAAA,oBAAuC,CAAC;IAC1E,gBAAgBR;IAChB,cAAc;QAACS;KAAkB;AACrC"}

package/features/folders/deleteFolder/DeleteFolderRepository.d.ts

@@ -1,10 +1,13 @@
-import type { IDeleteFolderRepository } from "./IDeleteFolderRepository";
-import type { ListCache } from "../cache";
-import type { Folder } from "../Folder";
-import type { IDeleteFolderGateway } from "./IDeleteFolderGateway";
-export declare class DeleteFolderRepository implements IDeleteFolderRepository {
+import { DeleteFolderGateway } from "./abstractions.js";
+import { DeleteFolderRepository as RepositoryAbstraction } from "./abstractions.js";
+import { FoldersCache } from "../../../features/folders/abstractions.js";
+declare class DeleteFolderRepositoryImpl implements RepositoryAbstraction.Interface {
     private cache;
     private gateway;
-    constructor(cache: ListCache<Folder>, gateway: IDeleteFolderGateway);
-    execute(folder: Folder): Promise<void>;
+    constructor(cache: FoldersCache.Interface, gateway: DeleteFolderGateway.Interface);
+    execute(id: string): Promise<void>;
 }
+export declare const DeleteFolderRepository: typeof DeleteFolderRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDeleteFolderRepository>;
+};
+export {};

package/features/folders/deleteFolder/DeleteFolderRepository.js

@@ -1,12 +1,22 @@
-export class DeleteFolderRepository {
-  constructor(cache, gateway) {
-    this.cache = cache;
-    this.gateway = gateway;
-  }
-  async execute(folder) {
-    await this.gateway.execute(folder.id);
-    this.cache.removeItems(f => f.id === folder.id);
-  }
+import { DeleteFolderGateway, DeleteFolderRepository } from "./abstractions.js";
+import { FoldersCache } from "../abstractions.js";
+class DeleteFolderRepositoryImpl {
+    constructor(cache, gateway){
+        this.cache = cache;
+        this.gateway = gateway;
+    }
+    async execute(id) {
+        await this.gateway.execute(id);
+        this.cache.removeItems((f)=>f.id === id);
+    }
 }
+const DeleteFolderRepository_DeleteFolderRepository = DeleteFolderRepository.createImplementation({
+    implementation: DeleteFolderRepositoryImpl,
+    dependencies: [
+        FoldersCache,
+        DeleteFolderGateway
+    ]
+});
+export { DeleteFolderRepository_DeleteFolderRepository as DeleteFolderRepository };
 
 //# sourceMappingURL=DeleteFolderRepository.js.map

package/features/folders/deleteFolder/DeleteFolderRepository.js.map

@@ -1 +1 @@
-{"version":3,"names":["DeleteFolderRepository","constructor","cache","gateway","execute","folder","id","removeItems","f"],"sources":["DeleteFolderRepository.ts"],"sourcesContent":["import type { IDeleteFolderRepository } from \"./IDeleteFolderRepository\";\nimport type { ListCache } from \"../cache\";\nimport type { Folder } from \"../Folder\";\nimport type { IDeleteFolderGateway } from \"./IDeleteFolderGateway\";\n\nexport class DeleteFolderRepository implements IDeleteFolderRepository {\n    private cache: ListCache<Folder>;\n    private gateway: IDeleteFolderGateway;\n\n    constructor(cache: ListCache<Folder>, gateway: IDeleteFolderGateway) {\n        this.cache = cache;\n        this.gateway = gateway;\n    }\n\n    async execute(folder: Folder) {\n        await this.gateway.execute(folder.id);\n        this.cache.removeItems(f => f.id === folder.id);\n    }\n}\n"],"mappings":"AAKA,OAAO,MAAMA,sBAAsB,CAAoC;EAInEC,WAAWA,CAACC,KAAwB,EAAEC,OAA6B,EAAE;IACjE,IAAI,CAACD,KAAK,GAAGA,KAAK;IAClB,IAAI,CAACC,OAAO,GAAGA,OAAO;EAC1B;EAEA,MAAMC,OAAOA,CAACC,MAAc,EAAE;IAC1B,MAAM,IAAI,CAACF,OAAO,CAACC,OAAO,CAACC,MAAM,CAACC,EAAE,CAAC;IACrC,IAAI,CAACJ,KAAK,CAACK,WAAW,CAACC,CAAC,IAAIA,CAAC,CAACF,EAAE,KAAKD,MAAM,CAACC,EAAE,CAAC;EACnD;AACJ","ignoreList":[]}
+{"version":3,"file":"features/folders/deleteFolder/DeleteFolderRepository.js","sources":["../../../../src/features/folders/deleteFolder/DeleteFolderRepository.ts"],"sourcesContent":["import { DeleteFolderGateway } from \"./abstractions.js\";\nimport { DeleteFolderRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { FoldersCache } from \"~/features/folders/abstractions.js\";\n\nclass DeleteFolderRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private cache: FoldersCache.Interface,\n        private gateway: DeleteFolderGateway.Interface\n    ) {}\n\n    async execute(id: string) {\n        await this.gateway.execute(id);\n        this.cache.removeItems(f => f.id === id);\n    }\n}\n\nexport const DeleteFolderRepository = RepositoryAbstraction.createImplementation({\n    implementation: DeleteFolderRepositoryImpl,\n    dependencies: [FoldersCache, DeleteFolderGateway]\n});\n"],"names":["DeleteFolderRepositoryImpl","cache","gateway","id","f","DeleteFolderRepository","RepositoryAbstraction","FoldersCache","DeleteFolderGateway"],"mappings":";;AAIA,MAAMA;IACF,YACYC,KAA6B,EAC7BC,OAAsC,CAChD;aAFUD,KAAK,GAALA;aACAC,OAAO,GAAPA;IACT;IAEH,MAAM,QAAQC,EAAU,EAAE;QACtB,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAACA;QAC3B,IAAI,CAAC,KAAK,CAAC,WAAW,CAACC,CAAAA,IAAKA,EAAE,EAAE,KAAKD;IACzC;AACJ;AAEO,MAAME,gDAAyBC,uBAAAA,oBAA0C,CAAC;IAC7E,gBAAgBN;IAChB,cAAc;QAACO;QAAcC;KAAoB;AACrD"}

package/features/folders/deleteFolder/DeleteFolderUseCase.d.ts

@@ -1,7 +1,10 @@
-import type { DeleteFolderParams, IDeleteFolderUseCase } from "./IDeleteFolderUseCase";
-import type { IDeleteFolderRepository } from "./IDeleteFolderRepository";
-export declare class DeleteFolderUseCase implements IDeleteFolderUseCase {
+import { DeleteFolderUseCase as UseCaseAbstraction, DeleteFolderRepository } from "./abstractions.js";
+declare class DeleteFolderUseCaseImpl implements UseCaseAbstraction.Interface {
     private repository;
-    constructor(repository: IDeleteFolderRepository);
-    execute(params: DeleteFolderParams): Promise<void>;
+    constructor(repository: DeleteFolderRepository.Interface);
+    execute(id: string): Promise<void>;
 }
+export declare const DeleteFolderUseCase: typeof DeleteFolderUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDeleteFolderUseCase>;
+};
+export {};

package/features/folders/deleteFolder/DeleteFolderUseCase.js

@@ -1,18 +1,18 @@
-import { Folder } from "../Folder";
-export class DeleteFolderUseCase {
-  constructor(repository) {
-    this.repository = repository;
-  }
-  async execute(params) {
-    await this.repository.execute(Folder.create({
-      id: params.id,
-      title: params.title,
-      slug: params.slug,
-      type: params.type,
-      parentId: params.parentId,
-      permissions: params.permissions
-    }));
-  }
+import { DeleteFolderRepository, DeleteFolderUseCase } from "./abstractions.js";
+class DeleteFolderUseCaseImpl {
+    constructor(repository){
+        this.repository = repository;
+    }
+    async execute(id) {
+        await this.repository.execute(id);
+    }
 }
+const DeleteFolderUseCase_DeleteFolderUseCase = DeleteFolderUseCase.createImplementation({
+    implementation: DeleteFolderUseCaseImpl,
+    dependencies: [
+        DeleteFolderRepository
+    ]
+});
+export { DeleteFolderUseCase_DeleteFolderUseCase as DeleteFolderUseCase };
 
 //# sourceMappingURL=DeleteFolderUseCase.js.map

package/features/folders/deleteFolder/DeleteFolderUseCase.js.map

@@ -1 +1 @@
-{"version":3,"names":["Folder","DeleteFolderUseCase","constructor","repository","execute","params","create","id","title","slug","type","parentId","permissions"],"sources":["DeleteFolderUseCase.ts"],"sourcesContent":["import type { DeleteFolderParams, IDeleteFolderUseCase } from \"./IDeleteFolderUseCase\";\nimport type { IDeleteFolderRepository } from \"./IDeleteFolderRepository\";\nimport { Folder } from \"../Folder\";\n\nexport class DeleteFolderUseCase implements IDeleteFolderUseCase {\n    private repository: IDeleteFolderRepository;\n\n    constructor(repository: IDeleteFolderRepository) {\n        this.repository = repository;\n    }\n\n    async execute(params: DeleteFolderParams) {\n        await this.repository.execute(\n            Folder.create({\n                id: params.id,\n                title: params.title,\n                slug: params.slug,\n                type: params.type,\n                parentId: params.parentId,\n                permissions: params.permissions\n            })\n        );\n    }\n}\n"],"mappings":"AAEA,SAASA,MAAM;AAEf,OAAO,MAAMC,mBAAmB,CAAiC;EAG7DC,WAAWA,CAACC,UAAmC,EAAE;IAC7C,IAAI,CAACA,UAAU,GAAGA,UAAU;EAChC;EAEA,MAAMC,OAAOA,CAACC,MAA0B,EAAE;IACtC,MAAM,IAAI,CAACF,UAAU,CAACC,OAAO,CACzBJ,MAAM,CAACM,MAAM,CAAC;MACVC,EAAE,EAAEF,MAAM,CAACE,EAAE;MACbC,KAAK,EAAEH,MAAM,CAACG,KAAK;MACnBC,IAAI,EAAEJ,MAAM,CAACI,IAAI;MACjBC,IAAI,EAAEL,MAAM,CAACK,IAAI;MACjBC,QAAQ,EAAEN,MAAM,CAACM,QAAQ;MACzBC,WAAW,EAAEP,MAAM,CAACO;IACxB,CAAC,CACL,CAAC;EACL;AACJ","ignoreList":[]}
+{"version":3,"file":"features/folders/deleteFolder/DeleteFolderUseCase.js","sources":["../../../../src/features/folders/deleteFolder/DeleteFolderUseCase.ts"],"sourcesContent":["import {\n    DeleteFolderUseCase as UseCaseAbstraction,\n    DeleteFolderRepository\n} from \"./abstractions.js\";\n\nclass DeleteFolderUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: DeleteFolderRepository.Interface) {}\n\n    async execute(id: string) {\n        await this.repository.execute(id);\n    }\n}\n\nexport const DeleteFolderUseCase = UseCaseAbstraction.createImplementation({\n    implementation: DeleteFolderUseCaseImpl,\n    dependencies: [DeleteFolderRepository]\n});\n"],"names":["DeleteFolderUseCaseImpl","repository","id","DeleteFolderUseCase","UseCaseAbstraction","DeleteFolderRepository"],"mappings":";AAKA,MAAMA;IACF,YAAoBC,UAA4C,CAAE;aAA9CA,UAAU,GAAVA;IAA+C;IAEnE,MAAM,QAAQC,EAAU,EAAE;QACtB,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;IAClC;AACJ;AAEO,MAAMC,0CAAsBC,oBAAAA,oBAAuC,CAAC;IACvE,gBAAgBJ;IAChB,cAAc;QAACK;KAAuB;AAC1C"}

package/features/folders/deleteFolder/abstractions.d.ts

@@ -0,0 +1,21 @@
+export interface IDeleteFolderUseCase {
+    execute: (id: string) => Promise<void>;
+}
+export declare const DeleteFolderUseCase: import("@webiny/di").Abstraction<IDeleteFolderUseCase>;
+export declare namespace DeleteFolderUseCase {
+    type Interface = IDeleteFolderUseCase;
+}
+export interface IDeleteFolderRepository {
+    execute: (id: string) => Promise<void>;
+}
+export declare const DeleteFolderRepository: import("@webiny/di").Abstraction<IDeleteFolderRepository>;
+export declare namespace DeleteFolderRepository {
+    type Interface = IDeleteFolderRepository;
+}
+export interface IDeleteFolderGateway {
+    execute: (id: string) => Promise<void>;
+}
+export declare const DeleteFolderGateway: import("@webiny/di").Abstraction<IDeleteFolderGateway>;
+export declare namespace DeleteFolderGateway {
+    type Interface = IDeleteFolderGateway;
+}

package/features/folders/deleteFolder/abstractions.js

@@ -0,0 +1,7 @@
+import { createAbstraction } from "@webiny/feature/admin";
+const DeleteFolderUseCase = createAbstraction("DeleteFolderUseCase");
+const DeleteFolderRepository = createAbstraction("DeleteFolderRepository");
+const DeleteFolderGateway = createAbstraction("DeleteFolderGateway");
+export { DeleteFolderGateway, DeleteFolderRepository, DeleteFolderUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/folders/deleteFolder/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folders/deleteFolder/abstractions.js","sources":["../../../../src/features/folders/deleteFolder/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\n\n// Use Case\n\nexport interface IDeleteFolderUseCase {\n    execute: (id: string) => Promise<void>;\n}\n\nexport const DeleteFolderUseCase = createAbstraction<IDeleteFolderUseCase>(\"DeleteFolderUseCase\");\n\nexport namespace DeleteFolderUseCase {\n    export type Interface = IDeleteFolderUseCase;\n}\n\n// Repository\n\nexport interface IDeleteFolderRepository {\n    execute: (id: string) => Promise<void>;\n}\n\nexport const DeleteFolderRepository =\n    createAbstraction<IDeleteFolderRepository>(\"DeleteFolderRepository\");\n\nexport namespace DeleteFolderRepository {\n    export type Interface = IDeleteFolderRepository;\n}\n\n// Gateway\nexport interface IDeleteFolderGateway {\n    execute: (id: string) => Promise<void>;\n}\n\nexport const DeleteFolderGateway = createAbstraction<IDeleteFolderGateway>(\"DeleteFolderGateway\");\n\nexport namespace DeleteFolderGateway {\n    export type Interface = IDeleteFolderGateway;\n}\n"],"names":["DeleteFolderUseCase","createAbstraction","DeleteFolderRepository","DeleteFolderGateway"],"mappings":";AAQO,MAAMA,sBAAsBC,kBAAwC;AAYpE,MAAMC,yBACTD,kBAA2C;AAWxC,MAAME,sBAAsBF,kBAAwC"}

package/features/folders/deleteFolder/feature.d.ts

@@ -0,0 +1,3 @@
+export declare const DeleteFolderFeature: import("@webiny/feature/admin").FeatureDefinition<{
+    useCase: import("./abstractions.js").IDeleteFolderUseCase;
+}, []>;

package/features/folders/deleteFolder/feature.js

@@ -0,0 +1,21 @@
+import { createFeature } from "@webiny/feature/admin";
+import { DeleteFolderUseCase } from "./abstractions.js";
+import { DeleteFolderUseCase as external_DeleteFolderUseCase_js_DeleteFolderUseCase } from "./DeleteFolderUseCase.js";
+import { DeleteFolderRepository } from "./DeleteFolderRepository.js";
+import { DeleteFolderGqlGateway } from "./DeleteFolderGqlGateway.js";
+const DeleteFolderFeature = createFeature({
+    name: "DeleteFolder",
+    register (container) {
+        container.register(external_DeleteFolderUseCase_js_DeleteFolderUseCase);
+        container.register(DeleteFolderRepository).inSingletonScope();
+        container.register(DeleteFolderGqlGateway);
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(DeleteFolderUseCase)
+        };
+    }
+});
+export { DeleteFolderFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/folders/deleteFolder/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folders/deleteFolder/feature.js","sources":["../../../../src/features/folders/deleteFolder/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { DeleteFolderUseCase as UseCase } from \"./abstractions.js\";\nimport { DeleteFolderUseCase } from \"./DeleteFolderUseCase.js\";\nimport { DeleteFolderRepository } from \"./DeleteFolderRepository.js\";\nimport { DeleteFolderGqlGateway } from \"./DeleteFolderGqlGateway.js\";\n\nexport const DeleteFolderFeature = createFeature({\n    name: \"DeleteFolder\",\n    register(container) {\n        container.register(DeleteFolderUseCase);\n        container.register(DeleteFolderRepository).inSingletonScope();\n        container.register(DeleteFolderGqlGateway);\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCase)\n        };\n    }\n});\n"],"names":["DeleteFolderFeature","createFeature","container","DeleteFolderUseCase","DeleteFolderRepository","DeleteFolderGqlGateway","UseCase"],"mappings":";;;;;AAMO,MAAMA,sBAAsBC,cAAc;IAC7C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,wBAAwB,gBAAgB;QAC3DF,UAAU,QAAQ,CAACG;IACvB;IACA,SAAQH,SAAS;QACb,OAAO;YACH,SAASA,UAAU,OAAO,CAACI;QAC/B;IACJ;AACJ"}

package/features/folders/deleteFolder/index.d.ts

@@ -1 +1 @@
-export * from "./useDeleteFolder";
+export * from "./useDeleteFolder.js";

package/features/folders/deleteFolder/index.js

@@ -1,3 +1 @@
-export * from "./useDeleteFolder";
-
-//# sourceMappingURL=index.js.map
+export * from "./useDeleteFolder.js";

package/features/folders/deleteFolder/useDeleteFolder.d.ts

@@ -1,4 +1,3 @@
-import type { DeleteFolderParams } from "./IDeleteFolderUseCase";
 export declare const useDeleteFolder: () => {
-    deleteFolder: (params: DeleteFolderParams) => Promise<void>;
+    deleteFolder: (id: string) => Promise<void>;
 };

package/features/folders/deleteFolder/useDeleteFolder.js

@@ -1,19 +1,11 @@
-import { useCallback } from "react";
-import { useApolloClient } from "@apollo/react-hooks";
-import { DeleteFolderGqlGateway } from "./DeleteFolderGqlGateway";
-import { DeleteFolder } from "./DeleteFolder";
-import { useFoldersType } from "../../../hooks";
-export const useDeleteFolder = () => {
-  const client = useApolloClient();
-  const type = useFoldersType();
-  const gateway = new DeleteFolderGqlGateway(client);
-  const deleteFolder = useCallback(params => {
-    const instance = DeleteFolder.getInstance(type, gateway);
-    return instance.execute(params);
-  }, [type, gateway]);
-  return {
-    deleteFolder
-  };
+import { useFeature } from "@webiny/app";
+import { DeleteFolderFeature } from "./feature.js";
+const useDeleteFolder = ()=>{
+    const { useCase } = useFeature(DeleteFolderFeature);
+    return {
+        deleteFolder: (id)=>useCase.execute(id)
+    };
 };
+export { useDeleteFolder };
 
 //# sourceMappingURL=useDeleteFolder.js.map

package/features/folders/deleteFolder/useDeleteFolder.js.map

@@ -1 +1 @@
-{"version":3,"names":["useCallback","useApolloClient","DeleteFolderGqlGateway","DeleteFolder","useFoldersType","useDeleteFolder","client","type","gateway","deleteFolder","params","instance","getInstance","execute"],"sources":["useDeleteFolder.ts"],"sourcesContent":["import { useCallback } from \"react\";\nimport { useApolloClient } from \"@apollo/react-hooks\";\nimport { DeleteFolderGqlGateway } from \"./DeleteFolderGqlGateway\";\nimport type { DeleteFolderParams } from \"./IDeleteFolderUseCase\";\nimport { DeleteFolder } from \"./DeleteFolder\";\nimport { useFoldersType } from \"~/hooks\";\n\nexport const useDeleteFolder = () => {\n    const client = useApolloClient();\n    const type = useFoldersType();\n    const gateway = new DeleteFolderGqlGateway(client);\n\n    const deleteFolder = useCallback(\n        (params: DeleteFolderParams) => {\n            const instance = DeleteFolder.getInstance(type, gateway);\n            return instance.execute(params);\n        },\n        [type, gateway]\n    );\n\n    return {\n        deleteFolder\n    };\n};\n"],"mappings":"AAAA,SAASA,WAAW,QAAQ,OAAO;AACnC,SAASC,eAAe,QAAQ,qBAAqB;AACrD,SAASC,sBAAsB;AAE/B,SAASC,YAAY;AACrB,SAASC,cAAc;AAEvB,OAAO,MAAMC,eAAe,GAAGA,CAAA,KAAM;EACjC,MAAMC,MAAM,GAAGL,eAAe,CAAC,CAAC;EAChC,MAAMM,IAAI,GAAGH,cAAc,CAAC,CAAC;EAC7B,MAAMI,OAAO,GAAG,IAAIN,sBAAsB,CAACI,MAAM,CAAC;EAElD,MAAMG,YAAY,GAAGT,WAAW,CAC3BU,MAA0B,IAAK;IAC5B,MAAMC,QAAQ,GAAGR,YAAY,CAACS,WAAW,CAACL,IAAI,EAAEC,OAAO,CAAC;IACxD,OAAOG,QAAQ,CAACE,OAAO,CAACH,MAAM,CAAC;EACnC,CAAC,EACD,CAACH,IAAI,EAAEC,OAAO,CAClB,CAAC;EAED,OAAO;IACHC;EACJ,CAAC;AACL,CAAC","ignoreList":[]}
+{"version":3,"file":"features/folders/deleteFolder/useDeleteFolder.js","sources":["../../../../src/features/folders/deleteFolder/useDeleteFolder.ts"],"sourcesContent":["import { useFeature } from \"@webiny/app\";\nimport { DeleteFolderFeature } from \"./feature.js\";\n\nexport const useDeleteFolder = () => {\n    const { useCase } = useFeature(DeleteFolderFeature);\n\n    return {\n        deleteFolder: (id: string) => {\n            return useCase.execute(id);\n        }\n    };\n};\n"],"names":["useDeleteFolder","useCase","useFeature","DeleteFolderFeature","id"],"mappings":";;AAGO,MAAMA,kBAAkB;IAC3B,MAAM,EAAEC,OAAO,EAAE,GAAGC,WAAWC;IAE/B,OAAO;QACH,cAAc,CAACC,KACJH,QAAQ,OAAO,CAACG;IAE/B;AACJ"}

package/features/folders/feature.d.ts

@@ -0,0 +1 @@
+export declare const FoldersFeature: import("@webiny/feature/admin").FeatureDefinition<any, [context: import("./abstractions.js").IFoldersContext]>;

package/features/folders/feature.js

@@ -0,0 +1,39 @@
+import { loadingRepositoryFactory } from "@webiny/app-utils";
+import { createFeature } from "@webiny/feature/admin";
+import { folderCacheFactory, loadedFolderCacheFactory } from "./cache/index.js";
+import { GetDescendantFoldersFeature } from "./getDescendantFolders/feature.js";
+import { GetFolderAncestorsFeature } from "./getFolderAncestors/feature.js";
+import { GetFolderExtensionsFieldsFeature } from "./getFolderExtensionsFields/feature.js";
+import { GetFolderLevelPermissionFeature } from "./getFolderLevelPermission/feature.js";
+import { ListFoldersFeature } from "./listFolders/feature.js";
+import { ListFoldersByParentIdsFeature } from "./listFoldersByParentIds/feature.js";
+import { LoadFolderHierarchyFeature } from "./loadFolderHierarchy/feature.js";
+import { FoldersCache, FoldersContext, FoldersLoadingRepository, LoadedFoldersCache } from "./abstractions.js";
+import { DeleteFolderFeature } from "./deleteFolder/feature.js";
+import { CreateFolderFeature } from "./createFolder/feature.js";
+import { GetFolderFeature } from "./getFolder/feature.js";
+import { UpdateFolderFeature } from "./updateFolder/feature.js";
+const FoldersFeature = createFeature({
+    name: "Folders",
+    register (container, context) {
+        container.registerInstance(FoldersContext, context);
+        container.registerInstance(FoldersCache, folderCacheFactory.getCache(context.type));
+        container.registerInstance(LoadedFoldersCache, loadedFolderCacheFactory.getCache(context.type));
+        const loadingRepository = loadingRepositoryFactory.getRepository(context.type);
+        container.registerInstance(FoldersLoadingRepository, loadingRepository);
+        CreateFolderFeature.register(container);
+        UpdateFolderFeature.register(container);
+        DeleteFolderFeature.register(container);
+        GetFolderFeature.register(container);
+        GetDescendantFoldersFeature.register(container);
+        GetFolderAncestorsFeature.register(container);
+        GetFolderExtensionsFieldsFeature.register(container);
+        GetFolderLevelPermissionFeature.register(container);
+        LoadFolderHierarchyFeature.register(container);
+        ListFoldersFeature.register(container);
+        ListFoldersByParentIdsFeature.register(container);
+    }
+});
+export { FoldersFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/folders/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folders/feature.js","sources":["../../../src/features/folders/feature.ts"],"sourcesContent":["import { loadingRepositoryFactory } from \"@webiny/app-utils\";\nimport { createFeature } from \"@webiny/feature/admin\";\nimport { loadedFolderCacheFactory } from \"~/features/folders/cache/index.js\";\nimport { folderCacheFactory } from \"~/features/folders/cache/index.js\";\nimport { GetDescendantFoldersFeature } from \"~/features/folders/getDescendantFolders/feature.js\";\nimport { GetFolderAncestorsFeature } from \"~/features/folders/getFolderAncestors/feature.js\";\nimport { GetFolderExtensionsFieldsFeature } from \"~/features/folders/getFolderExtensionsFields/feature.js\";\nimport { GetFolderLevelPermissionFeature } from \"~/features/folders/getFolderLevelPermission/feature.js\";\nimport { ListFoldersFeature } from \"~/features/folders/listFolders/feature.js\";\nimport { ListFoldersByParentIdsFeature } from \"~/features/folders/listFoldersByParentIds/feature.js\";\nimport { LoadFolderHierarchyFeature } from \"~/features/folders/loadFolderHierarchy/feature.js\";\nimport { LoadedFoldersCache } from \"./abstractions.js\";\nimport { FoldersCache } from \"./abstractions.js\";\nimport { FoldersContext } from \"./abstractions.js\";\nimport { FoldersLoadingRepository } from \"./abstractions.js\";\nimport { DeleteFolderFeature } from \"./deleteFolder/feature.js\";\nimport { CreateFolderFeature } from \"./createFolder/feature.js\";\nimport { GetFolderFeature } from \"./getFolder/feature.js\";\nimport { UpdateFolderFeature } from \"./updateFolder/feature.js\";\n\nexport const FoldersFeature = createFeature({\n    name: \"Folders\",\n    register(container, context: FoldersContext.Interface) {\n        // FoldersContext is used by other features to load the right folders type.\n        container.registerInstance(FoldersContext, context);\n\n        container.registerInstance(FoldersCache, folderCacheFactory.getCache(context.type));\n\n        container.registerInstance(\n            LoadedFoldersCache,\n            loadedFolderCacheFactory.getCache(context.type)\n        );\n\n        const loadingRepository = loadingRepositoryFactory.getRepository(context.type);\n        container.registerInstance(FoldersLoadingRepository, loadingRepository);\n\n        // Folders features\n        CreateFolderFeature.register(container);\n        UpdateFolderFeature.register(container);\n        DeleteFolderFeature.register(container);\n        GetFolderFeature.register(container);\n        GetDescendantFoldersFeature.register(container);\n        GetFolderAncestorsFeature.register(container);\n        GetFolderExtensionsFieldsFeature.register(container);\n        GetFolderLevelPermissionFeature.register(container);\n        LoadFolderHierarchyFeature.register(container);\n        ListFoldersFeature.register(container);\n        ListFoldersByParentIdsFeature.register(container);\n    }\n});\n"],"names":["FoldersFeature","createFeature","container","context","FoldersContext","FoldersCache","folderCacheFactory","LoadedFoldersCache","loadedFolderCacheFactory","loadingRepository","loadingRepositoryFactory","FoldersLoadingRepository","CreateFolderFeature","UpdateFolderFeature","DeleteFolderFeature","GetFolderFeature","GetDescendantFoldersFeature","GetFolderAncestorsFeature","GetFolderExtensionsFieldsFeature","GetFolderLevelPermissionFeature","LoadFolderHierarchyFeature","ListFoldersFeature","ListFoldersByParentIdsFeature"],"mappings":";;;;;;;;;;;;;;;AAoBO,MAAMA,iBAAiBC,cAAc;IACxC,MAAM;IACN,UAASC,SAAS,EAAEC,OAAiC;QAEjDD,UAAU,gBAAgB,CAACE,gBAAgBD;QAE3CD,UAAU,gBAAgB,CAACG,cAAcC,mBAAmB,QAAQ,CAACH,QAAQ,IAAI;QAEjFD,UAAU,gBAAgB,CACtBK,oBACAC,yBAAyB,QAAQ,CAACL,QAAQ,IAAI;QAGlD,MAAMM,oBAAoBC,yBAAyB,aAAa,CAACP,QAAQ,IAAI;QAC7ED,UAAU,gBAAgB,CAACS,0BAA0BF;QAGrDG,oBAAoB,QAAQ,CAACV;QAC7BW,oBAAoB,QAAQ,CAACX;QAC7BY,oBAAoB,QAAQ,CAACZ;QAC7Ba,iBAAiB,QAAQ,CAACb;QAC1Bc,4BAA4B,QAAQ,CAACd;QACrCe,0BAA0B,QAAQ,CAACf;QACnCgB,iCAAiC,QAAQ,CAAChB;QAC1CiB,gCAAgC,QAAQ,CAACjB;QACzCkB,2BAA2B,QAAQ,CAAClB;QACpCmB,mBAAmB,QAAQ,CAACnB;QAC5BoB,8BAA8B,QAAQ,CAACpB;IAC3C;AACJ"}

package/features/folders/folderEvents/AddCreatedFolderToCache.d.ts

@@ -0,0 +1,22 @@
+import { GetFolderGateway } from "../../../features/folders/getFolder/abstractions.js";
+import { FolderCreatedEventHandler } from "./abstractions.js";
+/**
+ * Reads the folder back and puts it in the cache for its type, so every open folder tree of that
+ * type shows it.
+ *
+ * Read back rather than taken from the event, so the folder has the same fields and the same
+ * permission checks as any other the admin loads. `addItems` replaces by id, so an event that
+ * arrives twice, or for a folder already loaded, changes nothing.
+ *
+ * The cache is reached through `folderCacheFactory` rather than injected, because this runs in the
+ * root container and each folder type's cache is registered in its own view's child container.
+ */
+declare class AddCreatedFolderToCacheImpl implements FolderCreatedEventHandler.Interface {
+    private getFolder;
+    constructor(getFolder: GetFolderGateway.Interface);
+    handle(event: FolderCreatedEventHandler.Event): Promise<void>;
+}
+export declare const AddCreatedFolderToCache: typeof AddCreatedFolderToCacheImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/app/features/eventPublisher/abstractions.js").IEventHandler<import("./FolderCreatedEvent.js").FolderCreatedEvent>>;
+};
+export {};

package/features/folders/folderEvents/AddCreatedFolderToCache.js

@@ -0,0 +1,24 @@
+import { GetFolderGateway } from "../getFolder/abstractions.js";
+import { folderCacheFactory } from "../cache/index.js";
+import { Folder } from "../../../domain/folder/Folder.js";
+import { FolderCreatedEventHandler } from "./abstractions.js";
+class AddCreatedFolderToCacheImpl {
+    constructor(getFolder){
+        this.getFolder = getFolder;
+    }
+    async handle(event) {
+        const folder = Folder.create(await this.getFolder.execute(event.payload.id));
+        folderCacheFactory.getCache(folder.type).addItems([
+            folder
+        ]);
+    }
+}
+const AddCreatedFolderToCache = FolderCreatedEventHandler.createImplementation({
+    implementation: AddCreatedFolderToCacheImpl,
+    dependencies: [
+        GetFolderGateway
+    ]
+});
+export { AddCreatedFolderToCache };
+
+//# sourceMappingURL=AddCreatedFolderToCache.js.map

package/features/folders/folderEvents/AddCreatedFolderToCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folders/folderEvents/AddCreatedFolderToCache.js","sources":["../../../../src/features/folders/folderEvents/AddCreatedFolderToCache.ts"],"sourcesContent":["import { GetFolderGateway } from \"~/features/folders/getFolder/abstractions.js\";\nimport { folderCacheFactory } from \"~/features/folders/cache/index.js\";\nimport { Folder } from \"~/domain/folder/Folder.js\";\nimport { FolderCreatedEventHandler } from \"./abstractions.js\";\n\n/**\n * Reads the folder back and puts it in the cache for its type, so every open folder tree of that\n * type shows it.\n *\n * Read back rather than taken from the event, so the folder has the same fields and the same\n * permission checks as any other the admin loads. `addItems` replaces by id, so an event that\n * arrives twice, or for a folder already loaded, changes nothing.\n *\n * The cache is reached through `folderCacheFactory` rather than injected, because this runs in the\n * root container and each folder type's cache is registered in its own view's child container.\n */\nclass AddCreatedFolderToCacheImpl implements FolderCreatedEventHandler.Interface {\n    constructor(private getFolder: GetFolderGateway.Interface) {}\n\n    async handle(event: FolderCreatedEventHandler.Event): Promise<void> {\n        const folder = Folder.create(await this.getFolder.execute(event.payload.id));\n\n        folderCacheFactory.getCache(folder.type).addItems([folder]);\n    }\n}\n\nexport const AddCreatedFolderToCache = FolderCreatedEventHandler.createImplementation({\n    implementation: AddCreatedFolderToCacheImpl,\n    dependencies: [GetFolderGateway]\n});\n"],"names":["AddCreatedFolderToCacheImpl","getFolder","event","folder","Folder","folderCacheFactory","AddCreatedFolderToCache","FolderCreatedEventHandler","GetFolderGateway"],"mappings":";;;;AAgBA,MAAMA;IACF,YAAoBC,SAAqC,CAAE;aAAvCA,SAAS,GAATA;IAAwC;IAE5D,MAAM,OAAOC,KAAsC,EAAiB;QAChE,MAAMC,SAASC,OAAO,MAAM,CAAC,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACF,MAAM,OAAO,CAAC,EAAE;QAE1EG,mBAAmB,QAAQ,CAACF,OAAO,IAAI,EAAE,QAAQ,CAAC;YAACA;SAAO;IAC9D;AACJ;AAEO,MAAMG,0BAA0BC,0BAA0B,oBAAoB,CAAC;IAClF,gBAAgBP;IAChB,cAAc;QAACQ;KAAiB;AACpC"}

package/features/folders/folderEvents/FolderCreatedEvent.d.ts

@@ -0,0 +1,14 @@
+import { BaseEvent } from "@webiny/app/features/eventPublisher/index.js";
+export interface FolderCreatedPayload {
+    id: string;
+}
+/**
+ * A folder now exists that the admin's cache may not have.
+ *
+ * Deliberately says nothing about where the news came from. The websocket is one source today; the
+ * palette or a background task can publish the same event, and the handlers do not change.
+ */
+export declare class FolderCreatedEvent extends BaseEvent<FolderCreatedPayload> {
+    readonly eventType: "Aco/FolderCreated";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("@webiny/app/features/eventPublisher/abstractions.js").IEventHandler<FolderCreatedEvent>>;
+}

package/features/folders/folderEvents/FolderCreatedEvent.js

@@ -0,0 +1,13 @@
+import { BaseEvent } from "@webiny/app/features/eventPublisher/index.js";
+import { FolderCreatedEventHandler } from "./abstractions.js";
+class FolderCreatedEvent extends BaseEvent {
+    getHandlerAbstraction() {
+        return FolderCreatedEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Aco/FolderCreated";
+    }
+}
+export { FolderCreatedEvent };
+
+//# sourceMappingURL=FolderCreatedEvent.js.map

package/features/folders/folderEvents/FolderCreatedEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folders/folderEvents/FolderCreatedEvent.js","sources":["../../../../src/features/folders/folderEvents/FolderCreatedEvent.ts"],"sourcesContent":["import { BaseEvent } from \"@webiny/app/features/eventPublisher/index.js\";\nimport { FolderCreatedEventHandler } from \"./abstractions.js\";\n\nexport interface FolderCreatedPayload {\n    id: string;\n}\n\n/**\n * A folder now exists that the admin's cache may not have.\n *\n * Deliberately says nothing about where the news came from. The websocket is one source today; the\n * palette or a background task can publish the same event, and the handlers do not change.\n */\nexport class FolderCreatedEvent extends BaseEvent<FolderCreatedPayload> {\n    readonly eventType = \"Aco/FolderCreated\" as const;\n\n    getHandlerAbstraction() {\n        return FolderCreatedEventHandler;\n    }\n}\n"],"names":["FolderCreatedEvent","BaseEvent","FolderCreatedEventHandler"],"mappings":";;AAaO,MAAMA,2BAA2BC;IAGpC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACM,SAAS,GAAG;;AAKzB"}

package/features/folders/folderEvents/FolderDeletedEvent.d.ts

@@ -0,0 +1,9 @@
+import { BaseEvent } from "@webiny/app/features/eventPublisher/index.js";
+export interface FolderDeletedPayload {
+    id: string;
+}
+/** A folder no longer exists, and the admin's cache may still hold it. */
+export declare class FolderDeletedEvent extends BaseEvent<FolderDeletedPayload> {
+    readonly eventType: "Aco/FolderDeleted";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("@webiny/app/features/eventPublisher/abstractions.js").IEventHandler<FolderDeletedEvent>>;
+}

package/features/folders/folderEvents/FolderDeletedEvent.js

@@ -0,0 +1,13 @@
+import { BaseEvent } from "@webiny/app/features/eventPublisher/index.js";
+import { FolderDeletedEventHandler } from "./abstractions.js";
+class FolderDeletedEvent extends BaseEvent {
+    getHandlerAbstraction() {
+        return FolderDeletedEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Aco/FolderDeleted";
+    }
+}
+export { FolderDeletedEvent };
+
+//# sourceMappingURL=FolderDeletedEvent.js.map

package/features/folders/folderEvents/FolderDeletedEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folders/folderEvents/FolderDeletedEvent.js","sources":["../../../../src/features/folders/folderEvents/FolderDeletedEvent.ts"],"sourcesContent":["import { BaseEvent } from \"@webiny/app/features/eventPublisher/index.js\";\nimport { FolderDeletedEventHandler } from \"./abstractions.js\";\n\nexport interface FolderDeletedPayload {\n    id: string;\n}\n\n/** A folder no longer exists, and the admin's cache may still hold it. */\nexport class FolderDeletedEvent extends BaseEvent<FolderDeletedPayload> {\n    readonly eventType = \"Aco/FolderDeleted\" as const;\n\n    getHandlerAbstraction() {\n        return FolderDeletedEventHandler;\n    }\n}\n"],"names":["FolderDeletedEvent","BaseEvent","FolderDeletedEventHandler"],"mappings":";;AAQO,MAAMA,2BAA2BC;IAGpC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACM,SAAS,GAAG;;AAKzB"}