polar-alerts 0.0.1

package/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Daniil Prylepa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/alert-sender.d.ts

@@ -0,0 +1,6 @@
+import { AlertParams, TelegramAlertsConfig } from './types';
+export declare class TelegramAlertSender {
+    private config;
+    constructor(config: TelegramAlertsConfig);
+    sendAlert(params: AlertParams | Promise<AlertParams>): void;
+}

package/dist/alert-sender.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramAlertSender = void 0;
+const node_telegram_bot_api_1 = __importDefault(require("node-telegram-bot-api"));
+const utils_1 = require("./utils");
+class TelegramAlertSender {
+    constructor(config) {
+        this.config = config;
+    }
+    sendAlert(params) {
+        const send = async () => {
+            const awaitedParams = params instanceof Promise ? await params : params;
+            const { title, description, hashtags, links, silent = false, } = awaitedParams;
+            const bot = new node_telegram_bot_api_1.default(this.config.telegram.botToken);
+            // Build message
+            let message = `*${(0, utils_1.escapeMarkdown)(title)}*\n\n`;
+            if (description) {
+                message += `${description}\n`;
+            }
+            if (links && links.length > 0) {
+                for (const link of links) {
+                    message += `🔗 [${(0, utils_1.escapeMarkdown)(link.label)}](${link.url})\n`;
+                }
+                message += '\n';
+            }
+            if (hashtags && hashtags.length > 0) {
+                const formattedTags = hashtags
+                    .map((tag) => (tag.startsWith('#') ? tag : `#${tag}`))
+                    .join(' ');
+                message += formattedTags;
+            }
+            try {
+                await bot.sendMessage(this.config.telegram.chatId, message.trim(), {
+                    parse_mode: 'Markdown',
+                    disable_web_page_preview: true,
+                    disable_notification: silent,
+                    message_thread_id: this.config.telegram.threadId,
+                });
+            }
+            catch (error) {
+                console.error('Failed to send Telegram alert:', error);
+                throw new Error(`Failed to send Telegram alert: ${error}`);
+            }
+        };
+        try {
+            if (this.config.deferExecution) {
+                this.config.deferExecution(send());
+            }
+            else {
+                send().catch(console.error);
+            }
+        }
+        catch (error) {
+            console.error('Error in sendAlert:', error);
+        }
+    }
+}
+exports.TelegramAlertSender = TelegramAlertSender;

package/dist/description-builder.d.ts

@@ -0,0 +1,32 @@
+import { PolarAlertsConfig } from './types';
+import type { Product } from '@polar-sh/sdk/models/components/product.js';
+import type { OrderProduct } from '@polar-sh/sdk/models/components/orderproduct.js';
+import type { Customer } from '@polar-sh/sdk/models/components/customer.js';
+import type { CheckoutProduct } from '@polar-sh/sdk/models/components/checkoutproduct.js';
+type FieldFormat = 'code' | 'italic' | 'plain';
+export declare class AlertDescriptionBuilder {
+    private sections;
+    private config;
+    private escapeMarkdown;
+    constructor({ config, escapeMarkdown, }: {
+        config: PolarAlertsConfig;
+        escapeMarkdown: (text: string) => string;
+    });
+    custom(text: string | Promise<string>): this;
+    separator(): this;
+    field(label: string, value: string | undefined | null, format?: FieldFormat): this;
+    dateField(label: string, date: Date | null | undefined, dateFormat?: string): this;
+    moneyField(label: string, amountInCents: number, condition?: any): this;
+    productInfo(product: Product | CheckoutProduct | OrderProduct, amount?: number): this;
+    hashtags(hashtags: string[], condition?: boolean): this;
+    link(label: string, url: string, condition?: boolean): this;
+    customerInfo(customer: {
+        id: string;
+        name?: string | null;
+        email?: string | null;
+        billingAddress?: Customer['billingAddress'];
+        createdAt?: Date;
+    }): this;
+    build(): Promise<string>;
+}
+export {};

