@webiny/api-file-manager-s3 0.0.0-unstable.eb196ccd2f → 0.0.0-unstable.eb81deee7e

package/enterprise/ApplyThreatScanning/CreateFileWithThreatScanDecorator.js

@@ -0,0 +1,28 @@
+import { CreateFileUseCase } from "@webiny/api-file-manager/features/file/CreateFile/abstractions.js";
+import { FeatureFlags } from "@webiny/api-core/features/featureFlags/abstractions.js";
+class CreateFileWithThreatScanDecoratorImpl {
+    constructor(featureFlags, decoratee){
+        this.featureFlags = featureFlags;
+        this.decoratee = decoratee;
+    }
+    async execute(input, meta) {
+        if (!this.featureFlags.get().isEnabled("fileManager.threatDetection")) return this.decoratee.execute(input, meta);
+        const modifiedInput = {
+            ...input,
+            tags: [
+                ...input.tags || [],
+                "threatScanInProgress"
+            ]
+        };
+        return this.decoratee.execute(modifiedInput, meta);
+    }
+}
+const CreateFileWithThreatScanDecorator = CreateFileUseCase.createDecorator({
+    decorator: CreateFileWithThreatScanDecoratorImpl,
+    dependencies: [
+        FeatureFlags
+    ]
+});
+export { CreateFileWithThreatScanDecorator };
+
+//# sourceMappingURL=CreateFileWithThreatScanDecorator.js.map

package/enterprise/ApplyThreatScanning/CreateFileWithThreatScanDecorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enterprise/ApplyThreatScanning/CreateFileWithThreatScanDecorator.js","sources":["../../../src/enterprise/ApplyThreatScanning/CreateFileWithThreatScanDecorator.ts"],"sourcesContent":["import { CreateFileUseCase } from \"@webiny/api-file-manager/features/file/CreateFile/abstractions.js\";\nimport type { CreateFileInput } from \"@webiny/api-file-manager/features/file/CreateFile/abstractions.js\";\nimport { FeatureFlags } from \"@webiny/api-core/features/featureFlags/abstractions.js\";\n\nclass CreateFileWithThreatScanDecoratorImpl implements CreateFileUseCase.Interface {\n    constructor(\n        private featureFlags: FeatureFlags.Interface,\n        private decoratee: CreateFileUseCase.Interface\n    ) {}\n\n    async execute(\n        input: CreateFileInput,\n        meta?: Record<string, any>\n    ): ReturnType<CreateFileUseCase.Interface[\"execute\"]> {\n        if (!this.featureFlags.get().isEnabled(\"fileManager.threatDetection\")) {\n            return this.decoratee.execute(input, meta);\n        }\n\n        const modifiedInput: CreateFileInput = {\n            ...input,\n            tags: [...(input.tags || []), \"threatScanInProgress\"]\n        };\n\n        return this.decoratee.execute(modifiedInput, meta);\n    }\n}\n\nexport const CreateFileWithThreatScanDecorator = CreateFileUseCase.createDecorator({\n    decorator: CreateFileWithThreatScanDecoratorImpl,\n    dependencies: [FeatureFlags]\n});\n"],"names":["CreateFileWithThreatScanDecoratorImpl","featureFlags","decoratee","input","meta","modifiedInput","CreateFileWithThreatScanDecorator","CreateFileUseCase","FeatureFlags"],"mappings":";;AAIA,MAAMA;IACF,YACYC,YAAoC,EACpCC,SAAsC,CAChD;aAFUD,YAAY,GAAZA;aACAC,SAAS,GAATA;IACT;IAEH,MAAM,QACFC,KAAsB,EACtBC,IAA0B,EACwB;QAClD,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,GAAG,SAAS,CAAC,gCACnC,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAACD,OAAOC;QAGzC,MAAMC,gBAAiC;YACnC,GAAGF,KAAK;YACR,MAAM;mBAAKA,MAAM,IAAI,IAAI,EAAE;gBAAG;aAAuB;QACzD;QAEA,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAACE,eAAeD;IACjD;AACJ;AAEO,MAAME,oCAAoCC,kBAAkB,eAAe,CAAC;IAC/E,WAAWP;IACX,cAAc;QAACQ;KAAa;AAChC"}

package/enterprise/ApplyThreatScanning/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const ApplyThreatScanningFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/enterprise/ApplyThreatScanning/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { CreateFileWithThreatScanDecorator } from "./CreateFileWithThreatScanDecorator.js";
+const ApplyThreatScanningFeature = createFeature({
+    name: "FileManagerS3/ApplyThreatScanning",
+    register (container) {
+        container.registerDecorator(CreateFileWithThreatScanDecorator);
+    }
+});
+export { ApplyThreatScanningFeature };
+
+//# sourceMappingURL=feature.js.map

package/enterprise/ApplyThreatScanning/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enterprise/ApplyThreatScanning/feature.js","sources":["../../../src/enterprise/ApplyThreatScanning/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CreateFileWithThreatScanDecorator } from \"./CreateFileWithThreatScanDecorator.js\";\n\nexport const ApplyThreatScanningFeature = createFeature({\n    name: \"FileManagerS3/ApplyThreatScanning\",\n    register(container) {\n        container.registerDecorator(CreateFileWithThreatScanDecorator);\n    }\n});\n"],"names":["ApplyThreatScanningFeature","createFeature","container","CreateFileWithThreatScanDecorator"],"mappings":";;AAGO,MAAMA,6BAA6BC,cAAc;IACpD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,iBAAiB,CAACC;IAChC;AACJ"}

package/features/DeleteFileFromBucket/DeleteFileFromBucketHandler.d.ts

@@ -0,0 +1,15 @@
+import { FileAfterDeleteEventHandler } from "@webiny/api-file-manager/features/file/DeleteFile/events.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import { GlobalKeyValueStore } from "@webiny/api-core/features/keyValueStore/index.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+declare class DeleteFileFromBucketHandlerImpl implements FileAfterDeleteEventHandler.Interface {
+    private tenantContext;
+    private taskService;
+    private keyValueStore;
+    constructor(tenantContext: TenantContext.Interface, taskService: TaskService.Interface, keyValueStore: GlobalKeyValueStore.Interface);
+    handle(event: FileAfterDeleteEventHandler.Event): Promise<void>;
+}
+export declare const DeleteFileFromBucketHandler: typeof DeleteFileFromBucketHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-file-manager/features/file/DeleteFile/events.js").FileAfterDeleteEvent>>;
+};
+export {};

