clhq-postgres-module 1.1.0-alpha.100

package/dist/repositories/referral-event.repository.js

@@ -0,0 +1,154 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReferralEventRepository = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const base_repository_1 = require("./base.repository");
+const referral_event_entity_1 = require("../entities/referral-event.entity");
+let ReferralEventRepository = class ReferralEventRepository extends base_repository_1.BaseRepository {
+    constructor(repository) {
+        super(repository);
+        this.repository = repository;
+    }
+    async findByReferrerId(referrerId, options) {
+        const query = this.repository
+            .createQueryBuilder('re')
+            .where('re.referrer_id = :referrerId', { referrerId })
+            .leftJoinAndSelect('re.referred', 'referred')
+            .orderBy('re.signup_at', 'DESC');
+        if (options?.status) {
+            query.andWhere('re.status = :status', { status: options.status });
+        }
+        if (options?.limit) {
+            query.take(options.limit);
+        }
+        if (options?.offset) {
+            query.skip(options.offset);
+        }
+        return query.getMany();
+    }
+    async findByReferredId(referredId) {
+        return this.repository.find({
+            where: { referredId },
+            relations: ['referrer'],
+            order: { signupAt: 'DESC' },
+        });
+    }
+    async findByReferralPair(referrerId, referredId) {
+        return this.repository.findOne({
+            where: { referrerId, referredId },
+            relations: ['referrer', 'referred'],
+        });
+    }
+    async findByReferralCode(referralCode) {
+        return this.repository.find({
+            where: { referralCode },
+            relations: ['referrer', 'referred'],
+            order: { signupAt: 'DESC' },
+        });
+    }
+    async countConversionsByReferrer(referrerId) {
+        return this.repository.count({
+            where: {
+                referrerId,
+                status: referral_event_entity_1.ReferralStatus.CONVERTED,
+            },
+        });
+    }
+    async countSignupsByReferrer(referrerId) {
+        return this.repository.count({
+            where: { referrerId },
+        });
+    }
+    async getReferralStats(referrerId) {
+        const stats = await this.repository
+            .createQueryBuilder('re')
+            .select([
+            'COUNT(*) as totalSignups',
+            'COUNT(CASE WHEN re.status = :converted THEN 1 END) as totalConversions',
+            'SUM(re.referrer_reward_amount) as totalRewardAmount',
+        ])
+            .where('re.referrer_id = :referrerId', { referrerId })
+            .setParameters({ converted: referral_event_entity_1.ReferralStatus.CONVERTED })
+            .getRawOne();
+        const totalSignups = Number(stats.totalSignups) || 0;
+        const totalConversions = Number(stats.totalConversions) || 0;
+        const conversionRate = totalSignups > 0 ? (totalConversions / totalSignups) * 100 : 0;
+        const totalRewardAmount = Number(stats.totalRewardAmount) || 0;
+        return {
+            totalSignups,
+            totalConversions,
+            conversionRate,
+            totalRewardAmount,
+        };
+    }
+    async updateStatus(id, status, additionalData) {
+        const updateData = { status };
+        if (additionalData) {
+            Object.assign(updateData, additionalData);
+        }
+        return this.update(id, updateData);
+    }
+    async updateRewardStatus(id, rewardStatus, rewardAmount, rewardProcessedAt) {
+        const updateData = { rewardStatus };
+        if (rewardAmount !== undefined) {
+            updateData.referrerRewardAmount = rewardAmount;
+        }
+        if (rewardProcessedAt) {
+            updateData.rewardProcessedAt = rewardProcessedAt;
+        }
+        return this.update(id, updateData);
+    }
+    async getPendingRewards() {
+        return this.repository.find({
+            where: { rewardStatus: referral_event_entity_1.RewardStatus.PENDING },
+            relations: ['referrer', 'referred'],
+            order: { signupAt: 'ASC' },
+        });
+    }
+    async getConversionFunnel(startDate, endDate) {
+        const funnelData = await this.repository
+            .createQueryBuilder('re')
+            .select('re.status', 'status')
+            .addSelect('COUNT(*)', 'count')
+            .where('re.signup_at BETWEEN :start AND :end', { start: startDate, end: endDate })
+            .groupBy('re.status')
+            .getRawMany();
+        const counts = Object.fromEntries(funnelData.map((f) => [f.status, Number(f.count)]));
+        return {
+            signup: counts[referral_event_entity_1.ReferralStatus.SIGNUP] || 0,
+            emailVerified: counts[referral_event_entity_1.ReferralStatus.EMAIL_VERIFIED] || 0,
+            firstProject: counts[referral_event_entity_1.ReferralStatus.FIRST_PROJECT] || 0,
+            converted: counts[referral_event_entity_1.ReferralStatus.CONVERTED] || 0,
+        };
+    }
+    async getAttributionBreakdown(startDate, endDate) {
+        const attributionData = await this.repository
+            .createQueryBuilder('re')
+            .select('COALESCE(re.attribution_source, \'unknown\')', 'source')
+            .addSelect('COUNT(*)', 'count')
+            .where('re.signup_at BETWEEN :start AND :end', { start: startDate, end: endDate })
+            .groupBy('re.attribution_source')
+            .getRawMany();
+        return Object.fromEntries(attributionData.map((a) => [a.source, Number(a.count)]));
+    }
+};
+exports.ReferralEventRepository = ReferralEventRepository;
+exports.ReferralEventRepository = ReferralEventRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(referral_event_entity_1.ReferralEvent)),
+    __metadata("design:paramtypes", [typeorm_2.Repository])
+], ReferralEventRepository);

