@webiny/api-file-manager-s3 0.0.0-unstable.78f581c1d2 → 0.0.0-unstable.7be00a75a9

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,24 @@
+import { TaskDefinition } 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 ExtractMetadataTask implements TaskDefinition.Interface<ExtractMetadataInput> {
+    private keyValueStore;
+    private updateFileUseCase;
+    id: string;
+    title: string;
+    description: string;
+    maxIterations: number;
+    isPrivate: boolean;
+    databaseLogs: boolean;
+    selfCleanup: ("onSuccess" | "onAbort")[];
+    constructor(keyValueStore: GlobalKeyValueStore.Interface, updateFileUseCase: UpdateFileUseCase.Interface);
+    run({ input, controller }: TaskDefinition.RunParams<ExtractMetadataInput>): Promise<TaskDefinition.Result<ExtractMetadataInput>>;
+    private cleanValues;
+}
+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,90 @@
+import { S3 } from "@webiny/aws-sdk/client-s3/index.js";
+import { TaskDefinition } 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 ExtractMetadataTask {
+    constructor(keyValueStore, updateFileUseCase){
+        this.keyValueStore = keyValueStore;
+        this.updateFileUseCase = updateFileUseCase;
+        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"
+        ];
+    }
+    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 ExtractMetadataTaskDefinition = TaskDefinition.createImplementation({
+    implementation: ExtractMetadataTask,
+    dependencies: [
+        GlobalKeyValueStore,
+        UpdateFileUseCase
+    ]
+});
+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 { TaskDefinition } 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 ExtractMetadataTask implements TaskDefinition.Interface<ExtractMetadataInput> {\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\n    selfCleanup = [\"onSuccess\" as const, \"onAbort\" as const];\n\n    constructor(\n        private keyValueStore: GlobalKeyValueStore.Interface,\n        private updateFileUseCase: UpdateFileUseCase.Interface\n    ) {}\n\n    public async run({\n        input,\n        controller\n    }: TaskDefinition.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\nexport const ExtractMetadataTaskDefinition = TaskDefinition.createImplementation({\n    implementation: ExtractMetadataTask,\n    dependencies: [GlobalKeyValueStore, UpdateFileUseCase]\n});\n"],"names":["ExtractMetadataTask","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","ExtractMetadataTaskDefinition","TaskDefinition","GlobalKeyValueStore","UpdateFileUseCase"],"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: "cloudfrontInvalidateCache",
+            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: \"cloudfrontInvalidateCache\",\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: "cloudfrontInvalidateCache",
+            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: \"cloudfrontInvalidateCache\",\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,26 @@
+import { TaskDefinition } 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 InvalidateCloudfrontCacheTask implements TaskDefinition.Interface<InvalidateCacheInput> {
+    id: string;
+    title: string;
+    description: string;
+    maxIterations: number;
+    isPrivate: boolean;
+    selfCleanup: ("onSuccess" | "onAbort")[];
+    private continueIfCode;
+    run({ input, controller }: TaskDefinition.RunParams<InvalidateCacheInput>): Promise<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskResultError | import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskResultAborted | TaskDefinition.ResultDone<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput> | TaskDefinition.ResultContinue<InvalidateCacheInput>>;
+    private invalidateCache;
+}
+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 {};

package/features/FlushCache/InvalidateCacheTask.js

@@ -0,0 +1,75 @@
+import { ServiceDiscovery } from "@webiny/api";
+import { CloudFront } from "@webiny/aws-sdk/client-cloudfront/index.js";
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { executeWithRetry } from "@webiny/utils";
+class ReturnContinue extends Error {
+}
+class InvalidateCloudfrontCacheTask {
+    async run({ input, controller }) {
+        if (controller.runtime.isAborted()) return controller.response.aborted();
+        const manifest = await ServiceDiscovery.load();
+        if (!manifest) return controller.response.error({
+            message: "Unable to invalidate cache due to a missing service manifest.",
+            code: "MISSING_SERVICE_MANIFEST",
+            data: {
+                manifest: "api"
+            }
+        });
+        const { distributionId } = manifest.api.cloudfront;
+        const invalidateCache = ()=>this.invalidateCache(input.caller, distributionId, input.paths);
+        try {
+            await executeWithRetry(invalidateCache, {
+                minTimeout: 2000,
+                retries: 10000,
+                onFailedAttempt: ({ error })=>{
+                    if (this.continueIfCode.includes(error.name)) throw new ReturnContinue();
+                    if (error.message.includes("not authorized to perform")) throw error;
+                    if (controller.runtime.isCloseToTimeout()) throw new ReturnContinue();
+                }
+            });
+        } catch (error) {
+            if (error instanceof ReturnContinue) return controller.response.continue(input);
+            return controller.response.error({
+                message: error.message,
+                code: "EXECUTE_WITH_RETRY_FAILED",
+                data: input.paths
+            });
+        }
+        return controller.response.done();
+    }
+    async invalidateCache(caller, distributionId, paths) {
+        const cloudfront = new CloudFront();
+        await cloudfront.createInvalidation({
+            DistributionId: distributionId,
+            InvalidationBatch: {
+                CallerReference: `${new Date().getTime()}-${caller}`,
+                Paths: {
+                    Quantity: paths.length,
+                    Items: paths
+                }
+            }
+        });
+    }
+    constructor(){
+        this.id = "cloudfrontInvalidateCache";
+        this.title = "Invalidate CloudFront Cache";
+        this.description = "A task to invalidate Cloudfront cache by given paths.";
+        this.maxIterations = 100;
+        this.isPrivate = true;
+        this.selfCleanup = [
+            "onSuccess",
+            "onAbort"
+        ];
+        this.continueIfCode = [
+            "TooManyInvalidationsInProgress",
+            "Throttling"
+        ];
+    }
+}
+const InvalidateCloudfrontCacheTaskDefinition = TaskDefinition.createImplementation({
+    implementation: InvalidateCloudfrontCacheTask,
+    dependencies: []
+});
+export { InvalidateCloudfrontCacheTaskDefinition };
+
+//# sourceMappingURL=InvalidateCacheTask.js.map

package/features/FlushCache/InvalidateCacheTask.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/FlushCache/InvalidateCacheTask.js","sources":["../../../src/features/FlushCache/InvalidateCacheTask.ts"],"sourcesContent":["import { ServiceDiscovery } from \"@webiny/api\";\nimport { CloudFront } from \"@webiny/aws-sdk/client-cloudfront/index.js\";\nimport { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { executeWithRetry } from \"@webiny/utils\";\n\nclass ReturnContinue extends Error {}\n\nexport interface InvalidateCacheInput {\n    /**\n     * Caller of the task (e.g., `fm-before-update`, `fm-after-delete`).\n     */\n    caller: string;\n    /**\n     * Cache paths to invalidate.\n     */\n    paths: string[];\n}\n\nclass InvalidateCloudfrontCacheTask implements TaskDefinition.Interface<InvalidateCacheInput> {\n    id = \"cloudfrontInvalidateCache\";\n    title = \"Invalidate CloudFront Cache\";\n    description = \"A task to invalidate Cloudfront cache by given paths.\";\n    maxIterations = 100;\n    isPrivate = true;\n\n    selfCleanup = [\"onSuccess\" as const, \"onAbort\" as const];\n\n    private continueIfCode = [\"TooManyInvalidationsInProgress\", \"Throttling\"];\n\n    public async run({ input, controller }: TaskDefinition.RunParams<InvalidateCacheInput>) {\n        if (controller.runtime.isAborted()) {\n            return controller.response.aborted();\n        }\n\n        const manifest = await ServiceDiscovery.load();\n\n        if (!manifest) {\n            return controller.response.error({\n                message: `Unable to invalidate cache due to a missing service manifest.`,\n                code: \"MISSING_SERVICE_MANIFEST\",\n                data: {\n                    manifest: \"api\"\n                }\n            });\n        }\n\n        const { distributionId } = manifest.api.cloudfront;\n\n        const invalidateCache = () => {\n            return this.invalidateCache(input.caller, distributionId as string, input.paths);\n        };\n\n        try {\n            await executeWithRetry(invalidateCache, {\n                minTimeout: 2000,\n                // instead of forever: true\n                retries: 10000,\n                onFailedAttempt: ({ error }) => {\n                    if (this.continueIfCode.includes(error.name)) {\n                        throw new ReturnContinue();\n                    }\n\n                    if (error.message.includes(\"not authorized to perform\")) {\n                        throw error;\n                    }\n\n                    if (controller.runtime.isCloseToTimeout()) {\n                        throw new ReturnContinue();\n                    }\n                }\n            });\n        } catch (error) {\n            if (error instanceof ReturnContinue) {\n                return controller.response.continue(input);\n            }\n\n            return controller.response.error({\n                message: error.message,\n                code: \"EXECUTE_WITH_RETRY_FAILED\",\n                data: input.paths\n            });\n        }\n\n        return controller.response.done();\n    }\n\n    private async invalidateCache(\n        caller: string,\n        distributionId: string,\n        paths: string[]\n    ): Promise<void> {\n        const cloudfront = new CloudFront();\n        await cloudfront.createInvalidation({\n            DistributionId: distributionId,\n            InvalidationBatch: {\n                CallerReference: `${new Date().getTime()}-${caller}`,\n                Paths: {\n                    Quantity: paths.length,\n                    Items: paths\n                }\n            }\n        });\n    }\n}\n\nexport const InvalidateCloudfrontCacheTaskDefinition = TaskDefinition.createImplementation({\n    implementation: InvalidateCloudfrontCacheTask,\n    dependencies: []\n});\n"],"names":["ReturnContinue","Error","InvalidateCloudfrontCacheTask","input","controller","manifest","ServiceDiscovery","distributionId","invalidateCache","executeWithRetry","error","caller","paths","cloudfront","CloudFront","Date","InvalidateCloudfrontCacheTaskDefinition","TaskDefinition"],"mappings":";;;;AAKA,MAAMA,uBAAuBC;AAAO;AAapC,MAAMC;IAWF,MAAa,IAAI,EAAEC,KAAK,EAAEC,UAAU,EAAkD,EAAE;QACpF,IAAIA,WAAW,OAAO,CAAC,SAAS,IAC5B,OAAOA,WAAW,QAAQ,CAAC,OAAO;QAGtC,MAAMC,WAAW,MAAMC,iBAAiB,IAAI;QAE5C,IAAI,CAACD,UACD,OAAOD,WAAW,QAAQ,CAAC,KAAK,CAAC;YAC7B,SAAS;YACT,MAAM;YACN,MAAM;gBACF,UAAU;YACd;QACJ;QAGJ,MAAM,EAAEG,cAAc,EAAE,GAAGF,SAAS,GAAG,CAAC,UAAU;QAElD,MAAMG,kBAAkB,IACb,IAAI,CAAC,eAAe,CAACL,MAAM,MAAM,EAAEI,gBAA0BJ,MAAM,KAAK;QAGnF,IAAI;YACA,MAAMM,iBAAiBD,iBAAiB;gBACpC,YAAY;gBAEZ,SAAS;gBACT,iBAAiB,CAAC,EAAEE,KAAK,EAAE;oBACvB,IAAI,IAAI,CAAC,cAAc,CAAC,QAAQ,CAACA,MAAM,IAAI,GACvC,MAAM,IAAIV;oBAGd,IAAIU,MAAM,OAAO,CAAC,QAAQ,CAAC,8BACvB,MAAMA;oBAGV,IAAIN,WAAW,OAAO,CAAC,gBAAgB,IACnC,MAAM,IAAIJ;gBAElB;YACJ;QACJ,EAAE,OAAOU,OAAO;YACZ,IAAIA,iBAAiBV,gBACjB,OAAOI,WAAW,QAAQ,CAAC,QAAQ,CAACD;YAGxC,OAAOC,WAAW,QAAQ,CAAC,KAAK,CAAC;gBAC7B,SAASM,MAAM,OAAO;gBACtB,MAAM;gBACN,MAAMP,MAAM,KAAK;YACrB;QACJ;QAEA,OAAOC,WAAW,QAAQ,CAAC,IAAI;IACnC;IAEA,MAAc,gBACVO,MAAc,EACdJ,cAAsB,EACtBK,KAAe,EACF;QACb,MAAMC,aAAa,IAAIC;QACvB,MAAMD,WAAW,kBAAkB,CAAC;YAChC,gBAAgBN;YAChB,mBAAmB;gBACf,iBAAiB,GAAG,IAAIQ,OAAO,OAAO,GAAG,CAAC,EAAEJ,QAAQ;gBACpD,OAAO;oBACH,UAAUC,MAAM,MAAM;oBACtB,OAAOA;gBACX;YACJ;QACJ;IACJ;;aAnFA,EAAE,GAAG;aACL,KAAK,GAAG;aACR,WAAW,GAAG;aACd,aAAa,GAAG;aAChB,SAAS,GAAG;aAEZ,WAAW,GAAG;YAAC;YAAsB;SAAmB;aAEhD,cAAc,GAAG;YAAC;YAAkC;SAAa;;AA4E7E;AAEO,MAAMI,0CAA0CC,eAAe,oBAAoB,CAAC;IACvF,gBAAgBf;IAChB,cAAc,EAAE;AACpB"}