package/features/DeleteFileFromBucket/DeleteFileFromBucketHandler.js

@@ -0,0 +1,35 @@
+import { FileAfterDeleteEventHandler } from "@webiny/api-file-manager/features/file/DeleteFile/events.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import { GlobalKeyValueStore } from "@webiny/api-core/features/keyValueStore/index.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+class DeleteFileFromBucketHandlerImpl {
+    constructor(tenantContext, taskService, keyValueStore){
+        this.tenantContext = tenantContext;
+        this.taskService = taskService;
+        this.keyValueStore = keyValueStore;
+    }
+    async handle(event) {
+        const { file } = event.payload;
+        const tenant = this.tenantContext.getTenant();
+        await this.taskService.trigger({
+            definition: "fileManagerFolderDelete",
+            input: {
+                caller: "fm-after-delete",
+                bucket: String(process.env.S3_BUCKET),
+                folderKey: `tenants/${tenant.id}/files/${file.id}`
+            }
+        });
+        await this.keyValueStore.delete(`FileManager/File/${file.id}/Metadata`);
+    }
+}
+const DeleteFileFromBucketHandler = FileAfterDeleteEventHandler.createImplementation({
+    implementation: DeleteFileFromBucketHandlerImpl,
+    dependencies: [
+        TenantContext,
+        TaskService,
+        GlobalKeyValueStore
+    ]
+});
+export { DeleteFileFromBucketHandler };
+
+//# sourceMappingURL=DeleteFileFromBucketHandler.js.map

package/features/DeleteFileFromBucket/DeleteFileFromBucketHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/DeleteFileFromBucket/DeleteFileFromBucketHandler.js","sources":["../../../src/features/DeleteFileFromBucket/DeleteFileFromBucketHandler.ts"],"sourcesContent":["import { FileAfterDeleteEventHandler } from \"@webiny/api-file-manager/features/file/DeleteFile/events.js\";\nimport { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport { GlobalKeyValueStore } from \"@webiny/api-core/features/keyValueStore/index.js\";\nimport type { DeleteS3FolderInput } from \"~/features/DeleteFileFromBucket/DeleteS3FolderTask.js\";\nimport { TenantContext } from \"@webiny/api-core/features/tenancy/TenantContext/index.js\";\n\nclass DeleteFileFromBucketHandlerImpl implements FileAfterDeleteEventHandler.Interface {\n    constructor(\n        private tenantContext: TenantContext.Interface,\n        private taskService: TaskService.Interface,\n        private keyValueStore: GlobalKeyValueStore.Interface\n    ) {}\n\n    async handle(event: FileAfterDeleteEventHandler.Event): Promise<void> {\n        const { file } = event.payload;\n        const tenant = this.tenantContext.getTenant();\n\n        // Delete S3 folder recursively\n        await this.taskService.trigger<DeleteS3FolderInput>({\n            definition: \"fileManagerFolderDelete\",\n            input: {\n                caller: \"fm-after-delete\",\n                bucket: String(process.env.S3_BUCKET),\n                folderKey: `tenants/${tenant.id}/files/${file.id}`\n            }\n        });\n\n        // Delete file metadata\n        await this.keyValueStore.delete(`FileManager/File/${file.id}/Metadata`);\n    }\n}\n\nexport const DeleteFileFromBucketHandler = FileAfterDeleteEventHandler.createImplementation({\n    implementation: DeleteFileFromBucketHandlerImpl,\n    dependencies: [TenantContext, TaskService, GlobalKeyValueStore]\n});\n"],"names":["DeleteFileFromBucketHandlerImpl","tenantContext","taskService","keyValueStore","event","file","tenant","String","process","DeleteFileFromBucketHandler","FileAfterDeleteEventHandler","TenantContext","TaskService","GlobalKeyValueStore"],"mappings":";;;;AAMA,MAAMA;IACF,YACYC,aAAsC,EACtCC,WAAkC,EAClCC,aAA4C,CACtD;aAHUF,aAAa,GAAbA;aACAC,WAAW,GAAXA;aACAC,aAAa,GAAbA;IACT;IAEH,MAAM,OAAOC,KAAwC,EAAiB;QAClE,MAAM,EAAEC,IAAI,EAAE,GAAGD,MAAM,OAAO;QAC9B,MAAME,SAAS,IAAI,CAAC,aAAa,CAAC,SAAS;QAG3C,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAsB;YAChD,YAAY;YACZ,OAAO;gBACH,QAAQ;gBACR,QAAQC,OAAOC,QAAQ,GAAG,CAAC,SAAS;gBACpC,WAAW,CAAC,QAAQ,EAAEF,OAAO,EAAE,CAAC,OAAO,EAAED,KAAK,EAAE,EAAE;YACtD;QACJ;QAGA,MAAM,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,iBAAiB,EAAEA,KAAK,EAAE,CAAC,SAAS,CAAC;IAC1E;AACJ;AAEO,MAAMI,8BAA8BC,4BAA4B,oBAAoB,CAAC;IACxF,gBAAgBV;IAChB,cAAc;QAACW;QAAeC;QAAaC;KAAoB;AACnE"}

package/features/DeleteFileFromBucket/DeleteS3FolderTask.d.ts

@@ -0,0 +1,37 @@
+import { TaskDefinition, TaskHandler } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+export interface DeleteS3FolderInput {
+    /**
+     * Caller of the task (e.g., `fm-after-delete`).
+     */
+    caller: string;
+    /**
+     * Cache paths to invalidate.
+     */
+    bucket: string;
+    /**
+     * FM file directory key to delete.
+     */
+    folderKey: string;
+    /**
+     * Continuation token for pagination.
+     */
+    continuationToken?: string;
+}
+declare class DeleteS3FolderTaskHandlerImpl implements TaskHandler.Interface<DeleteS3FolderInput> {
+    run({ input, controller }: TaskHandler.RunParams<DeleteS3FolderInput>): Promise<TaskDefinition.Result<DeleteS3FolderInput>>;
+}
+declare class DeleteS3FolderTask implements TaskDefinition.Interface {
+    id: string;
+    title: string;
+    description: string;
+    maxIterations: number;
+    isPrivate: boolean;
+    readonly selfCleanup: ("onAbort" | "onSuccess")[];
+    handler: typeof DeleteS3FolderTaskHandlerImpl & {
+        __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskHandler<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput>>;
+    };
+}
+export declare const DeleteS3FolderTaskDefinition: typeof DeleteS3FolderTask & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskDefinition<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput>>;
+};
+export {};