package/dist/repositories/repository.module.d.ts

@@ -0,0 +1,2 @@
+export declare class RepositoryModule {
+}

package/dist/repositories/repository.module.js

@@ -0,0 +1,77 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepositoryModule = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const entities_1 = require("../entities");
+const _1 = require("./");
+const repositories = [
+    _1.UserRepository,
+    _1.UserProfileRepository,
+    _1.UserOnboardingRepository,
+    _1.AuthSessionRepository,
+    _1.WorkspaceRepository,
+    _1.WorkspaceMemberRepository,
+    _1.InviteRepository,
+    _1.EditorProjectRepository,
+    _1.CommentRepository,
+    _1.SubscriptionPlanRepository,
+    _1.PlanRepository,
+    _1.UserSubscriptionRepository,
+    _1.SubscriptionUsageRepository,
+    _1.PaymentTransactionRepository,
+    _1.StripeWebhookRepository,
+    _1.CreditTransactionRepository,
+    _1.RewardRuleRepository,
+    _1.ReferralEventRepository,
+    _1.AiUsageRepository,
+    _1.AssetRepository,
+    _1.EffectRepository,
+    _1.VideoTranscodeRepository,
+    _1.VideoRenderRepository,
+    _1.VideoFilmstripRepository,
+    _1.AudioWaveformRepository,
+];
+const entities = [
+    entities_1.User,
+    entities_1.UserProfile,
+    entities_1.UserOnboardingResponse,
+    entities_1.AuthSession,
+    entities_1.Workspace,
+    entities_1.WorkspaceMember,
+    entities_1.Invite,
+    entities_1.EditorProject,
+    entities_1.Comment,
+    entities_1.SubscriptionPlan,
+    entities_1.Plan,
+    entities_1.UserSubscription,
+    entities_1.SubscriptionUsage,
+    entities_1.PaymentTransaction,
+    entities_1.StripeWebhookEvent,
+    entities_1.CreditTransaction,
+    entities_1.RewardRule,
+    entities_1.ReferralEvent,
+    entities_1.AIUsage,
+    entities_1.Asset,
+    entities_1.Effect,
+    entities_1.VideoTranscode,
+    entities_1.VideoRender,
+    entities_1.VideoFilmstrip,
+    entities_1.AudioWaveform,
+];
+let RepositoryModule = class RepositoryModule {
+};
+exports.RepositoryModule = RepositoryModule;
+exports.RepositoryModule = RepositoryModule = __decorate([
+    (0, common_1.Module)({
+        imports: [typeorm_1.TypeOrmModule.forFeature(entities)],
+        providers: repositories,
+        exports: repositories,
+    })
+], RepositoryModule);

package/dist/repositories/reward-rule.repository.d.ts

@@ -0,0 +1,10 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { RewardRule } from '../entities/reward-rule.entity';
+export declare class RewardRuleRepository extends BaseRepository<RewardRule> {
+    constructor(repository: Repository<RewardRule>);
+    findActive(): Promise<RewardRule[]>;
+    findByTriggerEvent(event: string): Promise<RewardRule[]>;
+    findByRuleName(ruleName: string): Promise<RewardRule | null>;
+    deactivate(id: string): Promise<void>;
+}

package/dist/repositories/reward-rule.repository.js

