rokot-notification/lib/apns/plugin.js

Rokot - [Rocketmakers](http://www.rocketmakers.com/) TypeScript NodeJs Platform

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const apn_1 = require("apn");
const recipients_1 = require("../core/recipients");
const dispatchHandler_1 = require("../core/dispatchHandler");
function isNotificationFailureError(failure) {
    return !!failure.error;
}
exports.isNotificationFailureError = isNotificationFailureError;
function isNotificationFailureResponse(failure) {
    return !!failure.response;
}
exports.isNotificationFailureResponse = isNotificationFailureResponse;
class ApnsNotificationDispatchHandler extends dispatchHandler_1.NotificationDispatchHandler {
    constructor(logger, transport) {
        super("apns", logger, transport);
    }
}
exports.ApnsNotificationDispatchHandler = ApnsNotificationDispatchHandler;
function apnsInitializer(logger, options, recipientResolver = recipients_1.recipientTokenResolver) {
    return __awaiter(this, void 0, void 0, function* () {
        const transport = yield ApnsNotificationTransport.create(logger, options, recipientResolver);
        return new ApnsNotificationDispatchHandler(logger, transport);
    });
}
exports.apnsInitializer = apnsInitializer;
class ApnsNotificationTransport {
    constructor(logger, native, recipientResolver) {
        this.logger = logger;
        this.native = native;
        this.recipientResolver = recipientResolver;
        logger.trace("Created Apns Notification Transport");
    }
    static create(logger, options, recipientResolver) {
        return __awaiter(this, void 0, void 0, function* () {
            const provider = new apn_1.Provider(options);
            return new ApnsNotificationTransport(logger, provider, recipientResolver);
        });
    }
    resolveTokens(recipients) {
        return this.recipientResolver.find(recipients, "apns");
    }
    send(recipients, builder) {
        return __awaiter(this, void 0, void 0, function* () {
            const tokens = yield this.resolveTokens(recipients);
            if (!tokens || !tokens.length) {
                return { transport: "apns", error: "No Tokens Found" };
            }
            const native = new apn_1.Notification();
            builder && builder(native);
            return this.sendMessage(tokens, native);
        });
    }
    sendMessage(tokens, native) {
        return __awaiter(this, void 0, void 0, function* () {
            try {
                const resp = yield this.native.send(native, tokens);
                this.logger.trace("Apns send response: ", resp && JSON.stringify(resp, null, 2));
                return { transport: "apns", sent: resp.sent.map(s => s.device), failed: resp.failed.map(f => ({ token: f.device, error: f })), native: resp };
            }
            catch (e) {
                this.logger.error(e, "Apns was unable to send notification");
                return { transport: "apns", error: e };
            }
        });
    }
    shutdown() {
        this.native.shutdown();
    }
}
exports.ApnsNotificationTransport = ApnsNotificationTransport;