@webiny/api-file-manager-s3 6.0.0-beta.0 → 6.0.0-rc.0

package/features/ExtractMetadata/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","ExtractMetadataHandler","ExtractMetadataTaskDefinition","ExtractMetadataFeature","name","register","container"],"sources":["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"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,sBAAsB;AAC/B,SAASC,6BAA6B;AAEtC,OAAO,MAAMC,sBAAsB,GAAGH,aAAa,CAAC;EAChDI,IAAI,EAAE,+BAA+B;EACrCC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACJ,sBAAsB,CAAC;IAC1CK,SAAS,CAACD,QAAQ,CAACH,6BAA6B,CAAC;EACrD;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/FlushCache/FlushCacheOnFileDeleteHandler.d.ts

@@ -0,0 +1,12 @@
+import { FileAfterDeleteHandler } 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 FileAfterDeleteHandler.Interface {
+    private taskService;
+    private readonly pathsGenerator;
+    constructor(taskService: TaskService.Interface);
+    handle(event: FileAfterDeleteHandler.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,27 @@
+import { FileAfterDeleteHandler } 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)
+      }
+    });
+  }
+}
+export const FlushCacheOnFileDeleteHandler = FileAfterDeleteHandler.createImplementation({
+  implementation: FlushCacheOnFileDeleteHandlerImpl,
+  dependencies: [TaskService]
+});
+
+//# sourceMappingURL=FlushCacheOnFileDeleteHandler.js.map

package/features/FlushCache/FlushCacheOnFileDeleteHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["FileAfterDeleteHandler","TaskService","CdnPathsGenerator","FlushCacheOnFileDeleteHandlerImpl","constructor","taskService","pathsGenerator","handle","event","file","payload","trigger","definition","input","caller","paths","generate","id","FlushCacheOnFileDeleteHandler","createImplementation","implementation","dependencies"],"sources":["FlushCacheOnFileDeleteHandler.ts"],"sourcesContent":["import { FileAfterDeleteHandler } 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 FileAfterDeleteHandler.Interface {\n    private readonly pathsGenerator: CdnPathsGenerator;\n\n    constructor(private taskService: TaskService.Interface) {\n        this.pathsGenerator = new CdnPathsGenerator();\n    }\n\n    async handle(event: FileAfterDeleteHandler.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 = FileAfterDeleteHandler.createImplementation({\n    implementation: FlushCacheOnFileDeleteHandlerImpl,\n    dependencies: [TaskService]\n});\n"],"mappings":"AAAA,SAASA,sBAAsB,QAAQ,6DAA6D;AACpG,SAASC,WAAW,QAAQ,qDAAqD;AACjF,SAASC,iBAAiB;AAE1B,MAAMC,iCAAiC,CAA6C;EAGhFC,WAAWA,CAASC,WAAkC,EAAE;IAAA,KAApCA,WAAkC,GAAlCA,WAAkC;IAClD,IAAI,CAACC,cAAc,GAAG,IAAIJ,iBAAiB,CAAC,CAAC;EACjD;EAEA,MAAMK,MAAMA,CAACC,KAAmC,EAAiB;IAC7D,MAAM;MAAEC;IAAK,CAAC,GAAGD,KAAK,CAACE,OAAO;IAE9B,MAAM,IAAI,CAACL,WAAW,CAACM,OAAO,CAAC;MAC3BC,UAAU,EAAE,2BAA2B;MACvCC,KAAK,EAAE;QACHC,MAAM,EAAE,kBAAkB;QAC1BC,KAAK,EAAE,IAAI,CAACT,cAAc,CAACU,QAAQ,CAACP,IAAI,CAACQ,EAAE;MAC/C;IACJ,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAMC,6BAA6B,GAAGlB,sBAAsB,CAACmB,oBAAoB,CAAC;EACrFC,cAAc,EAAEjB,iCAAiC;EACjDkB,YAAY,EAAE,CAACpB,WAAW;AAC9B,CAAC,CAAC","ignoreList":[]}

package/features/FlushCache/FlushCacheOnFileUpdateHandler.d.ts