@@ -0,0 +1,48 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RewardRuleRepository = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const base_repository_1 = require("./base.repository");
+const reward_rule_entity_1 = require("../entities/reward-rule.entity");
+let RewardRuleRepository = class RewardRuleRepository extends base_repository_1.BaseRepository {
+    constructor(repository) {
+        super(repository);
+    }
+    async findActive() {
+        return this.repository.find({
+            where: { isActive: true },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async findByTriggerEvent(event) {
+        return this.repository.find({
+            where: { triggerEvent: event, isActive: true },
+        });
+    }
+    async findByRuleName(ruleName) {
+        return this.repository.findOne({ where: { ruleName } });
+    }
+    async deactivate(id) {
+        await this.repository.update(id, { isActive: false });
+    }
+};
+exports.RewardRuleRepository = RewardRuleRepository;
+exports.RewardRuleRepository = RewardRuleRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(reward_rule_entity_1.RewardRule)),
+    __metadata("design:paramtypes", [typeorm_2.Repository])
+], RewardRuleRepository);

package/dist/repositories/stripe-webhook.repository.d.ts

@@ -0,0 +1,10 @@
+import { Repository } from 'typeorm';
+import { StripeWebhookEvent, WebhookStatus } from '../entities/stripe-webhook.entity';
+import { BaseRepository } from './base.repository';
+export declare class StripeWebhookRepository extends BaseRepository<StripeWebhookEvent> {
+    private readonly webhookRepository;
+    constructor(webhookRepository: Repository<StripeWebhookEvent>);
+    findByEventId(eventId: string): Promise<StripeWebhookEvent | null>;
+    findByStatus(status: WebhookStatus): Promise<StripeWebhookEvent[]>;
+    updateStatus(id: string, status: WebhookStatus, errorMessage?: string): Promise<void>;
+}

package/dist/repositories/stripe-webhook.repository.js

@@ -0,0 +1,53 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StripeWebhookRepository = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const stripe_webhook_entity_1 = require("../entities/stripe-webhook.entity");
+const base_repository_1 = require("./base.repository");
+let StripeWebhookRepository = class StripeWebhookRepository extends base_repository_1.BaseRepository {
+    constructor(webhookRepository) {
+        super(webhookRepository);
+        this.webhookRepository = webhookRepository;
+    }
+    async findByEventId(eventId) {
+        return this.webhookRepository.findOne({
+            where: { eventId },
+        });
+    }
+    async findByStatus(status) {
+        return this.webhookRepository.find({
+            where: { status },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async updateStatus(id, status, errorMessage) {
+        const updates = { status };
+        if (status === stripe_webhook_entity_1.WebhookStatus.PROCESSED) {
+            updates.processedAt = new Date();
+        }
+        if (errorMessage) {
+            updates.errorMessage = errorMessage;
+        }
+        await this.webhookRepository.update(id, updates);
+    }
+};
+exports.StripeWebhookRepository = StripeWebhookRepository;
+exports.StripeWebhookRepository = StripeWebhookRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(stripe_webhook_entity_1.StripeWebhookEvent)),
+    __metadata("design:paramtypes", [typeorm_2.Repository])
+], StripeWebhookRepository);

package/dist/repositories/subscription-plan.repository.d.ts

@@ -0,0 +1,15 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { SubscriptionPlan } from '../entities/subscription-plan.entity';
+export declare class SubscriptionPlanRepository extends BaseRepository<SubscriptionPlan> {
+    private readonly planRepository;
+    constructor(planRepository: Repository<SubscriptionPlan>);
+    findActive(): Promise<SubscriptionPlan[]>;
+    findByKey(planKey: string): Promise<SubscriptionPlan | null>;
+    findFeatured(): Promise<SubscriptionPlan[]>;
+    findByStripeProductId(stripeProductId: string): Promise<SubscriptionPlan | null>;
+    findWithCollaboration(): Promise<SubscriptionPlan[]>;
+    findActivePlans(): Promise<SubscriptionPlan[]>;
+    findByPlanKey(planKey: string): Promise<SubscriptionPlan | null>;
+    findAllPlans(): Promise<SubscriptionPlan[]>;
+}

package/dist/repositories/subscription-plan.repository.js

