@webiny/api-headless-cms-import-export 5.41.0-beta.0

package/tasks/utils/cmsEntryZipper/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_CmsEntryZipper","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get","_CmsEntryZipperExecuteContinueResult","_CmsEntryZipperExecuteDoneResult","_CmsEntryZipperExecuteDoneResult2","_CmsEntryZipperExecuteContinueResult2","_CmsEntryZipper2"],"sources":["index.ts"],"sourcesContent":["export * from \"./CmsEntryZipper\";\nexport * from \"./CmsEntryZipperExecuteContinueResult\";\nexport * from \"./CmsEntryZipperExecuteDoneResult\";\nexport * from \"./abstractions/CmsEntryZipperExecuteDoneResult\";\nexport * from \"./abstractions/CmsEntryZipperExecuteContinueResult\";\nexport * from \"./abstractions/CmsEntryZipper\";\n"],"mappings":";;;;;AAAA,IAAAA,eAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,eAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,eAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAT,eAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AACA,IAAAK,oCAAA,GAAAT,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAO,oCAAA,EAAAN,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAK,oCAAA,CAAAL,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAC,oCAAA,CAAAL,GAAA;IAAA;EAAA;AAAA;AACA,IAAAM,gCAAA,GAAAV,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAQ,gCAAA,EAAAP,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAM,gCAAA,CAAAN,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAE,gCAAA,CAAAN,GAAA;IAAA;EAAA;AAAA;AACA,IAAAO,iCAAA,GAAAX,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAS,iCAAA,EAAAR,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAO,iCAAA,CAAAP,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAG,iCAAA,CAAAP,GAAA;IAAA;EAAA;AAAA;AACA,IAAAQ,qCAAA,GAAAZ,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAU,qCAAA,EAAAT,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAQ,qCAAA,CAAAR,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAI,qCAAA,CAAAR,GAAA;IAAA;EAAA;AAAA;AACA,IAAAS,gBAAA,GAAAb,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAW,gBAAA,EAAAV,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAS,gBAAA,CAAAT,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAK,gBAAA,CAAAT,GAAA;IAAA;EAAA;AAAA","ignoreList":[]}

package/tasks/utils/decompressor/CompressedFileReader.d.ts

@@ -0,0 +1,14 @@
+import type { S3Client } from "../helpers/s3Client";
+import type { IUnzipperFile } from "./abstractions/Decompressor";
+import type { ICompressedFileReader } from "./abstractions/CompressedFileReader";
+export interface ICompressedFileReaderParams {
+    client: S3Client;
+    bucket: string;
+}
+export declare class CompressedFileReader implements ICompressedFileReader {
+    private readonly client;
+    private readonly bucket;
+    constructor(params: ICompressedFileReaderParams);
+    read(target: string): Promise<IUnzipperFile[]>;
+}
+export declare const createCompressedFileReader: (params: ICompressedFileReaderParams) => ICompressedFileReader;

package/tasks/utils/decompressor/CompressedFileReader.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCompressedFileReader = exports.CompressedFileReader = void 0;
+var _unzipper = require("unzipper");
+class CompressedFileReader {
+  constructor(params) {
+    this.client = params.client;
+    this.bucket = params.bucket;
+  }
+  async read(target) {
+    const result = await _unzipper.Open.s3_v3(this.client, {
+      Bucket: this.bucket,
+      Key: target
+    });
+    return result.files.filter(file => {
+      return file.type === "File";
+    });
+  }
+}
+exports.CompressedFileReader = CompressedFileReader;
+const createCompressedFileReader = params => {
+  return new CompressedFileReader(params);
+};
+exports.createCompressedFileReader = createCompressedFileReader;
+
+//# sourceMappingURL=CompressedFileReader.js.map

package/tasks/utils/decompressor/CompressedFileReader.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_unzipper","require","CompressedFileReader","constructor","params","client","bucket","read","target","result","Open","s3_v3","Bucket","Key","files","filter","file","type","exports","createCompressedFileReader"],"sources":["CompressedFileReader.ts"],"sourcesContent":["import { Open } from \"unzipper\";\nimport type { S3Client } from \"../helpers/s3Client\";\nimport type { IUnzipperFile } from \"./abstractions/Decompressor\";\nimport type { ICompressedFileReader } from \"./abstractions/CompressedFileReader\";\n\nexport interface ICompressedFileReaderParams {\n    client: S3Client;\n    bucket: string;\n}\n\nexport class CompressedFileReader implements ICompressedFileReader {\n    private readonly client: S3Client;\n    private readonly bucket: string;\n\n    public constructor(params: ICompressedFileReaderParams) {\n        this.client = params.client;\n        this.bucket = params.bucket;\n    }\n\n    public async read(target: string): Promise<IUnzipperFile[]> {\n        const result = await Open.s3_v3(this.client, {\n            Bucket: this.bucket,\n            Key: target\n        });\n        return result.files.filter(file => {\n            return file.type === \"File\";\n        });\n    }\n}\n\nexport const createCompressedFileReader = (\n    params: ICompressedFileReaderParams\n): ICompressedFileReader => {\n    return new CompressedFileReader(params);\n};\n"],"mappings":";;;;;;AAAA,IAAAA,SAAA,GAAAC,OAAA;AAUO,MAAMC,oBAAoB,CAAkC;EAIxDC,WAAWA,CAACC,MAAmC,EAAE;IACpD,IAAI,CAACC,MAAM,GAAGD,MAAM,CAACC,MAAM;IAC3B,IAAI,CAACC,MAAM,GAAGF,MAAM,CAACE,MAAM;EAC/B;EAEA,MAAaC,IAAIA,CAACC,MAAc,EAA4B;IACxD,MAAMC,MAAM,GAAG,MAAMC,cAAI,CAACC,KAAK,CAAC,IAAI,CAACN,MAAM,EAAE;MACzCO,MAAM,EAAE,IAAI,CAACN,MAAM;MACnBO,GAAG,EAAEL;IACT,CAAC,CAAC;IACF,OAAOC,MAAM,CAACK,KAAK,CAACC,MAAM,CAACC,IAAI,IAAI;MAC/B,OAAOA,IAAI,CAACC,IAAI,KAAK,MAAM;IAC/B,CAAC,CAAC;EACN;AACJ;AAACC,OAAA,CAAAhB,oBAAA,GAAAA,oBAAA;AAEM,MAAMiB,0BAA0B,GACnCf,MAAmC,IACX;EACxB,OAAO,IAAIF,oBAAoB,CAACE,MAAM,CAAC;AAC3C,CAAC;AAACc,OAAA,CAAAC,0BAAA,GAAAA,0BAAA","ignoreList":[]}

