clhq-dynamodb-module 1.1.0-alpha.90

package/dist/repositories/clip-effect.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 ClipEffectRepository_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClipEffectRepository = 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 ClipEffectRepository = ClipEffectRepository_1 = class ClipEffectRepository extends base_repository_1.BaseRepository {
+    logger = new common_1.Logger(ClipEffectRepository_1.name);
+    constructor(dynamoDbClient) {
+        super(dynamoDbClient, `clip-effect-${process.env.STAGE}`);
+    }
+    async findByClipId(clipId) {
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            IndexName: 'clipId-index',
+            KeyConditionExpression: 'clipId = :clipId',
+            ExpressionAttributeValues: {
+                ':clipId': clipId,
+            },
+        });
+        return result.Items || [];
+    }
+    async findByEffectId(effectId) {
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            IndexName: 'effectId-index',
+            KeyConditionExpression: 'effectId = :effectId',
+            ExpressionAttributeValues: {
+                ':effectId': effectId,
+            },
+        });
+        return result.Items || [];
+    }
+};
+exports.ClipEffectRepository = ClipEffectRepository;
+exports.ClipEffectRepository = ClipEffectRepository = ClipEffectRepository_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [client_dynamodb_1.DynamoDB])
+], ClipEffectRepository);

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

@@ -0,0 +1,13 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { Clip } from '../entities/clip.entity';
+export declare class ClipRepository extends BaseRepository<Clip> {
+    private readonly logger;
+    constructor(dynamoDbClient: DynamoDB);
+    findByTrackId(trackId: string): Promise<Clip[]>;
+    findByAssetId(assetId: string): Promise<Clip[]>;
+    findClipsInTimeRange(trackId: string, startTime: number, endTime: number): Promise<Clip[]>;
+    findOverlappingClips(trackId: string, startTime: number, endTime: number): Promise<Clip[]>;
+    moveClip(clipId: string, newStartTime: number, newEndTime: number): Promise<void>;
+    duplicateClip(clipId: string, newTrackId?: string): Promise<Clip>;
+}

package/dist/repositories/clip.repository.js

@@ -0,0 +1,101 @@
+"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 ClipRepository_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClipRepository = 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 ClipRepository = ClipRepository_1 = class ClipRepository extends base_repository_1.BaseRepository {
+    logger = new common_1.Logger(ClipRepository_1.name);
+    constructor(dynamoDbClient) {
+        super(dynamoDbClient, `clip-${process.env.STAGE}`);
+    }
+    async findByTrackId(trackId) {
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            IndexName: 'trackId-startTimeMs-index',
+            KeyConditionExpression: 'trackId = :trackId',
+            ExpressionAttributeValues: {
+                ':trackId': trackId,
+            },
+        });
+        return result.Items || [];
+    }
+    async findByAssetId(assetId) {
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            IndexName: 'assetId-index',
+            KeyConditionExpression: 'assetId = :assetId',
+            ExpressionAttributeValues: {
+                ':assetId': assetId,
+            },
+        });
+        return result.Items || [];
+    }
+    async findClipsInTimeRange(trackId, startTime, endTime) {
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            IndexName: 'trackId-startTimeMs-index',
+            KeyConditionExpression: 'trackId = :trackId AND startTimeMs BETWEEN :startTime AND :endTime',
+            ExpressionAttributeValues: {
+                ':trackId': trackId,
+                ':startTime': startTime,
+                ':endTime': endTime,
+            },
+        });
+        return result.Items || [];
+    }
+    async findOverlappingClips(trackId, startTime, endTime) {
+        const result = await this.dynamoDb.scan({
+            TableName: this.tableName,
+            FilterExpression: 'trackId = :trackId AND ((startTimeMs <= :startTime AND endTimeMs > :startTime) OR (startTimeMs < :endTime AND endTimeMs >= :endTime) OR (startTimeMs >= :startTime AND endTimeMs <= :endTime))',
+            ExpressionAttributeValues: {
+                ':trackId': trackId,
+                ':startTime': startTime,
+                ':endTime': endTime,
+            },
+        });
+        return result.Items || [];
+    }
+    async moveClip(clipId, newStartTime, newEndTime) {
+        await this.dynamoDb.update({
+            TableName: this.tableName,
+            Key: { id: clipId },
+            UpdateExpression: 'SET startTimeMs = :startTime, endTimeMs = :endTime, updatedAt = :updatedAt',
+            ExpressionAttributeValues: {
+                ':startTime': newStartTime,
+                ':endTime': newEndTime,
+                ':updatedAt': new Date().toISOString(),
+            },
+        });
+    }
+    async duplicateClip(clipId, newTrackId) {
+        const originalClip = await this.findById(clipId);
+        if (!originalClip) {
+            throw new Error('Clip not found');
+        }
+        const newClip = {
+            ...originalClip,
+            id: `${Date.now()}-${Math.random()}`,
+            trackId: newTrackId || originalClip.trackId,
+            name: `${originalClip.name || 'Clip'} Copy`,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+        return await this.create(newClip);
+    }
+};
+exports.ClipRepository = ClipRepository;
+exports.ClipRepository = ClipRepository = ClipRepository_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [client_dynamodb_1.DynamoDB])
+], ClipRepository);

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