@@ -0,0 +1,77 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionPlanRepository = void 0;
+const typeorm_1 = require("typeorm");
+const common_1 = require("@nestjs/common");
+const typeorm_2 = require("@nestjs/typeorm");
+const base_repository_1 = require("./base.repository");
+const subscription_plan_entity_1 = require("../entities/subscription-plan.entity");
+let SubscriptionPlanRepository = class SubscriptionPlanRepository extends base_repository_1.BaseRepository {
+    constructor(planRepository) {
+        super(planRepository);
+        this.planRepository = planRepository;
+    }
+    async findActive() {
+        return this.planRepository.find({
+            where: { isActive: true },
+            order: { displayOrder: 'ASC' }
+        });
+    }
+    async findByKey(planKey) {
+        return this.planRepository.findOne({
+            where: { planKey }
+        });
+    }
+    async findFeatured() {
+        return this.planRepository.find({
+            where: {
+                isActive: true,
+                isFeatured: true
+            },
+            order: { displayOrder: 'ASC' }
+        });
+    }
+    async findByStripeProductId(stripeProductId) {
+        return this.planRepository.findOne({
+            where: { stripeProductId }
+        });
+    }
+    async findWithCollaboration() {
+        return this.planRepository.find({
+            where: {
+                isActive: true,
+                hasCollaboration: true
+            },
+            order: { priceMonthly: 'ASC' }
+        });
+    }
+    async findActivePlans() {
+        return this.findActive();
+    }
+    async findByPlanKey(planKey) {
+        return this.findByKey(planKey);
+    }
+    async findAllPlans() {
+        return this.planRepository.find({
+            order: { displayOrder: 'ASC' }
+        });
+    }
+};
+exports.SubscriptionPlanRepository = SubscriptionPlanRepository;
+exports.SubscriptionPlanRepository = SubscriptionPlanRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(subscription_plan_entity_1.SubscriptionPlan)),
+    __metadata("design:paramtypes", [typeorm_1.Repository])
+], SubscriptionPlanRepository);

package/dist/repositories/subscription-usage.repository.d.ts

@@ -0,0 +1,9 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { SubscriptionUsage } from '../entities/subscription-usage.entity';
+export declare class SubscriptionUsageRepository extends BaseRepository<SubscriptionUsage> {
+    constructor(repository: Repository<SubscriptionUsage>);
+    findBySubscriptionId(subscriptionId: string): Promise<SubscriptionUsage[]>;
+    findCurrentPeriod(subscriptionId: string): Promise<SubscriptionUsage | null>;
+    incrementUsage(id: string, amount?: number): Promise<void>;
+}

package/dist/repositories/subscription-usage.repository.js

@@ -0,0 +1,50 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionUsageRepository = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const base_repository_1 = require("./base.repository");
+const subscription_usage_entity_1 = require("../entities/subscription-usage.entity");
+let SubscriptionUsageRepository = class SubscriptionUsageRepository extends base_repository_1.BaseRepository {
+    constructor(repository) {
+        super(repository);
+    }
+    async findBySubscriptionId(subscriptionId) {
+        return this.repository.find({
+            where: { subscriptionId },
+            order: { periodStart: 'DESC' },
+        });
+    }
+    async findCurrentPeriod(subscriptionId) {
+        const now = new Date();
+        return this.repository.findOne({
+            where: {
+                subscriptionId,
+                periodStart: (0, typeorm_2.Between)(new Date(now.getTime() - 32 * 24 * 60 * 60 * 1000), now),
+            },
+            order: { periodStart: 'DESC' },
+        });
+    }
+    async incrementUsage(id, amount = 1) {
+        await this.repository.increment({ id }, 'usageCount', amount);
+    }
+};
+exports.SubscriptionUsageRepository = SubscriptionUsageRepository;
+exports.SubscriptionUsageRepository = SubscriptionUsageRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(subscription_usage_entity_1.SubscriptionUsage)),
+    __metadata("design:paramtypes", [typeorm_2.Repository])
+], SubscriptionUsageRepository);

package/dist/repositories/user-onboarding.repository.d.ts

@@ -0,0 +1,10 @@
+import { Repository } from 'typeorm';
+import { UserOnboardingResponse } from '../entities/user-onboarding.entity';
+import { BaseRepository } from './base.repository';
+export declare class UserOnboardingRepository extends BaseRepository<UserOnboardingResponse> {
+    private readonly onboardingRepository;
+    constructor(onboardingRepository: Repository<UserOnboardingResponse>);
+    findByUserId(userId: string): Promise<UserOnboardingResponse[]>;
+    findByUserAndQuestion(userId: string, questionKey: string): Promise<UserOnboardingResponse | null>;
+    upsertResponse(userId: string, questionKey: string, responseValue: any): Promise<UserOnboardingResponse>;
+}

