@crowdin/app-project-module 1.8.0 → 1.9.0

package/out/types.d.ts

@@ -1,5 +1,4 @@
 import Crowdin from '@crowdin/crowdin-api-client';
-import { JwtPayload, VerifyOptions } from '@crowdin/crowdin-apps-functions';
 import { Request } from 'express';
 import { ContextContent } from './modules/context-menu/types';
 import { CustomMTLogic } from './modules/custom-mt/types';
@@ -588,3 +587,48 @@ export interface FileStore {
     storeFile: (content: Buffer) => Promise<string>;
     deleteFile: (fileRef: string) => Promise<void>;
 }
+export interface JwtPayload {
+    aud: string;
+    sub: string;
+    domain?: string;
+    module?: string;
+    context: JwtPayloadContext;
+    iat: number;
+    exp: number;
+    code?: string;
+}
+export interface JwtPayloadContext {
+    project_id: number;
+    project_identifier?: string;
+    organization_id: number;
+    organization_domain?: string;
+    user_id: number;
+    user_login?: string;
+}
+export interface VerifyOptions {
+    ignoreExpiration: boolean;
+}
+export interface InstallEvent {
+    appId: string;
+    appSecret: string;
+    clientId: string;
+    userId: number;
+    agentId?: number;
+    organizationId: number;
+    domain?: string;
+    baseUrl: string;
+    code?: string;
+}
+export interface UninstallEvent {
+    appId: string;
+    appSecret: string;
+    clientId: string;
+    organizationId: number;
+    domain?: string;
+    baseUrl: string;
+}
+export declare class PaymentRequiredError extends Error {
+    subscribeLink: string;
+    initializedAt: string;
+    constructor(subscribeLink: string, initializedAt: string);
+}

package/out/types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.storageFiles = exports.ProjectPermissions = exports.UserPermissions = exports.EditorMode = exports.SubscriptionInfoType = exports.AccountType = exports.Scope = exports.AuthenticationType = void 0;
+exports.PaymentRequiredError = exports.storageFiles = exports.ProjectPermissions = exports.UserPermissions = exports.EditorMode = exports.SubscriptionInfoType = exports.AccountType = exports.Scope = exports.AuthenticationType = void 0;
 var AuthenticationType;
 (function (AuthenticationType) {
     AuthenticationType["CODE"] = "authorization_code";
@@ -76,3 +76,13 @@ var storageFiles;
     storageFiles["SQLITE_BACKUP"] = "backup_app.sqlite";
     storageFiles["DUMP"] = "dump_table_%s.sql";
 })(storageFiles || (exports.storageFiles = storageFiles = {}));
+class PaymentRequiredError extends Error {
+    constructor(subscribeLink, initializedAt) {
+        super('Payment required');
+        this.subscribeLink = subscribeLink;
+        this.initializedAt = initializedAt;
+        // @ts-expect-error: Adding custom property
+        this.code = 402;
+    }
+}
+exports.PaymentRequiredError = PaymentRequiredError;

package/out/util/app-functions/crowdin.d.ts

