@misterhomer1992/miit-bot-payment 1.1.6 → 2.0.4

package/src/modules/subscriptionPlan/service.test.ts

@@ -0,0 +1,401 @@
+import { describe, it, beforeEach, mock } from 'node:test';
+import assert from 'node:assert';
+import { SubscriptionPlanService } from './service';
+import type { SubscriptionPlanEntity, ISubscriptionPlanRepository } from './types';
+import type { Logger } from '../logger/types';
+
+// Mock logger
+const createMockLogger = (): Logger => ({
+    info: mock.fn(),
+    warning: mock.fn(),
+    error: mock.fn(),
+    debug: mock.fn(),
+});
+
+// Mock subscription plan entity
+const createMockPlan = (overrides: Partial<SubscriptionPlanEntity> = {}): SubscriptionPlanEntity => ({
+    id: 'plan-monthly',
+    titleCode: 'subscription.plan.monthly.title',
+    descriptionCode: 'subscription.plan.monthly.description',
+    amount: 100,
+    currency: 'UAH',
+    features: {
+        messages: 1000,
+        images: 50,
+        voice: 100,
+    },
+    regularMode: 'monthly',
+    count: 1,
+    credits: 5000,
+    isActive: true,
+    createdAt: '2025-01-01T00:00:00.000Z',
+    updatedAt: '2025-01-01T00:00:00.000Z',
+    ...overrides,
+});
+
+// Mock repository
+const createMockRepository = (overrides: Partial<ISubscriptionPlanRepository> = {}): ISubscriptionPlanRepository => ({
+    getAll: mock.fn(async () => []),
+    getById: mock.fn(async () => null),
+    create: mock.fn(async (params) => ({
+        id: 'new-plan-id',
+        ...params,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+    })),
+    update: mock.fn(async (id, params) => ({
+        ...createMockPlan({ id }),
+        ...params,
+        updatedAt: new Date().toISOString(),
+    })),
+    deactivate: mock.fn(async () => {}),
+    seedDefaults: mock.fn(async () => {}),
+    isEmpty: mock.fn(async () => false),
+    ...overrides,
+});
+
+describe('SubscriptionPlanService', () => {
+    let logger: Logger;
+    let repository: ISubscriptionPlanRepository;
+    let service: SubscriptionPlanService;
+
+    beforeEach(() => {
+        logger = createMockLogger();
+        repository = createMockRepository();
+        service = new SubscriptionPlanService({ logger, repository });
+    });
+
+    describe('getAll', () => {
+        it('should return all plans from repository', async () => {
+            const plans = [createMockPlan({ id: 'plan-1' }), createMockPlan({ id: 'plan-2' })];
+            repository = createMockRepository({
+                getAll: mock.fn(async () => plans),
+                isEmpty: mock.fn(async () => false),
+            });
+            service = new SubscriptionPlanService({ logger, repository });
+
+            const result = await service.getAll();
+
+            assert.strictEqual(result.length, 2);
+            assert.strictEqual(result[0].id, 'plan-1');
+        });
+
+        it('should return cached plans on second call', async () => {
+            const plans = [createMockPlan({ id: 'plan-1' })];
+            const getAllMock = mock.fn(async () => plans);
+            repository = createMockRepository({
+                getAll: getAllMock,
+                isEmpty: mock.fn(async () => false),
+            });
+            service = new SubscriptionPlanService({ logger, repository });
+
+            await service.getAll();
+            await service.getAll();
+
+            // Should only call repository once due to caching
+            assert.strictEqual(getAllMock.mock.calls.length, 1);
+        });
+
+        it('should seed defaults if repository is empty', async () => {
+            const seedDefaultsMock = mock.fn(async () => {});
+            repository = createMockRepository({
+                isEmpty: mock.fn(async () => true),
+                seedDefaults: seedDefaultsMock,
+                getAll: mock.fn(async () => [createMockPlan()]),
+            });
+            service = new SubscriptionPlanService({ logger, repository });
+
+            await service.getAll();
+
+            assert.strictEqual(seedDefaultsMock.mock.calls.length, 1);
+        });
+
+        it('should return empty array on error', async () => {
+            repository = createMockRepository({
+                isEmpty: mock.fn(async () => false),
+                getAll: mock.fn(async () => {
+                    throw new Error('DB error');
+                }),
+            });
+            service = new SubscriptionPlanService({ logger, repository });
+
+            const result = await service.getAll();
+
+            assert.deepStrictEqual(result, []);
+            assert.strictEqual((logger.error as any).mock.calls.length, 1);
+        });
+    });
+
+    describe('getById', () => {
+        it('should return plan from cache if available', async () => {
+            const plans = [createMockPlan({ id: 'plan-1' }), createMockPlan({ id: 'plan-2' })];
+            const getByIdMock = mock.fn(async () => null);
+            repository = createMockRepository({
+                getAll: mock.fn(async () => plans),
+                getById: getByIdMock,
+                isEmpty: mock.fn(async () => false),
+            });
+            service = new SubscriptionPlanService({ logger, repository });
+
+            const result = await service.getById('plan-1');
+
+            assert.strictEqual(result?.id, 'plan-1');
+            // getById should not be called if found in cache
+            assert.strictEqual(getByIdMock.mock.calls.length, 0);
+        });
+
+        it('should fallback to repository if not in cache', async () => {
+            const plan = createMockPlan({ id: 'plan-new' });
+            repository = createMockRepository({
+                getAll: mock.fn(async () => []),
+                getById: mock.fn(async () => plan),
+                isEmpty: mock.fn(async () => false),
+            });
+            service = new SubscriptionPlanService({ logger, repository });
+
+            const result = await service.getById('plan-new');
+
+            assert.strictEqual(result?.id, 'plan-new');
+        });
+
+        it('should return null on error', async () => {
+            repository = createMockRepository({
+                getAll: mock.fn(async () => {
+                    throw new Error('Cache error');
+                }),
+                isEmpty: mock.fn(async () => false),
+            });
+            service = new SubscriptionPlanService({ logger, repository });
+
+            const result = await service.getById('plan-1');
+
+            assert.strictEqual(result, null);
+        });
+    });
+
+    describe('create', () => {
+        it('should create plan successfully', async () => {
+            const createMock = mock.fn(async (params) => ({
+                ...params,
+                id: 'new-plan-id',
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+            }));
+            repository = createMockRepository({ create: createMock });
+            service = new SubscriptionPlanService({ logger, repository });
+
+            const params = {
+                titleCode: 'new.plan.title',
+                descriptionCode: 'new.plan.description',
+                amount: 200,
+                currency: 'UAH' as const,
+                features: { messages: 2000, images: 100, voice: 200 },
+                regularMode: 'monthly' as const,
+                count: 1,
+                credits: 10000,
+                isActive: true,
+            };
+
+            const result = await service.create(params);
+
+            assert.strictEqual(result.id, 'new-plan-id');
+            assert.strictEqual(result.titleCode, params.titleCode);
+        });
+
+        it('should invalidate cache after create', async () => {
+            const plans = [createMockPlan({ id: 'plan-1' })];
+            const getAllMock = mock.fn(async () => plans);
+            repository = createMockRepository({
+                getAll: getAllMock,
+                isEmpty: mock.fn(async () => false),
+            });
+            service = new SubscriptionPlanService({ logger, repository });
+
+            await service.getAll(); // Populate cache
+            await service.create({
+                titleCode: 'new.plan.title',
+                descriptionCode: 'new.plan.description',
+                amount: 200,
+                currency: 'UAH',
+                features: { messages: 2000, images: 100, voice: 200 },
+                regularMode: 'monthly',
+                count: 1,
+                credits: 10000,
+                isActive: true,
+            });
+            await service.getAll(); // Should hit repository again
+
+            assert.strictEqual(getAllMock.mock.calls.length, 2);
+        });
+
+        it('should throw error on repository error', async () => {
+            repository = createMockRepository({
+                create: mock.fn(async () => {
+                    throw new Error('Create error');
+                }),
+            });
+            service = new SubscriptionPlanService({ logger, repository });
+
+            await assert.rejects(
+                async () =>
+                    service.create({
+                        titleCode: 'new.plan.title',
+                        descriptionCode: 'new.plan.description',
+                        amount: 200,
+                        currency: 'UAH',
+                        features: { messages: 2000, images: 100, voice: 200 },
+                        regularMode: 'monthly',
+                        count: 1,
+                        credits: 10000,
+                        isActive: true,
+                    }),
+                { message: 'Create error' },
+            );
+        });
+    });
+
+    describe('update', () => {
+        it('should update plan successfully', async () => {
+            const updateMock = mock.fn(async (id, params) => ({
+                ...createMockPlan({ id }),
+                ...params,
+                updatedAt: new Date().toISOString(),
+            }));
+            repository = createMockRepository({ update: updateMock });
+            service = new SubscriptionPlanService({ logger, repository });
+
+            const result = await service.update('plan-1', { amount: 150 });
+
+            assert.strictEqual(result.id, 'plan-1');
+            assert.strictEqual(result.amount, 150);
+        });
+
+        it('should invalidate cache after update', async () => {
+            const plans = [createMockPlan({ id: 'plan-1' })];
+            const getAllMock = mock.fn(async () => plans);
+            repository = createMockRepository({
+                getAll: getAllMock,
+                isEmpty: mock.fn(async () => false),
+            });
+            service = new SubscriptionPlanService({ logger, repository });
+
+            await service.getAll(); // Populate cache
+            await service.update('plan-1', { amount: 150 });
+            await service.getAll(); // Should hit repository again
+
+            assert.strictEqual(getAllMock.mock.calls.length, 2);
+        });
+
+        it('should throw error on repository error', async () => {
+            repository = createMockRepository({
+                update: mock.fn(async () => {
+                    throw new Error('Update error');
+                }),
+            });
+            service = new SubscriptionPlanService({ logger, repository });
+
+            await assert.rejects(async () => service.update('plan-1', { amount: 150 }), { message: 'Update error' });
+        });
+    });
+
+    describe('deactivate', () => {
+        it('should deactivate plan successfully', async () => {
+            const deactivateMock = mock.fn(async () => {});
+            repository = createMockRepository({ deactivate: deactivateMock });
+            service = new SubscriptionPlanService({ logger, repository });
+
+            await service.deactivate('plan-1');
+
+            const calls = (deactivateMock as any).mock.calls;
+            assert.strictEqual(calls.length, 1);
+            const callArg = calls[0]?.arguments[0];
+            assert.strictEqual(callArg, 'plan-1');
+        });
+
+        it('should invalidate cache after deactivate', async () => {
+            const plans = [createMockPlan({ id: 'plan-1' })];
+            const getAllMock = mock.fn(async () => plans);
+            repository = createMockRepository({
+                getAll: getAllMock,
+                isEmpty: mock.fn(async () => false),
+            });
+            service = new SubscriptionPlanService({ logger, repository });
+
+            await service.getAll(); // Populate cache
+            await service.deactivate('plan-1');
+            await service.getAll(); // Should hit repository again
+
+            assert.strictEqual(getAllMock.mock.calls.length, 2);
+        });
+
+        it('should throw error on repository error', async () => {
+            repository = createMockRepository({
+                deactivate: mock.fn(async () => {
+                    throw new Error('Deactivate error');
+                }),
+            });
+            service = new SubscriptionPlanService({ logger, repository });
+
+            await assert.rejects(async () => service.deactivate('plan-1'), { message: 'Deactivate error' });
+        });
+    });
+
+    describe('resetCache', () => {
+        it('should clear the cache', async () => {
+            const plans = [createMockPlan({ id: 'plan-1' })];
+            const getAllMock = mock.fn(async () => plans);
+            repository = createMockRepository({
+                getAll: getAllMock,
+                isEmpty: mock.fn(async () => false),
+            });
+            service = new SubscriptionPlanService({ logger, repository });
+
+            await service.getAll(); // Populate cache
+            service.resetCache();
+            await service.getAll(); // Should hit repository again
+
+            assert.strictEqual(getAllMock.mock.calls.length, 2);
+            assert.strictEqual((logger.info as any).mock.calls.length, 1);
+        });
+    });
+
+    describe('seedDefaults', () => {
+        it('should seed defaults if repository is empty', async () => {
+            const seedDefaultsMock = mock.fn(async () => {});
+            repository = createMockRepository({
+                isEmpty: mock.fn(async () => true),
+                seedDefaults: seedDefaultsMock,
+            });
+            service = new SubscriptionPlanService({ logger, repository });
+
+            await service.seedDefaults();
+
+            assert.strictEqual(seedDefaultsMock.mock.calls.length, 1);
+            assert.strictEqual((logger.info as any).mock.calls.length, 1);
+        });
+
+        it('should not seed if repository is not empty', async () => {
+            const seedDefaultsMock = mock.fn(async () => {});
+            repository = createMockRepository({
+                isEmpty: mock.fn(async () => false),
+                seedDefaults: seedDefaultsMock,
+            });
+            service = new SubscriptionPlanService({ logger, repository });
+
+            await service.seedDefaults();
+
+            assert.strictEqual(seedDefaultsMock.mock.calls.length, 0);
+        });
+
+        it('should throw error on repository error', async () => {
+            repository = createMockRepository({
+                isEmpty: mock.fn(async () => {
+                    throw new Error('Empty check error');
+                }),
+            });
+            service = new SubscriptionPlanService({ logger, repository });
+
+            await assert.rejects(async () => service.seedDefaults(), { message: 'Empty check error' });
+        });
+    });
+});