package/features/FlushCache/feature.d.ts

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

package/features/FlushCache/feature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import { FlushCacheOnFileDeleteHandler } from "./FlushCacheOnFileDeleteHandler.js";
+import { FlushCacheOnFileUpdateHandler } from "./FlushCacheOnFileUpdateHandler.js";
+import { InvalidateCloudfrontCacheTaskDefinition } from "./InvalidateCacheTask.js";
+const FlushCacheFeature = createFeature({
+    name: "FileManagerS3/FlushCache",
+    register (container) {
+        container.register(FlushCacheOnFileDeleteHandler);
+        container.register(FlushCacheOnFileUpdateHandler);
+        container.register(InvalidateCloudfrontCacheTaskDefinition);
+    }
+});
+export { FlushCacheFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/FlushCache/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/FlushCache/feature.js","sources":["../../../src/features/FlushCache/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { FlushCacheOnFileDeleteHandler } from \"./FlushCacheOnFileDeleteHandler.js\";\nimport { FlushCacheOnFileUpdateHandler } from \"./FlushCacheOnFileUpdateHandler.js\";\nimport { InvalidateCloudfrontCacheTaskDefinition } from \"./InvalidateCacheTask.js\";\n\nexport const FlushCacheFeature = createFeature({\n    name: \"FileManagerS3/FlushCache\",\n    register(container) {\n        container.register(FlushCacheOnFileDeleteHandler);\n        container.register(FlushCacheOnFileUpdateHandler);\n        container.register(InvalidateCloudfrontCacheTaskDefinition);\n    }\n});\n"],"names":["FlushCacheFeature","createFeature","container","FlushCacheOnFileDeleteHandler","FlushCacheOnFileUpdateHandler","InvalidateCloudfrontCacheTaskDefinition"],"mappings":";;;;AAKO,MAAMA,oBAAoBC,cAAc;IAC3C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG;IACvB;AACJ"}

