Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp

feat(api/admin): allow lifetime gift codes on self-hosted

Hampuse1bf263d52d4
diff --git a/fluxer_api/src/api/admin/controllers/CodesAdminController.ts b/fluxer_api/src/api/admin/controllers/CodesAdminController.ts
index 0e9e1c621..81ab1cf16 100644
--- a/fluxer_api/src/api/admin/controllers/CodesAdminController.ts
+++ b/fluxer_api/src/api/admin/controllers/CodesAdminController.ts
@@ -12,6 +12,7 @@ import type {HonoApp} from '@app/api/types/HonoEnv';
import {Validator} from '@app/api/Validator';
import {AdminACLs} from '@fluxer/constants/src/AdminACLs';
import {FeatureNotAvailableSelfHostedError} from '@fluxer/errors/src/domains/core/FeatureNotAvailableSelfHostedError';
+import {InputValidationError} from '@fluxer/errors/src/domains/core/InputValidationError';
import {CodesResponse, GenerateGiftCodesRequest} from '@fluxer/schema/src/domains/admin/AdminSchemas';
function trimTrailingSlash(value: string): string {
@@ -28,7 +29,7 @@ export function CodesAdminController(app: HonoApp) {
operationId: 'create_admin_gift_codes',
summary: 'Issue gift codes',
description:
- 'Create one-use premium gift codes with an explicit positive duration and return their complete redemption links. Lifetime gifts are not supported. On self-hosted instances the premium mode must be mirror. Requires GIFT_CODES_GENERATE permission.',
+ 'Create one-use premium gift codes and return their complete redemption links. Use a positive duration, or on a self-hosted instance the duration type lifetime for premium that never ends. On self-hosted instances the premium mode must be mirror. Requires GIFT_CODES_GENERATE permission.',
responseSchema: CodesResponse,
statusCode: 200,
security: 'adminApiKey',
@@ -40,6 +41,9 @@ export function CodesAdminController(app: HonoApp) {
}
const adminService = ctx.get('adminService');
const {count, duration_type, duration_quantity} = ctx.req.valid('json');
+ if (duration_type === 'lifetime' && !Config.instance.selfHosted) {
+ throw InputValidationError.create('duration_type', 'Lifetime gift codes are only for self-hosted instances');
+ }
const codes = await adminService.codeGenerationService.generateGiftCodes({
count,
durationType: duration_type,
diff --git a/fluxer_api/src/api/admin/services/AdminCodeGenerationService.ts b/fluxer_api/src/api/admin/services/AdminCodeGenerationService.ts
index a0d0fb9e9..e1fda4297 100644
--- a/fluxer_api/src/api/admin/services/AdminCodeGenerationService.ts
+++ b/fluxer_api/src/api/admin/services/AdminCodeGenerationService.ts
@@ -10,7 +10,7 @@ const DURATION_TYPES = new Set<GiftCodeDurationType>(['days', 'weeks', 'months',
interface GenerateGiftCodesOptions {
count: number;
- durationType: GiftCodeDurationType;
+ durationType: GiftCodeDurationType | 'lifetime';
durationQuantity: number;
createdByUserId: UserID;
}
@@ -19,7 +19,10 @@ export class AdminCodeGenerationService {
constructor(private readonly userRepository: UserRepository) {}
async generateGiftCodes(options: GenerateGiftCodesOptions): Promise<Array<string>> {
- const {count, durationType, durationQuantity, createdByUserId} = this.validateOptions(options);
+ const {count, createdByUserId} = this.validateOptions(options);
+ const lifetime = options.durationType === 'lifetime';
+ const durationType = options.durationType === 'lifetime' ? 'months' : options.durationType;
+ const durationQuantity = lifetime ? 0 : options.durationQuantity;
const durationMonths = mapGiftCodeDurationToMonths(durationType, durationQuantity);
const codes: Array<string> = [];
for (let i = 0; i < count; i += 1) {
@@ -42,6 +45,9 @@ export class AdminCodeGenerationService {
if (!Number.isInteger(options.count) || options.count < 1 || options.count > MAX_CODES_PER_REQUEST) {
throw new Error(`Gift code count must be between 1 and ${MAX_CODES_PER_REQUEST}`);
}
+ if (options.durationType === 'lifetime') {
+ return options;
+ }
if (!DURATION_TYPES.has(options.durationType)) {
throw new Error(`Unsupported gift code duration type: ${options.durationType}`);
}
diff --git a/fluxer_api/src/api/admin/tests/LifetimeGiftCodes.test.ts b/fluxer_api/src/api/admin/tests/LifetimeGiftCodes.test.ts
new file mode 100644
index 000000000..34e208b91
--- /dev/null
+++ b/fluxer_api/src/api/admin/tests/LifetimeGiftCodes.test.ts
@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+import {createTestAccount, setUserACLs, type TestAccount} from '@app/api/auth/tests/AuthTestUtils';
+import {createUserID} from '@app/api/BrandedTypes';
+import {getConfig} from '@app/api/Config';
+import {getCachedInstancePremiumMode, setCachedInstancePremiumMode} from '@app/api/limits/InstancePremiumModeCache';
+import {
+ getInstanceConfigRepository,
+ getLimitConfigService,
+ getUserRepository,
+} from '@app/api/middleware/ServiceSingletons';
+import {getStoredBillingConfig, setStoredBillingConfig} from '@app/api/stripe/BillingConfigCache';
+import {type ApiTestHarness, createApiTestHarness} from '@app/api/test/ApiTestHarness';
+import {HTTP_STATUS} from '@app/api/test/TestConstants';
+import {createBuilder, createBuilderWithoutAuth} from '@app/api/test/TestRequestBuilder';
+import {fetchUserMe} from '@app/api/user/tests/UserTestUtils';
+import {AccountIdentityModes} from '@fluxer/constants/src/AccountIdentityConstants';
+import {AdminACLs} from '@fluxer/constants/src/AdminACLs';
+import {APIErrorCodes} from '@fluxer/constants/src/ApiErrorCodes';
+import {UserPremiumTypes} from '@fluxer/constants/src/UserConstants';
+import {afterAll, beforeAll, beforeEach, describe, expect, it} from 'vitest';
+
+describe('lifetime gift codes on a self-hosted instance', () => {
+ let harness: ApiTestHarness;
+ let admin: TestAccount;
+ const originalSelfHosted = getConfig().instance.selfHosted;
+ const originalPremiumMode = getCachedInstancePremiumMode();
+ const originalBilling = getStoredBillingConfig();
+
+ beforeAll(async () => {
+ getConfig().instance.selfHosted = true;
+ harness = await createApiTestHarness();
+ });
+
+ beforeEach(async () => {
+ await harness.reset();
+ await getInstanceConfigRepository().setAppPublicConfig({setup: {configured: true}});
+ setStoredBillingConfig(null);
+ await getLimitConfigService().updatePolicyConfig({premium_mode: 'mirror'});
+ setCachedInstancePremiumMode('mirror');
+ admin = await setUserACLs(harness, await createTestAccount(harness), [
+ AdminACLs.AUTHENTICATE,
+ AdminACLs.GIFT_CODES_GENERATE,
+ ]);
+ });
+
+ afterAll(async () => {
+ await harness.shutdown();
+ getConfig().instance.selfHosted = originalSelfHosted;
+ setCachedInstancePremiumMode(originalPremiumMode);
+ setStoredBillingConfig(originalBilling);
+ });
+
+ async function generate(body: Record<string, unknown>): Promise<string> {
+ const {codes} = await createBuilder<{codes: Array<string>}>(harness, admin.token)
+ .post('/admin/gift-codes')
+ .body({count: 1, ...body})
+ .execute();
+ const code = codes[0]?.split('/').pop();
+ if (!code) throw new Error('no gift code generated');
+ return code;
+ }
+
+ it('issues a lifetime code that grants lifetime premium', async () => {
+ const code = await generate({duration_type: 'lifetime', duration_quantity: 1});
+ const gift = await createBuilderWithoutAuth<{duration_quantity: number}>(harness).get(`/gifts/${code}`).execute();
+ expect(gift.duration_quantity).toBe(0);
+ const account = await createTestAccount(harness);
+ await createBuilder(harness, account.token).post(`/gifts/${code}/redeem`).expect(HTTP_STATUS.NO_CONTENT).execute();
+ const {json: me} = await fetchUserMe(harness, account.token);
+ expect(me.premium_type).toBe(UserPremiumTypes.LIFETIME);
+ expect(me.premium_until ?? null).toBeNull();
+ expect(me.traits).toContain('premium');
+ });
+
+ it('lets an account on a username instance redeem a code', async () => {
+ await getInstanceConfigRepository().setAccountIdentityMode(AccountIdentityModes.USERNAME, 'setup');
+ const code = await generate({duration_type: 'lifetime', duration_quantity: 1});
+ const account = await createTestAccount(harness);
+ const user = await getUserRepository().findUniqueAssert(createUserID(BigInt(account.userId)));
+ await getUserRepository().patchUpsert(user.id, {email: null, email_verified: false}, user.toRow());
+ await createBuilder(harness, account.token).post(`/gifts/${code}/redeem`).expect(HTTP_STATUS.NO_CONTENT).execute();
+ const {json: me} = await fetchUserMe(harness, account.token);
+ expect(me.premium_type).toBe(UserPremiumTypes.LIFETIME);
+ });
+
+ it('grants lifetime premium without taking a visionary number', async () => {
+ const slotsBefore = await getUserRepository().listVisionarySlots();
+ const code = await generate({duration_type: 'lifetime', duration_quantity: 1});
+ const account = await createTestAccount(harness);
+ await createBuilder(harness, account.token).post(`/gifts/${code}/redeem`).expect(HTTP_STATUS.NO_CONTENT).execute();
+ const user = await getUserRepository().findUnique(createUserID(BigInt(account.userId)));
+ expect(user?.premiumType).toBe(UserPremiumTypes.LIFETIME);
+ expect(user?.premiumLifetimeSequence ?? null).toBeNull();
+ expect(await getUserRepository().listVisionarySlots()).toEqual(slotsBefore);
+ });
+
+ it('refuses lifetime codes on the hosted instance, where lifetime is Visionary', async () => {
+ getConfig().instance.selfHosted = false;
+ try {
+ await createBuilder(harness, admin.token)
+ .post('/admin/gift-codes')
+ .body({count: 1, duration_type: 'lifetime', duration_quantity: 1})
+ .expect(HTTP_STATUS.BAD_REQUEST, APIErrorCodes.INVALID_FORM_BODY)
+ .execute();
+ } finally {
+ getConfig().instance.selfHosted = true;
+ }
+ });
+
+ it('still issues codes with a duration', async () => {
+ const code = await generate({duration_type: 'months', duration_quantity: 3});
+ const gift = await createBuilderWithoutAuth<{duration_type: string; duration_quantity: number}>(harness)
+ .get(`/gifts/${code}`)
+ .execute();
+ expect(gift).toMatchObject({duration_type: 'months', duration_quantity: 3});
+ });
+});