@@ -0,0 +1,12 @@
+import { FileBeforeUpdateHandler } 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 FileBeforeUpdateHandler.Interface {
+    private taskService;
+    private readonly pathsGenerator;
+    constructor(taskService: TaskService.Interface);
+    handle(event: FileBeforeUpdateHandler.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,35 @@
+import { FileBeforeUpdateHandler } 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;
+
+    // Only trigger cache flush if access control type has changed
+    if (prevAccessControl?.type === newAccessControl?.type) {
+      return;
+    }
+    await this.taskService.trigger({
+      definition: "cloudfrontInvalidateCache",
+      input: {
+        caller: "fm-before-update",
+        paths: this.pathsGenerator.generate(file.id)
+      }
+    });
+  }
+}
+export const FlushCacheOnFileUpdateHandler = FileBeforeUpdateHandler.createImplementation({
+  implementation: FlushCacheOnFileUpdateHandlerImpl,
+  dependencies: [TaskService]
+});
+
+//# sourceMappingURL=FlushCacheOnFileUpdateHandler.js.map

package/features/FlushCache/FlushCacheOnFileUpdateHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["FileBeforeUpdateHandler","TaskService","CdnPathsGenerator","FlushCacheOnFileUpdateHandlerImpl","constructor","taskService","pathsGenerator","handle","event","file","original","payload","prevAccessControl","accessControl","newAccessControl","type","trigger","definition","input","caller","paths","generate","id","FlushCacheOnFileUpdateHandler","createImplementation","implementation","dependencies"],"sources":["FlushCacheOnFileUpdateHandler.ts"],"sourcesContent":["import { FileBeforeUpdateHandler } 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 FileBeforeUpdateHandler.Interface {\n    private readonly pathsGenerator: CdnPathsGenerator;\n\n    constructor(private taskService: TaskService.Interface) {\n        this.pathsGenerator = new CdnPathsGenerator();\n    }\n\n    async handle(event: FileBeforeUpdateHandler.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 = FileBeforeUpdateHandler.createImplementation({\n    implementation: FlushCacheOnFileUpdateHandlerImpl,\n    dependencies: [TaskService]\n});\n"],"mappings":"AAAA,SAASA,uBAAuB,QAAQ,6DAA6D;AACrG,SAASC,WAAW,QAAQ,qDAAqD;AACjF,SAASC,iBAAiB;AAE1B,MAAMC,iCAAiC,CAA8C;EAGjFC,WAAWA,CAASC,WAAkC,EAAE;IAAA,KAApCA,WAAkC,GAAlCA,WAAkC;IAClD,IAAI,CAACC,cAAc,GAAG,IAAIJ,iBAAiB,CAAC,CAAC;EACjD;EAEA,MAAMK,MAAMA,CAACC,KAAoC,EAAiB;IAC9D,MAAM;MAAEC,IAAI;MAAEC;IAAS,CAAC,GAAGF,KAAK,CAACG,OAAO;IAExC,MAAMC,iBAAiB,GAAGF,QAAQ,CAACG,aAAa;IAChD,MAAMC,gBAAgB,GAAGL,IAAI,CAACI,aAAa;;IAE3C;IACA,IAAID,iBAAiB,EAAEG,IAAI,KAAKD,gBAAgB,EAAEC,IAAI,EAAE;MACpD;IACJ;IAEA,MAAM,IAAI,CAACV,WAAW,CAACW,OAAO,CAAC;MAC3BC,UAAU,EAAE,2BAA2B;MACvCC,KAAK,EAAE;QACHC,MAAM,EAAE,kBAAkB;QAC1BC,KAAK,EAAE,IAAI,CAACd,cAAc,CAACe,QAAQ,CAACZ,IAAI,CAACa,EAAE;MAC/C;IACJ,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAMC,6BAA6B,GAAGvB,uBAAuB,CAACwB,oBAAoB,CAAC;EACtFC,cAAc,EAAEtB,iCAAiC;EACjDuB,YAAY,EAAE,CAACzB,WAAW;AAC9B,CAAC,CAAC","ignoreList":[]}

package/features/FlushCache/InvalidateCacheTask.d.ts