package/tasks/utils/decompressor/Decompressor.d.ts

@@ -0,0 +1,18 @@
+import type { IDecompressor, IDecompressorDecompressParams, IUnzipperFile } from "./abstractions/Decompressor";
+import type { IMultipartUploadFactory, IUploadDoneResult } from "../upload";
+export interface IDecompressorParamsUploadCreateFactory {
+    (filename: string): IMultipartUploadFactory;
+}
+export interface IDecompressorParams {
+    createUploadFactory: IDecompressorParamsUploadCreateFactory;
+}
+export declare class Decompressor implements IDecompressor {
+    private readonly createUploadFactory;
+    constructor(params: IDecompressorParams);
+    /**
+     * Should not be used with large files (> 10/20MB)
+     */
+    read(files: IUnzipperFile[], target: string): Promise<string>;
+    extract(params: IDecompressorDecompressParams): Promise<IUploadDoneResult>;
+}
+export declare const createDecompressor: (params: IDecompressorParams) => IDecompressor;

package/tasks/utils/decompressor/Decompressor.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDecompressor = exports.Decompressor = void 0;
+var _stream = require("stream");
+class Decompressor {
+  constructor(params) {
+    this.createUploadFactory = params.createUploadFactory;
+  }
+  /**
+   * Should not be used with large files (> 10/20MB)
+   */
+  async read(files, target) {
+    const file = files.find(f => f.path === target);
+    if (!file) {
+      throw new Error(`File "${target}" not found in the compressed file.`);
+    }
+    const buffer = await file.buffer();
+    return buffer.toString();
+  }
+  async extract(params) {
+    const {
+      source,
+      target
+    } = params;
+    const factory = this.createUploadFactory(target);
+    const multipartUpload = await factory.start();
+    const promises = [];
+    const localStream = new _stream.PassThrough({
+      autoDestroy: true
+    }).on("error", err => {
+      console.log("Decompressor Local Stream Error", err);
+      throw err;
+    }).on("data", data => {
+      const p = multipartUpload.add(data);
+      promises.push(p);
+    });
+    let stream;
+    try {
+      stream = source.stream();
+    } catch (ex) {
+      console.error(`Failed to create stream for "${source.path}".`, ex);
+      throw ex;
+    }
+    return new Promise((resolve, reject) => {
+      let alreadyDone = false;
+      let alreadyError = false;
+      const done = async () => {
+        if (alreadyDone) {
+          return;
+        }
+        alreadyDone = true;
+        try {
+          await Promise.all(promises);
+          const result = await multipartUpload.complete();
+          resolve(result.result);
+        } catch (ex) {
+          console.error("Failed to upload file.", ex);
+          multipartUpload.abort();
+          reject(ex);
+        } finally {
+          stream.destroy();
+        }
+      };
+      const error = async err => {
+        if (alreadyError) {
+          return;
+        }
+        alreadyError = true;
+        try {
+          await multipartUpload.abort();
+          reject(err);
+        } catch (ex) {
+          reject(ex);
+        } finally {
+          stream.destroy();
+        }
+      };
+      stream.pipe(localStream).on("finish", () => {
+        done();
+      }).on("error", err => {
+        error(err);
+      });
+    });
+  }
+}
+exports.Decompressor = Decompressor;
+const createDecompressor = params => {
+  return new Decompressor(params);
+};
+exports.createDecompressor = createDecompressor;
+
+//# sourceMappingURL=Decompressor.js.map

package/tasks/utils/decompressor/Decompressor.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_stream","require","Decompressor","constructor","params","createUploadFactory","read","files","target","file","find","f","path","Error","buffer","toString","extract","source","factory","multipartUpload","start","promises","localStream","PassThrough","autoDestroy","on","err","console","log","data","p","add","push","stream","ex","error","Promise","resolve","reject","alreadyDone","alreadyError","done","all","result","complete","abort","destroy","pipe","exports","createDecompressor"],"sources":["Decompressor.ts"],"sourcesContent":["import type {\n    IDecompressor,\n    IDecompressorDecompressParams,\n    IUnzipperFile\n} from \"./abstractions/Decompressor\";\nimport type {\n    IMultipartUploadFactory,\n    IMultipartUploadHandlerAddResult,\n    IUploadDoneResult\n} from \"~/tasks/utils/upload\";\nimport type { Entry } from \"unzipper\";\nimport { PassThrough } from \"stream\";\n\nexport interface IDecompressorParamsUploadCreateFactory {\n    (filename: string): IMultipartUploadFactory;\n}\n\nexport interface IDecompressorParams {\n    createUploadFactory: IDecompressorParamsUploadCreateFactory;\n}\n\nexport class Decompressor implements IDecompressor {\n    private readonly createUploadFactory: IDecompressorParamsUploadCreateFactory;\n\n    public constructor(params: IDecompressorParams) {\n        this.createUploadFactory = params.createUploadFactory;\n    }\n    /**\n     * Should not be used with large files (> 10/20MB)\n     */\n    public async read(files: IUnzipperFile[], target: string): Promise<string> {\n        const file = files.find(f => f.path === target);\n        if (!file) {\n            throw new Error(`File \"${target}\" not found in the compressed file.`);\n        }\n\n        const buffer = await file.buffer();\n\n        return buffer.toString();\n    }\n\n    public async extract(params: IDecompressorDecompressParams): Promise<IUploadDoneResult> {\n        const { source, target } = params;\n\n        const factory = this.createUploadFactory(target);\n\n        const multipartUpload = await factory.start();\n\n        const promises: Promise<IMultipartUploadHandlerAddResult>[] = [];\n\n        const localStream = new PassThrough({\n            autoDestroy: true\n        })\n            .on(\"error\", err => {\n                console.log(\"Decompressor Local Stream Error\", err);\n                throw err;\n            })\n            .on(\"data\", data => {\n                const p = multipartUpload.add(data);\n                promises.push(p);\n            });\n\n        let stream: Entry;\n        try {\n            stream = source.stream();\n        } catch (ex) {\n            console.error(`Failed to create stream for \"${source.path}\".`, ex);\n            throw ex;\n        }\n        return new Promise<IUploadDoneResult>((resolve, reject) => {\n            let alreadyDone = false;\n            let alreadyError = false;\n\n            const done = async (): Promise<void> => {\n                if (alreadyDone) {\n                    return;\n                }\n                alreadyDone = true;\n                try {\n                    await Promise.all(promises);\n                    const result = await multipartUpload.complete();\n                    resolve(result.result);\n                } catch (ex) {\n                    console.error(\"Failed to upload file.\", ex);\n                    multipartUpload.abort();\n                    reject(ex);\n                } finally {\n                    stream.destroy();\n                }\n            };\n\n            const error = async (err: Error): Promise<void> => {\n                if (alreadyError) {\n                    return;\n                }\n                alreadyError = true;\n                try {\n                    await multipartUpload.abort();\n                    reject(err);\n                } catch (ex) {\n                    reject(ex);\n                } finally {\n                    stream.destroy();\n                }\n            };\n\n            stream\n                .pipe(localStream)\n                .on(\"finish\", () => {\n                    done();\n                })\n                .on(\"error\", err => {\n                    error(err);\n                });\n        });\n    }\n}\n\nexport const createDecompressor = (params: IDecompressorParams): IDecompressor => {\n    return new Decompressor(params);\n};\n"],"mappings":"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","ignoreList":[]}

