clhq-postgres-module 1.1.0-alpha.106 → 1.1.0-alpha.108

package/dist/repositories/asset-metadata.repository.js

@@ -0,0 +1,195 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetMetadataRepository = void 0;
+const typeorm_1 = require("typeorm");
+const common_1 = require("@nestjs/common");
+const typeorm_2 = require("@nestjs/typeorm");
+const base_repository_1 = require("./base.repository");
+const asset_metadata_entity_1 = require("../entities/asset-metadata.entity");
+let AssetMetadataRepository = class AssetMetadataRepository extends base_repository_1.BaseRepository {
+    constructor(assetMetadataRepository) {
+        super(assetMetadataRepository);
+        this.assetMetadataRepository = assetMetadataRepository;
+    }
+    async findByAssetId(assetId) {
+        return this.assetMetadataRepository.findOne({
+            where: { assetId },
+        });
+    }
+    async findByUserId(userId) {
+        return this.assetMetadataRepository.find({
+            where: { userId },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async findByWorkspaceId(workspaceId) {
+        return this.assetMetadataRepository.find({
+            where: { workspaceId },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async findByStatus(status) {
+        return this.assetMetadataRepository.find({
+            where: { status },
+            order: { createdAt: 'ASC' },
+        });
+    }
+    async findPendingForProcessing(limit = 50) {
+        return this.assetMetadataRepository.find({
+            where: { status: asset_metadata_entity_1.AssetMetadataStatus.PENDING },
+            order: { createdAt: 'ASC' },
+            take: limit,
+        });
+    }
+    async updateStatus(id, status, error) {
+        const updateData = { status };
+        if (error) {
+            updateData.processingError = error;
+        }
+        if (status === asset_metadata_entity_1.AssetMetadataStatus.COMPLETED) {
+            updateData.aiProcessedAt = new Date();
+        }
+        await this.assetMetadataRepository.update(id, updateData);
+        return this.findById(id);
+    }
+    async updateEmbedding(id, embedding, model, version) {
+        await this.assetMetadataRepository.update(id, {
+            contentEmbedding: embedding,
+            embeddingModel: model,
+            embeddingVersion: version,
+            embeddingGeneratedAt: new Date(),
+        });
+        return this.findById(id);
+    }
+    async updateContent(id, content) {
+        await this.assetMetadataRepository.update(id, {
+            content,
+            aiProcessedAt: new Date(),
+        });
+        return this.findById(id);
+    }
+    async updateTechnical(id, technical) {
+        await this.assetMetadataRepository.update(id, { technical });
+        return this.findById(id);
+    }
+    async findSimilarByEmbedding(embedding, userId, limit = 20, excludeAssetId, minSimilarity = 0.0) {
+        const embeddingStr = `[${embedding.join(',')}]`;
+        let query = this.assetMetadataRepository
+            .createQueryBuilder('am')
+            .select('am.*')
+            .addSelect(`1 - (COALESCE(am.content_embedding_vec, am.content_embedding::vector(1536)) <=> '${embeddingStr}'::vector(1536))`, 'similarity')
+            .where('am.user_id = :userId', { userId })
+            .andWhere('(am.content_embedding_vec IS NOT NULL OR am.content_embedding IS NOT NULL)');
+        if (excludeAssetId) {
+            query = query.andWhere('am.asset_id != :excludeAssetId', { excludeAssetId });
+        }
+        if (minSimilarity > 0) {
+            query = query.andWhere(`1 - (COALESCE(am.content_embedding_vec, am.content_embedding::vector(1536)) <=> '${embeddingStr}'::vector(1536)) >= :minSimilarity`, { minSimilarity });
+        }
+        const results = await query
+            .orderBy(`COALESCE(am.content_embedding_vec, am.content_embedding::vector(1536)) <=> '${embeddingStr}'::vector(1536)`, 'ASC')
+            .limit(limit)
+            .getRawMany();
+        return results;
+    }
+    async findSimilarByEmbeddingOptimized(embedding, userId, limit = 20, minSimilarity = 0.5) {
+        const embeddingStr = `[${embedding.join(',')}]`;
+        const results = await this.assetMetadataRepository.query(`SELECT * FROM search_similar_assets_optimized($1::vector(1536), $2, $3, $4)`, [embeddingStr, userId, limit, minSimilarity]);
+        return results.map((r) => ({
+            assetId: r.asset_id,
+            similarity: r.similarity,
+            category: r.category,
+            tags: r.tags,
+            description: r.description,
+            usageCount: r.usage_count,
+            lastUsedAt: r.last_used_at,
+        }));
+    }
+    async findByTags(userId, tags) {
+        return this.assetMetadataRepository
+            .createQueryBuilder('am')
+            .where('am.user_id = :userId', { userId })
+            .andWhere('am.tags && :tags', { tags })
+            .orderBy('am.created_at', 'DESC')
+            .getMany();
+    }
+    async searchByKeywords(userId, searchTerm) {
+        return this.assetMetadataRepository
+            .createQueryBuilder('am')
+            .where('am.user_id = :userId', { userId })
+            .andWhere(`(
+          am.description ILIKE :term
+          OR am.category ILIKE :term
+          OR :term = ANY(am.tags)
+          OR am.content->>'transcription' ILIKE :term
+          OR am.content->'keywords' ? :exactTerm
+        )`, { term: `%${searchTerm}%`, exactTerm: searchTerm })
+            .orderBy('am.created_at', 'DESC')
+            .getMany();
+    }
+    async incrementUsageCount(assetId, projectId) {
+        const metadata = await this.findByAssetId(assetId);
+        if (!metadata)
+            return;
+        const projectsUsedIn = metadata.projectsUsedIn || [];
+        if (projectId && !projectsUsedIn.includes(projectId)) {
+            projectsUsedIn.push(projectId);
+        }
+        await this.assetMetadataRepository
+            .createQueryBuilder()
+            .update()
+            .set({
+            usageCount: () => 'usage_count + 1',
+            lastUsedAt: new Date(),
+            projectsUsedIn,
+        })
+            .where('asset_id = :assetId', { assetId })
+            .execute();
+    }
+    async findWithoutEmbeddings(limit = 100) {
+        return this.assetMetadataRepository.find({
+            where: {
+                contentEmbedding: null,
+                status: asset_metadata_entity_1.AssetMetadataStatus.COMPLETED,
+            },
+            order: { createdAt: 'ASC' },
+            take: limit,
+        });
+    }
+    async getStatsForUser(userId) {
+        const stats = await this.assetMetadataRepository
+            .createQueryBuilder('am')
+            .select('COUNT(*)', 'total')
+            .addSelect(`COUNT(*) FILTER (WHERE am.status = 'pending')`, 'pending')
+            .addSelect(`COUNT(*) FILTER (WHERE am.status = 'completed')`, 'completed')
+            .addSelect(`COUNT(*) FILTER (WHERE am.status = 'failed')`, 'failed')
+            .addSelect(`COUNT(*) FILTER (WHERE am.content_embedding IS NOT NULL)`, 'withEmbeddings')
+            .where('am.user_id = :userId', { userId })
+            .getRawOne();
+        return {
+            total: parseInt(stats.total, 10),
+            pending: parseInt(stats.pending, 10),
+            completed: parseInt(stats.completed, 10),
+            failed: parseInt(stats.failed, 10),
+            withEmbeddings: parseInt(stats.withEmbeddings, 10),
+        };
+    }
+};
+exports.AssetMetadataRepository = AssetMetadataRepository;
+exports.AssetMetadataRepository = AssetMetadataRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(asset_metadata_entity_1.AssetMetadata)),
+    __metadata("design:paramtypes", [typeorm_1.Repository])
+], AssetMetadataRepository);

package/dist/repositories/index.d.ts

@@ -24,3 +24,9 @@ export { VideoTranscodeRepository } from './video-transcode.repository';
 export { VideoRenderRepository } from './video-render.repository';
 export { VideoFilmstripRepository } from './video-filmstrip.repository';
 export { AudioWaveformRepository } from './audio-waveform.repository';
+export { AssetMetadataRepository } from './asset-metadata.repository';
+export { ProjectMetadataRepository } from './project-metadata.repository';
+export { UserContextRepository } from './user-context.repository';
+export { AiEmbeddingRepository } from './ai-embedding.repository';
+export { MetadataActivityLogRepository } from './metadata-activity-log.repository';
+export { ProjectSceneRepository } from './project-scene.repository';

package/dist/repositories/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AudioWaveformRepository = exports.VideoFilmstripRepository = exports.VideoRenderRepository = exports.VideoTranscodeRepository = exports.EffectRepository = exports.AssetRepository = exports.AiUsageRepository = exports.ReferralEventRepository = exports.RewardRuleRepository = exports.CreditTransactionRepository = exports.StripeWebhookRepository = exports.PaymentTransactionRepository = exports.SubscriptionUsageRepository = exports.UserSubscriptionRepository = exports.PlanRepository = exports.SubscriptionPlanRepository = exports.CommentRepository = exports.EditorProjectRepository = exports.InviteRepository = exports.WorkspaceMemberRepository = exports.WorkspaceRepository = exports.AuthSessionRepository = exports.UserOnboardingRepository = exports.UserProfileRepository = exports.UserRepository = exports.BaseRepository = void 0;
+exports.ProjectSceneRepository = exports.MetadataActivityLogRepository = exports.AiEmbeddingRepository = exports.UserContextRepository = exports.ProjectMetadataRepository = exports.AssetMetadataRepository = exports.AudioWaveformRepository = exports.VideoFilmstripRepository = exports.VideoRenderRepository = exports.VideoTranscodeRepository = exports.EffectRepository = exports.AssetRepository = exports.AiUsageRepository = exports.ReferralEventRepository = exports.RewardRuleRepository = exports.CreditTransactionRepository = exports.StripeWebhookRepository = exports.PaymentTransactionRepository = exports.SubscriptionUsageRepository = exports.UserSubscriptionRepository = exports.PlanRepository = exports.SubscriptionPlanRepository = exports.CommentRepository = exports.EditorProjectRepository = exports.InviteRepository = exports.WorkspaceMemberRepository = exports.WorkspaceRepository = exports.AuthSessionRepository = exports.UserOnboardingRepository = exports.UserProfileRepository = exports.UserRepository = exports.BaseRepository = void 0;
 var base_repository_1 = require("./base.repository");
 Object.defineProperty(exports, "BaseRepository", { enumerable: true, get: function () { return base_repository_1.BaseRepository; } });
 var user_repository_1 = require("./user.repository");
@@ -53,3 +53,15 @@ var video_filmstrip_repository_1 = require("./video-filmstrip.repository");
 Object.defineProperty(exports, "VideoFilmstripRepository", { enumerable: true, get: function () { return video_filmstrip_repository_1.VideoFilmstripRepository; } });
 var audio_waveform_repository_1 = require("./audio-waveform.repository");
 Object.defineProperty(exports, "AudioWaveformRepository", { enumerable: true, get: function () { return audio_waveform_repository_1.AudioWaveformRepository; } });
+var asset_metadata_repository_1 = require("./asset-metadata.repository");
+Object.defineProperty(exports, "AssetMetadataRepository", { enumerable: true, get: function () { return asset_metadata_repository_1.AssetMetadataRepository; } });
+var project_metadata_repository_1 = require("./project-metadata.repository");
+Object.defineProperty(exports, "ProjectMetadataRepository", { enumerable: true, get: function () { return project_metadata_repository_1.ProjectMetadataRepository; } });
+var user_context_repository_1 = require("./user-context.repository");
+Object.defineProperty(exports, "UserContextRepository", { enumerable: true, get: function () { return user_context_repository_1.UserContextRepository; } });
+var ai_embedding_repository_1 = require("./ai-embedding.repository");
+Object.defineProperty(exports, "AiEmbeddingRepository", { enumerable: true, get: function () { return ai_embedding_repository_1.AiEmbeddingRepository; } });
+var metadata_activity_log_repository_1 = require("./metadata-activity-log.repository");
+Object.defineProperty(exports, "MetadataActivityLogRepository", { enumerable: true, get: function () { return metadata_activity_log_repository_1.MetadataActivityLogRepository; } });
+var project_scene_repository_1 = require("./project-scene.repository");
+Object.defineProperty(exports, "ProjectSceneRepository", { enumerable: true, get: function () { return project_scene_repository_1.ProjectSceneRepository; } });

package/dist/repositories/metadata-activity-log.repository.d.ts

@@ -0,0 +1,41 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { MetadataActivityLog, MetadataActivityAction, MetadataActivitySource } from '../entities/metadata-activity-log.entity';
+export declare class MetadataActivityLogRepository extends BaseRepository<MetadataActivityLog> {
+    private readonly activityLogRepository;
+    constructor(activityLogRepository: Repository<MetadataActivityLog>);
+    logActivity(data: {
+        userId: string;
+        workspaceId?: string;
+        sessionId?: string;
+        entityType: string;
+        entityId: string;
+        action: MetadataActivityAction;
+        source?: MetadataActivitySource;
+        metadataBefore?: Record<string, any>;
+        metadataAfter?: Record<string, any>;
+        details?: Record<string, any>;
+        projectId?: string;
+        durationMs?: number;
+    }): Promise<MetadataActivityLog>;
+    findByUserId(userId: string, limit?: number): Promise<MetadataActivityLog[]>;
+    findByEntity(entityType: string, entityId: string, limit?: number): Promise<MetadataActivityLog[]>;
+    findByProjectId(projectId: string, limit?: number): Promise<MetadataActivityLog[]>;
+    findByAction(action: MetadataActivityAction, userId?: string, limit?: number): Promise<MetadataActivityLog[]>;
+    findByDateRange(userId: string, startDate: Date, endDate: Date): Promise<MetadataActivityLog[]>;
+    findRecentEditActions(userId: string, limit?: number): Promise<MetadataActivityLog[]>;
+    findAiInteractions(userId: string, limit?: number): Promise<MetadataActivityLog[]>;
+    getActionCounts(userId: string, startDate?: Date): Promise<Record<string, number>>;
+    getEffectUsageFromLogs(userId: string, startDate?: Date): Promise<Record<string, number>>;
+    getTransitionUsageFromLogs(userId: string, startDate?: Date): Promise<Record<string, number>>;
+    getActivityHeatmap(userId: string, days?: number): Promise<{
+        hourOfDay: Record<number, number>;
+        dayOfWeek: Record<number, number>;
+    }>;
+    cleanupOldLogs(retentionDays?: number): Promise<number>;
+    getSessionSummary(sessionId: string): Promise<{
+        actions: number;
+        duration: number;
+        actionBreakdown: Record<string, number>;
+    }>;
+}

package/dist/repositories/metadata-activity-log.repository.js

@@ -0,0 +1,220 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataActivityLogRepository = void 0;
+const typeorm_1 = require("typeorm");
+const common_1 = require("@nestjs/common");
+const typeorm_2 = require("@nestjs/typeorm");
+const base_repository_1 = require("./base.repository");
+const metadata_activity_log_entity_1 = require("../entities/metadata-activity-log.entity");
+let MetadataActivityLogRepository = class MetadataActivityLogRepository extends base_repository_1.BaseRepository {
+    constructor(activityLogRepository) {
+        super(activityLogRepository);
+        this.activityLogRepository = activityLogRepository;
+    }
+    async logActivity(data) {
+        return this.create({
+            ...data,
+            source: data.source || metadata_activity_log_entity_1.MetadataActivitySource.USER,
+        });
+    }
+    async findByUserId(userId, limit = 100) {
+        return this.activityLogRepository.find({
+            where: { userId },
+            order: { createdAt: 'DESC' },
+            take: limit,
+        });
+    }
+    async findByEntity(entityType, entityId, limit = 50) {
+        return this.activityLogRepository.find({
+            where: { entityType, entityId },
+            order: { createdAt: 'DESC' },
+            take: limit,
+        });
+    }
+    async findByProjectId(projectId, limit = 100) {
+        return this.activityLogRepository.find({
+            where: { projectId },
+            order: { createdAt: 'DESC' },
+            take: limit,
+        });
+    }
+    async findByAction(action, userId, limit = 100) {
+        const where = { action };
+        if (userId) {
+            where.userId = userId;
+        }
+        return this.activityLogRepository.find({
+            where,
+            order: { createdAt: 'DESC' },
+            take: limit,
+        });
+    }
+    async findByDateRange(userId, startDate, endDate) {
+        return this.activityLogRepository.find({
+            where: {
+                userId,
+                createdAt: (0, typeorm_1.Between)(startDate, endDate),
+            },
+            order: { createdAt: 'ASC' },
+        });
+    }
+    async findRecentEditActions(userId, limit = 500) {
+        const editActions = [
+            metadata_activity_log_entity_1.MetadataActivityAction.EDIT_CLIP_ADDED,
+            metadata_activity_log_entity_1.MetadataActivityAction.EDIT_TRANSITION_ADDED,
+            metadata_activity_log_entity_1.MetadataActivityAction.EDIT_EFFECT_ADDED,
+            metadata_activity_log_entity_1.MetadataActivityAction.EDIT_TEXT_ADDED,
+            metadata_activity_log_entity_1.MetadataActivityAction.EDIT_AUDIO_ADDED,
+            metadata_activity_log_entity_1.MetadataActivityAction.EDIT_TRIM,
+        ];
+        return this.activityLogRepository
+            .createQueryBuilder('al')
+            .where('al.user_id = :userId', { userId })
+            .andWhere('al.action IN (:...actions)', { actions: editActions })
+            .orderBy('al.created_at', 'DESC')
+            .limit(limit)
+            .getMany();
+    }
+    async findAiInteractions(userId, limit = 100) {
+        const aiActions = [
+            metadata_activity_log_entity_1.MetadataActivityAction.AI_CONTEXT_REQUESTED,
+            metadata_activity_log_entity_1.MetadataActivityAction.AI_SUGGESTION_ACCEPTED,
+            metadata_activity_log_entity_1.MetadataActivityAction.AI_SUGGESTION_REJECTED,
+            metadata_activity_log_entity_1.MetadataActivityAction.AI_CONTENT_GENERATED,
+        ];
+        return this.activityLogRepository
+            .createQueryBuilder('al')
+            .where('al.user_id = :userId', { userId })
+            .andWhere('al.action IN (:...actions)', { actions: aiActions })
+            .orderBy('al.created_at', 'DESC')
+            .limit(limit)
+            .getMany();
+    }
+    async getActionCounts(userId, startDate) {
+        let query = this.activityLogRepository
+            .createQueryBuilder('al')
+            .select('al.action', 'action')
+            .addSelect('COUNT(*)', 'count')
+            .where('al.user_id = :userId', { userId })
+            .groupBy('al.action');
+        if (startDate) {
+            query = query.andWhere('al.created_at >= :startDate', { startDate });
+        }
+        const results = await query.getRawMany();
+        return results.reduce((acc, row) => {
+            acc[row.action] = parseInt(row.count, 10);
+            return acc;
+        }, {});
+    }
+    async getEffectUsageFromLogs(userId, startDate) {
+        let query = this.activityLogRepository
+            .createQueryBuilder('al')
+            .where('al.user_id = :userId', { userId })
+            .andWhere('al.action = :action', {
+            action: metadata_activity_log_entity_1.MetadataActivityAction.EDIT_EFFECT_ADDED,
+        });
+        if (startDate) {
+            query = query.andWhere('al.created_at >= :startDate', { startDate });
+        }
+        const logs = await query.getMany();
+        const effectCounts = {};
+        for (const log of logs) {
+            const effectName = log.details?.effectName || log.details?.effect || 'unknown';
+            effectCounts[effectName] = (effectCounts[effectName] || 0) + 1;
+        }
+        return effectCounts;
+    }
+    async getTransitionUsageFromLogs(userId, startDate) {
+        let query = this.activityLogRepository
+            .createQueryBuilder('al')
+            .where('al.user_id = :userId', { userId })
+            .andWhere('al.action = :action', {
+            action: metadata_activity_log_entity_1.MetadataActivityAction.EDIT_TRANSITION_ADDED,
+        });
+        if (startDate) {
+            query = query.andWhere('al.created_at >= :startDate', { startDate });
+        }
+        const logs = await query.getMany();
+        const transitionCounts = {};
+        for (const log of logs) {
+            const transitionName = log.details?.transitionName || log.details?.transition || 'unknown';
+            transitionCounts[transitionName] =
+                (transitionCounts[transitionName] || 0) + 1;
+        }
+        return transitionCounts;
+    }
+    async getActivityHeatmap(userId, days = 30) {
+        const startDate = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+        const logs = await this.activityLogRepository.find({
+            where: {
+                userId,
+                createdAt: (0, typeorm_1.MoreThan)(startDate),
+            },
+            select: ['createdAt'],
+        });
+        const hourOfDay = {};
+        const dayOfWeek = {};
+        for (const log of logs) {
+            const date = new Date(log.createdAt);
+            const hour = date.getHours();
+            const day = date.getDay();
+            hourOfDay[hour] = (hourOfDay[hour] || 0) + 1;
+            dayOfWeek[day] = (dayOfWeek[day] || 0) + 1;
+        }
+        return { hourOfDay, dayOfWeek };
+    }
+    async cleanupOldLogs(retentionDays = 90) {
+        const cutoffDate = new Date(Date.now() - retentionDays * 24 * 60 * 60 * 1000);
+        const result = await this.activityLogRepository.delete({
+            createdAt: (0, typeorm_1.LessThan)(cutoffDate),
+        });
+        return result.affected ?? 0;
+    }
+    async getSessionSummary(sessionId) {
+        const logs = await this.activityLogRepository.find({
+            where: { sessionId },
+            order: { createdAt: 'ASC' },
+        });
+        if (logs.length === 0) {
+            return { actions: 0, duration: 0, actionBreakdown: {} };
+        }
+        const actionBreakdown = {};
+        let totalDuration = 0;
+        for (const log of logs) {
+            actionBreakdown[log.action] = (actionBreakdown[log.action] || 0) + 1;
+            if (log.durationMs) {
+                totalDuration += log.durationMs;
+            }
+        }
+        if (totalDuration === 0 && logs.length > 1) {
+            const firstLog = logs[0];
+            const lastLog = logs[logs.length - 1];
+            totalDuration =
+                new Date(lastLog.createdAt).getTime() -
+                    new Date(firstLog.createdAt).getTime();
+        }
+        return {
+            actions: logs.length,
+            duration: totalDuration,
+            actionBreakdown,
+        };
+    }
+};
+exports.MetadataActivityLogRepository = MetadataActivityLogRepository;
+exports.MetadataActivityLogRepository = MetadataActivityLogRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(metadata_activity_log_entity_1.MetadataActivityLog)),
+    __metadata("design:paramtypes", [typeorm_1.Repository])
+], MetadataActivityLogRepository);

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

