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

package/dist/entities/index.d.ts

@@ -31,3 +31,5 @@ export * from './project-metadata.entity';
 export * from './user-context.entity';
 export * from './ai-embedding.entity';
 export * from './metadata-activity-log.entity';
+export * from './project-scene-job.entity';
+export * from './project-scene.entity';

package/dist/entities/index.js

@@ -49,3 +49,5 @@ __exportStar(require("./project-metadata.entity"), exports);
 __exportStar(require("./user-context.entity"), exports);
 __exportStar(require("./ai-embedding.entity"), exports);
 __exportStar(require("./metadata-activity-log.entity"), exports);
+__exportStar(require("./project-scene-job.entity"), exports);
+__exportStar(require("./project-scene.entity"), exports);

package/dist/entities/project-scene-job.entity.d.ts

@@ -0,0 +1,38 @@
+import { User } from './user.entity';
+export declare enum ProjectSceneJobStatus {
+    NEW = "NEW",
+    PROCESSING = "PROCESSING",
+    SUCCESS = "SUCCESS",
+    ERROR = "ERROR"
+}
+export declare class ProjectSceneJob {
+    id: string;
+    projectId: string;
+    userId: string;
+    user: User;
+    workspaceId: string;
+    status: ProjectSceneJobStatus;
+    totalScenes: number;
+    completedScenes: number;
+    failedScenes: number;
+    intervalSeconds: number;
+    durationMs: number;
+    data: {
+        scenes?: Array<{
+            timestamp: number;
+            url: string;
+            s3Key: string;
+            size: number;
+        }>;
+        errors?: Array<{
+            timestamp: number;
+            error: string;
+        }>;
+        processingTimeMs?: number;
+    };
+    errorMessage: string;
+    startedAt: Date;
+    completedAt: Date;
+    createdAt: Date;
+    updatedAt: Date;
+}

package/dist/entities/project-scene-job.entity.js

@@ -0,0 +1,103 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectSceneJob = exports.ProjectSceneJobStatus = void 0;
+const typeorm_1 = require("typeorm");
+const user_entity_1 = require("./user.entity");
+var ProjectSceneJobStatus;
+(function (ProjectSceneJobStatus) {
+    ProjectSceneJobStatus["NEW"] = "NEW";
+    ProjectSceneJobStatus["PROCESSING"] = "PROCESSING";
+    ProjectSceneJobStatus["SUCCESS"] = "SUCCESS";
+    ProjectSceneJobStatus["ERROR"] = "ERROR";
+})(ProjectSceneJobStatus || (exports.ProjectSceneJobStatus = ProjectSceneJobStatus = {}));
+let ProjectSceneJob = class ProjectSceneJob {
+};
+exports.ProjectSceneJob = ProjectSceneJob;
+__decorate([
+    (0, typeorm_1.PrimaryColumn)({ type: 'varchar', length: 255 }),
+    __metadata("design:type", String)
+], ProjectSceneJob.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'project_id', type: 'varchar', length: 255 }),
+    __metadata("design:type", String)
+], ProjectSceneJob.prototype, "projectId", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'user_id', type: 'uuid' }),
+    __metadata("design:type", String)
+], ProjectSceneJob.prototype, "userId", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => user_entity_1.User),
+    (0, typeorm_1.JoinColumn)({ name: 'user_id' }),
+    __metadata("design:type", user_entity_1.User)
+], ProjectSceneJob.prototype, "user", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'workspace_id', type: 'uuid', nullable: true }),
+    __metadata("design:type", String)
+], ProjectSceneJob.prototype, "workspaceId", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'enum',
+        enum: ProjectSceneJobStatus,
+        default: ProjectSceneJobStatus.NEW,
+    }),
+    __metadata("design:type", String)
+], ProjectSceneJob.prototype, "status", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'total_scenes', type: 'integer', default: 0 }),
+    __metadata("design:type", Number)
+], ProjectSceneJob.prototype, "totalScenes", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'completed_scenes', type: 'integer', default: 0 }),
+    __metadata("design:type", Number)
+], ProjectSceneJob.prototype, "completedScenes", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'failed_scenes', type: 'integer', default: 0 }),
+    __metadata("design:type", Number)
+], ProjectSceneJob.prototype, "failedScenes", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'interval_seconds', type: 'integer', default: 5 }),
+    __metadata("design:type", Number)
+], ProjectSceneJob.prototype, "intervalSeconds", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'duration_ms', type: 'integer', nullable: true }),
+    __metadata("design:type", Number)
+], ProjectSceneJob.prototype, "durationMs", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'jsonb', nullable: true }),
+    __metadata("design:type", Object)
+], ProjectSceneJob.prototype, "data", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'error_message', type: 'text', nullable: true }),
+    __metadata("design:type", String)
+], ProjectSceneJob.prototype, "errorMessage", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'started_at', type: 'timestamp', nullable: true }),
+    __metadata("design:type", Date)
+], ProjectSceneJob.prototype, "startedAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'completed_at', type: 'timestamp', nullable: true }),
+    __metadata("design:type", Date)
+], ProjectSceneJob.prototype, "completedAt", void 0);
+__decorate([
+    (0, typeorm_1.CreateDateColumn)({ name: 'created_at' }),
+    __metadata("design:type", Date)
+], ProjectSceneJob.prototype, "createdAt", void 0);
+__decorate([
+    (0, typeorm_1.UpdateDateColumn)({ name: 'updated_at' }),
+    __metadata("design:type", Date)
+], ProjectSceneJob.prototype, "updatedAt", void 0);
+exports.ProjectSceneJob = ProjectSceneJob = __decorate([
+    (0, typeorm_1.Entity)('project_scene_jobs'),
+    (0, typeorm_1.Index)(['projectId']),
+    (0, typeorm_1.Index)(['userId']),
+    (0, typeorm_1.Index)(['status'])
+], ProjectSceneJob);