package/src/modules/subscriptionPlan/service.ts

@@ -0,0 +1,148 @@
+import { Logger } from '../logger/types';
+import { InMemoryCache } from '../cache/InMemoryCache';
+import { SubscriptionPlanRepository } from './repository';
+import { SubscriptionPlanEntity, ISubscriptionPlanRepository, ISubscriptionPlanService } from './types';
+import { CACHE_TTL_MS, DEFAULT_SUBSCRIPTION_PLANS } from './const';
+
+const CACHE_KEY_ALL_PLANS = 'all_plans';
+
+export class SubscriptionPlanService implements ISubscriptionPlanService {
+    private readonly logger: Logger;
+    private readonly repository: ISubscriptionPlanRepository;
+    private readonly cache: InMemoryCache<SubscriptionPlanEntity[]>;
+
+    constructor({
+        logger,
+        repository,
+    }: {
+        logger: Logger;
+        repository?: ISubscriptionPlanRepository;
+    }) {
+        this.logger = logger;
+        this.repository = repository || new SubscriptionPlanRepository();
+        this.cache = new InMemoryCache<SubscriptionPlanEntity[]>({ ttl: CACHE_TTL_MS });
+    }
+
+    public async getAll(): Promise<SubscriptionPlanEntity[]> {
+        try {
+            const cached = this.cache.get(CACHE_KEY_ALL_PLANS);
+            if (cached) {
+                return cached;
+            }
+
+            await this.ensureSeeded();
+
+            const plans = await this.repository.getAll();
+            this.cache.set(CACHE_KEY_ALL_PLANS, plans);
+            return plans;
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in subscription plan service getAll',
+                payload: { error: JSON.stringify(error) },
+            });
+            return [];
+        }
+    }
+
+    public async getById(id: string): Promise<SubscriptionPlanEntity | null> {
+        try {
+            const allPlans = await this.getAll();
+            const cachedPlan = allPlans.find((plan) => plan.id === id);
+            if (cachedPlan) {
+                return cachedPlan;
+            }
+
+            return await this.repository.getById(id);
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in subscription plan service getById',
+                payload: { id, error: JSON.stringify(error) },
+            });
+            return null;
+        }
+    }
+
+    public async create(
+        params: Omit<SubscriptionPlanEntity, 'id' | 'createdAt' | 'updatedAt'>,
+    ): Promise<SubscriptionPlanEntity> {
+        try {
+            const plan = await this.repository.create(params);
+            this.invalidateCache();
+            return plan;
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in subscription plan service create',
+                payload: { params: JSON.stringify(params), error: JSON.stringify(error) },
+            });
+            throw error;
+        }
+    }
+
+    public async update(
+        id: string,
+        params: Partial<Omit<SubscriptionPlanEntity, 'id' | 'createdAt' | 'updatedAt'>>,
+    ): Promise<SubscriptionPlanEntity> {
+        try {
+            const plan = await this.repository.update(id, params);
+            this.invalidateCache();
+            return plan;
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in subscription plan service update',
+                payload: { id, params: JSON.stringify(params), error: JSON.stringify(error) },
+            });
+            throw error;
+        }
+    }
+
+    public async deactivate(id: string): Promise<void> {
+        try {
+            await this.repository.deactivate(id);
+            this.invalidateCache();
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in subscription plan service deactivate',
+                payload: { id, error: JSON.stringify(error) },
+            });
+            throw error;
+        }
+    }
+
+    public resetCache(): void {
+        this.cache.clear();
+        this.logger.info({
+            message: 'Subscription plan cache reset',
+        });
+    }
+
+    public async seedDefaults(): Promise<void> {
+        try {
+            const isEmpty = await this.repository.isEmpty();
+            if (isEmpty) {
+                await this.repository.seedDefaults(DEFAULT_SUBSCRIPTION_PLANS);
+                this.invalidateCache();
+                this.logger.info({
+                    message: 'Default subscription plans seeded',
+                    payload: { count: DEFAULT_SUBSCRIPTION_PLANS.length },
+                });
+            }
+        } catch (error) {
+            this.logger.error({
+                message: 'Error in subscription plan service seedDefaults',
+                payload: { error: JSON.stringify(error) },
+            });
+            throw error;
+        }
+    }
+
+    private async ensureSeeded(): Promise<void> {
+        const isEmpty = await this.repository.isEmpty();
+        if (isEmpty) {
+            await this.seedDefaults();
+        }
+    }
+
+    private invalidateCache(): void {
+        this.cache.delete(CACHE_KEY_ALL_PLANS);
+    }
+}

