@misterhomer1992/payment-manager 1.0.0

package/dist/types/errors.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidOrderReferenceError = exports.PaymentProviderError = exports.InvalidWebhookSecretError = exports.TokenPackInactiveError = exports.TokenPackNotFoundError = exports.SubscriptionNotFoundError = exports.SubscriptionAlreadyActiveError = exports.PlanInactiveError = exports.PlanNotFoundError = exports.PaymentManagerError = void 0;
+class PaymentManagerError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.name = 'PaymentManagerError';
+        this.code = code;
+    }
+}
+exports.PaymentManagerError = PaymentManagerError;
+class PlanNotFoundError extends PaymentManagerError {
+    constructor(planId) {
+        super(`Plan not found: ${planId}`, 'PLAN_NOT_FOUND');
+        this.name = 'PlanNotFoundError';
+    }
+}
+exports.PlanNotFoundError = PlanNotFoundError;
+class PlanInactiveError extends PaymentManagerError {
+    constructor(planId) {
+        super(`Plan is inactive: ${planId}`, 'PLAN_INACTIVE');
+        this.name = 'PlanInactiveError';
+    }
+}
+exports.PlanInactiveError = PlanInactiveError;
+class SubscriptionAlreadyActiveError extends PaymentManagerError {
+    constructor(userId) {
+        super(`User already has an active subscription: ${userId}`, 'SUBSCRIPTION_ALREADY_ACTIVE');
+        this.name = 'SubscriptionAlreadyActiveError';
+    }
+}
+exports.SubscriptionAlreadyActiveError = SubscriptionAlreadyActiveError;
+class SubscriptionNotFoundError extends PaymentManagerError {
+    constructor(userId) {
+        super(`No active subscription found for user: ${userId}`, 'SUBSCRIPTION_NOT_FOUND');
+        this.name = 'SubscriptionNotFoundError';
+    }
+}
+exports.SubscriptionNotFoundError = SubscriptionNotFoundError;
+class TokenPackNotFoundError extends PaymentManagerError {
+    constructor(packId) {
+        super(`Token pack not found: ${packId}`, 'TOKEN_PACK_NOT_FOUND');
+        this.name = 'TokenPackNotFoundError';
+    }
+}
+exports.TokenPackNotFoundError = TokenPackNotFoundError;
+class TokenPackInactiveError extends PaymentManagerError {
+    constructor(packId) {
+        super(`Token pack is inactive: ${packId}`, 'TOKEN_PACK_INACTIVE');
+        this.name = 'TokenPackInactiveError';
+    }
+}
+exports.TokenPackInactiveError = TokenPackInactiveError;
+class InvalidWebhookSecretError extends PaymentManagerError {
+    constructor() {
+        super('Invalid webhook secret', 'INVALID_WEBHOOK_SECRET');
+        this.name = 'InvalidWebhookSecretError';
+    }
+}
+exports.InvalidWebhookSecretError = InvalidWebhookSecretError;
+class PaymentProviderError extends PaymentManagerError {
+    constructor(message) {
+        super(message, 'PAYMENT_PROVIDER_ERROR');
+        this.name = 'PaymentProviderError';
+    }
+}
+exports.PaymentProviderError = PaymentProviderError;
+class InvalidOrderReferenceError extends PaymentManagerError {
+    constructor(orderReference) {
+        super(`Invalid order reference: ${orderReference}`, 'INVALID_ORDER_REFERENCE');
+        this.name = 'InvalidOrderReferenceError';
+    }
+}
+exports.InvalidOrderReferenceError = InvalidOrderReferenceError;

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+export { SubscriptionPlanEntity } from './plan.js';
+export { SubscriptionEntity } from './subscription.js';
+export { PaymentEntity } from './payment.js';
+export { TokenPackEntity, UserTokenBalance } from './tokenPack.js';
+export { WebhookResponse, DeactivationResult, ServiceUrlRequestParams } from './webhook.js';
+export { OrderReferenceParams, ParsedOrderReference } from './orderReference.js';
+export { PaymentManagerError, PlanNotFoundError, PlanInactiveError, SubscriptionAlreadyActiveError, SubscriptionNotFoundError, TokenPackNotFoundError, TokenPackInactiveError, InvalidWebhookSecretError, PaymentProviderError, InvalidOrderReferenceError, } from './errors.js';