package/features/DeleteFileFromBucket/DeleteS3FolderTask.js

@@ -0,0 +1,57 @@
+import { S3 } from "@webiny/aws-sdk/client-s3/index.js";
+import { TaskDefinition, TaskHandler } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+class DeleteS3FolderTaskHandlerImpl {
+    async run({ input, controller }) {
+        if (controller.runtime.isAborted()) return controller.response.aborted();
+        if (!input.bucket) return controller.response.error({
+            message: "Bucket is not defined."
+        });
+        const s3 = new S3();
+        const filesList = await s3.listObjectsV2({
+            Bucket: input.bucket,
+            Prefix: `${input.folderKey}/`,
+            ContinuationToken: input.continuationToken
+        });
+        if (filesList.Contents && filesList.Contents.length > 0) {
+            const objectsToDelete = filesList.Contents.filter((file)=>file.Key).map((file)=>({
+                    Key: file.Key
+                }));
+            if (objectsToDelete.length > 0) await s3.deleteObjects({
+                Bucket: input.bucket,
+                Delete: {
+                    Objects: objectsToDelete
+                }
+            });
+        }
+        if (filesList.IsTruncated && filesList.NextContinuationToken) return controller.response.continue({
+            ...input,
+            continuationToken: filesList.NextContinuationToken
+        });
+        return controller.response.done();
+    }
+}
+const DeleteS3FolderTaskHandler = TaskHandler.createImplementation({
+    implementation: DeleteS3FolderTaskHandlerImpl,
+    dependencies: []
+});
+class DeleteS3FolderTask {
+    constructor(){
+        this.id = "fileManagerFolderDelete";
+        this.title = "Delete folder and all of its contents from the bucket.";
+        this.description = "A task to delete all files from a given folder.";
+        this.maxIterations = 5;
+        this.isPrivate = true;
+        this.selfCleanup = [
+            "onSuccess",
+            "onAbort"
+        ];
+        this.handler = DeleteS3FolderTaskHandler;
+    }
+}
+const DeleteS3FolderTaskDefinition = TaskDefinition.createImplementation({
+    implementation: DeleteS3FolderTask,
+    dependencies: []
+});
+export { DeleteS3FolderTaskDefinition };
+
+//# sourceMappingURL=DeleteS3FolderTask.js.map

package/features/DeleteFileFromBucket/DeleteS3FolderTask.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/DeleteFileFromBucket/DeleteS3FolderTask.js","sources":["../../../src/features/DeleteFileFromBucket/DeleteS3FolderTask.ts"],"sourcesContent":["import { S3 } from \"@webiny/aws-sdk/client-s3/index.js\";\nimport {\n    TaskDefinition,\n    TaskHandler\n} from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\n\nexport interface DeleteS3FolderInput {\n    /**\n     * Caller of the task (e.g., `fm-after-delete`).\n     */\n    caller: string;\n    /**\n     * Cache paths to invalidate.\n     */\n    bucket: string;\n    /**\n     * FM file directory key to delete.\n     */\n    folderKey: string;\n    /**\n     * Continuation token for pagination.\n     */\n    continuationToken?: string;\n}\n\nclass DeleteS3FolderTaskHandlerImpl implements TaskHandler.Interface<DeleteS3FolderInput> {\n    public async run({\n        input,\n        controller\n    }: TaskHandler.RunParams<DeleteS3FolderInput>): Promise<\n        TaskDefinition.Result<DeleteS3FolderInput>\n    > {\n        if (controller.runtime.isAborted()) {\n            return controller.response.aborted();\n        }\n\n        if (!input.bucket) {\n            return controller.response.error({ message: `Bucket is not defined.` });\n        }\n\n        const s3 = new S3();\n\n        // List objects in the folder with pagination support.\n        const filesList = await s3.listObjectsV2({\n            Bucket: input.bucket,\n            Prefix: `${input.folderKey}/`,\n            ContinuationToken: input.continuationToken\n        });\n\n        // Delete all files in the folder using batch delete.\n        if (filesList.Contents && filesList.Contents.length > 0) {\n            const objectsToDelete = filesList.Contents.filter(file => file.Key).map(file => ({\n                Key: file.Key!\n            }));\n\n            if (objectsToDelete.length > 0) {\n                await s3.deleteObjects({\n                    Bucket: input.bucket,\n                    Delete: {\n                        Objects: objectsToDelete\n                    }\n                });\n            }\n        }\n\n        // If there are more objects to delete, continue in the next iteration.\n        if (filesList.IsTruncated && filesList.NextContinuationToken) {\n            return controller.response.continue({\n                ...input,\n                continuationToken: filesList.NextContinuationToken\n            });\n        }\n\n        return controller.response.done();\n    }\n}\n\nconst DeleteS3FolderTaskHandler = TaskHandler.createImplementation({\n    implementation: DeleteS3FolderTaskHandlerImpl,\n    dependencies: []\n});\n\nclass DeleteS3FolderTask implements TaskDefinition.Interface {\n    id = \"fileManagerFolderDelete\";\n    title = \"Delete folder and all of its contents from the bucket.\";\n    description = \"A task to delete all files from a given folder.\";\n    maxIterations = 5;\n    isPrivate = true;\n    public readonly selfCleanup = [\"onSuccess\" as const, \"onAbort\" as const];\n\n    handler = DeleteS3FolderTaskHandler;\n}\n\nexport const DeleteS3FolderTaskDefinition = TaskDefinition.createImplementation({\n    implementation: DeleteS3FolderTask,\n    dependencies: []\n});\n"],"names":["DeleteS3FolderTaskHandlerImpl","input","controller","s3","S3","filesList","objectsToDelete","file","DeleteS3FolderTaskHandler","TaskHandler","DeleteS3FolderTask","DeleteS3FolderTaskDefinition","TaskDefinition"],"mappings":";;AAyBA,MAAMA;IACF,MAAa,IAAI,EACbC,KAAK,EACLC,UAAU,EAC+B,EAE3C;QACE,IAAIA,WAAW,OAAO,CAAC,SAAS,IAC5B,OAAOA,WAAW,QAAQ,CAAC,OAAO;QAGtC,IAAI,CAACD,MAAM,MAAM,EACb,OAAOC,WAAW,QAAQ,CAAC,KAAK,CAAC;YAAE,SAAS;QAAyB;QAGzE,MAAMC,KAAK,IAAIC;QAGf,MAAMC,YAAY,MAAMF,GAAG,aAAa,CAAC;YACrC,QAAQF,MAAM,MAAM;YACpB,QAAQ,GAAGA,MAAM,SAAS,CAAC,CAAC,CAAC;YAC7B,mBAAmBA,MAAM,iBAAiB;QAC9C;QAGA,IAAII,UAAU,QAAQ,IAAIA,UAAU,QAAQ,CAAC,MAAM,GAAG,GAAG;YACrD,MAAMC,kBAAkBD,UAAU,QAAQ,CAAC,MAAM,CAACE,CAAAA,OAAQA,KAAK,GAAG,EAAE,GAAG,CAACA,CAAAA,OAAS;oBAC7E,KAAKA,KAAK,GAAG;gBACjB;YAEA,IAAID,gBAAgB,MAAM,GAAG,GACzB,MAAMH,GAAG,aAAa,CAAC;gBACnB,QAAQF,MAAM,MAAM;gBACpB,QAAQ;oBACJ,SAASK;gBACb;YACJ;QAER;QAGA,IAAID,UAAU,WAAW,IAAIA,UAAU,qBAAqB,EACxD,OAAOH,WAAW,QAAQ,CAAC,QAAQ,CAAC;YAChC,GAAGD,KAAK;YACR,mBAAmBI,UAAU,qBAAqB;QACtD;QAGJ,OAAOH,WAAW,QAAQ,CAAC,IAAI;IACnC;AACJ;AAEA,MAAMM,4BAA4BC,YAAY,oBAAoB,CAAC;IAC/D,gBAAgBT;IAChB,cAAc,EAAE;AACpB;AAEA,MAAMU;;aACF,EAAE,GAAG;aACL,KAAK,GAAG;aACR,WAAW,GAAG;aACd,aAAa,GAAG;aAChB,SAAS,GAAG;aACI,WAAW,GAAG;YAAC;YAAsB;SAAmB;aAExE,OAAO,GAAGF;;AACd;AAEO,MAAMG,+BAA+BC,eAAe,oBAAoB,CAAC;IAC5E,gBAAgBF;IAChB,cAAc,EAAE;AACpB"}