@@ -0,0 +1,25 @@
+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;
+    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,86 @@
+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 {
+  id = "cloudfrontInvalidateCache";
+  title = "Invalidate CloudFront Cache";
+  description = "A task to invalidate Cloudfront cache by given paths.";
+  maxIterations = 100;
+  isPrivate = true;
+  continueIfCode = ["TooManyInvalidationsInProgress", "Throttling"];
+  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 = () => {
+      return this.invalidateCache(input.caller, distributionId, input.paths);
+    };
+    try {
+      await executeWithRetry(invalidateCache, {
+        minTimeout: 2000,
+        // instead of forever: true
+        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
+        }
+      }
+    });
+  }
+}
+export const InvalidateCloudfrontCacheTaskDefinition = TaskDefinition.createImplementation({
+  implementation: InvalidateCloudfrontCacheTask,
+  dependencies: []
+});
+
+//# sourceMappingURL=InvalidateCacheTask.js.map

package/features/FlushCache/InvalidateCacheTask.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ServiceDiscovery","CloudFront","TaskDefinition","executeWithRetry","ReturnContinue","Error","InvalidateCloudfrontCacheTask","id","title","description","maxIterations","isPrivate","continueIfCode","run","input","controller","runtime","isAborted","response","aborted","manifest","load","error","message","code","data","distributionId","api","cloudfront","invalidateCache","caller","paths","minTimeout","retries","onFailedAttempt","includes","name","isCloseToTimeout","continue","done","createInvalidation","DistributionId","InvalidationBatch","CallerReference","Date","getTime","Paths","Quantity","length","Items","InvalidateCloudfrontCacheTaskDefinition","createImplementation","implementation","dependencies"],"sources":["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    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"],"mappings":"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","ignoreList":[]}

package/features/FlushCache/feature.d.ts

@@ -0,0 +1 @@
+export declare const FlushCacheFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/FlushCache/feature.js

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

package/features/FlushCache/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","FlushCacheOnFileDeleteHandler","FlushCacheOnFileUpdateHandler","InvalidateCloudfrontCacheTaskDefinition","FlushCacheFeature","name","register","container"],"sources":["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"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,6BAA6B;AACtC,SAASC,6BAA6B;AACtC,SAASC,uCAAuC;AAEhD,OAAO,MAAMC,iBAAiB,GAAGJ,aAAa,CAAC;EAC3CK,IAAI,EAAE,0BAA0B;EAChCC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACL,6BAA6B,CAAC;IACjDM,SAAS,CAACD,QAAQ,CAACJ,6BAA6B,CAAC;IACjDK,SAAS,CAACD,QAAQ,CAACH,uCAAuC,CAAC;EAC/D;AACJ,CAAC,CAAC","ignoreList":[]}

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,14 @@
+export class MetadataReader {
+  constructor(keyValueStore) {
+    this.keyValueStore = keyValueStore;
+  }
+  async read(fileId) {
+    const result = await this.keyValueStore.get(`FileManager/File/${fileId}/Metadata`);
+    if (result.isFail()) {
+      return undefined;
+    }
+    return result.value;
+  }
+}
+
+//# sourceMappingURL=MetadataReader.js.map

package/features/WriteFileMetadata/MetadataReader.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["MetadataReader","constructor","keyValueStore","read","fileId","result","get","isFail","undefined","value"],"sources":["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"],"mappings":"AAUA,OAAO,MAAMA,cAAc,CAAC;EACxBC,WAAWA,CAASC,aAA4C,EAAE;IAAA,KAA9CA,aAA4C,GAA5CA,aAA4C;EAAG;EAEnE,MAAMC,IAAIA,CAACC,MAAc,EAAsC;IAC3D,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACH,aAAa,CAACI,GAAG,CACvC,oBAAoBF,MAAM,WAC9B,CAAC;IAED,IAAIC,MAAM,CAACE,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOC,SAAS;IACpB;IAEA,OAAOH,MAAM,CAACI,KAAK;EACvB;AACJ","ignoreList":[]}

package/features/WriteFileMetadata/MetadataWriter.d.ts