@@ -0,0 +1,12 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { Comment, CommentStatus } from '../entities/comment.entity';
+export declare class CommentRepository extends BaseRepository<Comment> {
+    private readonly logger;
+    constructor(dynamoDbClient: DynamoDB);
+    findByProjectId(projectId: string): Promise<Comment[]>;
+    findByStatus(projectId: string, status: CommentStatus): Promise<Comment[]>;
+    findReplies(parentId: string): Promise<Comment[]>;
+    findByUserId(userId: string): Promise<Comment[]>;
+    markAsResolved(commentId: string): Promise<void>;
+}

package/dist/repositories/comment.repository.js

@@ -0,0 +1,92 @@
+"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 CommentRepository_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommentRepository = 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 comment_entity_1 = require("../entities/comment.entity");
+let CommentRepository = CommentRepository_1 = class CommentRepository extends base_repository_1.BaseRepository {
+    logger = new common_1.Logger(CommentRepository_1.name);
+    constructor(dynamoDbClient) {
+        super(dynamoDbClient, `comment-${process.env.STAGE}`);
+    }
+    async findByProjectId(projectId) {
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            IndexName: 'projectId-createdAt-index',
+            KeyConditionExpression: 'projectId = :projectId',
+            ScanIndexForward: false,
+            ExpressionAttributeValues: {
+                ':projectId': projectId,
+            },
+        });
+        return result.Items || [];
+    }
+    async findByStatus(projectId, status) {
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            IndexName: 'projectId-status-index',
+            KeyConditionExpression: 'projectId = :projectId AND #status = :status',
+            ExpressionAttributeNames: {
+                '#status': 'status',
+            },
+            ExpressionAttributeValues: {
+                ':projectId': projectId,
+                ':status': status,
+            },
+        });
+        return result.Items || [];
+    }
+    async findReplies(parentId) {
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            IndexName: 'parentId-createdAt-index',
+            KeyConditionExpression: 'parentId = :parentId',
+            ExpressionAttributeValues: {
+                ':parentId': parentId,
+            },
+        });
+        return result.Items || [];
+    }
+    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 markAsResolved(commentId) {
+        await this.dynamoDb.update({
+            TableName: this.tableName,
+            Key: { id: commentId },
+            UpdateExpression: 'SET #status = :status, updatedAt = :updatedAt',
+            ExpressionAttributeNames: {
+                '#status': 'status',
+            },
+            ExpressionAttributeValues: {
+                ':status': comment_entity_1.CommentStatus.RESOLVED,
+                ':updatedAt': new Date().toISOString(),
+            },
+        });
+    }
+};
+exports.CommentRepository = CommentRepository;
+exports.CommentRepository = CommentRepository = CommentRepository_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [client_dynamodb_1.DynamoDB])
+], CommentRepository);

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

@@ -0,0 +1,26 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { EditorProject } from '../entities/editor-project.entity';
+import { ProjectStatus, ProjectVisibility } from '../common/enums';
+export declare class EditorProjectRepository extends BaseRepository<EditorProject> {
+    private readonly logger;
+    constructor(dynamoDbClient: DynamoDB);
+    findByUserAndWorkspace(ownerId: string, workspaceId: string): Promise<EditorProject[]>;
+    findTemplates(): Promise<EditorProject[]>;
+    findFavorites(ownerId: string): Promise<EditorProject[]>;
+    findPremiumTemplates(): Promise<EditorProject[]>;
+    findRecentlyOpened(ownerId: string, limit?: number): Promise<EditorProject[]>;
+    countByOwner(ownerId: string): Promise<number>;
+    getAllTagsByOwner(ownerId: string): Promise<string[]>;
+    findByWorkspaceId(workspaceId: string): Promise<EditorProject[]>;
+    findByOwnerId(ownerId: string): Promise<EditorProject[]>;
+    findByStatus(status: ProjectStatus): Promise<EditorProject[]>;
+    findByVisibility(visibility: ProjectVisibility): Promise<EditorProject[]>;
+    findByTemplateCategory(templateCategory: string): Promise<EditorProject[]>;
+    findByTag(tag: string): Promise<EditorProject[]>;
+    findByCollaboratorId(collaboratorId: string): Promise<EditorProject[]>;
+    findByTitle(title: string): Promise<EditorProject[]>;
+    findById(id: string): Promise<EditorProject | undefined>;
+    updateThumbnailUrl(projectId: string, thumbnailUrl: string): Promise<void>;
+    duplicateProject(projectId: string, newTitle?: string): Promise<EditorProject>;
+}

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

