@crowdin/app-project-module 1.16.0 → 2.0.0

package/out/storage/drizzle/postgresql/config.d.ts

@@ -0,0 +1,5 @@
+/**
+ * npm run drizzle:postgresql:generate -- --name "<migration_name>"
+ */
+declare const _default: import("drizzle-kit").Config;
+export default _default;

package/out/storage/drizzle/postgresql/config.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const drizzle_kit_1 = require("drizzle-kit");
+/**
+ * npm run drizzle:postgresql:generate -- --name "<migration_name>"
+ */
+exports.default = (0, drizzle_kit_1.defineConfig)({
+    schema: 'src/storage/drizzle/postgresql/schema.ts',
+    out: 'src/storage/drizzle/postgresql/migrations',
+    dialect: 'postgresql',
+});

package/out/storage/drizzle/postgresql/index.d.ts

@@ -0,0 +1,14 @@
+import { Pool, PoolConfig } from 'pg';
+import * as schema from './schema';
+export type PostgreStorageConfig = PoolConfig;
+export type POSTGRESQL_DB = import('drizzle-orm/node-postgres').NodePgDatabase<typeof schema> & {
+    $client: Pool;
+};
+export declare function initPostgreSQL(config: PostgreStorageConfig, additionalSchema?: Record<string, unknown>): POSTGRESQL_DB;
+export declare const POSTGRESQL_SCHEMA: typeof schema;
+export declare const migratePostgreSQL: ({ db, name, directoryPath, additionalMigrationFolder, }: {
+    db: POSTGRESQL_DB;
+    name: string;
+    directoryPath?: string;
+    additionalMigrationFolder?: string;
+}) => Promise<void>;

package/out/storage/drizzle/postgresql/index.js

@@ -0,0 +1,144 @@
+"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.migratePostgreSQL = exports.POSTGRESQL_SCHEMA = void 0;
+exports.initPostgreSQL = initPostgreSQL;
+const node_postgres_1 = require("drizzle-orm/node-postgres");
+const migrator_1 = require("drizzle-orm/node-postgres/migrator");
+const pg_1 = require("pg");
+const crypto_1 = require("crypto");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = require("path");
+const types_1 = require("../../../types");
+const schema = __importStar(require("./schema"));
+function initPostgreSQL(config, additionalSchema = {}) {
+    const client = new pg_1.Pool(config);
+    return (0, node_postgres_1.drizzle)(client, { schema: Object.assign(Object.assign({}, schema), additionalSchema) });
+}
+exports.POSTGRESQL_SCHEMA = schema;
+const migratePostgreSQL = (_a) => __awaiter(void 0, [_a], void 0, function* ({ db, name, directoryPath, additionalMigrationFolder, }) {
+    if (directoryPath && hasDumpFiles(directoryPath)) {
+        yield migrateFromSqlite(db, directoryPath);
+    }
+    // Use advisory lock to prevent concurrent migrations
+    const lockId = generateLockId(name);
+    yield db.$client.query('SELECT pg_advisory_lock($1)', [lockId]);
+    try {
+        yield (0, migrator_1.migrate)(db, { migrationsFolder: (0, path_1.join)(__dirname, 'migrations') });
+        if (additionalMigrationFolder) {
+            yield (0, migrator_1.migrate)(db, { migrationsFolder: additionalMigrationFolder });
+        }
+    }
+    finally {
+        yield db.$client.query('SELECT pg_advisory_unlock($1)', [lockId]);
+    }
+});
+exports.migratePostgreSQL = migratePostgreSQL;
+function hasDumpFiles(directoryPath) {
+    if (!fs_1.default.existsSync(directoryPath)) {
+        return false;
+    }
+    const [name, extension] = types_1.storageFiles.DUMP.split('%s');
+    const files = fs_1.default.readdirSync(directoryPath).filter((file) => file.startsWith(name) && file.endsWith(extension));
+    return files.length > 0;
+}
+function migrateFromSqlite(db, directoryPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [name, extension] = types_1.storageFiles.DUMP.split('%s');
+        const files = fs_1.default
+            .readdirSync(directoryPath)
+            .filter((file) => file.startsWith(name) && file.endsWith(extension))
+            .sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
+        for (const file of files) {
+            const filePath = (0, path_1.join)(directoryPath, file);
+            const sql = fs_1.default.readFileSync(filePath, 'utf8');
+            try {
+                yield db.$client.query(sql);
+                fs_1.default.unlinkSync(filePath);
+            }
+            catch (e) {
+                console.error('Error while executing', file);
+                console.error(e);
+                fs_1.default.renameSync(filePath, filePath.replace('dump_table_', 'error_dump_table_'));
+            }
+        }
+        // Reset sequences for tables with serial primary keys
+        yield resetSequences(db);
+    });
+}
+function resetSequences(db) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (const table of Object.keys(schema)) {
+            const tableName = schema[table]._.name;
+            const query = `
+            SELECT a.attname
+            FROM pg_index i
+            JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
+            WHERE i.indrelid = '${tableName}'::regclass
+            AND i.indisprimary;
+        `;
+            const primaryKeyResult = yield db.$client.query(query);
+            if (primaryKeyResult.rows.length === 0) {
+                continue;
+            }
+            const primaryKey = primaryKeyResult.rows[0].attname;
+            const maxIdResult = yield db.$client.query(`SELECT MAX(${primaryKey}) FROM ${tableName}`);
+            const maxId = maxIdResult.rows[0].max;
+            // Skip if maxId is not a valid integer
+            if (maxId === null || isNaN(Number(maxId))) {
+                continue;
+            }
+            yield db.$client.query(`SELECT setval('${tableName}_${primaryKey}_seq', ${Number(maxId)}, true)`);
+        }
+    });
+}
+function generateLockId(str) {
+    // Create MD5 hash of the string
+    const hash = (0, crypto_1.createHash)('md5').update(str).digest('hex');
+    // Take first 8 hex characters and convert to integer
+    return parseInt(hash.substring(0, 8), 16);
+}