package/dist/entities/project-scene.entity.d.ts

@@ -0,0 +1,27 @@
+export declare enum ProjectSceneStatus {
+    PENDING = "PENDING",
+    GENERATING = "GENERATING",
+    READY = "READY",
+    FAILED = "FAILED"
+}
+export declare class ProjectScene {
+    id: string;
+    projectId: string;
+    jobId: string;
+    timestamp: number;
+    status: ProjectSceneStatus;
+    s3Url: string;
+    s3Key: string;
+    fileSize: number;
+    width: number;
+    height: number;
+    generationTimeMs: number;
+    errorMessage: string;
+    metadata: {
+        layerCount?: number;
+        itemTypes?: string[];
+        editlySpec?: any;
+    };
+    createdAt: Date;
+    updatedAt: Date;
+}

package/dist/entities/project-scene.entity.js

@@ -0,0 +1,93 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectScene = exports.ProjectSceneStatus = void 0;
+const typeorm_1 = require("typeorm");
+var ProjectSceneStatus;
+(function (ProjectSceneStatus) {
+    ProjectSceneStatus["PENDING"] = "PENDING";
+    ProjectSceneStatus["GENERATING"] = "GENERATING";
+    ProjectSceneStatus["READY"] = "READY";
+    ProjectSceneStatus["FAILED"] = "FAILED";
+})(ProjectSceneStatus || (exports.ProjectSceneStatus = ProjectSceneStatus = {}));
+let ProjectScene = class ProjectScene {
+};
+exports.ProjectScene = ProjectScene;
+__decorate([
+    (0, typeorm_1.PrimaryGeneratedColumn)('uuid'),
+    __metadata("design:type", String)
+], ProjectScene.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'project_id', type: 'varchar', length: 255 }),
+    __metadata("design:type", String)
+], ProjectScene.prototype, "projectId", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'job_id', type: 'varchar', length: 255, nullable: true }),
+    __metadata("design:type", String)
+], ProjectScene.prototype, "jobId", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'float' }),
+    __metadata("design:type", Number)
+], ProjectScene.prototype, "timestamp", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'enum',
+        enum: ProjectSceneStatus,
+        default: ProjectSceneStatus.PENDING,
+    }),
+    __metadata("design:type", String)
+], ProjectScene.prototype, "status", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 's3_url', type: 'text', nullable: true }),
+    __metadata("design:type", String)
+], ProjectScene.prototype, "s3Url", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 's3_key', type: 'text', nullable: true }),
+    __metadata("design:type", String)
+], ProjectScene.prototype, "s3Key", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'file_size', type: 'integer', nullable: true }),
+    __metadata("design:type", Number)
+], ProjectScene.prototype, "fileSize", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'integer', nullable: true }),
+    __metadata("design:type", Number)
+], ProjectScene.prototype, "width", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'integer', nullable: true }),
+    __metadata("design:type", Number)
+], ProjectScene.prototype, "height", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'generation_time_ms', type: 'integer', nullable: true }),
+    __metadata("design:type", Number)
+], ProjectScene.prototype, "generationTimeMs", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: 'error_message', type: 'text', nullable: true }),
+    __metadata("design:type", String)
+], ProjectScene.prototype, "errorMessage", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'jsonb', nullable: true }),
+    __metadata("design:type", Object)
+], ProjectScene.prototype, "metadata", void 0);
+__decorate([
+    (0, typeorm_1.CreateDateColumn)({ name: 'created_at' }),
+    __metadata("design:type", Date)
+], ProjectScene.prototype, "createdAt", void 0);
+__decorate([
+    (0, typeorm_1.UpdateDateColumn)({ name: 'updated_at' }),
+    __metadata("design:type", Date)
+], ProjectScene.prototype, "updatedAt", void 0);
+exports.ProjectScene = ProjectScene = __decorate([
+    (0, typeorm_1.Entity)('project_scenes'),
+    (0, typeorm_1.Index)(['projectId']),
+    (0, typeorm_1.Index)(['projectId', 'timestamp']),
+    (0, typeorm_1.Unique)(['projectId', 'timestamp'])
+], ProjectScene);

