clhq-postgres-module 1.1.0-alpha.90

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[]>;
+}

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

@@ -0,0 +1,193 @@
+"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.EditorProjectRepository = 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 editor_project_entity_1 = require("../entities/editor-project.entity");
+let EditorProjectRepository = class EditorProjectRepository extends base_repository_1.BaseRepository {
+    constructor(projectRepository) {
+        super(projectRepository);
+        this.projectRepository = projectRepository;
+    }
+    async findByWorkspace(workspaceId) {
+        return this.projectRepository.find({
+            where: { workspaceId },
+            order: { lastOpenedAt: 'DESC' }
+        });
+    }
+    async findByOwner(ownerId) {
+        return this.projectRepository.find({
+            where: { ownerId },
+            order: { lastOpenedAt: 'DESC' }
+        });
+    }
+    async findByStatus(workspaceId, status) {
+        return this.projectRepository.find({
+            where: {
+                workspaceId,
+                status,
+            },
+            order: { updatedAt: 'DESC' }
+        });
+    }
+    async findRecent(ownerId, limit = 10) {
+        return this.projectRepository.find({
+            where: {
+                ownerId,
+            },
+            order: { lastOpenedAt: 'DESC' },
+            take: limit,
+        });
+    }
+    async findFavorites(ownerId) {
+        return this.projectRepository.find({
+            where: { ownerId, isFavorite: true },
+            order: { lastOpenedAt: 'DESC' }
+        });
+    }
+    async findTemplates() {
+        return this.projectRepository.find({
+            where: { isTemplate: true },
+            order: { templateUsageCount: 'DESC' }
+        });
+    }
+    async findPremiumTemplates() {
+        return this.projectRepository.find({
+            where: {
+                isTemplate: true,
+                isPremiumTemplate: true,
+            },
+            order: { templateUsageCount: 'DESC' }
+        });
+    }
+    async updateLastOpened(projectId) {
+        await this.projectRepository.update(projectId, {
+            lastOpenedAt: new Date(),
+        });
+    }
+    async toggleFavorite(projectId) {
+        const project = await this.projectRepository.findOne({ where: { id: projectId } });
+        if (project) {
+            project.isFavorite = !project.isFavorite;
+            await this.projectRepository.save(project);
+        }
+    }
+    async incrementTemplateUsage(projectId) {
+        await this.projectRepository
+            .createQueryBuilder()
+            .update()
+            .set({ templateUsageCount: () => 'templateUsageCount + 1' })
+            .where('id = :projectId', { projectId })
+            .execute();
+    }
+    async findByTemplateCategory(category) {
+        return this.projectRepository.find({
+            where: {
+                isTemplate: true,
+                templateCategory: category,
+            },
+            order: { templateUsageCount: 'DESC' }
+        });
+    }
+    async findByTag(tag) {
+        return this.projectRepository
+            .createQueryBuilder('project')
+            .where(':tag = ANY(project.tags)', { tag })
+            .orderBy('project.updatedAt', 'DESC')
+            .getMany();
+    }
+    async getAllTagsByOwner(ownerId) {
+        const result = await this.projectRepository
+            .createQueryBuilder('project')
+            .select('DISTINCT unnest(project.tags)', 'tag')
+            .where('project.ownerId = :ownerId', { ownerId })
+            .getRawMany();
+        return result.map(r => r.tag).filter(Boolean);
+    }
+    async findByVisibility(visibility) {
+        return this.projectRepository.find({
+            where: { visibility: visibility },
+            order: { updatedAt: 'DESC' }
+        });
+    }
+    async findByCollaboratorId(collaboratorId) {
+        return this.projectRepository
+            .createQueryBuilder('project')
+            .where(':collaboratorId = ANY(project.collaboratorIds)', { collaboratorId })
+            .orderBy('project.updatedAt', 'DESC')
+            .getMany();
+    }
+    async findByTitle(title) {
+        return this.projectRepository
+            .createQueryBuilder('project')
+            .where('LOWER(project.title) LIKE LOWER(:title)', { title: `%${title}%` })
+            .orderBy('project.updatedAt', 'DESC')
+            .getMany();
+    }
+    async updateThumbnailUrl(projectId, thumbnailUrl) {
+        await this.projectRepository.update(projectId, {
+            thumbnailUrl,
+            updatedAt: new Date(),
+        });
+    }
+    async duplicateProject(projectId, newTitle) {
+        const original = await this.findById(projectId);
+        if (!original) {
+            throw new Error(`Project ${projectId} not found`);
+        }
+        const { id, createdAt, updatedAt, lastOpenedAt, ...projectData } = original;
+        const duplicate = this.projectRepository.create({
+            ...projectData,
+            title: newTitle || `${original.title} (Copy)`,
+            isFavorite: false,
+            templateUsageCount: 0,
+        });
+        return this.projectRepository.save(duplicate);
+    }
+    async countByOwner(ownerId) {
+        return this.projectRepository.count({
+            where: { ownerId }
+        });
+    }
+    async findByOwnerId(ownerId) {
+        return this.findByOwner(ownerId);
+    }
+    async findByUserAndWorkspace(ownerId, workspaceId) {
+        return this.projectRepository.find({
+            where: { ownerId, workspaceId },
+            order: { lastOpenedAt: 'DESC' }
+        });
+    }
+    async findByWorkspaceId(workspaceId) {
+        return this.findByWorkspace(workspaceId);
+    }
+    async findRecentlyOpened(ownerId, limit = 10) {
+        return this.findRecent(ownerId, limit);
+    }
+    async findByGlobalStatus(status) {
+        return this.projectRepository.find({
+            where: { status },
+            order: { updatedAt: 'DESC' }
+        });
+    }
+};
+exports.EditorProjectRepository = EditorProjectRepository;
+exports.EditorProjectRepository = EditorProjectRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(editor_project_entity_1.EditorProject)),
+    __metadata("design:paramtypes", [typeorm_1.Repository])
+], EditorProjectRepository);

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