package/dist/types/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidOrderReferenceError = exports.PaymentProviderError = exports.InvalidWebhookSecretError = exports.TokenPackInactiveError = exports.TokenPackNotFoundError = exports.SubscriptionNotFoundError = exports.SubscriptionAlreadyActiveError = exports.PlanInactiveError = exports.PlanNotFoundError = exports.PaymentManagerError = void 0;
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "PaymentManagerError", { enumerable: true, get: function () { return errors_js_1.PaymentManagerError; } });
+Object.defineProperty(exports, "PlanNotFoundError", { enumerable: true, get: function () { return errors_js_1.PlanNotFoundError; } });
+Object.defineProperty(exports, "PlanInactiveError", { enumerable: true, get: function () { return errors_js_1.PlanInactiveError; } });
+Object.defineProperty(exports, "SubscriptionAlreadyActiveError", { enumerable: true, get: function () { return errors_js_1.SubscriptionAlreadyActiveError; } });
+Object.defineProperty(exports, "SubscriptionNotFoundError", { enumerable: true, get: function () { return errors_js_1.SubscriptionNotFoundError; } });
+Object.defineProperty(exports, "TokenPackNotFoundError", { enumerable: true, get: function () { return errors_js_1.TokenPackNotFoundError; } });
+Object.defineProperty(exports, "TokenPackInactiveError", { enumerable: true, get: function () { return errors_js_1.TokenPackInactiveError; } });
+Object.defineProperty(exports, "InvalidWebhookSecretError", { enumerable: true, get: function () { return errors_js_1.InvalidWebhookSecretError; } });
+Object.defineProperty(exports, "PaymentProviderError", { enumerable: true, get: function () { return errors_js_1.PaymentProviderError; } });
+Object.defineProperty(exports, "InvalidOrderReferenceError", { enumerable: true, get: function () { return errors_js_1.InvalidOrderReferenceError; } });

package/dist/types/orderReference.d.ts

@@ -0,0 +1,18 @@
+export interface OrderReferenceParams {
+    version: string;
+    platform: string;
+    userId: string;
+    type: 'sub' | 'tkn';
+    planId?: string;
+    tokenPackId?: string;
+    date: Date;
+}
+export interface ParsedOrderReference {
+    version: string;
+    platform: string;
+    userId: string;
+    type: 'sub' | 'tkn';
+    planId?: string;
+    tokenPackId?: string;
+    date: Date;
+}

package/dist/types/orderReference.js

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

package/dist/types/payment.d.ts

@@ -0,0 +1,14 @@
+export interface PaymentEntity {
+    id: string;
+    userId: string;
+    planId?: string;
+    tokenPackId?: string;
+    amount: number;
+    currency: string;
+    status: 'pending' | 'approved' | 'rejected';
+    orderReference: string;
+    paymentLink?: string;
+    paymentLinkCreatedAt?: Date;
+    createdAt: Date;
+    updatedAt: Date;
+}

package/dist/types/payment.js

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

package/dist/types/plan.d.ts

@@ -0,0 +1,10 @@
+export interface SubscriptionPlanEntity {
+    id: string;
+    name: string;
+    amount: number;
+    regularMode: 'daily' | 'monthly' | 'yearly';
+    description?: string;
+    isActive: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}

package/dist/types/plan.js

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

package/dist/types/subscription.d.ts

@@ -0,0 +1,12 @@
+export interface SubscriptionEntity {
+    id: string;
+    userId: string;
+    planId: string;
+    status: 'active' | 'cancelled' | 'expired';
+    startedAt: Date;
+    expiresAt: Date;
+    pendingPlanId?: string;
+    pendingPlanChangeDate?: Date;
+    createdAt: Date;
+    updatedAt: Date;
+}

