@crowdin/app-project-module 0.81.1 → 0.82.0

package/out/index.js

@@ -83,6 +83,7 @@ const projectReportsApp = __importStar(require("./modules/project-reports"));
 const projectToolsApp = __importStar(require("./modules/project-tools"));
 const webhooks = __importStar(require("./modules/webhooks"));
 const workflowStepType = __importStar(require("./modules/workflow-step-type"));
+const aiRequestProcessors = __importStar(require("./modules/ai-request-processors"));
 const subscription_1 = require("./util/subscription");
 var types_2 = require("./types");
 Object.defineProperty(exports, "ProjectPermissions", { enumerable: true, get: function () { return types_2.ProjectPermissions; } });
@@ -190,6 +191,7 @@ function addCrowdinEndpoints(app, clientConfig) {
     externalQaCheck.register({ config, app });
     webhooks.register({ config, app });
     workflowStepType.register({ config, app });
+    aiRequestProcessors.register({ config, app });
     addFormSchema({ config, app });
     return Object.assign(Object.assign({}, exports.metadataStore), { storage: storage.getStorage(), establishCrowdinConnection: (authRequest, moduleKey) => {
             let jwtToken = '';

package/out/modules/ai-request-processors/handler.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="qs" />
+import { Response } from 'express';
+import { CrowdinClientRequest } from '../../types';
+import { AiRequestProcessorModule, AiStreamProcessorModule } from './types';
+export default function handle(module: AiRequestProcessorModule | AiStreamProcessorModule, canHandleStream?: boolean): (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;

package/out/modules/ai-request-processors/handler.js

@@ -0,0 +1,63 @@
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../../util");
+const logger_1 = require("../../util/logger");
+const BUFFERING_FLAG = '~buffering~';
+function handle(module, canHandleStream = false) {
+    return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            if (canHandleStream && req.headers['transfer-encoding'] === 'chunked') {
+                if (!('processStream' in module)) {
+                    res.writeHead(202, {}).end();
+                    return;
+                }
+                res.writeHead(200, {
+                    Connection: 'keep-alive',
+                    'Cache-Control': 'no-cache',
+                    'Content-Type': 'text/event-stream',
+                    'X-Accel-Buffering': 'no',
+                });
+                req.on('data', (chunk) => __awaiter(this, void 0, void 0, function* () {
+                    let chunkStr = chunk.toString();
+                    // actually we checked if processStream exists already, but need do to this again to calm down TS compiler
+                    chunkStr = module.processStream
+                        ? yield module.processStream(chunkStr, req.query, req.crowdinApiClient, req.crowdinContext)
+                        : chunkStr;
+                    if (!chunkStr && typeof chunkStr !== 'string') {
+                        res.write(BUFFERING_FLAG);
+                        return;
+                    }
+                    res.write(chunkStr);
+                }));
+                req.on('end', () => {
+                    res.end();
+                });
+                req.on('error', (e) => {
+                    if (req.logError) {
+                        req.logError(e);
+                    }
+                    res.end();
+                });
+                return;
+            }
+            const result = yield module.processRequest(req.body, req.query, req.crowdinApiClient, req.crowdinContext);
+            res.send(result);
+        }
+        catch (e) {
+            if (req.logError) {
+                req.logError(e);
+            }
+            res.send({ error: { message: (0, logger_1.getErrorMessage)(e) } });
+        }
+    }));
+}
+exports.default = handle;

package/out/modules/ai-request-processors/index.d.ts

@@ -0,0 +1,16 @@
+import { Express } from 'express';
+import { Config } from '../../types';
+export declare enum AiRequestProcessorModuleWithStream {
+    aiRequestPreParse = "aiRequestPreParse"
+}
+export declare enum AiRequestProcessorModuleWithoutStream {
+    aiRequestPreCompile = "aiRequestPreCompile",
+    aiRequestPostCompile = "aiRequestPostCompile",
+    aiRequestPostParse = "aiRequestPostParse"
+}
+export type AiRequestProcessorModuleType = AiRequestProcessorModuleWithoutStream | AiRequestProcessorModuleWithStream;
+export declare function generateModuleSlugFromType(moduleType: string): string;
+export declare function register({ config, app }: {
+    config: Config;
+    app: Express;
+}): void;

package/out/modules/ai-request-processors/index.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = exports.generateModuleSlugFromType = exports.AiRequestProcessorModuleWithoutStream = exports.AiRequestProcessorModuleWithStream = void 0;
+const json_response_1 = __importDefault(require("../../middlewares/json-response"));
+const crowdin_client_1 = __importDefault(require("../../middlewares/crowdin-client"));
+const handler_1 = __importDefault(require("./handler"));
+var AiRequestProcessorModuleWithStream;
+(function (AiRequestProcessorModuleWithStream) {
+    AiRequestProcessorModuleWithStream["aiRequestPreParse"] = "aiRequestPreParse";
+})(AiRequestProcessorModuleWithStream = exports.AiRequestProcessorModuleWithStream || (exports.AiRequestProcessorModuleWithStream = {}));
+var AiRequestProcessorModuleWithoutStream;
+(function (AiRequestProcessorModuleWithoutStream) {
+    AiRequestProcessorModuleWithoutStream["aiRequestPreCompile"] = "aiRequestPreCompile";
+    AiRequestProcessorModuleWithoutStream["aiRequestPostCompile"] = "aiRequestPostCompile";
+    AiRequestProcessorModuleWithoutStream["aiRequestPostParse"] = "aiRequestPostParse";
+})(AiRequestProcessorModuleWithoutStream = exports.AiRequestProcessorModuleWithoutStream || (exports.AiRequestProcessorModuleWithoutStream = {}));
+function generateModuleSlugFromType(moduleType) {
+    return moduleType
+        .split(/\.?(?=[A-Z])/)
+        .join('-')
+        .toLowerCase();
+}
+exports.generateModuleSlugFromType = generateModuleSlugFromType;
+function registerProcessorModuleByTypeKey(moduleKey, { config, app }) {
+    const module = config[moduleKey];
+    if (!module) {
+        return;
+    }
+    app.post('/ai-request-processor/' + generateModuleSlugFromType(moduleKey), json_response_1.default, (0, crowdin_client_1.default)({
+        config,
+        optional: false,
+        checkSubscriptionExpiration: true,
+        moduleKey: module.key,
+    }), (0, handler_1.default)(module, moduleKey in AiRequestProcessorModuleWithStream));
+}
+function register({ config, app }) {
+    [
+        ...Object.values(AiRequestProcessorModuleWithoutStream),
+        ...Object.values(AiRequestProcessorModuleWithStream),
+    ].forEach((moduleTypeKey) => registerProcessorModuleByTypeKey(moduleTypeKey, { config, app }));
+}
+exports.register = register;

package/out/modules/ai-request-processors/types.d.ts

@@ -0,0 +1,14 @@
+import { CrowdinContextInfo, ModuleKey } from '../../types';
+import Crowdin from '@crowdin/crowdin-api-client';
+export interface AiRequestProcessorModule extends ModuleKey {
+    /**
+     * updates request data
+     */
+    processRequest: (requestData: any, requestContext: any, client: Crowdin, context: CrowdinContextInfo) => Promise<never>;
+}
+export interface AiStreamProcessorModule extends AiRequestProcessorModule {
+    /**
+     * updates request data
+     */
+    processStream?: (chunk: any, requestContext: any, client: Crowdin, context: CrowdinContextInfo) => Promise<string | null>;
+}

package/out/modules/ai-request-processors/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -92,11 +92,31 @@ function handle(baseConfig, config, folderName) {
                 break;
             case types_1.ProcessFileJobType.POST_IMPORT:
             case types_1.ProcessFileJobType.PRE_EXPORT:
-                const { strings, error: stringsFileError } = fileProcessResult;
+                const { strings, error: stringsFileError, previewFile } = fileProcessResult;
+                let maxSize = files_1.MAX_BODY_SIZE;
+                if (strings && previewFile && body.jobType === types_1.ProcessFileJobType.POST_IMPORT) {
+                    maxSize = maxSize / 2;
+                }
+                if (previewFile && body.jobType === types_1.ProcessFileJobType.POST_IMPORT) {
+                    if (Buffer.byteLength(previewFile) < maxSize) {
+                        response.preview = previewFile.toString('base64');
+                    }
+                    else {
+                        let url;
+                        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;
+                    }
+                }
                 if (strings) {
                     const stringsNDJson = strings.map((s) => JSON.stringify(s)).join('\n\r');
                     const bufferData = Buffer.from(stringsNDJson, 'utf-8');
-                    if (Buffer.byteLength(bufferData) < files_1.MAX_BODY_SIZE) {
+                    if (Buffer.byteLength(bufferData) < maxSize) {
                         response.strings = strings;
                     }
                     else {

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

@@ -115,7 +115,7 @@ export interface BuildFileResponse {
     fileName?: string;
     fileType?: string;
 }
-export interface StringsFileResponse extends Omit<ParseFileResponse, 'previewFile'> {
+export interface StringsFileResponse extends ParseFileResponse {
     notModified?: boolean;
 }
 export interface ContentFileResponse extends BuildFileResponse {

package/out/modules/manifest.js

@@ -6,6 +6,7 @@ const subscription_1 = require("../util/subscription");
 const api_1 = require("./api/api");
 const util_2 = require("./ai-tools/util");
 const util_3 = require("./workflow-step-type/util");
+const ai_request_processors_1 = require("./ai-request-processors");
 function normalizeEnvironments(environments) {
     if (Array.isArray(environments)) {
         return environments;
@@ -236,6 +237,22 @@ function handle(config) {
             })), (uiModule ? { url: '/settings/' + (uiModule.fileName || 'index.html') } : {})),
         ];
     }
+    [
+        ...Object.values(ai_request_processors_1.AiRequestProcessorModuleWithoutStream),
+        ...Object.values(ai_request_processors_1.AiRequestProcessorModuleWithStream),
+    ].forEach((moduleType) => {
+        const module = config[moduleType];
+        if (!module) {
+            return;
+        }
+        const moduleSlug = (0, ai_request_processors_1.generateModuleSlugFromType)(moduleType);
+        modules[moduleSlug] = [
+            {
+                key: config.identifier + '-' + moduleSlug,
+                processorUrl: '/ai-request-processor/' + moduleSlug,
+            },
+        ];
+    });
     if (config.aiPromptProvider) {
         // prevent possible overrides of the other modules
         config.aiPromptProvider = Object.assign(Object.assign({}, config.aiPromptProvider), { key: config.identifier + '-ai-prompt-provider' });