package/features/DeleteFileFromBucket/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const DeleteFileFromBucketFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/DeleteFileFromBucket/feature.js

@@ -0,0 +1,13 @@
+import { createFeature } from "@webiny/feature/api";
+import { DeleteFileFromBucketHandler } from "./DeleteFileFromBucketHandler.js";
+import { DeleteS3FolderTaskDefinition } from "./DeleteS3FolderTask.js";
+const DeleteFileFromBucketFeature = createFeature({
+    name: "FileManagerS3/DeleteFileFromBucket",
+    register (container) {
+        container.register(DeleteFileFromBucketHandler);
+        container.register(DeleteS3FolderTaskDefinition);
+    }
+});
+export { DeleteFileFromBucketFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/DeleteFileFromBucket/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/DeleteFileFromBucket/feature.js","sources":["../../../src/features/DeleteFileFromBucket/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { DeleteFileFromBucketHandler } from \"./DeleteFileFromBucketHandler.js\";\nimport { DeleteS3FolderTaskDefinition } from \"./DeleteS3FolderTask.js\";\n\nexport const DeleteFileFromBucketFeature = createFeature({\n    name: \"FileManagerS3/DeleteFileFromBucket\",\n    register(container) {\n        container.register(DeleteFileFromBucketHandler);\n        container.register(DeleteS3FolderTaskDefinition);\n    }\n});\n"],"names":["DeleteFileFromBucketFeature","createFeature","container","DeleteFileFromBucketHandler","DeleteS3FolderTaskDefinition"],"mappings":";;;AAIO,MAAMA,8BAA8BC,cAAc;IACrD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;IACvB;AACJ"}

package/features/ExtractMetadata/ExtractMetadataHandler.d.ts

@@ -0,0 +1,11 @@
+import { FileAfterCreateEventHandler } from "@webiny/api-file-manager/features/file/CreateFile/events.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+declare class ExtractMetadataHandlerImpl implements FileAfterCreateEventHandler.Interface {
+    private taskService;
+    constructor(taskService: TaskService.Interface);
+    handle(event: FileAfterCreateEventHandler.Event): Promise<void>;
+}
+export declare const ExtractMetadataHandler: typeof ExtractMetadataHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher/abstractions.js").IEventHandler<import("@webiny/api-file-manager/features/file/CreateFile/events.js").FileAfterCreateEvent>>;
+};
+export {};

package/features/ExtractMetadata/ExtractMetadataHandler.js

@@ -0,0 +1,25 @@
+import { FileAfterCreateEventHandler } from "@webiny/api-file-manager/features/file/CreateFile/events.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+class ExtractMetadataHandlerImpl {
+    constructor(taskService){
+        this.taskService = taskService;
+    }
+    async handle(event) {
+        const { file } = event.payload;
+        await this.taskService.trigger({
+            definition: "fileManagerExtractMetadata",
+            input: {
+                fileId: file.id
+            }
+        });
+    }
+}
+const ExtractMetadataHandler = FileAfterCreateEventHandler.createImplementation({
+    implementation: ExtractMetadataHandlerImpl,
+    dependencies: [
+        TaskService
+    ]
+});
+export { ExtractMetadataHandler };
+
+//# sourceMappingURL=ExtractMetadataHandler.js.map