package/dist/types/subscription.js

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

package/dist/types/tokenPack.d.ts

@@ -0,0 +1,15 @@
+export interface TokenPackEntity {
+    id: string;
+    name: string;
+    tokenAmount: number;
+    price: number;
+    isActive: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface UserTokenBalance {
+    userId: string;
+    balance: number;
+    totalPurchased: number;
+    updatedAt: Date;
+}

package/dist/types/tokenPack.js

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

package/dist/types/webhook.d.ts

@@ -0,0 +1,32 @@
+export interface WebhookResponse {
+    orderReference: string;
+    status: 'accept' | 'reject';
+    time: string;
+    signature: string;
+}
+export interface DeactivationResult {
+    expired: string[];
+    downgraded: string[];
+}
+export interface ServiceUrlRequestParams {
+    merchantAccount: string;
+    orderReference: string;
+    merchantSignature: string;
+    amount: number;
+    currency: string;
+    authCode: string;
+    email: string;
+    phone: string;
+    createdDate: number;
+    processingDate: number;
+    cardPan: string;
+    cardType: string;
+    issuerBankCountry: string;
+    issuerBankName: string;
+    recToken: string;
+    transactionStatus: string;
+    reason: string;
+    reasonCode: number;
+    fee: number;
+    paymentSystem: string;
+}

package/dist/types/webhook.js

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

package/dist/utils/gracePeriod.d.ts

@@ -0,0 +1,3 @@
+import type { SubscriptionPlanEntity } from '../types/plan.js';
+export declare function getGracePeriod(regularMode: SubscriptionPlanEntity['regularMode']): number;
+export declare function getExpirationWithGrace(expiresAt: Date, regularMode: SubscriptionPlanEntity['regularMode']): Date;

package/dist/utils/gracePeriod.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGracePeriod = getGracePeriod;
+exports.getExpirationWithGrace = getExpirationWithGrace;
+const MS_PER_HOUR = 60 * 60 * 1000;
+const MS_PER_DAY = 24 * MS_PER_HOUR;
+function getGracePeriod(regularMode) {
+    switch (regularMode) {
+        case 'daily':
+            return 6 * MS_PER_HOUR;
+        case 'monthly':
+            return MS_PER_DAY;
+        case 'yearly':
+            return MS_PER_DAY;
+    }
+}
+function getExpirationWithGrace(expiresAt, regularMode) {
+    return new Date(expiresAt.getTime() + getGracePeriod(regularMode));
+}

package/dist/utils/orderReference.d.ts

@@ -0,0 +1,3 @@
+import type { OrderReferenceParams, ParsedOrderReference } from '../types/orderReference.js';
+export declare function buildOrderReference(params: OrderReferenceParams): string;
+export declare function parseOrderReference(ref: string): ParsedOrderReference;

package/dist/utils/orderReference.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOrderReference = buildOrderReference;
+exports.parseOrderReference = parseOrderReference;
+const errors_js_1 = require("../types/errors.js");
+const PREFIX = 'miiabot';
+function buildOrderReference(params) {
+    const { version, platform, userId, type, planId, tokenPackId, date } = params;
+    const idSegment = type === 'sub' ? `plnId=${planId}` : `tknId=${tokenPackId}`;
+    const utcDate = date.toISOString();
+    return `${PREFIX}_v=${version}_p=${platform}_uid=${userId}_type=${type}_${idSegment}_utcDate=${utcDate}`;
+}
+function parseOrderReference(ref) {
+    // Strip _WFPREG-* suffix added by WayForPay for recurrent payments
+    const cleaned = ref.replace(/_WFPREG-.*$/, '');
+    const vMatch = cleaned.match(/_v=([^_]+)/);
+    const pMatch = cleaned.match(/_p=([^_]+)/);
+    const uidMatch = cleaned.match(/_uid=([^_]+)/);
+    const typeMatch = cleaned.match(/_type=(sub|tkn)/);
+    const dateMatch = cleaned.match(/_utcDate=(.+)$/);
+    if (!vMatch || !pMatch || !uidMatch || !typeMatch || !dateMatch) {
+        throw new errors_js_1.InvalidOrderReferenceError(ref);
+    }
+    if (!cleaned.startsWith(PREFIX + '_')) {
+        throw new errors_js_1.InvalidOrderReferenceError(ref);
+    }
+    const type = typeMatch[1];
+    const parsedDate = new Date(dateMatch[1]);
+    if (isNaN(parsedDate.getTime())) {
+        throw new errors_js_1.InvalidOrderReferenceError(ref);
+    }
+    const result = {
+        version: vMatch[1],
+        platform: pMatch[1],
+        userId: uidMatch[1],
+        type,
+        date: parsedDate,
+    };
+    if (type === 'sub') {
+        const plnMatch = cleaned.match(/_plnId=([^_]+)/);
+        if (!plnMatch)
+            throw new errors_js_1.InvalidOrderReferenceError(ref);
+        result.planId = plnMatch[1];
+    }
+    else {
+        const tknMatch = cleaned.match(/_tknId=([^_]+)/);
+        if (!tknMatch)
+            throw new errors_js_1.InvalidOrderReferenceError(ref);
+        result.tokenPackId = tknMatch[1];
+    }
+    return result;
+}

package/dist/utils/proration.d.ts

@@ -0,0 +1,10 @@
+import type { SubscriptionPlanEntity } from '../types/plan.js';
+export declare function cycleDays(regularMode: SubscriptionPlanEntity['regularMode']): number;
+export interface ProrationResult {
+    remainingRatio: number;
+    remainingValue: number;
+    newDailyRate: number;
+    daysOnNewPlan: number;
+    newExpiresAt: Date;
+}
+export declare function calculateUpgradeProration(currentPlan: SubscriptionPlanEntity, newPlan: SubscriptionPlanEntity, startedAt: Date, expiresAt: Date, now: Date): ProrationResult;

package/dist/utils/proration.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cycleDays = cycleDays;
+exports.calculateUpgradeProration = calculateUpgradeProration;
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+function cycleDays(regularMode) {
+    switch (regularMode) {
+        case 'daily':
+            return 1;
+        case 'monthly':
+            return 30;
+        case 'yearly':
+            return 365;
+    }
+}
+function calculateUpgradeProration(currentPlan, newPlan, startedAt, expiresAt, now) {
+    const totalDays = (expiresAt.getTime() - startedAt.getTime()) / MS_PER_DAY;
+    const daysUsed = (now.getTime() - startedAt.getTime()) / MS_PER_DAY;
+    const remainingDays = totalDays - daysUsed;
+    const remainingRatio = remainingDays / totalDays;
+    const remainingValue = remainingRatio * currentPlan.amount;
+    const newDailyRate = newPlan.amount / cycleDays(newPlan.regularMode);
+    const daysOnNewPlan = remainingValue / newDailyRate;
+    const newExpiresAt = new Date(now.getTime() + daysOnNewPlan * MS_PER_DAY);
+    return {
+        remainingRatio,
+        remainingValue,
+        newDailyRate,
+        daysOnNewPlan,
+        newExpiresAt,
+    };
+}

package/dist/utils/webhookResponse.d.ts

@@ -0,0 +1,2 @@
+import type { WebhookResponse } from '../types/webhook.js';
+export declare function buildWebhookResponse(orderReference: string, status: WebhookResponse['status'], merchantSecretKey: string): WebhookResponse;

package/dist/utils/webhookResponse.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildWebhookResponse = buildWebhookResponse;
+const node_crypto_1 = require("node:crypto");
+function buildWebhookResponse(orderReference, status, merchantSecretKey) {
+    const time = new Date().toISOString();
+    const data = `${orderReference};${status};${time}`;
+    const signature = (0, node_crypto_1.createHmac)('md5', merchantSecretKey).update(data).digest('hex');
+    return { orderReference, status, time, signature };
+}

package/jest.config.ts

@@ -0,0 +1,11 @@
+import type { Config } from 'jest';
+
+const config: Config = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+  },
+};
+
+export default config;

