clhq-dynamodb-module 1.1.0-alpha.90

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

@@ -0,0 +1,123 @@
+"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 PaymentTransactionRepository_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentTransactionRepository = void 0;
+const common_1 = require("@nestjs/common");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const base_repository_1 = require("./base.repository");
+const payment_transaction_entity_1 = require("../entities/payment-transaction.entity");
+let PaymentTransactionRepository = PaymentTransactionRepository_1 = class PaymentTransactionRepository extends base_repository_1.BaseRepository {
+    logger = new common_1.Logger(PaymentTransactionRepository_1.name);
+    constructor(dynamoDbClient) {
+        super(dynamoDbClient, `payment-transaction-${process.env.STAGE}`);
+    }
+    async findByUserId(userId) {
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            IndexName: 'userId-createdAt-index',
+            KeyConditionExpression: 'userId = :userId',
+            ScanIndexForward: false,
+            ExpressionAttributeValues: {
+                ':userId': userId,
+            },
+        });
+        return result.Items || [];
+    }
+    async findBySubscriptionId(subscriptionId) {
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            IndexName: 'subscriptionId-index',
+            KeyConditionExpression: 'subscriptionId = :subscriptionId',
+            ExpressionAttributeValues: {
+                ':subscriptionId': subscriptionId,
+            },
+        });
+        return result.Items || [];
+    }
+    async findByStripePaymentIntentId(stripePaymentIntentId) {
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            IndexName: 'stripePaymentIntentId-index',
+            KeyConditionExpression: 'stripePaymentIntentId = :stripePaymentIntentId',
+            ExpressionAttributeValues: {
+                ':stripePaymentIntentId': stripePaymentIntentId,
+            },
+        });
+        return result.Items?.[0];
+    }
+    async findByStatusAndDateRange(status, startDate, endDate) {
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            IndexName: 'status-createdAt-index',
+            KeyConditionExpression: '#status = :status AND createdAt BETWEEN :startDate AND :endDate',
+            ExpressionAttributeNames: {
+                '#status': 'status',
+            },
+            ExpressionAttributeValues: {
+                ':status': status,
+                ':startDate': startDate,
+                ':endDate': endDate,
+            },
+        });
+        return result.Items || [];
+    }
+    async findFailedTransactions(userId) {
+        if (userId) {
+            const result = await this.dynamoDb.query({
+                TableName: this.tableName,
+                IndexName: 'userId-status-index',
+                KeyConditionExpression: 'userId = :userId AND #status = :status',
+                ExpressionAttributeNames: {
+                    '#status': 'status',
+                },
+                ExpressionAttributeValues: {
+                    ':userId': userId,
+                    ':status': payment_transaction_entity_1.TransactionStatus.FAILED,
+                },
+            });
+            return result.Items || [];
+        }
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            IndexName: 'status-index',
+            KeyConditionExpression: '#status = :status',
+            ExpressionAttributeNames: {
+                '#status': 'status',
+            },
+            ExpressionAttributeValues: {
+                ':status': payment_transaction_entity_1.TransactionStatus.FAILED,
+            },
+        });
+        return result.Items || [];
+    }
+    async getTotalRevenueByPeriod(startDate, endDate) {
+        const result = await this.dynamoDb.scan({
+            TableName: this.tableName,
+            FilterExpression: '#status = :completed AND transactionType = :payment AND createdAt BETWEEN :startDate AND :endDate',
+            ExpressionAttributeNames: {
+                '#status': 'status',
+            },
+            ExpressionAttributeValues: {
+                ':completed': payment_transaction_entity_1.TransactionStatus.COMPLETED,
+                ':payment': payment_transaction_entity_1.PaymentTransactionType.PAYMENT,
+                ':startDate': startDate,
+                ':endDate': endDate,
+            },
+        });
+        return result.Items.reduce((total, transaction) => total + transaction.amount, 0);
+    }
+};
+exports.PaymentTransactionRepository = PaymentTransactionRepository;
+exports.PaymentTransactionRepository = PaymentTransactionRepository = PaymentTransactionRepository_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [client_dynamodb_1.DynamoDB])
+], PaymentTransactionRepository);

package/dist/repositories/project-version.repository.d.ts

@@ -0,0 +1,9 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { ProjectVersion } from '../entities/project-version.entity';
+export declare class ProjectVersionRepository extends BaseRepository<ProjectVersion> {
+    private readonly logger;
+    constructor(dynamoDbClient: DynamoDB);
+    findByProjectId(projectId: string): Promise<ProjectVersion[]>;
+    findLatestVersion(projectId: string): Promise<ProjectVersion | undefined>;
+}