package/features/ExtractMetadata/ExtractMetadataHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ExtractMetadata/ExtractMetadataHandler.js","sources":["../../../src/features/ExtractMetadata/ExtractMetadataHandler.ts"],"sourcesContent":["import { FileAfterCreateEventHandler } from \"@webiny/api-file-manager/features/file/CreateFile/events.js\";\nimport { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport type { ExtractMetadataInput } from \"./ExtractMetadataTask.js\";\n\nclass ExtractMetadataHandlerImpl implements FileAfterCreateEventHandler.Interface {\n    constructor(private taskService: TaskService.Interface) {}\n\n    async handle(event: FileAfterCreateEventHandler.Event): Promise<void> {\n        const { file } = event.payload;\n\n        // Trigger the metadata extraction task\n        await this.taskService.trigger<ExtractMetadataInput>({\n            definition: \"fileManagerExtractMetadata\",\n            input: {\n                fileId: file.id\n            }\n        });\n    }\n}\n\nexport const ExtractMetadataHandler = FileAfterCreateEventHandler.createImplementation({\n    implementation: ExtractMetadataHandlerImpl,\n    dependencies: [TaskService]\n});\n"],"names":["ExtractMetadataHandlerImpl","taskService","event","file","ExtractMetadataHandler","FileAfterCreateEventHandler","TaskService"],"mappings":";;AAIA,MAAMA;IACF,YAAoBC,WAAkC,CAAE;aAApCA,WAAW,GAAXA;IAAqC;IAEzD,MAAM,OAAOC,KAAwC,EAAiB;QAClE,MAAM,EAAEC,IAAI,EAAE,GAAGD,MAAM,OAAO;QAG9B,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAuB;YACjD,YAAY;YACZ,OAAO;gBACH,QAAQC,KAAK,EAAE;YACnB;QACJ;IACJ;AACJ;AAEO,MAAMC,yBAAyBC,4BAA4B,oBAAoB,CAAC;IACnF,gBAAgBL;IAChB,cAAc;QAACM;KAAY;AAC/B"}

package/features/ExtractMetadata/ExtractMetadataTask.d.ts

@@ -0,0 +1,29 @@
+import { TaskDefinition, TaskHandler } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { GlobalKeyValueStore } from "@webiny/api-core/features/keyValueStore/index.js";
+import { UpdateFileUseCase } from "@webiny/api-file-manager/features/file/UpdateFile/index.js";
+export interface ExtractMetadataInput {
+    fileId: string;
+}
+declare class ExtractMetadataTaskHandlerImpl implements TaskHandler.Interface<ExtractMetadataInput> {
+    private keyValueStore;
+    private updateFileUseCase;
+    constructor(keyValueStore: GlobalKeyValueStore.Interface, updateFileUseCase: UpdateFileUseCase.Interface);
+    run({ input, controller }: TaskHandler.RunParams<ExtractMetadataInput>): Promise<TaskDefinition.Result<ExtractMetadataInput>>;
+    private cleanValues;
+}
+declare class ExtractMetadataTask implements TaskDefinition.Interface {
+    id: string;
+    title: string;
+    description: string;
+    maxIterations: number;
+    isPrivate: boolean;
+    databaseLogs: boolean;
+    selfCleanup: ("onAbort" | "onSuccess")[];
+    handler: typeof ExtractMetadataTaskHandlerImpl & {
+        __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskHandler<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskOutput>>;
+    };
+}
+export declare const ExtractMetadataTaskDefinition: typeof ExtractMetadataTask & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskDefinition<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskOutput>>;
+};
+export {};

package/features/ExtractMetadata/ExtractMetadataTask.js

@@ -0,0 +1,99 @@
+import { S3 } from "@webiny/aws-sdk/client-s3/index.js";
+import { TaskDefinition, TaskHandler } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { GlobalKeyValueStore } from "@webiny/api-core/features/keyValueStore/index.js";
+import { UpdateFileUseCase } from "@webiny/api-file-manager/features/file/UpdateFile/index.js";
+import { MetadataReader } from "../WriteFileMetadata/MetadataReader.js";
+class ExtractMetadataTaskHandlerImpl {
+    constructor(keyValueStore, updateFileUseCase){
+        this.keyValueStore = keyValueStore;
+        this.updateFileUseCase = updateFileUseCase;
+    }
+    async run({ input, controller }) {
+        if (controller.runtime.isAborted()) return controller.response.aborted();
+        const metadataReader = new MetadataReader(this.keyValueStore);
+        const fileMetadata = await metadataReader.read(input.fileId);
+        if (!fileMetadata) return controller.response.error({
+            message: `File metadata not found for file ID: ${input.fileId}`
+        });
+        if (!fileMetadata.contentType.startsWith("image/")) return controller.response.done();
+        const s3 = new S3();
+        const bucket = String(process.env.S3_BUCKET);
+        try {
+            const s3Object = await s3.getObject({
+                Bucket: bucket,
+                Key: fileMetadata.bucketKey
+            });
+            if (!s3Object.Body) return controller.response.error({
+                message: `S3 object body is empty for file: ${input.fileId}`
+            });
+            const sharp = await import("sharp").then((m)=>m.default);
+            const ExifReader = await import("exifreader").then((m)=>m.default);
+            const buffer = Buffer.from(await s3Object.Body.transformToByteArray());
+            const sharpInstance = sharp(buffer);
+            const sharpMetadata = await sharpInstance.metadata();
+            const tags = ExifReader.load(buffer, {
+                expanded: true
+            });
+            const metadata = {
+                image: {
+                    width: sharpMetadata.width,
+                    height: sharpMetadata.height,
+                    format: sharpMetadata.format,
+                    orientation: sharpMetadata.orientation ?? 1
+                }
+            };
+            if (tags.exif) metadata.exif = this.cleanValues(tags.exif);
+            if (tags.iptc) metadata.iptc = this.cleanValues(tags.iptc);
+            const updateResult = await this.updateFileUseCase.execute({
+                id: input.fileId,
+                metadata
+            });
+            if (updateResult.isFail()) return controller.response.error({
+                message: `Failed to update file with metadata: ${updateResult.error.message}`
+            });
+            return controller.response.done();
+        } catch (error) {
+            return controller.response.error({
+                message: `Failed to extract metadata: ${error instanceof Error ? error.message : String(error)}`
+            });
+        }
+    }
+    cleanValues(tags) {
+        const cleaned = {};
+        for (const [key, tag] of Object.entries(tags))if (tag && "object" == typeof tag) {
+            if (void 0 !== tag.description && null !== tag.description) cleaned[key] = tag.description;
+            else if (Array.isArray(tag.value) && tag.value.length > 20) ;
+            else if (void 0 !== tag.value) cleaned[key] = tag.value;
+        }
+        return cleaned;
+    }
+}
+const ExtractMetadataTaskHandler = TaskHandler.createImplementation({
+    implementation: ExtractMetadataTaskHandlerImpl,
+    dependencies: [
+        GlobalKeyValueStore,
+        UpdateFileUseCase
+    ]
+});
+class ExtractMetadataTask {
+    constructor(){
+        this.id = "fileManagerExtractMetadata";
+        this.title = "Extract image metadata (dimensions, EXIF, IPTC)";
+        this.description = "A task to extract metadata from uploaded image files";
+        this.maxIterations = 1;
+        this.isPrivate = true;
+        this.databaseLogs = false;
+        this.selfCleanup = [
+            "onSuccess",
+            "onAbort"
+        ];
+        this.handler = ExtractMetadataTaskHandler;
+    }
+}
+const ExtractMetadataTaskDefinition = TaskDefinition.createImplementation({
+    implementation: ExtractMetadataTask,
+    dependencies: []
+});
+export { ExtractMetadataTaskDefinition };
+
+//# sourceMappingURL=ExtractMetadataTask.js.map