package/tasks/utils/decompressor/abstractions/CompressedFileReader.d.ts

@@ -0,0 +1,4 @@
+import type { IUnzipperFile } from "..";
+export interface ICompressedFileReader {
+    read(target: string): Promise<IUnzipperFile[]>;
+}

package/tasks/utils/decompressor/abstractions/CompressedFileReader.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+//# sourceMappingURL=CompressedFileReader.js.map

package/tasks/utils/decompressor/abstractions/CompressedFileReader.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["CompressedFileReader.ts"],"sourcesContent":["import type { IUnzipperFile } from \"~/tasks/utils/decompressor\";\n\nexport interface ICompressedFileReader {\n    read(target: string): Promise<IUnzipperFile[]>;\n}\n"],"mappings":"","ignoreList":[]}

package/tasks/utils/decompressor/abstractions/Decompressor.d.ts

@@ -0,0 +1,11 @@
+import type { IUploadDoneResult } from "../../upload";
+import type { File as IUnzipperFile } from "unzipper";
+export type { IUnzipperFile };
+export interface IDecompressorDecompressParams {
+    source: IUnzipperFile;
+    target: string;
+}
+export interface IDecompressor {
+    read(files: IUnzipperFile[], target: string): Promise<string>;
+    extract(params: IDecompressorDecompressParams): Promise<IUploadDoneResult>;
+}

package/tasks/utils/decompressor/abstractions/Decompressor.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+//# sourceMappingURL=Decompressor.js.map

package/tasks/utils/decompressor/abstractions/Decompressor.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["Decompressor.ts"],"sourcesContent":["import type { IUploadDoneResult } from \"~/tasks/utils/upload\";\nimport type { File as IUnzipperFile } from \"unzipper\";\n\nexport type { IUnzipperFile };\n\nexport interface IDecompressorDecompressParams {\n    source: IUnzipperFile;\n    target: string;\n}\n\nexport interface IDecompressor {\n    read(files: IUnzipperFile[], target: string): Promise<string>;\n    extract(params: IDecompressorDecompressParams): Promise<IUploadDoneResult>;\n}\n"],"mappings":"","ignoreList":[]}

package/tasks/utils/decompressor/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./abstractions/CompressedFileReader";
+export * from "./abstractions/Decompressor";
+export * from "./CompressedFileReader";
+export * from "./Decompressor";

package/tasks/utils/decompressor/index.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _CompressedFileReader = require("./abstractions/CompressedFileReader");
+Object.keys(_CompressedFileReader).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _CompressedFileReader[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _CompressedFileReader[key];
+    }
+  });
+});
+var _Decompressor = require("./abstractions/Decompressor");
+Object.keys(_Decompressor).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Decompressor[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Decompressor[key];
+    }
+  });
+});
+var _CompressedFileReader2 = require("./CompressedFileReader");
+Object.keys(_CompressedFileReader2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _CompressedFileReader2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _CompressedFileReader2[key];
+    }
+  });
+});
+var _Decompressor2 = require("./Decompressor");
+Object.keys(_Decompressor2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Decompressor2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Decompressor2[key];
+    }
+  });
+});
+
+//# sourceMappingURL=index.js.map

package/tasks/utils/decompressor/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_CompressedFileReader","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get","_Decompressor","_CompressedFileReader2","_Decompressor2"],"sources":["index.ts"],"sourcesContent":["export * from \"./abstractions/CompressedFileReader\";\nexport * from \"./abstractions/Decompressor\";\nexport * from \"./CompressedFileReader\";\nexport * from \"./Decompressor\";\n"],"mappings":";;;;;AAAA,IAAAA,qBAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,qBAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,qBAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAT,qBAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AACA,IAAAK,aAAA,GAAAT,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAO,aAAA,EAAAN,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAK,aAAA,CAAAL,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAC,aAAA,CAAAL,GAAA;IAAA;EAAA;AAAA;AACA,IAAAM,sBAAA,GAAAV,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAQ,sBAAA,EAAAP,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAM,sBAAA,CAAAN,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAE,sBAAA,CAAAN,GAAA;IAAA;EAAA;AAAA;AACA,IAAAO,cAAA,GAAAX,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAS,cAAA,EAAAR,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAO,cAAA,CAAAP,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAG,cAAA,CAAAP,GAAA;IAAA;EAAA;AAAA","ignoreList":[]}

package/tasks/utils/deleteFiles/DeleteFiles.d.ts