@@ -0,0 +1,10 @@
+import { TenantContext } from "@webiny/api-core/features/TenantContext";
+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 @@
+export class MetadataWriter {
+  constructor(tenantContext, keyValueStore) {
+    this.tenantContext = tenantContext;
+    this.keyValueStore = keyValueStore;
+  }
+  async write(files) {
+    /**
+     * We need to write each file with retry.
+     */
+    const writers = files.map(async file => {
+      const metadata = this.getMetadata(file);
+      await this.keyValueStore.set(`FileManager/File/${file.id}/Metadata`, metadata);
+    });
+    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
+    };
+  }
+}
+
+//# sourceMappingURL=MetadataWriter.js.map

package/features/WriteFileMetadata/MetadataWriter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["MetadataWriter","constructor","tenantContext","keyValueStore","write","files","writers","map","file","metadata","getMetadata","set","id","Promise","all","tenant","getTenant","bucketKey","key","size","contentType","type"],"sources":["MetadataWriter.ts"],"sourcesContent":["import { TenantContext } from \"@webiny/api-core/features/TenantContext\";\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            await this.keyValueStore.set(`FileManager/File/${file.id}/Metadata`, metadata);\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"],"mappings":"AAIA,OAAO,MAAMA,cAAc,CAAC;EACxBC,WAAWA,CACCC,aAAsC,EACtCC,aAA4C,EACtD;IAAA,KAFUD,aAAsC,GAAtCA,aAAsC;IAAA,KACtCC,aAA4C,GAA5CA,aAA4C;EACrD;EAEH,MAAMC,KAAKA,CAACC,KAAa,EAAE;IACvB;AACR;AACA;IACQ,MAAMC,OAAO,GAAGD,KAAK,CAACE,GAAG,CAAC,MAAMC,IAAI,IAAI;MACpC,MAAMC,QAAQ,GAAG,IAAI,CAACC,WAAW,CAACF,IAAI,CAAC;MACvC,MAAM,IAAI,CAACL,aAAa,CAACQ,GAAG,CAAC,oBAAoBH,IAAI,CAACI,EAAE,WAAW,EAAEH,QAAQ,CAAC;IAClF,CAAC,CAAC;IAEF,MAAMI,OAAO,CAACC,GAAG,CAACR,OAAO,CAAC;EAC9B;EAEQI,WAAWA,CAACF,IAAU,EAAE;IAC5B,MAAMO,MAAM,GAAG,IAAI,CAACb,aAAa,CAACc,SAAS,CAAC,CAAC;IAC7C,OAAO;MACHJ,EAAE,EAAEJ,IAAI,CAACI,EAAE;MACXK,SAAS,EAAE,WAAWF,MAAM,CAACH,EAAE,UAAUJ,IAAI,CAACU,GAAG,EAAE;MACnDH,MAAM,EAAEA,MAAM,CAACH,EAAE;MACjBO,IAAI,EAAEX,IAAI,CAACW,IAAI;MACfC,WAAW,EAAEZ,IAAI,CAACa;IACtB,CAAC;EACL;AACJ","ignoreList":[]}

package/features/WriteFileMetadata/WriteMetadataAfterBatchCreateHandler.d.ts

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

package/features/WriteFileMetadata/WriteMetadataAfterBatchCreateHandler.js

@@ -0,0 +1,21 @@
+import { TenantContext } from "@webiny/api-core/features/TenantContext";
+import { FileAfterBatchCreateHandler } 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);
+  }
+}
+export const WriteMetadataAfterBatchCreateHandler = FileAfterBatchCreateHandler.createImplementation({
+  implementation: WriteMetadataAfterBatchCreateHandlerImpl,
+  dependencies: [TenantContext, GlobalKeyValueStore]
+});
+
+//# sourceMappingURL=WriteMetadataAfterBatchCreateHandler.js.map