package/out/storage/drizzle/postgresql/migrations/0000_init.sql

@@ -0,0 +1,113 @@
+CREATE TABLE IF NOT EXISTS "app_metadata" (
+	"id" text PRIMARY KEY NOT NULL,
+	"data" text,
+	"crowdin_id" text
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "crowdin_credentials" (
+	"id" text PRIMARY KEY NOT NULL,
+	"app_secret" text,
+	"domain" text,
+	"user_id" text,
+	"agent_id" text,
+	"organization_id" text,
+	"base_url" text,
+	"access_token" text NOT NULL,
+	"refresh_token" text NOT NULL,
+	"expire" text NOT NULL,
+	"type" text NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "files_snapshot" (
+	"id" serial PRIMARY KEY NOT NULL,
+	"integration_id" text NOT NULL,
+	"crowdin_id" text NOT NULL,
+	"files" text,
+	"provider" text NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "integration_credentials" (
+	"id" text PRIMARY KEY NOT NULL,
+	"credentials" text NOT NULL,
+	"crowdin_id" text NOT NULL,
+	"managers" text
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "integration_settings" (
+	"id" serial PRIMARY KEY NOT NULL,
+	"integration_id" text NOT NULL,
+	"crowdin_id" text NOT NULL,
+	"config" text
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "job" (
+	"id" text PRIMARY KEY NOT NULL,
+	"integration_id" text NOT NULL,
+	"crowdin_id" text NOT NULL,
+	"type" text NOT NULL,
+	"title" text,
+	"progress" integer DEFAULT 0 NOT NULL,
+	"status" text DEFAULT 'CREATED' NOT NULL,
+	"payload" text,
+	"info" text,
+	"data" text,
+	"attempt" integer DEFAULT 0 NOT NULL,
+	"errors" text,
+	"processed_entities" text,
+	"initiated_by" text,
+	"created_at" text NOT NULL,
+	"updated_at" text,
+	"finished_at" text
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "sync_settings" (
+	"id" serial PRIMARY KEY NOT NULL,
+	"files" text,
+	"integration_id" text NOT NULL,
+	"crowdin_id" text NOT NULL,
+	"type" text NOT NULL,
+	"provider" text NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "synced_data" (
+	"id" serial PRIMARY KEY NOT NULL,
+	"files" text,
+	"integration_id" text NOT NULL,
+	"crowdin_id" text NOT NULL,
+	"type" text NOT NULL,
+	"updated_at" text
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "translation_file_cache" (
+	"id" serial PRIMARY KEY NOT NULL,
+	"integration_id" text NOT NULL,
+	"crowdin_id" text NOT NULL,
+	"file_id" integer NOT NULL,
+	"language_id" text NOT NULL,
+	"etag" text
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "unsynced_files" (
+	"id" serial PRIMARY KEY NOT NULL,
+	"integration_id" text NOT NULL,
+	"crowdin_id" text NOT NULL,
+	"files" text
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "user_errors" (
+	"id" serial PRIMARY KEY NOT NULL,
+	"action" text NOT NULL,
+	"message" text NOT NULL,
+	"data" text,
+	"created_at" text NOT NULL,
+	"crowdin_id" text NOT NULL,
+	"integration_id" text
+);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "webhooks" (
+	"id" serial PRIMARY KEY NOT NULL,
+	"file_id" text NOT NULL,
+	"integration_id" text NOT NULL,
+	"crowdin_id" text NOT NULL,
+	"provider" text NOT NULL
+);

package/out/storage/drizzle/postgresql/migrations/0001_init_indexes.sql

@@ -0,0 +1,28 @@
+CREATE INDEX IF NOT EXISTS idx_crowdin ON "integration_credentials" ("crowdin_id");
+
+CREATE INDEX IF NOT EXISTS idx_integration_provider ON "sync_settings" ("integration_id","provider");
+CREATE INDEX IF NOT EXISTS idx_crowdin ON "sync_settings" ("crowdin_id");
+CREATE INDEX IF NOT EXISTS idx_type ON "sync_settings" ("type");
+
+CREATE INDEX IF NOT EXISTS idx_integration ON "files_snapshot" ("integration_id");
+CREATE INDEX IF NOT EXISTS idx_crowdin ON "files_snapshot" ("crowdin_id");
+
+CREATE INDEX IF NOT EXISTS idx_integration_crowdin ON "webhooks" ("integration_id","crowdin_id");
+CREATE INDEX IF NOT EXISTS idx_file_provider ON "webhooks" ("file_id","provider");
+
+CREATE INDEX IF NOT EXISTS idx_integration_crowdin ON "user_errors" ("integration_id","crowdin_id");
+CREATE INDEX IF NOT EXISTS idx_crowdin ON "user_errors" ("crowdin_id");
+CREATE INDEX IF NOT EXISTS idx_created_at ON "user_errors" ("created_at");
+
+CREATE INDEX IF NOT EXISTS idx_integration ON "integration_settings" ("integration_id");
+CREATE INDEX IF NOT EXISTS idx_crowdin ON "integration_settings" ("crowdin_id");
+
+CREATE INDEX IF NOT EXISTS idx_integration_crowdin ON "job" ("integration_id","crowdin_id") WHERE "finished_at" IS NULL;
+CREATE INDEX IF NOT EXISTS idx_finished_at ON "job" ("finished_at") WHERE "finished_at" IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_status ON "job" ("status") WHERE "finished_at" IS NULL;
+
+CREATE INDEX IF NOT EXISTS idx_integration_crowdin_file_language ON "translation_file_cache" ("integration_id","crowdin_id","file_id","language_id");
+CREATE INDEX IF NOT EXISTS idx_crowdin ON "translation_file_cache" ("crowdin_id");
+
+CREATE INDEX IF NOT EXISTS idx_integration_crowdin ON "unsynced_files" ("integration_id","crowdin_id");
+CREATE INDEX IF NOT EXISTS idx_crowdin ON "unsynced_files" ("crowdin_id");