@@ -0,0 +1,11 @@
+import type { IDeleteFiles, IDeleteFilesExecuteInput } from "./abstractions/DeleteFiles";
+import type { IFileFetcher } from "../fileFetcher";
+export interface IDeleteFilesParams {
+    fileFetcher: IFileFetcher;
+}
+export declare class DeleteFiles implements IDeleteFiles {
+    private readonly fileFetcher;
+    constructor(params: IDeleteFilesParams);
+    execute(input: IDeleteFilesExecuteInput): Promise<void>;
+}
+export declare const createDeleteFiles: () => IDeleteFiles;

package/tasks/utils/deleteFiles/DeleteFiles.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDeleteFiles = exports.DeleteFiles = void 0;
+var _s3Client = require("../helpers/s3Client");
+var _fileFetcher = require("../fileFetcher");
+var _getBucket = require("../helpers/getBucket");
+class DeleteFiles {
+  constructor(params) {
+    this.fileFetcher = params.fileFetcher;
+  }
+  async execute(input) {
+    if (!input) {
+      return;
+    }
+    const files = (Array.isArray(input) ? input : [input]).filter(file => {
+      return !!file;
+    });
+    for (const file of files) {
+      const exists = await this.fileFetcher.exists(file);
+      if (!exists) {
+        continue;
+      }
+      try {
+        const result = await this.fileFetcher.delete(file);
+        if (!result.$metadata) {
+          continue;
+        }
+        if (result.$metadata.httpStatusCode !== 200) {
+          console.log(`Failed to delete file "${file}".`);
+        }
+      } catch (ex) {
+        console.log(`Failed to delete file "${file}".`, ex);
+      }
+    }
+  }
+}
+exports.DeleteFiles = DeleteFiles;
+const createDeleteFiles = () => {
+  const client = (0, _s3Client.createS3Client)();
+  const bucket = (0, _getBucket.getBucket)();
+  return new DeleteFiles({
+    fileFetcher: new _fileFetcher.FileFetcher({
+      client,
+      bucket
+    })
+  });
+};
+exports.createDeleteFiles = createDeleteFiles;
+
+//# sourceMappingURL=DeleteFiles.js.map

package/tasks/utils/deleteFiles/DeleteFiles.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_s3Client","require","_fileFetcher","_getBucket","DeleteFiles","constructor","params","fileFetcher","execute","input","files","Array","isArray","filter","file","exists","result","delete","$metadata","httpStatusCode","console","log","ex","exports","createDeleteFiles","client","createS3Client","bucket","getBucket","FileFetcher"],"sources":["DeleteFiles.ts"],"sourcesContent":["import type {\n    IDeleteFiles,\n    IDeleteFilesExecuteInput\n} from \"~/tasks/utils/deleteFiles/abstractions/DeleteFiles\";\nimport { createS3Client } from \"../helpers/s3Client\";\nimport { FileFetcher } from \"~/tasks/utils/fileFetcher\";\nimport type { IFileFetcher } from \"~/tasks/utils/fileFetcher\";\nimport { getBucket } from \"../helpers/getBucket\";\n\nexport interface IDeleteFilesParams {\n    fileFetcher: IFileFetcher;\n}\n\nexport class DeleteFiles implements IDeleteFiles {\n    private readonly fileFetcher: IFileFetcher;\n\n    public constructor(params: IDeleteFilesParams) {\n        this.fileFetcher = params.fileFetcher;\n    }\n\n    public async execute(input: IDeleteFilesExecuteInput): Promise<void> {\n        if (!input) {\n            return;\n        }\n        const files = (Array.isArray(input) ? input : [input]).filter((file): file is string => {\n            return !!file;\n        });\n        for (const file of files) {\n            const exists = await this.fileFetcher.exists(file);\n            if (!exists) {\n                continue;\n            }\n            try {\n                const result = await this.fileFetcher.delete(file);\n                if (!result.$metadata) {\n                    continue;\n                }\n                if (result.$metadata.httpStatusCode !== 200) {\n                    console.log(`Failed to delete file \"${file}\".`);\n                }\n            } catch (ex) {\n                console.log(`Failed to delete file \"${file}\".`, ex);\n            }\n        }\n    }\n}\n\nexport const createDeleteFiles = (): IDeleteFiles => {\n    const client = createS3Client();\n    const bucket = getBucket();\n    return new DeleteFiles({\n        fileFetcher: new FileFetcher({\n            client,\n            bucket\n        })\n    });\n};\n"],"mappings":";;;;;;AAIA,IAAAA,SAAA,GAAAC,OAAA;AACA,IAAAC,YAAA,GAAAD,OAAA;AAEA,IAAAE,UAAA,GAAAF,OAAA;AAMO,MAAMG,WAAW,CAAyB;EAGtCC,WAAWA,CAACC,MAA0B,EAAE;IAC3C,IAAI,CAACC,WAAW,GAAGD,MAAM,CAACC,WAAW;EACzC;EAEA,MAAaC,OAAOA,CAACC,KAA+B,EAAiB;IACjE,IAAI,CAACA,KAAK,EAAE;MACR;IACJ;IACA,MAAMC,KAAK,GAAG,CAACC,KAAK,CAACC,OAAO,CAACH,KAAK,CAAC,GAAGA,KAAK,GAAG,CAACA,KAAK,CAAC,EAAEI,MAAM,CAAEC,IAAI,IAAqB;MACpF,OAAO,CAAC,CAACA,IAAI;IACjB,CAAC,CAAC;IACF,KAAK,MAAMA,IAAI,IAAIJ,KAAK,EAAE;MACtB,MAAMK,MAAM,GAAG,MAAM,IAAI,CAACR,WAAW,CAACQ,MAAM,CAACD,IAAI,CAAC;MAClD,IAAI,CAACC,MAAM,EAAE;QACT;MACJ;MACA,IAAI;QACA,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACT,WAAW,CAACU,MAAM,CAACH,IAAI,CAAC;QAClD,IAAI,CAACE,MAAM,CAACE,SAAS,EAAE;UACnB;QACJ;QACA,IAAIF,MAAM,CAACE,SAAS,CAACC,cAAc,KAAK,GAAG,EAAE;UACzCC,OAAO,CAACC,GAAG,CAAE,0BAAyBP,IAAK,IAAG,CAAC;QACnD;MACJ,CAAC,CAAC,OAAOQ,EAAE,EAAE;QACTF,OAAO,CAACC,GAAG,CAAE,0BAAyBP,IAAK,IAAG,EAAEQ,EAAE,CAAC;MACvD;IACJ;EACJ;AACJ;AAACC,OAAA,CAAAnB,WAAA,GAAAA,WAAA;AAEM,MAAMoB,iBAAiB,GAAGA,CAAA,KAAoB;EACjD,MAAMC,MAAM,GAAG,IAAAC,wBAAc,EAAC,CAAC;EAC/B,MAAMC,MAAM,GAAG,IAAAC,oBAAS,EAAC,CAAC;EAC1B,OAAO,IAAIxB,WAAW,CAAC;IACnBG,WAAW,EAAE,IAAIsB,wBAAW,CAAC;MACzBJ,MAAM;MACNE;IACJ,CAAC;EACL,CAAC,CAAC;AACN,CAAC;AAACJ,OAAA,CAAAC,iBAAA,GAAAA,iBAAA","ignoreList":[]}

