@transifex/api 2.4.1 → 3.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@transifex/api",
-  "version": "2.4.1",
+  "version": "3.2.0",
   "description": "Transifex API SDK",
   "keywords": [
     "transifex",
@@ -29,9 +29,9 @@
   },
   "devDependencies": {
     "@babel/cli": "^7.15.4",
-    "@babel/core": "^7.15.5",
+    "@babel/core": "^7.17.8",
     "@babel/preset-env": "^7.15.0",
-    "@transifex/jsonapi": "^2.4.1",
+    "@transifex/jsonapi": "^3.2.0",
     "babel-eslint": "^10.1.0",
     "babel-loader": "^8.2.2",
     "eslint": "^7.32.0",

package/src/transifexApi.js

@@ -1,4 +1,31 @@
-import { JsonApi, Resource as JsonApiResource } from '@transifex/jsonapi'; /* eslint-disable-line max-classes-per-file */
+/* eslint-disable no-await-in-loop, max-classes-per-file */
+import { JsonApi, Resource as JsonApiResource } from '@transifex/jsonapi';
+
+function sleep(sec) {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      resolve();
+    }, sec * 1000);
+  });
+}
+
+async function download({ interval = 5, ...data }) {
+  // 'this' is a Resource subclass
+  const resource = await this.create(data);
+  while (!resource.redirect) {
+    await sleep(interval);
+    await resource.reload();
+  }
+  return resource.redirect;
+}
+
+async function upload({ interval = 5, ...data }) {
+  const resource = await this.create(data);
+  while (resource.get('status') !== 'succeeded') {
+    await sleep(interval);
+    await resource.reload();
+  }
+}
 
 export class TransifexApi extends JsonApi {
   static HOST = 'https://rest.api.transifex.com';
@@ -31,6 +58,28 @@ TransifexApi.register(ProjectWebhook, 'ProjectWebhook');
 
 class Resource extends JsonApiResource {
   static TYPE = 'resources';
+
+  async purge() {
+    let count = 0;
+    /* eslint-disable no-restricted-syntax */
+    for await (
+      const page of this.constructor.API.ResourceString
+        .filter({ resource: this })
+        .allPages()
+    ) {
+      count += page.data.length;
+      await this.constructor.API.ResourceString.bulkDelete(page.data);
+    }
+    /* eslint-enable */
+    return count;
+  }
+
+  async downloadSource(attributes = {}) {
+    return this.constructor.API.ResourceStringsAsyncDownload.download({
+      resource: this,
+      ...attributes,
+    });
+  }
 }
 TransifexApi.register(Resource, 'Resource');
 
@@ -39,15 +88,56 @@ class ResourceString extends JsonApiResource {
 }
 TransifexApi.register(ResourceString, 'ResourceString');
 
-class ResourceStringAsyncDownload extends JsonApiResource {
+class ResourceStringsAsyncDownload extends JsonApiResource {
   static TYPE = 'resource_strings_async_downloads';
+
+  /**
+   * Download source content
+   *
+   * @static
+   * @param {object} data
+   * @param {Resource} data.resource
+   * @param {string} data.content_encoding - "text" (default) or "base64"
+   * @param {string} data.file_type - "default" (default) or "xliff"
+   * @param {boolean} data.pseudo - Generate mock string translations
+   * @param {string} data.callback_url - The URL that will be called when processing is complete
+   * @param {number} data.interval - Seconds to check status (5sec default)
+   * @memberof ResourceStringsAsyncDownload
+   * @returns - A URL to download the content
+   */
+  static async download(data) {
+    return download.call(this, {
+      content_encoding: 'text',
+      file_type: 'default',
+      ...data,
+    });
+  }
 }
-TransifexApi.register(ResourceStringAsyncDownload, 'ResourceStringAsyncDownload');
+TransifexApi.register(ResourceStringsAsyncDownload, 'ResourceStringsAsyncDownload');
 
-class ResourceStringAsyncUpload extends JsonApiResource {
+class ResourceStringsAsyncUpload extends JsonApiResource {
   static TYPE = 'resource_strings_async_uploads';
+
+  /**
+   * Upload source content
+   *
+   * Content is always in string format. To upload a binary file, convert it to
+   * Base64 and set the content_type='base64'.
+   *
+   * @static
+   * @param {object} data
+   * @param {Resource} data.resource
+   * @param {string} data.content
+   * @param {string} data.content_encoding - "text" (default) or "base64"
+   * @param {string} data.callback_url - The URL that will be called when processing is complete
+   * @param {number} data.interval - seconds to check status (5sec default)
+   * @memberof ResourceStringsAsyncUpload
+   */
+  static async upload(data) {
+    return upload.call(this, { content_encoding: 'text', ...data });
+  }
 }
-TransifexApi.register(ResourceStringAsyncUpload, 'ResourceStringAsyncUpload');
+TransifexApi.register(ResourceStringsAsyncUpload, 'ResourceStringsAsyncUpload');
 
 class ResourceStringComment extends JsonApiResource {
   static TYPE = 'resource_string_comments';
@@ -71,43 +161,166 @@ TransifexApi.register(ContextScreenshot, 'ContextScreenshot');
 
 class OrganizationActivityReportsAsyncDownload extends JsonApiResource {
   static TYPE = 'organization_activity_reports_async_downloads';
+
+  /**
+   * Download organization activity report
+   *
+   * @static
+   * @param {object} data
+   * @param {Organization} data.organization
+   * @param {Language} data.language
+   * @param {User} data.user
+   * @param {string} data.date_from - Date, will be treated as UTC by the API
+   * @param {string} data.date_to - Date, will be treated as UTC by the API
+   * @param {number} data.interval - seconds to check status (5sec default)
+   * @memberof OrganizationActivityReportsAsyncDownload
+   * @returns - A URL to download the content
+   */
+  static async download(data) {
+    return download.call(this, data);
+  }
 }
 TransifexApi.register(OrganizationActivityReportsAsyncDownload, 'OrganizationActivityReportsAsyncDownload');
 
 class ProjectActivityReportsAsyncDownload extends JsonApiResource {
   static TYPE = 'project_activity_reports_async_downloads';
+
+  /**
+   * Download project activity report
+   *
+   * @static
+   * @param {object} data
+   * @param {Project} data.project
+   * @param {Language} data.language
+   * @param {User} data.user
+   * @param {string} data.date_from - Date, will be treated as UTC by the API
+   * @param {string} data.date_to - Date, will be treated as UTC by the API
+   * @param {number} data.interval - seconds to check status (5sec default)
+   * @memberof ProjectActivityReportsAsyncDownload
+   * @returns - A URL to download the content
+   */
+  static async download(data) {
+    return download.call(this, data);
+  }
 }
 TransifexApi.register(ProjectActivityReportsAsyncDownload, 'ProjectActivityReportsAsyncDownload');
 
 class ResourceActivityReportsAsyncDownload extends JsonApiResource {
   static TYPE = 'resource_activity_reports_async_downloads';
+
+  /**
+   * Download resource activity report
+   *
+   * @static
+   * @param {object} data
+   * @param {Resource} data.resource
+   * @param {Language} data.language
+   * @param {User} data.user
+   * @param {string} data.date_from - Date, will be treated as UTC by the API
+   * @param {string} data.date_to - Date, will be treated as UTC by the API
+   * @param {number} data.interval - seconds to check status (5sec default)
+   * @memberof ResourceActivityReportsAsyncDownload
+   * @returns - A URL to download the content
+   */
+  static async download(data) {
+    return download.call(this, data);
+  }
 }
 TransifexApi.register(ResourceActivityReportsAsyncDownload, 'ResourceActivityReportsAsyncDownload');
 
 class TeamActivityReportsAsyncDownload extends JsonApiResource {
   static TYPE = 'team_activity_reports_async_downloads';
+
+  /**
+   * Download team activity report
+   *
+   * @static
+   * @param {object} data
+   * @param {Team} data.team
+   * @param {Language} data.language
+   * @param {User} data.user
+   * @param {string} data.date_from - Date, will be treated as UTC by the API
+   * @param {string} data.date_to - Date, will be treated as UTC by the API
+   * @param {number} data.interval - seconds to check status (5sec default)
+   * @memberof TeamActivityReportsAsyncDownload
+   * @returns - A URL to download the content
+   */
+  static async download(data) {
+    return download.call(this, data);
+  }
 }
 TransifexApi.register(TeamActivityReportsAsyncDownload, 'TeamActivityReportsAsyncDownload');
 
-class ResourceLanguageStat extends JsonApiResource {
+class ResourceLanguageStats extends JsonApiResource {
   static TYPE = 'resource_language_stats';
 }
-TransifexApi.register(ResourceLanguageStat, 'ResourceLanguageStat');
+TransifexApi.register(ResourceLanguageStats, 'ResourceLanguageStats');
 
 class ResourceTranslation extends JsonApiResource {
   static TYPE = 'resource_translations';
 }
 TransifexApi.register(ResourceTranslation, 'ResourceTranslation');
 
-class ResourceTranslationAsyncDownload extends JsonApiResource {
+class ResourceTranslationsAsyncDownload extends JsonApiResource {
   static TYPE = 'resource_translations_async_downloads';
+
+  /**
+   * Download translation file
+   *
+   * @static
+   * @param {object} data
+   * @param {Resource} data.resource
+   * @param {Language} data.language
+   * @param {string} data.content_encoding - "text" (default) or "base64"
+   * @param {string} data.file_type - "default" (default) or "xliff"
+   * @param {string} data.mode - "default" (default), "reviewed", "proofread",
+   *   "translator", "untranslated", "onlytranslated", "onlyreviewed",
+   *   "onlyproofread", "sourceastranslation"
+   * @param {string} data.callback_url - The URL that will be called when processing is complete
+   * @param {number} data.interval - seconds to check status (5sec default)
+   * @memberof ResourceTranslationsAsyncDownload
+   * @returns - A URL to download the content
+   */
+  static async download(data) {
+    return download.call(this, {
+      content_encoding: 'text',
+      file_type: 'default',
+      mode: 'default',
+      ...data,
+    });
+  }
 }
-TransifexApi.register(ResourceTranslationAsyncDownload, 'ResourceTranslationAsyncDownload');
+TransifexApi.register(ResourceTranslationsAsyncDownload, 'ResourceTranslationsAsyncDownload');
 
-class ResourceTranslationAsyncUpload extends JsonApiResource {
+class ResourceTranslationsAsyncUpload extends JsonApiResource {
   static TYPE = 'resource_translations_async_uploads';
+
+  /**
+   * Upload translations.
+   *
+   * Content is always in string format. To upload a binary file, convert it to
+   * Base64 and set the content_type='base64'.
+   *
+   * @static
+   * @param {object} data
+   * @param {Resource} data.resource
+   * @param {Language} data.language
+   * @param {string} data.content
+   * @param {string} data.content_encoding - "text" (default) or "base64"
+   * @param {string} file_type - "default" (default) or "xliff"
+   * @param {string} data.callback_url - The URL that will be called when processing is complete
+   * @param {number} data.interval - seconds to check status (5sec default)
+   * @memberof ResourceTranslationsAsyncUpload
+   */
+  static async upload(data) {
+    return upload.call(this, {
+      content_encoding: 'text',
+      file_type: 'default',
+      ...data,
+    });
+  }
 }
-TransifexApi.register(ResourceTranslationAsyncUpload, 'ResourceTranslationAsyncUpload');
+TransifexApi.register(ResourceTranslationsAsyncUpload, 'ResourceTranslationsAsyncUpload');
 
 class TeamMembership extends JsonApiResource {
   static TYPE = 'team_memberships';
@@ -121,12 +334,54 @@ TransifexApi.register(Team, 'Team');
 
 class TmxAsyncDownload extends JsonApiResource {
   static TYPE = 'tmx_async_downloads';
+
+  /**
+   * Export project's TM as a TMX file
+   *
+   * @static
+   * @param {object} data
+   * @param {Project} data.project
+   * @param {Language} data.language
+   * @param {string} data.callback_url - The URL that will be called when processing is complete
+   * @param {number} data.interval - seconds to check status (5sec default)
+   * @memberof TmxAsyncDownload
+   * @returns - A URL to download the content
+   */
+  static async download(data) {
+    return download.call(this, { callback_url: null, ...data });
+  }
 }
 TransifexApi.register(TmxAsyncDownload, 'TmxAsyncDownload');
 
 class TmxAsyncUpload extends JsonApiResource {
   static TYPE = 'tmx_async_uploads';
+
+  /**
+   * Upload a TMX file
+   *
+   * Content is always in string format. To upload a binary file, convert it to
+   * Base64 and set the content_type='base64'.
+   *
+   * @static
+   * @param {object} data
+   * @param {Project} data.project
+   * @param {Language} data.language
+   * @param {string} data.content
+   * @param {string} data.content_encoding - "text" (default) or "base64"
+   * @param {boolean} data.override - Whether to override the TM
+   * @param {string} data.callback_url - The URL that will be called when processing is complete
+   * @param {number} data.interval - seconds to check status (5sec default)
+   * @memberof TmxAsyncUpload
+   */
+  static async upload(data) {
+    return upload.call(this, { content_encoding: 'text', ...data });
+  }
 }
 TransifexApi.register(TmxAsyncUpload, 'TmxAsyncUpload');
 
+class ResourceStringsRevision extends JsonApiResource {
+  static TYPE = 'resource_strings_revisions';
+}
+TransifexApi.register(ResourceStringsRevision, 'ResourceStringsRevision');
+
 export const transifexApi = new TransifexApi();

package/dist/browser.transifexApi.js.LICENSE.txt

@@ -1 +0,0 @@
-/*! For license information please see browser.jsonapi.js.LICENSE.txt */

package/dist/node.transifexApi.js.LICENSE.txt

@@ -1 +0,0 @@
-/*! For license information please see node.jsonapi.js.LICENSE.txt */