package/dist/repositories/project-version.repository.js

@@ -0,0 +1,51 @@
+"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 ProjectVersionRepository_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectVersionRepository = void 0;
+const common_1 = require("@nestjs/common");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const base_repository_1 = require("./base.repository");
+let ProjectVersionRepository = ProjectVersionRepository_1 = class ProjectVersionRepository extends base_repository_1.BaseRepository {
+    logger = new common_1.Logger(ProjectVersionRepository_1.name);
+    constructor(dynamoDbClient) {
+        super(dynamoDbClient, `project-version-${process.env.STAGE}`);
+    }
+    async findByProjectId(projectId) {
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            IndexName: 'projectId-versionNumber-index',
+            KeyConditionExpression: 'projectId = :projectId',
+            ExpressionAttributeValues: {
+                ':projectId': projectId,
+            },
+        });
+        return result.Items || [];
+    }
+    async findLatestVersion(projectId) {
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            IndexName: 'projectId-versionNumber-index',
+            KeyConditionExpression: 'projectId = :projectId',
+            ScanIndexForward: false,
+            Limit: 1,
+            ExpressionAttributeValues: {
+                ':projectId': projectId,
+            },
+        });
+        return result.Items?.[0];
+    }
+};
+exports.ProjectVersionRepository = ProjectVersionRepository;
+exports.ProjectVersionRepository = ProjectVersionRepository = ProjectVersionRepository_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [client_dynamodb_1.DynamoDB])
+], ProjectVersionRepository);

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

@@ -0,0 +1,17 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { Project, ProjectStatus } from '../entities/project.entity';
+export declare class ProjectRepository extends BaseRepository<Project> {
+    private readonly logger;
+    constructor(dynamoDbClient: DynamoDB);
+    findByWorkspaceId(workspaceId: string): Promise<Project[]>;
+    findByOwnerId(ownerId: string): Promise<Project[]>;
+    findByStatus(status: ProjectStatus): Promise<Project[]>;
+    findTemplates(category?: string, isPremium?: boolean): Promise<Project[]>;
+    findRecentProjects(userId: string, limit?: number): Promise<Project[]>;
+    findFavoriteProjects(userId: string): Promise<Project[]>;
+    findByTags(tags: string[], workspaceId?: string): Promise<Project[]>;
+    updateLastOpened(projectId: string, userId: string): Promise<void>;
+    incrementTemplateUsage(projectId: string): Promise<void>;
+    searchProjects(searchTerm: string, workspaceId?: string, userId?: string): Promise<Project[]>;
+}

package/dist/repositories/project.repository.js

