kannon.js 0.1.0

package/lib/kannon.d.ts

@@ -0,0 +1,13 @@
+import * as proto from './proto/kannon/mailer/apiv1/mailerapiv1';
+import { Recipient } from './proto/kannon/mailer/types/send';
+export declare class KannonCli {
+    private readonly senderEmail;
+    private readonly senderAlias;
+    private readonly token;
+    private readonly client;
+    constructor(host: string, skipTLS: boolean, senderEmail: string, senderAlias: string, token: string);
+    sendMail(recipients: Recipient[], subject: string, html: string, scheduledTime?: Date): Promise<proto.SendRes>;
+    sendMailTemplate(recipients: Recipient[], subject: string, templateId: string, scheduledTime?: Date): Promise<proto.SendRes>;
+    private meta;
+    private sender;
+}

package/lib/kannon.js

@@ -0,0 +1,89 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import * as proto from './proto/kannon/mailer/apiv1/mailerapiv1';
+import * as grpc from '@grpc/grpc-js';
+import { promisifyAll } from './utils/grpc-promisify';
+var KannonCli = /** @class */ (function () {
+    function KannonCli(host, skipTLS, senderEmail, senderAlias, token) {
+        this.senderEmail = senderEmail;
+        this.senderAlias = senderAlias;
+        this.token = token;
+        var credentials = skipTLS ? grpc.credentials.createInsecure() : grpc.credentials.createSsl();
+        this.client = promisifyAll(new proto.MailerClient(host, credentials));
+    }
+    KannonCli.prototype.sendMail = function (recipients, subject, html, scheduledTime) {
+        if (scheduledTime === void 0) { scheduledTime = new Date(); }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.client.sendHtml({
+                        html: html,
+                        sender: this.sender(),
+                        subject: subject,
+                        scheduledTime: scheduledTime,
+                        recipients: recipients,
+                    }, this.meta())];
+            });
+        });
+    };
+    KannonCli.prototype.sendMailTemplate = function (recipients, subject, templateId, scheduledTime) {
+        if (scheduledTime === void 0) { scheduledTime = new Date(); }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.client.sendTemplate({
+                        templateId: templateId,
+                        sender: this.sender(),
+                        subject: subject,
+                        scheduledTime: scheduledTime,
+                        recipients: recipients,
+                    }, this.meta())];
+            });
+        });
+    };
+    KannonCli.prototype.meta = function () {
+        var meta = new grpc.Metadata();
+        meta.add('authorization', 'Basic ' + this.token);
+        return meta;
+    };
+    KannonCli.prototype.sender = function () {
+        return {
+            alias: this.senderAlias,
+            email: this.senderEmail,
+        };
+    };
+    return KannonCli;
+}());
+export { KannonCli };

package/lib/proto/google/protobuf/timestamp.d.ts