@@ -0,0 +1,107 @@
+"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 EditorProjectRepository_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditorProjectRepository = 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 EditorProjectRepository = EditorProjectRepository_1 = class EditorProjectRepository extends base_repository_1.BaseRepository {
+    logger = new common_1.Logger(EditorProjectRepository_1.name);
+    constructor(dynamoDbClient) {
+        super(dynamoDbClient, `editor-project-${process.env.STAGE}`);
+    }
+    async findByUserAndWorkspace(ownerId, workspaceId) {
+        return this.find({ ownerId, workspaceId });
+    }
+    async findTemplates() {
+        return this.find({ isTemplate: true });
+    }
+    async findFavorites(ownerId) {
+        return this.find({ ownerId, isFavorite: true });
+    }
+    async findPremiumTemplates() {
+        return this.find({ isTemplate: true, isPremiumTemplate: true });
+    }
+    async findRecentlyOpened(ownerId, limit = 10) {
+        const projects = await this.find({ ownerId });
+        return projects
+            .filter((p) => !!p.lastOpenedAt)
+            .sort((a, b) => (b.lastOpenedAt || '').localeCompare(a.lastOpenedAt || ''))
+            .slice(0, limit);
+    }
+    async countByOwner(ownerId) {
+        const projects = await this.find({ ownerId });
+        return projects.length;
+    }
+    async getAllTagsByOwner(ownerId) {
+        const projects = await this.find({ ownerId });
+        const tagsSet = new Set();
+        projects.forEach((p) => {
+            if (Array.isArray(p.tags)) {
+                p.tags.forEach((tag) => tagsSet.add(tag));
+            }
+        });
+        return Array.from(tagsSet);
+    }
+    async findByWorkspaceId(workspaceId) {
+        return this.find({ workspaceId });
+    }
+    async findByOwnerId(ownerId) {
+        return this.find({ ownerId });
+    }
+    async findByStatus(status) {
+        return this.find({ status });
+    }
+    async findByVisibility(visibility) {
+        return this.find({ visibility });
+    }
+    async findByTemplateCategory(templateCategory) {
+        return this.find({ templateCategory });
+    }
+    async findByTag(tag) {
+        const projects = await this.find({});
+        return projects.filter((p) => Array.isArray(p.tags) && p.tags.includes(tag));
+    }
+    async findByCollaboratorId(collaboratorId) {
+        const projects = await this.find({});
+        return projects.filter((p) => Array.isArray(p.collaboratorIds) &&
+            p.collaboratorIds.includes(collaboratorId));
+    }
+    async findByTitle(title) {
+        return this.find({ title });
+    }
+    async findById(id) {
+        return super.findById(id);
+    }
+    async updateThumbnailUrl(projectId, thumbnailUrl) {
+        await this.update(projectId, { thumbnailUrl });
+    }
+    async duplicateProject(projectId, newTitle) {
+        const originalProject = await this.findById(projectId);
+        if (!originalProject) {
+            throw new Error('EditorProject not found');
+        }
+        const newProject = {
+            ...originalProject,
+            id: `${Date.now()}-${Math.random()}`,
+            title: newTitle || `${originalProject.title} Copy`,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+        return await this.create(newProject);
+    }
+};
+exports.EditorProjectRepository = EditorProjectRepository;
+exports.EditorProjectRepository = EditorProjectRepository = EditorProjectRepository_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [client_dynamodb_1.DynamoDB])
+], EditorProjectRepository);

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

@@ -0,0 +1,10 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { Effect, EffectType } from '../entities/effect.entity';
+export declare class EffectRepository extends BaseRepository<Effect> {
+    private readonly logger;
+    constructor(dynamoDbClient: DynamoDB);
+    findByType(effectType: EffectType): Promise<Effect[]>;
+    findActive(): Promise<Effect[]>;
+    findById(id: string): Promise<Effect | undefined>;
+}

package/dist/repositories/effect.repository.js

@@ -0,0 +1,59 @@
+"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 EffectRepository_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EffectRepository = 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 EffectRepository = EffectRepository_1 = class EffectRepository extends base_repository_1.BaseRepository {
+    logger = new common_1.Logger(EffectRepository_1.name);
+    constructor(dynamoDbClient) {
+        super(dynamoDbClient, `effect-${process.env.STAGE}`);
+    }
+    async findByType(effectType) {
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            IndexName: 'effectType-index',
+            KeyConditionExpression: 'effectType = :effectType',
+            ExpressionAttributeValues: {
+                ':effectType': effectType,
+            },
+        });
+        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];
+    }
+};
+exports.EffectRepository = EffectRepository;
+exports.EffectRepository = EffectRepository = EffectRepository_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [client_dynamodb_1.DynamoDB])
+], EffectRepository);

