clhq-dynamodb-module 1.1.0-alpha.90

package/readme.entity.implementation.md

@@ -0,0 +1,1560 @@
+```
+// ===== ENTITIES =====
+
+// entities/workspace.entity.ts
+import {
+  attribute,
+  table,
+  hashKey,
+} from '@aws/dynamodb-data-mapper-annotations';
+import { IsString, IsOptional, IsBoolean } from 'class-validator';
+
+@table('workspaces')
+export class Workspace {
+  @IsString()
+  @hashKey()
+  id: string;
+
+  @IsString()
+  @attribute()
+  name: string;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  description?: string;
+
+  @IsString()
+  @attribute()
+  ownerId: string;
+
+  @IsBoolean()
+  @attribute()
+  isShared: boolean = false;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  createdAt?: string;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  updatedAt?: string;
+}
+
+// entities/project.entity.ts
+import {
+  attribute,
+  table,
+  hashKey,
+} from '@aws/dynamodb-data-mapper-annotations';
+import { IsString, IsNumber, IsOptional, IsBoolean, IsEnum, IsArray } from 'class-validator';
+
+export enum ProjectStatus {
+  DRAFT = 'draft',
+  IN_PROGRESS = 'in_progress',
+  RENDERING = 'rendering',
+  COMPLETED = 'completed',
+  FAILED = 'failed',
+  ARCHIVED = 'archived',
+}
+
+export enum ProjectVisibility {
+  PRIVATE = 'private',
+  WORKSPACE = 'workspace',
+  PUBLIC = 'public',
+}
+
+@table('projects')
+export class Project {
+  @IsString()
+  @hashKey()
+  id: string;
+
+  @IsString()
+  @attribute()
+  workspaceId: string;
+
+  @IsString()
+  @attribute()
+  ownerId: string; // User who created the project
+
+  @IsString()
+  @attribute()
+  name: string;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  description?: string;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  thumbnailUrl?: string;
+
+  // Video specifications
+  @IsNumber()
+  @attribute()
+  durationMs: number = 0;
+
+  @IsNumber()
+  @attribute()
+  fps: number = 30;
+
+  @IsNumber()
+  @attribute()
+  resolutionWidth: number = 1920;
+
+  @IsNumber()
+  @attribute()
+  resolutionHeight: number = 1080;
+
+  @IsString()
+  @attribute()
+  backgroundColor: string = '#000000';
+
+  @IsString()
+  @attribute()
+  aspectRatio: string = '16:9'; // '16:9', '9:16', '1:1', '4:3'
+
+  // Project status and metadata
+  @IsEnum(ProjectStatus)
+  @attribute()
+  status: ProjectStatus = ProjectStatus.DRAFT;
+
+  @IsEnum(ProjectVisibility)
+  @attribute()
+  visibility: ProjectVisibility = ProjectVisibility.PRIVATE;
+
+  @IsNumber()
+  @attribute()
+  version: number = 1;
+
+  @IsBoolean()
+  @attribute()
+  isTemplate: boolean = false;
+
+  @IsBoolean()
+  @attribute()
+  isFavorite: boolean = false;
+
+  // Collaboration
+  @IsArray()
+  @IsOptional()
+  @attribute()
+  collaboratorIds?: string[];
+
+  @IsArray()
+  @IsOptional()
+  @attribute()
+  tags?: string[];
+
+  // Template specific
+  @IsString()
+  @IsOptional()
+  @attribute()
+  templateCategory?: string;
+
+  @IsBoolean()
+  @attribute()
+  isPremiumTemplate: boolean = false;
+
+  @IsNumber()
+  @attribute()
+  templateUsageCount: number = 0;
+
+  // Timestamps
+  @IsString()
+  @IsOptional()
+  @attribute()
+  lastOpenedAt?: string;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  lastEditedBy?: string;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  createdAt?: string;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  updatedAt?: string;
+
+  // Project settings
+  @IsOptional()
+  @attribute()
+  settings?: {
+    autoSave?: boolean;
+    gridSnap?: boolean;
+    showTimecode?: boolean;
+    previewQuality?: 'low' | 'medium' | 'high';
+    audioLevels?: boolean;
+  };
+}
+
+// entities/asset.entity.ts
+import {
+  attribute,
+  table,
+  hashKey,
+} from '@aws/dynamodb-data-mapper-annotations';
+import { IsString, IsNumber, IsOptional, IsBoolean, IsEnum, IsArray, IsObject } from 'class-validator';
+
+export enum AssetType {
+  VIDEO = 'video',
+  AUDIO = 'audio',
+  IMAGE = 'image',
+  FONT = 'font',
+  SUBTITLE = 'subtitle',
+  TEMPLATE = 'template',
+  GRAPHIC = 'graphic',
+}
+
+export enum AssetStatus {
+  UPLOADING = 'uploading',
+  PROCESSING = 'processing',
+  READY = 'ready',
+  FAILED = 'failed',
+  DELETED = 'deleted',
+}
+
+@table('assets')
+export class Asset {
+  @IsString()
+  @hashKey()
+  id: string;
+
+  @IsString()
+  @attribute()
+  workspaceId: string;
+
+  @IsString()
+  @attribute()
+  uploadedBy: string; // User ID
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  categoryId?: string;
+
+  @IsString()
+  @attribute()
+  name: string;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  originalFilename?: string;
+
+  @IsEnum(AssetType)
+  @attribute()
+  fileType: AssetType;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  mimeType?: string;
+
+  @IsNumber()
+  @attribute()
+  fileSize: number;
+
+  @IsString()
+  @attribute()
+  fileUrl: string;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  thumbnailUrl?: string;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  previewUrl?: string; // For video previews
+
+  // Media properties
+  @IsNumber()
+  @IsOptional()
+  @attribute()
+  durationMs?: number; // For video/audio
+
+  @IsNumber()
+  @IsOptional()
+  @attribute()
+  width?: number; // For image/video
+
+  @IsNumber()
+  @IsOptional()
+  @attribute()
+  height?: number; // For image/video
+
+  @IsNumber()
+  @IsOptional()
+  @attribute()
+  frameRate?: number; // For video
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  codec?: string; // For video/audio
+
+  @IsNumber()
+  @IsOptional()
+  @attribute()
+  bitrate?: number; // For video/audio
+
+  // Flexible metadata storage
+  @IsObject()
+  @IsOptional()
+  @attribute()
+  metadata?: {
+    colorSpace?: string;
+    hasAudio?: boolean;
+    audioChannels?: number;
+    audioSampleRate?: number;
+    videoCodec?: string;
+    audioCodec?: string;
+    creationTime?: string;
+    cameraModel?: string;
+    location?: {
+      latitude?: number;
+      longitude?: number;
+    };
+    exif?: Record<string, any>;
+  };
+
+  @IsEnum(AssetStatus)
+  @attribute()
+  uploadStatus: AssetStatus = AssetStatus.UPLOADING;
+
+  @IsArray()
+  @IsOptional()
+  @attribute()
+  tags?: string[];
+
+  @IsBoolean()
+  @attribute()
+  isPublic: boolean = false;
+
+  @IsBoolean()
+  @attribute()
+  isPremium: boolean = false;
+
+  // Usage tracking
+  @IsNumber()
+  @attribute()
+  usageCount: number = 0;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  lastUsedAt?: string;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  createdAt?: string;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  updatedAt?: string;
+}
+
+// entities/timeline.entity.ts
+import {
+  attribute,
+  table,
+  hashKey,
+} from '@aws/dynamodb-data-mapper-annotations';
+import { IsString, IsNumber, IsOptional } from 'class-validator';
+
+@table('timelines')
+export class Timeline {
+  @IsString()
+  @hashKey()
+  id: string;
+
+  @IsString()
+  @attribute()
+  projectId: string;
+
+  @IsString()
+  @attribute()
+  name: string = 'Main Timeline';
+
+  @IsNumber()
+  @attribute()
+  durationMs: number = 0;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  createdAt?: string;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  updatedAt?: string;
+}
+
+// entities/track.entity.ts
+import {
+  attribute,
+  table,
+  hashKey,
+} from '@aws/dynamodb-data-mapper-annotations';
+import { IsString, IsNumber, IsOptional, IsBoolean, IsEnum } from 'class-validator';
+
+export enum TrackType {
+  VIDEO = 'video',
+  AUDIO = 'audio',
+  SUBTITLE = 'subtitle',
+  OVERLAY = 'overlay',
+  TEXT = 'text',
+}
+
+@table('tracks')
+export class Track {
+  @IsString()
+  @hashKey()
+  id: string;
+
+  @IsString()
+  @attribute()
+  timelineId: string;
+
+  @IsEnum(TrackType)
+  @attribute()
+  trackType: TrackType;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  name?: string;
+
+  @IsNumber()
+  @attribute()
+  orderIndex: number;
+
+  @IsBoolean()
+  @attribute()
+  isLocked: boolean = false;
+
+  @IsBoolean()
+  @attribute()
+  isMuted: boolean = false;
+
+  @IsBoolean()
+  @attribute()
+  isVisible: boolean = true;
+
+  @IsNumber()
+  @attribute()
+  height: number = 60;
+
+  @IsString()
+  @attribute()
+  color: string = '#4A90E2';
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  createdAt?: string;
+}
+
+// entities/clip.entity.ts
+import {
+  attribute,
+  table,
+  hashKey,
+} from '@aws/dynamodb-data-mapper-annotations';
+import { IsString, IsNumber, IsOptional, IsBoolean, IsObject } from 'class-validator';
+
+@table('clips')
+export class Clip {
+  @IsString()
+  @hashKey()
+  id: string;
+
+  @IsString()
+  @attribute()
+  trackId: string;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  assetId?: string; // Can be null for generated clips (text, shapes, etc.)
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  name?: string;
+
+  // Timeline positioning
+  @IsNumber()
+  @attribute()
+  startTimeMs: number;
+
+  @IsNumber()
+  @attribute()
+  endTimeMs: number;
+
+  @IsNumber()
+  @attribute()
+  orderIndex: number;
+
+  // Asset trimming
+  @IsNumber()
+  @attribute()
+  assetStartTimeMs: number = 0; // Trim start
+
+  @IsNumber()
+  @IsOptional()
+  @attribute()
+  assetEndTimeMs?: number; // Trim end
+
+  // Audio/Video properties
+  @IsNumber()
+  @attribute()
+  volume: number = 1.0; // 0.0 to 2.0
+
+  @IsNumber()
+  @attribute()
+  opacity: number = 1.0; // 0.0 to 1.0
+
+  @IsNumber()
+  @attribute()
+  speed: number = 1.0; // 0.1 to 10.0
+
+  @IsBoolean()
+  @attribute()
+  isReversed: boolean = false;
+
+  // Visual transformations
+  @IsObject()
+  @IsOptional()
+  @attribute()
+  transform?: {
+    x?: number;
+    y?: number;
+    scaleX?: number;
+    scaleY?: number;
+    rotation?: number;
+    skewX?: number;
+    skewY?: number;
+  };
+
+  // Crop settings
+  @IsObject()
+  @IsOptional()
+  @attribute()
+  crop?: {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+  };
+
+  // Color correction
+  @IsObject()
+  @IsOptional()
+  @attribute()
+  colorCorrection?: {
+    brightness?: number;
+    contrast?: number;
+    saturation?: number;
+    hue?: number;
+    gamma?: number;
+    exposure?: number;
+    highlights?: number;
+    shadows?: number;
+    temperature?: number;
+    tint?: number;
+  };
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  createdAt?: string;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  updatedAt?: string;
+}
+
+// entities/effect.entity.ts
+import {
+  attribute,
+  table,
+  hashKey,
+} from '@aws/dynamodb-data-mapper-annotations';
+import { IsString, IsOptional, IsBoolean, IsEnum, IsObject } from 'class-validator';
+
+export enum EffectType {
+  FILTER = 'filter',
+  TRANSITION = 'transition',
+  TEXT = 'text',
+  SHAPE = 'shape',
+  ANIMATION = 'animation',
+  COLOR_CORRECTION = 'color_correction',
+  AUDIO_EFFECT = 'audio_effect',
+}
+
+@table('effects')
+export class Effect {
+  @IsString()
+  @hashKey()
+  id: string;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  categoryId?: string;
+
+  @IsString()
+  @attribute()
+  name: string;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  description?: string;
+
+  @IsEnum(EffectType)
+  @attribute()
+  effectType: EffectType;
+
+  @IsObject()
+  @IsOptional()
+  @attribute()
+  parametersSchema?: Record<string, any>; // JSON schema for parameters
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  thumbnailUrl?: string;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  previewUrl?: string;
+
+  @IsBoolean()
+  @attribute()
+  isPremium: boolean = false;
+
+  @IsBoolean()
+  @attribute()
+  isActive: boolean = true;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  createdAt?: string;
+}
+
+// entities/clip-effect.entity.ts
+import {
+  attribute,
+  table,
+  hashKey,
+} from '@aws/dynamodb-data-mapper-annotations';
+import { IsString, IsNumber, IsOptional, IsBoolean, IsObject } from 'class-validator';
+
+@table('clip_effects')
+export class ClipEffect {
+  @IsString()
+  @hashKey()
+  id: string;
+
+  @IsString()
+  @attribute()
+  clipId: string;
+
+  @IsString()
+  @attribute()
+  effectId: string;
+
+  @IsObject()
+  @IsOptional()
+  @attribute()
+  parameters?: Record<string, any>; // Actual parameter values
+
+  @IsNumber()
+  @attribute()
+  orderIndex: number;
+
+  @IsBoolean()
+  @attribute()
+  isEnabled: boolean = true;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  createdAt?: string;
+}
+
+// entities/keyframe.entity.ts
+import {
+  attribute,
+  table,
+  hashKey,
+} from '@aws/dynamodb-data-mapper-annotations';
+import { IsString, IsNumber, IsOptional, IsEnum, IsObject, IsArray } from 'class-validator';
+
+export enum EasingType {
+  LINEAR = 'linear',
+  EASE_IN = 'ease-in',
+  EASE_OUT = 'ease-out',
+  EASE_IN_OUT = 'ease-in-out',
+  BEZIER = 'bezier',
+}
+
+@table('keyframes')
+export class Keyframe {
+  @IsString()
+  @hashKey()
+  id: string;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  clipId?: string;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  clipEffectId?: string;
+
+  @IsString()
+  @attribute()
+  propertyName: string; // e.g., 'opacity', 'x', 'y', 'scale'
+
+  @IsNumber()
+  @attribute()
+  timeMs: number;
+
+  @IsObject()
+  @attribute()
+  value: any; // Can store various data types
+
+  @IsEnum(EasingType)
+  @attribute()
+  easingType: EasingType = EasingType.LINEAR;
+
+  @IsArray()
+  @IsOptional()
+  @attribute()
+  bezierValues?: number[]; // For custom bezier curves [x1, y1, x2, y2]
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  createdAt?: string;
+}
+
+// entities/project-version.entity.ts
+import {
+  attribute,
+  table,
+  hashKey,
+} from '@aws/dynamodb-data-mapper-annotations';
+import { IsString, IsNumber, IsOptional, IsObject } from 'class-validator';
+
+@table('project_versions')
+export class ProjectVersion {
+  @IsString()
+  @hashKey()
+  id: string;
+
+  @IsString()
+  @attribute()
+  projectId: string;
+
+  @IsNumber()
+  @attribute()
+  versionNumber: number;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  name?: string;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  description?: string;
+
+  @IsString()
+  @attribute()
+  createdBy: string; // User ID
+
+  @IsObject()
+  @IsOptional()
+  @attribute()
+  snapshotData?: Record<string, any>; // Serialized project state
+
+  @IsNumber()
+  @IsOptional()
+  @attribute()
+  fileSize?: number;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  createdAt?: string;
+}
+
+// entities/comment.entity.ts
+import {
+  attribute,
+  table,
+  hashKey,
+} from '@aws/dynamodb-data-mapper-annotations';
+import { IsString, IsNumber, IsOptional, IsEnum } from 'class-validator';
+
+export enum CommentStatus {
+  OPEN = 'open',
+  RESOLVED = 'resolved',
+  ARCHIVED = 'archived',
+}
+
+@table('comments')
+export class Comment {
+  @IsString()
+  @hashKey()
+  id: string;
+
+  @IsString()
+  @attribute()
+  projectId: string;
+
+  @IsString()
+  @attribute()
+  userId: string;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  parentId?: string; // For reply threads
+
+  @IsString()
+  @attribute()
+  content: string;
+
+  @IsNumber()
+  @IsOptional()
+  @attribute()
+  timestampMs?: number; // Specific time in timeline
+
+  @IsNumber()
+  @IsOptional()
+  @attribute()
+  positionX?: number; // X coordinate for video comments
+
+  @IsNumber()
+  @IsOptional()
+  @attribute()
+  positionY?: number; // Y coordinate for video comments
+
+  @IsEnum(CommentStatus)
+  @attribute()
+  status: CommentStatus = CommentStatus.OPEN;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  createdAt?: string;
+
+  @IsString()
+  @IsOptional()
+  @attribute()
+  updatedAt?: string;
+}
+
+// ===== REPOSITORIES =====
+
+// repositories/workspace.repository.ts
+import { Injectable, Logger } from '@nestjs/common';
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { Workspace } from '../entities/workspace.entity';
+
+@Injectable()
+export class WorkspaceRepository extends BaseRepository<Workspace> {
+  private readonly logger = new Logger(WorkspaceRepository.name);
+
+  constructor(dynamoDbClient: DynamoDB) {
+    super(dynamoDbClient, `Workspace-${process.env.STAGE}`);
+  }
+
+  async findByOwnerId(ownerId: string): Promise<Workspace[]> {
+    const result = await this.dynamoDb.query({
+      TableName: this.tableName,
+      IndexName: 'ownerId-index',
+      KeyConditionExpression: 'ownerId = :ownerId',
+      ExpressionAttributeValues: {
+        ':ownerId': ownerId,
+      },
+    });
+    return (result.Items as Workspace[]) || [];
+  }
+
+  async findSharedWorkspaces(): Promise<Workspace[]> {
+    const result = await this.dynamoDb.query({
+      TableName: this.tableName,
+      IndexName: 'isShared-index',
+      KeyConditionExpression: 'isShared = :shared',
+      ExpressionAttributeValues: {
+        ':shared': true,
+      },
+    });
+    return (result.Items as Workspace[]) || [];
+  }
+
+  async findByNameContains(searchTerm: string, ownerId?: string): Promise<Workspace[]> {
+    const filterExpression = ownerId 
+      ? 'contains(#name, :searchTerm) AND ownerId = :ownerId'
+      : 'contains(#name, :searchTerm)';
+    
+    const expressionAttributeValues = ownerId 
+      ? { ':searchTerm': searchTerm, ':ownerId': ownerId }
+      : { ':searchTerm': searchTerm };
+
+    const result = await this.dynamoDb.scan({
+      TableName: this.tableName,
+      FilterExpression: filterExpression,
+      ExpressionAttributeNames: {
+        '#name': 'name',
+      },
+      ExpressionAttributeValues: expressionAttributeValues,
+    });
+    return (result.Items as Workspace[]) || [];
+  }
+}
+
+// repositories/project.repository.ts
+import { Injectable, Logger } from '@nestjs/common';
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { Project, ProjectStatus, ProjectVisibility } from '../entities/project.entity';
+
+@Injectable()
+export class ProjectRepository extends BaseRepository<Project> {
+  private readonly logger = new Logger(ProjectRepository.name);
+
+  constructor(dynamoDbClient: DynamoDB) {
+    super(dynamoDbClient, `Project-${process.env.STAGE}`);
+  }
+
+  async findByWorkspaceId(workspaceId: string): Promise<Project[]> {
+    const result = await this.dynamoDb.query({
+      TableName: this.tableName,
+      IndexName: 'workspaceId-updatedAt-index',
+      KeyConditionExpression: 'workspaceId = :workspaceId',
+      ScanIndexForward: false, // Latest first
+      ExpressionAttributeValues: {
+        ':workspaceId': workspaceId,
+      },
+    });
+    return (result.Items as Project[]) || [];
+  }
+
+  async findByOwnerId(ownerId: string): Promise<Project[]> {
+    const result = await this.dynamoDb.query({
+      TableName: this.tableName,
+      IndexName: 'ownerId-updatedAt-index',
+      KeyConditionExpression: 'ownerId = :ownerId',
+      ScanIndexForward: false,
+      ExpressionAttributeValues: {
+        ':ownerId': ownerId,
+      },
+    });
+    return (result.Items as Project[]) || [];
+  }
+
+  async findByStatus(status: ProjectStatus): Promise<Project[]> {
+    const result = await this.dynamoDb.query({
+      TableName: this.tableName,
+      IndexName: 'status-updatedAt-index',
+      KeyConditionExpression: '#status = :status',
+      ExpressionAttributeNames: {
+        '#status': 'status',
+      },
+      ExpressionAttributeValues: {
+        ':status': status,
+      },
+    });
+    return (result.Items as Project[]) || [];
+  }
+
+  async findTemplates(category?: string, isPremium?: boolean): Promise<Project[]> {
+    let filterExpression = 'isTemplate = :isTemplate';
+    const expressionAttributeValues: any = { ':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 as Project[]) || [];
+  }
+
+  async findRecentProjects(userId: string, limit: number = 10): Promise<Project[]> {
+    const result = await this.dynamoDb.query({
+      TableName: this.tableName,
+      IndexName: 'ownerId-lastOpenedAt-index',
+      KeyConditionExpression: 'ownerId = :userId',
+      ScanIndexForward: false,
+      Limit: limit,
+      ExpressionAttributeValues: {
+        ':userId': userId,
+      },
+    });
+    return (result.Items as Project[]) || [];
+  }
+
+  async findFavoriteProjects(userId: string): Promise<Project[]> {
+    const result = await this.dynamoDb.query({
+      TableName: this.tableName,
+      IndexName: 'ownerId-isFavorite-index',
+      KeyConditionExpression: 'ownerId = :userId AND isFavorite = :favorite',
+      ExpressionAttributeValues: {
+        ':userId': userId,
+        ':favorite': true,
+      },
+    });
+    return (result.Items as Project[]) || [];
+  }
+
+  async findByTags(tags: string[], workspaceId?: string): Promise<Project[]> {
+    const tagConditions = tags.map((_, index) => `contains(tags, :tag${index})`).join(' OR ');
+    let filterExpression = `(${tagConditions})`;
+    
+    const expressionAttributeValues: any = {};
+    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 as Project[]) || [];
+  }
+
+  async updateLastOpened(projectId: string, userId: string): Promise<void> {
+    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: string): Promise<void> {
+    await this.dynamoDb.update({
+      TableName: this.tableName,
+      Key: { id: projectId },
+      UpdateExpression: 'ADD templateUsageCount :increment',
+      ExpressionAttributeValues: {
+        ':increment': 1,
+      },
+    });
+  }
+
+  async searchProjects(searchTerm: string, workspaceId?: string, userId?: string): Promise<Project[]> {
+    let filterExpression = 'contains(#name, :searchTerm) OR contains(description, :searchTerm)';
+    const expressionAttributeNames: any = { '#name': 'name' };
+    const expressionAttributeValues: any = { ':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 as Project[]) || [];
+  }
+}
+
+// repositories/asset.repository.ts
+import { Injectable, Logger } from '@nestjs/common';
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { Asset, AssetType, AssetStatus } from '../entities/asset.entity';
+
+@Injectable()
+export class AssetRepository extends BaseRepository<Asset> {
+  private readonly logger = new Logger(AssetRepository.name);
+
+  constructor(dynamoDbClient: DynamoDB) {
+    super(dynamoDbClient, `Asset-${process.env.STAGE}`);
+  }
+
+  async findByWorkspaceId(workspaceId: string): Promise<Asset[]> {
+    const result = await this.dynamoDb.query({
+      TableName: this.tableName,
+      IndexName: 'workspaceId-createdAt-index',
+      KeyConditionExpression: 'workspaceId = :workspaceId',
+      ScanIndexForward: false,
+      ExpressionAttributeValues: {
+        ':workspaceId': workspaceId,
+      },
+    });
+    return (result.Items as Asset[]) || [];
+  }
+
+  async findByFileType(fileType: AssetType, workspaceId?: string): Promise<Asset[]> {
+    if (workspaceId) {
+      const result = await this.dynamoDb.query({
+        TableName: this.tableName,
+        IndexName: 'workspaceId-fileType-index',
+        KeyConditionExpression: 'workspaceId = :workspaceId AND fileType = :fileType',
+        ExpressionAttributeValues: {
+          ':workspaceId': workspaceId,
+          ':fileType': fileType,
+        },
+      });
+      return (result.Items as Asset[]) || [];
+    }
+
+    const result = await this.dynamoDb.query({
+      TableName: this.tableName,
+      IndexName: 'fileType-index',
+      KeyConditionExpression: 'fileType = :fileType',
+      ExpressionAttributeValues: {
+        ':fileType': fileType,
+      },
+    });
+    return (result.Items as Asset[]) || [];
+  }
+
+  async findByUploadStatus(status: AssetStatus): Promise<Asset[]> {
+    const result = await this.dynamoDb.query({
+      TableName: this.tableName,
+      IndexName: 'uploadStatus-index',
+      KeyConditionExpression: 'uploadStatus = :status',
+      ExpressionAttributeValues: {
+        ':status': status,
+      },
+    });
+    return (result.Items as Asset[]) || [];
+  }
+
+  async findByUploadedBy(userId: string): Promise<Asset[]> {
+    const result = await this.dynamoDb.query({
+      TableName: this.tableName,
+      IndexName: 'uploadedBy-createdAt-index',
+      KeyConditionExpression: 'uploadedBy = :userId',
+      ScanIndexForward: false,
+      ExpressionAttributeValues: {
+        ':userId': userId,
+      },
+    });
+    return (result.Items as Asset[]) || [];
+  }
+
+  async findByTags(tags: string[], workspaceId?: string): Promise<Asset[]> {
+    const tagConditions = tags.map((_, index) => `contains(tags, :tag${index})`).join(' OR ');
+    let filterExpression = `(${tagConditions})`;
+    
+    const expressionAttributeValues: any = {};
+    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 as Asset[]) || [];
+  }
+
+  async searchAssets(searchTerm: string, workspaceId?: string): Promise<Asset[]> {
+    let filterExpression = 'contains(#name, :searchTerm) OR contains(originalFilename, :searchTerm)';
+    const expressionAttributeNames: any = { '#name': 'name' };
+    const expressionAttributeValues: any = { ':searchTerm': searchTerm };
+
+    if (workspaceId) {
+      filterExpression += ' AND workspaceId = :workspaceId';
+      expressionAttributeValues[':workspaceId'] = workspaceId;
+    }
+
+    const result = await this.dynamoDb.scan({
+      TableName: this.tableName,
+      FilterExpression: filterExpression,
+      ExpressionAttributeNames: expressionAttributeNames,
+      ExpressionAttributeValues: expressionAttributeValues,
+    });
+    return (result.Items as Asset[]) || [];
+  }
+
+  async updateUsage(assetId: string): Promise<void> {
+    await this.dynamoDb.update({
+      TableName: this.tableName,
+      Key: { id: assetId },
+      UpdateExpression: 'ADD usageCount :increment SET lastUsedAt = :timestamp',
+      ExpressionAttributeValues: {
+        ':increment': 1,
+        ':timestamp': new Date().toISOString(),
+      },
+    });
+  }
+
+  async getWorkspaceStorageUsage(workspaceId: string): Promise<number> {
+    const result = await this.dynamoDb.query({
+      TableName: this.tableName,
+      IndexName: 'workspaceId-index',
+      KeyConditionExpression: 'workspaceId = :workspaceId',
+      ProjectionExpression: 'fileSize',
+      ExpressionAttributeValues: {
+        ':workspaceId': workspaceId,
+      },
+    });
+
+    return (result.Items as Asset[])
+      .reduce((total, asset) => total + (asset.fileSize || 0), 0);
+  }
+
+  async findPublicAssets(fileType?: AssetType): Promise<Asset[]> {
+    let filterExpression = 'isPublic = :isPublic';
+    const expressionAttributeValues: any = { ':isPublic': true };
+
+    if (fileType) {
+      filterExpression += ' AND fileType = :fileType';
+      expressionAttributeValues[':fileType'] = fileType;
+    }
+
+    const result = await this.dynamoDb.scan({
+      TableName: this.tableName,
+      FilterExpression: filterExpression,
+      ExpressionAttributeValues: expressionAttributeValues,
+    });
+    return (result.Items as Asset[]) || [];
+  }
+}
+
+// repositories/timeline.repository.ts
+import { Injectable, Logger } from '@nestjs/common';
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { Timeline } from '../entities/timeline.entity';
+
+@Injectable()
+export class TimelineRepository extends BaseRepository<Timeline> {
+  private readonly logger = new Logger(TimelineRepository.name);
+
+  constructor(dynamoDbClient: DynamoDB) {
+    super(dynamoDbClient, `Timeline-${process.env.STAGE}`);
+  }
+
+  async findByProjectId(projectId: string): Promise<Timeline[]> {
+    const result = await this.dynamoDb.query({
+      TableName: this.tableName,
+      IndexName: 'projectId-index',
+      KeyConditionExpression: 'projectId = :projectId',
+      ExpressionAttributeValues: {
+        ':projectId': projectId,
+      },
+    });
+    return (result.Items as Timeline[]) || [];
+  }
+
+  async findMainTimelineByProjectId(projectId: string): Promise<Timeline | undefined> {
+    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] as Timeline;
+  }
+}
+
+// repositories/track.repository.ts
+import { Injectable, Logger } from '@nestjs/common';
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { Track, TrackType } from '../entities/track.entity';
+
+@Injectable()
+export class TrackRepository extends BaseRepository<Track> {
+  private readonly logger = new Logger(TrackRepository.name);
+
+  constructor(dynamoDbClient: DynamoDB) {
+    super(dynamoDbClient, `Track-${process.env.STAGE}`);
+  }
+
+  async findByTimelineId(timelineId: string): Promise<Track[]> {
+    const result = await this.dynamoDb.query({
+      TableName: this.tableName,
+      IndexName: 'timelineId-orderIndex-index',
+      KeyConditionExpression: 'timelineId = :timelineId',
+      ExpressionAttributeValues: {
+        ':timelineId': timelineId,
+      },
+    });
+    return (result.Items as Track[]) || [];
+  }
+
+  async findByTrackType(timelineId: string, trackType: TrackType): Promise<Track[]> {
+    const result = await this.dynamoDb.query({
+      TableName: this.tableName,
+      IndexName: 'timelineId-trackType-index',
+      KeyConditionExpression: 'timelineId = :timelineId AND trackType = :trackType',
+      ExpressionAttributeValues: {
+        ':timelineId': timelineId,
+        ':trackType': trackType,
+      },
+    });
+    return (result.Items as Track[]) || [];
+  }
+
+  async reorderTracks(timelineId: string, trackOrders: { id: string; orderIndex: number }[]): Promise<void> {
+    const updatePromises = trackOrders.map(({ id, orderIndex }) =>
+      this.dynamoDb.update({
+        TableName: this.tableName,
+        Key: { id },
+        UpdateExpression: 'SET orderIndex = :orderIndex',
+        ExpressionAttributeValues: {
+          ':orderIndex': orderIndex,
+        },
+      })
+    );
+
+    await Promise.all(updatePromises);
+  }
+}
+
+// repositories/clip.repository.ts
+import { Injectable, Logger } from '@nestjs/common';
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { Clip } from '../entities/clip.entity';
+
+@Injectable()
+export class ClipRepository extends BaseRepository<Clip> {
+  private readonly logger = new Logger(ClipRepository.name);
+
+  constructor(dynamoDbClient: DynamoDB) {
+    super(dynamoDbClient, `Clip-${process.env.STAGE}`);
+  }
+
+  async findByTrackId(trackId: string): Promise<Clip[]> {
+    const result = await this.dynamoDb.query({
+      TableName: this.tableName,
+      IndexName: 'trackId-startTimeMs-index',
+      KeyConditionExpression: 'trackId = :trackId',
+      ExpressionAttributeValues: {
+        ':trackId': trackId,
+      },
+    });
+    return (result.Items as Clip[]) || [];
+  }
+
+  async findByAssetId(assetId: string): Promise<Clip[]> {
+    const result = await this.dynamoDb.query({
+      TableName: this.tableName,
+      IndexName: 'assetId-index',
+      KeyConditionExpression: 'assetId = :assetId',
+      ExpressionAttributeValues: {
+        ':assetId': assetId,
+      },
+    });
+    return (result.Items as Clip[]) || [];
+  }
+
+  async findClipsInTimeRange(trackId: string, startTime: number, endTime: number): Promise<Clip[]> {
+    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 as Clip[]) || [];
+  }
+
+  async findOverlappingClips(trackId: string, startTime: number, endTime: number): Promise<Clip[]> {
+    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 as Clip[]) || [];
+  }
+
+  async moveClip(clipId: string, newStartTime: number, newEndTime: number): Promise<void> {
+    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: string, newTrackId?: string): Promise<Clip> {
+    const originalClip = await this.findById(clipId);
+    if (!originalClip) {
+      throw new Error('Clip not found');
+    }
+
+    const newClip: Clip = {
+      ...originalClip,
+      id: `${Date.now()}-${Math.random()}`, // Generate new ID
+      trackId: newTrackId || originalClip.trackId,
+      name: `${originalClip.name || 'Clip'} Copy`,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+
+    return await this.create(newClip);
+  }
+}
+
+// repositories/comment.repository.ts
+import { Injectable, Logger } from '@nestjs/common';
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { Comment, CommentStatus } from '../entities/comment.entity';
+
+@Injectable()
+export class CommentRepository extends BaseRepository<Comment> {
+  private readonly logger = new Logger(CommentRepository.name);
+
+  constructor(dynamoDbClient: DynamoDB) {
+    super(dynamoDbClient, `Comment-${process.env.STAGE}`);
+  }
+
+  async findByProjectId(projectId: string): Promise<Comment[]> {
+    const result = await this.dynamoDb.query({
+      TableName: this.tableName,
+      IndexName: 'projectId-createdAt-index',
+      KeyConditionExpression: 'projectId = :projectId',
+      ScanIndexForward: false, // Latest first
+      ExpressionAttributeValues: {
+        ':projectId': projectId,
+      },
+    });
+    return (result.Items as Comment[]) || [];
+  }
+
+  async findByStatus(projectId: string, status: CommentStatus): Promise<Comment[]> {
+    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 as Comment[]) || [];
+  }
+
+  async findReplies(parentId: string): Promise<Comment[]> {
+    const result = await this.dynamoDb.query({
+      TableName: this.tableName,
+      IndexName: 'parentId-createdAt-index',
+      KeyConditionExpression: 'parentId = :parentId',
+      ExpressionAttributeValues: {
+        ':parentId': parentId,
+      },
+    });
+    return (result.Items as Comment[]) || [];
+  }
+
+  async findByUserId(userId: string): Promise<Comment[]> {
+    const result = await this.dynamoDb.query({
+      TableName: this.tableName,
+      IndexName: 'userId-createdAt-index',
+      KeyConditionExpression: 'userId = :userId',
+      ScanIndexForward: false,
+      ExpressionAttributeValues: {
+        ':userId': userId,
+      },
+    });
+    return (result.Items as Comment[]) || [];
+  }
+
+  async markAsResolved(commentId: string): Promise<void> {
+    await this.dynamoDb.update({
+      TableName: this.tableName,
+      Key: { id: commentId },
+      UpdateExpression: 'SET #status = :status, updatedAt = :updatedAt',
+      ExpressionAttributeNames: {
+        '#status': 'status',
+      },
+      ExpressionAttributeValues: {
+        ':status': CommentStatus.RESOLVED,
+        ':updatedAt': new Date().toISOString(),
+      },
+    });
+  }
+}
+```