package/features/GetFileContentsById/GetFileContentsByIdUseCase.d.ts

@@ -0,0 +1,13 @@
+import { Result } from "@webiny/feature/api";
+import { GlobalKeyValueStore } from "@webiny/api-core/features/keyValueStore/index.js";
+import { GetFileContentsByIdUseCase } from "@webiny/api-file-manager/features/file/GetFileContentsById/index.js";
+import type { FileContents } from "@webiny/api-file-manager/features/file/GetFileContentsById/index.js";
+declare class GetFileContentsByIdUseCaseImpl implements GetFileContentsByIdUseCase.Interface {
+    private metadataReader;
+    constructor(keyValueStore: GlobalKeyValueStore.Interface);
+    execute(fileId: string): Promise<Result<FileContents, GetFileContentsByIdUseCase.Error>>;
+}
+export declare const GetFileContentsByIdUseCaseImplementation: typeof GetFileContentsByIdUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-file-manager/features/file/GetFileContentsById/abstractions").IGetFileContentsByIdUseCase>;
+};
+export {};

package/features/GetFileContentsById/GetFileContentsByIdUseCase.js

@@ -0,0 +1,40 @@
+import { Result } from "@webiny/feature/api";
+import { S3 } from "@webiny/aws-sdk/client-s3/index.js";
+import { GlobalKeyValueStore } from "@webiny/api-core/features/keyValueStore/index.js";
+import { GetFileContentsByIdUseCase } from "@webiny/api-file-manager/features/file/GetFileContentsById/index.js";
+import { FileNotFoundError, FilePersistenceError } from "@webiny/api-file-manager/domain/file/errors.js";
+import { MetadataReader } from "../WriteFileMetadata/MetadataReader.js";
+class GetFileContentsByIdUseCaseImpl {
+    constructor(keyValueStore){
+        this.metadataReader = new MetadataReader(keyValueStore);
+    }
+    async execute(fileId) {
+        const metadata = await this.metadataReader.read(fileId);
+        if (!metadata) return Result.fail(new FileNotFoundError(fileId));
+        try {
+            const s3 = new S3();
+            const bucket = String(process.env.S3_BUCKET);
+            const response = await s3.getObject({
+                Bucket: bucket,
+                Key: metadata.bucketKey
+            });
+            if (!response.Body) return Result.fail(new FileNotFoundError(fileId));
+            const buffer = Buffer.from(await response.Body.transformToByteArray());
+            return Result.ok({
+                buffer,
+                contentType: metadata.contentType
+            });
+        } catch (error) {
+            return Result.fail(new FilePersistenceError(error instanceof Error ? error : new Error(String(error))));
+        }
+    }
+}
+const GetFileContentsByIdUseCaseImplementation = GetFileContentsByIdUseCase.createImplementation({
+    implementation: GetFileContentsByIdUseCaseImpl,
+    dependencies: [
+        GlobalKeyValueStore
+    ]
+});
+export { GetFileContentsByIdUseCaseImplementation };
+
+//# sourceMappingURL=GetFileContentsByIdUseCase.js.map