package/package.json

@@ -0,0 +1,29 @@
+{
+	"name": "@misterhomer1992/payment-manager",
+	"version": "1.0.0",
+	"description": "Payment management library with WayForPay and Firebase integration",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"scripts": {
+		"build": "tsc",
+		"test": "jest --passWithNoTests",
+		"prepublishOnly": "npm run build",
+		"format": "prettier --write \"src/**/*.ts\""
+	},
+	"author": "",
+	"license": "ISC",
+	"dependencies": {
+		"@misterhomer1992/wayforpay-api": "^3.0.1"
+	},
+	"peerDependencies": {
+		"firebase-admin": ">=12.0.0"
+	},
+	"devDependencies": {
+		"@types/jest": "^29.5.14",
+		"jest": "^29.7.0",
+		"prettier": "^3.8.1",
+		"ts-jest": "^29.2.5",
+		"ts-node": "^10.9.2",
+		"typescript": "^5.7.3"
+	}
+}

package/src/collections/payments.ts

@@ -0,0 +1,61 @@
+import { getConfig } from '../config.js';
+import type { PaymentEntity } from '../types/index.js';
+
+const COLLECTION = 'payments';
+
+function collection() {
+	return getConfig().firestore.collection(COLLECTION);
+}
+
+export async function create(payment: Omit<PaymentEntity, 'id' | 'createdAt' | 'updatedAt'>): Promise<string> {
+	const now = new Date();
+	const docRef = await collection().add({
+		...payment,
+		createdAt: now,
+		updatedAt: now,
+	});
+	return docRef.id;
+}
+
+export async function update(paymentId: string, data: Partial<Omit<PaymentEntity, 'id'>>): Promise<void> {
+	await collection()
+		.doc(paymentId)
+		.update({
+			...data,
+			updatedAt: new Date(),
+		});
+}
+
+export async function findPendingByUserAndPlan(userId: string, planId: string): Promise<PaymentEntity | null> {
+	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() } as PaymentEntity;
+}
+
+export async function findPendingByUserAndTokenPack(userId: string, packId: string): Promise<PaymentEntity | null> {
+	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() } as PaymentEntity;
+}
+
+export async function findByOrderReference(orderReference: string): Promise<PaymentEntity | null> {
+	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() } as PaymentEntity;
+}