package/features/WriteFileMetadata/WriteMetadataAfterBatchCreateHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TenantContext","FileAfterBatchCreateHandler","MetadataWriter","GlobalKeyValueStore","WriteMetadataAfterBatchCreateHandlerImpl","constructor","tenantContext","keyValueStore","metadataWriter","handle","event","files","payload","write","WriteMetadataAfterBatchCreateHandler","createImplementation","implementation","dependencies"],"sources":["WriteMetadataAfterBatchCreateHandler.ts"],"sourcesContent":["import { TenantContext } from \"@webiny/api-core/features/TenantContext\";\nimport { FileAfterBatchCreateHandler } 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 implements FileAfterBatchCreateHandler.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: FileAfterBatchCreateHandler.Event): Promise<void> {\n        const { files } = event.payload;\n        await this.metadataWriter.write(files);\n    }\n}\n\nexport const WriteMetadataAfterBatchCreateHandler =\n    FileAfterBatchCreateHandler.createImplementation({\n        implementation: WriteMetadataAfterBatchCreateHandlerImpl,\n        dependencies: [TenantContext, GlobalKeyValueStore]\n    });\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,yCAAyC;AACvE,SAASC,2BAA2B,QAAQ,qEAAqE;AACjH,SAASC,cAAc;AACvB,SAASC,mBAAmB,QAAQ,kDAAkD;AAEtF,MAAMC,wCAAwC,CAAkD;EAG5FC,WAAWA,CACPC,aAAsC,EACtCC,aAA4C,EAC9C;IACE,IAAI,CAACC,cAAc,GAAG,IAAIN,cAAc,CAACI,aAAa,EAAEC,aAAa,CAAC;EAC1E;EAEA,MAAME,MAAMA,CAACC,KAAwC,EAAiB;IAClE,MAAM;MAAEC;IAAM,CAAC,GAAGD,KAAK,CAACE,OAAO;IAC/B,MAAM,IAAI,CAACJ,cAAc,CAACK,KAAK,CAACF,KAAK,CAAC;EAC1C;AACJ;AAEA,OAAO,MAAMG,oCAAoC,GAC7Cb,2BAA2B,CAACc,oBAAoB,CAAC;EAC7CC,cAAc,EAAEZ,wCAAwC;EACxDa,YAAY,EAAE,CAACjB,aAAa,EAAEG,mBAAmB;AACrD,CAAC,CAAC","ignoreList":[]}

package/features/WriteFileMetadata/WriteMetadataAfterCreateHandler.d.ts

@@ -0,0 +1,12 @@
+import { FileAfterCreateHandler } 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 FileAfterCreateHandler.Interface {
+    private readonly metadataWriter;
+    constructor(tenantContext: TenantContext.Interface, keyValueStore: GlobalKeyValueStore.Interface);
+    handle(event: FileAfterCreateHandler.Event): Promise<void>;
+}
+export declare const WriteMetadataAfterCreateHandler: typeof WriteMetadataAfterCreateHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<import("@webiny/api-file-manager/features/file/CreateFile/events.js").FileAfterCreateEvent>>;
+};
+export {};

package/features/WriteFileMetadata/WriteMetadataAfterCreateHandler.js

@@ -0,0 +1,21 @@
+import { FileAfterCreateHandler } 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]);
+  }
+}
+export const WriteMetadataAfterCreateHandler = FileAfterCreateHandler.createImplementation({
+  implementation: WriteMetadataAfterCreateHandlerImpl,
+  dependencies: [TenantContext, GlobalKeyValueStore]
+});
+
+//# sourceMappingURL=WriteMetadataAfterCreateHandler.js.map