@@ -0,0 +1,32 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { ProjectMetadata } from '../entities/project-metadata.entity';
+export declare class ProjectMetadataRepository extends BaseRepository<ProjectMetadata> {
+    private readonly projectMetadataRepository;
+    constructor(projectMetadataRepository: Repository<ProjectMetadata>);
+    findByProjectId(projectId: string): Promise<ProjectMetadata | null>;
+    findByUserId(userId: string): Promise<ProjectMetadata[]>;
+    findByWorkspaceId(workspaceId: string): Promise<ProjectMetadata[]>;
+    findByProjectType(userId: string, projectType: string): Promise<ProjectMetadata[]>;
+    updateComposition(projectId: string, composition: ProjectMetadata['composition']): Promise<ProjectMetadata | null>;
+    updateStyleFingerprint(projectId: string, styleFingerprint: ProjectMetadata['styleFingerprint']): Promise<ProjectMetadata | null>;
+    updateEmbedding(projectId: string, embedding: number[]): Promise<ProjectMetadata | null>;
+    recordEditSession(projectId: string, sessionDurationMs: number): Promise<void>;
+    addAssetUsed(projectId: string, assetId: string): Promise<void>;
+    incrementEffectUsage(projectId: string, effectName: string): Promise<void>;
+    addExportToHistory(projectId: string, exportData: {
+        format: string;
+        resolution: string;
+        fileSize?: number;
+    }): Promise<void>;
+    recordAiSuggestion(projectId: string, suggestionType: string, accepted: boolean): Promise<void>;
+    findSimilarByEmbedding(embedding: number[], userId: string, limit?: number, excludeProjectId?: string): Promise<Array<ProjectMetadata & {
+        similarity: number;
+    }>>;
+    getStylePreferencesForUser(userId: string): Promise<{
+        topTransitions: Record<string, number>;
+        topEffects: Record<string, number>;
+        avgClipDuration: number;
+        preferredPacing: string;
+    }>;
+}