package/dist/repositories/user-onboarding.repository.js

@@ -0,0 +1,56 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserOnboardingRepository = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const user_onboarding_entity_1 = require("../entities/user-onboarding.entity");
+const base_repository_1 = require("./base.repository");
+let UserOnboardingRepository = class UserOnboardingRepository extends base_repository_1.BaseRepository {
+    constructor(onboardingRepository) {
+        super(onboardingRepository);
+        this.onboardingRepository = onboardingRepository;
+    }
+    async findByUserId(userId) {
+        return this.onboardingRepository.find({
+            where: { userId },
+            order: { createdAt: 'ASC' },
+        });
+    }
+    async findByUserAndQuestion(userId, questionKey) {
+        return this.onboardingRepository.findOne({
+            where: { userId, questionKey },
+        });
+    }
+    async upsertResponse(userId, questionKey, responseValue) {
+        const existing = await this.findByUserAndQuestion(userId, questionKey);
+        if (existing) {
+            existing.responseValue = responseValue;
+            return this.onboardingRepository.save(existing);
+        }
+        const newResponse = this.onboardingRepository.create({
+            userId,
+            questionKey,
+            responseValue,
+        });
+        return this.onboardingRepository.save(newResponse);
+    }
+};
+exports.UserOnboardingRepository = UserOnboardingRepository;
+exports.UserOnboardingRepository = UserOnboardingRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(user_onboarding_entity_1.UserOnboardingResponse)),
+    __metadata("design:paramtypes", [typeorm_2.Repository])
+], UserOnboardingRepository);

package/dist/repositories/user-profile.repository.d.ts

@@ -0,0 +1,9 @@
+import { Repository } from 'typeorm';
+import { UserProfile } from '../entities/user-profile.entity';
+import { BaseRepository } from './base.repository';
+export declare class UserProfileRepository extends BaseRepository<UserProfile> {
+    private readonly userProfileRepository;
+    constructor(userProfileRepository: Repository<UserProfile>);
+    findByUserId(userId: string): Promise<UserProfile | null>;
+    updateProfile(userId: string, updates: Partial<UserProfile>): Promise<UserProfile | null>;
+}

package/dist/repositories/user-profile.repository.js

@@ -0,0 +1,41 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserProfileRepository = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const user_profile_entity_1 = require("../entities/user-profile.entity");
+const base_repository_1 = require("./base.repository");
+let UserProfileRepository = class UserProfileRepository extends base_repository_1.BaseRepository {
+    constructor(userProfileRepository) {
+        super(userProfileRepository);
+        this.userProfileRepository = userProfileRepository;
+    }
+    async findByUserId(userId) {
+        return this.userProfileRepository.findOne({
+            where: { userId },
+        });
+    }
+    async updateProfile(userId, updates) {
+        await this.userProfileRepository.update({ userId }, updates);
+        return this.findByUserId(userId);
+    }
+};
+exports.UserProfileRepository = UserProfileRepository;
+exports.UserProfileRepository = UserProfileRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(user_profile_entity_1.UserProfile)),
+    __metadata("design:paramtypes", [typeorm_2.Repository])
+], UserProfileRepository);

package/dist/repositories/user-subscription.repository.d.ts

@@ -0,0 +1,16 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { UserSubscription, SubscriptionStatus } from '../entities/user-subscription.entity';
+export declare class UserSubscriptionRepository extends BaseRepository<UserSubscription> {
+    private readonly subscriptionRepository;
+    constructor(subscriptionRepository: Repository<UserSubscription>);
+    findActiveByUserId(userId: string): Promise<UserSubscription | null>;
+    findByUserId(userId: string): Promise<UserSubscription[]>;
+    cancelSubscription(subscriptionId: string): Promise<void>;
+    findOneByUserId(userId: string): Promise<UserSubscription | null>;
+    findByStripeSubscriptionId(stripeSubscriptionId: string): Promise<UserSubscription | null>;
+    findByStatus(status: SubscriptionStatus): Promise<UserSubscription[]>;
+    findByPlanId(planId: string): Promise<UserSubscription[]>;
+    findExpiringSubscriptions(beforeDate: string): Promise<UserSubscription[]>;
+    findTrialEndingSoon(beforeDate: string): Promise<UserSubscription[]>;
+}