@@ -0,0 +1,10 @@
+import { Repository } from 'typeorm';
+import { Effect, EffectType } from '../entities/effect.entity';
+import { BaseRepository } from './base.repository';
+export declare class EffectRepository extends BaseRepository<Effect> {
+    private readonly effectRepository;
+    constructor(effectRepository: Repository<Effect>);
+    findByType(effectType: EffectType): Promise<Effect[]>;
+    findActiveEffects(): Promise<Effect[]>;
+    incrementUsage(id: string): Promise<void>;
+}

package/dist/repositories/effect.repository.js

@@ -0,0 +1,47 @@
+"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.EffectRepository = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const effect_entity_1 = require("../entities/effect.entity");
+const base_repository_1 = require("./base.repository");
+let EffectRepository = class EffectRepository extends base_repository_1.BaseRepository {
+    constructor(effectRepository) {
+        super(effectRepository);
+        this.effectRepository = effectRepository;
+    }
+    async findByType(effectType) {
+        return this.effectRepository.find({
+            where: { effectType, isActive: true },
+            order: { usageCount: 'DESC' },
+        });
+    }
+    async findActiveEffects() {
+        return this.effectRepository.find({
+            where: { isActive: true },
+            order: { usageCount: 'DESC' },
+        });
+    }
+    async incrementUsage(id) {
+        await this.effectRepository.increment({ id }, 'usageCount', 1);
+    }
+};
+exports.EffectRepository = EffectRepository;
+exports.EffectRepository = EffectRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(effect_entity_1.Effect)),
+    __metadata("design:paramtypes", [typeorm_2.Repository])
+], EffectRepository);

package/dist/repositories/index.d.ts

@@ -0,0 +1,23 @@
+export { BaseRepository } from './base.repository';
+export { UserRepository } from './user.repository';
+export { UserProfileRepository } from './user-profile.repository';
+export { UserOnboardingRepository } from './user-onboarding.repository';
+export { AuthSessionRepository } from './auth-session.repository';
+export { WorkspaceRepository } from './workspace.repository';
+export { WorkspaceMemberRepository } from './workspace-member.repository';
+export { InviteRepository } from './invite.repository';
+export { EditorProjectRepository } from './editor-project.repository';
+export { CommentRepository } from './comment.repository';
+export { SubscriptionPlanRepository } from './subscription-plan.repository';
+export { PlanRepository } from './plan.repository';
+export { UserSubscriptionRepository } from './user-subscription.repository';
+export { SubscriptionUsageRepository } from './subscription-usage.repository';
+export { PaymentTransactionRepository } from './payment-transaction.repository';
+export { StripeWebhookRepository } from './stripe-webhook.repository';
+export { CreditTransactionRepository } from './credit-transaction.repository';
+export { RewardRuleRepository } from './reward-rule.repository';
+export { AiUsageRepository } from './ai-usage.repository';
+export { AssetRepository } from './asset.repository';
+export { EffectRepository } from './effect.repository';
+export { VideoTranscodeRepository } from './video-transcode.repository';
+export { VideoRenderRepository } from './video-render.repository';