package/dist/description-builder.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertDescriptionBuilder = void 0;
+const date_fns_1 = require("date-fns");
+const utils_1 = require("./utils");
+class AlertDescriptionBuilder {
+    constructor({ config, escapeMarkdown, }) {
+        this.sections = [];
+        this.config = config;
+        this.escapeMarkdown = escapeMarkdown;
+    }
+    custom(text) {
+        this.sections.push(text);
+        return this;
+    }
+    separator() {
+        this.sections.push('');
+        return this;
+    }
+    field(label, value, format = 'code') {
+        if (value) {
+            const escaped = this.escapeMarkdown(value);
+            const formatted = format === 'code'
+                ? `\`${escaped}\``
+                : format === 'italic'
+                    ? `*${escaped}*`
+                    : escaped;
+            this.sections.push(`*${label}* - ${formatted}`);
+        }
+        return this;
+    }
+    dateField(label, date, dateFormat = 'MMM d, yyyy h:mm a') {
+        if (date) {
+            this.field(label, (0, date_fns_1.format)(date, dateFormat));
+        }
+        return this;
+    }
+    moneyField(label, amountInCents, condition = true) {
+        if (condition) {
+            const text = `*${label}* - *$${amountInCents / 100}*`;
+            this.sections.push(text);
+        }
+        return this;
+    }
+    productInfo(product, amount) {
+        let text = `[${this.escapeMarkdown(product.name)}](${(0, utils_1.getProductLink)(this.config, product.id)})`;
+        if (amount !== undefined) {
+            text += ` (*$${amount / 100}*`;
+            if (product.recurringInterval) {
+                text += `/${this.escapeMarkdown(product.recurringInterval)}`;
+            }
+            text += ')';
+        }
+        this.sections.push(text);
+        return this;
+    }
+    hashtags(hashtags, condition = true) {
+        if (condition && hashtags && hashtags.length > 0) {
+            const formattedTags = hashtags
+                .map((tag) => (tag.startsWith('#') ? tag : `#${tag}`))
+                .join(' ');
+            this.sections.push(formattedTags);
+        }
+        return this;
+    }
+    link(label, url, condition = true) {
+        if (condition && label && url) {
+            this.sections.push(`🔗 [${this.escapeMarkdown(label)}](${url})`);
+        }
+        return this;
+    }
+    customerInfo(customer) {
+        const country = customer.billingAddress?.country;
+        const flag = country ? (0, utils_1.getCountryFlag)(country) : '';
+        let section = `${flag ? `${flag} ` : ''}${this.escapeMarkdown(customer.name ?? '')}\n\`${customer.email}\``;
+        if (customer.createdAt) {
+            section += `\n*Created* - \`${(0, date_fns_1.format)(customer.createdAt, 'PPP')}\``;
+        }
+        section += '\n';
+        section += `\n🔗 [View Customer](${(0, utils_1.getCustomerLink)(this.config, customer.id)})\n`;
+        this.sections.push(section);
+        return this;
+    }
+    async build() {
+        const sectionPromises = this.sections.map(async (section) => {
+            if (typeof section === 'string') {
+                return Promise.resolve(section);
+            }
+            return section;
+        });
+        const sections = await Promise.all(sectionPromises);
+        return sections.join('\n');
+    }
+}
+exports.AlertDescriptionBuilder = AlertDescriptionBuilder;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { PolarAlertsClient } from './webhook-handler';
+export type { PolarAlertsConfig } from './types';

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolarAlertsClient = void 0;
+var webhook_handler_1 = require("./webhook-handler");
+Object.defineProperty(exports, "PolarAlertsClient", { enumerable: true, get: function () { return webhook_handler_1.PolarAlertsClient; } });

package/dist/senders/index.d.ts

@@ -0,0 +1,2 @@
+export * from './telegram';
+export * from './types';

package/dist/senders/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./telegram"), exports);
+__exportStar(require("./types"), exports);

package/dist/senders/telegram.d.ts

