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

package/features/FlushCache/InvalidateCacheTask.js

@@ -0,0 +1,84 @@
+import { ServiceDiscovery } from "@webiny/api-core/features/serviceDiscovery/index.js";
+import { CloudFront } from "@webiny/aws-sdk/client-cloudfront/index.js";
+import { TaskDefinition, TaskHandler } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { executeWithRetry } from "@webiny/utils";
+class ReturnContinue extends Error {
+}
+class InvalidateCloudfrontCacheTaskHandlerImpl {
+    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.continueIfCode = [
+            "TooManyInvalidationsInProgress",
+            "Throttling"
+        ];
+    }
+}
+const InvalidateCloudfrontCacheTaskHandler = TaskHandler.createImplementation({
+    implementation: InvalidateCloudfrontCacheTaskHandlerImpl,
+    dependencies: []
+});
+class InvalidateCloudfrontCacheTask {
+    constructor(){
+        this.id = "invalidateAssetCache";
+        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.handler = InvalidateCloudfrontCacheTaskHandler;
+    }
+}
+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-core/features/serviceDiscovery/index.js\";\nimport { CloudFront } from \"@webiny/aws-sdk/client-cloudfront/index.js\";\nimport {\n    TaskDefinition,\n    TaskHandler\n} 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 InvalidateCloudfrontCacheTaskHandlerImpl implements TaskHandler.Interface<InvalidateCacheInput> {\n    private continueIfCode = [\"TooManyInvalidationsInProgress\", \"Throttling\"];\n\n    public async run({ input, controller }: TaskHandler.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\nconst InvalidateCloudfrontCacheTaskHandler = TaskHandler.createImplementation({\n    implementation: InvalidateCloudfrontCacheTaskHandlerImpl,\n    dependencies: []\n});\n\nclass InvalidateCloudfrontCacheTask implements TaskDefinition.Interface {\n    id = \"invalidateAssetCache\";\n    title = \"Invalidate CloudFront Cache\";\n    description = \"A task to invalidate Cloudfront cache by given paths.\";\n    maxIterations = 100;\n    isPrivate = true;\n    selfCleanup = [\"onSuccess\" as const, \"onAbort\" as const];\n\n    handler = InvalidateCloudfrontCacheTaskHandler;\n}\n\nexport const InvalidateCloudfrontCacheTaskDefinition = TaskDefinition.createImplementation({\n    implementation: InvalidateCloudfrontCacheTask,\n    dependencies: []\n});\n"],"names":["ReturnContinue","Error","InvalidateCloudfrontCacheTaskHandlerImpl","input","controller","manifest","ServiceDiscovery","distributionId","invalidateCache","executeWithRetry","error","caller","paths","cloudfront","CloudFront","Date","InvalidateCloudfrontCacheTaskHandler","TaskHandler","InvalidateCloudfrontCacheTask","InvalidateCloudfrontCacheTaskDefinition","TaskDefinition"],"mappings":";;;;AAQA,MAAMA,uBAAuBC;AAAO;AAapC,MAAMC;IAGF,MAAa,IAAI,EAAEC,KAAK,EAAEC,UAAU,EAA+C,EAAE;QACjF,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;;aA3EQ,cAAc,GAAG;YAAC;YAAkC;SAAa;;AA4E7E;AAEA,MAAMI,uCAAuCC,YAAY,oBAAoB,CAAC;IAC1E,gBAAgBf;IAChB,cAAc,EAAE;AACpB;AAEA,MAAMgB;;aACF,EAAE,GAAG;aACL,KAAK,GAAG;aACR,WAAW,GAAG;aACd,aAAa,GAAG;aAChB,SAAS,GAAG;aACZ,WAAW,GAAG;YAAC;YAAsB;SAAmB;aAExD,OAAO,GAAGF;;AACd;AAEO,MAAMG,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;
+};

package/features/GetFileContentsByKey/feature.js

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

package/features/GetFileContentsByKey/feature.js.map

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

package/features/WriteFileMetadata/MetadataReader.d.ts

@@ -0,0 +1,14 @@
+import { GlobalKeyValueStore } from "@webiny/api-core/features/keyValueStore/index.js";
+interface AssetMetadata {
+    id: string;
+    tenant: string;
+    size: number;
+    contentType: string;
+    bucketKey: string;
+}
+export declare class MetadataReader {
+    private keyValueStore;
+    constructor(keyValueStore: GlobalKeyValueStore.Interface);
+    read(fileId: string): Promise<AssetMetadata | undefined>;
+}
+export {};