@@ -0,0 +1,132 @@
+"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 ProjectRepository_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectRepository = void 0;
+const common_1 = require("@nestjs/common");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const base_repository_1 = require("./base.repository");
+let ProjectRepository = ProjectRepository_1 = class ProjectRepository extends base_repository_1.BaseRepository {
+    logger = new common_1.Logger(ProjectRepository_1.name);
+    constructor(dynamoDbClient) {
+        super(dynamoDbClient, `projects-${process.env.STAGE}`);
+    }
+    async findByWorkspaceId(workspaceId) {
+        return this.find({ workspaceId });
+    }
+    async findByOwnerId(ownerId) {
+        return this.find({ ownerId });
+    }
+    async findByStatus(status) {
+        return this.find({ status });
+    }
+    async findTemplates(category, isPremium) {
+        let filterExpression = `isTemplate = :isTemplate`;
+        const expressionAttributeValues = {
+            ':isTemplate': true,
+        };
+        if (category) {
+            filterExpression += ` AND templateCategory = :category`;
+            expressionAttributeValues[`:category`] = category;
+        }
+        if (isPremium !== undefined) {
+            filterExpression += ` AND isPremiumTemplate = :isPremium`;
+            expressionAttributeValues[`:isPremium`] = isPremium;
+        }
+        const result = await this.dynamoDb.scan({
+            TableName: this.tableName,
+            FilterExpression: filterExpression,
+            ExpressionAttributeValues: expressionAttributeValues,
+        });
+        return result.Items || [];
+    }
+    async findRecentProjects(userId, limit = 10) {
+        const all = await this.find({ ownerId: userId });
+        return all
+            .filter((p) => p.lastOpenedAt)
+            .sort((a, b) => (b.lastOpenedAt || '').localeCompare(a.lastOpenedAt || ''))
+            .slice(0, limit);
+    }
+    async findFavoriteProjects(userId) {
+        const all = await this.find({ ownerId: userId, isFavorite: true });
+        return all;
+    }
+    async findByTags(tags, workspaceId) {
+        const tagConditions = tags
+            .map((_, index) => `contains(tags, :tag${index})`)
+            .join(' OR ');
+        let filterExpression = `(${tagConditions})`;
+        const expressionAttributeValues = {};
+        tags.forEach((tag, index) => {
+            expressionAttributeValues[`:tag${index}`] = tag;
+        });
+        if (workspaceId) {
+            filterExpression += ` AND workspaceId = :workspaceId`;
+            expressionAttributeValues[`:workspaceId`] = workspaceId;
+        }
+        const result = await this.dynamoDb.scan({
+            TableName: this.tableName,
+            FilterExpression: filterExpression,
+            ExpressionAttributeValues: expressionAttributeValues,
+        });
+        return result.Items || [];
+    }
+    async updateLastOpened(projectId, userId) {
+        await this.dynamoDb.update({
+            TableName: this.tableName,
+            Key: { id: projectId },
+            UpdateExpression: 'SET lastOpenedAt = :timestamp, lastEditedBy = :userId',
+            ExpressionAttributeValues: {
+                ':timestamp': new Date().toISOString(),
+                ':userId': userId,
+            },
+        });
+    }
+    async incrementTemplateUsage(projectId) {
+        await this.dynamoDb.update({
+            TableName: this.tableName,
+            Key: { id: projectId },
+            UpdateExpression: 'ADD templateUsageCount :increment',
+            ExpressionAttributeValues: {
+                ':increment': 1,
+            },
+        });
+    }
+    async searchProjects(searchTerm, workspaceId, userId) {
+        let filterExpression = `contains(#name, :searchTerm) OR contains(description, :searchTerm)`;
+        const expressionAttributeNames = {
+            '#name': 'name',
+        };
+        const expressionAttributeValues = {
+            ':searchTerm': searchTerm,
+        };
+        if (workspaceId) {
+            filterExpression += ` AND workspaceId = :workspaceId`;
+            expressionAttributeValues[`:workspaceId`] = workspaceId;
+        }
+        if (userId) {
+            filterExpression += ` AND ownerId = :userId`;
+            expressionAttributeValues[`:userId`] = userId;
+        }
+        const result = await this.dynamoDb.scan({
+            TableName: this.tableName,
+            FilterExpression: filterExpression,
+            ExpressionAttributeNames: expressionAttributeNames,
+            ExpressionAttributeValues: expressionAttributeValues,
+        });
+        return result.Items || [];
+    }
+};
+exports.ProjectRepository = ProjectRepository;
+exports.ProjectRepository = ProjectRepository = ProjectRepository_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [client_dynamodb_1.DynamoDB])
+], ProjectRepository);

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

@@ -0,0 +1,13 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { RewardRule, RewardType } from '../entities/reward-rule.entity';
+export declare class RewardRuleRepository extends BaseRepository<RewardRule> {
+    private readonly logger;
+    constructor(dynamoDbClient: DynamoDB);
+    findByType(type: RewardType): Promise<RewardRule[]>;
+    findActive(): Promise<RewardRule[]>;
+    findById(id: string): Promise<RewardRule | undefined>;
+    createRewardRule(rule: RewardRule): Promise<RewardRule>;
+    updateRewardRule(id: string, updates: Partial<RewardRule>): Promise<RewardRule | undefined>;
+    deleteRewardRule(id: string): Promise<boolean>;
+}

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

@@ -0,0 +1,84 @@
+"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 RewardRuleRepository_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RewardRuleRepository = void 0;
+const common_1 = require("@nestjs/common");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const base_repository_1 = require("./base.repository");
+let RewardRuleRepository = RewardRuleRepository_1 = class RewardRuleRepository extends base_repository_1.BaseRepository {
+    logger = new common_1.Logger(RewardRuleRepository_1.name);
+    constructor(dynamoDbClient) {
+        super(dynamoDbClient, `reward-rule-${process.env.STAGE}`);
+    }
+    async findByType(type) {
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            IndexName: 'type-index',
+            KeyConditionExpression: 'type = :type',
+            ExpressionAttributeValues: {
+                ':type': type,
+            },
+        });
+        return result.Items || [];
+    }
+    async findActive() {
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            IndexName: 'isActive-index',
+            KeyConditionExpression: 'isActive = :active',
+            ExpressionAttributeValues: {
+                ':active': true,
+            },
+        });
+        return result.Items || [];
+    }
+    async findById(id) {
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            KeyConditionExpression: 'id = :id',
+            ExpressionAttributeValues: {
+                ':id': id,
+            },
+        });
+        return result.Items?.[0];
+    }
+    async createRewardRule(rule) {
+        await this.dynamoDb.put({
+            TableName: this.tableName,
+            Item: rule,
+        });
+        return rule;
+    }
+    async updateRewardRule(id, updates) {
+        const rule = await this.findById(id);
+        if (!rule)
+            return undefined;
+        const updatedRule = { ...rule, ...updates };
+        await this.dynamoDb.put({
+            TableName: this.tableName,
+            Item: updatedRule,
+        });
+        return updatedRule;
+    }
+    async deleteRewardRule(id) {
+        await this.dynamoDb.delete({
+            TableName: this.tableName,
+            Key: { id },
+        });
+        return true;
+    }
+};
+exports.RewardRuleRepository = RewardRuleRepository;
+exports.RewardRuleRepository = RewardRuleRepository = RewardRuleRepository_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [client_dynamodb_1.DynamoDB])
+], RewardRuleRepository);

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