package/features/GetFileContentsById/GetFileContentsByIdUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/GetFileContentsById/GetFileContentsByIdUseCase.js","sources":["../../../src/features/GetFileContentsById/GetFileContentsByIdUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { S3 } from \"@webiny/aws-sdk/client-s3/index.js\";\nimport { GlobalKeyValueStore } from \"@webiny/api-core/features/keyValueStore/index.js\";\nimport { GetFileContentsByIdUseCase } from \"@webiny/api-file-manager/features/file/GetFileContentsById/index.js\";\nimport type { FileContents } from \"@webiny/api-file-manager/features/file/GetFileContentsById/index.js\";\nimport {\n    FileNotFoundError,\n    FilePersistenceError\n} from \"@webiny/api-file-manager/domain/file/errors.js\";\nimport { MetadataReader } from \"~/features/WriteFileMetadata/MetadataReader.js\";\n\nclass GetFileContentsByIdUseCaseImpl implements GetFileContentsByIdUseCase.Interface {\n    private metadataReader: MetadataReader;\n\n    constructor(keyValueStore: GlobalKeyValueStore.Interface) {\n        this.metadataReader = new MetadataReader(keyValueStore);\n    }\n\n    async execute(fileId: string): Promise<Result<FileContents, GetFileContentsByIdUseCase.Error>> {\n        const metadata = await this.metadataReader.read(fileId);\n        if (!metadata) {\n            return Result.fail(new FileNotFoundError(fileId));\n        }\n\n        try {\n            const s3 = new S3();\n            const bucket = String(process.env.S3_BUCKET);\n            const response = await s3.getObject({ Bucket: bucket, Key: metadata.bucketKey });\n\n            if (!response.Body) {\n                return Result.fail(new FileNotFoundError(fileId));\n            }\n\n            const buffer = Buffer.from(await response.Body.transformToByteArray());\n            return Result.ok({ buffer, contentType: metadata.contentType });\n        } catch (error) {\n            return Result.fail(\n                new FilePersistenceError(error instanceof Error ? error : new Error(String(error)))\n            );\n        }\n    }\n}\n\nexport const GetFileContentsByIdUseCaseImplementation =\n    GetFileContentsByIdUseCase.createImplementation({\n        implementation: GetFileContentsByIdUseCaseImpl,\n        dependencies: [GlobalKeyValueStore]\n    });\n"],"names":["GetFileContentsByIdUseCaseImpl","keyValueStore","MetadataReader","fileId","metadata","Result","FileNotFoundError","s3","S3","bucket","String","process","response","buffer","Buffer","error","FilePersistenceError","Error","GetFileContentsByIdUseCaseImplementation","GetFileContentsByIdUseCase","GlobalKeyValueStore"],"mappings":";;;;;;AAWA,MAAMA;IAGF,YAAYC,aAA4C,CAAE;QACtD,IAAI,CAAC,cAAc,GAAG,IAAIC,eAAeD;IAC7C;IAEA,MAAM,QAAQE,MAAc,EAAmE;QAC3F,MAAMC,WAAW,MAAM,IAAI,CAAC,cAAc,CAAC,IAAI,CAACD;QAChD,IAAI,CAACC,UACD,OAAOC,OAAO,IAAI,CAAC,IAAIC,kBAAkBH;QAG7C,IAAI;YACA,MAAMI,KAAK,IAAIC;YACf,MAAMC,SAASC,OAAOC,QAAQ,GAAG,CAAC,SAAS;YAC3C,MAAMC,WAAW,MAAML,GAAG,SAAS,CAAC;gBAAE,QAAQE;gBAAQ,KAAKL,SAAS,SAAS;YAAC;YAE9E,IAAI,CAACQ,SAAS,IAAI,EACd,OAAOP,OAAO,IAAI,CAAC,IAAIC,kBAAkBH;YAG7C,MAAMU,SAASC,OAAO,IAAI,CAAC,MAAMF,SAAS,IAAI,CAAC,oBAAoB;YACnE,OAAOP,OAAO,EAAE,CAAC;gBAAEQ;gBAAQ,aAAaT,SAAS,WAAW;YAAC;QACjE,EAAE,OAAOW,OAAO;YACZ,OAAOV,OAAO,IAAI,CACd,IAAIW,qBAAqBD,iBAAiBE,QAAQF,QAAQ,IAAIE,MAAMP,OAAOK;QAEnF;IACJ;AACJ;AAEO,MAAMG,2CACTC,2BAA2B,oBAAoB,CAAC;IAC5C,gBAAgBnB;IAChB,cAAc;QAACoB;KAAoB;AACvC"}

