@crowdin/app-project-module 2.10.0 → 2.11.1

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

@@ -28,6 +28,7 @@ export declare class DrizzleStorage implements Storage {
     updateIntegrationManagers(id: string, managers: string): Promise<void>;
     getIntegrationCredentials(id: string): Promise<IntegrationCredentials | undefined>;
     getAllIntegrationCredentials(crowdinId: string): Promise<IntegrationCredentials[]>;
+    getIntegrationCredentialsByProject(organization: string, projectId: number): Promise<IntegrationCredentials[]>;
     deleteIntegrationCredentials(id: string): Promise<void>;
     deleteAllIntegrationCredentials(crowdinId: string): Promise<void>;
     saveMetadata(id: string, metadata: any, crowdinId: string): Promise<void>;

package/out/storage/drizzle/index.js

@@ -13,6 +13,7 @@ exports.DrizzleStorage = void 0;
 const crypto_1 = require("crypto");
 const drizzle_orm_1 = require("drizzle-orm");
 const types_1 = require("../../modules/integration/util/types");
+const token_1 = require("../../util/app-functions/token");
 const d1_1 = require("./d1");
 const types_2 = require("./d1/types");
 const postgresql_1 = require("./postgresql");
@@ -274,6 +275,37 @@ class DrizzleStorage {
             }));
         });
     }
+    getIntegrationCredentialsByProject(organization, projectId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.migrationPromise;
+            // id format: "{organization}__{projectId}__{userId}"
+            // parseCrowdinId is the authoritative parser; used as a post-filter in both paths.
+            const filterByProjectId = (item) => {
+                const { organization: itemOrganization, projectId: itemProjectId } = (0, token_1.parseCrowdinId)(item.id);
+                return itemOrganization === organization && itemProjectId === projectId;
+            };
+            // Org names with underscores make the LIKE pre-filter unreliable (SQL treats _ as a
+            // single-char wildcard), so fall back to a full org-level load + JS filter.
+            if (organization.includes('_')) {
+                const all = yield this.getAllIntegrationCredentials(organization);
+                return all.filter(filterByProjectId);
+            }
+            // LIKE narrows the DB scan to rows whose id starts with the right org and projectId prefix.
+            const res = yield this.db.query.integrationCredentials.findMany({
+                where: (0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(this.schema.integrationCredentials.crowdin_id, organization), (0, drizzle_orm_1.like)(this.schema.integrationCredentials.id, `${organization}__${projectId}__%`)),
+            });
+            return (res
+                .map((item) => ({
+                id: item.id,
+                credentials: item.credentials,
+                crowdinId: item.crowdin_id,
+                managers: item.managers,
+            }))
+                // SQL LIKE treats _ as a single-char wildcard, so "org__1__%" also matches "org__10__456".
+                // parseCrowdinId gives the exact match LIKE cannot guarantee.
+                .filter(filterByProjectId));
+        });
+    }
     deleteIntegrationCredentials(id) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.migrationPromise;

package/out/storage/types.d.ts