@@ -0,0 +1,11 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { SubscriptionPlan } from '../entities/subscription-plan.entity';
+export declare class SubscriptionPlanRepository extends BaseRepository<SubscriptionPlan> {
+    private readonly logger;
+    constructor(dynamoDbClient: DynamoDB);
+    findByPlanKey(planKey: string): Promise<SubscriptionPlan | undefined>;
+    findActivePlans(): Promise<SubscriptionPlan[]>;
+    findFeaturedPlans(): Promise<SubscriptionPlan[]>;
+    findByPriceRange(minPrice: number, maxPrice: number): Promise<SubscriptionPlan[]>;
+}

package/dist/repositories/subscription-plan.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 SubscriptionPlanRepository_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionPlanRepository = void 0;
+const common_1 = require("@nestjs/common");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const base_repository_1 = require("./base.repository");
+let SubscriptionPlanRepository = SubscriptionPlanRepository_1 = class SubscriptionPlanRepository extends base_repository_1.BaseRepository {
+    logger = new common_1.Logger(SubscriptionPlanRepository_1.name);
+    constructor(dynamoDbClient) {
+        super(dynamoDbClient, `subscription-plan-${process.env.STAGE}`);
+    }
+    async findByPlanKey(planKey) {
+        const result = await this.find({ planKey });
+        return result[0];
+    }
+    async findActivePlans() {
+        const result = await this.find({ isActive: true });
+        return result.sort((a, b) => (a.displayOrder || 0) - (b.displayOrder || 0));
+    }
+    async findFeaturedPlans() {
+        return this.find({ isFeatured: true });
+    }
+    async findByPriceRange(minPrice, maxPrice) {
+        const result = await this.dynamoDb.scan({
+            TableName: this.tableName,
+            FilterExpression: 'priceMonthly BETWEEN :minPrice AND :maxPrice',
+            ExpressionAttributeValues: {
+                ':minPrice': minPrice,
+                ':maxPrice': maxPrice,
+            },
+        });
+        return result.Items || [];
+    }
+};
+exports.SubscriptionPlanRepository = SubscriptionPlanRepository;
+exports.SubscriptionPlanRepository = SubscriptionPlanRepository = SubscriptionPlanRepository_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [client_dynamodb_1.DynamoDB])
+], SubscriptionPlanRepository);

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

@@ -0,0 +1,12 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { SubscriptionUsage } from '../entities/subscription-usage.entity';
+export declare class SubscriptionUsageRepository extends BaseRepository<SubscriptionUsage> {
+    private readonly logger;
+    constructor(dynamoDbClient: DynamoDB);
+    findByUserId(userId: string): Promise<SubscriptionUsage[]>;
+    findCurrentUsageByUserId(userId: string): Promise<SubscriptionUsage | undefined>;
+    findBySubscriptionId(subscriptionId: string): Promise<SubscriptionUsage[]>;
+    incrementUsage(userId: string, usageType: keyof Pick<SubscriptionUsage, 'projectsCreated' | 'exportsCompleted' | 'aiFeaturesUsed' | 'renderMinutesUsed'>, amount?: number): Promise<void>;
+    updateStorageUsage(userId: string, storageUsedGb: number): Promise<void>;
+}

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