@@ -0,0 +1,104 @@
+import Crowdin, { ReportsModel, SourceFilesModel, TranslationsModel, WebhooksModel } from '@crowdin/crowdin-api-client';
+interface UpdateOrCreateFileArgs {
+    client: Crowdin;
+    projectId: number;
+    name: string;
+    title?: string;
+    type?: SourceFilesModel.FileType;
+    directoryId?: number;
+    data: any;
+    file?: SourceFilesModel.File;
+    excludedTargetLanguages?: string[];
+    importOptions?: SourceFilesModel.ImportOptions;
+}
+export declare function updateOrCreateFile(options: UpdateOrCreateFileArgs): Promise<number>;
+interface GetFolderArgs {
+    directories: SourceFilesModel.Directory[];
+    client: Crowdin;
+    projectId: number;
+    directoryName: string;
+    parentDirectory?: SourceFilesModel.Directory;
+}
+export declare function getFolder(args: GetFolderArgs): Promise<{
+    folder?: SourceFilesModel.Directory;
+    files: SourceFilesModel.File[];
+}>;
+interface GetOrCreateFolderArgs {
+    directories: SourceFilesModel.Directory[];
+    client: Crowdin;
+    projectId: number;
+    directoryName: string;
+    parentDirectory?: SourceFilesModel.Directory;
+}
+export declare function getOrCreateFolder(args: GetOrCreateFolderArgs): Promise<{
+    folder: SourceFilesModel.Directory;
+    files: SourceFilesModel.File[];
+    created: boolean;
+}>;
+interface UploadTranslationsArgs {
+    client: Crowdin;
+    projectId: number;
+    fileId: number;
+    language: string;
+    fileName: string;
+    fileContent: any;
+    request?: Omit<TranslationsModel.UploadTranslationRequest, 'fileId' | 'storageId'>;
+}
+export declare function uploadTranslations(args: UploadTranslationsArgs): Promise<TranslationsModel.UploadTranslationResponse>;
+interface UpdateSourceFilesArgs {
+    client: Crowdin;
+    projectId: number;
+    directory: string;
+    fileEntities: FileEntity[];
+    parentDirectory?: SourceFilesModel.Directory;
+}
+export declare function updateSourceFiles(args: UpdateSourceFilesArgs): Promise<void>;
+interface HandleTranslationsArgs {
+    client: Crowdin;
+    projectId: number;
+    directory: string;
+    request: TranslationsRequest;
+    parentDirectory?: SourceFilesModel.Directory;
+    handleFn: (translations: any, language: string, file: SourceFilesModel.File) => Promise<void>;
+}
+export declare function handleTranslations(args: HandleTranslationsArgs): Promise<void>;
+interface CreateOrUpdateWebhookArgs {
+    client: Crowdin;
+    projectId: number;
+    url: string;
+    events: WebhooksModel.Event[];
+    payload: any;
+    name: string;
+    requestType?: WebhooksModel.RequestType;
+    batchingEnabled?: boolean;
+    headers?: Record<string, string>;
+    contentType?: WebhooksModel.ContentType;
+    webhookId?: number;
+    webhookMatch?: (webhook: WebhooksModel.Webhook) => boolean;
+}
+export declare function createOrUpdateWebhook(args: CreateOrUpdateWebhookArgs): Promise<number>;
+export declare function getSubscription({ appIdentifier, token, organization, baseUrl, }: SubscriptionRequest): Promise<Subscription>;
+export declare function generateReport({ client, projectId, request, }: {
+    client: Crowdin;
+    projectId: number;
+    request: ReportsModel.GenerateReportRequest;
+}): Promise<any | undefined>;
+interface FileEntity {
+    name: string;
+    title: string;
+    type: SourceFilesModel.FileType;
+    data: any;
+}
+interface TranslationsRequest {
+    [fileId: string]: string[];
+}
+interface SubscriptionRequest {
+    token: string;
+    organization?: string;
+    appIdentifier: string;
+    baseUrl?: string;
+}
+interface Subscription {
+    expires: string;
+}
+export {};

package/out/util/app-functions/crowdin.js

