@onesignal/node-onesignal 5.8.0 → 5.9.0

package/README.md

@@ -62,6 +62,15 @@ const response = await client.createNotification(notification);
 console.log('Notification ID:', response.id);
 ```
 
+## Send with idempotent retries
+
+`createNotificationWithRetry` generates a UUIDv4 `idempotency_key` when absent (a caller-provided key is respected), retries 429 / 503 / transport errors with the **same** key (honoring `Retry-After`, exponential backoff otherwise; `maxRetries` / `baseDelayMs` configurable via the options object), fails fast on other errors, and reports via `wasReplayed` whether the server answered from a previously completed request (`Idempotent-Replayed` response header). It is a `DefaultApi` method, so the call mirrors `createNotification`:
+
+```javascript
+const result = await client.createNotificationWithRetry(notification);
+console.log('Notification ID:', result.response.id, 'replayed:', result.wasReplayed);
+```
+
 ## Send a push notification by External ID
 
 Target specific users with the alias label `external_id` (snake_case). This is different from the notification-level `external_id` field, which is only for [idempotent requests](https://documentation.onesignal.com/docs/idempotent-notification-requests).

package/dist/apis/exception.d.ts

@@ -7,4 +7,5 @@ export declare class ApiException<T> extends Error {
     constructor(code: number, message: string, body: T, headers: {
         [key: string]: string;
     });
+    get errorMessages(): string[];
 }

package/dist/apis/exception.js

@@ -10,6 +10,49 @@ class ApiException extends Error {
         this.headers = headers;
         Object.setPrototypeOf(this, ApiException.prototype);
     }
+    get errorMessages() {
+        let parsed = this.body;
+        if (typeof parsed === "string") {
+            try {
+                parsed = JSON.parse(parsed);
+            }
+            catch {
+                return [];
+            }
+        }
+        if (parsed === null || typeof parsed !== "object") {
+            return [];
+        }
+        const errors = parsed.errors;
+        if (typeof errors === "string") {
+            return [errors];
+        }
+        if (Array.isArray(errors)) {
+            return errors
+                .map((e) => {
+                if (typeof e === "string") {
+                    return e;
+                }
+                if (e !== null && typeof e === "object") {
+                    const title = typeof e.title === "string" ? e.title : undefined;
+                    const code = typeof e.code === "string" ? e.code : (e.code != null ? String(e.code) : undefined);
+                    return title || code;
+                }
+                return undefined;
+            })
+                .filter((m) => typeof m === "string");
+        }
+        if (errors !== null && typeof errors === "object") {
+            return Object.keys(errors)
+                .map((key) => {
+                const value = errors[key];
+                const rendered = typeof value === "string" ? value : JSON.stringify(value);
+                return key + ": " + rendered;
+            })
+                .sort();
+        }
+        return [];
+    }
 }
 exports.ApiException = ApiException;
 //# sourceMappingURL=exception.js.map

package/dist/errors.d.ts

@@ -0,0 +1,8 @@
+export declare const OneSignalErrors: {
+    readonly INVALID_API_KEY: "Access denied.  Please include an 'Authorization: ...' header with a valid API key (https://documentation.onesignal.com/docs/en/keys-and-ids#api-keys).";
+    readonly NOTIFICATION_NOT_FOUND: "Notification not found";
+    readonly NO_SUBSCRIBERS: "All included players are not subscribed";
+    readonly NO_TARGETING_SPECIFIED: "You must include which players, segments, or tags you wish to send this notification to.";
+    readonly SERVICE_UNAVAILABLE: "Service temporarily unavailable";
+};
+export type OneSignalErrorMessage = typeof OneSignalErrors[keyof typeof OneSignalErrors];

package/dist/errors.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OneSignalErrors = void 0;
+exports.OneSignalErrors = {
+    INVALID_API_KEY: "Access denied.  Please include an 'Authorization: ...' header with a valid API key (https://documentation.onesignal.com/docs/en/keys-and-ids#api-keys).",
+    NOTIFICATION_NOT_FOUND: "Notification not found",
+    NO_SUBSCRIBERS: "All included players are not subscribed",
+    NO_TARGETING_SPECIFIED: "You must include which players, segments, or tags you wish to send this notification to.",
+    SERVICE_UNAVAILABLE: "Service temporarily unavailable",
+};
+//# sourceMappingURL=errors.js.map

package/dist/helpers.d.ts

@@ -0,0 +1,12 @@
+import { Configuration } from './configuration';
+import { Notification } from './models/Notification';
+import { CreateNotificationSuccessResponse } from './models/CreateNotificationSuccessResponse';
+export interface CreateNotificationWithRetryOptions {
+    maxRetries?: number;
+    baseDelayMs?: number;
+}
+export interface CreateNotificationWithRetryResult {
+    response: CreateNotificationSuccessResponse;
+    wasReplayed: boolean;
+}
+export declare function createNotificationWithRetry(configuration: Configuration, notification: Notification, options?: CreateNotificationWithRetryOptions): Promise<CreateNotificationWithRetryResult>;

package/dist/helpers.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNotificationWithRetry = void 0;
+const crypto_1 = require("crypto");
+const DefaultApi_1 = require("./apis/DefaultApi");
+const RETRYABLE_STATUSES = [429, 503];
+const MIN_BASE_DELAY_MS = 1000;
+const MAX_BASE_DELAY_MS = 60000;
+async function createNotificationWithRetry(configuration, notification, options) {
+    const maxRetries = options && options.maxRetries !== undefined ? options.maxRetries : 3;
+    const requestedBaseDelayMs = options && typeof options.baseDelayMs === 'number' && isFinite(options.baseDelayMs)
+        ? options.baseDelayMs
+        : MIN_BASE_DELAY_MS;
+    const baseDelayMs = Math.min(MAX_BASE_DELAY_MS, Math.max(MIN_BASE_DELAY_MS, requestedBaseDelayMs));
+    if (!notification.idempotency_key) {
+        notification.idempotency_key = generateUuidV4();
+    }
+    const requestFactory = new DefaultApi_1.DefaultApiRequestFactory(configuration);
+    const responseProcessor = new DefaultApi_1.DefaultApiResponseProcessor();
+    let attempt = 0;
+    while (true) {
+        let response;
+        try {
+            const requestContext = await requestFactory.createNotification(notification, configuration);
+            response = await configuration.httpApi.send(requestContext).toPromise();
+        }
+        catch (e) {
+            if (attempt >= maxRetries) {
+                throw e;
+            }
+            await sleep(baseDelayMs * Math.pow(2, attempt));
+            attempt++;
+            continue;
+        }
+        if (RETRYABLE_STATUSES.indexOf(response.httpStatusCode) !== -1 && attempt < maxRetries) {
+            await sleep(retryDelayMs(response.headers, attempt, baseDelayMs));
+            attempt++;
+            continue;
+        }
+        const body = await responseProcessor.createNotification(response);
+        return { response: body, wasReplayed: isReplayed(response.headers) };
+    }
+}
+exports.createNotificationWithRetry = createNotificationWithRetry;
+function headerValue(headers, name) {
+    const target = name.toLowerCase();
+    for (const key in headers) {
+        if (Object.prototype.hasOwnProperty.call(headers, key) && key.toLowerCase() === target) {
+            return headers[key];
+        }
+    }
+    return undefined;
+}
+function isReplayed(headers) {
+    const value = headerValue(headers, 'idempotent-replayed');
+    return value !== undefined && value.trim().toLowerCase() === 'true';
+}
+function retryDelayMs(headers, attempt, baseDelayMs) {
+    const retryAfter = headerValue(headers, 'retry-after');
+    if (retryAfter !== undefined && /^\d+$/.test(retryAfter.trim())) {
+        return parseInt(retryAfter.trim(), 10) * 1000;
+    }
+    return baseDelayMs * Math.pow(2, attempt);
+}
+function generateUuidV4() {
+    const bytes = (0, crypto_1.randomBytes)(16);
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = bytes.toString('hex');
+    return (hex.substring(0, 8) + '-' +
+        hex.substring(8, 12) + '-' +
+        hex.substring(12, 16) + '-' +
+        hex.substring(16, 20) + '-' +
+        hex.substring(20));
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=helpers.js.map

package/dist/index.d.ts

@@ -4,7 +4,9 @@ export * from "./models/all";
 export { createConfiguration } from "./configuration";
 export { Configuration, ConfigurationParameters } from "./configuration";
 export * from "./apis/exception";
+export * from "./helpers";
 export * from "./servers";
 export { RequiredError } from "./apis/baseapi";
 export { PromiseMiddleware as Middleware } from './middleware';
 export { PromiseDefaultApi as DefaultApi } from './types/PromiseAPI';
+export * from "./errors";

package/dist/index.js

@@ -21,9 +21,11 @@ __exportStar(require("./models/all"), exports);
 var configuration_1 = require("./configuration");
 Object.defineProperty(exports, "createConfiguration", { enumerable: true, get: function () { return configuration_1.createConfiguration; } });
 __exportStar(require("./apis/exception"), exports);
+__exportStar(require("./helpers"), exports);
 __exportStar(require("./servers"), exports);
 var baseapi_1 = require("./apis/baseapi");
 Object.defineProperty(exports, "RequiredError", { enumerable: true, get: function () { return baseapi_1.RequiredError; } });
 var PromiseAPI_1 = require("./types/PromiseAPI");
 Object.defineProperty(exports, "DefaultApi", { enumerable: true, get: function () { return PromiseAPI_1.PromiseDefaultApi; } });
+__exportStar(require("./errors"), exports);
 //# sourceMappingURL=index.js.map

package/dist/types/PromiseAPI.d.ts

@@ -1,4 +1,6 @@
+import * as models from '../models/all';
 import { Configuration } from '../configuration';
+import { CreateNotificationWithRetryOptions, CreateNotificationWithRetryResult } from '../helpers';
 import { ApiKeyTokensListResponse } from '../models/ApiKeyTokensListResponse';
 import { App } from '../models/App';
 import { CopyTemplateRequest } from '../models/CopyTemplateRequest';
@@ -37,7 +39,9 @@ import { UserIdentityBody } from '../models/UserIdentityBody';
 import { DefaultApiRequestFactory, DefaultApiResponseProcessor } from "../apis/DefaultApi";
 export declare class PromiseDefaultApi {
     private api;
+    private configuration;
     constructor(configuration: Configuration, requestFactory?: DefaultApiRequestFactory, responseProcessor?: DefaultApiResponseProcessor);
+    createNotificationWithRetry(notification: models.Notification, options?: CreateNotificationWithRetryOptions): Promise<CreateNotificationWithRetryResult>;
     cancelNotification(appId: string, notificationId: string, _options?: Configuration): Promise<GenericSuccessBoolResponse>;
     copyTemplateToApp(templateId: string, appId: string, copyTemplateRequest: CopyTemplateRequest, _options?: Configuration): Promise<TemplateResource>;
     createAlias(appId: string, aliasLabel: string, aliasId: string, userIdentityBody: UserIdentityBody, _options?: Configuration): Promise<UserIdentityBody>;

package/dist/types/PromiseAPI.js

@@ -1,10 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromiseDefaultApi = void 0;
+const helpers_1 = require("../helpers");
 const ObservableAPI_1 = require("./ObservableAPI");
 class PromiseDefaultApi {
     constructor(configuration, requestFactory, responseProcessor) {
         this.api = new ObservableAPI_1.ObservableDefaultApi(configuration, requestFactory, responseProcessor);
+        this.configuration = configuration;
+    }
+    createNotificationWithRetry(notification, options) {
+        return (0, helpers_1.createNotificationWithRetry)(this.configuration, notification, options);
     }
     cancelNotification(appId, notificationId, _options) {
         const result = this.api.cancelNotification(appId, notificationId, _options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onesignal/node-onesignal",
-  "version": "5.8.0",
+  "version": "5.9.0",
   "description": "OpenAPI client for @onesignal/node-onesignal",
   "author": "OpenAPI-Generator Contributors",
   "keywords": [