@@ -0,0 +1,132 @@
+import _m0 from 'protobufjs/minimal';
+export declare const protobufPackage = "google.protobuf";
+/**
+ * A Timestamp represents a point in time independent of any time zone or local
+ * calendar, encoded as a count of seconds and fractions of seconds at
+ * nanosecond resolution. The count is relative to an epoch at UTC midnight on
+ * January 1, 1970, in the proleptic Gregorian calendar which extends the
+ * Gregorian calendar backwards to year one.
+ *
+ * All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
+ * second table is needed for interpretation, using a [24-hour linear
+ * smear](https://developers.google.com/time/smear).
+ *
+ * The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
+ * restricting to that range, we ensure that we can convert to and from [RFC
+ * 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
+ *
+ * # Examples
+ *
+ * Example 1: Compute Timestamp from POSIX `time()`.
+ *
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds(time(NULL));
+ *     timestamp.set_nanos(0);
+ *
+ * Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+ *
+ *     struct timeval tv;
+ *     gettimeofday(&tv, NULL);
+ *
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds(tv.tv_sec);
+ *     timestamp.set_nanos(tv.tv_usec * 1000);
+ *
+ * Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+ *
+ *     FILETIME ft;
+ *     GetSystemTimeAsFileTime(&ft);
+ *     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+ *
+ *     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+ *     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+ *     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+ *
+ * Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+ *
+ *     long millis = System.currentTimeMillis();
+ *
+ *     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+ *         .setNanos((int) ((millis % 1000) * 1000000)).build();
+ *
+ * Example 5: Compute Timestamp from Java `Instant.now()`.
+ *
+ *     Instant now = Instant.now();
+ *
+ *     Timestamp timestamp =
+ *         Timestamp.newBuilder().setSeconds(now.getEpochSecond())
+ *             .setNanos(now.getNano()).build();
+ *
+ * Example 6: Compute Timestamp from current time in Python.
+ *
+ *     timestamp = Timestamp()
+ *     timestamp.GetCurrentTime()
+ *
+ * # JSON Mapping
+ *
+ * In JSON format, the Timestamp type is encoded as a string in the
+ * [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
+ * format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
+ * where {year} is always expressed using four digits while {month}, {day},
+ * {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
+ * seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
+ * are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
+ * is required. A proto3 JSON serializer should always use UTC (as indicated by
+ * "Z") when printing the Timestamp type and a proto3 JSON parser should be
+ * able to accept both UTC and other timezones (as indicated by an offset).
+ *
+ * For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
+ * 01:30 UTC on January 15, 2017.
+ *
+ * In JavaScript, one can convert a Date object to this format using the
+ * standard
+ * [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
+ * method. In Python, a standard `datetime.datetime` object can be converted
+ * to this format using
+ * [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
+ * the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
+ * the Joda Time's [`ISODateTimeFormat.dateTime()`](
+ * http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D
+ * ) to obtain a formatter capable of generating timestamps in this format.
+ */
+export interface Timestamp {
+    /**
+     * Represents seconds of UTC time since Unix epoch
+     * 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
+     * 9999-12-31T23:59:59Z inclusive.
+     */
+    seconds: number;
+    /**
+     * Non-negative fractions of a second at nanosecond resolution. Negative
+     * second values with fractions must still have non-negative nanos values
+     * that count forward in time. Must be from 0 to 999,999,999
+     * inclusive.
+     */
+    nanos: number;
+}
+export declare const Timestamp: {
+    encode(message: Timestamp, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Timestamp;
+    fromJSON(object: any): Timestamp;
+    toJSON(message: Timestamp): unknown;
+    fromPartial<I extends {
+        seconds?: number | undefined;
+        nanos?: number | undefined;
+    } & {
+        seconds?: number | undefined;
+        nanos?: number | undefined;
+    } & { [K in Exclude<keyof I, keyof Timestamp>]: never; }>(object: I): Timestamp;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export {};

package/lib/proto/google/protobuf/timestamp.js

@@ -0,0 +1,86 @@
+/* eslint-disable */
+import Long from 'long';
+import _m0 from 'protobufjs/minimal';
+export var protobufPackage = 'google.protobuf';
+function createBaseTimestamp() {
+    return { seconds: 0, nanos: 0 };
+}
+export var Timestamp = {
+    encode: function (message, writer) {
+        if (writer === void 0) { writer = _m0.Writer.create(); }
+        if (message.seconds !== 0) {
+            writer.uint32(8).int64(message.seconds);
+        }
+        if (message.nanos !== 0) {
+            writer.uint32(16).int32(message.nanos);
+        }
+        return writer;
+    },
+    decode: function (input, length) {
+        var reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        var end = length === undefined ? reader.len : reader.pos + length;
+        var message = createBaseTimestamp();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.seconds = longToNumber(reader.int64());
+                    break;
+                case 2:
+                    message.nanos = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON: function (object) {
+        return {
+            seconds: isSet(object.seconds) ? Number(object.seconds) : 0,
+            nanos: isSet(object.nanos) ? Number(object.nanos) : 0,
+        };
+    },
+    toJSON: function (message) {
+        var obj = {};
+        message.seconds !== undefined && (obj.seconds = Math.round(message.seconds));
+        message.nanos !== undefined && (obj.nanos = Math.round(message.nanos));
+        return obj;
+    },
+    fromPartial: function (object) {
+        var _a, _b;
+        var message = createBaseTimestamp();
+        message.seconds = (_a = object.seconds) !== null && _a !== void 0 ? _a : 0;
+        message.nanos = (_b = object.nanos) !== null && _b !== void 0 ? _b : 0;
+        return message;
+    },
+};
+var tsProtoGlobalThis = (function () {
+    if (typeof globalThis !== 'undefined') {
+        return globalThis;
+    }
+    if (typeof self !== 'undefined') {
+        return self;
+    }
+    if (typeof window !== 'undefined') {
+        return window;
+    }
+    if (typeof global !== 'undefined') {
+        return global;
+    }
+    throw 'Unable to locate global object';
+})();
+function longToNumber(long) {
+    if (long.gt(Number.MAX_SAFE_INTEGER)) {
+        throw new tsProtoGlobalThis.Error('Value is larger than Number.MAX_SAFE_INTEGER');
+    }
+    return long.toNumber();
+}
+if (_m0.util.Long !== Long) {
+    _m0.util.Long = Long;
+    _m0.configure();
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/lib/proto/kannon/mailer/apiv1/mailerapiv1.d.ts

@@ -0,0 +1,197 @@
+/// <reference types="node" />
+import { CallOptions, ChannelCredentials, Client, ClientOptions, ClientUnaryCall, handleUnaryCall, Metadata, ServiceError, UntypedServiceImplementation } from '@grpc/grpc-js';
+import _m0 from 'protobufjs/minimal';
+import { Recipient, Sender } from '../types/send';
+export declare const protobufPackage = "pkg.kannon.mailer.apiv1";
+export interface SendHTMLReq {
+    sender: Sender | undefined;
+    subject: string;
+    html: string;
+    scheduledTime?: Date | undefined;
+    recipients: Recipient[];
+}
+export interface SendTemplateReq {
+    sender: Sender | undefined;
+    subject: string;
+    templateId: string;
+    scheduledTime?: Date | undefined;
+    recipients: Recipient[];
+}
+export interface SendRes {
+    messageId: string;
+    templateId: string;
+    scheduledTime: Date | undefined;
+}
+export declare const SendHTMLReq: {
+    encode(message: SendHTMLReq, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SendHTMLReq;
+    fromJSON(object: any): SendHTMLReq;
+    toJSON(message: SendHTMLReq): unknown;
+    fromPartial<I extends {
+        sender?: {
+            email?: string | undefined;
+            alias?: string | undefined;
+        } | undefined;
+        subject?: string | undefined;
+        html?: string | undefined;
+        scheduledTime?: Date | undefined;
+        recipients?: {
+            email?: string | undefined;
+            fields?: {
+                [x: string]: string | undefined;
+            } | undefined;
+        }[] | undefined;
+    } & {
+        sender?: ({
+            email?: string | undefined;
+            alias?: string | undefined;
+        } & {
+            email?: string | undefined;
+            alias?: string | undefined;
+        } & { [K in Exclude<keyof I["sender"], keyof Sender>]: never; }) | undefined;
+        subject?: string | undefined;
+        html?: string | undefined;
+        scheduledTime?: Date | undefined;
+        recipients?: ({
+            email?: string | undefined;
+            fields?: {
+                [x: string]: string | undefined;
+            } | undefined;
+        }[] & ({
+            email?: string | undefined;
+            fields?: {
+                [x: string]: string | undefined;
+            } | undefined;
+        } & {
+            email?: string | undefined;
+            fields?: ({
+                [x: string]: string | undefined;
+            } & {
+                [x: string]: string | undefined;
+            } & { [K_1 in Exclude<keyof I["recipients"][number]["fields"], string | number>]: never; }) | undefined;
+        } & { [K_2 in Exclude<keyof I["recipients"][number], keyof Recipient>]: never; })[] & { [K_3 in Exclude<keyof I["recipients"], keyof {
+            email?: string | undefined;
+            fields?: {
+                [x: string]: string | undefined;
+            } | undefined;
+        }[]>]: never; }) | undefined;
+    } & { [K_4 in Exclude<keyof I, keyof SendHTMLReq>]: never; }>(object: I): SendHTMLReq;
+};
+export declare const SendTemplateReq: {
+    encode(message: SendTemplateReq, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SendTemplateReq;
+    fromJSON(object: any): SendTemplateReq;
+    toJSON(message: SendTemplateReq): unknown;
+    fromPartial<I extends {
+        sender?: {
+            email?: string | undefined;
+            alias?: string | undefined;
+        } | undefined;
+        subject?: string | undefined;
+        templateId?: string | undefined;
+        scheduledTime?: Date | undefined;
+        recipients?: {
+            email?: string | undefined;
+            fields?: {
+                [x: string]: string | undefined;
+            } | undefined;
+        }[] | undefined;
+    } & {
+        sender?: ({
+            email?: string | undefined;
+            alias?: string | undefined;
+        } & {
+            email?: string | undefined;
+            alias?: string | undefined;
+        } & { [K in Exclude<keyof I["sender"], keyof Sender>]: never; }) | undefined;
+        subject?: string | undefined;
+        templateId?: string | undefined;
+        scheduledTime?: Date | undefined;
+        recipients?: ({
+            email?: string | undefined;
+            fields?: {
+                [x: string]: string | undefined;
+            } | undefined;
+        }[] & ({
+            email?: string | undefined;
+            fields?: {
+                [x: string]: string | undefined;
+            } | undefined;
+        } & {
+            email?: string | undefined;
+            fields?: ({
+                [x: string]: string | undefined;
+            } & {
+                [x: string]: string | undefined;
+            } & { [K_1 in Exclude<keyof I["recipients"][number]["fields"], string | number>]: never; }) | undefined;
+        } & { [K_2 in Exclude<keyof I["recipients"][number], keyof Recipient>]: never; })[] & { [K_3 in Exclude<keyof I["recipients"], keyof {
+            email?: string | undefined;
+            fields?: {
+                [x: string]: string | undefined;
+            } | undefined;
+        }[]>]: never; }) | undefined;
+    } & { [K_4 in Exclude<keyof I, keyof SendTemplateReq>]: never; }>(object: I): SendTemplateReq;
+};
+export declare const SendRes: {
+    encode(message: SendRes, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SendRes;
+    fromJSON(object: any): SendRes;
+    toJSON(message: SendRes): unknown;
+    fromPartial<I extends {
+        messageId?: string | undefined;
+        templateId?: string | undefined;
+        scheduledTime?: Date | undefined;
+    } & {
+        messageId?: string | undefined;
+        templateId?: string | undefined;
+        scheduledTime?: Date | undefined;
+    } & { [K in Exclude<keyof I, keyof SendRes>]: never; }>(object: I): SendRes;
+};
+export type MailerService = typeof MailerService;
+export declare const MailerService: {
+    readonly sendHtml: {
+        readonly path: "/pkg.kannon.mailer.apiv1.Mailer/SendHTML";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: SendHTMLReq) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => SendHTMLReq;
+        readonly responseSerialize: (value: SendRes) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => SendRes;
+    };
+    readonly sendTemplate: {
+        readonly path: "/pkg.kannon.mailer.apiv1.Mailer/SendTemplate";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: SendTemplateReq) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => SendTemplateReq;
+        readonly responseSerialize: (value: SendRes) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => SendRes;
+    };
+};
+export interface MailerServer extends UntypedServiceImplementation {
+    sendHtml: handleUnaryCall<SendHTMLReq, SendRes>;
+    sendTemplate: handleUnaryCall<SendTemplateReq, SendRes>;
+}
+export interface MailerClient extends Client {
+    sendHtml(request: SendHTMLReq, callback: (error: ServiceError | null, response: SendRes) => void): ClientUnaryCall;
+    sendHtml(request: SendHTMLReq, metadata: Metadata, callback: (error: ServiceError | null, response: SendRes) => void): ClientUnaryCall;
+    sendHtml(request: SendHTMLReq, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: SendRes) => void): ClientUnaryCall;
+    sendTemplate(request: SendTemplateReq, callback: (error: ServiceError | null, response: SendRes) => void): ClientUnaryCall;
+    sendTemplate(request: SendTemplateReq, metadata: Metadata, callback: (error: ServiceError | null, response: SendRes) => void): ClientUnaryCall;
+    sendTemplate(request: SendTemplateReq, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: SendRes) => void): ClientUnaryCall;
+}
+export declare const MailerClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): MailerClient;
+    service: typeof MailerService;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export {};

package/lib/proto/kannon/mailer/apiv1/mailerapiv1.js

@@ -0,0 +1,290 @@
+/* eslint-disable */
+import { makeGenericClientConstructor, } from '@grpc/grpc-js';
+import _m0 from 'protobufjs/minimal';
+import { Timestamp } from '../../../google/protobuf/timestamp';
+import { Recipient, Sender } from '../types/send';
+export var protobufPackage = 'pkg.kannon.mailer.apiv1';
+function createBaseSendHTMLReq() {
+    return { sender: undefined, subject: '', html: '', scheduledTime: undefined, recipients: [] };
+}
+export var SendHTMLReq = {
+    encode: function (message, writer) {
+        if (writer === void 0) { writer = _m0.Writer.create(); }
+        if (message.sender !== undefined) {
+            Sender.encode(message.sender, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.subject !== '') {
+            writer.uint32(26).string(message.subject);
+        }
+        if (message.html !== '') {
+            writer.uint32(34).string(message.html);
+        }
+        if (message.scheduledTime !== undefined) {
+            Timestamp.encode(toTimestamp(message.scheduledTime), writer.uint32(42).fork()).ldelim();
+        }
+        for (var _i = 0, _a = message.recipients; _i < _a.length; _i++) {
+            var v = _a[_i];
+            Recipient.encode(v, writer.uint32(50).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode: function (input, length) {
+        var reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        var end = length === undefined ? reader.len : reader.pos + length;
+        var message = createBaseSendHTMLReq();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sender = Sender.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.subject = reader.string();
+                    break;
+                case 4:
+                    message.html = reader.string();
+                    break;
+                case 5:
+                    message.scheduledTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+                    break;
+                case 6:
+                    message.recipients.push(Recipient.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON: function (object) {
+        return {
+            sender: isSet(object.sender) ? Sender.fromJSON(object.sender) : undefined,
+            subject: isSet(object.subject) ? String(object.subject) : '',
+            html: isSet(object.html) ? String(object.html) : '',
+            scheduledTime: isSet(object.scheduledTime) ? fromJsonTimestamp(object.scheduledTime) : undefined,
+            recipients: Array.isArray(object === null || object === void 0 ? void 0 : object.recipients) ? object.recipients.map(function (e) { return Recipient.fromJSON(e); }) : [],
+        };
+    },
+    toJSON: function (message) {
+        var obj = {};
+        message.sender !== undefined && (obj.sender = message.sender ? Sender.toJSON(message.sender) : undefined);
+        message.subject !== undefined && (obj.subject = message.subject);
+        message.html !== undefined && (obj.html = message.html);
+        message.scheduledTime !== undefined && (obj.scheduledTime = message.scheduledTime.toISOString());
+        if (message.recipients) {
+            obj.recipients = message.recipients.map(function (e) { return (e ? Recipient.toJSON(e) : undefined); });
+        }
+        else {
+            obj.recipients = [];
+        }
+        return obj;
+    },
+    fromPartial: function (object) {
+        var _a, _b, _c, _d;
+        var message = createBaseSendHTMLReq();
+        message.sender =
+            object.sender !== undefined && object.sender !== null ? Sender.fromPartial(object.sender) : undefined;
+        message.subject = (_a = object.subject) !== null && _a !== void 0 ? _a : '';
+        message.html = (_b = object.html) !== null && _b !== void 0 ? _b : '';
+        message.scheduledTime = (_c = object.scheduledTime) !== null && _c !== void 0 ? _c : undefined;
+        message.recipients = ((_d = object.recipients) === null || _d === void 0 ? void 0 : _d.map(function (e) { return Recipient.fromPartial(e); })) || [];
+        return message;
+    },
+};
+function createBaseSendTemplateReq() {
+    return { sender: undefined, subject: '', templateId: '', scheduledTime: undefined, recipients: [] };
+}
+export var SendTemplateReq = {
+    encode: function (message, writer) {
+        if (writer === void 0) { writer = _m0.Writer.create(); }
+        if (message.sender !== undefined) {
+            Sender.encode(message.sender, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.subject !== '') {
+            writer.uint32(26).string(message.subject);
+        }
+        if (message.templateId !== '') {
+            writer.uint32(34).string(message.templateId);
+        }
+        if (message.scheduledTime !== undefined) {
+            Timestamp.encode(toTimestamp(message.scheduledTime), writer.uint32(42).fork()).ldelim();
+        }
+        for (var _i = 0, _a = message.recipients; _i < _a.length; _i++) {
+            var v = _a[_i];
+            Recipient.encode(v, writer.uint32(50).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode: function (input, length) {
+        var reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        var end = length === undefined ? reader.len : reader.pos + length;
+        var message = createBaseSendTemplateReq();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sender = Sender.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.subject = reader.string();
+                    break;
+                case 4:
+                    message.templateId = reader.string();
+                    break;
+                case 5:
+                    message.scheduledTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+                    break;
+                case 6:
+                    message.recipients.push(Recipient.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON: function (object) {
+        return {
+            sender: isSet(object.sender) ? Sender.fromJSON(object.sender) : undefined,
+            subject: isSet(object.subject) ? String(object.subject) : '',
+            templateId: isSet(object.templateId) ? String(object.templateId) : '',
+            scheduledTime: isSet(object.scheduledTime) ? fromJsonTimestamp(object.scheduledTime) : undefined,
+            recipients: Array.isArray(object === null || object === void 0 ? void 0 : object.recipients) ? object.recipients.map(function (e) { return Recipient.fromJSON(e); }) : [],
+        };
+    },
+    toJSON: function (message) {
+        var obj = {};
+        message.sender !== undefined && (obj.sender = message.sender ? Sender.toJSON(message.sender) : undefined);
+        message.subject !== undefined && (obj.subject = message.subject);
+        message.templateId !== undefined && (obj.templateId = message.templateId);
+        message.scheduledTime !== undefined && (obj.scheduledTime = message.scheduledTime.toISOString());
+        if (message.recipients) {
+            obj.recipients = message.recipients.map(function (e) { return (e ? Recipient.toJSON(e) : undefined); });
+        }
+        else {
+            obj.recipients = [];
+        }
+        return obj;
+    },
+    fromPartial: function (object) {
+        var _a, _b, _c, _d;
+        var message = createBaseSendTemplateReq();
+        message.sender =
+            object.sender !== undefined && object.sender !== null ? Sender.fromPartial(object.sender) : undefined;
+        message.subject = (_a = object.subject) !== null && _a !== void 0 ? _a : '';
+        message.templateId = (_b = object.templateId) !== null && _b !== void 0 ? _b : '';
+        message.scheduledTime = (_c = object.scheduledTime) !== null && _c !== void 0 ? _c : undefined;
+        message.recipients = ((_d = object.recipients) === null || _d === void 0 ? void 0 : _d.map(function (e) { return Recipient.fromPartial(e); })) || [];
+        return message;
+    },
+};
+function createBaseSendRes() {
+    return { messageId: '', templateId: '', scheduledTime: undefined };
+}
+export var SendRes = {
+    encode: function (message, writer) {
+        if (writer === void 0) { writer = _m0.Writer.create(); }
+        if (message.messageId !== '') {
+            writer.uint32(10).string(message.messageId);
+        }
+        if (message.templateId !== '') {
+            writer.uint32(18).string(message.templateId);
+        }
+        if (message.scheduledTime !== undefined) {
+            Timestamp.encode(toTimestamp(message.scheduledTime), writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode: function (input, length) {
+        var reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        var end = length === undefined ? reader.len : reader.pos + length;
+        var message = createBaseSendRes();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.messageId = reader.string();
+                    break;
+                case 2:
+                    message.templateId = reader.string();
+                    break;
+                case 3:
+                    message.scheduledTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON: function (object) {
+        return {
+            messageId: isSet(object.messageId) ? String(object.messageId) : '',
+            templateId: isSet(object.templateId) ? String(object.templateId) : '',
+            scheduledTime: isSet(object.scheduledTime) ? fromJsonTimestamp(object.scheduledTime) : undefined,
+        };
+    },
+    toJSON: function (message) {
+        var obj = {};
+        message.messageId !== undefined && (obj.messageId = message.messageId);
+        message.templateId !== undefined && (obj.templateId = message.templateId);
+        message.scheduledTime !== undefined && (obj.scheduledTime = message.scheduledTime.toISOString());
+        return obj;
+    },
+    fromPartial: function (object) {
+        var _a, _b, _c;
+        var message = createBaseSendRes();
+        message.messageId = (_a = object.messageId) !== null && _a !== void 0 ? _a : '';
+        message.templateId = (_b = object.templateId) !== null && _b !== void 0 ? _b : '';
+        message.scheduledTime = (_c = object.scheduledTime) !== null && _c !== void 0 ? _c : undefined;
+        return message;
+    },
+};
+export var MailerService = {
+    sendHtml: {
+        path: '/pkg.kannon.mailer.apiv1.Mailer/SendHTML',
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: function (value) { return Buffer.from(SendHTMLReq.encode(value).finish()); },
+        requestDeserialize: function (value) { return SendHTMLReq.decode(value); },
+        responseSerialize: function (value) { return Buffer.from(SendRes.encode(value).finish()); },
+        responseDeserialize: function (value) { return SendRes.decode(value); },
+    },
+    sendTemplate: {
+        path: '/pkg.kannon.mailer.apiv1.Mailer/SendTemplate',
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: function (value) { return Buffer.from(SendTemplateReq.encode(value).finish()); },
+        requestDeserialize: function (value) { return SendTemplateReq.decode(value); },
+        responseSerialize: function (value) { return Buffer.from(SendRes.encode(value).finish()); },
+        responseDeserialize: function (value) { return SendRes.decode(value); },
+    },
+};
+export var MailerClient = makeGenericClientConstructor(MailerService, 'pkg.kannon.mailer.apiv1.Mailer');
+function toTimestamp(date) {
+    var seconds = date.getTime() / 1000;
+    var nanos = (date.getTime() % 1000) * 1000000;
+    return { seconds: seconds, nanos: nanos };
+}
+function fromTimestamp(t) {
+    var millis = t.seconds * 1000;
+    millis += t.nanos / 1000000;
+    return new Date(millis);
+}
+function fromJsonTimestamp(o) {
+    if (o instanceof Date) {
+        return o;
+    }
+    else if (typeof o === 'string') {
+        return new Date(o);
+    }
+    else {
+        return fromTimestamp(Timestamp.fromJSON(o));
+    }
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/lib/proto/kannon/mailer/types/email.d.ts

@@ -0,0 +1,42 @@
+import _m0 from 'protobufjs/minimal';
+export declare const protobufPackage = "pkg.kannon.mailer.types";
+export interface EmailToSend {
+    emailId: string;
+    from: string;
+    to: string;
+    returnPath: string;
+    body: Uint8Array;
+    shouldRetry: boolean;
+}
+export declare const EmailToSend: {
+    encode(message: EmailToSend, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): EmailToSend;
+    fromJSON(object: any): EmailToSend;
+    toJSON(message: EmailToSend): unknown;
+    fromPartial<I extends {
+        emailId?: string | undefined;
+        from?: string | undefined;
+        to?: string | undefined;
+        returnPath?: string | undefined;
+        body?: Uint8Array | undefined;
+        shouldRetry?: boolean | undefined;
+    } & {
+        emailId?: string | undefined;
+        from?: string | undefined;
+        to?: string | undefined;
+        returnPath?: string | undefined;
+        body?: Uint8Array | undefined;
+        shouldRetry?: boolean | undefined;
+    } & { [K in Exclude<keyof I, keyof EmailToSend>]: never; }>(object: I): EmailToSend;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export {};

package/lib/proto/kannon/mailer/types/email.js

@@ -0,0 +1,137 @@
+/* eslint-disable */
+import _m0 from 'protobufjs/minimal';
+export var protobufPackage = 'pkg.kannon.mailer.types';
+function createBaseEmailToSend() {
+    return { emailId: '', from: '', to: '', returnPath: '', body: new Uint8Array(), shouldRetry: false };
+}
+export var EmailToSend = {
+    encode: function (message, writer) {
+        if (writer === void 0) { writer = _m0.Writer.create(); }
+        if (message.emailId !== '') {
+            writer.uint32(10).string(message.emailId);
+        }
+        if (message.from !== '') {
+            writer.uint32(18).string(message.from);
+        }
+        if (message.to !== '') {
+            writer.uint32(26).string(message.to);
+        }
+        if (message.returnPath !== '') {
+            writer.uint32(34).string(message.returnPath);
+        }
+        if (message.body.length !== 0) {
+            writer.uint32(42).bytes(message.body);
+        }
+        if (message.shouldRetry === true) {
+            writer.uint32(48).bool(message.shouldRetry);
+        }
+        return writer;
+    },
+    decode: function (input, length) {
+        var reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        var end = length === undefined ? reader.len : reader.pos + length;
+        var message = createBaseEmailToSend();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.emailId = reader.string();
+                    break;
+                case 2:
+                    message.from = reader.string();
+                    break;
+                case 3:
+                    message.to = reader.string();
+                    break;
+                case 4:
+                    message.returnPath = reader.string();
+                    break;
+                case 5:
+                    message.body = reader.bytes();
+                    break;
+                case 6:
+                    message.shouldRetry = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON: function (object) {
+        return {
+            emailId: isSet(object.emailId) ? String(object.emailId) : '',
+            from: isSet(object.from) ? String(object.from) : '',
+            to: isSet(object.to) ? String(object.to) : '',
+            returnPath: isSet(object.returnPath) ? String(object.returnPath) : '',
+            body: isSet(object.body) ? bytesFromBase64(object.body) : new Uint8Array(),
+            shouldRetry: isSet(object.shouldRetry) ? Boolean(object.shouldRetry) : false,
+        };
+    },
+    toJSON: function (message) {
+        var obj = {};
+        message.emailId !== undefined && (obj.emailId = message.emailId);
+        message.from !== undefined && (obj.from = message.from);
+        message.to !== undefined && (obj.to = message.to);
+        message.returnPath !== undefined && (obj.returnPath = message.returnPath);
+        message.body !== undefined &&
+            (obj.body = base64FromBytes(message.body !== undefined ? message.body : new Uint8Array()));
+        message.shouldRetry !== undefined && (obj.shouldRetry = message.shouldRetry);
+        return obj;
+    },
+    fromPartial: function (object) {
+        var _a, _b, _c, _d, _e, _f;
+        var message = createBaseEmailToSend();
+        message.emailId = (_a = object.emailId) !== null && _a !== void 0 ? _a : '';
+        message.from = (_b = object.from) !== null && _b !== void 0 ? _b : '';
+        message.to = (_c = object.to) !== null && _c !== void 0 ? _c : '';
+        message.returnPath = (_d = object.returnPath) !== null && _d !== void 0 ? _d : '';
+        message.body = (_e = object.body) !== null && _e !== void 0 ? _e : new Uint8Array();
+        message.shouldRetry = (_f = object.shouldRetry) !== null && _f !== void 0 ? _f : false;
+        return message;
+    },
+};
+var tsProtoGlobalThis = (function () {
+    if (typeof globalThis !== 'undefined') {
+        return globalThis;
+    }
+    if (typeof self !== 'undefined') {
+        return self;
+    }
+    if (typeof window !== 'undefined') {
+        return window;
+    }
+    if (typeof global !== 'undefined') {
+        return global;
+    }
+    throw 'Unable to locate global object';
+})();
+function bytesFromBase64(b64) {
+    if (tsProtoGlobalThis.Buffer) {
+        return Uint8Array.from(tsProtoGlobalThis.Buffer.from(b64, 'base64'));
+    }
+    else {
+        var bin = tsProtoGlobalThis.atob(b64);
+        var arr = new Uint8Array(bin.length);
+        for (var i = 0; i < bin.length; ++i) {
+            arr[i] = bin.charCodeAt(i);
+        }
+        return arr;
+    }
+}
+function base64FromBytes(arr) {
+    if (tsProtoGlobalThis.Buffer) {
+        return tsProtoGlobalThis.Buffer.from(arr).toString('base64');
+    }
+    else {
+        var bin_1 = [];
+        arr.forEach(function (byte) {
+            bin_1.push(String.fromCharCode(byte));
+        });
+        return tsProtoGlobalThis.btoa(bin_1.join(''));
+    }
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/lib/proto/kannon/mailer/types/send.d.ts

@@ -0,0 +1,72 @@
+import _m0 from 'protobufjs/minimal';
+export declare const protobufPackage = "pkg.kannon.mailer.types";
+export interface Sender {
+    email: string;
+    alias: string;
+}
+export interface Recipient {
+    email: string;
+    fields: {
+        [key: string]: string;
+    };
+}
+export interface Recipient_FieldsEntry {
+    key: string;
+    value: string;
+}
+export declare const Sender: {
+    encode(message: Sender, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Sender;
+    fromJSON(object: any): Sender;
+    toJSON(message: Sender): unknown;
+    fromPartial<I extends {
+        email?: string | undefined;
+        alias?: string | undefined;
+    } & {
+        email?: string | undefined;
+        alias?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof Sender>]: never; }>(object: I): Sender;
+};
+export declare const Recipient: {
+    encode(message: Recipient, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Recipient;
+    fromJSON(object: any): Recipient;
+    toJSON(message: Recipient): unknown;
+    fromPartial<I extends {
+        email?: string | undefined;
+        fields?: {
+            [x: string]: string | undefined;
+        } | undefined;
+    } & {
+        email?: string | undefined;
+        fields?: ({
+            [x: string]: string | undefined;
+        } & {
+            [x: string]: string | undefined;
+        } & { [K in Exclude<keyof I["fields"], string | number>]: never; }) | undefined;
+    } & { [K_1 in Exclude<keyof I, keyof Recipient>]: never; }>(object: I): Recipient;
+};
+export declare const Recipient_FieldsEntry: {
+    encode(message: Recipient_FieldsEntry, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Recipient_FieldsEntry;
+    fromJSON(object: any): Recipient_FieldsEntry;
+    toJSON(message: Recipient_FieldsEntry): unknown;
+    fromPartial<I extends {
+        key?: string | undefined;
+        value?: string | undefined;
+    } & {
+        key?: string | undefined;
+        value?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof Recipient_FieldsEntry>]: never; }>(object: I): Recipient_FieldsEntry;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export {};

package/lib/proto/kannon/mailer/types/send.js

@@ -0,0 +1,190 @@
+/* eslint-disable */
+import _m0 from 'protobufjs/minimal';
+export var protobufPackage = 'pkg.kannon.mailer.types';
+function createBaseSender() {
+    return { email: '', alias: '' };
+}
+export var Sender = {
+    encode: function (message, writer) {
+        if (writer === void 0) { writer = _m0.Writer.create(); }
+        if (message.email !== '') {
+            writer.uint32(10).string(message.email);
+        }
+        if (message.alias !== '') {
+            writer.uint32(18).string(message.alias);
+        }
+        return writer;
+    },
+    decode: function (input, length) {
+        var reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        var end = length === undefined ? reader.len : reader.pos + length;
+        var message = createBaseSender();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.email = reader.string();
+                    break;
+                case 2:
+                    message.alias = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON: function (object) {
+        return {
+            email: isSet(object.email) ? String(object.email) : '',
+            alias: isSet(object.alias) ? String(object.alias) : '',
+        };
+    },
+    toJSON: function (message) {
+        var obj = {};
+        message.email !== undefined && (obj.email = message.email);
+        message.alias !== undefined && (obj.alias = message.alias);
+        return obj;
+    },
+    fromPartial: function (object) {
+        var _a, _b;
+        var message = createBaseSender();
+        message.email = (_a = object.email) !== null && _a !== void 0 ? _a : '';
+        message.alias = (_b = object.alias) !== null && _b !== void 0 ? _b : '';
+        return message;
+    },
+};
+function createBaseRecipient() {
+    return { email: '', fields: {} };
+}
+export var Recipient = {
+    encode: function (message, writer) {
+        if (writer === void 0) { writer = _m0.Writer.create(); }
+        if (message.email !== '') {
+            writer.uint32(10).string(message.email);
+        }
+        Object.entries(message.fields).forEach(function (_a) {
+            var key = _a[0], value = _a[1];
+            Recipient_FieldsEntry.encode({ key: key, value: value }, writer.uint32(18).fork()).ldelim();
+        });
+        return writer;
+    },
+    decode: function (input, length) {
+        var reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        var end = length === undefined ? reader.len : reader.pos + length;
+        var message = createBaseRecipient();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.email = reader.string();
+                    break;
+                case 2:
+                    var entry2 = Recipient_FieldsEntry.decode(reader, reader.uint32());
+                    if (entry2.value !== undefined) {
+                        message.fields[entry2.key] = entry2.value;
+                    }
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON: function (object) {
+        return {
+            email: isSet(object.email) ? String(object.email) : '',
+            fields: isObject(object.fields)
+                ? Object.entries(object.fields).reduce(function (acc, _a) {
+                    var key = _a[0], value = _a[1];
+                    acc[key] = String(value);
+                    return acc;
+                }, {})
+                : {},
+        };
+    },
+    toJSON: function (message) {
+        var obj = {};
+        message.email !== undefined && (obj.email = message.email);
+        obj.fields = {};
+        if (message.fields) {
+            Object.entries(message.fields).forEach(function (_a) {
+                var k = _a[0], v = _a[1];
+                obj.fields[k] = v;
+            });
+        }
+        return obj;
+    },
+    fromPartial: function (object) {
+        var _a, _b;
+        var message = createBaseRecipient();
+        message.email = (_a = object.email) !== null && _a !== void 0 ? _a : '';
+        message.fields = Object.entries((_b = object.fields) !== null && _b !== void 0 ? _b : {}).reduce(function (acc, _a) {
+            var key = _a[0], value = _a[1];
+            if (value !== undefined) {
+                acc[key] = String(value);
+            }
+            return acc;
+        }, {});
+        return message;
+    },
+};
+function createBaseRecipient_FieldsEntry() {
+    return { key: '', value: '' };
+}
+export var Recipient_FieldsEntry = {
+    encode: function (message, writer) {
+        if (writer === void 0) { writer = _m0.Writer.create(); }
+        if (message.key !== '') {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== '') {
+            writer.uint32(18).string(message.value);
+        }
+        return writer;
+    },
+    decode: function (input, length) {
+        var reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        var end = length === undefined ? reader.len : reader.pos + length;
+        var message = createBaseRecipient_FieldsEntry();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.string();
+                    break;
+                case 2:
+                    message.value = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON: function (object) {
+        return { key: isSet(object.key) ? String(object.key) : '', value: isSet(object.value) ? String(object.value) : '' };
+    },
+    toJSON: function (message) {
+        var obj = {};
+        message.key !== undefined && (obj.key = message.key);
+        message.value !== undefined && (obj.value = message.value);
+        return obj;
+    },
+    fromPartial: function (object) {
+        var _a, _b;
+        var message = createBaseRecipient_FieldsEntry();
+        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : '';
+        message.value = (_b = object.value) !== null && _b !== void 0 ? _b : '';
+        return message;
+    },
+};
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/lib/utils/grpc-promisify.d.ts

@@ -0,0 +1,18 @@
+import * as grpc from '@grpc/grpc-js';
+type CbFun<Req, Res> = (req: Req, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: any, response: Res) => void) => void;
+type AsyncFun<Req, Res> = (req: Req, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>) => Promise<Res>;
+type promisify<CB> = CB extends CbFun<infer Req, infer Res> ? AsyncFun<Req, Res> : never;
+export type promisifyAll<Cli extends grpc.Client> = {
+    [k in keyof Cli]: promisify<Cli[k]>;
+};
+declare function promisify<Req, Res>(cb: CbFun<Req, Res>): promisify<CbFun<Req, Res>>;
+export declare function promisifyAll<TClient extends grpc.Client>(client: TClient): promisifyAll<TClient>;
+export declare function CreateClientContructor<TClient extends grpc.Client>(Cli: ITCli<TClient>): (conf: GrpcClientConfig) => promisifyAll<TClient>;
+interface ITCli<TClient extends grpc.Client> {
+    new (address: string, credentials: grpc.ChannelCredentials, options?: Partial<grpc.ChannelOptions>): TClient;
+}
+export interface GrpcClientConfig {
+    host: string;
+    skipTLS: boolean;
+}
+export {};

package/lib/utils/grpc-promisify.js

@@ -0,0 +1,31 @@
+import * as grpc from '@grpc/grpc-js';
+function promisify(cb) {
+    return function (req, metadata, options) {
+        if (metadata === void 0) { metadata = new grpc.Metadata(); }
+        if (options === void 0) { options = {}; }
+        return new Promise(function (resolve, reject) {
+            cb(req, metadata, options, function (err, res) {
+                if (!!err) {
+                    return reject(err);
+                }
+                return resolve(res);
+            });
+        });
+    };
+}
+export function promisifyAll(client) {
+    var methods = Object.getPrototypeOf(client);
+    var res = {};
+    for (var _i = 0, _a = Object.entries(methods); _i < _a.length; _i++) {
+        var _b = _a[_i], name_1 = _b[0], method = _b[1];
+        res[name_1] = promisify(method.bind(client));
+    }
+    return res;
+}
+export function CreateClientContructor(Cli) {
+    return function (conf) {
+        var credentials = conf.skipTLS ? grpc.credentials.createInsecure() : grpc.credentials.createSsl();
+        var cli = new Cli(conf.host, credentials);
+        return promisifyAll(cli);
+    };
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "kannon.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kannon-email/kannon.js"
+  },
+  "version": "0.1.0",
+  "description": "Kannon node client libreary",
+  "main": "lib/kannon.js",
+  "types": "lib/kannon.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "format": "prettier --write \"src/**/*.ts\" \"src/**/*.js\"",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prepare": "npm run build"
+  },
+  "author": "ludusrusso",
+  "license": "ISC",
+  "devDependencies": {
+    "prettier": "^2.8.1",
+    "ts-proto": "^1.137.0",
+    "tslint": "^6.1.3",
+    "tslint-config-prettier": "^1.18.0"
+  },
+  "dependencies": {
+    "@grpc/grpc-js": "^1.8.1"
+  },
+  "keywords": [
+    "email",
+    "node",
+    "grpc"
+  ],
+  "files": [
+    "lib/**/*"
+  ]
+}