package/features/WriteFileMetadata/WriteMetadataAfterCreateHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["FileAfterCreateHandler","MetadataWriter","TenantContext","GlobalKeyValueStore","WriteMetadataAfterCreateHandlerImpl","constructor","tenantContext","keyValueStore","metadataWriter","handle","event","file","payload","write","WriteMetadataAfterCreateHandler","createImplementation","implementation","dependencies"],"sources":["WriteMetadataAfterCreateHandler.ts"],"sourcesContent":["import { FileAfterCreateHandler } 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 FileAfterCreateHandler.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: FileAfterCreateHandler.Event): Promise<void> {\n        const { file } = event.payload;\n        await this.metadataWriter.write([file]);\n    }\n}\n\nexport const WriteMetadataAfterCreateHandler = FileAfterCreateHandler.createImplementation({\n    implementation: WriteMetadataAfterCreateHandlerImpl,\n    dependencies: [TenantContext, GlobalKeyValueStore]\n});\n"],"mappings":"AAAA,SAASA,sBAAsB,QAAQ,6DAA6D;AACpG,SAASC,cAAc;AACvB,SAASC,aAAa,QAAQ,0DAA0D;AACxF,SAASC,mBAAmB,QAAQ,kDAAkD;AAEtF,MAAMC,mCAAmC,CAA6C;EAGlFC,WAAWA,CACPC,aAAsC,EACtCC,aAA4C,EAC9C;IACE,IAAI,CAACC,cAAc,GAAG,IAAIP,cAAc,CAACK,aAAa,EAAEC,aAAa,CAAC;EAC1E;EAEA,MAAME,MAAMA,CAACC,KAAmC,EAAiB;IAC7D,MAAM;MAAEC;IAAK,CAAC,GAAGD,KAAK,CAACE,OAAO;IAC9B,MAAM,IAAI,CAACJ,cAAc,CAACK,KAAK,CAAC,CAACF,IAAI,CAAC,CAAC;EAC3C;AACJ;AAEA,OAAO,MAAMG,+BAA+B,GAAGd,sBAAsB,CAACe,oBAAoB,CAAC;EACvFC,cAAc,EAAEZ,mCAAmC;EACnDa,YAAY,EAAE,CAACf,aAAa,EAAEC,mBAAmB;AACrD,CAAC,CAAC","ignoreList":[]}

package/features/WriteFileMetadata/feature.d.ts

@@ -0,0 +1 @@
+export declare const WriteFileMetadataFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/WriteFileMetadata/feature.js

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

package/features/WriteFileMetadata/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","WriteMetadataAfterCreateHandler","WriteMetadataAfterBatchCreateHandler","WriteFileMetadataFeature","name","register","container"],"sources":["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"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,+BAA+B;AACxC,SAASC,oCAAoC;AAE7C,OAAO,MAAMC,wBAAwB,GAAGH,aAAa,CAAC;EAClDI,IAAI,EAAE,iCAAiC;EACvCC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACJ,+BAA+B,CAAC;IACnDK,SAAS,CAACD,QAAQ,CAACH,oCAAoC,CAAC;EAC5D;AACJ,CAAC,CAAC","ignoreList":[]}

package/graphql/checkPermissions.d.ts

@@ -0,0 +1,5 @@
+import type { FilePermission } from "@webiny/api-file-manager/types.js";
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+export declare const checkPermissions: (identityContext: IdentityContext.Interface, check?: {
+    rwd?: string;
+}) => Promise<FilePermission[]>;

package/{plugins → graphql}/checkPermissions.js