package/dist/repositories/index.d.ts

@@ -0,0 +1,21 @@
+export * from './asset.repository';
+export * from './base.repository';
+export * from './clip.repository';
+export * from './clip-effect.repository';
+export * from './comment.repository';
+export * from './effect.repository';
+export * from './keyframe.repository';
+export * from './payment-transaction.repository';
+export * from './project-version.repository';
+export * from './reward-rule.repository';
+export * from './subscription-plan.repository';
+export * from './subscription-usage.repository';
+export * from './timeline.repository';
+export * from './track.repository';
+export * from './user.repository';
+export * from './user-onboarding-response.repository';
+export * from './user-subscription.repository';
+export * from './workspace-member.repository';
+export * from './workspace.repository';
+export * from './user-profile.repository';
+export * from './editor-project.repository';

package/dist/repositories/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./asset.repository"), exports);
+__exportStar(require("./base.repository"), exports);
+__exportStar(require("./clip.repository"), exports);
+__exportStar(require("./clip-effect.repository"), exports);
+__exportStar(require("./comment.repository"), exports);
+__exportStar(require("./effect.repository"), exports);
+__exportStar(require("./keyframe.repository"), exports);
+__exportStar(require("./payment-transaction.repository"), exports);
+__exportStar(require("./project-version.repository"), exports);
+__exportStar(require("./reward-rule.repository"), exports);
+__exportStar(require("./subscription-plan.repository"), exports);
+__exportStar(require("./subscription-usage.repository"), exports);
+__exportStar(require("./timeline.repository"), exports);
+__exportStar(require("./track.repository"), exports);
+__exportStar(require("./user.repository"), exports);
+__exportStar(require("./user-onboarding-response.repository"), exports);
+__exportStar(require("./user-subscription.repository"), exports);
+__exportStar(require("./workspace-member.repository"), exports);
+__exportStar(require("./workspace.repository"), exports);
+__exportStar(require("./user-profile.repository"), exports);
+__exportStar(require("./editor-project.repository"), exports);

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

@@ -0,0 +1,9 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { Keyframe } from '../entities/keyframe.entity';
+export declare class KeyframeRepository extends BaseRepository<Keyframe> {
+    private readonly logger;
+    constructor(dynamoDbClient: DynamoDB);
+    findByClipId(clipId: string): Promise<Keyframe[]>;
+    findByClipEffectId(clipEffectId: string): Promise<Keyframe[]>;
+}

package/dist/repositories/keyframe.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 KeyframeRepository_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyframeRepository = 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 KeyframeRepository = KeyframeRepository_1 = class KeyframeRepository extends base_repository_1.BaseRepository {
+    logger = new common_1.Logger(KeyframeRepository_1.name);
+    constructor(dynamoDbClient) {
+        super(dynamoDbClient, `keyframe-${process.env.STAGE}`);
+    }
+    async findByClipId(clipId) {
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            IndexName: 'clipId-index',
+            KeyConditionExpression: 'clipId = :clipId',
+            ExpressionAttributeValues: {
+                ':clipId': clipId,
+            },
+        });
+        return result.Items || [];
+    }
+    async findByClipEffectId(clipEffectId) {
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            IndexName: 'clipEffectId-index',
+            KeyConditionExpression: 'clipEffectId = :clipEffectId',
+            ExpressionAttributeValues: {
+                ':clipEffectId': clipEffectId,
+            },
+        });
+        return result.Items || [];
+    }
+};
+exports.KeyframeRepository = KeyframeRepository;
+exports.KeyframeRepository = KeyframeRepository = KeyframeRepository_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [client_dynamodb_1.DynamoDB])
+], KeyframeRepository);

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

@@ -0,0 +1,13 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { PaymentTransaction, TransactionStatus } from '../entities/payment-transaction.entity';
+export declare class PaymentTransactionRepository extends BaseRepository<PaymentTransaction> {
+    private readonly logger;
+    constructor(dynamoDbClient: DynamoDB);
+    findByUserId(userId: string): Promise<PaymentTransaction[]>;
+    findBySubscriptionId(subscriptionId: string): Promise<PaymentTransaction[]>;
+    findByStripePaymentIntentId(stripePaymentIntentId: string): Promise<PaymentTransaction | undefined>;
+    findByStatusAndDateRange(status: TransactionStatus, startDate: string, endDate: string): Promise<PaymentTransaction[]>;
+    findFailedTransactions(userId?: string): Promise<PaymentTransaction[]>;
+    getTotalRevenueByPeriod(startDate: string, endDate: string): Promise<number>;
+}