@onesignal/node-onesignal 5.8.0 → 5.10.0

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,16 @@
+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>;
+export type MessageSent = CreateNotificationSuccessResponse;
+export type MessageNotSent = CreateNotificationSuccessResponse;
+export declare function isMessageSent(response: CreateNotificationSuccessResponse): response is MessageSent;
+export declare function isMessageNotSent(response: CreateNotificationSuccessResponse): response is MessageNotSent;

package/dist/helpers.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMessageNotSent = exports.isMessageSent = 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));
+}
+function isMessageSent(response) {
+    return typeof response.id === 'string' && response.id.length > 0;
+}
+exports.isMessageSent = isMessageSent;
+function isMessageNotSent(response) {
+    return !isMessageSent(response);
+}
+exports.isMessageNotSent = isMessageNotSent;
+//# 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/models/NotificationSlice.d.ts

@@ -3,6 +3,8 @@ export declare class NotificationSlice {
     'total_count'?: number;
     'offset'?: number;
     'limit'?: number;
+    'time_offset'?: string;
+    'next_time_offset'?: string;
     'notifications'?: Array<NotificationWithMeta>;
     static readonly discriminator: string | undefined;
     static readonly attributeTypeMap: Array<{

package/dist/models/NotificationSlice.js

@@ -29,6 +29,18 @@ NotificationSlice.attributeTypeMap = [
         "type": "number",
         "format": ""
     },
+    {
+        "name": "time_offset",
+        "baseName": "time_offset",
+        "type": "string",
+        "format": ""
+    },
+    {
+        "name": "next_time_offset",
+        "baseName": "next_time_offset",
+        "type": "string",
+        "format": ""
+    },
     {
         "name": "notifications",
         "baseName": "notifications",

package/dist/types/ObjectParamAPI.d.ts

@@ -148,6 +148,7 @@ export interface DefaultApiGetNotificationsRequest {
     limit?: number;
     offset?: number;
     kind?: 0 | 1 | 3;
+    timeOffset?: string;
 }
 export interface DefaultApiGetOutcomesRequest {
     appId: string;

package/dist/types/ObjectParamAPI.js

@@ -85,7 +85,7 @@ class ObjectDefaultApi {
         return this.api.getNotificationHistory(param.notificationId, param.getNotificationHistoryRequestBody, options).toPromise();
     }
     getNotifications(param, options) {
-        return this.api.getNotifications(param.appId, param.limit, param.offset, param.kind, options).toPromise();
+        return this.api.getNotifications(param.appId, param.limit, param.offset, param.kind, param.timeOffset, options).toPromise();
     }
     getOutcomes(param, options) {
         return this.api.getOutcomes(param.appId, param.outcomeNames, param.outcomeNames2, param.outcomeTimeRange, param.outcomePlatforms, param.outcomeAttribution, options).toPromise();

package/dist/types/ObservableAPI.d.ts

@@ -67,7 +67,7 @@ export declare class ObservableDefaultApi {
     getApps(_options?: Configuration): Observable<Array<App>>;
     getNotification(appId: string, notificationId: string, _options?: Configuration): Observable<NotificationWithMeta>;
     getNotificationHistory(notificationId: string, getNotificationHistoryRequestBody: GetNotificationHistoryRequestBody, _options?: Configuration): Observable<NotificationHistorySuccessResponse>;
-    getNotifications(appId: string, limit?: number, offset?: number, kind?: 0 | 1 | 3, _options?: Configuration): Observable<NotificationSlice>;
+    getNotifications(appId: string, limit?: number, offset?: number, kind?: 0 | 1 | 3, timeOffset?: string, _options?: Configuration): Observable<NotificationSlice>;
     getOutcomes(appId: string, outcomeNames: string, outcomeNames2?: string, outcomeTimeRange?: string, outcomePlatforms?: string, outcomeAttribution?: string, _options?: Configuration): Observable<OutcomesData>;
     getSegments(appId: string, offset?: number, limit?: number, _options?: Configuration): Observable<GetSegmentsSuccessResponse>;
     getUser(appId: string, aliasLabel: string, aliasId: string, _options?: Configuration): Observable<User>;

package/dist/types/ObservableAPI.js

@@ -400,8 +400,8 @@ class ObservableDefaultApi {
             return middlewarePostObservable.pipe((0, rxjsStub_2.map)((rsp) => this.responseProcessor.getNotificationHistory(rsp)));
         }));
     }
-    getNotifications(appId, limit, offset, kind, _options) {
-        const requestContextPromise = this.requestFactory.getNotifications(appId, limit, offset, kind, _options);
+    getNotifications(appId, limit, offset, kind, timeOffset, _options) {
+        const requestContextPromise = this.requestFactory.getNotifications(appId, limit, offset, kind, timeOffset, _options);
         let middlewarePreObservable = (0, rxjsStub_1.from)(requestContextPromise);
         for (let middleware of this.configuration.middleware) {
             middlewarePreObservable = middlewarePreObservable.pipe((0, rxjsStub_2.mergeMap)((ctx) => middleware.pre(ctx)));

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>;
@@ -64,7 +68,7 @@ export declare class PromiseDefaultApi {
     getApps(_options?: Configuration): Promise<Array<App>>;
     getNotification(appId: string, notificationId: string, _options?: Configuration): Promise<NotificationWithMeta>;
     getNotificationHistory(notificationId: string, getNotificationHistoryRequestBody: GetNotificationHistoryRequestBody, _options?: Configuration): Promise<NotificationHistorySuccessResponse>;
-    getNotifications(appId: string, limit?: number, offset?: number, kind?: 0 | 1 | 3, _options?: Configuration): Promise<NotificationSlice>;
+    getNotifications(appId: string, limit?: number, offset?: number, kind?: 0 | 1 | 3, timeOffset?: string, _options?: Configuration): Promise<NotificationSlice>;
     getOutcomes(appId: string, outcomeNames: string, outcomeNames2?: string, outcomeTimeRange?: string, outcomePlatforms?: string, outcomeAttribution?: string, _options?: Configuration): Promise<OutcomesData>;
     getSegments(appId: string, offset?: number, limit?: number, _options?: Configuration): Promise<GetSegmentsSuccessResponse>;
     getUser(appId: string, aliasLabel: string, aliasId: string, _options?: Configuration): Promise<User>;

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);
@@ -110,8 +115,8 @@ class PromiseDefaultApi {
         const result = this.api.getNotificationHistory(notificationId, getNotificationHistoryRequestBody, _options);
         return result.toPromise();
     }
-    getNotifications(appId, limit, offset, kind, _options) {
-        const result = this.api.getNotifications(appId, limit, offset, kind, _options);
+    getNotifications(appId, limit, offset, kind, timeOffset, _options) {
+        const result = this.api.getNotifications(appId, limit, offset, kind, timeOffset, _options);
         return result.toPromise();
     }
     getOutcomes(appId, outcomeNames, outcomeNames2, outcomeTimeRange, outcomePlatforms, outcomeAttribution, _options) {

package/package.json

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