@@ -1,12 +1,6 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.checkPermissions = void 0;
-var _apiSecurity = require("@webiny/api-security");
-const checkPermissions = async (context, check = {}) => {
-  const filePermissions = await context.security.getPermissions("fm.file");
+import { NotAuthorizedError } from "@webiny/api-core/features/security/shared/index.js";
+export const checkPermissions = async (identityContext, check = {}) => {
+  const filePermissions = await identityContext.getPermissions("fm.file");
   const relevantFilePermissions = filePermissions.filter(current => {
     if (check.rwd && !hasRwd(current, check.rwd)) {
       return false;
@@ -14,11 +8,10 @@ const checkPermissions = async (context, check = {}) => {
     return true;
   });
   if (relevantFilePermissions.length === 0) {
-    throw new _apiSecurity.NotAuthorizedError();
+    throw new NotAuthorizedError();
   }
   return relevantFilePermissions;
 };
-exports.checkPermissions = checkPermissions;
 const hasRwd = (filesFilePermissions, rwd) => {
   if (!Array.isArray(filesFilePermissions)) {
     filesFilePermissions = [filesFilePermissions];

package/graphql/checkPermissions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NotAuthorizedError","checkPermissions","identityContext","check","filePermissions","getPermissions","relevantFilePermissions","filter","current","rwd","hasRwd","length","filesFilePermissions","Array","isArray","permissionWithoutRwdRestrictions","some","permission","includes"],"sources":["checkPermissions.ts"],"sourcesContent":["import type { FilePermission } from \"@webiny/api-file-manager/types.js\";\nimport { NotAuthorizedError } from \"@webiny/api-core/features/security/shared/index.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/IdentityContext\";\n\nexport const checkPermissions = async (\n    identityContext: IdentityContext.Interface,\n    check: { rwd?: string } = {}\n) => {\n    const filePermissions = await identityContext.getPermissions<FilePermission>(\"fm.file\");\n\n    const relevantFilePermissions = filePermissions.filter(current => {\n        if (check.rwd && !hasRwd(current, check.rwd)) {\n            return false;\n        }\n\n        return true;\n    });\n\n    if (relevantFilePermissions.length === 0) {\n        throw new NotAuthorizedError();\n    }\n\n    return relevantFilePermissions;\n};\n\nconst hasRwd = (filesFilePermissions: FilePermission | FilePermission[], rwd: string): boolean => {\n    if (!Array.isArray(filesFilePermissions)) {\n        filesFilePermissions = [filesFilePermissions];\n    }\n\n    if (!rwd) {\n        return true;\n    }\n\n    // Is there a permission that doesn't restrict RWD permissions, that means all RWD permissions are allowed.\n    const permissionWithoutRwdRestrictions = filesFilePermissions.some(permission => {\n        return typeof permission.rwd !== \"string\";\n    });\n\n    if (permissionWithoutRwdRestrictions) {\n        return true;\n    }\n\n    // If there is no permission that doesn't restrict RWD permissions, that means we need to check if the RWD.\n    return filesFilePermissions.some(permission => {\n        return permission.rwd && permission.rwd.includes(rwd);\n    });\n};\n"],"mappings":"AACA,SAASA,kBAAkB,QAAQ,oDAAoD;AAGvF,OAAO,MAAMC,gBAAgB,GAAG,MAAAA,CAC5BC,eAA0C,EAC1CC,KAAuB,GAAG,CAAC,CAAC,KAC3B;EACD,MAAMC,eAAe,GAAG,MAAMF,eAAe,CAACG,cAAc,CAAiB,SAAS,CAAC;EAEvF,MAAMC,uBAAuB,GAAGF,eAAe,CAACG,MAAM,CAACC,OAAO,IAAI;IAC9D,IAAIL,KAAK,CAACM,GAAG,IAAI,CAACC,MAAM,CAACF,OAAO,EAAEL,KAAK,CAACM,GAAG,CAAC,EAAE;MAC1C,OAAO,KAAK;IAChB;IAEA,OAAO,IAAI;EACf,CAAC,CAAC;EAEF,IAAIH,uBAAuB,CAACK,MAAM,KAAK,CAAC,EAAE;IACtC,MAAM,IAAIX,kBAAkB,CAAC,CAAC;EAClC;EAEA,OAAOM,uBAAuB;AAClC,CAAC;AAED,MAAMI,MAAM,GAAGA,CAACE,oBAAuD,EAAEH,GAAW,KAAc;EAC9F,IAAI,CAACI,KAAK,CAACC,OAAO,CAACF,oBAAoB,CAAC,EAAE;IACtCA,oBAAoB,GAAG,CAACA,oBAAoB,CAAC;EACjD;EAEA,IAAI,CAACH,GAAG,EAAE;IACN,OAAO,IAAI;EACf;;EAEA;EACA,MAAMM,gCAAgC,GAAGH,oBAAoB,CAACI,IAAI,CAACC,UAAU,IAAI;IAC7E,OAAO,OAAOA,UAAU,CAACR,GAAG,KAAK,QAAQ;EAC7C,CAAC,CAAC;EAEF,IAAIM,gCAAgC,EAAE;IAClC,OAAO,IAAI;EACf;;EAEA;EACA,OAAOH,oBAAoB,CAACI,IAAI,CAACC,UAAU,IAAI;IAC3C,OAAOA,UAAU,CAACR,GAAG,IAAIQ,UAAU,CAACR,GAAG,CAACS,QAAQ,CAACT,GAAG,CAAC;EACzD,CAAC,CAAC;AACN,CAAC","ignoreList":[]}

package/graphql/schema.d.ts

@@ -0,0 +1 @@
+export declare const createS3GraphQLSchema: () => import("@webiny/handler-graphql").GraphQLSchemaPlugin<import("@webiny/api/types.js").Context>;