package/src/collections/plans.ts

@@ -0,0 +1,53 @@
+import { getConfig } from '../config.js';
+import type { SubscriptionPlanEntity } from '../types/index.js';
+
+const COLLECTION = 'subscriptionPlans';
+
+function collection() {
+	return getConfig().firestore.collection(COLLECTION);
+}
+
+export async function getById(planId: string): Promise<SubscriptionPlanEntity | null> {
+	const doc = await collection().doc(planId).get();
+	if (!doc.exists) return null;
+	return { id: doc.id, ...doc.data() } as SubscriptionPlanEntity;
+}
+
+export async function getAll(): Promise<SubscriptionPlanEntity[]> {
+	const snapshot = await collection().get();
+	return snapshot.docs.map((doc) => ({ id: doc.id, ...doc.data() }) as SubscriptionPlanEntity);
+}
+
+export async function create(plan: Omit<SubscriptionPlanEntity, 'createdAt' | 'updatedAt'>): Promise<void> {
+	const now = new Date();
+	await collection()
+		.doc(plan.id)
+		.set({
+			...plan,
+			createdAt: now,
+			updatedAt: now,
+		});
+}
+
+export async function update(planId: string, data: Partial<Omit<SubscriptionPlanEntity, 'id'>>): Promise<void> {
+	await collection()
+		.doc(planId)
+		.update({
+			...data,
+			updatedAt: new Date(),
+		});
+}
+
+export async function upsert(plan: Omit<SubscriptionPlanEntity, 'createdAt' | 'updatedAt'>): Promise<void> {
+	const now = new Date();
+	await collection()
+		.doc(plan.id)
+		.set(
+			{
+				...plan,
+				createdAt: now,
+				updatedAt: now,
+			},
+			{ merge: true },
+		);
+}

