clhq-postgres-module 1.1.0-alpha.90

package/dist/repositories/invite.repository.js

@@ -0,0 +1,60 @@
+"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.InviteRepository = 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 invite_entity_1 = require("../entities/invite.entity");
+let InviteRepository = class InviteRepository extends base_repository_1.BaseRepository {
+    constructor(repository) {
+        super(repository);
+    }
+    async findByToken(token) {
+        return this.repository.findOne({ where: { token } });
+    }
+    async findByEmail(email) {
+        return this.repository.find({
+            where: { email },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async findByWorkspaceId(workspaceId) {
+        return this.repository.find({
+            where: { workspaceId },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async findPending() {
+        return this.repository.find({
+            where: {
+                status: 'pending',
+                expiresAt: (0, typeorm_2.LessThan)(new Date()),
+            },
+        });
+    }
+    async markExpired(id) {
+        await this.repository.update(id, { status: 'expired' });
+    }
+    async acceptInvite(token) {
+        await this.repository.update({ token }, { status: 'accepted', acceptedAt: new Date() });
+    }
+};
+exports.InviteRepository = InviteRepository;
+exports.InviteRepository = InviteRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(invite_entity_1.Invite)),
+    __metadata("design:paramtypes", [typeorm_2.Repository])
+], InviteRepository);

package/dist/repositories/payment-transaction.repository.d.ts

@@ -0,0 +1,10 @@
+import { Repository } from 'typeorm';
+import { PaymentTransaction, PaymentStatus } from '../entities/payment-transaction.entity';
+import { BaseRepository } from './base.repository';
+export declare class PaymentTransactionRepository extends BaseRepository<PaymentTransaction> {
+    private readonly transactionRepository;
+    constructor(transactionRepository: Repository<PaymentTransaction>);
+    findByUserId(userId: string): Promise<PaymentTransaction[]>;
+    findByTransactionId(transactionId: string): Promise<PaymentTransaction | null>;
+    findByStatus(status: PaymentStatus): Promise<PaymentTransaction[]>;
+}

package/dist/repositories/payment-transaction.repository.js

@@ -0,0 +1,49 @@
+"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.PaymentTransactionRepository = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const payment_transaction_entity_1 = require("../entities/payment-transaction.entity");
+const base_repository_1 = require("./base.repository");
+let PaymentTransactionRepository = class PaymentTransactionRepository extends base_repository_1.BaseRepository {
+    constructor(transactionRepository) {
+        super(transactionRepository);
+        this.transactionRepository = transactionRepository;
+    }
+    async findByUserId(userId) {
+        return this.transactionRepository.find({
+            where: { userId },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async findByTransactionId(transactionId) {
+        return this.transactionRepository.findOne({
+            where: { transactionId },
+        });
+    }
+    async findByStatus(status) {
+        return this.transactionRepository.find({
+            where: { status },
+            order: { createdAt: 'DESC' },
+        });
+    }
+};
+exports.PaymentTransactionRepository = PaymentTransactionRepository;
+exports.PaymentTransactionRepository = PaymentTransactionRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(payment_transaction_entity_1.PaymentTransaction)),
+    __metadata("design:paramtypes", [typeorm_2.Repository])
+], PaymentTransactionRepository);

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

@@ -0,0 +1,10 @@
+import { Repository } from 'typeorm';
+import { Plan } from '../entities/plan.entity';
+import { BaseRepository } from './base.repository';
+export declare class PlanRepository extends BaseRepository<Plan> {
+    private readonly planRepository;
+    constructor(planRepository: Repository<Plan>);
+    findByKey(planKey: string): Promise<Plan | null>;
+    findActivePlans(): Promise<Plan[]>;
+    findByStripeProductId(stripeProductId: string): Promise<Plan | null>;
+}

package/dist/repositories/plan.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.PlanRepository = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const plan_entity_1 = require("../entities/plan.entity");
+const base_repository_1 = require("./base.repository");
+let PlanRepository = class PlanRepository extends base_repository_1.BaseRepository {
+    constructor(planRepository) {
+        super(planRepository);
+        this.planRepository = planRepository;
+    }
+    async findByKey(planKey) {
+        return this.planRepository.findOne({
+            where: { planKey },
+        });
+    }
+    async findActivePlans() {
+        return this.planRepository.find({
+            where: { isActive: true },
+            order: { displayOrder: 'ASC' },
+        });
+    }
+    async findByStripeProductId(stripeProductId) {
+        return this.planRepository.findOne({
+            where: { stripeProductId },
+        });
+    }
+};
+exports.PlanRepository = PlanRepository;
+exports.PlanRepository = PlanRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(plan_entity_1.Plan)),
+    __metadata("design:paramtypes", [typeorm_2.Repository])
+], PlanRepository);

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

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

package/dist/repositories/repository.module.js

@@ -0,0 +1,71 @@
+"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.AiUsageRepository,
+    _1.AssetRepository,
+    _1.EffectRepository,
+    _1.VideoTranscodeRepository,
+    _1.VideoRenderRepository,
+];
+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.AIUsage,
+    entities_1.Asset,
+    entities_1.Effect,
+    entities_1.VideoTranscode,
+    entities_1.VideoRender,
+];
+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>;
+}