package/dist/repositories/ai-embedding.repository.d.ts

@@ -0,0 +1,38 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { AiEmbedding, EmbeddingEntityType, EmbeddingType } from '../entities/ai-embedding.entity';
+export declare class AiEmbeddingRepository extends BaseRepository<AiEmbedding> {
+    private readonly aiEmbeddingRepository;
+    constructor(aiEmbeddingRepository: Repository<AiEmbedding>);
+    findByEntity(entityType: EmbeddingEntityType, entityId: string): Promise<AiEmbedding | null>;
+    findByEntityType(entityType: EmbeddingEntityType, userId?: string): Promise<AiEmbedding[]>;
+    findByUserId(userId: string): Promise<AiEmbedding[]>;
+    findByWorkspaceId(workspaceId: string): Promise<AiEmbedding[]>;
+    upsertEmbedding(data: {
+        entityType: EmbeddingEntityType;
+        entityId: string;
+        userId?: string;
+        workspaceId?: string;
+        embeddingType?: EmbeddingType;
+        embedding: number[];
+        sourceText?: string;
+        modelId: string;
+        modelVersion?: string;
+        metadata?: AiEmbedding['metadata'];
+    }): Promise<AiEmbedding>;
+    deleteByEntity(entityType: EmbeddingEntityType, entityId: string): Promise<boolean>;
+    findSimilar(embedding: number[], entityType: EmbeddingEntityType, userId?: string, limit?: number, excludeEntityId?: string): Promise<Array<AiEmbedding & {
+        similarity: number;
+    }>>;
+    batchFindSimilar(queries: Array<{
+        embedding: number[];
+        entityType: EmbeddingEntityType;
+        userId?: string;
+        limit?: number;
+    }>): Promise<Array<Array<AiEmbedding & {
+        similarity: number;
+    }>>>;
+    getCountsByEntityType(userId?: string): Promise<Record<string, number>>;
+    findByModelVersion(modelId: string, modelVersion?: string): Promise<AiEmbedding[]>;
+    findOutdatedEmbeddings(modelId: string, currentVersion: string, limit?: number): Promise<AiEmbedding[]>;
+}

package/dist/repositories/ai-embedding.repository.js

