@crowdin/app-project-module 0.103.0 → 0.104.1

package/out/index.js

@@ -88,6 +88,7 @@ const webhooks = __importStar(require("./modules/webhooks"));
 const workflowStepType = __importStar(require("./modules/workflow-step-type"));
 const aiRequestProcessors = __importStar(require("./modules/ai-request-processors"));
 const automationAction = __importStar(require("./modules/automation-action"));
+const authGuard = __importStar(require("./modules/auth-guard"));
 const subscription_1 = require("./util/subscription");
 var types_2 = require("./types");
 Object.defineProperty(exports, "ProjectPermissions", { enumerable: true, get: function () { return types_2.ProjectPermissions; } });
@@ -222,6 +223,7 @@ function addCrowdinEndpoints(app, clientConfig) {
     workflowStepType.register({ config, app });
     aiRequestProcessors.register({ config, app });
     automationAction.register({ config, app });
+    authGuard.register({ config, app });
     addFormSchema({ config, app });
     return Object.assign(Object.assign({}, exports.metadataStore), { storage: storage.getStorage(), establishCrowdinConnection: (authRequest, moduleKey) => {
             let jwtToken = '';

package/out/modules/auth-guard/handlers/verify.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="qs" />
+import { Response } from 'express';
+import { CrowdinClientRequest } from '../../../types';
+import { AuthGuardModule } from '../types';
+export default function verifyHandler(authGuardModules: AuthGuardModule[]): (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/auth-guard/handlers/verify.js

@@ -0,0 +1,57 @@
+"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");
+function verifyHandler(authGuardModules) {
+    return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
+        const { userId, organizationId, ipAddress, moduleKey, code } = req.body;
+        req.logInfo(`Auth guard verification request for module: ${moduleKey}`);
+        // Find the auth-guard module by key
+        const module = authGuardModules.find((m) => m.key === moduleKey);
+        if (!module) {
+            req.logError(`Auth guard module not found: ${moduleKey}`);
+            return res.status(404).json({
+                error: `Auth guard module not found: ${moduleKey}`,
+            });
+        }
+        try {
+            // Call the user-provided verification logic
+            const result = yield module.verify({
+                client: req.crowdinApiClient,
+                context: req.crowdinContext,
+                userId,
+                organizationId,
+                ipAddress,
+                moduleKey,
+                code,
+            });
+            if (!result || typeof result.success !== 'boolean') {
+                req.logError('Invalid response from auth guard verification function');
+                return res.status(500).json({
+                    success: false,
+                    message: 'Invalid response from verification function',
+                });
+            }
+            // Return the result (always HTTP 200, success field indicates verification result)
+            req.logInfo(`Auth guard verification ${result.success ? 'succeeded' : 'failed'} for module: ${moduleKey}`);
+            return res.status(200).json(result);
+        }
+        catch (error) {
+            req.logError(`Auth guard verification error: ${error.message || error}`);
+            // Return HTTP 500 for internal errors
+            return res.status(500).json({
+                success: false,
+                message: 'Internal server error during verification',
+            });
+        }
+    }));
+}
+exports.default = verifyHandler;

package/out/modules/auth-guard/index.d.ts

@@ -0,0 +1,6 @@
+import { Express } from 'express';
+import { Config } from '../../types';
+export declare function register({ config, app }: {
+    config: Config;
+    app: Express;
+}): void;

package/out/modules/auth-guard/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const crowdin_client_1 = __importDefault(require("../../middlewares/crowdin-client"));
+const json_response_1 = __importDefault(require("../../middlewares/json-response"));
+const render_ui_module_1 = __importDefault(require("../../middlewares/render-ui-module"));
+const ui_module_1 = __importDefault(require("../../middlewares/ui-module"));
+const verify_1 = __importDefault(require("./handlers/verify"));
+function register({ config, app }) {
+    if (!config.authGuard) {
+        return;
+    }
+    // Normalize to array
+    const authGuardModules = Array.isArray(config.authGuard) ? config.authGuard : [config.authGuard];
+    if (!authGuardModules.length) {
+        return;
+    }
+    // Register settings UI modules if provided
+    authGuardModules.forEach((module, index) => {
+        if (module.settingsUiModule) {
+            const moduleKey = module.key || `${config.identifier}-auth-guard-${index}`;
+            app.use(`/auth-guard/${moduleKey}/settings`, (0, ui_module_1.default)({ config, moduleType: moduleKey }), (0, render_ui_module_1.default)(module.settingsUiModule));
+        }
+    });
+    // Register verification endpoint
+    app.post('/auth-guard/verify', json_response_1.default, (0, crowdin_client_1.default)({
+        config,
+        optional: false,
+        checkSubscriptionExpiration: false,
+        moduleKey: authGuardModules.map((m, i) => m.key || `${config.identifier}-auth-guard-${i}`),
+    }), (0, verify_1.default)(authGuardModules));
+}
+exports.register = register;

package/out/modules/auth-guard/types.d.ts

@@ -0,0 +1,101 @@
+import Crowdin from '@crowdin/crowdin-api-client';
+import { CrowdinContextInfo, Environments, ModuleKey, UiModule } from '../../types';
+/**
+ * Auth Guard verification type
+ */
+export type AuthGuardVerificationType = 'direct' | 'redirect' | 'iframe';
+/**
+ * Auth Guard module options
+ */
+export interface AuthGuardOptions {
+    /**
+     * Verification type: direct (backend-only), redirect (external page), or iframe (embedded iframe)
+     * @default 'direct'
+     */
+    type?: AuthGuardVerificationType;
+    /**
+     * Whether to apply this check to organization administrators
+     * @default false
+     */
+    applyToAdmin?: boolean;
+    /**
+     * User-facing URL for redirect and iframe types
+     * Required if type is not 'direct'
+     */
+    url?: string;
+}
+/**
+ * Request body for auth guard verification
+ */
+export interface AuthGuardVerifyRequest {
+    /**
+     * User ID
+     */
+    userId: number;
+    /**
+     * Organization ID
+     */
+    organizationId: number;
+    /**
+     * User's IP address
+     */
+    ipAddress: string;
+    /**
+     * Module key to identify which auth-guard module to invoke
+     */
+    moduleKey: string;
+    /**
+     * Verification code (provided for redirect/iframe types after user interaction)
+     */
+    code?: string;
+}
+/**
+ * Response for auth guard verification
+ */
+export interface AuthGuardVerifyResponse {
+    /**
+     * Whether verification was successful
+     */
+    success: boolean;
+    /**
+     * Optional error or informational message
+     */
+    message?: string;
+}
+/**
+ * Auth Guard module configuration
+ */
+export interface AuthGuardModule extends ModuleKey, Environments {
+    /**
+     * Module name displayed to users during verification
+     */
+    name?: string;
+    /**
+     * Module description (primarily for iframe type)
+     */
+    description?: string;
+    /**
+     * Endpoint URL for verification (relative to baseUrl or absolute)
+     */
+    url?: string;
+    /**
+     * Module configuration options
+     */
+    options?: AuthGuardOptions;
+    /**
+     * Settings UI module for configuration
+     */
+    settingsUiModule?: UiModule;
+    /**
+     * Verification logic function
+     */
+    verify: (params: {
+        client?: Crowdin;
+        context?: CrowdinContextInfo;
+        userId: number;
+        organizationId: number;
+        ipAddress: string;
+        moduleKey: string;
+        code?: string;
+    }) => Promise<AuthGuardVerifyResponse>;
+}

package/out/modules/auth-guard/types.js

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

package/out/modules/manifest.js

@@ -411,6 +411,35 @@ function handle(config) {
                 : {})), { validateSettingsUrl: (0, index_1.getAutomationActionUrl)('/automation-action/validate-settings', automationAction), executeUrl: (0, index_1.getAutomationActionUrl)('/automation-action/execute', automationAction), invocationWaitMode: automationAction.invocationWaitMode || 'sync' }), (uiModule ? { url: (0, index_1.getAutomationActionUrl)('/automation-action', automationAction) } : {})));
         }
     }
