smartling-api-sdk-nodejs 2.21.1 → 2.23.0

package/.scannerwork/report-task.txt

@@ -2,5 +2,5 @@ projectKey=smartling-api-sdk-nodejs
 serverUrl=https://sonar-next.connectors.stg.smartling.net
 serverVersion=8.6.1.40680
 dashboardUrl=https://sonar-next.connectors.stg.smartling.net/dashboard?id=smartling-api-sdk-nodejs
-ceTaskId=AZg2oi-ALw_GP6qdp7B5
-ceTaskUrl=https://sonar-next.connectors.stg.smartling.net/api/ce/task?id=AZg2oi-ALw_GP6qdp7B5
+ceTaskId=AZh0732vF9ynshTVs21w
+ceTaskUrl=https://sonar-next.connectors.stg.smartling.net/api/ce/task?id=AZh0732vF9ynshTVs21w

package/api/base/index.ts

@@ -162,7 +162,8 @@ export class SmartlingBaseApi {
                     "dueDate",
                     "actionTime",
                     "publishDate",
-                    "lastModified"
+                    "lastModified",
+                    "attemptDate"
                 ];
 
                 if (dateProperties.includes(key) && value) {

package/api/tags/dto/project-id-tag-dto.ts

@@ -0,0 +1,5 @@
+import { TagDto } from "./tag-dto";
+
+export interface ProjectIdTagDto extends TagDto {
+    projectId: string;
+}

package/api/tags/dto/string-tags-dto.ts

@@ -0,0 +1,6 @@
+import { TagDto } from "./tag-dto";
+
+export interface StringTagsDto {
+    stringHashcode: string;
+    tags: Array<TagDto>;
+}

package/api/tags/dto/tag-dto.ts

@@ -0,0 +1,3 @@
+export interface TagDto {
+    tag: string;
+}

package/api/tags/index.ts

@@ -0,0 +1,87 @@
+import { SmartlingBaseApi } from "../base/index";
+import { AccessTokenProvider } from "../auth/access-token-provider";
+import { Logger } from "../logger";
+import { SmartlingListResponse } from "../http/smartling-list-response";
+import { TagDto } from "./dto/tag-dto";
+import { StringTagsDto } from "./dto/string-tags-dto";
+import { ListAccountTagsParameters } from "./params/list-account-tags-parameters";
+import { ListProjectTagsParameters } from "./params/list-project-tags-parameters";
+import { SearchStringTagsParameters } from "./params/search-string-tags-parameters";
+import { AddTagsToStringsParameters } from "./params/add-tags-to-strings-parameters";
+import { RemoveTagsFromStringsParameters } from "./params/remove-tags-from-strings-parameters";
+import { RemoveAllTagsFromStringsParameters } from "./params/remove-all-tags-from-strings-parameters";
+import { ProjectIdTagDto } from "./dto/project-id-tag-dto";
+
+export class SmartlingTagsApi extends SmartlingBaseApi {
+    constructor(smartlingApiBaseUrl: string, authApi: AccessTokenProvider, logger: Logger) {
+        super(logger);
+        this.authApi = authApi;
+        this.entrypoint = `${smartlingApiBaseUrl}/tags-api/v2`;
+    }
+
+    async listAccountTags(
+        accountUid: string,
+        params: ListAccountTagsParameters
+    ): Promise<SmartlingListResponse<ProjectIdTagDto>> {
+        return await this.makeRequest(
+            "post",
+            `${this.entrypoint}/accounts/${accountUid}/tags`,
+            JSON.stringify(params.export())
+        );
+    }
+
+    async listProjectTags(
+        projectId: string,
+        params: ListProjectTagsParameters
+    ): Promise<SmartlingListResponse<TagDto>> {
+        return await this.makeRequest(
+            "get",
+            `${this.entrypoint}/projects/${projectId}/tags`,
+            params.export()
+        );
+    }
+
+    async searchStringTags(
+        projectId: string,
+        params: SearchStringTagsParameters
+    ): Promise<Array<StringTagsDto>> {
+        return await this.makeRequest(
+            "post",
+            `${this.entrypoint}/projects/${projectId}/strings/tags/search`,
+            JSON.stringify(params.export())
+        );
+    }
+
+    async addTagsToStrings(
+        projectId: string,
+        params: AddTagsToStringsParameters
+    ): Promise<void> {
+        return await this.makeRequest(
+            "post",
+            `${this.entrypoint}/projects/${projectId}/strings/tags/add`,
+            JSON.stringify(params.export())
+        );
+    }
+
+    async removeTagsFromStrings(
+        projectId: string,
+        params: RemoveTagsFromStringsParameters
+    ): Promise<void> {
+        return await this.makeRequest(
+            "post",
+            `${this.entrypoint}/projects/${projectId}/strings/tags/remove`,
+            JSON.stringify(params.export())
+        );
+    }
+
+    async removeAllTagsFromStrings(
+        projectId: string,
+        params: RemoveAllTagsFromStringsParameters
+    ): Promise<Record<string, unknown>> {
+        return await this.makeRequest(
+            "post",
+            `${this.entrypoint}/projects/${projectId}/strings/tags/remove/all`,
+            JSON.stringify(params.export())
+        );
+    }
+}

package/api/tags/params/add-tags-to-strings-parameters.ts

@@ -0,0 +1,4 @@
+import { BaseTagsStringsParameters } from "./base-tags-strings-parameters";
+
+export class AddTagsToStringsParameters
+    extends BaseTagsStringsParameters<AddTagsToStringsParameters> {}

package/api/tags/params/base-tags-strings-parameters.ts

@@ -0,0 +1,40 @@
+import { BaseParameters } from "../../parameters";
+import { SmartlingException } from "../../exception";
+
+export abstract class BaseTagsStringsParameters<
+    T extends BaseTagsStringsParameters<T>
+> extends BaseParameters {
+    setTags(tags: Array<string>): T {
+        if (!tags || tags.length === 0) {
+            throw new SmartlingException("Tags array is required");
+        }
+
+        if (tags.length > 100) {
+            throw new SmartlingException("Tags array must not exceed 100 items");
+        }
+
+        tags.forEach((tag) => {
+            if (tag.length > 128) {
+                throw new SmartlingException("Tag length must not exceed 128 characters");
+            }
+        });
+
+        this.set("tags", tags);
+
+        return this as unknown as T;
+    }
+
+    setStringHashcodes(stringHashcodes: Array<string>): T {
+        if (!stringHashcodes || stringHashcodes.length === 0) {
+            throw new SmartlingException("String hashcodes array is required");
+        }
+
+        if (stringHashcodes.length > 1000) {
+            throw new SmartlingException("String hashcodes array must not exceed 1000 items");
+        }
+
+        this.set("stringHashcodes", stringHashcodes);
+
+        return this as unknown as T;
+    }
+}

package/api/tags/params/list-account-tags-parameters.ts

@@ -0,0 +1,40 @@
+import { BaseParameters } from "../../parameters";
+import { SmartlingException } from "../../exception";
+
+export class ListAccountTagsParameters extends BaseParameters {
+    setProjectIds(projectIds: Array<string>): ListAccountTagsParameters {
+        if (projectIds && projectIds.length > 1000) {
+            throw new SmartlingException("Project IDs array must not exceed 1000 items");
+        }
+
+        this.set("projectIds", projectIds);
+
+        return this;
+    }
+
+    setTagMask(tagMask: string): ListAccountTagsParameters {
+        this.set("tagMask", tagMask);
+
+        return this;
+    }
+
+    setLimit(limit: number): ListAccountTagsParameters {
+        if (limit < 1 || limit > 1500) {
+            throw new SmartlingException("Limit must be between 1 and 1500");
+        }
+
+        this.set("limit", limit);
+
+        return this;
+    }
+
+    setOffset(offset: number): ListAccountTagsParameters {
+        if (offset < 0) {
+            throw new SmartlingException("Offset must be non-negative");
+        }
+
+        this.set("offset", offset);
+
+        return this;
+    }
+}

package/api/tags/params/list-project-tags-parameters.ts

@@ -0,0 +1,30 @@
+import { BaseParameters } from "../../parameters";
+import { SmartlingException } from "../../exception";
+
+export class ListProjectTagsParameters extends BaseParameters {
+    setTagMask(tagMask: string): ListProjectTagsParameters {
+        this.set("tagMask", tagMask);
+
+        return this;
+    }
+
+    setLimit(limit: number): ListProjectTagsParameters {
+        if (limit < 0 || limit > 100) {
+            throw new SmartlingException("Limit must be between 0 and 100");
+        }
+
+        this.set("limit", limit);
+
+        return this;
+    }
+
+    setOffset(offset: number): ListProjectTagsParameters {
+        if (offset < 0) {
+            throw new SmartlingException("Offset must be non-negative");
+        }
+
+        this.set("offset", offset);
+
+        return this;
+    }
+}

package/api/tags/params/remove-all-tags-from-strings-parameters.ts

@@ -0,0 +1,18 @@
+import { BaseParameters } from "../../parameters";
+import { SmartlingException } from "../../exception";
+
+export class RemoveAllTagsFromStringsParameters extends BaseParameters {
+    setStringHashcodes(stringHashcodes: Array<string>): RemoveAllTagsFromStringsParameters {
+        if (!stringHashcodes || stringHashcodes.length === 0) {
+            throw new SmartlingException("String hashcodes array is required");
+        }
+
+        if (stringHashcodes.length > 1000) {
+            throw new SmartlingException("String hashcodes array must not exceed 1000 items");
+        }
+
+        this.set("stringHashcodes", stringHashcodes);
+
+        return this;
+    }
+}

package/api/tags/params/remove-tags-from-strings-parameters.ts

@@ -0,0 +1,4 @@
+import { BaseTagsStringsParameters } from "./base-tags-strings-parameters";
+
+export class RemoveTagsFromStringsParameters
+    extends BaseTagsStringsParameters<RemoveTagsFromStringsParameters> {}

package/api/tags/params/search-string-tags-parameters.ts

@@ -0,0 +1,18 @@
+import { BaseParameters } from "../../parameters";
+import { SmartlingException } from "../../exception";
+
+export class SearchStringTagsParameters extends BaseParameters {
+    setStringHashcodes(stringHashcodes: Array<string>): SearchStringTagsParameters {
+        if (!stringHashcodes || stringHashcodes.length === 0) {
+            throw new SmartlingException("String hashcodes array is required");
+        }
+
+        if (stringHashcodes.length > 1000) {
+            throw new SmartlingException("String hashcodes array must not exceed 1000 items");
+        }
+
+        this.set("stringHashcodes", stringHashcodes);
+
+        return this;
+    }
+}

package/api/webhooks/dto/scrollable-response.ts

@@ -0,0 +1,7 @@
+interface ScrollableResponse<T> {
+    items: Array<T>;
+    hasMore: boolean;
+    scrollId: string | null;
+}
+
+export { ScrollableResponse };

package/api/webhooks/dto/subscription-attempted-event-dto.ts

@@ -0,0 +1,10 @@
+import { SubscriptionEventAttemptStatus } from "./subscription-event-attempt-status";
+
+interface SubscriptionAttemptedEventDto {
+    eventId: string;
+    eventType: string;
+    createdDate: Date;
+    lastAttemptStatus: SubscriptionEventAttemptStatus
+}
+
+export { SubscriptionAttemptedEventDto };

package/api/webhooks/dto/subscription-dto.ts

@@ -0,0 +1,18 @@
+import { SubscriptionEvent } from "../params/subscription-event";
+import { SubscriptionRequestHeader } from "../params/subscription-request-header";
+
+interface SubscriptionDto {
+    subscriptionUid: string;
+    subscriptionName: string;
+    subscriptionUrl: string;
+    accountUid: string;
+    enabled: boolean;
+    userUid: string;
+    description: string | null;
+    createdDate: string;
+    requestHeaders: SubscriptionRequestHeader[];
+    events: SubscriptionEvent[];
+    projectUids: string[];
+}
+
+export { SubscriptionDto };

package/api/webhooks/dto/subscription-event-attempt-dto.ts

@@ -0,0 +1,16 @@
+import { SubscriptionEventAttemptStatus } from "./subscription-event-attempt-status";
+import { SubscriptionEventTriggerType } from "./subscription-event-trigger-type";
+
+interface SubscriptionEventAttemptDto {
+    attemptId: string;
+    eventId: string;
+    response: string | null;
+    responseDurationMs: number;
+    responseStatusCode: number;
+    attemptStatus: SubscriptionEventAttemptStatus;
+    attemptDate: Date;
+    url: string;
+    triggerType: SubscriptionEventTriggerType;
+}
+
+export { SubscriptionEventAttemptDto };

package/api/webhooks/dto/subscription-event-attempt-status.ts

@@ -0,0 +1,8 @@
+enum SubscriptionEventAttemptStatus {
+    SUCCESS = "SUCCESS",
+    PENDING = "PENDING",
+    FAIL = "FAIL",
+    SENDING = "SENDING"
+}
+
+export { SubscriptionEventAttemptStatus };

package/api/webhooks/dto/subscription-event-dto.ts

@@ -0,0 +1,8 @@
+interface SubscriptionEventDto {
+    eventId: string;
+    eventType: string;
+    createdDate: Date;
+    payload: Record<string, unknown>;
+}
+
+export { SubscriptionEventDto };

package/api/webhooks/dto/subscription-event-trigger-type.ts

@@ -0,0 +1,6 @@
+enum SubscriptionEventTriggerType {
+    SCHEDULED = "SCHEDULED",
+    MANUAL = "MANUAL"
+}
+
+export { SubscriptionEventTriggerType };

package/api/webhooks/dto/subscription-secret-dto.ts

@@ -0,0 +1,5 @@
+interface SubscriptionSecretDto {
+    payloadSecret: string;
+}
+
+export { SubscriptionSecretDto };

package/api/webhooks/dto/subscription-statistics-dto.ts

@@ -0,0 +1,8 @@
+interface SubscriptionStatisticsDto {
+    failEvents: number;
+    pendingEvents: number;
+    sendingEvents: number;
+    successEvents: number;
+}
+
+export { SubscriptionStatisticsDto };

package/api/webhooks/dto/webhook-event-type.dto.ts

@@ -0,0 +1,7 @@
+class WebhookEventTypeDto {
+    eventType: string;
+    description: string;
+    schema: Record<string, unknown>;
+}
+
+export { WebhookEventTypeDto };

package/api/webhooks/index.ts

@@ -0,0 +1,17 @@
+export { SmartlingWebhooksApi } from "./smartling-webhooks-api";
+export { ScrollableResponse } from "./dto/scrollable-response";
+export { SubscriptionAttemptedEventDto } from "./dto/subscription-attempted-event-dto";
+export { SubscriptionEventDto } from "./dto/subscription-event-dto";
+export { SubscriptionEventAttemptDto } from "./dto/subscription-event-attempt-dto";
+export { SubscriptionEventAttemptStatus } from "./dto/subscription-event-attempt-status";
+export { SubscriptionEventTriggerType } from "./dto/subscription-event-trigger-type";
+export { SubscriptionStatisticsDto } from "./dto/subscription-statistics-dto";
+export { SubscriptionDto } from "./dto/subscription-dto";
+export { SubscriptionSecretDto } from "./dto/subscription-secret-dto";
+export { WebhookEventTypeDto } from "./dto/webhook-event-type.dto";
+export { SubscriptionEvent } from "./params/subscription-event";
+export { CreateSubscriptionParameters } from "./params/create-subscription-parameters";
+export { UpdateSubscriptionParameters } from "./params/update-subscription-parameters";
+export { SubscriptionRequestHeader } from "./params/subscription-request-header";
+export { UpdateSubscriptionSecretParameters } from "./params/update-subscription-secret-parameters";
+export { GetSubscriptionEventsParameters } from "./params/get-subscription-events-parameters";

package/api/webhooks/params/create-subscription-parameters.ts

@@ -0,0 +1,9 @@
+import { CreateUpdateSubscriptionParameters } from "./create-update-subscription-parameters";
+
+export class CreateSubscriptionParameters extends CreateUpdateSubscriptionParameters {
+    setPayloadSecret(payloadSecret: string): this {
+        this.set("payloadSecret", payloadSecret);
+
+        return this;
+    }
+}

package/api/webhooks/params/create-update-subscription-parameters.ts

@@ -0,0 +1,70 @@
+import { BaseParameters } from "../../parameters";
+import { SmartlingException } from "../../exception";
+import { SubscriptionEvent } from "./subscription-event";
+import { SubscriptionRequestHeader } from "./subscription-request-header";
+
+const MAX_EVENTS_SIZE = 1000;
+const MAX_SUBSCRIPTION_HEADERS_SIZE = 20;
+const MAX_PROJECT_UIDS_SIZE = 10;
+
+export abstract class CreateUpdateSubscriptionParameters extends BaseParameters {
+    constructor(
+        subscriptionName: string,
+        subscriptionUrl: string,
+        events: SubscriptionEvent[]
+    ) {
+        super();
+
+        if (!subscriptionName) {
+            throw new SmartlingException("Subscription name is required.");
+        }
+
+        if (!subscriptionUrl) {
+            throw new SmartlingException("Subscription url is required.");
+        }
+
+        if (!events.length) {
+            throw new SmartlingException("At least one event is required.");
+        }
+
+        if (events.length > MAX_EVENTS_SIZE) {
+            throw new SmartlingException(`The request contains too many events: ${events.length}. Maximum allowed events number is ${MAX_EVENTS_SIZE}.`);
+        }
+
+        this.set("subscriptionName", subscriptionName);
+        this.set("subscriptionUrl", subscriptionUrl);
+        this.set("events", events);
+    }
+
+    setDescription(description: string): this {
+        this.set("description", description);
+
+        return this;
+    }
+
+    setRequestHeaders(requestHeaders: SubscriptionRequestHeader[]): this {
+        if (!requestHeaders.length) {
+            throw new SmartlingException("At least one subscription header is required.");
+        }
+
+        if (requestHeaders.length > MAX_SUBSCRIPTION_HEADERS_SIZE) {
+            throw new SmartlingException(`The request contains too many subscription headers: ${requestHeaders.length}. Maximum allowed subscription headers number is ${MAX_SUBSCRIPTION_HEADERS_SIZE}.`);
+        }
+
+        this.set("requestHeaders", requestHeaders);
+        return this;
+    }
+
+    setProjectUids(projectUids: string[]): this {
+        if (!projectUids.length) {
+            throw new SmartlingException("At least one project uid is required.");
+        }
+
+        if (projectUids.length > MAX_PROJECT_UIDS_SIZE) {
+            throw new SmartlingException(`The request contains too many project uids: ${projectUids.length}. Maximum allowed project uids number is ${MAX_PROJECT_UIDS_SIZE}.`);
+        }
+        this.set("projectUids", projectUids);
+
+        return this;
+    }
+}

package/api/webhooks/params/get-subscription-events-parameters.ts

@@ -0,0 +1,38 @@
+import { BaseParameters } from "../../parameters";
+import { SubscriptionEventAttemptStatus } from "../dto/subscription-event-attempt-status";
+
+export class GetSubscriptionEventsParameters extends BaseParameters {
+    setLimit(limit: number): this {
+        this.set("limit", limit);
+        return this;
+    }
+
+    setScrollId(scrollId: string): this {
+        this.set("scrollId", scrollId);
+        return this;
+    }
+
+    setAttemptStatus(attemptStatus: SubscriptionEventAttemptStatus): this {
+        this.set("attemptStatus", attemptStatus);
+        return this;
+    }
+
+    setCreatedDateBefore(createdDateBefore: Date): this {
+        this.set("createdDateBefore", GetSubscriptionEventsParameters.prepareDateParameter(createdDateBefore));
+        return this;
+    }
+
+    setCreatedDateAfter(createdDateAfter: Date): this {
+        this.set("createdDateAfter", GetSubscriptionEventsParameters.prepareDateParameter(createdDateAfter));
+        return this;
+    }
+
+    setEventTypes(eventTypes: string[]): this {
+        this.set("eventTypes", eventTypes);
+        return this;
+    }
+
+    private static prepareDateParameter(date: Date): string {
+        return `${date.toISOString().split(".")[0]}Z`;
+    }
+}

package/api/webhooks/params/subscription-event.ts

@@ -0,0 +1,6 @@
+interface SubscriptionEvent {
+    type: string;
+    schemaVersion: string;
+}
+
+export { SubscriptionEvent };

package/api/webhooks/params/subscription-request-header.ts

@@ -0,0 +1,6 @@
+interface SubscriptionRequestHeader {
+    headerName: string;
+    headerValue: string;
+}
+
+export { SubscriptionRequestHeader };

package/api/webhooks/params/update-subscription-parameters.ts

@@ -0,0 +1,19 @@
+import { CreateUpdateSubscriptionParameters } from "./create-update-subscription-parameters";
+import { SubscriptionEvent } from "./subscription-event";
+
+export class UpdateSubscriptionParameters extends CreateUpdateSubscriptionParameters {
+    constructor(
+        subscriptionName: string,
+        subscriptionUrl: string,
+        events: SubscriptionEvent[],
+        enabled: boolean
+    ) {
+        super(
+            subscriptionName,
+            subscriptionUrl,
+            events
+        );
+
+        this.set("enabled", enabled);
+    }
+}

package/api/webhooks/params/update-subscription-secret-parameters.ts

@@ -0,0 +1,14 @@
+import { BaseParameters } from "../../parameters";
+import { SmartlingException } from "../../exception";
+
+export class UpdateSubscriptionSecretParameters extends BaseParameters {
+    constructor(payloadSecret: string) {
+        super();
+
+        if (!payloadSecret) {
+            throw new SmartlingException("Payload secret is required.");
+        }
+
+        this.set("payloadSecret", payloadSecret);
+    }
+}