package/src/collections/subscriptions.ts

@@ -0,0 +1,52 @@
+import { getConfig } from '../config.js';
+import type { SubscriptionEntity } from '../types/index.js';
+
+const COLLECTION = 'subscriptions';
+
+function collection() {
+	return getConfig().firestore.collection(COLLECTION);
+}
+
+export async function getActiveByUserId(userId: string): Promise<SubscriptionEntity | null> {
+	const snapshot = await collection().where('userId', '==', userId).where('status', '==', 'active').limit(1).get();
+
+	if (snapshot.empty) return null;
+	const doc = snapshot.docs[0];
+	return { id: doc.id, ...doc.data() } as SubscriptionEntity;
+}
+
+export async function getByUserId(userId: string): Promise<SubscriptionEntity[]> {
+	const snapshot = await collection()
+		.where('userId', '==', userId)
+		.where('status', 'in', ['active', 'cancelled'])
+		.get();
+
+	return snapshot.docs.map((doc) => ({ id: doc.id, ...doc.data() }) as SubscriptionEntity);
+}
+
+export async function create(
+	subscription: Omit<SubscriptionEntity, 'id' | 'createdAt' | 'updatedAt'>,
+): Promise<string> {
+	const now = new Date();
+	const docRef = await collection().add({
+		...subscription,
+		createdAt: now,
+		updatedAt: now,
+	});
+	return docRef.id;
+}
+
+export async function update(subscriptionId: string, data: Partial<Omit<SubscriptionEntity, 'id'>>): Promise<void> {
+	await collection()
+		.doc(subscriptionId)
+		.update({
+			...data,
+			updatedAt: new Date(),
+		});
+}
+
+export async function getAllActiveAndCancelled(): Promise<SubscriptionEntity[]> {
+	const snapshot = await collection().where('status', 'in', ['active', 'cancelled']).get();
+
+	return snapshot.docs.map((doc) => ({ id: doc.id, ...doc.data() }) as SubscriptionEntity);
+}

package/src/collections/tokenPacks.ts

@@ -0,0 +1,42 @@
+import { getConfig } from '../config.js';
+import type { TokenPackEntity } from '../types/index.js';
+
+const COLLECTION = 'tokenPacks';
+
+function collection() {
+	return getConfig().firestore.collection(COLLECTION);
+}
+
+export async function getById(packId: string): Promise<TokenPackEntity | null> {
+	const doc = await collection().doc(packId).get();
+	if (!doc.exists) return null;
+	return { id: doc.id, ...doc.data() } as TokenPackEntity;
+}
+
+export async function getAll(): Promise<TokenPackEntity[]> {
+	const snapshot = await collection().get();
+	return snapshot.docs.map((doc) => ({ id: doc.id, ...doc.data() }) as TokenPackEntity);
+}
+
+export async function create(pack: Omit<TokenPackEntity, 'id' | 'createdAt' | 'updatedAt'>): Promise<string> {
+	const now = new Date();
+	const docRef = await collection().add({
+		...pack,
+		createdAt: now,
+		updatedAt: now,
+	});
+	return docRef.id;
+}
+
+export async function update(packId: string, data: Partial<Omit<TokenPackEntity, 'id'>>): Promise<void> {
+	await collection()
+		.doc(packId)
+		.update({
+			...data,
+			updatedAt: new Date(),
+		});
+}
+
+export async function remove(packId: string): Promise<void> {
+	await collection().doc(packId).delete();
+}