package/features/WriteFileMetadata/MetadataReader.js

@@ -0,0 +1,13 @@
+class MetadataReader {
+    constructor(keyValueStore){
+        this.keyValueStore = keyValueStore;
+    }
+    async read(fileId) {
+        const result = await this.keyValueStore.get(`FileManager/File/${fileId}/Metadata`);
+        if (result.isFail()) return;
+        return result.value;
+    }
+}
+export { MetadataReader };
+
+//# sourceMappingURL=MetadataReader.js.map

package/features/WriteFileMetadata/MetadataReader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/WriteFileMetadata/MetadataReader.js","sources":["../../../src/features/WriteFileMetadata/MetadataReader.ts"],"sourcesContent":["import { GlobalKeyValueStore } from \"@webiny/api-core/features/keyValueStore/index.js\";\n\ninterface AssetMetadata {\n    id: string;\n    tenant: string;\n    size: number;\n    contentType: string;\n    bucketKey: string;\n}\n\nexport class MetadataReader {\n    constructor(private keyValueStore: GlobalKeyValueStore.Interface) {}\n\n    async read(fileId: string): Promise<AssetMetadata | undefined> {\n        const result = await this.keyValueStore.get<AssetMetadata>(\n            `FileManager/File/${fileId}/Metadata`\n        );\n\n        if (result.isFail()) {\n            return undefined;\n        }\n\n        return result.value;\n    }\n}\n"],"names":["MetadataReader","keyValueStore","fileId","result"],"mappings":"AAUO,MAAMA;IACT,YAAoBC,aAA4C,CAAE;aAA9CA,aAAa,GAAbA;IAA+C;IAEnE,MAAM,KAAKC,MAAc,EAAsC;QAC3D,MAAMC,SAAS,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG,CACvC,CAAC,iBAAiB,EAAED,OAAO,SAAS,CAAC;QAGzC,IAAIC,OAAO,MAAM,IACb;QAGJ,OAAOA,OAAO,KAAK;IACvB;AACJ"}

package/features/WriteFileMetadata/MetadataWriter.d.ts

@@ -0,0 +1,10 @@
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import type { File } from "@webiny/api-file-manager/domain/file/types.js";
+import { GlobalKeyValueStore } from "@webiny/api-core/features/keyValueStore/index.js";
+export declare class MetadataWriter {
+    private tenantContext;
+    private keyValueStore;
+    constructor(tenantContext: TenantContext.Interface, keyValueStore: GlobalKeyValueStore.Interface);
+    write(files: File[]): Promise<void>;
+    private getMetadata;
+}

package/features/WriteFileMetadata/MetadataWriter.js

@@ -0,0 +1,28 @@
+class MetadataWriter {
+    constructor(tenantContext, keyValueStore){
+        this.tenantContext = tenantContext;
+        this.keyValueStore = keyValueStore;
+    }
+    async write(files) {
+        const writers = files.map(async (file)=>{
+            const metadata = this.getMetadata(file);
+            const key = `FileManager/File/${file.id}/Metadata`;
+            const result = await this.keyValueStore.set(key, metadata);
+            if (result.isFail()) console.error(`[FileManagerS3] Failed to write delivery metadata "${key}":`, result.error);
+        });
+        await Promise.all(writers);
+    }
+    getMetadata(file) {
+        const tenant = this.tenantContext.getTenant();
+        return {
+            id: file.id,
+            bucketKey: `tenants/${tenant.id}/files/${file.key}`,
+            tenant: tenant.id,
+            size: file.size,
+            contentType: file.type
+        };
+    }
+}
+export { MetadataWriter };
+
+//# sourceMappingURL=MetadataWriter.js.map