package/src/modules/subscriptionPlan/types.ts

@@ -0,0 +1,67 @@
+import { NestedPathsAccess } from '../../types/utilities';
+
+type SubscriptionPlanEntity = {
+    id: string;
+    titleCode: string;
+    descriptionCode: string;
+    amount: number;
+    currency: 'UAH' | 'USD';
+    features: {
+        messages: number;
+        images: number;
+        voice: number;
+    };
+    regularMode: 'daily' | 'monthly' | 'yearly';
+    count: number;
+    credits: number;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+};
+
+type SubscriptionPlanFieldPath = NestedPathsAccess<SubscriptionPlanEntity>;
+
+interface ISubscriptionPlanRepository {
+    getAll(): Promise<SubscriptionPlanEntity[]>;
+
+    getById(id: string): Promise<SubscriptionPlanEntity | null>;
+
+    create(params: Omit<SubscriptionPlanEntity, 'id' | 'createdAt' | 'updatedAt'>): Promise<SubscriptionPlanEntity>;
+
+    update(
+        id: string,
+        params: Partial<Omit<SubscriptionPlanEntity, 'id' | 'createdAt' | 'updatedAt'>>,
+    ): Promise<SubscriptionPlanEntity>;
+
+    deactivate(id: string): Promise<void>;
+
+    seedDefaults(defaultPlans: Omit<SubscriptionPlanEntity, 'createdAt' | 'updatedAt'>[]): Promise<void>;
+
+    isEmpty(): Promise<boolean>;
+}
+
+interface ISubscriptionPlanService {
+    getAll(): Promise<SubscriptionPlanEntity[]>;
+
+    getById(id: string): Promise<SubscriptionPlanEntity | null>;
+
+    create(params: Omit<SubscriptionPlanEntity, 'id' | 'createdAt' | 'updatedAt'>): Promise<SubscriptionPlanEntity>;
+
+    update(
+        id: string,
+        params: Partial<Omit<SubscriptionPlanEntity, 'id' | 'createdAt' | 'updatedAt'>>,
+    ): Promise<SubscriptionPlanEntity>;
+
+    deactivate(id: string): Promise<void>;
+
+    resetCache(): void;
+
+    seedDefaults(): Promise<void>;
+}
+
+export type {
+    SubscriptionPlanEntity,
+    SubscriptionPlanFieldPath,
+    ISubscriptionPlanRepository,
+    ISubscriptionPlanService,
+};

