clhq-postgres-module 1.1.0-alpha.105 → 1.1.0-alpha.107

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

@@ -0,0 +1,186 @@
+"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.ProjectMetadataRepository = 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 project_metadata_entity_1 = require("../entities/project-metadata.entity");
+let ProjectMetadataRepository = class ProjectMetadataRepository extends base_repository_1.BaseRepository {
+    constructor(projectMetadataRepository) {
+        super(projectMetadataRepository);
+        this.projectMetadataRepository = projectMetadataRepository;
+    }
+    async findByProjectId(projectId) {
+        return this.projectMetadataRepository.findOne({
+            where: { projectId },
+        });
+    }
+    async findByUserId(userId) {
+        return this.projectMetadataRepository.find({
+            where: { userId },
+            order: { updatedAt: 'DESC' },
+        });
+    }
+    async findByWorkspaceId(workspaceId) {
+        return this.projectMetadataRepository.find({
+            where: { workspaceId },
+            order: { updatedAt: 'DESC' },
+        });
+    }
+    async findByProjectType(userId, projectType) {
+        return this.projectMetadataRepository.find({
+            where: { userId, projectType },
+            order: { updatedAt: 'DESC' },
+        });
+    }
+    async updateComposition(projectId, composition) {
+        await this.projectMetadataRepository.update({ projectId }, { composition });
+        return this.findByProjectId(projectId);
+    }
+    async updateStyleFingerprint(projectId, styleFingerprint) {
+        await this.projectMetadataRepository.update({ projectId }, { styleFingerprint });
+        return this.findByProjectId(projectId);
+    }
+    async updateEmbedding(projectId, embedding) {
+        await this.projectMetadataRepository.update({ projectId }, {
+            projectEmbedding: embedding,
+            embeddingGeneratedAt: new Date(),
+        });
+        return this.findByProjectId(projectId);
+    }
+    async recordEditSession(projectId, sessionDurationMs) {
+        await this.projectMetadataRepository
+            .createQueryBuilder()
+            .update()
+            .set({
+            editSessionsCount: () => 'edit_sessions_count + 1',
+            totalEditTimeMs: () => `total_edit_time_ms + ${sessionDurationMs}`,
+        })
+            .where('project_id = :projectId', { projectId })
+            .execute();
+    }
+    async addAssetUsed(projectId, assetId) {
+        const metadata = await this.findByProjectId(projectId);
+        if (!metadata)
+            return;
+        const assetsUsed = metadata.assetsUsed || [];
+        if (!assetsUsed.includes(assetId)) {
+            assetsUsed.push(assetId);
+            await this.projectMetadataRepository.update({ projectId }, { assetsUsed });
+        }
+    }
+    async incrementEffectUsage(projectId, effectName) {
+        const metadata = await this.findByProjectId(projectId);
+        if (!metadata)
+            return;
+        const effectsUsed = metadata.effectsUsed || {};
+        effectsUsed[effectName] = (effectsUsed[effectName] || 0) + 1;
+        await this.projectMetadataRepository.update({ projectId }, { effectsUsed });
+    }
+    async addExportToHistory(projectId, exportData) {
+        const metadata = await this.findByProjectId(projectId);
+        if (!metadata)
+            return;
+        const exportHistory = metadata.exportHistory || [];
+        exportHistory.push({
+            ...exportData,
+            exportedAt: new Date().toISOString(),
+        });
+        await this.projectMetadataRepository.update({ projectId }, { exportHistory });
+    }
+    async recordAiSuggestion(projectId, suggestionType, accepted) {
+        const metadata = await this.findByProjectId(projectId);
+        if (!metadata)
+            return;
+        const aiSuggestionsApplied = metadata.aiSuggestionsApplied || [];
+        aiSuggestionsApplied.push({
+            suggestionType,
+            appliedAt: new Date().toISOString(),
+            accepted,
+        });
+        await this.projectMetadataRepository.update({ projectId }, { aiSuggestionsApplied });
+    }
+    async findSimilarByEmbedding(embedding, userId, limit = 10, excludeProjectId) {
+        const embeddingStr = JSON.stringify(embedding);
+        let query = this.projectMetadataRepository
+            .createQueryBuilder('pm')
+            .select('pm.*')
+            .addSelect(`1 - (pm.project_embedding::vector(1536) <=> '${embeddingStr}'::vector(1536))`, 'similarity')
+            .where('pm.user_id = :userId', { userId })
+            .andWhere('pm.project_embedding IS NOT NULL');
+        if (excludeProjectId) {
+            query = query.andWhere('pm.project_id != :excludeProjectId', {
+                excludeProjectId,
+            });
+        }
+        const results = await query
+            .orderBy('similarity', 'DESC')
+            .limit(limit)
+            .getRawMany();
+        return results;
+    }
+    async getStylePreferencesForUser(userId) {
+        const projects = await this.projectMetadataRepository.find({
+            where: { userId },
+            select: ['styleFingerprint', 'effectsUsed'],
+        });
+        const transitions = {};
+        const effects = {};
+        let totalClipDuration = 0;
+        let clipDurationCount = 0;
+        const pacingCounts = {};
+        for (const project of projects) {
+            if (project.styleFingerprint?.transitions) {
+                for (const t of project.styleFingerprint.transitions) {
+                    transitions[t] = (transitions[t] || 0) + 1;
+                }
+            }
+            if (project.effectsUsed) {
+                for (const [effect, count] of Object.entries(project.effectsUsed)) {
+                    effects[effect] = (effects[effect] || 0) + count;
+                }
+            }
+            if (project.styleFingerprint?.avgClipDuration) {
+                totalClipDuration += project.styleFingerprint.avgClipDuration;
+                clipDurationCount++;
+            }
+            if (project.styleFingerprint?.pacing) {
+                pacingCounts[project.styleFingerprint.pacing] =
+                    (pacingCounts[project.styleFingerprint.pacing] || 0) + 1;
+            }
+        }
+        let preferredPacing = 'medium';
+        let maxPacingCount = 0;
+        for (const [pacing, count] of Object.entries(pacingCounts)) {
+            if (count > maxPacingCount) {
+                maxPacingCount = count;
+                preferredPacing = pacing;
+            }
+        }
+        return {
+            topTransitions: transitions,
+            topEffects: effects,
+            avgClipDuration: clipDurationCount > 0 ? totalClipDuration / clipDurationCount : 0,
+            preferredPacing,
+        };
+    }
+};
+exports.ProjectMetadataRepository = ProjectMetadataRepository;
+exports.ProjectMetadataRepository = ProjectMetadataRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(project_metadata_entity_1.ProjectMetadata)),
+    __metadata("design:paramtypes", [typeorm_1.Repository])
+], ProjectMetadataRepository);