package/features/WriteFileMetadata/MetadataWriter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/WriteFileMetadata/MetadataWriter.js","sources":["../../../src/features/WriteFileMetadata/MetadataWriter.ts"],"sourcesContent":["import { TenantContext } from \"@webiny/api-core/features/tenancy/TenantContext/index.js\";\nimport type { File } from \"@webiny/api-file-manager/domain/file/types.js\";\nimport { GlobalKeyValueStore } from \"@webiny/api-core/features/keyValueStore/index.js\";\n\nexport class MetadataWriter {\n    constructor(\n        private tenantContext: TenantContext.Interface,\n        private keyValueStore: GlobalKeyValueStore.Interface\n    ) {}\n\n    async write(files: File[]) {\n        /**\n         * We need to write each file with retry.\n         */\n        const writers = files.map(async file => {\n            const metadata = this.getMetadata(file);\n            const key = `FileManager/File/${file.id}/Metadata`;\n            // Check the result: the KV store returns a failed Result (it does not throw), so an\n            // ignored failure here would silently break asset delivery (missing metadata → 404).\n            const result = await this.keyValueStore.set(key, metadata);\n            if (result.isFail()) {\n                console.error(\n                    `[FileManagerS3] Failed to write delivery metadata \"${key}\":`,\n                    result.error\n                );\n            }\n        });\n\n        await Promise.all(writers);\n    }\n\n    private getMetadata(file: File) {\n        const tenant = this.tenantContext.getTenant();\n        return {\n            id: file.id,\n            bucketKey: `tenants/${tenant.id}/files/${file.key}`,\n            tenant: tenant.id,\n            size: file.size,\n            contentType: file.type\n        };\n    }\n}\n"],"names":["MetadataWriter","tenantContext","keyValueStore","files","writers","file","metadata","key","result","console","Promise","tenant"],"mappings":"AAIO,MAAMA;IACT,YACYC,aAAsC,EACtCC,aAA4C,CACtD;aAFUD,aAAa,GAAbA;aACAC,aAAa,GAAbA;IACT;IAEH,MAAM,MAAMC,KAAa,EAAE;QAIvB,MAAMC,UAAUD,MAAM,GAAG,CAAC,OAAME;YAC5B,MAAMC,WAAW,IAAI,CAAC,WAAW,CAACD;YAClC,MAAME,MAAM,CAAC,iBAAiB,EAAEF,KAAK,EAAE,CAAC,SAAS,CAAC;YAGlD,MAAMG,SAAS,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG,CAACD,KAAKD;YACjD,IAAIE,OAAO,MAAM,IACbC,QAAQ,KAAK,CACT,CAAC,mDAAmD,EAAEF,IAAI,EAAE,CAAC,EAC7DC,OAAO,KAAK;QAGxB;QAEA,MAAME,QAAQ,GAAG,CAACN;IACtB;IAEQ,YAAYC,IAAU,EAAE;QAC5B,MAAMM,SAAS,IAAI,CAAC,aAAa,CAAC,SAAS;QAC3C,OAAO;YACH,IAAIN,KAAK,EAAE;YACX,WAAW,CAAC,QAAQ,EAAEM,OAAO,EAAE,CAAC,OAAO,EAAEN,KAAK,GAAG,EAAE;YACnD,QAAQM,OAAO,EAAE;YACjB,MAAMN,KAAK,IAAI;YACf,aAAaA,KAAK,IAAI;QAC1B;IACJ;AACJ"}

package/features/WriteFileMetadata/WriteMetadataAfterBatchCreateHandler.d.ts

@@ -0,0 +1,12 @@
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { FileAfterBatchCreateEventHandler } from "@webiny/api-file-manager/features/file/CreateFilesInBatch/events.js";
+import { GlobalKeyValueStore } from "@webiny/api-core/features/keyValueStore/index.js";
+declare class WriteMetadataAfterBatchCreateHandlerImpl implements FileAfterBatchCreateEventHandler.Interface {
+    private readonly metadataWriter;
+    constructor(tenantContext: TenantContext.Interface, keyValueStore: GlobalKeyValueStore.Interface);
+    handle(event: FileAfterBatchCreateEventHandler.Event): Promise<void>;
+}
+export declare const WriteMetadataAfterBatchCreateHandler: typeof WriteMetadataAfterBatchCreateHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher/abstractions.js").IEventHandler<import("@webiny/api-file-manager/features/file/CreateFilesInBatch/events.js").FileAfterBatchCreateEvent>>;
+};
+export {};

package/features/WriteFileMetadata/WriteMetadataAfterBatchCreateHandler.js

@@ -0,0 +1,23 @@
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { FileAfterBatchCreateEventHandler } from "@webiny/api-file-manager/features/file/CreateFilesInBatch/events.js";
+import { MetadataWriter } from "./MetadataWriter.js";
+import { GlobalKeyValueStore } from "@webiny/api-core/features/keyValueStore/index.js";
+class WriteMetadataAfterBatchCreateHandlerImpl {
+    constructor(tenantContext, keyValueStore){
+        this.metadataWriter = new MetadataWriter(tenantContext, keyValueStore);
+    }
+    async handle(event) {
+        const { files } = event.payload;
+        await this.metadataWriter.write(files);
+    }
+}
+const WriteMetadataAfterBatchCreateHandler = FileAfterBatchCreateEventHandler.createImplementation({
+    implementation: WriteMetadataAfterBatchCreateHandlerImpl,
+    dependencies: [
+        TenantContext,
+        GlobalKeyValueStore
+    ]
+});
+export { WriteMetadataAfterBatchCreateHandler };
+
+//# sourceMappingURL=WriteMetadataAfterBatchCreateHandler.js.map