package/tasks/utils/deleteFiles/abstractions/DeleteFiles.d.ts

@@ -0,0 +1,8 @@
+export type IDeleteFilesExecuteInput = string | string[] | undefined | null;
+export interface IDeleteFiles {
+    /**
+     * This method should take a file or an array of file paths and delete them.
+     * It should log errors if any occur.
+     */
+    execute(input: IDeleteFilesExecuteInput): Promise<void>;
+}

package/tasks/utils/deleteFiles/abstractions/DeleteFiles.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+//# sourceMappingURL=DeleteFiles.js.map

package/tasks/utils/deleteFiles/abstractions/DeleteFiles.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["DeleteFiles.ts"],"sourcesContent":["export type IDeleteFilesExecuteInput = string | string[] | undefined | null;\n\nexport interface IDeleteFiles {\n    /**\n     * This method should take a file or an array of file paths and delete them.\n     * It should log errors if any occur.\n     */\n    execute(input: IDeleteFilesExecuteInput): Promise<void>;\n}\n"],"mappings":"","ignoreList":[]}

package/tasks/utils/entryAssets/EntryAssets.d.ts

@@ -0,0 +1,15 @@
+import type { IContentEntryTraverser } from "@webiny/api-headless-cms";
+import type { IAsset, IAssignAssetsInput, IEntryAssets } from "./abstractions/EntryAssets";
+import type { IUniqueResolver } from "../uniqueResolver/abstractions/UniqueResolver";
+export interface IEntryAssetsParams {
+    traverser: IContentEntryTraverser;
+    uniqueResolver: IUniqueResolver<IAsset>;
+}
+export declare class EntryAssets implements IEntryAssets {
+    private readonly uniqueResolver;
+    private readonly traverser;
+    constructor(params: IEntryAssetsParams);
+    assignAssets(input: IAssignAssetsInput): Promise<IAsset[]>;
+    private parseAssetSrc;
+    private assignAssetsToItems;
+}

package/tasks/utils/entryAssets/EntryAssets.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EntryAssets = void 0;
+var _matchKeyOrAlias = require("../helpers/matchKeyOrAlias");
+const fileTypes = ["file"];
+class EntryAssets {
+  constructor(params) {
+    this.traverser = params.traverser;
+    this.uniqueResolver = params.uniqueResolver;
+  }
+  async assignAssets(input) {
+    const entries = Array.isArray(input) ? input : [input];
+    if (entries.length === 0) {
+      return [];
+    }
+    const assets = [];
+    for (const entry of entries) {
+      if (!entry?.values) {
+        continue;
+      }
+      await this.traverser.traverse(entry.values, ({
+        field,
+        value
+      }) => {
+        if (!value || fileTypes.includes(field.type) === false) {
+          return;
+        }
+        assets.push(...this.assignAssetsToItems(value));
+      });
+    }
+    return assets;
+  }
+  parseAssetSrc(input) {
+    if (!input || typeof input !== "string" || !input.trim()) {
+      return null;
+    }
+    const result = (0, _matchKeyOrAlias.matchKeyOrAlias)(input);
+    if (!result) {
+      return null;
+    }
+    return {
+      ...result,
+      url: input
+    };
+  }
+  assignAssetsToItems(input) {
+    const assets = {};
+    if (!input) {
+      return [];
+    }
+    const inputArray = Array.isArray(input) ? input : [input];
+    for (const src of inputArray) {
+      const asset = this.parseAssetSrc(src);
+      if (!asset) {
+        continue;
+      } else if (assets[asset.url]) {
+        continue;
+      }
+      assets[asset.url] = asset;
+    }
+    return this.uniqueResolver.resolve(Object.values(assets), "url");
+  }
+}
+exports.EntryAssets = EntryAssets;
+
+//# sourceMappingURL=EntryAssets.js.map