package/features/GetFileContentsById/feature.d.ts

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

package/features/GetFileContentsById/feature.js

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

package/features/GetFileContentsById/feature.js.map

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

package/features/GetFileContentsByKey/GetFileContentsByKeyUseCase.d.ts

@@ -0,0 +1,13 @@
+import { Result } from "@webiny/feature/api";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { GetFileContentsByKeyUseCase } from "@webiny/api-file-manager/features/file/GetFileContentsByKey/index.js";
+import type { FileContents } from "@webiny/api-file-manager/features/file/GetFileContentsById/index.js";
+declare class GetFileContentsByKeyUseCaseImpl implements GetFileContentsByKeyUseCase.Interface {
+    private tenantContext;
+    constructor(tenantContext: TenantContext.Interface);
+    execute(key: string): Promise<Result<FileContents, GetFileContentsByKeyUseCase.Error>>;
+}
+export declare const GetFileContentsByKeyUseCaseImplementation: typeof GetFileContentsByKeyUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-file-manager/features/file/GetFileContentsByKey/abstractions").IGetFileContentsByKeyUseCase>;
+};
+export {};

package/features/GetFileContentsByKey/GetFileContentsByKeyUseCase.js

@@ -0,0 +1,40 @@
+import { Result } from "@webiny/feature/api";
+import { S3 } from "@webiny/aws-sdk/client-s3/index.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { GetFileContentsByKeyUseCase } from "@webiny/api-file-manager/features/file/GetFileContentsByKey/index.js";
+import { FileNotFoundError, FilePersistenceError } from "@webiny/api-file-manager/domain/file/errors.js";
+class GetFileContentsByKeyUseCaseImpl {
+    constructor(tenantContext){
+        this.tenantContext = tenantContext;
+    }
+    async execute(key) {
+        const tenant = this.tenantContext.getTenant();
+        const bucketKey = `tenants/${tenant.id}/files/${key}`;
+        try {
+            const s3 = new S3();
+            const bucket = String(process.env.S3_BUCKET);
+            const response = await s3.getObject({
+                Bucket: bucket,
+                Key: bucketKey
+            });
+            if (!response.Body) return Result.fail(new FileNotFoundError(key));
+            const buffer = Buffer.from(await response.Body.transformToByteArray());
+            const contentType = response.ContentType || "application/octet-stream";
+            return Result.ok({
+                buffer,
+                contentType
+            });
+        } catch (error) {
+            return Result.fail(new FilePersistenceError(error instanceof Error ? error : new Error(String(error))));
+        }
+    }
+}
+const GetFileContentsByKeyUseCaseImplementation = GetFileContentsByKeyUseCase.createImplementation({
+    implementation: GetFileContentsByKeyUseCaseImpl,
+    dependencies: [
+        TenantContext
+    ]
+});
+export { GetFileContentsByKeyUseCaseImplementation };
+
+//# sourceMappingURL=GetFileContentsByKeyUseCase.js.map