@@ -0,0 +1,245 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateOrCreateFile = updateOrCreateFile;
+exports.getFolder = getFolder;
+exports.getOrCreateFolder = getOrCreateFolder;
+exports.uploadTranslations = uploadTranslations;
+exports.updateSourceFiles = updateSourceFiles;
+exports.handleTranslations = handleTranslations;
+exports.createOrUpdateWebhook = createOrUpdateWebhook;
+exports.getSubscription = getSubscription;
+exports.generateReport = generateReport;
+const axios_1 = __importDefault(require("axios"));
+const types_1 = require("../../types");
+function updateOrCreateFile(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const storageFile = yield options.client.uploadStorageApi.addStorage(options.name, options.data);
+        if (options.file) {
+            yield options.client.sourceFilesApi.updateOrRestoreFile(options.projectId, options.file.id, Object.assign({ storageId: storageFile.data.id }, (options.importOptions && { importOptions: options.importOptions })));
+            const updates = [];
+            if (options.title && options.title !== options.file.title) {
+                updates.push({
+                    value: options.title,
+                    op: 'replace',
+                    path: '/title',
+                });
+            }
+            if (options.excludedTargetLanguages) {
+                updates.push({
+                    value: options.excludedTargetLanguages,
+                    op: 'replace',
+                    path: '/excludedTargetLanguages',
+                });
+            }
+            if (updates.length > 0) {
+                yield options.client.sourceFilesApi.editFile(options.projectId, options.file.id, updates);
+            }
+            return options.file.id;
+        }
+        else {
+            const newFile = yield options.client.sourceFilesApi.createFile(options.projectId, {
+                storageId: storageFile.data.id,
+                name: options.name,
+                title: options.title,
+                type: options.type,
+                directoryId: options.directoryId,
+                excludedTargetLanguages: options.excludedTargetLanguages,
+                importOptions: options.importOptions,
+            });
+            return newFile.data.id;
+        }
+    });
+}
+function getFolder(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const folder = args.directories.find((d) => {
+            var _a;
+            return d.name === args.directoryName &&
+                ((!args.parentDirectory && !d.directoryId) || d.directoryId === ((_a = args.parentDirectory) === null || _a === void 0 ? void 0 : _a.id));
+        });
+        let files = [];
+        if (folder) {
+            files = (yield args.client.sourceFilesApi.withFetchAll().listProjectFiles(args.projectId, { directoryId: folder.id })).data.map((e) => e.data);
+        }
+        return { folder, files };
+    });
+}
+function getOrCreateFolder(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let { folder, files } = yield getFolder(args);
+        let created = false;
+        if (!folder) {
+            created = true;
+            folder = (yield args.client.sourceFilesApi.createDirectory(args.projectId, {
+                name: args.directoryName,
+                directoryId: args.parentDirectory ? args.parentDirectory.id : undefined,
+            })).data;
+            files = (yield args.client.sourceFilesApi.withFetchAll().listProjectFiles(args.projectId, { directoryId: folder.id })).data.map((e) => e.data);
+        }
+        return { folder, files, created };
+    });
+}
+function uploadTranslations(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const storage = yield args.client.uploadStorageApi.addStorage(args.fileName, args.fileContent);
+        return (yield args.client.translationsApi.uploadTranslation(args.projectId, args.language, Object.assign({ fileId: args.fileId, storageId: storage.data.id }, (args.request || {})))).data;
+    });
+}
+function updateSourceFiles(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const directories = yield args.client.sourceFilesApi.withFetchAll().listProjectDirectories(args.projectId);
+        const { folder, files } = yield getOrCreateFolder({
+            directories: directories.data.map((d) => d.data),
+            client: args.client,
+            projectId: args.projectId,
+            directoryName: args.directory,
+            parentDirectory: args.parentDirectory,
+        });
+        yield Promise.all(args.fileEntities.map((fileEntity) => __awaiter(this, void 0, void 0, function* () {
+            return yield updateOrCreateFile({
+                client: args.client,
+                projectId: args.projectId,
+                name: fileEntity.name,
+                title: fileEntity.title,
+                type: fileEntity.type,
+                directoryId: folder.id,
+                data: fileEntity.data,
+                file: files.find((f) => f.name === fileEntity.name),
+            });
+        })));
+    });
+}
+function handleTranslations(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const directories = yield args.client.sourceFilesApi.withFetchAll().listProjectDirectories(args.projectId);
+        const { files } = yield getFolder({
+            directories: directories.data.map((d) => d.data),
+            client: args.client,
+            projectId: args.projectId,
+            directoryName: args.directory,
+            parentDirectory: args.parentDirectory,
+        });
+        for (const [fileId, targetLanguages] of Object.entries(args.request)) {
+            const file = files.find((f) => f.id === parseInt(fileId));
+            if (!file) {
+                continue;
+            }
+            yield Promise.all(targetLanguages.map((languageCode) => __awaiter(this, void 0, void 0, function* () {
+                const translationsLink = yield args.client.translationsApi.buildProjectFileTranslation(args.projectId, file.id, {
+                    targetLanguageId: languageCode,
+                });
+                if (!translationsLink) {
+                    return;
+                }
+                const response = yield axios_1.default.get(translationsLink.data.url);
+                yield args.handleFn(response.data, languageCode, file);
+            })));
+        }
+    });
+}
+function createOrUpdateWebhook(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { client, projectId, events, name, url, payload, requestType = 'POST', batchingEnabled = true, headers, contentType, webhookId, webhookMatch, } = args;
+        let id = webhookId;
+        if (webhookMatch) {
+            const webhooks = yield client.webhooksApi.withFetchAll().listWebhooks(projectId);
+            const webhook = webhooks.data.find((e) => webhookMatch(e.data));
+            if (webhook) {
+                id = webhook.data.id;
+            }
+        }
+        if (id) {
+            yield client.webhooksApi.editWebhook(projectId, id, [
+                {
+                    value: events,
+                    op: 'replace',
+                    path: '/events',
+                },
+                {
+                    value: payload,
+                    op: 'replace',
+                    path: '/payload',
+                },
+                {
+                    value: url,
+                    op: 'replace',
+                    path: '/url',
+                },
+            ]);
+            return id;
+        }
+        else {
+            const newWebhook = yield client.webhooksApi.addWebhook(projectId, {
+                name,
+                url,
+                events,
+                requestType,
+                payload,
+                batchingEnabled,
+                headers,
+                contentType,
+            });
+            return newWebhook.data.id;
+        }
+    });
+}
+function getSubscription(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ appIdentifier, token, organization, baseUrl, }) {
+        var _b, _c, _d, _e;
+        let requestUrl;
+        if (baseUrl) {
+            requestUrl = `${baseUrl}/api/v2/applications/${appIdentifier}/subscription`;
+        }
+        else if (!!organization) {
+            requestUrl = `https://${organization}.api.crowdin.com/api/v2/applications/${appIdentifier}/subscription`;
+        }
+        else {
+            requestUrl = `https://crowdin.com/api/v2/applications/${appIdentifier}/subscription`;
+        }
+        try {
+            const response = yield axios_1.default.get(requestUrl, {
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+            });
+            return response.data;
+        }
+        catch (error) {
+            const e = error;
+            if (e.response) {
+                if (e.response.status === 402) {
+                    throw new types_1.PaymentRequiredError((_b = e.response.data) === null || _b === void 0 ? void 0 : _b.subscribeLink, (_c = e.response.data) === null || _c === void 0 ? void 0 : _c.initializedAt);
+                }
+                else if ((_e = (_d = e.response.data) === null || _d === void 0 ? void 0 : _d.error) === null || _e === void 0 ? void 0 : _e.message) {
+                    throw new Error(e.response.data.error.message);
+                }
+            }
+            throw e;
+        }
+    });
+}
+function generateReport(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ client, projectId, request, }) {
+        const report = yield client.reportsApi.generateReport(projectId, request);
+        while (true) {
+            const status = yield client.reportsApi.checkReportStatus(projectId, report.data.identifier);
+            if (status.data.status === 'finished') {
+                const downloadRes = yield client.reportsApi.downloadReport(projectId, report.data.identifier);
+                const reportBlob = yield axios_1.default.get(downloadRes.data.url);
+                return reportBlob.data;
+            }
+        }
+    });
+}

