@crowdin/app-project-module 0.81.0 → 0.82.0

package/README.md

@@ -1,13 +1,11 @@
-# Crowdin App Project Module
+# Crowdin Apps SDK
 
-Module that will automatically add all necessary endpoints for Crowdin App.
+The Crowdin Apps SDK is a framework that allows you to build custom apps for Crowdin. It provides a set of tools and components that you can use to build your app and integrate it with Crowdin.
 
-:bookmark: See the [docs](https://crowdin.github.io/app-project-module/) for more information.
-
-## Contributing
+It is designed to help you create apps that can be easily installed and used by Crowdin users. It handles the communication between your app and Crowdin, so you can focus on building the functionality of your app.
 
-If you would like to contribute please read the [Contributing](/CONTRIBUTING.md) guidelines.
+:bookmark: See the [docs](https://crowdin.github.io/app-project-module/) for more information.
 
 ## Seeking Assistance
 
-If you find any problems or would like to suggest a feature, please feel free to file an issue on GitHub at [Issues Page](https://github.com/crowdin/app-project-module/issues) or [Contact Customer Success Service](https://crowdin.com/contacts).
+If you are experiencing problems or would like to suggest a feature, [Contact Customer Success Service](https://crowdin.com/contacts).

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' });