+    if (config.authGuard) {
+        // prevent possible overrides of the other modules
+        if (Array.isArray(config.authGuard)) {
+            config.authGuard = config.authGuard.map((authGuard) => (Object.assign({}, authGuard)));
+        }
+        else {
+            config.authGuard = Object.assign({}, config.authGuard);
+        }
+        const authGuards = Array.isArray(config.authGuard) ? config.authGuard : [config.authGuard];
+        modules['auth-guard'] = [];
+        for (let i = 0; i < authGuards.length; i++) {
+            if (!authGuards[i].key) {
+                authGuards[i].key = config.identifier + '-auth-guard-' + i;
+            }
+            const options = authGuards[i].options || {};
+            const manifestEntry = {
+                key: authGuards[i].key,
+                name: authGuards[i].name || config.name,
+                url: '/auth-guard/verify',
+            };
+            if (authGuards[i].description) {
+                manifestEntry.description = authGuards[i].description;
+            }
+            if (options.type || options.applyToAdmin !== undefined || options.url) {
+                manifestEntry.options = Object.assign(Object.assign(Object.assign({}, (options.type && { type: options.type })), (options.applyToAdmin !== undefined && { applyToAdmin: options.applyToAdmin })), (options.url && { url: options.url }));
+            }
+            modules['auth-guard'].push(manifestEntry);
+        }
+    }
     const events = {
         installed: '/installed',
         uninstall: '/uninstall',

package/out/types.d.ts

@@ -20,6 +20,7 @@ import { Webhook } from './modules/webhooks/types';
 import { WorkflowStepTypeModule } from './modules/workflow-step-type/types';
 import { AiRequestProcessorModule, AiStreamProcessorModule } from './modules/ai-request-processors/types';
 import { AutomationActionModule } from './modules/automation-action/types';
+import { AuthGuardModule } from './modules/auth-guard/types';
 export interface ClientConfig extends ImagePath {
     /**
      * Authentication Crowdin App type: "authorization_code", "crowdin_app", "crowdin_agent". Default: "crowdin_app"
@@ -272,6 +273,10 @@ export interface ClientConfig extends ImagePath {
      * Automation action module
      */
     automationAction?: AutomationActionModule | AutomationActionModule[];
+    /**
+     * Auth guard module for custom authentication/authorization checks
+     */
+    authGuard?: AuthGuardModule | AuthGuardModule[];
 }
 export interface Environments {
     environments?: Environment | Environment[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crowdin/app-project-module",
-  "version": "0.103.0",
+  "version": "0.104.1",
   "description": "Module that generates for you all common endpoints for serving standalone Crowdin App",
   "main": "out/index.js",
   "types": "out/index.d.ts",