@crowdin/app-project-module 0.74.0 → 0.76.0

package/out/modules/integration/util/types.d.ts

@@ -3,6 +3,8 @@ import { Config } from '../../../types';
 import { IntegrationLogic, IntegrationSyncSettings } from '../types';
 import { ResponseObject } from '@crowdin/crowdin-api-client/out/core';
 import { TranslationsModel } from '@crowdin/crowdin-api-client/out/translations';
+import { AxiosError } from 'axios';
+import { AppModuleError, AppUserModuleError } from '../../../util/logger';
 export declare enum JobType {
     UPDATE_TO_CROWDIN = "updateCrowdin",
     UPDATE_TO_INTEGRATION = "updateIntegration",
@@ -56,6 +58,8 @@ export type JobClient = {
     type: JobClientType;
     translationUploaded: SaveUploadedFileTranslation;
     fetchTranslation: FetchTranslation;
+    markFilesAsUnsynced: MarkUnsyncedFiles;
+    unmarkFilesAsUnsynced: UnmarkUnsyncedFiles;
 };
 export type UpdateJobProgress = ({ progress, status, info, data, attempt, }: Omit<UpdateJobParams, 'id'>) => Promise<{
     isCanceled: boolean;
@@ -92,3 +96,20 @@ export interface TranslationCache {
 export type GetFileTranslationCache = Pick<TranslationCache, 'integrationId' | 'crowdinId' | 'fileId'>;
 export type GetFileTranslationCacheByLanguageParams = Pick<TranslationCache, 'integrationId' | 'crowdinId' | 'fileId' | 'languageId'>;
 export type UpdateTranslationCacheParams = Pick<TranslationCache, 'integrationId' | 'crowdinId' | 'fileId' | 'languageId' | 'etag'>;
+export type MarkUnsyncedFiles = ({ files, }: {
+    files: {
+        fileId: number;
+        error: AxiosError | AppModuleError | AppUserModuleError | Error | string;
+    }[];
+}) => Promise<void>;
+export type UnmarkUnsyncedFiles = ({ files }: {
+    files: {
+        fileId: number;
+    }[];
+}) => Promise<void>;
+export interface UnsyncedFiles {
+    integrationId: string;
+    crowdinId: string;
+    files: string;
+}
+export type GetUnsyncedFiles = Pick<UnsyncedFiles, 'integrationId' | 'crowdinId'>;

package/out/modules/integration/util/webhooks.js

@@ -45,8 +45,8 @@ const connection_1 = require("../../../util/connection");
 const defaults_1 = require("./defaults");
 const index_1 = require("../../../util/index");
 const logger_1 = require("../../../util/logger");
-const prefetchCount = 20;
-const forceProcessDelay = 5000;
+const prefetchCount = 10;
+const forceProcessDelay = 10000;
 exports.HookEvents = {
     fileAdded: 'file.added',
     fileDeleted: 'file.deleted',
@@ -407,7 +407,7 @@ function consumer({ channel, config, integration, }) {
                     webhooksInfo[clientId].data.push(data);
                 }
                 if (messagesCounter < prefetchCount) {
-                    // if all messages are not received, wait 5 seconds to force process messages
+                    // if all messages are not received, wait 10 seconds to force process messages
                     timeoutId = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
                         yield processMessages({
                             webhooksData,
@@ -436,16 +436,22 @@ function consumer({ channel, config, integration, }) {
 }
 function processMessages({ channel, msg, webhooksData, webhooksInfo, }) {
     return __awaiter(this, void 0, void 0, function* () {
-        yield Promise.all(webhooksData);
-        for (const { data, integration, webhookData } of Object.values(webhooksInfo)) {
-            if (webhookData && webhookData.crowdinClient) {
-                yield updateCrowdinFromWebhookRequest({
-                    integration: integration,
-                    webhookData: webhookData,
-                    req: data,
-                });
+        try {
+            yield Promise.all(webhooksData);
+            for (const { data, integration, webhookData } of Object.values(webhooksInfo)) {
+                if (webhookData && webhookData.crowdinClient) {
+                    yield updateCrowdinFromWebhookRequest({
+                        integration: integration,
+                        webhookData: webhookData,
+                        req: data,
+                    });
+                }
             }
+            channel.ack(msg, true);
+        }
+        catch (e) {
+            (0, logger_1.logError)(e);
+            channel.nack(msg, false, false);
         }
-        channel.ack(msg, true);
     });
 }

package/out/storage/index.d.ts

@@ -1,8 +1,22 @@
 import { IntegrationConfig, IntegrationCredentials, IntegrationFilesSnapshot, IntegrationSyncSettings, IntegrationWebhooks, Provider } from '../modules/integration/types';
 import { Config, CrowdinCredentials, UnauthorizedConfig } from '../types';
-import { CreateJobParams, GetActiveJobsParams, GetJobParams, GetFileTranslationCacheByLanguageParams, Job, TranslationCache, UpdateJobParams, UpdateTranslationCacheParams, GetFileTranslationCache } from '../modules/integration/util/types';
+import { CreateJobParams, GetActiveJobsParams, GetJobParams, GetFileTranslationCacheByLanguageParams, Job, TranslationCache, UpdateJobParams, UpdateTranslationCacheParams, GetFileTranslationCache, UnsyncedFiles, GetUnsyncedFiles } from '../modules/integration/util/types';
 import { UserErrors } from './types';
+declare const TABLES: {
+    crowdin_credentials: string;
+    integration_credentials: string;
+    sync_settings: string;
+    app_metadata: string;
+    files_snapshot: string;
+    webhooks: string;
+    user_errors: string;
+    integration_settings: string;
+    job: string;
+    translation_file_cache: string;
+    unsynced_files: string;
+};
 export interface Storage {
+    tables: typeof TABLES;
     migrate(): Promise<void>;
     saveCrowdinCredentials(credentials: CrowdinCredentials): Promise<void>;
     updateCrowdinCredentials(credentials: CrowdinCredentials): Promise<void>;
@@ -51,6 +65,10 @@ export interface Storage {
     getFileTranslationCache(params: GetFileTranslationCache): Promise<TranslationCache[] | undefined>;
     getFileTranslationCacheByLanguage(params: GetFileTranslationCacheByLanguageParams): Promise<TranslationCache | undefined>;
     updateTranslationCache(params: UpdateTranslationCacheParams): Promise<void>;
+    saveUnsyncedFiles(params: UnsyncedFiles): Promise<void>;
+    getUnsyncedFiles(params: GetUnsyncedFiles): Promise<UnsyncedFiles | undefined>;
+    updateUnsyncedFiles(params: UnsyncedFiles): Promise<void>;
 }
 export declare function initialize(config: Config | UnauthorizedConfig): Promise<void>;
 export declare function getStorage(): Storage;
+export {};

package/out/storage/index.js

@@ -1,4 +1,28 @@
 "use strict";
+/* eslint-disable @typescript-eslint/camelcase */
+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) {
@@ -8,18 +32,44 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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.getStorage = exports.initialize = void 0;
+const types_1 = require("../types");
 const logger_1 = require("../util/logger");
 const mysql_1 = require("./mysql");
 const postgre_1 = require("./postgre");
 const sqlite_1 = require("./sqlite");
+const path_1 = __importStar(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+const util = __importStar(require("node:util"));
+const TABLES = {
+    crowdin_credentials: 'crowdin_credentials',
+    integration_credentials: 'integration_credentials',
+    sync_settings: 'sync_settings',
+    app_metadata: 'app_metadata',
+    files_snapshot: 'files_snapshot',
+    webhooks: 'webhooks',
+    user_errors: 'user_errors',
+    integration_settings: 'integration_settings',
+    job: 'job',
+    translation_file_cache: 'translation_file_cache',
+    unsynced_files: 'unsynced_files',
+};
 let storage;
 function initialize(config) {
     return __awaiter(this, void 0, void 0, function* () {
         if (config.postgreConfig) {
             (0, logger_1.log)('Using PostgreSQL database');
-            storage = new postgre_1.PostgreStorage(config.postgreConfig);
+            let dumpDirectory = null;
+            if (config.migrateToPostgreFromSQLite) {
+                dumpDirectory = config.dbFolder;
+                createDumpForMigration(config);
+            }
+            storage = new postgre_1.PostgreStorage(config.postgreConfig, dumpDirectory);
         }
         else if (config.mysqlConfig) {
             (0, logger_1.log)('Using MySQL database');
@@ -27,6 +77,10 @@ function initialize(config) {
         }
         else {
             (0, logger_1.log)('Using SQLite database');
+            if (config.migrateToPostgreFromSQLite === false) {
+                (0, logger_1.log)('Try to get SQLite file from backup');
+                getSqLiteFileFromBackup(config);
+            }
             storage = new sqlite_1.SQLiteStorage({ dbFolder: config.dbFolder });
         }
         yield storage.migrate();
@@ -40,3 +94,45 @@ function getStorage() {
     return storage;
 }
 exports.getStorage = getStorage;
+function createDumpForMigration(config) {
+    const sqliteFilePath = (0, path_1.join)(config.dbFolder, types_1.storageFiles.SQLITE);
+    const backupFilePath = (0, path_1.join)(config.dbFolder, types_1.storageFiles.SQLITE_BACKUP);
+    if (!fs_1.default.existsSync(sqliteFilePath)) {
+        (0, logger_1.log)('SQLite database not found, skipping migration dump creation');
+        return;
+    }
+    (0, logger_1.log)('Creating dump for migration from SQLite to PostgreSQL');
+    for (const tableName in TABLES) {
+        (0, logger_1.log)(`Creating dump for table ${tableName}`);
+        const dumpFileName = util.format(types_1.storageFiles.DUMP, tableName);
+        const dumpFilePath = path_1.default.join(config.dbFolder, dumpFileName);
+        (0, child_process_1.execSync)(`sqlite3 ${sqliteFilePath} ".output ${dumpFilePath}" ".dump ${tableName}" ".output stdout"`);
+        let modifiedContent = fs_1.default.readFileSync(dumpFilePath).toString();
+        // 1. Remove SQLite-specific PRAGMA statements
+        modifiedContent = modifiedContent.replace(/PRAGMA foreign_keys=OFF;\n/g, '');
+        // 2. Adjust transaction syntax for PostgreSQL
+        modifiedContent = modifiedContent.replace(/BEGIN TRANSACTION;\n/g, '');
+        modifiedContent = modifiedContent.replace(/COMMIT TRANSACTION;\n/g, '');
+        // 3. Ensure tables are only created if they don't already exist
+        modifiedContent = modifiedContent
+            .replace(/CREATE TABLE IF NOT EXISTS/g, 'CREATE TABLE') // Remove duplicate IF NOT EXISTS
+            .replace(/CREATE TABLE/g, 'CREATE TABLE IF NOT EXISTS'); // Add IF NOT EXISTS if missing
+        // 4. Add `ON CONFLICT DO NOTHING` to INSERT statements to handle conflicts gracefully
+        modifiedContent = modifiedContent.replace(/(INSERT INTO [^;]+)(;)/g, '$1 ON CONFLICT DO NOTHING;');
+        // 5. Convert SQLite-specific data types to PostgreSQL equivalents
+        modifiedContent = modifiedContent.replace(/integer not null primary key autoincrement/gi, 'serial primary key');
+        modifiedContent = modifiedContent.replace(/varchar not null primary key/gi, 'varchar primary key');
+        // 6. Remove SQLite-specific function replace()
+        modifiedContent = modifiedContent.replace(/replace\s*\('([^']+?)',\s*'?\\[rn]'?\s*,\s*char\s*\([0-9]+\)\s*\)/gi, "'$1'");
+        fs_1.default.writeFileSync(dumpFilePath, modifiedContent, { encoding: 'utf8', flag: 'w' });
+    }
+    fs_1.default.renameSync(sqliteFilePath, backupFilePath);
+}
+function getSqLiteFileFromBackup(config) {
+    const sqliteFilePath = (0, path_1.join)(config.dbFolder, types_1.storageFiles.SQLITE);
+    const backupFilePath = (0, path_1.join)(config.dbFolder, types_1.storageFiles.SQLITE_BACKUP);
+    if (fs_1.default.existsSync(backupFilePath) && !fs_1.default.existsSync(sqliteFilePath)) {
+        (0, logger_1.log)('Restoring SQLite database from backup');
+        fs_1.default.renameSync(backupFilePath, sqliteFilePath);
+    }
+}

package/out/storage/mysql.d.ts

@@ -1,6 +1,6 @@
 import { Storage } from '.';
 import { CrowdinCredentials } from '../types';
-import { CreateJobParams, GetActiveJobsParams, GetJobParams, GetFileTranslationCacheByLanguageParams, Job, TranslationCache, UpdateJobParams, UpdateTranslationCacheParams, GetFileTranslationCache } from '../modules/integration/util/types';
+import { CreateJobParams, GetActiveJobsParams, GetJobParams, GetFileTranslationCacheByLanguageParams, Job, TranslationCache, UpdateJobParams, UpdateTranslationCacheParams, GetFileTranslationCache, UnsyncedFiles, GetUnsyncedFiles } from '../modules/integration/util/types';
 import { IntegrationConfig, IntegrationCredentials, IntegrationFilesSnapshot, IntegrationSyncSettings, IntegrationWebhooks } from '../modules/integration/types';
 import { UserErrors } from './types';
 export interface MySQLStorageConfig {
@@ -17,6 +17,19 @@ export declare class MySQLStorage implements Storage {
     private _rej?;
     private dbPromise;
     private config;
+    tables: {
+        crowdin_credentials: string;
+        integration_credentials: string;
+        sync_settings: string;
+        app_metadata: string;
+        files_snapshot: string;
+        webhooks: string;
+        user_errors: string;
+        integration_settings: string;
+        job: string;
+        translation_file_cache: string;
+        unsynced_files: string;
+    };
     constructor(config: MySQLStorageConfig);
     executeQuery<T>(command: (connection: any) => Promise<T>): Promise<T>;
     migrate(): Promise<void>;
@@ -68,4 +81,7 @@ export declare class MySQLStorage implements Storage {
     getFileTranslationCache({ integrationId, crowdinId, fileId, }: GetFileTranslationCache): Promise<TranslationCache[] | undefined>;
     getFileTranslationCacheByLanguage({ integrationId, crowdinId, fileId, languageId, }: GetFileTranslationCacheByLanguageParams): Promise<TranslationCache | undefined>;
     updateTranslationCache({ integrationId, crowdinId, fileId, languageId, etag, }: UpdateTranslationCacheParams): Promise<void>;
+    saveUnsyncedFiles({ integrationId, crowdinId, files }: UnsyncedFiles): Promise<void>;
+    updateUnsyncedFiles({ integrationId, crowdinId, files }: UnsyncedFiles): Promise<void>;
+    getUnsyncedFiles({ integrationId, crowdinId }: GetUnsyncedFiles): Promise<UnsyncedFiles | undefined>;
 }

package/out/storage/mysql.js

@@ -2,6 +2,7 @@
 /* eslint-disable no-unused-expressions */
 /* eslint-disable @typescript-eslint/no-var-requires */
 /* eslint-disable @typescript-eslint/ban-ts-ignore */
+/* eslint-disable @typescript-eslint/camelcase */
 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) {
@@ -23,6 +24,100 @@ class MySQLStorage {
             this._res = res;
             this._rej = rej;
         });
+        this.tables = {
+            crowdin_credentials: `(
+            id              varchar(255) primary key,
+            app_secret      text,
+            domain          varchar(255),
+            user_id         varchar(255),
+            agent_id        varchar(255),
+            organization_id varchar(255),
+            base_url        varchar(255),
+            access_token    text not null,
+            refresh_token   text not null,
+            expire          varchar(255) not null,
+            type            varchar(255) not null
+        )`,
+            integration_credentials: `(
+            id              varchar(255) primary key,
+            credentials     text,
+            crowdin_id      varchar(255) not null,
+            managers        text
+        )`,
+            sync_settings: `(
+            id              int auto_increment primary key,
+            files           text,
+            integration_id  varchar(255) not null,
+            crowdin_id      varchar(255) not null,
+            type            varchar(255) not null,
+            provider        varchar(255) not null
+        )`,
+            app_metadata: `(
+            id              varchar(255) primary key,
+            data            text,
+            crowdin_id      text
+        )`,
+            files_snapshot: `(
+            id              int auto_increment primary key,
+            files           text,
+            integration_id  varchar(255) not null,
+            crowdin_id      varchar(255) not null,
+            provider        varchar(255) not null
+        )`,
+            webhooks: `(
+            id              int auto_increment primary key,
+            file_id         varchar(255) not null,
+            integration_id  varchar(255) not null,
+            crowdin_id      varchar(255) not null,
+            provider        varchar(255) not null
+        )`,
+            user_errors: `(
+            id              int auto_increment primary key,
+            action          varchar(255) not null,
+            message         varchar(255) not null,
+            data            text,
+            created_at      varchar(255) not null,
+            crowdin_id      varchar(255) not null,
+            integration_id  varchar(255)
+        )`,
+            integration_settings: `(
+            id              int auto_increment primary key,
+            integration_id  varchar(255) not null,
+            crowdin_id      varchar(255) not null,
+            config          text
+        )`,
+            job: `(
+            id              varchar(255) not null primary key,
+            integration_id  varchar(255) not null,
+            crowdin_id      varchar(255) not null,
+            type            varchar(255) not null,
+            payload         text,
+            title           text,
+            progress        int 0,
+            status          varchar(255)     '${types_1.JobStatus.CREATED}',
+            payload         text,
+            info            text,
+            data            text,
+            attempt         int 0,
+            created_at      varchar(255) not null,
+            updated_at      varchar(255),
+            finished_at     varchar(255)
+        )`,
+            translation_file_cache: `(
+            id              int auto_increment primary key,
+            integration_id  varchar(255) not null,
+            crowdin_id      varchar(255) not null,
+            file_id         int not null,
+            language_id     varchar(255) not null,
+            etag            varchar(255)
+        )`,
+            unsynced_files: `(
+            id             int auto_increment primary key,
+            integration_id varchar(255) not null,
+            crowdin_id     varchar(255) not null,
+            files          text
+        )`,
+        };
         this.config = config;
     }
     executeQuery(command) {
@@ -52,7 +147,7 @@ class MySQLStorage {
     migrate() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                yield this.executeQuery(this.addTables);
+                yield this.executeQuery((connection) => this.addTables(connection));
                 this._res && this._res();
             }
             catch (e) {
@@ -63,122 +158,9 @@ class MySQLStorage {
     }
     addTables(connection) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield connection.execute(`
-            create table if not exists crowdin_credentials
-            (
-                id              varchar(255) primary key,
-                app_secret      text,
-                domain          varchar(255),
-                user_id         varchar(255),
-                agent_id        varchar(255),
-                organization_id varchar(255),
-                base_url        varchar(255),
-                access_token    text not null,
-                refresh_token   text not null,
-                expire          varchar(255) not null,
-                type            varchar(255) not null
-            )
-            `);
-            yield connection.execute(`
-            create table if not exists integration_credentials
-            (
-                id              varchar(255) primary key,
-                credentials     text,
-                crowdin_id      varchar(255) not null,
-                managers        text
-            )
-            `);
-            yield connection.execute(`
-            create table if not exists sync_settings
-            (
-                id             int auto_increment primary key,
-                files          text,
-                integration_id varchar(255) not null,
-                crowdin_id     varchar(255) not null,
-                type           varchar(255) not null,
-                provider       varchar(255) not null
-            )
-            `);
-            yield connection.execute(`
-            create table if not exists app_metadata
-            (
-                id             varchar(255) primary key,
-                data           text,
-                crowdin_id     text
-            )
-            `);
-            yield connection.execute(`
-            create table if not exists files_snapshot
-            (
-                id             int auto_increment primary key,
-                files          text,
-                integration_id varchar(255) not null,
-                crowdin_id     varchar(255) not null,
-                provider       varchar(255) not null
-            )
-            `);
-            yield connection.execute(`
-            create table if not exists webhooks
-            (
-                id             int auto_increment primary key,
-                file_id        varchar(255) not null,
-                integration_id varchar(255) not null,
-                crowdin_id     varchar(255) not null,
-                provider       varchar(255) not null
-            )
-            `);
-            yield connection.execute(`
-            create table if not exists user_errors
-            (
-                id             int auto_increment primary key,
-                action         varchar(255) not null,
-                message        varchar(255) not null,
-                data           text,
-                created_at     varchar(255) not null,
-                crowdin_id     varchar(255) not null,
-                integration_id varchar(255)
-            )
-            `);
-            yield connection.execute(`
-            create table if not exists integration_settings
-            (
-                id             int auto_increment primary key,
-                integration_id varchar(255) not null,
-                crowdin_id     varchar(255) not null,
-                config         text
-            )
-            `);
-            yield connection.execute(`
-            create table if not exists job
-            (
-                id             varchar(255) not null primary key,
-                integration_id varchar(255) not null,
-                crowdin_id     varchar(255) not null,
-                type           varchar(255) not null,
-                payload        text,
-                title          text,
-                progress       int 0,
-                status         varchar(255)     '${types_1.JobStatus.CREATED}',
-                payload        text,
-                info           text,
-                data           text,
-                attempt        int 0,
-                created_at     varchar(255) not null,
-                updated_at     varchar(255),
-                finished_at    varchar(255)
-            )
-            `);
-            yield connection.execute(`
-            create table if not exists translation_file_cache
-            (
-                id             int auto_increment primary key,
-                integration_id varchar(255) not null,
-                crowdin_id     varchar(255) not null,
-                file_id        int not null,
-                language_id    varchar(255) not null,
-                etag           varchar(255)
-            )
-            `);
+            for (const [tableName, tableSchema] of Object.entries(this.tables)) {
+                yield connection.execute(`create table if not exists ${tableName} ${tableSchema}`);
+            }
         });
     }
     saveCrowdinCredentials(credentials) {
@@ -248,6 +230,7 @@ class MySQLStorage {
                 yield connection.execute('DELETE FROM integration_settings WHERE crowdin_id = ?', [id]);
                 yield connection.execute('DELETE FROM job WHERE crowdin_id = ?', [id]);
                 yield connection.execute('DELETE FROM translation_file_cache WHERE crowdin_id = ?', [id]);
+                yield connection.execute('DELETE FROM unsynced_files WHERE crowdin_id = ?', [id]);
             }));
         });
     }
@@ -300,6 +283,7 @@ class MySQLStorage {
                 yield connection.execute('DELETE FROM files_snapshot where integration_id = ?', [id]);
                 yield connection.execute('DELETE FROM webhooks where integration_id = ?', [id]);
                 yield connection.execute('DELETE FROM job where integration_id = ?', [id]);
+                yield connection.execute('DELETE FROM unsynced_files where integration_id = ?', [id]);
             }));
         });
     }
@@ -313,6 +297,7 @@ class MySQLStorage {
                 yield connection.execute('DELETE FROM webhooks where crowdin_id = ?', [crowdinId]);
                 yield connection.execute('DELETE FROM user_errors where crowdin_id = ?', [crowdinId]);
                 yield connection.execute('DELETE FROM job where crowdin_id = ?', [crowdinId]);
+                yield connection.execute('DELETE FROM unsynced_files where crowdin_id = ?', [crowdinId]);
             }));
         });
     }