package/features/ExtractMetadata/ExtractMetadataTask.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ExtractMetadata/ExtractMetadataTask.js","sources":["../../../src/features/ExtractMetadata/ExtractMetadataTask.ts"],"sourcesContent":["import type { ExifTags } from \"exifreader\";\nimport { S3 } from \"@webiny/aws-sdk/client-s3/index.js\";\nimport {\n    TaskDefinition,\n    TaskHandler\n} from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { GlobalKeyValueStore } from \"@webiny/api-core/features/keyValueStore/index.js\";\nimport { UpdateFileUseCase } from \"@webiny/api-file-manager/features/file/UpdateFile/index.js\";\nimport { MetadataReader } from \"../WriteFileMetadata/MetadataReader.js\";\n\nexport interface ExtractMetadataInput {\n    fileId: string;\n}\n\nclass ExtractMetadataTaskHandlerImpl implements TaskHandler.Interface<ExtractMetadataInput> {\n    constructor(\n        private keyValueStore: GlobalKeyValueStore.Interface,\n        private updateFileUseCase: UpdateFileUseCase.Interface\n    ) {}\n\n    public async run({\n        input,\n        controller\n    }: TaskHandler.RunParams<ExtractMetadataInput>): Promise<\n        TaskDefinition.Result<ExtractMetadataInput>\n    > {\n        if (controller.runtime.isAborted()) {\n            return controller.response.aborted();\n        }\n\n        // Load file metadata\n        const metadataReader = new MetadataReader(this.keyValueStore);\n        const fileMetadata = await metadataReader.read(input.fileId);\n\n        if (!fileMetadata) {\n            return controller.response.error({\n                message: `File metadata not found for file ID: ${input.fileId}`\n            });\n        }\n\n        // Check if it's an image file\n        if (!fileMetadata.contentType.startsWith(\"image/\")) {\n            return controller.response.done();\n        }\n\n        // Fetch the image from S3\n        const s3 = new S3();\n        const bucket = String(process.env.S3_BUCKET);\n\n        try {\n            const s3Object = await s3.getObject({\n                Bucket: bucket,\n                Key: fileMetadata.bucketKey\n            });\n\n            if (!s3Object.Body) {\n                return controller.response.error({\n                    message: `S3 object body is empty for file: ${input.fileId}`\n                });\n            }\n\n            const sharp = await import(/* webpackChunkName: \"sharp\" */ \"sharp\").then(\n                m => m.default\n            );\n\n            const ExifReader = await import(/* webpackChunkName: \"exifreader\" */ \"exifreader\").then(\n                m => m.default\n            );\n\n            // Convert S3 body to buffer\n            const buffer = Buffer.from(await s3Object.Body.transformToByteArray());\n\n            // Extract metadata using Sharp for image dimensions\n            const sharpInstance = sharp(buffer);\n            const sharpMetadata = await sharpInstance.metadata();\n\n            // Use ExifReader to extract EXIF and IPTC data\n            const tags = ExifReader.load(buffer, { expanded: true });\n\n            // Build metadata object\n            const metadata: Record<string, any> = {\n                image: {\n                    width: sharpMetadata.width,\n                    height: sharpMetadata.height,\n                    format: sharpMetadata.format,\n                    orientation: sharpMetadata.orientation ?? 1\n                }\n            };\n\n            // Extract EXIF data if available\n            if (tags.exif) {\n                metadata.exif = this.cleanValues(tags.exif);\n            }\n\n            // Extract IPTC data if available\n            if (tags.iptc) {\n                metadata.iptc = this.cleanValues(tags.iptc);\n            }\n\n            // Update the file with extracted metadata\n            const updateResult = await this.updateFileUseCase.execute({\n                id: input.fileId,\n                metadata\n            });\n\n            if (updateResult.isFail()) {\n                return controller.response.error({\n                    message: `Failed to update file with metadata: ${updateResult.error.message}`\n                });\n            }\n\n            return controller.response.done();\n        } catch (error) {\n            return controller.response.error({\n                message: `Failed to extract metadata: ${\n                    error instanceof Error ? error.message : String(error)\n                }`\n            });\n        }\n    }\n\n    private cleanValues(tags: ExifTags) {\n        const cleaned: Record<string, any> = {};\n\n        for (const [key, tag] of Object.entries(tags)) {\n            if (!tag || typeof tag !== \"object\") {\n                continue;\n            }\n\n            // Use description if available, otherwise value\n            if (tag.description !== undefined && tag.description !== null) {\n                cleaned[key] = tag.description;\n            } else if (Array.isArray(tag.value) && tag.value.length > 20) {\n                // Skip large byte arrays\n            } else if (tag.value !== undefined) {\n                cleaned[key] = tag.value;\n            }\n        }\n\n        return cleaned;\n    }\n}\n\nconst ExtractMetadataTaskHandler = TaskHandler.createImplementation({\n    implementation: ExtractMetadataTaskHandlerImpl,\n    dependencies: [GlobalKeyValueStore, UpdateFileUseCase]\n});\n\nclass ExtractMetadataTask implements TaskDefinition.Interface {\n    id = \"fileManagerExtractMetadata\";\n    title = \"Extract image metadata (dimensions, EXIF, IPTC)\";\n    description = \"A task to extract metadata from uploaded image files\";\n    maxIterations = 1;\n    isPrivate = true;\n    databaseLogs = false;\n    selfCleanup = [\"onSuccess\" as const, \"onAbort\" as const];\n\n    handler = ExtractMetadataTaskHandler;\n}\n\nexport const ExtractMetadataTaskDefinition = TaskDefinition.createImplementation({\n    implementation: ExtractMetadataTask,\n    dependencies: []\n});\n"],"names":["ExtractMetadataTaskHandlerImpl","keyValueStore","updateFileUseCase","input","controller","metadataReader","MetadataReader","fileMetadata","s3","S3","bucket","String","process","s3Object","sharp","m","ExifReader","buffer","Buffer","sharpInstance","sharpMetadata","tags","metadata","updateResult","error","Error","cleaned","key","tag","Object","undefined","Array","ExtractMetadataTaskHandler","TaskHandler","GlobalKeyValueStore","UpdateFileUseCase","ExtractMetadataTask","ExtractMetadataTaskDefinition","TaskDefinition"],"mappings":"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"}

