@crowdin/app-project-module 1.15.1 → 2.0.0

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

@@ -0,0 +1,7 @@
+import type { D1Database } from '@cloudflare/workers-types';
+import { D1_DB, Migration } from './types';
+export declare function initD1({ database, additionalSchema, }: {
+    database: D1Database;
+    additionalSchema?: Record<string, unknown>;
+}): D1_DB;
+export declare const migrateD1: (db: D1_DB, additionalMigrations?: Migration[]) => Promise<void>;

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

@@ -0,0 +1,48 @@
+"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 });
+exports.migrateD1 = void 0;
+exports.initD1 = initD1;
+const d1_1 = require("drizzle-orm/d1");
+const init_1 = require("./migrations/init");
+const types_1 = require("./types");
+function initD1({ database, additionalSchema, }) {
+    return (0, d1_1.drizzle)(database, { schema: Object.assign(Object.assign({}, types_1.D1_SCHEMA), additionalSchema) });
+}
+const migrations = [init_1.INIT_MIGRATION];
+const migrationHistoryTableName = '__drizzle_migrations';
+const migrateD1 = (db_1, ...args_1) => __awaiter(void 0, [db_1, ...args_1], void 0, function* (db, additionalMigrations = []) {
+    const allMigrations = [...migrations, ...additionalMigrations];
+    const uniqueMigrationNames = new Set(allMigrations.map((migration) => migration.name));
+    if (uniqueMigrationNames.size !== allMigrations.length) {
+        throw new Error('Migration names must be unique');
+    }
+    // Ensure migration history table exists
+    yield db.$client
+        .prepare(`CREATE TABLE IF NOT EXISTS ${migrationHistoryTableName} (
+            name           varchar not null primary key,
+            created_at     varchar not null
+        )`)
+        .run();
+    // Get list of applied migrations
+    const appliedMigrationsResult = yield db.$client.prepare(`SELECT name FROM ${migrationHistoryTableName}`).all();
+    const appliedMigrations = new Set(appliedMigrationsResult.results.map((row) => row.name));
+    // Filter out migrations that have already been applied
+    const pendingMigrations = allMigrations.filter((migration) => !appliedMigrations.has(migration.name));
+    for (const migration of pendingMigrations) {
+        yield migration.run(db);
+        yield db.$client
+            .prepare(`INSERT INTO ${migrationHistoryTableName} (name, created_at) VALUES (?, ?)`)
+            .bind(migration.name, Date.now().toString())
+            .run();
+    }
+});
+exports.migrateD1 = migrateD1;

package/out/storage/drizzle/d1/migrations/init.d.ts

@@ -0,0 +1,2 @@
+import { Migration } from '../types';
+export declare const INIT_MIGRATION: Migration;

package/out/storage/drizzle/d1/migrations/init.js