package/tasks/utils/entryAssets/EntryAssets.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_matchKeyOrAlias","require","fileTypes","EntryAssets","constructor","params","traverser","uniqueResolver","assignAssets","input","entries","Array","isArray","length","assets","entry","values","traverse","field","value","includes","type","push","assignAssetsToItems","parseAssetSrc","trim","result","matchKeyOrAlias","url","inputArray","src","asset","resolve","Object","exports"],"sources":["EntryAssets.ts"],"sourcesContent":["import type { IContentEntryTraverser } from \"@webiny/api-headless-cms\";\nimport { matchKeyOrAlias } from \"~/tasks/utils/helpers/matchKeyOrAlias\";\nimport type { IAsset, IAssignAssetsInput, IEntryAssets } from \"./abstractions/EntryAssets\";\nimport type { GenericRecord } from \"@webiny/api/types\";\nimport type { IUniqueResolver } from \"~/tasks/utils/uniqueResolver/abstractions/UniqueResolver\";\n\nexport interface IEntryAssetsParams {\n    traverser: IContentEntryTraverser;\n    uniqueResolver: IUniqueResolver<IAsset>;\n}\n\nconst fileTypes: string[] = [\"file\"];\n\nexport class EntryAssets implements IEntryAssets {\n    private readonly uniqueResolver: IUniqueResolver<IAsset>;\n\n    private readonly traverser: IContentEntryTraverser;\n\n    public constructor(params: IEntryAssetsParams) {\n        this.traverser = params.traverser;\n        this.uniqueResolver = params.uniqueResolver;\n    }\n\n    public async assignAssets(input: IAssignAssetsInput): Promise<IAsset[]> {\n        const entries = Array.isArray(input) ? input : [input];\n        if (entries.length === 0) {\n            return [];\n        }\n\n        const assets: IAsset[] = [];\n\n        for (const entry of entries) {\n            if (!entry?.values) {\n                continue;\n            }\n            await this.traverser.traverse(entry.values, ({ field, value }) => {\n                if (!value || fileTypes.includes(field.type) === false) {\n                    return;\n                }\n\n                assets.push(...this.assignAssetsToItems(value));\n            });\n        }\n        return assets;\n    }\n\n    private parseAssetSrc(input?: string | unknown): IAsset | null {\n        if (!input || typeof input !== \"string\" || !input.trim()) {\n            return null;\n        }\n\n        const result = matchKeyOrAlias(input);\n        if (!result) {\n            return null;\n        }\n        return {\n            ...result,\n            url: input\n        };\n    }\n\n    private assignAssetsToItems(input: string | string[] | unknown): IAsset[] {\n        const assets: GenericRecord<string, IAsset> = {};\n        if (!input) {\n            return [];\n        }\n        const inputArray: string[] = Array.isArray(input) ? input : [input];\n        for (const src of inputArray) {\n            const asset = this.parseAssetSrc(src);\n            if (!asset) {\n                continue;\n            } else if (assets[asset.url]) {\n                continue;\n            }\n            assets[asset.url] = asset;\n        }\n        return this.uniqueResolver.resolve(Object.values(assets), \"url\");\n    }\n}\n"],"mappings":";;;;;;AACA,IAAAA,gBAAA,GAAAC,OAAA;AAUA,MAAMC,SAAmB,GAAG,CAAC,MAAM,CAAC;AAE7B,MAAMC,WAAW,CAAyB;EAKtCC,WAAWA,CAACC,MAA0B,EAAE;IAC3C,IAAI,CAACC,SAAS,GAAGD,MAAM,CAACC,SAAS;IACjC,IAAI,CAACC,cAAc,GAAGF,MAAM,CAACE,cAAc;EAC/C;EAEA,MAAaC,YAAYA,CAACC,KAAyB,EAAqB;IACpE,MAAMC,OAAO,GAAGC,KAAK,CAACC,OAAO,CAACH,KAAK,CAAC,GAAGA,KAAK,GAAG,CAACA,KAAK,CAAC;IACtD,IAAIC,OAAO,CAACG,MAAM,KAAK,CAAC,EAAE;MACtB,OAAO,EAAE;IACb;IAEA,MAAMC,MAAgB,GAAG,EAAE;IAE3B,KAAK,MAAMC,KAAK,IAAIL,OAAO,EAAE;MACzB,IAAI,CAACK,KAAK,EAAEC,MAAM,EAAE;QAChB;MACJ;MACA,MAAM,IAAI,CAACV,SAAS,CAACW,QAAQ,CAACF,KAAK,CAACC,MAAM,EAAE,CAAC;QAAEE,KAAK;QAAEC;MAAM,CAAC,KAAK;QAC9D,IAAI,CAACA,KAAK,IAAIjB,SAAS,CAACkB,QAAQ,CAACF,KAAK,CAACG,IAAI,CAAC,KAAK,KAAK,EAAE;UACpD;QACJ;QAEAP,MAAM,CAACQ,IAAI,CAAC,GAAG,IAAI,CAACC,mBAAmB,CAACJ,KAAK,CAAC,CAAC;MACnD,CAAC,CAAC;IACN;IACA,OAAOL,MAAM;EACjB;EAEQU,aAAaA,CAACf,KAAwB,EAAiB;IAC3D,IAAI,CAACA,KAAK,IAAI,OAAOA,KAAK,KAAK,QAAQ,IAAI,CAACA,KAAK,CAACgB,IAAI,CAAC,CAAC,EAAE;MACtD,OAAO,IAAI;IACf;IAEA,MAAMC,MAAM,GAAG,IAAAC,gCAAe,EAAClB,KAAK,CAAC;IACrC,IAAI,CAACiB,MAAM,EAAE;MACT,OAAO,IAAI;IACf;IACA,OAAO;MACH,GAAGA,MAAM;MACTE,GAAG,EAAEnB;IACT,CAAC;EACL;EAEQc,mBAAmBA,CAACd,KAAkC,EAAY;IACtE,MAAMK,MAAqC,GAAG,CAAC,CAAC;IAChD,IAAI,CAACL,KAAK,EAAE;MACR,OAAO,EAAE;IACb;IACA,MAAMoB,UAAoB,GAAGlB,KAAK,CAACC,OAAO,CAACH,KAAK,CAAC,GAAGA,KAAK,GAAG,CAACA,KAAK,CAAC;IACnE,KAAK,MAAMqB,GAAG,IAAID,UAAU,EAAE;MAC1B,MAAME,KAAK,GAAG,IAAI,CAACP,aAAa,CAACM,GAAG,CAAC;MACrC,IAAI,CAACC,KAAK,EAAE;QACR;MACJ,CAAC,MAAM,IAAIjB,MAAM,CAACiB,KAAK,CAACH,GAAG,CAAC,EAAE;QAC1B;MACJ;MACAd,MAAM,CAACiB,KAAK,CAACH,GAAG,CAAC,GAAGG,KAAK;IAC7B;IACA,OAAO,IAAI,CAACxB,cAAc,CAACyB,OAAO,CAACC,MAAM,CAACjB,MAAM,CAACF,MAAM,CAAC,EAAE,KAAK,CAAC;EACpE;AACJ;AAACoB,OAAA,CAAA/B,WAAA,GAAAA,WAAA","ignoreList":[]}

package/tasks/utils/entryAssets/EntryAssetsResolver.d.ts