@@ -0,0 +1,22 @@
+import { AlertsSenderConfig, AlertsSender, AlertParams } from './types';
+/**
+ * Telegram alert configuration options
+ */
+export interface TelegramAlertsConfig {
+    /**
+     * Your Telegram bot token (obtain via @BotFather on Telegram).
+     */
+    botToken: string;
+    /** The chat ID where alerts will be sent. Can be set to a group, channel, or user id. */
+    chatId: string;
+    /**
+     * Optional: Set a thread ID when sending alerts to a specific thread on telegram (group topics).
+     */
+    threadId?: number;
+}
+export declare class TelegramAlertSender implements AlertsSender {
+    private config;
+    constructor(config: AlertsSenderConfig & TelegramAlertsConfig);
+    sendAlert(params: AlertParams | Promise<AlertParams>): void;
+    escapeMarkdown(text: string): string;
+}

package/dist/senders/telegram.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramAlertSender = void 0;
+const node_telegram_bot_api_1 = __importDefault(require("node-telegram-bot-api"));
+class TelegramAlertSender {
+    constructor(config) {
+        this.config = config;
+    }
+    sendAlert(params) {
+        const send = async () => {
+            const awaitedParams = params instanceof Promise ? await params : params;
+            const { title, description, silent = false } = awaitedParams;
+            const bot = new node_telegram_bot_api_1.default(this.config.botToken);
+            // Build message
+            let message = `*${this.escapeMarkdown(title)}*\n\n`;
+            if (description) {
+                message += `${description}\n`;
+            }
+            try {
+                await bot.sendMessage(this.config.chatId, message.trim(), {
+                    parse_mode: 'Markdown',
+                    disable_web_page_preview: true,
+                    disable_notification: silent,
+                    message_thread_id: this.config.threadId,
+                });
+            }
+            catch (error) {
+                console.error('Failed to send Telegram alert:', error);
+                throw new Error(`Failed to send Telegram alert: ${error}`);
+            }
+        };
+        try {
+            if (this.config.waitUntil) {
+                this.config.waitUntil(send());
+            }
+            else {
+                send().catch(console.error);
+            }
+        }
+        catch (error) {
+            console.error('Error in sendAlert:', error);
+        }
+    }
+    // This escapeMarkdown method is for Telegram v1 Markdown formatting.
+    escapeMarkdown(text) {
+        return text
+            .replace(/\*/g, '\\*')
+            .replace(/`/g, '\\`')
+            .replace(/\[/g, '\\[');
+    }
+}
+exports.TelegramAlertSender = TelegramAlertSender;

package/dist/senders/types.d.ts

@@ -0,0 +1,13 @@
+import { PolarAlertsConfig } from '../types';
+export interface AlertsSenderConfig {
+    waitUntil?: PolarAlertsConfig['waitUntil'];
+}
+export interface AlertsSender {
+    sendAlert(params: AlertParams | Promise<AlertParams>): void;
+    escapeMarkdown(text: string): string;
+}
+export interface AlertParams {
+    title: string;
+    description?: string;
+    silent?: boolean;
+}

package/dist/senders/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/templates.d.ts

@@ -0,0 +1,8 @@
+import { PolarAlertsConfig } from './types';
+import { AlertParams } from './senders/types';
+export declare function createAlertTemplates({ config, escapeMarkdown, }: {
+    config: PolarAlertsConfig;
+    escapeMarkdown: (text: string) => string;
+}): Record<string, (params: {
+    data: any;
+}) => Promise<AlertParams | undefined>>;

package/dist/templates.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAlertTemplates = createAlertTemplates;
+const description_builder_1 = require("./description-builder");
+const utils_1 = require("./utils");
+function createAlertTemplates({ config, escapeMarkdown, }) {
+    return {
+        ['checkout.created']: async ({ data: checkout, }) => {
+            const description = new description_builder_1.AlertDescriptionBuilder({
+                config,
+                escapeMarkdown,
+            });
+            checkout.products.forEach((product) => {
+                description.productInfo(product, product.prices.find((price) => price.amountType === 'fixed')
+                    ?.priceAmount ?? 0);
+            });
+            description
+                .separator()
+                .field('Status', checkout.status.toUpperCase())
+                .dateField('Created at', checkout.createdAt)
+                .dateField('Expires at', checkout.expiresAt)
+                .separator()
+                .field('🏷️ Discount', checkout.discount
+                ? `${checkout.discount.name} ($${checkout.discount.code})`
+                : undefined, 'italic')
+                .separator()
+                .link('View Checkout', (0, utils_1.getSubscriptionLink)(config, checkout.id))
+                .separator();
+            if (checkout.customerId) {
+                description.customerInfo({
+                    id: checkout.customerId,
+                    name: checkout.customerName,
+                    email: checkout.customerEmail,
+                    billingAddress: checkout.customerBillingAddress,
+                });
+            }
+            return {
+                title: '🛒🆕 Checkout Created',
+                description: await description
+                    .hashtags(['checkout', 'created'])
+                    .build(),
+            };
+        },
+        ['checkout.updated']: async ({ data: checkout, }) => {
+            const description = new description_builder_1.AlertDescriptionBuilder({
+                config,
+                escapeMarkdown,
+            });
+            checkout.products.forEach((product) => {
+                description.productInfo(product, product.prices.find((price) => price.amountType === 'fixed')
+                    ?.priceAmount ?? 0);
+            });
+            description
+                .separator()
+                .field('Status', checkout.status.toUpperCase())
+                .dateField('Created at', checkout.createdAt)
+                .dateField('Expires at', checkout.expiresAt)
+                .separator()
+                .field('🏷️ Discount', checkout.discount
+                ? `${checkout.discount.name} ($${checkout.discount.code})`
+                : undefined, 'italic')
+                .separator()
+                .link('View Checkout', (0, utils_1.getSubscriptionLink)(config, checkout.id))
+                .separator();
+            if (checkout.customerId) {
+                description.customerInfo({
+                    id: checkout.customerId,
+                    name: checkout.customerName,
+                    email: checkout.customerEmail,
+                    billingAddress: checkout.customerBillingAddress,
+                });
+            }
+            return {
+                title: '🛒🔁 Checkout Updated',
+                description: await description
+                    .hashtags(['checkout', 'updated'])
+                    .build(),
+            };
+        },
+        ['subscription.created']: async ({ data: subscription, }) => ({
+            title: '🔁✅ Subscription Created',
+            description: await new description_builder_1.AlertDescriptionBuilder({
+                config,
+                escapeMarkdown,
+            })
+                .productInfo(subscription.product, subscription.amount)
+                .separator()
+                .dateField('Started on', subscription.startedAt)
+                .separator()
+                .link('View Subscription', (0, utils_1.getSubscriptionLink)(config, subscription.id))
+                .separator()
+                .customerInfo(subscription.customer)
+                .hashtags(['subscription', 'created'])
+                .build(),
+        }),
+        ['subscription.canceled']: async ({ data: subscription, }) => ({
+            title: '🔁❌ Subscription Canceled',
+            description: await new description_builder_1.AlertDescriptionBuilder({
+                config,
+                escapeMarkdown,
+            })
+                .productInfo(subscription.product, subscription.amount)
+                .separator()
+                .field('❔ Cancellation reason', subscription.customerCancellationReason?.toUpperCase())
+                .field('💬 Comment', subscription.customerCancellationComment)
+                .dateField('Started on', subscription.startedAt)
+                .dateField('Ends on', subscription.endsAt)
+                .separator()
+                .link('View Subscription', (0, utils_1.getSubscriptionLink)(config, subscription.id))
+                .separator()
+                .customerInfo(subscription.customer)
+                .hashtags(['subscription', 'canceled'])
+                .build(),
+        }),
+        ['subscription.uncanceled']: async ({ data: subscription, }) => ({
+            title: '🔁✅ Subscription Uncanceled',
+            description: await new description_builder_1.AlertDescriptionBuilder({
+                config,
+                escapeMarkdown,
+            })
+                .productInfo(subscription.product, subscription.amount)
+                .separator()
+                .field('Status', subscription.status.toUpperCase())
+                .separator()
+                .dateField('Started on', subscription.startedAt)
+                .dateField('Current period start', subscription.currentPeriodStart)
+                .dateField('Current period end', subscription.currentPeriodEnd)
+                .separator()
+                .link('View Subscription', (0, utils_1.getSubscriptionLink)(config, subscription.id))
+                .separator()
+                .customerInfo(subscription.customer)
+                .hashtags(['subscription', 'uncanceled'])
+                .build(),
+        }),
+        ['subscription.updated']: async ({ data: subscription, }) => {
+            if (subscription.status !== 'past_due') {
+                return;
+            }
+            return {
+                title: '🔁⚠️ Subscription Payment Past Due',
+                description: await new description_builder_1.AlertDescriptionBuilder({
+                    config,
+                    escapeMarkdown,
+                })
+                    .productInfo(subscription.product, subscription.amount)
+                    .separator()
+                    .field('Status', subscription.status.toUpperCase())
+                    .separator()
+                    .dateField('Started on', subscription.startedAt)
+                    .dateField('Current period start', subscription.currentPeriodStart)
+                    .dateField('Current period end', subscription.currentPeriodEnd)
+                    .separator()
+                    .link('View Subscription', (0, utils_1.getSubscriptionLink)(config, subscription.id))
+                    .separator()
+                    .customerInfo(subscription.customer)
+                    .hashtags(['subscription', 'past_due'])
+                    .build(),
+            };
+        },
+        ['order.created']: async ({ data: order }) => {
+            if (!order.product) {
+                throw new Error('Product not found in order.');
+            }
+            return {
+                title: '💰🆕 Order Created',
+                description: await new description_builder_1.AlertDescriptionBuilder({
+                    config,
+                    escapeMarkdown,
+                })
+                    .productInfo(order.product, order.subtotalAmount)
+                    .separator()
+                    .field('🏷️ Discount', order.discount
+                    ? `$${order.discountAmount / 100} (${order.discount?.name || ''})`
+                    : undefined, 'italic')
+                    .moneyField('💵 Total', order.netAmount)
+                    .moneyField('🏛️ Taxes', order.taxAmount, order.taxAmount > 0)
+                    .separator()
+                    .field('Status', order.status.toUpperCase())
+                    .dateField('Created on', order.createdAt)
+                    .separator()
+                    .link('View Order', (0, utils_1.getOrderLink)(config, order.id))
+                    .separator()
+                    .customerInfo(order.customer)
+                    .hashtags(['order', 'created'])
+                    .build(),
+                silent: false,
+            };
+        },
+        ['order.paid']: async ({ data: order }) => {
+            if (!order.product) {
+                throw new Error('Product not found in order.');
+            }
+            return {
+                title: '💰 Order Paid',
+                description: await new description_builder_1.AlertDescriptionBuilder({
+                    config,
+                    escapeMarkdown,
+                })
+                    .productInfo(order.product, order.subtotalAmount)
+                    .separator()
+                    .field('🏷️ Discount', order.discount
+                    ? `$${order.discountAmount / 100} (${order.discount?.name || ''})`
+                    : undefined, 'italic')
+                    .moneyField('💵 Total', order.netAmount)
+                    .moneyField('🏛️ Taxes', order.taxAmount, order.taxAmount > 0)
+                    .separator()
+                    .field('Billing reason', order.billingReason.toUpperCase())
+                    .dateField('Paid on', order.createdAt)
+                    .separator()
+                    .link('View Order', (0, utils_1.getOrderLink)(config, order.id))
+                    .separator()
+                    .customerInfo(order.customer)
+                    .hashtags(['order', 'paid'])
+                    .build(),
+                silent: order.billingReason === 'subscription_cycle',
+            };
+        },
+        ['order.refunded']: async ({ data: order }) => {
+            if (!order.product) {
+                throw new Error('Product not found in order.');
+            }
+            return {
+                title: '💰❌ Order Refunded',
+                description: await new description_builder_1.AlertDescriptionBuilder({
+                    config,
+                    escapeMarkdown,
+                })
+                    .productInfo(order.product, order.subtotalAmount)
+                    .separator()
+                    .moneyField('💵 Total', order.netAmount)
+                    .moneyField('🏛️ Taxes', order.taxAmount, order.taxAmount > 0)
+                    .dateField('Refunded on', order.createdAt)
+                    .separator()
+                    .link('View Order', (0, utils_1.getOrderLink)(config, order.id))
+                    .separator()
+                    .customerInfo(order.customer)
+                    .hashtags(['order', 'refunded'])
+                    .build(),
+            };
+        },
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,29 @@
+import { TelegramAlertsConfig } from './senders';
+import { createAlertTemplates } from './templates';
+export type EventType = keyof ReturnType<typeof createAlertTemplates>;
+export interface PolarAlertsConfig {
+    /** Your Polar server environment. Used to construct dashboard links. */
+    polarServer: 'production' | 'sandbox';
+    /**
+     * Your Polar organization slug
+     */
+    polarOrganizationSlug: string;
+    /**
+     * Enable/disable specific event types
+     */
+    events?: Record<EventType, boolean> | 'all';
+    /**
+     * Telegram alert configuration options
+     */
+    telegram?: TelegramAlertsConfig;
+    /**
+     * Optional function to defer execution (e.g., Vercel's waitUntil)
+     * If not provided, alerts may be unreliable in serverless environments.
+     *
+     * See `waitUntil` documentation in
+     * [Vercel](https://vercel.com/docs/functions/functions-api-reference/vercel-functions-package#waituntil) and
+     * [Cloudflare](https://developers.cloudflare.com/workers/runtime-apis/context/#waituntil)
+     * for more details.
+     */
+    waitUntil?: (promise: Promise<any>) => void;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.d.ts

@@ -0,0 +1,7 @@
+import { PolarAlertsConfig } from './types';
+export declare function getCountryFlag(countryCode: string): string;
+export declare function getCustomerLink(config: PolarAlertsConfig, customerId: string): string;
+export declare function getOrderLink(config: PolarAlertsConfig, orderId: string): string;
+export declare function getProductLink(config: PolarAlertsConfig, productId: string): string;
+export declare function getSubscriptionLink(config: PolarAlertsConfig, subscriptionId: string): string;
+export declare function getCheckoutLink(config: PolarAlertsConfig, checkoutId: string): string;

package/dist/utils.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCountryFlag = getCountryFlag;
+exports.getCustomerLink = getCustomerLink;
+exports.getOrderLink = getOrderLink;
+exports.getProductLink = getProductLink;
+exports.getSubscriptionLink = getSubscriptionLink;
+exports.getCheckoutLink = getCheckoutLink;
+function getCountryFlag(countryCode) {
+    const code = countryCode.toUpperCase();
+    const codePoints = code
+        .split('')
+        .map((char) => 127397 + char.charCodeAt(0));
+    return String.fromCodePoint(...codePoints);
+}
+function getCustomerLink(config, customerId) {
+    return polarDashboardLink(config, `customers/${customerId}`);
+}
+function getOrderLink(config, orderId) {
+    return polarDashboardLink(config, `orders/${orderId}`);
+}
+function getProductLink(config, productId) {
+    return polarDashboardLink(config, `products/${productId}`);
+}
+function getSubscriptionLink(config, subscriptionId) {
+    return polarDashboardLink(config, `subscriptions/${subscriptionId}`);
+}
+function getCheckoutLink(config, checkoutId) {
+    return polarDashboardLink(config, `sales/checkouts/${checkoutId}`);
+}
+function polarDashboardLink(config, path) {
+    if (config.polarServer === 'production') {
+        return `https://polar.sh/dashboard/${config.polarOrganizationSlug}/${path}`;
+    }
+    else {
+        return `https://sandbox.polar.sh/dashboard/${config.polarOrganizationSlug}/${path}`;
+    }
+}

package/dist/webhook-handler.d.ts

@@ -0,0 +1,15 @@
+import { AlertParams } from './senders';
+import { PolarAlertsConfig } from './types';
+import type { validateEvent } from '@polar-sh/sdk/webhooks';
+type WebhookPayload = ReturnType<typeof validateEvent>;
+export declare class PolarAlertsClient {
+    private senders;
+    private config;
+    constructor(config: PolarAlertsConfig);
+    sendAlert(params: AlertParams | Promise<AlertParams>): Promise<void>;
+    /**
+     * Handle a Polar webhook event and send the appropriate alert
+     */
+    handleWebhook(payload: WebhookPayload): Promise<void>;
+}
+export {};

package/dist/webhook-handler.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolarAlertsClient = void 0;
+const senders_1 = require("./senders");
+const templates_1 = require("./templates");
+const DEFAULT_EVENT_CONFIG = {
+    'checkout.created': false,
+    'checkout.updated': false,
+    'subscription.created': true,
+    'subscription.canceled': true,
+    'subscription.uncanceled': true,
+    'subscription.updated': true,
+    'order.created': false,
+    'order.paid': true,
+    'order.refunded': true,
+};
+class PolarAlertsClient {
+    constructor(config) {
+        this.senders = [];
+        this.config = config;
+        if (config.telegram) {
+            this.senders.push(new senders_1.TelegramAlertSender({
+                ...config.telegram,
+                waitUntil: config.waitUntil,
+            }));
+        }
+    }
+    async sendAlert(params) {
+        for (const sender of this.senders) {
+            sender.sendAlert(params);
+        }
+    }
+    /**
+     * Handle a Polar webhook event and send the appropriate alert
+     */
+    async handleWebhook(payload) {
+        const eventType = payload.type;
+        const eventConfig = this.config.events === 'all'
+            ? {}
+            : {
+                ...DEFAULT_EVENT_CONFIG,
+                ...this.config.events,
+            };
+        // Default to true if not explicitly set to false
+        const isEventEnabled = (eventName) => eventConfig[eventName] ?? true;
+        if (!isEventEnabled(eventType)) {
+            return;
+        }
+        try {
+            for (const sender of this.senders) {
+                const templates = (0, templates_1.createAlertTemplates)({
+                    config: this.config,
+                    escapeMarkdown: sender.escapeMarkdown,
+                });
+                if (templates[eventType]) {
+                    const alert = await templates[eventType]({
+                        data: payload.data,
+                    });
+                    if (alert) {
+                        sender.sendAlert(alert);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error handling webhook event ${eventType}:`, error);
+            throw error;
+        }
+    }
+}
+exports.PolarAlertsClient = PolarAlertsClient;

package/package.json

@@ -0,0 +1,50 @@
+{
+    "name": "polar-alerts",
+    "version": "0.0.1",
+    "description": "Automatic Telegram alerts for Polar events with built-in webhook handling",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "files": [
+        "dist",
+        "README.md",
+        "LICENSE"
+    ],
+    "scripts": {
+        "build": "tsc",
+        "prepublishOnly": "npm run build",
+        "dev": "tsc --watch"
+    },
+    "keywords": [
+        "polar",
+        "telegram",
+        "alerts",
+        "notifications",
+        "webhooks",
+        "payments",
+        "subscriptions",
+        "bot",
+        "typescript"
+    ],
+    "author": "Daniil Prylepa",
+    "license": "MIT",
+    "dependencies": {
+        "node-telegram-bot-api": "^0.66.0",
+        "date-fns": "^4.0.0"
+    },
+    "peerDependencies": {
+        "@polar-sh/sdk": ">=0.40.0 <1.0.0"
+    },
+    "devDependencies": {
+        "@polar-sh/sdk": "^0.40.3",
+        "@types/node": "^22.0.0",
+        "@types/node-telegram-bot-api": "^0.64.0",
+        "typescript": "^5.0.0"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/world1dan/polar-alerts.git"
+    },
+    "engines": {
+        "node": ">=18"
+    }
+}