package/out/util/app-functions/token.d.ts

@@ -0,0 +1,71 @@
+import { JwtPayload, VerifyOptions } from '../../types';
+interface FetchAppTokenArgs {
+    appId: string;
+    appSecret: string;
+    clientId: string;
+    clientSecret: string;
+    domain: string;
+    userId: number;
+    url?: string;
+}
+export declare function fetchAppToken(options: FetchAppTokenArgs): Promise<AppToken>;
+interface FetchAgentTokenArgs extends FetchAppTokenArgs {
+    agentId: number;
+}
+export declare function fetchAgentToken(args: FetchAgentTokenArgs): Promise<AppToken>;
+interface FetchAppWithCodeTokenArgs extends FetchAppTokenArgs {
+    code: string;
+}
+export declare function fetchAppWithCodeToken(args: FetchAppWithCodeTokenArgs): Promise<AppToken>;
+interface GenerateOAuthTokenArgs {
+    clientId: string;
+    clientSecret: string;
+    code: string;
+    url?: string;
+}
+export declare function generateOAuthToken(options: GenerateOAuthTokenArgs): Promise<Token>;
+interface RefreshOAuthTokenArgs {
+    clientId: string;
+    clientSecret: string;
+    refreshToken: string;
+    url?: string;
+}
+export declare function refreshOAuthToken(options: RefreshOAuthTokenArgs): Promise<Token>;
+/**
+ *
+ * @param jwtPayload jwt token payload
+ * @returns unique identifier of crowdin user and project context
+ */
+export declare function constructCrowdinIdFromJwtPayload(jwtPayload: JwtPayload): string;
+/**
+ *
+ * @param crowdinId crowdin id (from {@link constructCrowdinIdFromJwtPayload})
+ * @returns crowdin project id
+ */
+export declare function getProjectId(crowdinId: string): number;
+/**
+ *
+ * @param crowdinId crowdin id (from {@link constructCrowdinIdFromJwtPayload})
+ * @returns object with organization(id|domain), project id and user id
+ */
+export declare function parseCrowdinId(crowdinId: string): {
+    organization: string;
+    projectId: number;
+    userId: number;
+};
+/**
+ *
+ * @param jwtToken jwt token which Crowdin adds to app iframe
+ * @param clientSecret OAuth client secret of the app
+ * @param options extra options for verification
+ * @returns jwt payload
+ */
+export declare function validateJwtToken(jwtToken: string, clientSecret: string, options?: VerifyOptions): Promise<JwtPayload>;
+interface AppToken {
+    accessToken: string;
+    expiresIn: number;
+}
+interface Token extends AppToken {
+    refreshToken: string;
+}
+export {};

package/out/util/app-functions/token.js