@@ -28,6 +28,7 @@ export interface Storage {
     updateIntegrationManagers(id: string, managers: string): Promise<void>;
     getIntegrationCredentials(id: string): Promise<IntegrationCredentials | undefined>;
     getAllIntegrationCredentials(crowdinId: string): Promise<IntegrationCredentials[]>;
+    getIntegrationCredentialsByProject(organization: string, projectId: number): Promise<IntegrationCredentials[]>;
     deleteIntegrationCredentials(id: string): Promise<void>;
     deleteAllIntegrationCredentials(crowdinId: string): Promise<void>;
     saveMetadata(id: string, metadata: any, crowdinId: string): Promise<void>;

package/out/types.d.ts

@@ -1,4 +1,5 @@
 import Crowdin from '@crowdin/crowdin-api-client';
+import type { AppStorage } from '@crowdin/apps-storage';
 import { Request } from 'express';
 import { ContextContent } from './modules/context-menu/types';
 import { CustomMTLogic } from './modules/custom-mt/types';
@@ -393,7 +394,8 @@ export declare enum Scope {
     AI_PROVIDERS = "ai.provider",
     AI_PROMPTS = "ai.prompt",
     AI_PROXIES = "ai.proxy",
-    APPLICATIONS = "application"
+    APPLICATIONS = "application",
+    APPLICATION_STORAGE = "application.storage"
 }
 export interface CrowdinClientRequest extends Request {
     crowdinApiClient: Crowdin;
@@ -478,6 +480,18 @@ export interface CrowdinAppUtilities extends CrowdinMetadataStore {
     }) => (req: any, res: any, next: any) => void;
     storage: Storage;
     cron: Cron;
+    /**
+     * Crowdin-hosted storage for this app installation (the `kv` key-value space).
+     * Unlike `storage` (the app's own database), this data lives on the Crowdin side
+     * and is shared across the installation. Requires the `crowdin_app` authentication
+     * type (the default) - the storage endpoints accept only the application's own
+     * token, so every other authentication type is rejected. `kv.user.*` records are
+     * private to the identity behind the stored credentials.
+     * Optionally enumerate the app's module keys in the type parameter
+     * (`crowdinStorage<'main' | 'reports'>(...)`) to get the full
+     * `module:{moduleKey}:` prefixes suggested in key positions.
+     */
+    crowdinStorage: <M extends string = never>(crowdinId: string) => Promise<AppStorage<M>>;
 }
 export interface CrowdinMetadataStore {
     saveMetadata: (options: {

package/out/types.js

@@ -36,6 +36,7 @@ var Scope;
     Scope["AI_PROMPTS"] = "ai.prompt";
     Scope["AI_PROXIES"] = "ai.proxy";
     Scope["APPLICATIONS"] = "application";
+    Scope["APPLICATION_STORAGE"] = "application.storage";
 })(Scope || (exports.Scope = Scope = {}));
 var AccountType;
 (function (AccountType) {

package/out/util/connection.js

@@ -266,10 +266,7 @@ function resolveIntegrationAccess(clientId) {
         const ownerIds = [];
         let projectIntegrationCredentials = [];
         if (!integrationCredentials) {
-            projectIntegrationCredentials = (yield (0, storage_1.getStorage)().getAllIntegrationCredentials(organization)).filter((item) => {
-                const { organization: itemOrganization, projectId: itemProjectId } = (0, token_1.parseCrowdinId)(item.id);
-                return itemOrganization === organization && itemProjectId === projectId;
-            });
+            projectIntegrationCredentials = yield (0, storage_1.getStorage)().getIntegrationCredentialsByProject(organization, projectId);
             for (const credentials of projectIntegrationCredentials) {
                 ownerIds.push((0, token_1.parseCrowdinId)(credentials.id).userId);
                 if (credentials.managers) {

package/out/util/crowdin-storage.d.ts

@@ -0,0 +1,7 @@
+import { type AppStorage, type StorageTransport } from '@crowdin/apps-storage';
+import { Config } from '../types';
+export declare function createCrowdinStorageTransport({ config, crowdinId, }: {
+    config: Config;
+    crowdinId: string;
+}): StorageTransport;
+export declare function createCrowdinStorage<M extends string = never>(config: Config, crowdinId: string): Promise<AppStorage<M>>;

package/out/util/crowdin-storage.js

@@ -0,0 +1,78 @@
+"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.createCrowdinStorageTransport = createCrowdinStorageTransport;
+exports.createCrowdinStorage = createCrowdinStorage;
+const axios_1 = __importDefault(require("axios"));
+const apps_storage_1 = require("@crowdin/apps-storage");
+const storage_1 = require("../storage");
+const types_1 = require("../types");
+const connection_1 = require("./connection");
+function loadCredentials(crowdinId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const credentials = yield (0, storage_1.getStorage)().getCrowdinCredentials(crowdinId);
+        if (!credentials) {
+            throw new Error('Failed to find Crowdin credentials');
+        }
+        return credentials;
+    });
+}
+function createCrowdinStorageTransport({ config, crowdinId, }) {
+    const send = (request, token, apiUrl) => __awaiter(this, void 0, void 0, function* () {
+        const url = `${apiUrl}/applications/${encodeURIComponent(config.identifier)}/storage/${request.path}`;
+        return axios_1.default.request({
+            method: request.method,
+            url,
+            params: request.query,
+            data: request.body,
+            headers: { Authorization: `Bearer ${token}` },
+            validateStatus: () => true,
+        });
+    });
+    return (request) => __awaiter(this, void 0, void 0, function* () {
+        const initial = yield (0, connection_1.prepareCrowdinClient)({
+            config,
+            credentials: yield loadCredentials(crowdinId),
+            autoRenew: true,
+        });
+        let response = yield send(request, initial.token, initial.client.url);
+        if (response.status === 401) {
+            const refreshed = yield (0, connection_1.prepareCrowdinClient)({
+                config,
+                credentials: yield loadCredentials(crowdinId),
+                autoRenew: true,
+            });
+            response = yield send(request, refreshed.token, refreshed.client.url);
+        }
+        return { status: response.status, body: response.data };
+    });
+}
+function createCrowdinStorage(config, crowdinId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const authenticationType = config.authenticationType || types_1.AuthenticationType.APP;
+        if (authenticationType !== types_1.AuthenticationType.APP) {
+            throw new Error(`Crowdin storage is not available for ${authenticationType} authentication because the storage endpoints accept only the application's own token`);
+        }
+        yield loadCredentials(crowdinId);
+        return (0, apps_storage_1.createStorage)({
+            transport: createCrowdinStorageTransport({ config, crowdinId }),
+            getUserId: () => __awaiter(this, void 0, void 0, function* () {
+                const credentials = yield loadCredentials(crowdinId);
+                return credentials.userId !== null && credentials.userId !== undefined
+                    ? String(credentials.userId)
+                    : undefined;
+            }),
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crowdin/app-project-module",
-  "version": "2.10.0",
+  "version": "2.11.1",
   "description": "Module that generates for you all common endpoints for serving standalone Crowdin App",
   "main": "out/index.js",
   "types": "out/index.d.ts",
@@ -57,8 +57,9 @@
     "out/**/*"
   ],
   "dependencies": {
+    "@crowdin/apps-storage": "0.x",
     "@crowdin/crowdin-api-client": "^1.56.1",
-    "@crowdin/logs-formatter": "^3.0.0",
+    "@crowdin/logs-formatter": "^3.1.0",
     "@godaddy/terminus": "^4.12.1",
     "ajv": "^8.20.0",
     "amqplib": "^2.0.1",