@@ -0,0 +1,122 @@
+"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 });
+exports.INIT_MIGRATION = void 0;
+const types_1 = require("../../../../modules/integration/util/types");
+exports.INIT_MIGRATION = {
+    name: 'init',
+    run: (db) => __awaiter(void 0, void 0, void 0, function* () {
+        const statements = [];
+        statements.push(db.$client.prepare(`CREATE TABLE IF NOT EXISTS crowdin_credentials (
+                    id              varchar not null primary key,
+                    app_secret      varchar     null,
+                    domain          varchar     null,
+                    user_id         varchar     null,
+                    agent_id        varchar     null,
+                    organization_id varchar     null,
+                    base_url        varchar     null,
+                    access_token    varchar not null,
+                    refresh_token   varchar not null,
+                    expire          varchar not null,
+                    type            varchar not null
+                )`));
+        statements.push(db.$client.prepare(`CREATE TABLE IF NOT EXISTS integration_credentials (
+                    id              varchar not null primary key,
+                    credentials     varchar not null,
+                    crowdin_id      varchar not null,
+                    managers        varchar     null
+                )`));
+        statements.push(db.$client.prepare(`CREATE TABLE IF NOT EXISTS sync_settings (
+                    id             integer not null primary key autoincrement,
+                    files          varchar     null,
+                    integration_id varchar not null,
+                    crowdin_id     varchar not null,
+                    type           varchar not null,
+                    provider       varchar not null
+                )`));
+        statements.push(db.$client.prepare(`CREATE TABLE IF NOT EXISTS app_metadata (
+                    id             varchar not null primary key,
+                    data           varchar     null,
+                    crowdin_id     varchar     null
+                )`));
+        statements.push(db.$client.prepare(`CREATE TABLE IF NOT EXISTS files_snapshot (
+                    id             integer not null primary key autoincrement,
+                    integration_id varchar not null,
+                    crowdin_id     varchar not null,
+                    files          varchar     null,
+                    provider       varchar not null
+                )`));
+        statements.push(db.$client.prepare(`CREATE TABLE IF NOT EXISTS webhooks (
+                    id             integer not null primary key autoincrement,
+                    file_id        varchar not null,
+                    integration_id varchar not null,
+                    crowdin_id     varchar not null,
+                    provider       varchar not null
+                )`));
+        statements.push(db.$client.prepare(`CREATE TABLE IF NOT EXISTS user_errors (
+                    id             integer not null primary key autoincrement,
+                    action         varchar not null,
+                    message        varchar not null,
+                    data           varchar     null,
+                    created_at     varchar not null,
+                    crowdin_id     varchar not null,
+                    integration_id varchar     null
+                )`));
+        statements.push(db.$client.prepare(`CREATE TABLE IF NOT EXISTS integration_settings (
+                    id             integer not null primary key autoincrement,
+                    integration_id varchar not null,
+                    crowdin_id     varchar not null,
+                    config         varchar     null
+                )`));
+        statements.push(db.$client.prepare(`CREATE TABLE IF NOT EXISTS job (
+                    id             varchar not null primary key,
+                    integration_id varchar not null,
+                    crowdin_id     varchar not null,
+                    type           varchar not null,
+                    title          varchar     null,
+                    progress       integer DEFAULT 0,
+                    status         varchar DEFAULT '${types_1.JobStatus.CREATED}',
+                    payload        varchar     null,
+                    info           varchar     null,
+                    data           varchar     null,
+                    attempt        varchar DEFAULT 0,
+                    errors         varchar     null,
+                    processed_entities varchar     null,
+                    initiated_by   varchar     null,
+                    created_at     varchar not null,
+                    updated_at     varchar     null,
+                    finished_at    varchar     null
+                )`));
+        statements.push(db.$client.prepare(`CREATE TABLE IF NOT EXISTS translation_file_cache (
+                    id             integer not null primary key autoincrement,
+                    integration_id varchar not null,
+                    crowdin_id     varchar not null,
+                    file_id        integer not null,
+                    language_id    varchar not null,
+                    etag           varchar
+                )`));
+        statements.push(db.$client.prepare(`CREATE TABLE IF NOT EXISTS unsynced_files (
+                    id             integer not null primary key autoincrement,
+                    integration_id varchar not null,
+                    crowdin_id     varchar not null,
+                    files          varchar     null
+                )`));
+        statements.push(db.$client.prepare(`CREATE TABLE IF NOT EXISTS synced_data (
+                    id             integer not null primary key autoincrement,
+                    files          varchar     null,
+                    integration_id varchar not null,
+                    crowdin_id     varchar not null,
+                    type           varchar not null,
+                    updated_at     varchar     null
+                )`));
+        yield db.$client.batch(statements);
+    }),
+};

package/out/storage/drizzle/d1/types.d.ts

@@ -0,0 +1,13 @@
+import { D1Database } from '@cloudflare/workers-types';
+import * as schema from '../sqlite/schema';
+export declare const D1_SCHEMA: typeof schema;
+export type D1StorageConfig = {
+    database: D1Database;
+};
+export type Migration = {
+    name: string;
+    run: (db: D1_DB) => Promise<void> | void;
+};
+export type D1_DB = import('drizzle-orm/d1').DrizzleD1Database<typeof schema> & {
+    $client: D1Database;
+};

package/out/storage/drizzle/d1/types.js

@@ -0,0 +1,38 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.D1_SCHEMA = void 0;
+const schema = __importStar(require("../sqlite/schema"));
+exports.D1_SCHEMA = schema;

package/out/storage/{sqlite.d.ts → drizzle/index.d.ts}

