@crowdin/app-project-module 0.108.0 → 1.0.0

package/out/modules/file-processing/handlers/custom-file-format.js

@@ -17,9 +17,11 @@ const path_1 = __importDefault(require("path"));
 const util_1 = require("../../../util");
 const files_1 = require("../util/files");
 const types_1 = require("../types");
-function handle(baseUrl, folder, config) {
-    if (!fs_1.default.existsSync(path_1.default.join(folder, 'custom-file-format'))) {
-        fs_1.default.mkdirSync(path_1.default.join(folder, 'custom-file-format'), { recursive: true });
+function handle({ baseUrl, folder, config, fileStore, }) {
+    if (!fileStore) {
+        if (!fs_1.default.existsSync(path_1.default.join(folder, 'custom-file-format'))) {
+            fs_1.default.mkdirSync(path_1.default.join(folder, 'custom-file-format'), { recursive: true });
+        }
     }
     return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
         const baseFilesUrl = `${baseUrl}/file/download`;
@@ -43,12 +45,32 @@ function handle(baseUrl, folder, config) {
         let error;
         switch (body.jobType) {
             case types_1.ProcessFileJobType.BUILD_FILE:
-                const buildFileResult = yield handleBuildFile(baseFilesUrl, folder, config, body, req.crowdinApiClient, req.crowdinContext, req.crowdinContext.jwtPayload.context.project_id, file);
+                const buildFileResult = yield handleBuildFile({
+                    baseUrl: baseFilesUrl,
+                    dataFolder: folder,
+                    config,
+                    req: body,
+                    client: req.crowdinApiClient,
+                    context: req.crowdinContext,
+                    projectId: req.crowdinContext.jwtPayload.context.project_id,
+                    file,
+                    fileStore,
+                });
                 response = buildFileResult.response;
                 error = buildFileResult.error;
                 break;
             case types_1.ProcessFileJobType.PARSE_FILE:
-                const parseFileResult = yield handleParseFile(baseFilesUrl, folder, config, body, req.crowdinApiClient, req.crowdinContext, req.crowdinContext.jwtPayload.context.project_id, file);
+                const parseFileResult = yield handleParseFile({
+                    baseUrl: baseFilesUrl,
+                    dataFolder: folder,
+                    config,
+                    req: body,
+                    client: req.crowdinApiClient,
+                    context: req.crowdinContext,
+                    projectId: req.crowdinContext.jwtPayload.context.project_id,
+                    file,
+                    fileStore,
+                });
                 response = parseFileResult.response;
                 error = parseFileResult.error;
                 break;
@@ -59,7 +81,7 @@ function handle(baseUrl, folder, config) {
     }));
 }
 exports.default = handle;
-function handleBuildFile(baseUrl, dataFolder, config, req, client, context, projectId, file) {
+function handleBuildFile({ baseUrl, dataFolder, config, req, client, context, projectId, file, fileStore, }) {
     return __awaiter(this, void 0, void 0, function* () {
         const response = {};
         if (!req.strings && !req.stringsUrl) {
@@ -74,10 +96,10 @@ function handleBuildFile(baseUrl, dataFolder, config, req, client, context, proj
         }
         let res;
         if ((req.file.id || !file) && config.exportStrings) {
-            res = yield config.exportStrings(req, strings, client, context, projectId);
+            res = yield config.exportStrings({ request: req, strings, client, context, projectId });
         }
         else if (file && config.buildFile) {
-            res = yield config.buildFile(file, req, strings, client, context, projectId);
+            res = yield config.buildFile({ fileContent: file, request: req, strings, client, context, projectId });
         }
         else {
             return { response };
@@ -88,25 +110,31 @@ function handleBuildFile(baseUrl, dataFolder, config, req, client, context, proj
         }
         else {
             let url;
-            if (config.storeFile) {
-                url = yield config.storeFile(res.contentFile);
+            if (fileStore) {
+                const fileRef = yield fileStore.storeFile(res.contentFile);
+                url = `${baseUrl}?file=${fileRef}`;
             }
             else {
-                const storedFile = yield (0, files_1.storeFile)(res.contentFile, path_1.default.join(dataFolder, 'custom-file-format'));
-                url = `${baseUrl}?file=${storedFile}`;
+                if (config.storeFile) {
+                    url = yield config.storeFile(res.contentFile);
+                }
+                else {
+                    const storedFile = yield (0, files_1.storeFile)(res.contentFile, path_1.default.join(dataFolder, 'custom-file-format'));
+                    url = `${baseUrl}?file=${storedFile}`;
+                }
             }
             response.contentUrl = url;
         }
         return { response, error: res.error };
     });
 }
-function handleParseFile(baseUrl, dataFolder, config, req, client, context, projectId, file) {
+function handleParseFile({ baseUrl, dataFolder, config, req, client, context, projectId, file, fileStore, }) {
     return __awaiter(this, void 0, void 0, function* () {
         const response = {};
         if (!config.parseFile || !file) {
             return { response };
         }
-        const res = yield config.parseFile(file, req, client, context, projectId);
+        const res = yield config.parseFile({ fileContent: file, request: req, client, context, projectId });
         let maxSize = files_1.MAX_BODY_SIZE;
         if (res.strings && res.previewFile) {
             maxSize = maxSize / 2;
@@ -117,12 +145,18 @@ function handleParseFile(baseUrl, dataFolder, config, req, client, context, proj
             }
             else {
                 let url;
-                if (config.storeFile) {
-                    url = yield config.storeFile(res.previewFile);
+                if (fileStore) {
+                    const fileRef = yield fileStore.storeFile(res.previewFile);
+                    url = `${baseUrl}?file=${fileRef}`;
                 }
                 else {
-                    const storedFile = yield (0, files_1.storeFile)(res.previewFile, path_1.default.join(dataFolder, 'custom-file-format'));
-                    url = `${baseUrl}?file=${storedFile}`;
+                    if (config.storeFile) {
+                        url = yield config.storeFile(res.previewFile);
+                    }
+                    else {
+                        const storedFile = yield (0, files_1.storeFile)(res.previewFile, path_1.default.join(dataFolder, 'custom-file-format'));
+                        url = `${baseUrl}?file=${storedFile}`;
+                    }
                 }
                 response.previewUrl = url;
             }
@@ -145,12 +179,18 @@ function handleParseFile(baseUrl, dataFolder, config, req, client, context, proj
             }
             else {
                 let url;
-                if (config.storeFile) {
-                    url = yield config.storeFile(bufferData);
+                if (fileStore) {
+                    const fileRef = yield fileStore.storeFile(bufferData);
+                    url = `${baseUrl}?file=${fileRef}`;
                 }
                 else {
-                    const storedFile = yield (0, files_1.storeFile)(bufferData, path_1.default.join(dataFolder, 'custom-file-format'));
-                    url = `${baseUrl}?file=${storedFile}`;
+                    if (config.storeFile) {
+                        url = yield config.storeFile(bufferData);
+                    }
+                    else {
+                        const storedFile = yield (0, files_1.storeFile)(bufferData, path_1.default.join(dataFolder, 'custom-file-format'));
+                        url = `${baseUrl}?file=${storedFile}`;
+                    }
                 }
                 response.stringsUrl = url;
             }

package/out/modules/file-processing/handlers/file-download.d.ts

@@ -2,4 +2,4 @@
 import { Request, Response } from 'express';
 import { Config } from '../../../types';
 import { FileProcessLogic } from '../types';
-export default function handle(config: Config, processingConfig: FileProcessLogic, folderName: string): (req: import("../../../types").CrowdinClientRequest | Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;
+export default function handle(config: Config, processingConfig: FileProcessLogic, folderName: string): (req: Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>> | import("../../../types").CrowdinClientRequest, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/modules/file-processing/handlers/file-download.js

@@ -19,6 +19,11 @@ const logger_1 = require("../../../util/logger");
 function handle(config, processingConfig, folderName) {
     const folder = processingConfig.filesFolder || config.dbFolder;
     return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
+        if (config.fileStore) {
+            const fileContent = yield config.fileStore.getFile(req.query.file);
+            res.send(fileContent);
+            return;
+        }
         const filePath = path_1.default.join(folder, folderName, req.query.file);
         (0, logger_1.log)(`Downloading file ${filePath}`);
         res.download(filePath, function (err) {

package/out/modules/file-processing/handlers/pre-post-process.d.ts

@@ -2,4 +2,4 @@
 import { Response } from 'express';
 import { Config, CrowdinClientRequest } from '../../../types';
 import { FileImportExportLogic } from '../types';
-export default function handle(baseConfig: Config, config: FileImportExportLogic, folderName: string): (req: CrowdinClientRequest | import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;
+export default function handle(baseConfig: Config, config: FileImportExportLogic, folderName: string): (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>> | CrowdinClientRequest, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/modules/file-processing/handlers/pre-post-process.js

@@ -19,8 +19,10 @@ const types_1 = require("../types");
 const files_1 = require("../util/files");
 function handle(baseConfig, config, folderName) {
     const folderPath = config.filesFolder || baseConfig.dbFolder;
-    if (!fs_1.default.existsSync(path_1.default.join(folderPath, folderName))) {
-        fs_1.default.mkdirSync(path_1.default.join(folderPath, folderName), { recursive: true });
+    if (!baseConfig.fileStore) {
+        if (!fs_1.default.existsSync(path_1.default.join(folderPath, folderName))) {
+            fs_1.default.mkdirSync(path_1.default.join(folderPath, folderName), { recursive: true });
+        }
     }
     return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
         var _a;
@@ -57,7 +59,13 @@ function handle(baseConfig, config, folderName) {
                 return rawContent;
             });
         }
-        const fileProcessResult = yield config.fileProcess(body, fileContent, req.crowdinApiClient, req.crowdinContext, req.crowdinContext.jwtPayload.context.project_id);
+        const fileProcessResult = yield config.fileProcess({
+            request: body,
+            content: fileContent,
+            client: req.crowdinApiClient,
+            context: req.crowdinContext,
+            projectId: req.crowdinContext.jwtPayload.context.project_id,
+        });
         if (fileProcessResult.notModified) {
             res.sendStatus(304);
             return;
@@ -72,12 +80,18 @@ function handle(baseConfig, config, folderName) {
                     }
                     else {
                         let url;
-                        if (config.storeFile) {
-                            url = yield config.storeFile(contentFile);
+                        if (baseConfig.fileStore) {
+                            const fileRef = yield baseConfig.fileStore.storeFile(contentFile);
+                            url = `${baseFilesUrl}?file=${fileRef}`;
                         }
                         else {
-                            const storedFile = yield (0, files_1.storeFile)(contentFile, path_1.default.join(folderPath, folderName));
-                            url = `${baseFilesUrl}?file=${storedFile}`;
+                            if (config.storeFile) {
+                                url = yield config.storeFile(contentFile);
+                            }
+                            else {
+                                const storedFile = yield (0, files_1.storeFile)(contentFile, path_1.default.join(folderPath, folderName));
+                                url = `${baseFilesUrl}?file=${storedFile}`;
+                            }
                         }
                         response.contentUrl = url;
                     }
@@ -103,12 +117,18 @@ function handle(baseConfig, config, folderName) {
                     }
                     else {
                         let url;
-                        if (config.storeFile) {
-                            url = yield config.storeFile(previewFile);
+                        if (baseConfig.fileStore) {
+                            const fileRef = yield baseConfig.fileStore.storeFile(previewFile);
+                            url = `${baseFilesUrl}?file=${fileRef}`;
                         }
                         else {
-                            const storedFile = yield (0, files_1.storeFile)(previewFile, path_1.default.join(folderPath, folderName));
-                            url = `${baseFilesUrl}?file=${storedFile}`;
+                            if (config.storeFile) {
+                                url = yield config.storeFile(previewFile);
+                            }
+                            else {
+                                const storedFile = yield (0, files_1.storeFile)(previewFile, path_1.default.join(folderPath, folderName));
+                                url = `${baseFilesUrl}?file=${storedFile}`;
+                            }
                         }
                         response.previewUrl = url;
                     }
@@ -121,12 +141,18 @@ function handle(baseConfig, config, folderName) {
                     }
                     else {
                         let url;
-                        if (config.storeFile) {
-                            url = yield config.storeFile(bufferData);
+                        if (baseConfig.fileStore) {
+                            const fileRef = yield baseConfig.fileStore.storeFile(bufferData);
+                            url = `${baseFilesUrl}?file=${fileRef}`;
                         }
                         else {
-                            const storedFile = yield (0, files_1.storeFile)(bufferData, path_1.default.join(folderPath, folderName));
-                            url = `${baseFilesUrl}?file=${storedFile}`;
+                            if (config.storeFile) {
+                                url = yield config.storeFile(bufferData);
+                            }
+                            else {
+                                const storedFile = yield (0, files_1.storeFile)(bufferData, path_1.default.join(folderPath, folderName));
+                                url = `${baseFilesUrl}?file=${storedFile}`;
+                            }
                         }
                         response.stringsUrl = url;
                     }

package/out/modules/file-processing/handlers/translations-alignment.d.ts

@@ -2,4 +2,4 @@
 import { Response } from 'express';
 import { Config, CrowdinClientRequest } from '../../../types';
 import { TranslationsAlignmentLogic } from '../types';
-export default function handle(baseConfig: Config, config: TranslationsAlignmentLogic, folderName: string): (req: CrowdinClientRequest | import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;
+export default function handle(baseConfig: Config, config: TranslationsAlignmentLogic, folderName: string): (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>> | CrowdinClientRequest, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/modules/file-processing/handlers/translations-alignment.js

@@ -37,10 +37,16 @@ function handle(baseConfig, config, folderName) {
         const fileTranslationsContent = body.translationStringsUrl
             ? (yield (0, files_1.getFileStrings)(body.translationStringsUrl))
             : body.translationStrings;
-        const fileProcessResult = yield config.fileProcess(body, {
-            sourceStrings: fileSourceStringsContent,
-            translations: fileTranslationsContent,
-        }, req.crowdinApiClient, req.crowdinContext, req.crowdinContext.jwtPayload.context.project_id);
+        const fileProcessResult = yield config.fileProcess({
+            request: body,
+            content: {
+                sourceStrings: fileSourceStringsContent,
+                translations: fileTranslationsContent,
+            },
+            client: req.crowdinApiClient,
+            context: req.crowdinContext,
+            projectId: req.crowdinContext.jwtPayload.context.project_id,
+        });
         const { strings, error: processingErrorMessage } = fileProcessResult;
         if (!strings) {
             response.translations = [];

package/out/modules/file-processing/index.js

@@ -21,13 +21,23 @@ function registerCustomFileFormat({ config, app }) {
         optional: false,
         checkSubscriptionExpiration: true,
         moduleKey: config.customFileFormat.key,
-    }), (0, custom_file_format_1.default)(config.baseUrl, config.customFileFormat.filesFolder || config.dbFolder, config.customFileFormat));
+    }), (0, custom_file_format_1.default)({
+        baseUrl: config.baseUrl,
+        folder: config.customFileFormat.filesFolder || config.dbFolder,
+        config: config.customFileFormat,
+        fileStore: config.fileStore,
+    }));
     // TEMPORARY CODE: it needs to support old path
     app.post('/process', (0, crowdin_client_1.default)({
         config,
         optional: false,
         checkSubscriptionExpiration: true,
-    }), (0, custom_file_format_1.default)(config.baseUrl, config.customFileFormat.filesFolder || config.dbFolder, config.customFileFormat));
+    }), (0, custom_file_format_1.default)({
+        baseUrl: config.baseUrl,
+        folder: config.customFileFormat.filesFolder || config.dbFolder,
+        config: config.customFileFormat,
+        fileStore: config.fileStore,
+    }));
     // END TEMPORARY CODE
     app.get('/file/download', (0, file_download_1.default)(config, config.customFileFormat, 'custom-file-format'));
 }

package/out/modules/file-processing/types.d.ts

@@ -48,15 +48,34 @@ export interface CustomFileFormatLogic extends FileProcessLogic {
     /**
      * Used for initial source file upload, source file update, and translation upload
      */
-    parseFile?: (fileContent: Buffer, req: Omit<ProcessFileRequest, 'jobType' | 'file'>, client: Crowdin, context: CrowdinContextInfo, projectId: number) => Promise<ParseFileResponse>;
+    parseFile?: (options: {
+        fileContent: Buffer;
+        request: Omit<ProcessFileRequest, 'jobType' | 'file'>;
+        client: Crowdin;
+        context: CrowdinContextInfo;
+        projectId: number;
+    }) => Promise<ParseFileResponse>;
     /**
      * Used for translation download
      */
-    buildFile?: (fileContent: Buffer, req: Omit<ProcessFileRequest, 'jobType' | 'file'>, strings: ProcessFileString[], client: Crowdin, context: CrowdinContextInfo, projectId: number) => Promise<BuildFileResponse>;
+    buildFile?: (options: {
+        fileContent: Buffer;
+        request: Omit<ProcessFileRequest, 'jobType' | 'file'>;
+        strings: ProcessFileString[];
+        client: Crowdin;
+        context: CrowdinContextInfo;
+        projectId: number;
+    }) => Promise<BuildFileResponse>;
     /**
      * Used for strings export
      */
-    exportStrings?: (req: Omit<ProcessFileRequest, 'jobType'>, strings: ProcessFileString[], client: Crowdin, context: CrowdinContextInfo, projectId: number) => Promise<BuildFileResponse>;
+    exportStrings?: (options: {
+        request: Omit<ProcessFileRequest, 'jobType'>;
+        strings: ProcessFileString[];
+        client: Crowdin;
+        context: CrowdinContextInfo;
+        projectId: number;
+    }) => Promise<BuildFileResponse>;
 }
 export type FileImportExportLogic = FilePreImportLogic | FilePostImportLogic | FilePreExportLogic | FilePostExportLogic;
 export type FileImportExportContent = ProcessFileString[] | Buffer | undefined;
@@ -66,10 +85,22 @@ export interface FileTranslationAlignmentContent {
     translations: TranslationAlignmentContent;
 }
 export interface BaseFileProcessLogic<T> {
-    fileProcess: (req: ProcessFileRequest, content: FileImportExportContent, client: Crowdin, context: CrowdinContextInfo, projectId: number) => Promise<T>;
+    fileProcess: (options: {
+        request: ProcessFileRequest;
+        content: FileImportExportContent;
+        client: Crowdin;
+        context: CrowdinContextInfo;
+        projectId: number;
+    }) => Promise<T>;
 }
 export interface TranslationAlignmentProcessLogin<T> {
-    fileProcess: (req: ProcessTranslationAlignmentRequest, content: FileTranslationAlignmentContent, client: Crowdin, context: CrowdinContextInfo, projectId: number) => Promise<T>;
+    fileProcess: (options: {
+        request: ProcessTranslationAlignmentRequest;
+        content: FileTranslationAlignmentContent;
+        client: Crowdin;
+        context: CrowdinContextInfo;
+        projectId: number;
+    }) => Promise<T>;
 }
 export interface FilePreImportLogic extends FileProcessLogic, BaseFileProcessLogic<ContentFileResponse> {
     /**

package/out/modules/file-processing/util/defaults.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -10,20 +33,41 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyFileProcessorsModuleDefaults = void 0;
-const client_s3_1 = require("@aws-sdk/client-s3");
-const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
+function loadAwsSdk() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const [s3Client, s3Presigner] = yield Promise.all([
+                Promise.resolve().then(() => __importStar(require('@aws-sdk/client-s3'))),
+                Promise.resolve().then(() => __importStar(require('@aws-sdk/s3-request-presigner'))),
+            ]);
+            return {
+                S3Client: s3Client.S3Client,
+                GetObjectCommand: s3Client.GetObjectCommand,
+                PutObjectCommand: s3Client.PutObjectCommand,
+                getSignedUrl: s3Presigner.getSignedUrl,
+            };
+        }
+        catch (_a) {
+            throw new Error('AWS SDK is not installed. To use S3 file storage, install required packages:\n' +
+                'npm install @aws-sdk/client-s3 @aws-sdk/s3-request-presigner');
+        }
+    });
+}
 function applyFileProcessorsModuleDefaults(config, fileModule) {
     var _a, _b;
     const AWS_TMP_BUCKET_NAME = (_a = config.awsConfig) === null || _a === void 0 ? void 0 : _a.tmpBucketName;
     const AWS_REGION = (_b = config.awsConfig) === null || _b === void 0 ? void 0 : _b.region;
     if (AWS_TMP_BUCKET_NAME && AWS_REGION && !fileModule.storeFile) {
-        const s3 = new client_s3_1.S3Client({ region: AWS_REGION });
+        let initPromise = null;
+        const getS3 = () => (initPromise !== null && initPromise !== void 0 ? initPromise : (initPromise = loadAwsSdk().then((sdk) => ({ sdk, s3: new sdk.S3Client({ region: AWS_REGION }) }))));
         fileModule.storeFile = (content) => __awaiter(this, void 0, void 0, function* () {
+            const { sdk, s3 } = yield getS3();
+            const { GetObjectCommand, PutObjectCommand, getSignedUrl } = sdk;
             const fileName = `file-${config.identifier}-${Date.now()}`;
-            const command = new client_s3_1.PutObjectCommand({ Bucket: AWS_TMP_BUCKET_NAME, Key: fileName, Body: content });
+            const command = new PutObjectCommand({ Bucket: AWS_TMP_BUCKET_NAME, Key: fileName, Body: content });
             yield s3.send(command);
-            const getObjectCommand = new client_s3_1.GetObjectCommand({ Bucket: AWS_TMP_BUCKET_NAME, Key: fileName });
-            return (0, s3_request_presigner_1.getSignedUrl)(s3, getObjectCommand, { expiresIn: 3600 });
+            const getObjectCommand = new GetObjectCommand({ Bucket: AWS_TMP_BUCKET_NAME, Key: fileName });
+            return getSignedUrl(s3, getObjectCommand, { expiresIn: 3600 });
         });
     }
 }

package/out/modules/file-processing/util/files.js

@@ -32,7 +32,8 @@ exports.storeFile = storeFile;
 function getFileContent(url) {
     return __awaiter(this, void 0, void 0, function* () {
         const response = (yield axios_1.default.get(url, { responseType: 'arraybuffer' })).data;
-        return response;
+        // Support for both Node.js (returns Buffer) and Cloudflare Workers (returns ArrayBuffer)
+        return Buffer.isBuffer(response) ? response : Buffer.from(response);
     });
 }
 exports.getFileContent = getFileContent;

package/out/modules/form-data-display.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="qs" />
 import { Config, CrowdinClientRequest } from '../types';
 import { Response } from 'express';
-export default function handle(config: Config): (req: CrowdinClientRequest | import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;
+export default function handle(config: Config): (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>> | CrowdinClientRequest, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/modules/form-data-save.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="qs" />
 import { Config, CrowdinClientRequest } from '../types';
 import { Response } from 'express';
-export default function handle(config: Config): (req: CrowdinClientRequest | import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;
+export default function handle(config: Config): (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>> | CrowdinClientRequest, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/modules/install.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="qs" />
 import { Request, Response } from 'express';
 import { Config } from '../types';
-export default function handle(config: Config): (req: import("../types").CrowdinClientRequest | Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;
+export default function handle(config: Config): (req: Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>> | import("../types").CrowdinClientRequest, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/modules/integration/handlers/crowdin-file-progress.d.ts

@@ -2,4 +2,4 @@
 import { Response } from 'express';
 import { CrowdinClientRequest } from '../../../types';
 import { IntegrationLogic } from '../types';
-export default function handle(integration: IntegrationLogic): (req: CrowdinClientRequest | import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;
+export default function handle(integration: IntegrationLogic): (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>> | CrowdinClientRequest, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/modules/integration/handlers/crowdin-file-progress.js

@@ -24,7 +24,11 @@ function handle(integration) {
         req.logInfo(`Loading translation progress for file ${fileId}`);
         if (integration.getFileProgress) {
             try {
-                const progress = yield integration.getFileProgress(req.crowdinContext.jwtPayload.context.project_id, req.crowdinApiClient, fileId);
+                const progress = yield integration.getFileProgress({
+                    projectId: req.crowdinContext.jwtPayload.context.project_id,
+                    client: req.crowdinApiClient,
+                    fileId,
+                });
                 req.logInfo(`Translation progress for file ${fileId} ${JSON.stringify(progress, null, 2)}`);
                 res.send(progress);
             }

package/out/modules/integration/handlers/crowdin-files-target-languages.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="qs" />
+import { Response } from 'express';
+import { Config } from '../../../types';
+import { IntegrationLogic } from '../types';
+export default function handle(config: Config, integration: IntegrationLogic): (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>> | import("../../../types").CrowdinClientRequest, res: Response<any, Record<string, any>>, next: Function) => void;