@@ -0,0 +1,192 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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) {
+        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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchAppToken = fetchAppToken;
+exports.fetchAgentToken = fetchAgentToken;
+exports.fetchAppWithCodeToken = fetchAppWithCodeToken;
+exports.generateOAuthToken = generateOAuthToken;
+exports.refreshOAuthToken = refreshOAuthToken;
+exports.constructCrowdinIdFromJwtPayload = constructCrowdinIdFromJwtPayload;
+exports.getProjectId = getProjectId;
+exports.parseCrowdinId = parseCrowdinId;
+exports.validateJwtToken = validateJwtToken;
+const axios_1 = __importDefault(require("axios"));
+const jwt = __importStar(require("jsonwebtoken"));
+const crowdinAuthUrl = 'https://accounts.crowdin.com/oauth/token';
+function fetchAppToken(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const token = yield axios_1.default.post(options.url || crowdinAuthUrl, {
+            grant_type: 'crowdin_app',
+            client_id: options.clientId,
+            client_secret: options.clientSecret,
+            app_id: options.appId,
+            app_secret: options.appSecret,
+            domain: options.domain,
+            user_id: options.userId,
+        });
+        return {
+            accessToken: token.data.access_token,
+            expiresIn: +token.data.expires_in,
+        };
+    });
+}
+function fetchAgentToken(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const token = yield axios_1.default.post(args.url || crowdinAuthUrl, {
+            grant_type: 'crowdin_agent',
+            client_id: args.clientId,
+            client_secret: args.clientSecret,
+            app_id: args.appId,
+            app_secret: args.appSecret,
+            domain: args.domain,
+            user_id: args.userId,
+            agent_id: args.agentId,
+        });
+        return {
+            accessToken: token.data.access_token,
+            expiresIn: +token.data.expires_in,
+        };
+    });
+}
+function fetchAppWithCodeToken(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const token = yield axios_1.default.post(args.url || crowdinAuthUrl, {
+            grant_type: 'crowdin_app_with_code',
+            client_id: args.clientId,
+            client_secret: args.clientSecret,
+            app_id: args.appId,
+            app_secret: args.appSecret,
+            domain: args.domain,
+            user_id: args.userId,
+            code: args.code,
+        });
+        return {
+            accessToken: token.data.access_token,
+            expiresIn: +token.data.expires_in,
+        };
+    });
+}
+function generateOAuthToken(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const token = yield axios_1.default.post(options.url || crowdinAuthUrl, {
+            grant_type: 'authorization_code',
+            client_id: options.clientId,
+            client_secret: options.clientSecret,
+            code: options.code,
+        });
+        return {
+            accessToken: token.data.access_token,
+            refreshToken: token.data.refresh_token,
+            expiresIn: +token.data.expires_in,
+        };
+    });
+}
+function refreshOAuthToken(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const token = yield axios_1.default.post(options.url || crowdinAuthUrl, {
+            grant_type: 'refresh_token',
+            client_id: options.clientId,
+            client_secret: options.clientSecret,
+            refresh_token: options.refreshToken,
+        });
+        return {
+            accessToken: token.data.access_token,
+            refreshToken: token.data.refresh_token,
+            expiresIn: +token.data.expires_in,
+        };
+    });
+}
+/**
+ *
+ * @param jwtPayload jwt token payload
+ * @returns unique identifier of crowdin user and project context
+ */
+function constructCrowdinIdFromJwtPayload(jwtPayload) {
+    return `${jwtPayload.domain || jwtPayload.context.organization_id}__${jwtPayload.context.project_id}__${jwtPayload.sub}`;
+}
+/**
+ *
+ * @param crowdinId crowdin id (from {@link constructCrowdinIdFromJwtPayload})
+ * @returns crowdin project id
+ */
+function getProjectId(crowdinId) {
+    return Number(crowdinId.split('__')[1]);
+}
+/**
+ *
+ * @param crowdinId crowdin id (from {@link constructCrowdinIdFromJwtPayload})
+ * @returns object with organization(id|domain), project id and user id
+ */
+function parseCrowdinId(crowdinId) {
+    const crowdinIdParts = crowdinId.split('__');
+    return {
+        organization: crowdinIdParts[0],
+        projectId: Number(crowdinIdParts[1]),
+        userId: Number(crowdinIdParts[2]),
+    };
+}
+/**
+ *
+ * @param jwtToken jwt token which Crowdin adds to app iframe
+ * @param clientSecret OAuth client secret of the app
+ * @param options extra options for verification
+ * @returns jwt payload
+ */
+function validateJwtToken(jwtToken, clientSecret, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((res, rej) => {
+            jwt.verify(jwtToken, clientSecret, options, (err, decoded) => {
+                if (err) {
+                    rej(err);
+                }
+                else {
+                    res(decoded);
+                }
+            });
+        });
+    });
+}