@@ -1,40 +1,29 @@
-import { Storage } from '.';
-import { IntegrationConfig, IntegrationCredentials, IntegrationFilesSnapshot, IntegrationSyncSettings, IntegrationWebhooks, Provider } from '../modules/integration/types';
-import { CreateJobParams, GetActiveJobsParams, GetAllJobsParams, GetFileTranslationCache, GetFileTranslationCacheByLanguageParams, GetJobParams, GetUnsyncedFiles, IntegrationSyncedData, Job, TranslationCache, UnsyncedFiles, UpdateJobParams, UpdateTranslationCacheParams } from '../modules/integration/util/types';
-import { CrowdinCredentials } from '../types';
-import { UserErrors } from './types';
-export interface SQLiteStorageConfig {
-    dbFolder: string;
-}
-export declare class SQLiteStorage implements Storage {
-    private config;
-    private db;
-    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;
-        synced_data: string;
-    };
-    constructor(config: SQLiteStorageConfig);
-    private addColumn;
-    private updateTables;
-    migrate(skipOnboarding?: boolean): Promise<void>;
+import { IntegrationConfig, IntegrationCredentials, IntegrationFilesSnapshot, IntegrationSyncSettings, IntegrationWebhooks, Provider } from '../../modules/integration/types';
+import { CreateJobParams, GetActiveJobsParams, GetAllJobsParams, GetFileTranslationCache, GetFileTranslationCacheByLanguageParams, GetJobParams, GetUnsyncedFiles, IntegrationSyncedData, Job, TranslationCache, UnsyncedFiles, UpdateJobParams, UpdateTranslationCacheParams } from '../../modules/integration/util/types';
+import { Config, CrowdinCredentials, UnauthorizedConfig } from '../../types';
+import { DB_TYPE, Storage, UserErrors } from '../types';
+import { POSTGRESQL_DB, POSTGRESQL_SCHEMA } from './postgresql';
+export declare class DrizzleStorage implements Storage {
+    readonly db: POSTGRESQL_DB;
+    protected readonly schema: typeof POSTGRESQL_SCHEMA;
+    protected readonly type: DB_TYPE;
+    protected readonly migrationPromise: Promise<void>;
+    protected migrated: boolean;
+    protected readonly config: Config | UnauthorizedConfig;
+    constructor({ config, type, delayedMigration, }: {
+        config: Config | UnauthorizedConfig;
+        type: DB_TYPE;
+        delayedMigration?: boolean;
+    });
+    migrateDelayed(): Promise<void>;
     saveCrowdinCredentials(credentials: CrowdinCredentials): Promise<void>;
     updateCrowdinCredentials(credentials: CrowdinCredentials): Promise<void>;
     getCrowdinCredentials(id: string): Promise<CrowdinCredentials | undefined>;
     getAllCrowdinCredentials(): Promise<CrowdinCredentials[]>;
     deleteCrowdinCredentials(id: string): Promise<void>;
-    saveIntegrationCredentials(id: string, credentials: any, crowdinId: string): Promise<void>;
-    updateIntegrationCredentials(id: string, credentials: any): Promise<void>;
-    updateIntegrationManagers(id: string, managers: any): Promise<void>;
+    saveIntegrationCredentials(id: string, credentials: string, crowdinId: string): Promise<void>;
+    updateIntegrationCredentials(id: string, credentials: string): Promise<void>;
+    updateIntegrationManagers(id: string, managers: string): Promise<void>;
     getIntegrationCredentials(id: string): Promise<IntegrationCredentials | undefined>;
     getAllIntegrationCredentials(crowdinId: string): Promise<IntegrationCredentials[]>;
     deleteIntegrationCredentials(id: string): Promise<void>;
@@ -46,31 +35,31 @@ export declare class SQLiteStorage implements Storage {
     deleteMetadata(id: string): Promise<void>;
     getSyncSettingsByProvider(integrationId: string, provider: Provider): Promise<IntegrationSyncSettings | undefined>;
     getSyncSettingsBySchedule(type: string, schedule: string): Promise<IntegrationSyncSettings[]>;
-    saveSyncSettings(files: any, integrationId: string, crowdinId: string, type: string, provider: Provider): Promise<void>;
-    updateSyncSettings(files: any, integrationId: string, crowdinId: string, type: string, provider: Provider): Promise<void>;
+    saveSyncSettings(files: string, integrationId: string, crowdinId: string, type: string, provider: Provider): Promise<void>;
+    updateSyncSettings(files: string, integrationId: string, crowdinId: string, type: string, provider: Provider): Promise<void>;
     getSyncSettings(integrationId: string, crowdinId: string, type: string, provider: Provider): Promise<IntegrationSyncSettings | undefined>;
-    saveFilesSnapshot(files: any, integrationId: string, crowdinId: string, provider: Provider): Promise<void>;
-    updateFilesSnapshot(files: any, integrationId: string, crowdinId: string, provider: Provider): Promise<void>;
+    saveFilesSnapshot(files: string, integrationId: string, crowdinId: string, provider: Provider): Promise<void>;
+    updateFilesSnapshot(files: string, integrationId: string, crowdinId: string, provider: Provider): Promise<void>;
     getFilesSnapshot(integrationId: string, crowdinId: string, provider: Provider): Promise<IntegrationFilesSnapshot | undefined>;
     getAllWebhooks(integrationId: string, crowdinId: string, provider: Provider): Promise<IntegrationWebhooks[] | undefined>;
     getWebhooks(fileId: string, integrationId: string, crowdinId: string, provider: Provider): Promise<IntegrationWebhooks | undefined>;
     saveWebhooks(fileId: string, integrationId: string, crowdinId: string, provider: Provider): Promise<void>;
-    deleteWebhooks(fileIds: any[], integrationId: string, crowdinId: string, provider: Provider): Promise<void>;
+    deleteWebhooks(fileIds: string[], integrationId: string, crowdinId: string, provider: Provider): Promise<void>;
     getAllUserErrors(crowdinId: string, integrationId?: string): Promise<UserErrors[] | undefined>;
-    saveUserError(action: string, message: string, data: any, createdAt: string, crowdinId: string, integrationId?: string): Promise<void>;
-    deleteUserErrors(date: string, crowdinId: string, integrationId?: string): Promise<void>;
-    deleteAllUsersErrorsOlderThan(date: string): Promise<void>;
-    saveIntegrationConfig(integrationId: string, crowdinId: string, config: any): Promise<void>;
+    saveUserError(action: string, message: string, data: string, createdAt: string, crowdinId: string, integrationId?: string): Promise<void>;
+    deleteUserErrors(createdAt: string, crowdinId: string, integrationId?: string): Promise<void>;
+    deleteAllUsersErrorsOlderThan(createdAt: string): Promise<void>;
+    saveIntegrationConfig(integrationId: string, crowdinId: string, config: string): Promise<void>;
     getAllIntegrationConfigs(crowdinId: string): Promise<IntegrationConfig[]>;
     getIntegrationConfig(integrationId: string): Promise<IntegrationConfig | undefined>;
-    updateIntegrationConfig(integrationId: string, config: any): Promise<void>;
+    updateIntegrationConfig(integrationId: string, config: string): Promise<void>;
     createJob(params: CreateJobParams): Promise<string>;
-    updateJob({ id, progress, status, info, data, attempt, errors, processedEntities, }: UpdateJobParams): Promise<void>;
+    updateJob(params: UpdateJobParams): Promise<void>;
     getJob(params: GetJobParams): Promise<Job | undefined>;
     getActiveJobs(params: GetActiveJobsParams): Promise<Job[] | undefined>;
     deleteFinishedJobs(): Promise<void>;
     getAllInProgressJobs(): Promise<Job[] | undefined>;
-    getAllJobs({ integrationId, crowdinId, limit, offset }: GetAllJobsParams): Promise<Job[] | undefined>;
+    getAllJobs(params: GetAllJobsParams): Promise<Job[] | undefined>;
     saveTranslationCache(params: TranslationCache): Promise<void>;
     getFileTranslationCache(params: GetFileTranslationCache): Promise<TranslationCache[] | undefined>;
     getFileTranslationCacheByLanguage(params: GetFileTranslationCacheByLanguageParams): Promise<TranslationCache | undefined>;
@@ -78,19 +67,9 @@ export declare class SQLiteStorage implements Storage {
     saveUnsyncedFiles(params: UnsyncedFiles): Promise<void>;
     getUnsyncedFiles(params: GetUnsyncedFiles): Promise<UnsyncedFiles | undefined>;
     updateUnsyncedFiles(params: UnsyncedFiles): Promise<void>;
-    registerCustomTable(tableName: string, schema: Record<string, string>): Promise<void>;
-    insertRecord(tableName: string, data: Record<string, any>): Promise<void>;
-    selectRecords(tableName: string, options?: {
-        columns?: string[];
-        whereClause?: string;
-        orderBy?: string;
-        limit?: number;
-        offset?: number;
-        distinct?: boolean;
-    }, params?: any[]): Promise<any[]>;
-    updateRecord(tableName: string, data: Record<string, any>, whereClause: string, params?: any[]): Promise<void>;
-    deleteRecord(tableName: string, whereClause: string, params?: any[]): Promise<void>;
-    saveSyncedData(files: any, integrationId: string, crowdinId: string, type: string): Promise<void>;
-    updateSyncedData(files: any, integrationId: string, crowdinId: string, type: string): Promise<void>;
+    saveSyncedData(files: string, integrationId: string, crowdinId: string, type: string): Promise<void>;
+    updateSyncedData(files: string, integrationId: string, crowdinId: string, type: string): Promise<void>;
     getSyncedData(integrationId: string, crowdinId: string, type: string): Promise<IntegrationSyncedData | undefined>;
+    private toString;
+    private toNumber;
 }