package/dist/repositories/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VideoRenderRepository = exports.VideoTranscodeRepository = exports.EffectRepository = exports.AssetRepository = exports.AiUsageRepository = 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");
+Object.defineProperty(exports, "UserRepository", { enumerable: true, get: function () { return user_repository_1.UserRepository; } });
+var user_profile_repository_1 = require("./user-profile.repository");
+Object.defineProperty(exports, "UserProfileRepository", { enumerable: true, get: function () { return user_profile_repository_1.UserProfileRepository; } });
+var user_onboarding_repository_1 = require("./user-onboarding.repository");
+Object.defineProperty(exports, "UserOnboardingRepository", { enumerable: true, get: function () { return user_onboarding_repository_1.UserOnboardingRepository; } });
+var auth_session_repository_1 = require("./auth-session.repository");
+Object.defineProperty(exports, "AuthSessionRepository", { enumerable: true, get: function () { return auth_session_repository_1.AuthSessionRepository; } });
+var workspace_repository_1 = require("./workspace.repository");
+Object.defineProperty(exports, "WorkspaceRepository", { enumerable: true, get: function () { return workspace_repository_1.WorkspaceRepository; } });
+var workspace_member_repository_1 = require("./workspace-member.repository");
+Object.defineProperty(exports, "WorkspaceMemberRepository", { enumerable: true, get: function () { return workspace_member_repository_1.WorkspaceMemberRepository; } });
+var invite_repository_1 = require("./invite.repository");
+Object.defineProperty(exports, "InviteRepository", { enumerable: true, get: function () { return invite_repository_1.InviteRepository; } });
+var editor_project_repository_1 = require("./editor-project.repository");
+Object.defineProperty(exports, "EditorProjectRepository", { enumerable: true, get: function () { return editor_project_repository_1.EditorProjectRepository; } });
+var comment_repository_1 = require("./comment.repository");
+Object.defineProperty(exports, "CommentRepository", { enumerable: true, get: function () { return comment_repository_1.CommentRepository; } });
+var subscription_plan_repository_1 = require("./subscription-plan.repository");
+Object.defineProperty(exports, "SubscriptionPlanRepository", { enumerable: true, get: function () { return subscription_plan_repository_1.SubscriptionPlanRepository; } });
+var plan_repository_1 = require("./plan.repository");
+Object.defineProperty(exports, "PlanRepository", { enumerable: true, get: function () { return plan_repository_1.PlanRepository; } });
+var user_subscription_repository_1 = require("./user-subscription.repository");
+Object.defineProperty(exports, "UserSubscriptionRepository", { enumerable: true, get: function () { return user_subscription_repository_1.UserSubscriptionRepository; } });
+var subscription_usage_repository_1 = require("./subscription-usage.repository");
+Object.defineProperty(exports, "SubscriptionUsageRepository", { enumerable: true, get: function () { return subscription_usage_repository_1.SubscriptionUsageRepository; } });
+var payment_transaction_repository_1 = require("./payment-transaction.repository");
+Object.defineProperty(exports, "PaymentTransactionRepository", { enumerable: true, get: function () { return payment_transaction_repository_1.PaymentTransactionRepository; } });
+var stripe_webhook_repository_1 = require("./stripe-webhook.repository");
+Object.defineProperty(exports, "StripeWebhookRepository", { enumerable: true, get: function () { return stripe_webhook_repository_1.StripeWebhookRepository; } });
+var credit_transaction_repository_1 = require("./credit-transaction.repository");
+Object.defineProperty(exports, "CreditTransactionRepository", { enumerable: true, get: function () { return credit_transaction_repository_1.CreditTransactionRepository; } });
+var reward_rule_repository_1 = require("./reward-rule.repository");
+Object.defineProperty(exports, "RewardRuleRepository", { enumerable: true, get: function () { return reward_rule_repository_1.RewardRuleRepository; } });
+var ai_usage_repository_1 = require("./ai-usage.repository");
+Object.defineProperty(exports, "AiUsageRepository", { enumerable: true, get: function () { return ai_usage_repository_1.AiUsageRepository; } });
+var asset_repository_1 = require("./asset.repository");
+Object.defineProperty(exports, "AssetRepository", { enumerable: true, get: function () { return asset_repository_1.AssetRepository; } });
+var effect_repository_1 = require("./effect.repository");
+Object.defineProperty(exports, "EffectRepository", { enumerable: true, get: function () { return effect_repository_1.EffectRepository; } });
+var video_transcode_repository_1 = require("./video-transcode.repository");
+Object.defineProperty(exports, "VideoTranscodeRepository", { enumerable: true, get: function () { return video_transcode_repository_1.VideoTranscodeRepository; } });
+var video_render_repository_1 = require("./video-render.repository");
+Object.defineProperty(exports, "VideoRenderRepository", { enumerable: true, get: function () { return video_render_repository_1.VideoRenderRepository; } });

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

@@ -0,0 +1,12 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { Invite } from '../entities/invite.entity';
+export declare class InviteRepository extends BaseRepository<Invite> {
+    constructor(repository: Repository<Invite>);
+    findByToken(token: string): Promise<Invite | null>;
+    findByEmail(email: string): Promise<Invite[]>;
+    findByWorkspaceId(workspaceId: string): Promise<Invite[]>;
+    findPending(): Promise<Invite[]>;
+    markExpired(id: string): Promise<void>;
+    acceptInvite(token: string): Promise<void>;
+}