@@ -0,0 +1,18 @@
+import type { File, FileListMeta, FilesListOpts } from "@webiny/api-file-manager/types";
+import type { IEntryAssetsResolver, IResolvedAsset } from "./abstractions/EntryAssetsResolver";
+import type { IAsset } from "./abstractions/EntryAssets";
+export interface IFetchFilesCbResult {
+    items: File[];
+    meta: FileListMeta;
+}
+export interface IFetchFilesCb {
+    (opts?: FilesListOpts): Promise<IFetchFilesCbResult>;
+}
+export interface IEntryAssetsResolverParams {
+    fetchFiles: IFetchFilesCb;
+}
+export declare class EntryAssetsResolver implements IEntryAssetsResolver {
+    private readonly fetchFiles;
+    constructor(params: IEntryAssetsResolverParams);
+    resolve(input: IAsset[]): Promise<IResolvedAsset[]>;
+}

package/tasks/utils/entryAssets/EntryAssetsResolver.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EntryAssetsResolver = void 0;
+const createResolvedAsset = file => {
+  const result = {
+    ...file,
+    aliases: file.aliases || []
+  };
+  /**
+   * We need to remove unnecessary fields from the resolved assets.
+   *
+   * We cannot return specific fields, rather than deleting unnecessary ones, because a user can extend the file model
+   * so we would not know which fields to return.
+   */
+  delete result.savedBy;
+  delete result.savedOn;
+  delete result.modifiedBy;
+  delete result.modifiedOn;
+  delete result.accessControl;
+  delete result.createdBy;
+  delete result.createdOn;
+  delete result.tenant;
+  delete result.locale;
+  delete result.webinyVersion;
+  return result;
+};
+class EntryAssetsResolver {
+  constructor(params) {
+    this.fetchFiles = params.fetchFiles;
+  }
+  async resolve(input) {
+    const keys = [];
+    const aliases = [];
+    for (const asset of input) {
+      if (asset.key) {
+        keys.push(asset.key);
+      } else if (asset.alias) {
+        aliases.push(asset.alias);
+      }
+    }
+    const assets = [];
+    const where = {};
+    if (keys.length > 0 && aliases.length > 0) {
+      where.OR = [{
+        key_in: keys
+      }, {
+        aliases_in: aliases
+      }];
+    } else if (keys.length > 0) {
+      where.key_in = keys;
+    } else if (aliases.length > 0) {
+      where.aliases_in = aliases;
+    } else {
+      return assets;
+    }
+    const fetch = async after => {
+      return this.fetchFiles({
+        where,
+        limit: 10000000,
+        sort: ["id_ASC"],
+        after
+      });
+    };
+    let after = undefined;
+    while (true) {
+      /**
+       * Unfortunately we must cast the result, because TS is not able to infer the correct type.
+       */
+      const {
+        items,
+        meta
+      } = await fetch(after);
+      for (const file of items) {
+        assets.push(createResolvedAsset(file));
+      }
+      if (!meta.hasMoreItems) {
+        return assets;
+      }
+      after = meta.cursor || undefined;
+    }
+  }
+}
+exports.EntryAssetsResolver = EntryAssetsResolver;
+
+//# sourceMappingURL=EntryAssetsResolver.js.map