@@ -675,5 +660,37 @@ class MySQLStorage {
                 `, [etag, integrationId, crowdinId, fileId, languageId]));
         });
     }
+    saveUnsyncedFiles({ integrationId, crowdinId, files }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.dbPromise;
+            yield this.executeQuery((connection) => connection.execute(`
+                INSERT INTO unsynced_files(integration_id, crowdin_id, files)
+                VALUES (?, ?, ?,)
+                `, [integrationId, crowdinId, files]));
+        });
+    }
+    updateUnsyncedFiles({ integrationId, crowdinId, files }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.dbPromise;
+            yield this.executeQuery((connection) => connection.execute(`
+                UPDATE unsynced_files
+                SET files = ?
+                WHERE integration_id = ? AND crowdin_id = ?
+                `, [files, integrationId, crowdinId]));
+        });
+    }
+    getUnsyncedFiles({ integrationId, crowdinId }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.dbPromise;
+            return this.executeQuery((connection) => __awaiter(this, void 0, void 0, function* () {
+                const [rows] = yield connection.execute(`
+                SELECT fileIds
+                FROM unsynced_files
+                WHERE integration_id = ? AND crowdin_id = ?
+                `, [integrationId, crowdinId]);
+                return (rows || [])[0];
+            }));
+        });
+    }
 }
 exports.MySQLStorage = MySQLStorage;

package/out/storage/postgre.d.ts

@@ -2,7 +2,7 @@ import { Client } from 'pg';
 import { Storage } from '.';
 import { CrowdinCredentials } from '../types';
 import { IntegrationConfig, IntegrationCredentials, IntegrationFilesSnapshot, IntegrationSyncSettings, IntegrationWebhooks } from '../modules/integration/types';
-import { CreateJobParams, GetActiveJobsParams, GetJobParams, GetFileTranslationCacheByLanguageParams, Job, TranslationCache, UpdateJobParams, UpdateTranslationCacheParams, GetFileTranslationCache } from '../modules/integration/util/types';
+import { CreateJobParams, GetActiveJobsParams, GetJobParams, GetFileTranslationCacheByLanguageParams, Job, TranslationCache, UpdateJobParams, UpdateTranslationCacheParams, GetFileTranslationCache, UnsyncedFiles, GetUnsyncedFiles } from '../modules/integration/util/types';
 import { UserErrors } from './types';
 export interface PostgreStorageConfig {
     host?: string;
@@ -18,10 +18,24 @@ export interface PostgreStorageConfig {
 }
 export declare class PostgreStorage implements Storage {
     private config;
+    private directoryPath;
     private _res?;
     private _rej?;
     private dbPromise;
-    constructor(config: PostgreStorageConfig);
+    tables: {
+        crowdin_credentials: string;
+        integration_credentials: string;
+        sync_settings: string;
+        app_metadata: string;
+        files_snapshot: string;
+        webhooks: string;
+        user_errors: string;
+        integration_settings: string;
+        job: string;
+        translation_file_cache: string;
+        unsynced_files: string;
+    };
+    constructor(config: PostgreStorageConfig, directoryPath: string | null);
     executeQuery<T>(command: (client: Client) => Promise<T>): Promise<T>;
     migrate(): Promise<void>;
     alterTables(client: Client): Promise<void>;
@@ -75,4 +89,8 @@ export declare class PostgreStorage implements Storage {
     getFileTranslationCache({ integrationId, crowdinId, fileId, }: GetFileTranslationCache): Promise<TranslationCache[] | undefined>;
     getFileTranslationCacheByLanguage({ integrationId, crowdinId, fileId, languageId, }: GetFileTranslationCacheByLanguageParams): Promise<TranslationCache | undefined>;
     updateTranslationCache({ integrationId, crowdinId, fileId, languageId, etag, }: UpdateTranslationCacheParams): Promise<void>;
+    private migrateFromSqlite;
+    saveUnsyncedFiles({ integrationId, crowdinId, files }: UnsyncedFiles): Promise<void>;
+    updateUnsyncedFiles({ integrationId, crowdinId, files }: UnsyncedFiles): Promise<void>;
+    getUnsyncedFiles({ integrationId, crowdinId }: GetUnsyncedFiles): Promise<UnsyncedFiles | undefined>;
 }