package/src/modules/token/const.ts

@@ -0,0 +1,64 @@
+import { TokenPackPlan } from './types';
+
+/**
+ * Default token pack plans available for purchase.
+ * Fixed packs: 10000, 30000, 75000 tokens
+ */
+export const DEFAULT_TOKEN_PACK_PLANS: TokenPackPlan[] = [
+    // UAH Plans
+    {
+        id: 'token-pack-small',
+        titleCode: 'token.pack.small.title',
+        descriptionCode: 'token.pack.small.description',
+        tokens: 10000,
+        amount: 49,
+        currency: 'UAH',
+        isActive: true,
+    },
+    {
+        id: 'token-pack-medium',
+        titleCode: 'token.pack.medium.title',
+        descriptionCode: 'token.pack.medium.description',
+        tokens: 30000,
+        amount: 129,
+        currency: 'UAH',
+        isActive: true,
+    },
+    {
+        id: 'token-pack-large',
+        titleCode: 'token.pack.large.title',
+        descriptionCode: 'token.pack.large.description',
+        tokens: 75000,
+        amount: 299,
+        currency: 'UAH',
+        isActive: true,
+    },
+    // USD Plans
+    {
+        id: 'token-pack-small-usd',
+        titleCode: 'token.pack.small.title',
+        descriptionCode: 'token.pack.small.description',
+        tokens: 10000,
+        amount: 2,
+        currency: 'USD',
+        isActive: true,
+    },
+    {
+        id: 'token-pack-medium-usd',
+        titleCode: 'token.pack.medium.title',
+        descriptionCode: 'token.pack.medium.description',
+        tokens: 30000,
+        amount: 5,
+        currency: 'USD',
+        isActive: true,
+    },
+    {
+        id: 'token-pack-large-usd',
+        titleCode: 'token.pack.large.title',
+        descriptionCode: 'token.pack.large.description',
+        tokens: 75000,
+        amount: 10,
+        currency: 'USD',
+        isActive: true,
+    },
+];

package/src/modules/token/index.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './service';
+export * from './const';