package/features/GetFileContentsByKey/GetFileContentsByKeyUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/GetFileContentsByKey/GetFileContentsByKeyUseCase.js","sources":["../../../src/features/GetFileContentsByKey/GetFileContentsByKeyUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { S3 } from \"@webiny/aws-sdk/client-s3/index.js\";\nimport { TenantContext } from \"@webiny/api-core/features/tenancy/TenantContext/index.js\";\nimport { GetFileContentsByKeyUseCase } from \"@webiny/api-file-manager/features/file/GetFileContentsByKey/index.js\";\nimport type { FileContents } from \"@webiny/api-file-manager/features/file/GetFileContentsById/index.js\";\nimport {\n    FileNotFoundError,\n    FilePersistenceError\n} from \"@webiny/api-file-manager/domain/file/errors.js\";\n\nclass GetFileContentsByKeyUseCaseImpl implements GetFileContentsByKeyUseCase.Interface {\n    constructor(private tenantContext: TenantContext.Interface) {}\n\n    async execute(key: string): Promise<Result<FileContents, GetFileContentsByKeyUseCase.Error>> {\n        const tenant = this.tenantContext.getTenant();\n        const bucketKey = `tenants/${tenant.id}/files/${key}`;\n\n        try {\n            const s3 = new S3();\n            const bucket = String(process.env.S3_BUCKET);\n            const response = await s3.getObject({ Bucket: bucket, Key: bucketKey });\n\n            if (!response.Body) {\n                return Result.fail(new FileNotFoundError(key));\n            }\n\n            const buffer = Buffer.from(await response.Body.transformToByteArray());\n            const contentType = response.ContentType || \"application/octet-stream\";\n            return Result.ok({ buffer, contentType });\n        } catch (error) {\n            return Result.fail(\n                new FilePersistenceError(error instanceof Error ? error : new Error(String(error)))\n            );\n        }\n    }\n}\n\nexport const GetFileContentsByKeyUseCaseImplementation =\n    GetFileContentsByKeyUseCase.createImplementation({\n        implementation: GetFileContentsByKeyUseCaseImpl,\n        dependencies: [TenantContext]\n    });\n"],"names":["GetFileContentsByKeyUseCaseImpl","tenantContext","key","tenant","bucketKey","s3","S3","bucket","String","process","response","Result","FileNotFoundError","buffer","Buffer","contentType","error","FilePersistenceError","Error","GetFileContentsByKeyUseCaseImplementation","GetFileContentsByKeyUseCase","TenantContext"],"mappings":";;;;;AAUA,MAAMA;IACF,YAAoBC,aAAsC,CAAE;aAAxCA,aAAa,GAAbA;IAAyC;IAE7D,MAAM,QAAQC,GAAW,EAAoE;QACzF,MAAMC,SAAS,IAAI,CAAC,aAAa,CAAC,SAAS;QAC3C,MAAMC,YAAY,CAAC,QAAQ,EAAED,OAAO,EAAE,CAAC,OAAO,EAAED,KAAK;QAErD,IAAI;YACA,MAAMG,KAAK,IAAIC;YACf,MAAMC,SAASC,OAAOC,QAAQ,GAAG,CAAC,SAAS;YAC3C,MAAMC,WAAW,MAAML,GAAG,SAAS,CAAC;gBAAE,QAAQE;gBAAQ,KAAKH;YAAU;YAErE,IAAI,CAACM,SAAS,IAAI,EACd,OAAOC,OAAO,IAAI,CAAC,IAAIC,kBAAkBV;YAG7C,MAAMW,SAASC,OAAO,IAAI,CAAC,MAAMJ,SAAS,IAAI,CAAC,oBAAoB;YACnE,MAAMK,cAAcL,SAAS,WAAW,IAAI;YAC5C,OAAOC,OAAO,EAAE,CAAC;gBAAEE;gBAAQE;YAAY;QAC3C,EAAE,OAAOC,OAAO;YACZ,OAAOL,OAAO,IAAI,CACd,IAAIM,qBAAqBD,iBAAiBE,QAAQF,QAAQ,IAAIE,MAAMV,OAAOQ;QAEnF;IACJ;AACJ;AAEO,MAAMG,4CACTC,4BAA4B,oBAAoB,CAAC;IAC7C,gBAAgBpB;IAChB,cAAc;QAACqB;KAAc;AACjC"}

package/features/GetFileContentsByKey/feature.d.ts

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