@@ -0,0 +1,146 @@
+"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.AiEmbeddingRepository = 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 ai_embedding_entity_1 = require("../entities/ai-embedding.entity");
+let AiEmbeddingRepository = class AiEmbeddingRepository extends base_repository_1.BaseRepository {
+    constructor(aiEmbeddingRepository) {
+        super(aiEmbeddingRepository);
+        this.aiEmbeddingRepository = aiEmbeddingRepository;
+    }
+    async findByEntity(entityType, entityId) {
+        return this.aiEmbeddingRepository.findOne({
+            where: { entityType, entityId },
+        });
+    }
+    async findByEntityType(entityType, userId) {
+        const where = { entityType };
+        if (userId) {
+            where.userId = userId;
+        }
+        return this.aiEmbeddingRepository.find({
+            where,
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async findByUserId(userId) {
+        return this.aiEmbeddingRepository.find({
+            where: { userId },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async findByWorkspaceId(workspaceId) {
+        return this.aiEmbeddingRepository.find({
+            where: { workspaceId },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async upsertEmbedding(data) {
+        const existing = await this.findByEntity(data.entityType, data.entityId);
+        if (existing) {
+            await this.aiEmbeddingRepository.update(existing.id, {
+                embedding: data.embedding,
+                embeddingType: data.embeddingType || existing.embeddingType,
+                dimension: data.embedding.length,
+                sourceText: data.sourceText,
+                modelId: data.modelId,
+                modelVersion: data.modelVersion,
+                metadata: data.metadata,
+            });
+            return (await this.findById(existing.id));
+        }
+        return this.create({
+            ...data,
+            dimension: data.embedding.length,
+        });
+    }
+    async deleteByEntity(entityType, entityId) {
+        const result = await this.aiEmbeddingRepository.delete({
+            entityType,
+            entityId,
+        });
+        return (result.affected ?? 0) > 0;
+    }
+    async findSimilar(embedding, entityType, userId, limit = 20, excludeEntityId) {
+        const embeddingStr = JSON.stringify(embedding);
+        const dimension = embedding.length;
+        let query = this.aiEmbeddingRepository
+            .createQueryBuilder('ae')
+            .select('ae.*')
+            .addSelect(`1 - (ae.embedding::vector(${dimension}) <=> '${embeddingStr}'::vector(${dimension}))`, 'similarity')
+            .where('ae.entity_type = :entityType', { entityType })
+            .andWhere('ae.dimension = :dimension', { dimension });
+        if (userId) {
+            query = query.andWhere('ae.user_id = :userId', { userId });
+        }
+        if (excludeEntityId) {
+            query = query.andWhere('ae.entity_id != :excludeEntityId', {
+                excludeEntityId,
+            });
+        }
+        const results = await query
+            .orderBy('similarity', 'DESC')
+            .limit(limit)
+            .getRawMany();
+        return results;
+    }
+    async batchFindSimilar(queries) {
+        const results = await Promise.all(queries.map((query) => this.findSimilar(query.embedding, query.entityType, query.userId, query.limit || 10)));
+        return results;
+    }
+    async getCountsByEntityType(userId) {
+        const queryBuilder = this.aiEmbeddingRepository
+            .createQueryBuilder('ae')
+            .select('ae.entity_type', 'entityType')
+            .addSelect('COUNT(*)', 'count')
+            .groupBy('ae.entity_type');
+        if (userId) {
+            queryBuilder.where('ae.user_id = :userId', { userId });
+        }
+        const results = await queryBuilder.getRawMany();
+        return results.reduce((acc, row) => {
+            acc[row.entityType] = parseInt(row.count, 10);
+            return acc;
+        }, {});
+    }
+    async findByModelVersion(modelId, modelVersion) {
+        const where = { modelId };
+        if (modelVersion) {
+            where.modelVersion = modelVersion;
+        }
+        return this.aiEmbeddingRepository.find({
+            where,
+            order: { createdAt: 'ASC' },
+        });
+    }
+    async findOutdatedEmbeddings(modelId, currentVersion, limit = 100) {
+        return this.aiEmbeddingRepository
+            .createQueryBuilder('ae')
+            .where('ae.model_id = :modelId', { modelId })
+            .andWhere('(ae.model_version IS NULL OR ae.model_version != :currentVersion)', { currentVersion })
+            .orderBy('ae.created_at', 'ASC')
+            .limit(limit)
+            .getMany();
+    }
+};
+exports.AiEmbeddingRepository = AiEmbeddingRepository;
+exports.AiEmbeddingRepository = AiEmbeddingRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(ai_embedding_entity_1.AiEmbedding)),
+    __metadata("design:paramtypes", [typeorm_1.Repository])
+], AiEmbeddingRepository);

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

@@ -0,0 +1,39 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { AssetMetadata, AssetMetadataStatus } from '../entities/asset-metadata.entity';
+export declare class AssetMetadataRepository extends BaseRepository<AssetMetadata> {
+    private readonly assetMetadataRepository;
+    constructor(assetMetadataRepository: Repository<AssetMetadata>);
+    findByAssetId(assetId: string): Promise<AssetMetadata | null>;
+    findByUserId(userId: string): Promise<AssetMetadata[]>;
+    findByWorkspaceId(workspaceId: string): Promise<AssetMetadata[]>;
+    findByStatus(status: AssetMetadataStatus): Promise<AssetMetadata[]>;
+    findPendingForProcessing(limit?: number): Promise<AssetMetadata[]>;
+    updateStatus(id: string, status: AssetMetadataStatus, error?: string): Promise<AssetMetadata | null>;
+    updateEmbedding(id: string, embedding: number[], model: string, version?: string): Promise<AssetMetadata | null>;
+    updateContent(id: string, content: AssetMetadata['content']): Promise<AssetMetadata | null>;
+    updateTechnical(id: string, technical: AssetMetadata['technical']): Promise<AssetMetadata | null>;
+    findSimilarByEmbedding(embedding: number[], userId: string, limit?: number, excludeAssetId?: string, minSimilarity?: number): Promise<Array<AssetMetadata & {
+        similarity: number;
+    }>>;
+    findSimilarByEmbeddingOptimized(embedding: number[], userId: string, limit?: number, minSimilarity?: number): Promise<Array<{
+        assetId: string;
+        similarity: number;
+        category: string;
+        tags: string[];
+        description: string;
+        usageCount: number;
+        lastUsedAt: Date;
+    }>>;
+    findByTags(userId: string, tags: string[]): Promise<AssetMetadata[]>;
+    searchByKeywords(userId: string, searchTerm: string): Promise<AssetMetadata[]>;
+    incrementUsageCount(assetId: string, projectId?: string): Promise<void>;
+    findWithoutEmbeddings(limit?: number): Promise<AssetMetadata[]>;
+    getStatsForUser(userId: string): Promise<{
+        total: number;
+        pending: number;
+        completed: number;
+        failed: number;
+        withEmbeddings: number;
+    }>;
+}