@misterhomer1992/payment-manager 1.0.0

package/.editorconfig

@@ -0,0 +1,7 @@
+root = true
+[*]
+indent_style = tab
+indent_size = 4
+insert_final_newline = true
+trim_trailing_whitespace = true
+max_line_length = 120

package/.prettierrc

@@ -0,0 +1,5 @@
+{
+    "tabWidth": 4,
+    "semi": true,
+    "singleQuote": true
+}

package/README.md

@@ -0,0 +1,181 @@
+# payment-manager
+
+A TypeScript library for managing subscriptions, one-time token purchases, and payment webhooks with [WayForPay](https://wayforpay.com/) and [Cloud Firestore](https://firebase.google.com/docs/firestore).
+
+Framework-agnostic — wire it into Express, Fastify, Cloud Functions, or anything else.
+
+## Features
+
+- Subscription lifecycle: create, upgrade/downgrade (with proration), cancel, expire
+- One-time token pack purchases
+- WayForPay webhook handling (payment confirmation + recurrent billing)
+- Cron-compatible expiration checks with grace periods
+- Payment URL caching (5-minute deduplication window)
+- Typed error classes for every failure scenario
+- Optional structured logging
+
+## Installation
+
+```bash
+npm install payment-manager firebase-admin
+```
+
+`firebase-admin` (>=12.0.0) is a peer dependency.
+
+## Quick Start
+
+```typescript
+import * as admin from 'firebase-admin';
+import { init } from 'payment-manager';
+
+admin.initializeApp();
+
+const pm = init({
+  firestore: admin.firestore(),
+  wayforpay: {
+    merchantAccount: 'your_merchant_account',
+    merchantSecretKey: 'your_merchant_secret_key',
+    merchantDomainName: 'example.com',
+  },
+  platform: 'my-app',
+  webhookSecret: 'your-webhook-secret',
+  logger: console,
+});
+
+await pm.plans.seedDefaultPlans([
+  { id: 'basic-monthly', name: 'Basic', amount: 100, regularMode: 'monthly', isActive: true },
+  { id: 'pro-monthly', name: 'Pro', amount: 300, regularMode: 'monthly', isActive: true },
+]);
+
+const { paymentUrl } = await pm.subscriptions.create({
+  userId: 'user-123',
+  planId: 'basic-monthly',
+  currency: 'UAH',
+  productName: 'My App Subscription',
+});
+```
+
+## Configuration
+
+```typescript
+interface PaymentManagerConfig {
+  firestore: Firestore;
+  wayforpay: {
+    merchantAccount: string;
+    merchantSecretKey: string;
+    merchantDomainName: string;
+  };
+  platform: string;         // included in order references
+  webhookSecret?: string;   // validates x-secret-key header on webhooks
+  logger?: {                // any object with info/warn/error (console, pino, winston)
+    info: (message: string, ...args: unknown[]) => void;
+    warn: (message: string, ...args: unknown[]) => void;
+    error: (message: string, ...args: unknown[]) => void;
+  };
+}
+```
+
+## API
+
+`init()` returns a `PaymentManager` object with five namespaces.
+
+### `pm.plans`
+
+| Method | Signature | Description |
+|---|---|---|
+| `seedDefaultPlans` | `(plans: PlanInput[]) => Promise<void>` | Upsert an array of plans by ID |
+| `create` | `(plan: PlanInput) => Promise<void>` | Create a single plan |
+| `getById` | `(planId: string) => Promise<SubscriptionPlanEntity \| null>` | Get a plan by ID |
+| `getAll` | `() => Promise<SubscriptionPlanEntity[]>` | List all plans |
+| `update` | `(planId: string, data: Partial<PlanInput>) => Promise<void>` | Update plan fields |
+| `deactivate` | `(planId: string) => Promise<void>` | Mark a plan as inactive |
+
+> `PlanInput` = `Omit<SubscriptionPlanEntity, 'createdAt' | 'updatedAt'>`
+
+### `pm.subscriptions`
+
+| Method | Signature | Description |
+|---|---|---|
+| `create` | `(params: { userId, planId, currency, productName }) => Promise<{ paymentUrl }>` | Create a subscription and return a WayForPay payment URL |
+| `getActiveByUserId` | `(userId: string) => Promise<SubscriptionEntity \| null>` | Get the active subscription for a user |
+| `changePlan` | `(userId: string, newPlanId: string) => Promise<void>` | Change plan (upgrade = immediate proration, downgrade = next billing cycle) |
+| `deactivate` | `(userId: string) => Promise<void>` | Cancel subscription via WayForPay |
+| `expire` | `(userId: string) => Promise<void>` | Manually expire a subscription |
+
+### `pm.tokenPacks`
+
+| Method | Signature | Description |
+|---|---|---|
+| `create` | `(pack: TokenPackInput) => Promise<string>` | Create a token pack, returns the generated ID |
+| `getAll` | `() => Promise<TokenPackEntity[]>` | List all token packs |
+| `activate` | `(packId: string) => Promise<void>` | Activate a token pack |
+| `deactivate` | `(packId: string) => Promise<void>` | Deactivate a token pack |
+| `remove` | `(packId: string) => Promise<void>` | Delete a token pack |
+| `buyExtraTokens` | `(params: { userId, packId, currency, productName }) => Promise<{ paymentUrl }>` | Purchase tokens, returns a one-time payment URL |
+
+> `TokenPackInput` = `Omit<TokenPackEntity, 'id' | 'createdAt' | 'updatedAt'>`
+
+### `pm.userTokens`
+
+| Method | Signature | Description |
+|---|---|---|
+| `getBalance` | `(userId: string) => Promise<UserTokenBalance>` | Get user's token balance (returns zero-balance default if no record exists) |
+
+### `pm.webhooks`
+
+| Method | Signature | Description |
+|---|---|---|
+| `handlePaymentCheck` | `(reqBody, headers) => Promise<WebhookResponse>` | Handle WayForPay `PAYMENT_CHECK` callback |
+| `handleSubscriptionDeactivationCheck` | `(headers) => Promise<DeactivationResult>` | Expire overdue subscriptions and apply pending downgrades (call from a cron job) |
+
+## Errors
+
+All errors extend `PaymentManagerError` with a `code` property:
+
+```typescript
+import { PaymentManagerError } from 'payment-manager';
+
+try {
+  await pm.subscriptions.create({ userId, planId, currency, productName });
+} catch (error) {
+  if (error instanceof PaymentManagerError) {
+    console.error(error.code, error.message);
+  }
+}
+```
+
+| Error | Code |
+|---|---|
+| `PlanNotFoundError` | `PLAN_NOT_FOUND` |
+| `PlanInactiveError` | `PLAN_INACTIVE` |
+| `SubscriptionNotFoundError` | `SUBSCRIPTION_NOT_FOUND` |
+| `SubscriptionAlreadyActiveError` | `SUBSCRIPTION_ALREADY_ACTIVE` |
+| `TokenPackNotFoundError` | `TOKEN_PACK_NOT_FOUND` |
+| `TokenPackInactiveError` | `TOKEN_PACK_INACTIVE` |
+| `InvalidWebhookSecretError` | `INVALID_WEBHOOK_SECRET` |
+| `PaymentProviderError` | `PAYMENT_PROVIDER_ERROR` |
+| `InvalidOrderReferenceError` | `INVALID_ORDER_REFERENCE` |
+
+## Grace Periods
+
+The deactivation check uses grace periods before expiring subscriptions:
+
+| Billing Cycle | Grace Period |
+|---|---|
+| daily | 6 hours |
+| monthly | 1 day |
+| yearly | 1 day |
+
+## Firestore Collections
+
+| Collection | Description |
+|---|---|
+| `subscriptionPlans` | Plan definitions |
+| `subscriptions` | User subscription records |
+| `payments` | Payment transactions |
+| `tokenPacks` | Token pack definitions |
+| `userTokenBalances` | Per-user token balances |
+
+## License
+
+ISC

package/USAGE.md

@@ -0,0 +1,400 @@
+# Payment Manager
+
+A standalone TypeScript library for managing subscriptions, one-time token pack purchases, and payment webhooks using **WayForPay** as the payment provider and **Firestore** as the database.
+
+The library is framework-agnostic — it exposes plain async functions that you wire into your own HTTP routes (Express, Fastify, Cloud Functions, etc.).
+
+## Key Features
+
+- Full subscription lifecycle: create, upgrade/downgrade with proration, cancel, expire
+- One-time token pack purchases (extra credits beyond subscription limits)
+- WayForPay webhook handling for payment confirmation and recurrent billing
+- Cron-compatible subscription expiration check with configurable grace periods
+- Payment URL caching (avoids duplicate WayForPay API calls within a 5-minute window)
+- Typed custom error classes for every failure scenario
+- Optional structured logging
+
+## Installation
+
+```bash
+npm install payment-manager
+```
+
+### Peer Dependencies
+
+The library requires `firebase-admin` (>=12.0.0) as a peer dependency. Install it in your project if you haven't already:
+
+```bash
+npm install firebase-admin
+```
+
+## Quick Start
+
+```typescript
+import * as admin from 'firebase-admin';
+import { init } from 'payment-manager';
+
+admin.initializeApp();
+const firestore = admin.firestore();
+
+const pm = init({
+  firestore,
+  wayforpay: {
+    merchantAccount: 'your_merchant_account',
+    merchantSecretKey: 'your_merchant_secret_key',
+    merchantDomainName: 'yourdomain.com',
+  },
+  platform: 'my-app',
+  webhookSecret: 'your-webhook-secret',   // optional
+  logger: console,                         // optional
+});
+
+// Seed your plans into Firestore
+await pm.plans.seedDefaultPlans([
+  { id: 'basic-monthly', name: 'Basic Monthly', amount: 100, regularMode: 'monthly', isActive: true },
+  { id: 'pro-monthly', name: 'Pro Monthly', amount: 300, regularMode: 'monthly', isActive: true },
+]);
+
+// Create a subscription (returns a WayForPay payment URL)
+const { paymentUrl } = await pm.subscriptions.create({
+  userId: 'user-123',
+  planId: 'basic-monthly',
+  currency: 'UAH',
+  productName: 'My App Subscription',
+});
+```
+
+## Configuration
+
+Pass a `PaymentManagerConfig` object to `init()`:
+
+```typescript
+interface PaymentManagerConfig {
+  /** Firestore instance from firebase-admin */
+  firestore: Firestore;
+
+  /** WayForPay merchant credentials */
+  wayforpay: {
+    merchantAccount: string;
+    merchantSecretKey: string;
+    merchantDomainName: string;
+  };
+
+  /** Platform identifier included in order references */
+  platform: string;
+
+  /**
+   * Secret for validating incoming webhook requests (x-secret-key header).
+   * Falls back to process.env.NOTIFY_TELEGRAM_USER_SECRET if not provided.
+   */
+  webhookSecret?: string;
+
+  /**
+   * Optional logger. Any object with info/warn/error methods works
+   * (e.g. console, winston, pino).
+   */
+  logger?: {
+    info: (message: string, ...args: unknown[]) => void;
+    warn: (message: string, ...args: unknown[]) => void;
+    error: (message: string, ...args: unknown[]) => void;
+  };
+}
+```
+
+Calling any method before `init()` throws:
+```
+Error: PaymentManager is not initialized. Call init(config) first.
+```
+
+## API Reference
+
+The `init()` function returns a `PaymentManager` object with five namespaces:
+
+### `pm.plans` — Subscription Plan Management
+
+```typescript
+// Seed your plans into Firestore (upserts by ID)
+await pm.plans.seedDefaultPlans([
+  { id: 'basic-monthly', name: 'Basic Monthly', amount: 100, regularMode: 'monthly', isActive: true },
+  { id: 'pro-monthly', name: 'Pro Monthly', amount: 300, regularMode: 'monthly', isActive: true },
+]);
+
+// CRUD operations
+await pm.plans.create({ id: 'enterprise', name: 'Enterprise', amount: 500, regularMode: 'monthly', isActive: true });
+const plan = await pm.plans.getById('basic-monthly');
+const allPlans = await pm.plans.getAll();
+await pm.plans.update('enterprise', { amount: 450 });
+await pm.plans.deactivate('enterprise');
+```
+
+### `pm.subscriptions` — Subscription Lifecycle
+
+```typescript
+// Create a new subscription (cancels any existing active subscription first)
+const { paymentUrl } = await pm.subscriptions.create({
+  userId: 'user-123',
+  planId: 'pro-monthly',
+  currency: 'UAH',
+  productName: 'My App Pro',
+});
+
+// Get current active subscription
+const sub = await pm.subscriptions.getActiveByUserId('user-123');
+
+// Change plan (upgrade = immediate proration, downgrade = applied at next billing cycle)
+await pm.subscriptions.changePlan('user-123', 'basic-monthly');
+
+// Cancel subscription (calls WayForPay cancelRegularPurchase)
+await pm.subscriptions.deactivate('user-123');
+
+// Manually expire a subscription
+await pm.subscriptions.expire('user-123');
+```
+
+**Plan change behavior:**
+- **Upgrade** (higher price): The remaining value of the current plan is prorated and converted into days on the new plan. The change is applied immediately.
+- **Downgrade** (lower price): The new plan is stored as `pendingPlanId` and applied automatically at the next billing cycle.
+
+### `pm.tokenPacks` — One-Time Token Purchases
+
+```typescript
+// Create and manage token packs
+const packId = await pm.tokenPacks.create({ name: '100 Tokens', tokenAmount: 100, price: 50, isActive: true });
+const allPacks = await pm.tokenPacks.getAll();
+await pm.tokenPacks.deactivate(packId);
+await pm.tokenPacks.activate(packId);
+await pm.tokenPacks.remove(packId);
+
+// Purchase tokens (returns a one-time payment URL)
+const { paymentUrl } = await pm.tokenPacks.buyExtraTokens({
+  userId: 'user-123',
+  packId: 'pack-100',
+  currency: 'UAH',
+  productName: '100 Extra Tokens',
+});
+```
+
+### `pm.userTokens` — Token Balance
+
+```typescript
+// Get user's token balance (returns zero-balance default if no record exists)
+const balance = await pm.userTokens.getBalance('user-123');
+// balance: { userId, balance, totalPurchased, updatedAt }
+```
+
+### `pm.webhooks` — Webhook Handlers
+
+```typescript
+// Handle WayForPay PAYMENT_CHECK webhook
+const response = await pm.webhooks.handlePaymentCheck(req.body, req.headers);
+// response: { orderReference, status: 'accept' | 'reject', time, signature }
+
+// Handle subscription expiration check (call from a cron job)
+const result = await pm.webhooks.handleSubscriptionDeactivationCheck(req.headers);
+// result: { expired: string[], downgraded: string[] }
+```
+
+## Wiring into Your Server
+
+### Express Example
+
+```typescript
+import express from 'express';
+import * as admin from 'firebase-admin';
+import { init } from 'payment-manager';
+
+admin.initializeApp();
+const app = express();
+app.use(express.json());
+
+const pm = init({
+  firestore: admin.firestore(),
+  wayforpay: {
+    merchantAccount: process.env.WFP_MERCHANT_ACCOUNT!,
+    merchantSecretKey: process.env.WFP_MERCHANT_SECRET!,
+    merchantDomainName: process.env.WFP_MERCHANT_DOMAIN!,
+  },
+  platform: 'my-app',
+  webhookSecret: process.env.WEBHOOK_SECRET,
+  logger: console,
+});
+
+// --- Plans ---
+app.post('/api/plans/seed', async (req, res) => {
+  await pm.plans.seedDefaultPlans([
+    { id: 'basic-monthly', name: 'Basic Monthly', amount: 100, regularMode: 'monthly', isActive: true },
+    { id: 'pro-monthly', name: 'Pro Monthly', amount: 300, regularMode: 'monthly', isActive: true },
+  ]);
+  res.json({ ok: true });
+});
+
+// --- Subscriptions ---
+app.post('/api/subscriptions', async (req, res) => {
+  const { userId, planId, currency, productName } = req.body;
+  const result = await pm.subscriptions.create({ userId, planId, currency, productName });
+  res.json(result);
+});
+
+app.post('/api/subscriptions/change-plan', async (req, res) => {
+  const { userId, newPlanId } = req.body;
+  await pm.subscriptions.changePlan(userId, newPlanId);
+  res.json({ ok: true });
+});
+
+app.post('/api/subscriptions/cancel', async (req, res) => {
+  await pm.subscriptions.deactivate(req.body.userId);
+  res.json({ ok: true });
+});
+
+// --- Token Packs ---
+app.post('/api/tokens/buy', async (req, res) => {
+  const { userId, packId, currency, productName } = req.body;
+  const result = await pm.tokenPacks.buyExtraTokens({ userId, packId, currency, productName });
+  res.json(result);
+});
+
+app.get('/api/tokens/balance/:userId', async (req, res) => {
+  const balance = await pm.userTokens.getBalance(req.params.userId);
+  res.json(balance);
+});
+
+// --- Webhooks ---
+app.post('/api/webhooks/payment', async (req, res) => {
+  const response = await pm.webhooks.handlePaymentCheck(req.body, req.headers as Record<string, string>);
+  res.json(response);
+});
+
+// --- Cron (subscription expiration check) ---
+app.post('/api/cron/deactivation-check', async (req, res) => {
+  const result = await pm.webhooks.handleSubscriptionDeactivationCheck(req.headers as Record<string, string>);
+  res.json(result);
+});
+
+app.listen(3000);
+```
+
+### Firebase Cloud Functions Example
+
+```typescript
+import * as admin from 'firebase-admin';
+import { onRequest } from 'firebase-functions/v2/https';
+import { onSchedule } from 'firebase-functions/v2/scheduler';
+import { init } from 'payment-manager';
+
+admin.initializeApp();
+
+const pm = init({
+  firestore: admin.firestore(),
+  wayforpay: {
+    merchantAccount: process.env.WFP_MERCHANT_ACCOUNT!,
+    merchantSecretKey: process.env.WFP_MERCHANT_SECRET!,
+    merchantDomainName: process.env.WFP_MERCHANT_DOMAIN!,
+  },
+  platform: 'my-app',
+  webhookSecret: process.env.WEBHOOK_SECRET,
+});
+
+export const createSubscription = onRequest(async (req, res) => {
+  const { userId, planId, currency, productName } = req.body;
+  const result = await pm.subscriptions.create({ userId, planId, currency, productName });
+  res.json(result);
+});
+
+export const wayforpayWebhook = onRequest(async (req, res) => {
+  const response = await pm.webhooks.handlePaymentCheck(req.body, req.headers as Record<string, string>);
+  res.json(response);
+});
+
+export const deactivationCheck = onSchedule('every 1 hours', async () => {
+  const headers = { 'x-secret-key': process.env.WEBHOOK_SECRET };
+  await pm.webhooks.handleSubscriptionDeactivationCheck(headers as Record<string, string>);
+});
+```
+
+## Firestore Collections
+
+The library creates and manages the following Firestore collections:
+
+| Collection | Description |
+|---|---|
+| `subscriptionPlans` | Subscription plan definitions |
+| `subscriptions` | User subscription records |
+| `payments` | Payment transaction records |
+| `tokenPacks` | Token pack definitions |
+| `userTokenBalances` | Per-user token balance |
+
+## Seeding Plans
+
+`pm.plans.seedDefaultPlans(plans)` accepts an array of plan objects and upserts them by ID. Define whatever plans your application needs:
+
+```typescript
+await pm.plans.seedDefaultPlans([
+  { id: 'basic-monthly', name: 'Basic', amount: 100, regularMode: 'monthly', isActive: true },
+  { id: 'pro-monthly', name: 'Pro', amount: 300, regularMode: 'monthly', isActive: true },
+  { id: 'enterprise-yearly', name: 'Enterprise', amount: 3000, regularMode: 'yearly', description: 'Annual enterprise plan', isActive: true },
+]);
+```
+
+## Error Handling
+
+All errors extend `PaymentManagerError` with a `code` property for programmatic handling:
+
+```typescript
+import { PlanNotFoundError, PaymentManagerError } from 'payment-manager';
+
+try {
+  await pm.subscriptions.create({ userId, planId, currency, productName });
+} catch (error) {
+  if (error instanceof PaymentManagerError) {
+    console.error(error.code, error.message);
+  }
+}
+```
+
+| Error Class | Code | When |
+|---|---|---|
+| `PlanNotFoundError` | `PLAN_NOT_FOUND` | Plan ID does not exist |
+| `PlanInactiveError` | `PLAN_INACTIVE` | Plan exists but is deactivated |
+| `SubscriptionNotFoundError` | `SUBSCRIPTION_NOT_FOUND` | No active subscription for user |
+| `SubscriptionAlreadyActiveError` | `SUBSCRIPTION_ALREADY_ACTIVE` | User already has an active subscription |
+| `TokenPackNotFoundError` | `TOKEN_PACK_NOT_FOUND` | Token pack ID does not exist |
+| `TokenPackInactiveError` | `TOKEN_PACK_INACTIVE` | Token pack exists but is deactivated |
+| `InvalidWebhookSecretError` | `INVALID_WEBHOOK_SECRET` | Webhook `x-secret-key` header mismatch |
+| `PaymentProviderError` | `PAYMENT_PROVIDER_ERROR` | WayForPay API call failed |
+| `InvalidOrderReferenceError` | `INVALID_ORDER_REFERENCE` | Malformed order reference string |
+
+## Webhook Secret Validation
+
+Both webhook handlers validate the `x-secret-key` request header against:
+1. The `webhookSecret` from config (if provided)
+2. `process.env.NOTIFY_TELEGRAM_USER_SECRET` (fallback)
+
+If neither is set, secret validation is skipped.
+
+## Grace Periods
+
+The deactivation check handler uses grace periods before expiring subscriptions:
+
+| Billing Cycle | Grace Period |
+|---|---|
+| daily | 6 hours |
+| monthly | 1 day |
+| yearly | 1 day |
+
+## TypeScript
+
+All types are exported from the package root:
+
+```typescript
+import type {
+  PaymentManagerConfig,
+  PaymentManager,
+  SubscriptionPlanEntity,
+  SubscriptionEntity,
+  PaymentEntity,
+  TokenPackEntity,
+  UserTokenBalance,
+  WebhookResponse,
+  DeactivationResult,
+} from 'payment-manager';
+```

package/dist/collections/payments.d.ts

@@ -0,0 +1,6 @@
+import type { PaymentEntity } from '../types/index.js';
+export declare function create(payment: Omit<PaymentEntity, 'id' | 'createdAt' | 'updatedAt'>): Promise<string>;
+export declare function update(paymentId: string, data: Partial<Omit<PaymentEntity, 'id'>>): Promise<void>;
+export declare function findPendingByUserAndPlan(userId: string, planId: string): Promise<PaymentEntity | null>;
+export declare function findPendingByUserAndTokenPack(userId: string, packId: string): Promise<PaymentEntity | null>;
+export declare function findByOrderReference(orderReference: string): Promise<PaymentEntity | null>;

package/dist/collections/payments.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = create;
+exports.update = update;
+exports.findPendingByUserAndPlan = findPendingByUserAndPlan;
+exports.findPendingByUserAndTokenPack = findPendingByUserAndTokenPack;
+exports.findByOrderReference = findByOrderReference;
+const config_js_1 = require("../config.js");
+const COLLECTION = 'payments';
+function collection() {
+    return (0, config_js_1.getConfig)().firestore.collection(COLLECTION);
+}
+async function create(payment) {
+    const now = new Date();
+    const docRef = await collection().add({
+        ...payment,
+        createdAt: now,
+        updatedAt: now,
+    });
+    return docRef.id;
+}
+async function update(paymentId, data) {
+    await collection()
+        .doc(paymentId)
+        .update({
+        ...data,
+        updatedAt: new Date(),
+    });
+}
+async function findPendingByUserAndPlan(userId, planId) {
+    const snapshot = await collection()
+        .where('userId', '==', userId)
+        .where('planId', '==', planId)
+        .where('status', '==', 'pending')
+        .limit(1)
+        .get();
+    if (snapshot.empty)
+        return null;
+    const doc = snapshot.docs[0];
+    return { id: doc.id, ...doc.data() };
+}
+async function findPendingByUserAndTokenPack(userId, packId) {
+    const snapshot = await collection()
+        .where('userId', '==', userId)
+        .where('tokenPackId', '==', packId)
+        .where('status', '==', 'pending')
+        .limit(1)
+        .get();
+    if (snapshot.empty)
+        return null;
+    const doc = snapshot.docs[0];
+    return { id: doc.id, ...doc.data() };
+}
+async function findByOrderReference(orderReference) {
+    const snapshot = await collection().where('orderReference', '==', orderReference).limit(1).get();
+    if (snapshot.empty)
+        return null;
+    const doc = snapshot.docs[0];
+    return { id: doc.id, ...doc.data() };
+}

package/dist/collections/plans.d.ts

@@ -0,0 +1,6 @@
+import type { SubscriptionPlanEntity } from '../types/index.js';
+export declare function getById(planId: string): Promise<SubscriptionPlanEntity | null>;
+export declare function getAll(): Promise<SubscriptionPlanEntity[]>;
+export declare function create(plan: Omit<SubscriptionPlanEntity, 'createdAt' | 'updatedAt'>): Promise<void>;
+export declare function update(planId: string, data: Partial<Omit<SubscriptionPlanEntity, 'id'>>): Promise<void>;
+export declare function upsert(plan: Omit<SubscriptionPlanEntity, 'createdAt' | 'updatedAt'>): Promise<void>;