package/features/ExtractMetadata/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const ExtractMetadataFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/ExtractMetadata/feature.js

@@ -0,0 +1,13 @@
+import { createFeature } from "@webiny/feature/api";
+import { ExtractMetadataHandler } from "./ExtractMetadataHandler.js";
+import { ExtractMetadataTaskDefinition } from "./ExtractMetadataTask.js";
+const ExtractMetadataFeature = createFeature({
+    name: "FileManagerS3/ExtractMetadata",
+    register (container) {
+        container.register(ExtractMetadataHandler);
+        container.register(ExtractMetadataTaskDefinition);
+    }
+});
+export { ExtractMetadataFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/ExtractMetadata/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ExtractMetadata/feature.js","sources":["../../../src/features/ExtractMetadata/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ExtractMetadataHandler } from \"./ExtractMetadataHandler.js\";\nimport { ExtractMetadataTaskDefinition } from \"./ExtractMetadataTask.js\";\n\nexport const ExtractMetadataFeature = createFeature({\n    name: \"FileManagerS3/ExtractMetadata\",\n    register(container) {\n        container.register(ExtractMetadataHandler);\n        container.register(ExtractMetadataTaskDefinition);\n    }\n});\n"],"names":["ExtractMetadataFeature","createFeature","container","ExtractMetadataHandler","ExtractMetadataTaskDefinition"],"mappings":";;;AAIO,MAAMA,yBAAyBC,cAAc;IAChD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;IACvB;AACJ"}

package/features/FlushCache/FlushCacheOnFileDeleteHandler.d.ts

@@ -0,0 +1,12 @@
+import { FileAfterDeleteEventHandler } from "@webiny/api-file-manager/features/file/DeleteFile/events.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+declare class FlushCacheOnFileDeleteHandlerImpl implements FileAfterDeleteEventHandler.Interface {
+    private taskService;
+    private readonly pathsGenerator;
+    constructor(taskService: TaskService.Interface);
+    handle(event: FileAfterDeleteEventHandler.Event): Promise<void>;
+}
+export declare const FlushCacheOnFileDeleteHandler: typeof FlushCacheOnFileDeleteHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-file-manager/features/file/DeleteFile/events.js").FileAfterDeleteEvent>>;
+};
+export {};

package/features/FlushCache/FlushCacheOnFileDeleteHandler.js

@@ -0,0 +1,28 @@
+import { FileAfterDeleteEventHandler } from "@webiny/api-file-manager/features/file/DeleteFile/events.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import { CdnPathsGenerator } from "../../utils/CdnPathsGenerator.js";
+class FlushCacheOnFileDeleteHandlerImpl {
+    constructor(taskService){
+        this.taskService = taskService;
+        this.pathsGenerator = new CdnPathsGenerator();
+    }
+    async handle(event) {
+        const { file } = event.payload;
+        await this.taskService.trigger({
+            definition: "invalidateAssetCache",
+            input: {
+                caller: "fm-before-delete",
+                paths: this.pathsGenerator.generate(file.id)
+            }
+        });
+    }
+}
+const FlushCacheOnFileDeleteHandler = FileAfterDeleteEventHandler.createImplementation({
+    implementation: FlushCacheOnFileDeleteHandlerImpl,
+    dependencies: [
+        TaskService
+    ]
+});
+export { FlushCacheOnFileDeleteHandler };
+
+//# sourceMappingURL=FlushCacheOnFileDeleteHandler.js.map

package/features/FlushCache/FlushCacheOnFileDeleteHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/FlushCache/FlushCacheOnFileDeleteHandler.js","sources":["../../../src/features/FlushCache/FlushCacheOnFileDeleteHandler.ts"],"sourcesContent":["import { FileAfterDeleteEventHandler } from \"@webiny/api-file-manager/features/file/DeleteFile/events.js\";\nimport { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport { CdnPathsGenerator } from \"~/utils/CdnPathsGenerator.js\";\n\nclass FlushCacheOnFileDeleteHandlerImpl implements FileAfterDeleteEventHandler.Interface {\n    private readonly pathsGenerator: CdnPathsGenerator;\n\n    constructor(private taskService: TaskService.Interface) {\n        this.pathsGenerator = new CdnPathsGenerator();\n    }\n\n    async handle(event: FileAfterDeleteEventHandler.Event): Promise<void> {\n        const { file } = event.payload;\n\n        await this.taskService.trigger({\n            definition: \"invalidateAssetCache\",\n            input: {\n                caller: \"fm-before-delete\",\n                paths: this.pathsGenerator.generate(file.id)\n            }\n        });\n    }\n}\n\nexport const FlushCacheOnFileDeleteHandler = FileAfterDeleteEventHandler.createImplementation({\n    implementation: FlushCacheOnFileDeleteHandlerImpl,\n    dependencies: [TaskService]\n});\n"],"names":["FlushCacheOnFileDeleteHandlerImpl","taskService","CdnPathsGenerator","event","file","FlushCacheOnFileDeleteHandler","FileAfterDeleteEventHandler","TaskService"],"mappings":";;;AAIA,MAAMA;IAGF,YAAoBC,WAAkC,CAAE;aAApCA,WAAW,GAAXA;QAChB,IAAI,CAAC,cAAc,GAAG,IAAIC;IAC9B;IAEA,MAAM,OAAOC,KAAwC,EAAiB;QAClE,MAAM,EAAEC,IAAI,EAAE,GAAGD,MAAM,OAAO;QAE9B,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC;YAC3B,YAAY;YACZ,OAAO;gBACH,QAAQ;gBACR,OAAO,IAAI,CAAC,cAAc,CAAC,QAAQ,CAACC,KAAK,EAAE;YAC/C;QACJ;IACJ;AACJ;AAEO,MAAMC,gCAAgCC,4BAA4B,oBAAoB,CAAC;IAC1F,gBAAgBN;IAChB,cAAc;QAACO;KAAY;AAC/B"}

package/features/FlushCache/FlushCacheOnFileUpdateHandler.d.ts