package/dist/repositories/repository.module.js

@@ -37,6 +37,11 @@ const repositories = [
     _1.VideoRenderRepository,
     _1.VideoFilmstripRepository,
     _1.AudioWaveformRepository,
+    _1.AssetMetadataRepository,
+    _1.ProjectMetadataRepository,
+    _1.UserContextRepository,
+    _1.AiEmbeddingRepository,
+    _1.MetadataActivityLogRepository,
 ];
 const entities = [
     entities_1.User,
@@ -64,6 +69,11 @@ const entities = [
     entities_1.VideoRender,
     entities_1.VideoFilmstrip,
     entities_1.AudioWaveform,
+    entities_1.AssetMetadata,
+    entities_1.ProjectMetadata,
+    entities_1.UserContext,
+    entities_1.AiEmbedding,
+    entities_1.MetadataActivityLog,
 ];
 let RepositoryModule = class RepositoryModule {
 };

package/dist/repositories/user-context.repository.d.ts

@@ -0,0 +1,66 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { UserContext } from '../entities/user-context.entity';
+export declare class UserContextRepository extends BaseRepository<UserContext> {
+    private readonly userContextRepository;
+    constructor(userContextRepository: Repository<UserContext>);
+    findByUserId(userId: string): Promise<UserContext | null>;
+    getOrCreate(userId: string): Promise<UserContext>;
+    updateStylePreferences(userId: string, preferences: {
+        preferredStyles?: string[];
+        preferredGenres?: string[];
+        preferredTransitions?: string[];
+        preferredEffects?: string[];
+        preferredFonts?: string[];
+    }): Promise<UserContext | null>;
+    updateDefaultSettings(userId: string, settings: {
+        defaultAspectRatio?: string;
+        defaultResolution?: string;
+        defaultFps?: number;
+    }): Promise<UserContext | null>;
+    updateBrandAssets(userId: string, brandAssets: {
+        brandColors?: UserContext['brandColors'];
+        brandFonts?: UserContext['brandFonts'];
+        brandLogoAssetIds?: string[];
+        brandWatermarkAssetId?: string;
+    }): Promise<UserContext | null>;
+    updateBehavioralAnalytics(userId: string, analytics: {
+        avgProjectDurationMs?: number;
+        avgSessionLengthMs?: number;
+        mostUsedEffects?: Record<string, number>;
+        mostUsedTransitions?: Record<string, number>;
+        editingPatterns?: UserContext['editingPatterns'];
+        skillLevel?: UserContext['skillLevel'];
+        activityHeatmap?: UserContext['activityHeatmap'];
+    }): Promise<UserContext | null>;
+    incrementProjectCount(userId: string, completed?: boolean): Promise<void>;
+    addEditTime(userId: string, durationMs: number): Promise<void>;
+    recordAiInteraction(userId: string, accepted: boolean): Promise<void>;
+    addRecentPrompt(userId: string, prompt: string, successful: boolean): Promise<void>;
+    updateEmbedding(userId: string, embedding: number[]): Promise<UserContext | null>;
+    markAggregated(userId: string): Promise<void>;
+    findNeedingAggregation(limit?: number): Promise<UserContext[]>;
+    getAiContext(userId: string): Promise<{
+        preferences: {
+            styles: string[];
+            genres: string[];
+            transitions: string[];
+            effects: string[];
+        };
+        defaults: {
+            aspectRatio: string;
+            resolution: string;
+            fps: number;
+        };
+        analytics: {
+            totalProjects: number;
+            avgProjectDuration: number;
+            skillLevel: string;
+            preferredPacing: string;
+        };
+        brand: {
+            colors: UserContext['brandColors'];
+            fonts: UserContext['brandFonts'];
+        };
+    } | null>;
+}

package/dist/repositories/user-context.repository.js

@@ -0,0 +1,161 @@
+"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.UserContextRepository = 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 user_context_entity_1 = require("../entities/user-context.entity");
+let UserContextRepository = class UserContextRepository extends base_repository_1.BaseRepository {
+    constructor(userContextRepository) {
+        super(userContextRepository);
+        this.userContextRepository = userContextRepository;
+    }
+    async findByUserId(userId) {
+        return this.userContextRepository.findOne({
+            where: { userId },
+        });
+    }
+    async getOrCreate(userId) {
+        let context = await this.findByUserId(userId);
+        if (!context) {
+            context = await this.create({ userId });
+        }
+        return context;
+    }
+    async updateStylePreferences(userId, preferences) {
+        await this.userContextRepository.update({ userId }, preferences);
+        return this.findByUserId(userId);
+    }
+    async updateDefaultSettings(userId, settings) {
+        await this.userContextRepository.update({ userId }, settings);
+        return this.findByUserId(userId);
+    }
+    async updateBrandAssets(userId, brandAssets) {
+        await this.userContextRepository.update({ userId }, brandAssets);
+        return this.findByUserId(userId);
+    }
+    async updateBehavioralAnalytics(userId, analytics) {
+        await this.userContextRepository.update({ userId }, analytics);
+        return this.findByUserId(userId);
+    }
+    async incrementProjectCount(userId, completed = false) {
+        const updates = {
+            totalProjectsCount: () => 'total_projects_count + 1',
+        };
+        if (completed) {
+            updates.completedProjectsCount = () => 'completed_projects_count + 1';
+        }
+        await this.userContextRepository
+            .createQueryBuilder()
+            .update()
+            .set(updates)
+            .where('user_id = :userId', { userId })
+            .execute();
+    }
+    async addEditTime(userId, durationMs) {
+        await this.userContextRepository
+            .createQueryBuilder()
+            .update()
+            .set({
+            totalEditTimeMs: () => `total_edit_time_ms + ${durationMs}`,
+        })
+            .where('user_id = :userId', { userId })
+            .execute();
+    }
+    async recordAiInteraction(userId, accepted) {
+        const updates = {
+            aiPromptsCount: () => 'ai_prompts_count + 1',
+        };
+        if (accepted) {
+            updates.aiSuggestionsAccepted = () => 'ai_suggestions_accepted + 1';
+        }
+        else {
+            updates.aiSuggestionsRejected = () => 'ai_suggestions_rejected + 1';
+        }
+        await this.userContextRepository
+            .createQueryBuilder()
+            .update()
+            .set(updates)
+            .where('user_id = :userId', { userId })
+            .execute();
+    }
+    async addRecentPrompt(userId, prompt, successful) {
+        const context = await this.findByUserId(userId);
+        if (!context)
+            return;
+        const recentPrompts = context.recentPrompts || [];
+        recentPrompts.unshift({
+            prompt,
+            timestamp: new Date().toISOString(),
+            successful,
+        });
+        const trimmedPrompts = recentPrompts.slice(0, 20);
+        await this.userContextRepository.update({ userId }, { recentPrompts: trimmedPrompts });
+    }
+    async updateEmbedding(userId, embedding) {
+        await this.userContextRepository.update({ userId }, {
+            userEmbedding: embedding,
+            embeddingGeneratedAt: new Date(),
+        });
+        return this.findByUserId(userId);
+    }
+    async markAggregated(userId) {
+        await this.userContextRepository.update({ userId }, { lastAggregatedAt: new Date() });
+    }
+    async findNeedingAggregation(limit = 100) {
+        const oneDayAgo = new Date(Date.now() - 24 * 60 * 60 * 1000);
+        return this.userContextRepository
+            .createQueryBuilder('uc')
+            .where('(uc.last_aggregated_at IS NULL OR uc.last_aggregated_at < :oneDayAgo)', { oneDayAgo })
+            .orderBy('uc.last_aggregated_at', 'ASC', 'NULLS FIRST')
+            .limit(limit)
+            .getMany();
+    }
+    async getAiContext(userId) {
+        const context = await this.findByUserId(userId);
+        if (!context)
+            return null;
+        return {
+            preferences: {
+                styles: context.preferredStyles || [],
+                genres: context.preferredGenres || [],
+                transitions: context.preferredTransitions || [],
+                effects: context.preferredEffects || [],
+            },
+            defaults: {
+                aspectRatio: context.defaultAspectRatio || '16:9',
+                resolution: context.defaultResolution || '1080p',
+                fps: context.defaultFps || 30,
+            },
+            analytics: {
+                totalProjects: context.totalProjectsCount || 0,
+                avgProjectDuration: context.avgProjectDurationMs || 0,
+                skillLevel: context.skillLevel || 'beginner',
+                preferredPacing: context.editingPatterns?.preferredPacing || 'medium',
+            },
+            brand: {
+                colors: context.brandColors,
+                fonts: context.brandFonts,
+            },
+        };
+    }
+};
+exports.UserContextRepository = UserContextRepository;
+exports.UserContextRepository = UserContextRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(user_context_entity_1.UserContext)),
+    __metadata("design:paramtypes", [typeorm_1.Repository])
+], UserContextRepository);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clhq-postgres-module",
-  "version": "1.1.0-alpha.105",
+  "version": "1.1.0-alpha.107",
   "description": "PostgreSQL module using TypeORM for Clippy",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -38,6 +38,9 @@
     "db:migrate:016": "npx ts-node scripts/run-migrations.ts 016",
     "db:migrate:017": "npx ts-node scripts/run-migrations.ts 017",
     "db:migrate:018": "npx ts-node scripts/run-migrations.ts 018",
+    "db:migrate:019": "npx ts-node scripts/run-migrations.ts 019",
+    "db:migrate:020": "npx ts-node scripts/run-migrations.ts 020",
+    "db:migrate:metadata": "npx ts-node scripts/run-migrations.ts 019 && npx ts-node scripts/run-migrations.ts 020",
     "db:verify": "env-cmd -f ../../.env.dev  npx ts-node scripts/verify-tables.ts",
     "db:test": "env-cmd -f ../../.env.dev  npx ts-node scripts/test-connections.ts",
     "db:sync": "env-cmd -f ../../.env.dev  npm run typeorm schema:sync -- -d src/config/data-source.ts",