package/features/WriteFileMetadata/WriteMetadataAfterBatchCreateHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/WriteFileMetadata/WriteMetadataAfterBatchCreateHandler.js","sources":["../../../src/features/WriteFileMetadata/WriteMetadataAfterBatchCreateHandler.ts"],"sourcesContent":["import { TenantContext } from \"@webiny/api-core/features/tenancy/TenantContext/index.js\";\nimport { FileAfterBatchCreateEventHandler } from \"@webiny/api-file-manager/features/file/CreateFilesInBatch/events.js\";\nimport { MetadataWriter } from \"./MetadataWriter.js\";\nimport { GlobalKeyValueStore } from \"@webiny/api-core/features/keyValueStore/index.js\";\n\nclass WriteMetadataAfterBatchCreateHandlerImpl\n    implements FileAfterBatchCreateEventHandler.Interface\n{\n    private readonly metadataWriter: MetadataWriter;\n\n    constructor(\n        tenantContext: TenantContext.Interface,\n        keyValueStore: GlobalKeyValueStore.Interface\n    ) {\n        this.metadataWriter = new MetadataWriter(tenantContext, keyValueStore);\n    }\n\n    async handle(event: FileAfterBatchCreateEventHandler.Event): Promise<void> {\n        const { files } = event.payload;\n        await this.metadataWriter.write(files);\n    }\n}\n\nexport const WriteMetadataAfterBatchCreateHandler =\n    FileAfterBatchCreateEventHandler.createImplementation({\n        implementation: WriteMetadataAfterBatchCreateHandlerImpl,\n        dependencies: [TenantContext, GlobalKeyValueStore]\n    });\n"],"names":["WriteMetadataAfterBatchCreateHandlerImpl","tenantContext","keyValueStore","MetadataWriter","event","files","WriteMetadataAfterBatchCreateHandler","FileAfterBatchCreateEventHandler","TenantContext","GlobalKeyValueStore"],"mappings":";;;;AAKA,MAAMA;IAKF,YACIC,aAAsC,EACtCC,aAA4C,CAC9C;QACE,IAAI,CAAC,cAAc,GAAG,IAAIC,eAAeF,eAAeC;IAC5D;IAEA,MAAM,OAAOE,KAA6C,EAAiB;QACvE,MAAM,EAAEC,KAAK,EAAE,GAAGD,MAAM,OAAO;QAC/B,MAAM,IAAI,CAAC,cAAc,CAAC,KAAK,CAACC;IACpC;AACJ;AAEO,MAAMC,uCACTC,iCAAiC,oBAAoB,CAAC;IAClD,gBAAgBP;IAChB,cAAc;QAACQ;QAAeC;KAAoB;AACtD"}

package/features/WriteFileMetadata/WriteMetadataAfterCreateHandler.d.ts