package/tasks/utils/entryAssets/EntryAssetsResolver.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createResolvedAsset","file","result","aliases","savedBy","savedOn","modifiedBy","modifiedOn","accessControl","createdBy","createdOn","tenant","locale","webinyVersion","EntryAssetsResolver","constructor","params","fetchFiles","resolve","input","keys","asset","key","push","alias","assets","where","length","OR","key_in","aliases_in","fetch","after","limit","sort","undefined","items","meta","hasMoreItems","cursor","exports"],"sources":["EntryAssetsResolver.ts"],"sourcesContent":["import type {\n    File,\n    FileListMeta,\n    FileListWhereParams,\n    FilesListOpts\n} from \"@webiny/api-file-manager/types\";\nimport type { IEntryAssetsResolver, IResolvedAsset } from \"./abstractions/EntryAssetsResolver\";\nimport type { IAsset } from \"./abstractions/EntryAssets\";\n\nexport interface IFetchFilesCbResult {\n    items: File[];\n    meta: FileListMeta;\n}\n\nexport interface IFetchFilesCb {\n    (opts?: FilesListOpts): Promise<IFetchFilesCbResult>;\n}\n\nexport interface IEntryAssetsResolverParams {\n    fetchFiles: IFetchFilesCb;\n}\n\nconst createResolvedAsset = (file: File): IResolvedAsset => {\n    const result: IResolvedAsset = {\n        ...file,\n        aliases: file.aliases || []\n    };\n    /**\n     * We need to remove unnecessary fields from the resolved assets.\n     *\n     * We cannot return specific fields, rather than deleting unnecessary ones, because a user can extend the file model\n     * so we would not know which fields to return.\n     */\n    delete result.savedBy;\n    delete result.savedOn;\n    delete result.modifiedBy;\n    delete result.modifiedOn;\n    delete result.accessControl;\n    delete result.createdBy;\n    delete result.createdOn;\n    delete result.tenant;\n    delete result.locale;\n    delete result.webinyVersion;\n\n    return result;\n};\n\nexport class EntryAssetsResolver implements IEntryAssetsResolver {\n    private readonly fetchFiles: IFetchFilesCb;\n\n    public constructor(params: IEntryAssetsResolverParams) {\n        this.fetchFiles = params.fetchFiles;\n    }\n\n    public async resolve(input: IAsset[]): Promise<IResolvedAsset[]> {\n        const keys: string[] = [];\n        const aliases: string[] = [];\n        for (const asset of input) {\n            if (asset.key) {\n                keys.push(asset.key);\n            } else if (asset.alias) {\n                aliases.push(asset.alias);\n            }\n        }\n\n        const assets: IResolvedAsset[] = [];\n        const where: FileListWhereParams = {};\n        if (keys.length > 0 && aliases.length > 0) {\n            where.OR = [\n                {\n                    key_in: keys\n                },\n                {\n                    aliases_in: aliases\n                }\n            ];\n        } else if (keys.length > 0) {\n            where.key_in = keys;\n        } else if (aliases.length > 0) {\n            where.aliases_in = aliases;\n        } else {\n            return assets;\n        }\n\n        const fetch = async (after?: string) => {\n            return this.fetchFiles({\n                where,\n                limit: 10000000,\n                sort: [\"id_ASC\"],\n                after\n            });\n        };\n\n        let after: string | undefined = undefined;\n        while (true) {\n            /**\n             * Unfortunately we must cast the result, because TS is not able to infer the correct type.\n             */\n            const { items, meta } = (await fetch(after)) as IFetchFilesCbResult;\n            for (const file of items) {\n                assets.push(createResolvedAsset(file));\n            }\n            if (!meta.hasMoreItems) {\n                return assets;\n            }\n            after = meta.cursor || undefined;\n        }\n    }\n}\n"],"mappings":";;;;;;AAsBA,MAAMA,mBAAmB,GAAIC,IAAU,IAAqB;EACxD,MAAMC,MAAsB,GAAG;IAC3B,GAAGD,IAAI;IACPE,OAAO,EAAEF,IAAI,CAACE,OAAO,IAAI;EAC7B,CAAC;EACD;AACJ;AACA;AACA;AACA;AACA;EACI,OAAOD,MAAM,CAACE,OAAO;EACrB,OAAOF,MAAM,CAACG,OAAO;EACrB,OAAOH,MAAM,CAACI,UAAU;EACxB,OAAOJ,MAAM,CAACK,UAAU;EACxB,OAAOL,MAAM,CAACM,aAAa;EAC3B,OAAON,MAAM,CAACO,SAAS;EACvB,OAAOP,MAAM,CAACQ,SAAS;EACvB,OAAOR,MAAM,CAACS,MAAM;EACpB,OAAOT,MAAM,CAACU,MAAM;EACpB,OAAOV,MAAM,CAACW,aAAa;EAE3B,OAAOX,MAAM;AACjB,CAAC;AAEM,MAAMY,mBAAmB,CAAiC;EAGtDC,WAAWA,CAACC,MAAkC,EAAE;IACnD,IAAI,CAACC,UAAU,GAAGD,MAAM,CAACC,UAAU;EACvC;EAEA,MAAaC,OAAOA,CAACC,KAAe,EAA6B;IAC7D,MAAMC,IAAc,GAAG,EAAE;IACzB,MAAMjB,OAAiB,GAAG,EAAE;IAC5B,KAAK,MAAMkB,KAAK,IAAIF,KAAK,EAAE;MACvB,IAAIE,KAAK,CAACC,GAAG,EAAE;QACXF,IAAI,CAACG,IAAI,CAACF,KAAK,CAACC,GAAG,CAAC;MACxB,CAAC,MAAM,IAAID,KAAK,CAACG,KAAK,EAAE;QACpBrB,OAAO,CAACoB,IAAI,CAACF,KAAK,CAACG,KAAK,CAAC;MAC7B;IACJ;IAEA,MAAMC,MAAwB,GAAG,EAAE;IACnC,MAAMC,KAA0B,GAAG,CAAC,CAAC;IACrC,IAAIN,IAAI,CAACO,MAAM,GAAG,CAAC,IAAIxB,OAAO,CAACwB,MAAM,GAAG,CAAC,EAAE;MACvCD,KAAK,CAACE,EAAE,GAAG,CACP;QACIC,MAAM,EAAET;MACZ,CAAC,EACD;QACIU,UAAU,EAAE3B;MAChB,CAAC,CACJ;IACL,CAAC,MAAM,IAAIiB,IAAI,CAACO,MAAM,GAAG,CAAC,EAAE;MACxBD,KAAK,CAACG,MAAM,GAAGT,IAAI;IACvB,CAAC,MAAM,IAAIjB,OAAO,CAACwB,MAAM,GAAG,CAAC,EAAE;MAC3BD,KAAK,CAACI,UAAU,GAAG3B,OAAO;IAC9B,CAAC,MAAM;MACH,OAAOsB,MAAM;IACjB;IAEA,MAAMM,KAAK,GAAG,MAAOC,KAAc,IAAK;MACpC,OAAO,IAAI,CAACf,UAAU,CAAC;QACnBS,KAAK;QACLO,KAAK,EAAE,QAAQ;QACfC,IAAI,EAAE,CAAC,QAAQ,CAAC;QAChBF;MACJ,CAAC,CAAC;IACN,CAAC;IAED,IAAIA,KAAyB,GAAGG,SAAS;IACzC,OAAO,IAAI,EAAE;MACT;AACZ;AACA;MACY,MAAM;QAAEC,KAAK;QAAEC;MAAK,CAAC,GAAI,MAAMN,KAAK,CAACC,KAAK,CAAyB;MACnE,KAAK,MAAM/B,IAAI,IAAImC,KAAK,EAAE;QACtBX,MAAM,CAACF,IAAI,CAACvB,mBAAmB,CAACC,IAAI,CAAC,CAAC;MAC1C;MACA,IAAI,CAACoC,IAAI,CAACC,YAAY,EAAE;QACpB,OAAOb,MAAM;MACjB;MACAO,KAAK,GAAGK,IAAI,CAACE,MAAM,IAAIJ,SAAS;IACpC;EACJ;AACJ;AAACK,OAAA,CAAA1B,mBAAA,GAAAA,mBAAA","ignoreList":[]}

package/tasks/utils/entryAssets/abstractions/EntryAssets.d.ts

@@ -0,0 +1,22 @@
+import type { CmsEntry } from "@webiny/api-headless-cms/types";
+import type { GenericRecord } from "@webiny/api/types";
+export interface IKeyAsset {
+    key: string;
+    alias?: never;
+    url: string;
+}
+export interface IAliasAsset {
+    key?: never;
+    alias: string;
+    url: string;
+}
+export type IAsset = IKeyAsset | IAliasAsset;
+export type IAssets = GenericRecord<string, IAsset>;
+export type IAssignAssetsInput = Pick<CmsEntry, "values"> | Pick<CmsEntry, "values">[];
+export interface IEntryAssets {
+    /**
+     * The output of this method is a list of assets that were found in the given input.
+     * If there were any duplicates, they will not be included in the output.
+     */
+    assignAssets(input: IAssignAssetsInput): Promise<IAsset[]>;
+}