clhq-postgres-module 1.1.0-alpha.100

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

@@ -0,0 +1,12 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { AiUsage } from '../entities/ai-usage.entity';
+export declare class AiUsageRepository extends BaseRepository<AiUsage> {
+    constructor(repository: Repository<AiUsage>);
+    findByUserId(userId: string): Promise<AiUsage[]>;
+    findByProjectId(projectId: string): Promise<AiUsage[]>;
+    getTotalUsage(userId: string, startDate: Date, endDate: Date): Promise<{
+        totalTokens: number;
+        totalCost: number;
+    }>;
+}

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

@@ -0,0 +1,56 @@
+"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.AiUsageRepository = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const base_repository_1 = require("./base.repository");
+const ai_usage_entity_1 = require("../entities/ai-usage.entity");
+let AiUsageRepository = class AiUsageRepository extends base_repository_1.BaseRepository {
+    constructor(repository) {
+        super(repository);
+    }
+    async findByUserId(userId) {
+        return this.repository.find({
+            where: { userId },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async findByProjectId(projectId) {
+        return this.repository.find({
+            where: { projectId },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async getTotalUsage(userId, startDate, endDate) {
+        const result = await this.repository
+            .createQueryBuilder('ai_usage')
+            .select('SUM(ai_usage.tokens_used)', 'totalTokens')
+            .addSelect('SUM(ai_usage.cost_cents)', 'totalCost')
+            .where('ai_usage.user_id = :userId', { userId })
+            .andWhere('ai_usage.created_at BETWEEN :startDate AND :endDate', { startDate, endDate })
+            .getRawOne();
+        return {
+            totalTokens: parseInt(result.totalTokens || '0'),
+            totalCost: parseInt(result.totalCost || '0'),
+        };
+    }
+};
+exports.AiUsageRepository = AiUsageRepository;
+exports.AiUsageRepository = AiUsageRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(ai_usage_entity_1.AiUsage)),
+    __metadata("design:paramtypes", [typeorm_2.Repository])
+], AiUsageRepository);

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

@@ -0,0 +1,22 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { Asset } from '../entities/asset.entity';
+export declare class AssetRepository extends BaseRepository<Asset> {
+    private readonly assetRepository;
+    constructor(assetRepository: Repository<Asset>);
+    findByWorkspace(workspaceId: string): Promise<Asset[]>;
+    findByFileType(workspaceId: string, fileType: string): Promise<Asset[]>;
+    findByUser(userId: string): Promise<Asset[]>;
+    findByUniqueId(uniqueId: string): Promise<Asset | null>;
+    searchByName(workspaceId: string, searchTerm: string): Promise<Asset[]>;
+    findByUploadedBy(userId: string): Promise<Asset[]>;
+    findByWorkspaceId(workspaceId: string): Promise<Asset[]>;
+    findByUploadStatus(uploadStatus: string): Promise<Asset[]>;
+    updateUploadStatus(id: string, uploadStatus: string): Promise<Asset | null>;
+    bulkUpdateUploadStatus(ids: string[], uploadStatus: string): Promise<void>;
+    updateMetadata(id: string, metadata: Record<string, any>): Promise<Asset | null>;
+    updateProcessingMetadata(uniqueId: string, processingData: Record<string, any>): Promise<Asset | null>;
+    getAll(): Promise<Asset[]>;
+    findByUserOrLegacy(userId: string): Promise<Asset[]>;
+    incrementUsageCount(id: string): Promise<void>;
+}

package/dist/repositories/asset.repository.js

@@ -0,0 +1,128 @@
+"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.AssetRepository = 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_entity_1 = require("../entities/asset.entity");
+let AssetRepository = class AssetRepository extends base_repository_1.BaseRepository {
+    constructor(assetRepository) {
+        super(assetRepository);
+        this.assetRepository = assetRepository;
+    }
+    async findByWorkspace(workspaceId) {
+        return this.assetRepository.find({
+            where: { workspaceId },
+            order: { createdAt: 'DESC' }
+        });
+    }
+    async findByFileType(workspaceId, fileType) {
+        return this.assetRepository.find({
+            where: {
+                workspaceId,
+                fileType,
+            },
+            order: { createdAt: 'DESC' }
+        });
+    }
+    async findByUser(userId) {
+        return this.assetRepository.find({
+            where: { uploadedBy: userId },
+            order: { createdAt: 'DESC' }
+        });
+    }
+    async findByUniqueId(uniqueId) {
+        return this.assetRepository.findOne({
+            where: { uniqueId },
+        });
+    }
+    async searchByName(workspaceId, searchTerm) {
+        return this.assetRepository
+            .createQueryBuilder('asset')
+            .where('asset.workspaceId = :workspaceId', { workspaceId })
+            .andWhere('asset.name ILIKE :searchTerm', { searchTerm: `%${searchTerm}%` })
+            .orderBy('asset.createdAt', 'DESC')
+            .getMany();
+    }
+    async findByUploadedBy(userId) {
+        return this.findByUser(userId);
+    }
+    async findByWorkspaceId(workspaceId) {
+        return this.findByWorkspace(workspaceId);
+    }
+    async findByUploadStatus(uploadStatus) {
+        return this.assetRepository.find({
+            where: { uploadStatus },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async updateUploadStatus(id, uploadStatus) {
+        await this.assetRepository.update(id, { uploadStatus });
+        return this.findById(id);
+    }
+    async bulkUpdateUploadStatus(ids, uploadStatus) {
+        await this.assetRepository.update({ id: (0, typeorm_1.In)(ids) }, { uploadStatus });
+    }
+    async updateMetadata(id, metadata) {
+        await this.assetRepository.update(id, { metadata });
+        return this.findById(id);
+    }
+    async updateProcessingMetadata(uniqueId, processingData) {
+        const asset = await this.findByUniqueId(uniqueId);
+        if (!asset)
+            return null;
+        const existingMetadata = asset.metadata || {};
+        const updatedMetadata = {
+            ...existingMetadata,
+            processing: {
+                ...existingMetadata.processing,
+                ...processingData,
+            },
+        };
+        await this.assetRepository.update(asset.id, { metadata: updatedMetadata });
+        return this.findById(asset.id);
+    }
+    async getAll() {
+        return this.assetRepository.find({
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async findByUserOrLegacy(userId) {
+        return this.assetRepository
+            .createQueryBuilder('asset')
+            .where('asset.uploadedBy = :userId', { userId })
+            .orWhere("asset.metadata->>'user' = :userId", { userId })
+            .orderBy('asset.createdAt', 'DESC')
+            .getMany();
+    }
+    async incrementUsageCount(id) {
+        await this.assetRepository
+            .createQueryBuilder()
+            .update()
+            .set({
+            usageCount: () => 'usage_count + 1',
+            lastUsedAt: new Date(),
+        })
+            .where('id = :id', { id })
+            .execute();
+    }
+};
+exports.AssetRepository = AssetRepository;
+exports.AssetRepository = AssetRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(asset_entity_1.Asset)),
+    __metadata("design:paramtypes", [typeorm_1.Repository])
+], AssetRepository);

package/dist/repositories/audio-waveform.repository.d.ts

@@ -0,0 +1,24 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { AudioWaveform, AudioWaveformStatus, AudioWaveformData } from '../entities/audio-waveform.entity';
+export declare class AudioWaveformRepository extends BaseRepository<AudioWaveform> {
+    private readonly audioWaveformRepository;
+    constructor(audioWaveformRepository: Repository<AudioWaveform>);
+    findByProjectId(projectId: string): Promise<AudioWaveform[]>;
+    findByStatus(status: AudioWaveformStatus): Promise<AudioWaveform[]>;
+    findByAudioS3Key(audioS3Key: string): Promise<AudioWaveform | null>;
+    updateWaveform(id: string, data: {
+        status?: AudioWaveformStatus;
+        audioS3Key?: string;
+        data?: AudioWaveformData;
+        queueStatus?: string;
+    }): Promise<AudioWaveform | null>;
+    createWithId(data: {
+        id: string;
+        projectId?: string;
+        audioS3Key?: string;
+        status?: AudioWaveformStatus;
+        data?: AudioWaveformData;
+        queueStatus?: string;
+    }): Promise<AudioWaveform>;
+}

package/dist/repositories/audio-waveform.repository.js

@@ -0,0 +1,57 @@
+"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.AudioWaveformRepository = 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 audio_waveform_entity_1 = require("../entities/audio-waveform.entity");
+let AudioWaveformRepository = class AudioWaveformRepository extends base_repository_1.BaseRepository {
+    constructor(audioWaveformRepository) {
+        super(audioWaveformRepository);
+        this.audioWaveformRepository = audioWaveformRepository;
+    }
+    async findByProjectId(projectId) {
+        return this.audioWaveformRepository.find({
+            where: { projectId },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async findByStatus(status) {
+        return this.audioWaveformRepository.find({
+            where: { status },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async findByAudioS3Key(audioS3Key) {
+        return this.audioWaveformRepository.findOne({
+            where: { audioS3Key },
+        });
+    }
+    async updateWaveform(id, data) {
+        await this.audioWaveformRepository.update(id, data);
+        return this.findById(id);
+    }
+    async createWithId(data) {
+        const entity = this.audioWaveformRepository.create(data);
+        return this.audioWaveformRepository.save(entity);
+    }
+};
+exports.AudioWaveformRepository = AudioWaveformRepository;
+exports.AudioWaveformRepository = AudioWaveformRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(audio_waveform_entity_1.AudioWaveform)),
+    __metadata("design:paramtypes", [typeorm_1.Repository])
+], AudioWaveformRepository);

package/dist/repositories/auth-session.repository.d.ts

@@ -0,0 +1,10 @@
+import { Repository } from 'typeorm';
+import { AuthSession } from '../entities/auth-session.entity';
+import { BaseRepository } from './base.repository';
+export declare class AuthSessionRepository extends BaseRepository<AuthSession> {
+    private readonly sessionRepository;
+    constructor(sessionRepository: Repository<AuthSession>);
+    findByToken(token: string): Promise<AuthSession | null>;
+    findActiveByUserId(userId: string): Promise<AuthSession[]>;
+    invalidateSession(id: string): Promise<void>;
+}

package/dist/repositories/auth-session.repository.js

@@ -0,0 +1,46 @@
+"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.AuthSessionRepository = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const auth_session_entity_1 = require("../entities/auth-session.entity");
+const base_repository_1 = require("./base.repository");
+let AuthSessionRepository = class AuthSessionRepository extends base_repository_1.BaseRepository {
+    constructor(sessionRepository) {
+        super(sessionRepository);
+        this.sessionRepository = sessionRepository;
+    }
+    async findByToken(token) {
+        return this.sessionRepository.findOne({
+            where: { token, isActive: true },
+        });
+    }
+    async findActiveByUserId(userId) {
+        return this.sessionRepository.find({
+            where: { userId, isActive: true },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async invalidateSession(id) {
+        await this.sessionRepository.update(id, { isActive: false });
+    }
+};
+exports.AuthSessionRepository = AuthSessionRepository;
+exports.AuthSessionRepository = AuthSessionRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(auth_session_entity_1.AuthSession)),
+    __metadata("design:paramtypes", [typeorm_2.Repository])
+], AuthSessionRepository);

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

@@ -0,0 +1,18 @@
+import { Repository, FindOptionsWhere, FindManyOptions, DeepPartial } from 'typeorm';
+export declare abstract class BaseRepository<T> {
+    protected repository: Repository<T>;
+    constructor(repository: Repository<T>);
+    findById(id: string): Promise<T | null>;
+    findAll(options?: FindManyOptions<T>): Promise<T[]>;
+    findOne(where: FindOptionsWhere<T>): Promise<T | null>;
+    findBy(where: FindOptionsWhere<T>): Promise<T[]>;
+    create(data: DeepPartial<T>): Promise<T>;
+    update(id: string, data: DeepPartial<T>): Promise<T | null>;
+    delete(id: string): Promise<boolean>;
+    softDelete(id: string): Promise<boolean>;
+    count(where?: FindOptionsWhere<T>): Promise<number>;
+    exists(where: FindOptionsWhere<T>): Promise<boolean>;
+    save(entity: DeepPartial<T>): Promise<T>;
+    saveMany(entities: DeepPartial<T>[]): Promise<T[]>;
+    query(sql: string, parameters?: any[]): Promise<any>;
+}

package/dist/repositories/base.repository.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseRepository = void 0;
+class BaseRepository {
+    constructor(repository) {
+        this.repository = repository;
+    }
+    async findById(id) {
+        return this.repository.findOne({ where: { id } });
+    }
+    async findAll(options) {
+        return this.repository.find(options);
+    }
+    async findOne(where) {
+        return this.repository.findOne({ where });
+    }
+    async findBy(where) {
+        return this.repository.findBy(where);
+    }
+    async create(data) {
+        const entity = this.repository.create(data);
+        return this.repository.save(entity);
+    }
+    async update(id, data) {
+        await this.repository.update(id, data);
+        return this.findById(id);
+    }
+    async delete(id) {
+        const result = await this.repository.delete(id);
+        return (result.affected ?? 0) > 0;
+    }
+    async softDelete(id) {
+        const result = await this.repository.softDelete(id);
+        return (result.affected ?? 0) > 0;
+    }
+    async count(where) {
+        return this.repository.count({ where });
+    }
+    async exists(where) {
+        const count = await this.repository.count({ where });
+        return count > 0;
+    }
+    async save(entity) {
+        return this.repository.save(entity);
+    }
+    async saveMany(entities) {
+        return this.repository.save(entities);
+    }
+    async query(sql, parameters) {
+        return this.repository.query(sql, parameters);
+    }
+}
+exports.BaseRepository = BaseRepository;

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

@@ -0,0 +1,14 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { Comment } from '../entities/comment.entity';
+export declare class CommentRepository extends BaseRepository<Comment> {
+    private readonly commentRepository;
+    constructor(commentRepository: Repository<Comment>);
+    findByProject(projectId: string): Promise<Comment[]>;
+    findByProjectPaginated(projectId: string, page?: number, limit?: number): Promise<Comment[]>;
+    findReplies(parentId: string): Promise<Comment[]>;
+    toggleResolved(commentId: string): Promise<void>;
+    deleteComment(commentId: string): Promise<void>;
+    findByUserId(userId: string): Promise<Comment[]>;
+    findByUser(userId: string): Promise<Comment[]>;
+}

package/dist/repositories/comment.repository.js

@@ -0,0 +1,76 @@
+"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.CommentRepository = 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 comment_entity_1 = require("../entities/comment.entity");
+let CommentRepository = class CommentRepository extends base_repository_1.BaseRepository {
+    constructor(commentRepository) {
+        super(commentRepository);
+        this.commentRepository = commentRepository;
+    }
+    async findByProject(projectId) {
+        return this.commentRepository.find({
+            where: { projectId },
+            relations: ['user'],
+            order: { createdAt: 'DESC' }
+        });
+    }
+    async findByProjectPaginated(projectId, page = 1, limit = 20) {
+        return this.commentRepository.find({
+            where: {
+                projectId,
+            },
+            relations: ['user'],
+            order: { createdAt: 'DESC' },
+            skip: (page - 1) * limit,
+            take: limit,
+        });
+    }
+    async findReplies(parentId) {
+        return this.commentRepository.find({
+            where: { parentId },
+            relations: ['user'],
+            order: { createdAt: 'ASC' }
+        });
+    }
+    async toggleResolved(commentId) {
+        const comment = await this.commentRepository.findOne({ where: { id: commentId } });
+        if (comment) {
+            comment.isResolved = !comment.isResolved;
+            await this.commentRepository.save(comment);
+        }
+    }
+    async deleteComment(commentId) {
+        await this.commentRepository.delete(commentId);
+    }
+    async findByUserId(userId) {
+        return this.commentRepository.find({
+            where: { userId },
+            order: { createdAt: 'DESC' }
+        });
+    }
+    async findByUser(userId) {
+        return this.findByUserId(userId);
+    }
+};
+exports.CommentRepository = CommentRepository;
+exports.CommentRepository = CommentRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(comment_entity_1.Comment)),
+    __metadata("design:paramtypes", [typeorm_1.Repository])
+], CommentRepository);

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

@@ -0,0 +1,9 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { CreditTransaction } from '../entities/credit-transaction.entity';
+export declare class CreditTransactionRepository extends BaseRepository<CreditTransaction> {
+    constructor(repository: Repository<CreditTransaction>);
+    findByUserId(userId: string): Promise<CreditTransaction[]>;
+    findByType(type: string): Promise<CreditTransaction[]>;
+    getUserBalance(userId: string): Promise<number>;
+}

package/dist/repositories/credit-transaction.repository.js

@@ -0,0 +1,49 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreditTransactionRepository = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const base_repository_1 = require("./base.repository");
+const credit_transaction_entity_1 = require("../entities/credit-transaction.entity");
+let CreditTransactionRepository = class CreditTransactionRepository extends base_repository_1.BaseRepository {
+    constructor(repository) {
+        super(repository);
+    }
+    async findByUserId(userId) {
+        return this.repository.find({
+            where: { userId },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async findByType(type) {
+        return this.repository.find({
+            where: { type },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async getUserBalance(userId) {
+        const transactions = await this.findByUserId(userId);
+        return transactions.reduce((sum, t) => {
+            return t.type === 'usage' ? sum - Number(t.amount) : sum + Number(t.amount);
+        }, 0);
+    }
+};
+exports.CreditTransactionRepository = CreditTransactionRepository;
+exports.CreditTransactionRepository = CreditTransactionRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(credit_transaction_entity_1.CreditTransaction)),
+    __metadata("design:paramtypes", [typeorm_2.Repository])
+], CreditTransactionRepository);

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

@@ -0,0 +1,31 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { EditorProject, ProjectStatus } from '../entities/editor-project.entity';
+export declare class EditorProjectRepository extends BaseRepository<EditorProject> {
+    private readonly projectRepository;
+    constructor(projectRepository: Repository<EditorProject>);
+    findByWorkspace(workspaceId: string): Promise<EditorProject[]>;
+    findByOwner(ownerId: string): Promise<EditorProject[]>;
+    findByStatus(workspaceId: string, status: ProjectStatus): Promise<EditorProject[]>;
+    findRecent(ownerId: string, limit?: number): Promise<EditorProject[]>;
+    findFavorites(ownerId: string): Promise<EditorProject[]>;
+    findTemplates(): Promise<EditorProject[]>;
+    findPremiumTemplates(): Promise<EditorProject[]>;
+    updateLastOpened(projectId: string): Promise<void>;
+    toggleFavorite(projectId: string): Promise<void>;
+    incrementTemplateUsage(projectId: string): Promise<void>;
+    findByTemplateCategory(category: string): Promise<EditorProject[]>;
+    findByTag(tag: string): Promise<EditorProject[]>;
+    getAllTagsByOwner(ownerId: string): Promise<string[]>;
+    findByVisibility(visibility: string): Promise<EditorProject[]>;
+    findByCollaboratorId(collaboratorId: string): Promise<EditorProject[]>;
+    findByTitle(title: string): Promise<EditorProject[]>;
+    updateThumbnailUrl(projectId: string, thumbnailUrl: string): Promise<void>;
+    duplicateProject(projectId: string, newTitle?: string): Promise<EditorProject>;
+    countByOwner(ownerId: string): Promise<number>;
+    findByOwnerId(ownerId: string): Promise<EditorProject[]>;
+    findByUserAndWorkspace(ownerId: string, workspaceId: string): Promise<EditorProject[]>;
+    findByWorkspaceId(workspaceId: string): Promise<EditorProject[]>;
+    findRecentlyOpened(ownerId: string, limit?: number): Promise<EditorProject[]>;
+    findByGlobalStatus(status: ProjectStatus): Promise<EditorProject[]>;
+}