@@ -0,0 +1,12 @@
+import { FileAfterCreateEventHandler } from "@webiny/api-file-manager/features/file/CreateFile/events.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { GlobalKeyValueStore } from "@webiny/api-core/features/keyValueStore/index.js";
+declare class WriteMetadataAfterCreateHandlerImpl implements FileAfterCreateEventHandler.Interface {
+    private readonly metadataWriter;
+    constructor(tenantContext: TenantContext.Interface, keyValueStore: GlobalKeyValueStore.Interface);
+    handle(event: FileAfterCreateEventHandler.Event): Promise<void>;
+}
+export declare const WriteMetadataAfterCreateHandler: typeof WriteMetadataAfterCreateHandlerImpl & {
+    __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/WriteFileMetadata/WriteMetadataAfterCreateHandler.js

@@ -0,0 +1,25 @@
+import { FileAfterCreateEventHandler } from "@webiny/api-file-manager/features/file/CreateFile/events.js";
+import { MetadataWriter } from "./MetadataWriter.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { GlobalKeyValueStore } from "@webiny/api-core/features/keyValueStore/index.js";
+class WriteMetadataAfterCreateHandlerImpl {
+    constructor(tenantContext, keyValueStore){
+        this.metadataWriter = new MetadataWriter(tenantContext, keyValueStore);
+    }
+    async handle(event) {
+        const { file } = event.payload;
+        await this.metadataWriter.write([
+            file
+        ]);
+    }
+}
+const WriteMetadataAfterCreateHandler = FileAfterCreateEventHandler.createImplementation({
+    implementation: WriteMetadataAfterCreateHandlerImpl,
+    dependencies: [
+        TenantContext,
+        GlobalKeyValueStore
+    ]
+});
+export { WriteMetadataAfterCreateHandler };
+
+//# sourceMappingURL=WriteMetadataAfterCreateHandler.js.map

package/features/WriteFileMetadata/WriteMetadataAfterCreateHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/WriteFileMetadata/WriteMetadataAfterCreateHandler.js","sources":["../../../src/features/WriteFileMetadata/WriteMetadataAfterCreateHandler.ts"],"sourcesContent":["import { FileAfterCreateEventHandler } from \"@webiny/api-file-manager/features/file/CreateFile/events.js\";\nimport { MetadataWriter } from \"./MetadataWriter.js\";\nimport { TenantContext } from \"@webiny/api-core/features/tenancy/TenantContext/index.js\";\nimport { GlobalKeyValueStore } from \"@webiny/api-core/features/keyValueStore/index.js\";\n\nclass WriteMetadataAfterCreateHandlerImpl implements FileAfterCreateEventHandler.Interface {\n    private readonly metadataWriter: MetadataWriter;\n\n    constructor(\n        tenantContext: TenantContext.Interface,\n        keyValueStore: GlobalKeyValueStore.Interface\n    ) {\n        this.metadataWriter = new MetadataWriter(tenantContext, keyValueStore);\n    }\n\n    async handle(event: FileAfterCreateEventHandler.Event): Promise<void> {\n        const { file } = event.payload;\n        await this.metadataWriter.write([file]);\n    }\n}\n\nexport const WriteMetadataAfterCreateHandler = FileAfterCreateEventHandler.createImplementation({\n    implementation: WriteMetadataAfterCreateHandlerImpl,\n    dependencies: [TenantContext, GlobalKeyValueStore]\n});\n"],"names":["WriteMetadataAfterCreateHandlerImpl","tenantContext","keyValueStore","MetadataWriter","event","file","WriteMetadataAfterCreateHandler","FileAfterCreateEventHandler","TenantContext","GlobalKeyValueStore"],"mappings":";;;;AAKA,MAAMA;IAGF,YACIC,aAAsC,EACtCC,aAA4C,CAC9C;QACE,IAAI,CAAC,cAAc,GAAG,IAAIC,eAAeF,eAAeC;IAC5D;IAEA,MAAM,OAAOE,KAAwC,EAAiB;QAClE,MAAM,EAAEC,IAAI,EAAE,GAAGD,MAAM,OAAO;QAC9B,MAAM,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC;YAACC;SAAK;IAC1C;AACJ;AAEO,MAAMC,kCAAkCC,4BAA4B,oBAAoB,CAAC;IAC5F,gBAAgBP;IAChB,cAAc;QAACQ;QAAeC;KAAoB;AACtD"}

package/features/WriteFileMetadata/feature.d.ts

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

package/features/WriteFileMetadata/feature.js

@@ -0,0 +1,13 @@
+import { createFeature } from "@webiny/feature/api";
+import { WriteMetadataAfterCreateHandler } from "./WriteMetadataAfterCreateHandler.js";
+import { WriteMetadataAfterBatchCreateHandler } from "./WriteMetadataAfterBatchCreateHandler.js";
+const WriteFileMetadataFeature = createFeature({
+    name: "FileManagerS3/WriteFileMetadata",
+    register (container) {
+        container.register(WriteMetadataAfterCreateHandler);
+        container.register(WriteMetadataAfterBatchCreateHandler);
+    }
+});
+export { WriteFileMetadataFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/WriteFileMetadata/feature.js.map

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

package/graphql/S3GraphQLSchema.d.ts

@@ -0,0 +1,10 @@
+import { CoreGraphQLSchemaFactory } from "@webiny/api-graphql/graphql/abstractions.js";
+import { GraphQLSchemaBuilder } from "@webiny/api-graphql/features/GraphQLSchemaBuilder/abstractions.js";
+declare class S3GraphQLSchemaImpl implements CoreGraphQLSchemaFactory.Interface {
+    getSchemaKey: () => string;
+    execute(builder: GraphQLSchemaBuilder.Interface): CoreGraphQLSchemaFactory.Return;
+}
+export declare const S3GraphQLSchema: typeof S3GraphQLSchemaImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-graphql/graphql/abstractions.core.js").ICoreGraphQLSchemaFactory>;
+};
+export {};