@@ -0,0 +1,68 @@
+"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 SubscriptionUsageRepository_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionUsageRepository = void 0;
+const common_1 = require("@nestjs/common");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const base_repository_1 = require("./base.repository");
+let SubscriptionUsageRepository = SubscriptionUsageRepository_1 = class SubscriptionUsageRepository extends base_repository_1.BaseRepository {
+    logger = new common_1.Logger(SubscriptionUsageRepository_1.name);
+    constructor(dynamoDbClient) {
+        super(dynamoDbClient, `subscription-usage-${process.env.STAGE}`);
+    }
+    async findByUserId(userId) {
+        return this.find({ userId });
+    }
+    async findCurrentUsageByUserId(userId) {
+        const now = new Date().toISOString();
+        const results = await this.find({ userId });
+        return results.find((usage) => usage.periodStart <= now && usage.periodEnd > now);
+    }
+    async findBySubscriptionId(subscriptionId) {
+        return this.find({ subscriptionId });
+    }
+    async incrementUsage(userId, usageType, amount = 1) {
+        const currentUsage = await this.findCurrentUsageByUserId(userId);
+        if (!currentUsage) {
+            throw new Error('No current usage record found for user');
+        }
+        await this.dynamoDb.update({
+            TableName: this.tableName,
+            Key: { id: currentUsage.id },
+            UpdateExpression: `ADD ${usageType} :amount SET updatedAt = :updatedAt`,
+            ExpressionAttributeValues: {
+                ':amount': amount,
+                ':updatedAt': new Date().toISOString(),
+            },
+        });
+    }
+    async updateStorageUsage(userId, storageUsedGb) {
+        const currentUsage = await this.findCurrentUsageByUserId(userId);
+        if (!currentUsage) {
+            throw new Error('No current usage record found for user');
+        }
+        await this.dynamoDb.update({
+            TableName: this.tableName,
+            Key: { id: currentUsage.id },
+            UpdateExpression: 'SET storageUsedGb = :storageUsed, updatedAt = :updatedAt',
+            ExpressionAttributeValues: {
+                ':storageUsed': storageUsedGb,
+                ':updatedAt': new Date().toISOString(),
+            },
+        });
+    }
+};
+exports.SubscriptionUsageRepository = SubscriptionUsageRepository;
+exports.SubscriptionUsageRepository = SubscriptionUsageRepository = SubscriptionUsageRepository_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [client_dynamodb_1.DynamoDB])
+], SubscriptionUsageRepository);

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

@@ -0,0 +1,9 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { Timeline } from '../entities/timeline.entity';
+export declare class TimelineRepository extends BaseRepository<Timeline> {
+    private readonly logger;
+    constructor(dynamoDbClient: DynamoDB);
+    findByProjectId(projectId: string): Promise<Timeline[]>;
+    findMainTimelineByProjectId(projectId: string): Promise<Timeline | undefined>;
+}

package/dist/repositories/timeline.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 TimelineRepository_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimelineRepository = void 0;
+const common_1 = require("@nestjs/common");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const base_repository_1 = require("./base.repository");
+let TimelineRepository = TimelineRepository_1 = class TimelineRepository extends base_repository_1.BaseRepository {
+    logger = new common_1.Logger(TimelineRepository_1.name);
+    constructor(dynamoDbClient) {
+        super(dynamoDbClient, `timeline-${process.env.STAGE}`);
+    }
+    async findByProjectId(projectId) {
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            IndexName: 'projectId-index',
+            KeyConditionExpression: 'projectId = :projectId',
+            ExpressionAttributeValues: {
+                ':projectId': projectId,
+            },
+        });
+        return result.Items || [];
+    }
+    async findMainTimelineByProjectId(projectId) {
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            IndexName: 'projectId-name-index',
+            KeyConditionExpression: 'projectId = :projectId AND #name = :name',
+            ExpressionAttributeNames: {
+                '#name': 'name',
+            },
+            ExpressionAttributeValues: {
+                ':projectId': projectId,
+                ':name': 'Main Timeline',
+            },
+        });
+        return result.Items?.[0];
+    }
+};
+exports.TimelineRepository = TimelineRepository;
+exports.TimelineRepository = TimelineRepository = TimelineRepository_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [client_dynamodb_1.DynamoDB])
+], TimelineRepository);

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

@@ -0,0 +1,13 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { Track, TrackType } from '../entities/track.entity';
+export declare class TrackRepository extends BaseRepository<Track> {
+    private readonly logger;
+    constructor(dynamoDbClient: DynamoDB);
+    findByTimelineId(timelineId: string): Promise<Track[]>;
+    findByTrackType(timelineId: string, trackType: TrackType): Promise<Track[]>;
+    reorderTracks(timelineId: string, trackOrders: {
+        id: string;
+        orderIndex: number;
+    }[]): Promise<void>;
+}