@@ -0,0 +1,12 @@
+import { FileBeforeUpdateEventHandler } from "@webiny/api-file-manager/features/file/UpdateFile/events.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+declare class FlushCacheOnFileUpdateHandlerImpl implements FileBeforeUpdateEventHandler.Interface {
+    private taskService;
+    private readonly pathsGenerator;
+    constructor(taskService: TaskService.Interface);
+    handle(event: FileBeforeUpdateEventHandler.Event): Promise<void>;
+}
+export declare const FlushCacheOnFileUpdateHandler: typeof FlushCacheOnFileUpdateHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-file-manager/features/file/UpdateFile/events.js").FileBeforeUpdateEvent>>;
+};
+export {};

package/features/FlushCache/FlushCacheOnFileUpdateHandler.js

@@ -0,0 +1,31 @@
+import { FileBeforeUpdateEventHandler } from "@webiny/api-file-manager/features/file/UpdateFile/events.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import { CdnPathsGenerator } from "../../utils/CdnPathsGenerator.js";
+class FlushCacheOnFileUpdateHandlerImpl {
+    constructor(taskService){
+        this.taskService = taskService;
+        this.pathsGenerator = new CdnPathsGenerator();
+    }
+    async handle(event) {
+        const { file, original } = event.payload;
+        const prevAccessControl = original.accessControl;
+        const newAccessControl = file.accessControl;
+        if (prevAccessControl?.type === newAccessControl?.type) return;
+        await this.taskService.trigger({
+            definition: "invalidateAssetCache",
+            input: {
+                caller: "fm-before-update",
+                paths: this.pathsGenerator.generate(file.id)
+            }
+        });
+    }
+}
+const FlushCacheOnFileUpdateHandler = FileBeforeUpdateEventHandler.createImplementation({
+    implementation: FlushCacheOnFileUpdateHandlerImpl,
+    dependencies: [
+        TaskService
+    ]
+});
+export { FlushCacheOnFileUpdateHandler };
+
+//# sourceMappingURL=FlushCacheOnFileUpdateHandler.js.map

package/features/FlushCache/FlushCacheOnFileUpdateHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/FlushCache/FlushCacheOnFileUpdateHandler.js","sources":["../../../src/features/FlushCache/FlushCacheOnFileUpdateHandler.ts"],"sourcesContent":["import { FileBeforeUpdateEventHandler } from \"@webiny/api-file-manager/features/file/UpdateFile/events.js\";\nimport { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport { CdnPathsGenerator } from \"~/utils/CdnPathsGenerator.js\";\n\nclass FlushCacheOnFileUpdateHandlerImpl implements FileBeforeUpdateEventHandler.Interface {\n    private readonly pathsGenerator: CdnPathsGenerator;\n\n    constructor(private taskService: TaskService.Interface) {\n        this.pathsGenerator = new CdnPathsGenerator();\n    }\n\n    async handle(event: FileBeforeUpdateEventHandler.Event): Promise<void> {\n        const { file, original } = event.payload;\n\n        const prevAccessControl = original.accessControl;\n        const newAccessControl = file.accessControl;\n\n        // Only trigger cache flush if access control type has changed\n        if (prevAccessControl?.type === newAccessControl?.type) {\n            return;\n        }\n\n        await this.taskService.trigger({\n            definition: \"invalidateAssetCache\",\n            input: {\n                caller: \"fm-before-update\",\n                paths: this.pathsGenerator.generate(file.id)\n            }\n        });\n    }\n}\n\nexport const FlushCacheOnFileUpdateHandler = FileBeforeUpdateEventHandler.createImplementation({\n    implementation: FlushCacheOnFileUpdateHandlerImpl,\n    dependencies: [TaskService]\n});\n"],"names":["FlushCacheOnFileUpdateHandlerImpl","taskService","CdnPathsGenerator","event","file","original","prevAccessControl","newAccessControl","FlushCacheOnFileUpdateHandler","FileBeforeUpdateEventHandler","TaskService"],"mappings":";;;AAIA,MAAMA;IAGF,YAAoBC,WAAkC,CAAE;aAApCA,WAAW,GAAXA;QAChB,IAAI,CAAC,cAAc,GAAG,IAAIC;IAC9B;IAEA,MAAM,OAAOC,KAAyC,EAAiB;QACnE,MAAM,EAAEC,IAAI,EAAEC,QAAQ,EAAE,GAAGF,MAAM,OAAO;QAExC,MAAMG,oBAAoBD,SAAS,aAAa;QAChD,MAAME,mBAAmBH,KAAK,aAAa;QAG3C,IAAIE,mBAAmB,SAASC,kBAAkB,MAC9C;QAGJ,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC;YAC3B,YAAY;YACZ,OAAO;gBACH,QAAQ;gBACR,OAAO,IAAI,CAAC,cAAc,CAAC,QAAQ,CAACH,KAAK,EAAE;YAC/C;QACJ;IACJ;AACJ;AAEO,MAAMI,gCAAgCC,6BAA6B,oBAAoB,CAAC;IAC3F,gBAAgBT;IAChB,cAAc;QAACU;KAAY;AAC/B"}

package/features/FlushCache/InvalidateCacheTask.d.ts

@@ -0,0 +1,31 @@
+import { TaskDefinition, TaskHandler } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+export interface InvalidateCacheInput {
+    /**
+     * Caller of the task (e.g., `fm-before-update`, `fm-after-delete`).
+     */
+    caller: string;
+    /**
+     * Cache paths to invalidate.
+     */
+    paths: string[];
+}
+declare class InvalidateCloudfrontCacheTaskHandlerImpl implements TaskHandler.Interface<InvalidateCacheInput> {
+    private continueIfCode;
+    run({ input, controller }: TaskHandler.RunParams<InvalidateCacheInput>): Promise<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskResultAborted | import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskResultError | TaskDefinition.ResultContinue<InvalidateCacheInput> | TaskDefinition.ResultDone<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput>>;
+    private invalidateCache;
+}
+declare class InvalidateCloudfrontCacheTask implements TaskDefinition.Interface {
+    id: string;
+    title: string;
+    description: string;
+    maxIterations: number;
+    isPrivate: boolean;
+    selfCleanup: ("onAbort" | "onSuccess")[];
+    handler: typeof InvalidateCloudfrontCacheTaskHandlerImpl & {
+        __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskHandler<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput>>;
+    };
+}
+export declare const InvalidateCloudfrontCacheTaskDefinition: typeof InvalidateCloudfrontCacheTask & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskDefinition<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput>>;
+};
+export {};