clhq-postgres-module 1.1.0-alpha.90

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

@@ -0,0 +1,41 @@
+"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.UserProfileRepository = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const user_profile_entity_1 = require("../entities/user-profile.entity");
+const base_repository_1 = require("./base.repository");
+let UserProfileRepository = class UserProfileRepository extends base_repository_1.BaseRepository {
+    constructor(userProfileRepository) {
+        super(userProfileRepository);
+        this.userProfileRepository = userProfileRepository;
+    }
+    async findByUserId(userId) {
+        return this.userProfileRepository.findOne({
+            where: { userId },
+        });
+    }
+    async updateProfile(userId, updates) {
+        await this.userProfileRepository.update({ userId }, updates);
+        return this.findByUserId(userId);
+    }
+};
+exports.UserProfileRepository = UserProfileRepository;
+exports.UserProfileRepository = UserProfileRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(user_profile_entity_1.UserProfile)),
+    __metadata("design:paramtypes", [typeorm_2.Repository])
+], UserProfileRepository);

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

@@ -0,0 +1,16 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { UserSubscription, SubscriptionStatus } from '../entities/user-subscription.entity';
+export declare class UserSubscriptionRepository extends BaseRepository<UserSubscription> {
+    private readonly subscriptionRepository;
+    constructor(subscriptionRepository: Repository<UserSubscription>);
+    findActiveByUserId(userId: string): Promise<UserSubscription | null>;
+    findByUserId(userId: string): Promise<UserSubscription[]>;
+    cancelSubscription(subscriptionId: string): Promise<void>;
+    findOneByUserId(userId: string): Promise<UserSubscription | null>;
+    findByStripeSubscriptionId(stripeSubscriptionId: string): Promise<UserSubscription | null>;
+    findByStatus(status: SubscriptionStatus): Promise<UserSubscription[]>;
+    findByPlanId(planId: string): Promise<UserSubscription[]>;
+    findExpiringSubscriptions(beforeDate: string): Promise<UserSubscription[]>;
+    findTrialEndingSoon(beforeDate: string): Promise<UserSubscription[]>;
+}

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

@@ -0,0 +1,90 @@
+"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.UserSubscriptionRepository = 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_subscription_entity_1 = require("../entities/user-subscription.entity");
+let UserSubscriptionRepository = class UserSubscriptionRepository extends base_repository_1.BaseRepository {
+    constructor(subscriptionRepository) {
+        super(subscriptionRepository);
+        this.subscriptionRepository = subscriptionRepository;
+    }
+    async findActiveByUserId(userId) {
+        return this.subscriptionRepository.findOne({
+            where: { userId, status: user_subscription_entity_1.SubscriptionStatus.ACTIVE }
+        });
+    }
+    async findByUserId(userId) {
+        return this.subscriptionRepository.find({
+            where: { userId },
+            order: { createdAt: 'DESC' }
+        });
+    }
+    async cancelSubscription(subscriptionId) {
+        await this.subscriptionRepository.update(subscriptionId, {
+            status: user_subscription_entity_1.SubscriptionStatus.CANCELLED,
+            cancelledAt: new Date(),
+        });
+    }
+    async findOneByUserId(userId) {
+        return this.subscriptionRepository.findOne({
+            where: { userId },
+            order: { createdAt: 'DESC' }
+        });
+    }
+    async findByStripeSubscriptionId(stripeSubscriptionId) {
+        return this.subscriptionRepository.findOne({
+            where: { stripeSubscriptionId }
+        });
+    }
+    async findByStatus(status) {
+        return this.subscriptionRepository.find({
+            where: { status },
+            order: { createdAt: 'DESC' }
+        });
+    }
+    async findByPlanId(planId) {
+        return this.subscriptionRepository.find({
+            where: { planId },
+            order: { createdAt: 'DESC' }
+        });
+    }
+    async findExpiringSubscriptions(beforeDate) {
+        return this.subscriptionRepository
+            .createQueryBuilder('subscription')
+            .where('subscription.currentPeriodEnd <= :beforeDate', { beforeDate: new Date(beforeDate) })
+            .andWhere('subscription.status IN (:...statuses)', {
+            statuses: [user_subscription_entity_1.SubscriptionStatus.ACTIVE, user_subscription_entity_1.SubscriptionStatus.TRIAL]
+        })
+            .orderBy('subscription.currentPeriodEnd', 'ASC')
+            .getMany();
+    }
+    async findTrialEndingSoon(beforeDate) {
+        return this.subscriptionRepository
+            .createQueryBuilder('subscription')
+            .where('subscription.trialEndsAt <= :beforeDate', { beforeDate: new Date(beforeDate) })
+            .andWhere('subscription.status = :status', { status: user_subscription_entity_1.SubscriptionStatus.TRIAL })
+            .orderBy('subscription.trialEndsAt', 'ASC')
+            .getMany();
+    }
+};
+exports.UserSubscriptionRepository = UserSubscriptionRepository;
+exports.UserSubscriptionRepository = UserSubscriptionRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(user_subscription_entity_1.UserSubscription)),
+    __metadata("design:paramtypes", [typeorm_1.Repository])
+], UserSubscriptionRepository);

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

@@ -0,0 +1,17 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { User } from '../entities/user.entity';
+export declare class UserRepository extends BaseRepository<User> {
+    private readonly userRepository;
+    constructor(userRepository: Repository<User>);
+    findByEmail(email: string): Promise<User | null>;
+    findByAuth0UserId(auth0UserId: string): Promise<User | null>;
+    findByStripeCustomerId(stripeCustomerId: string): Promise<User | null>;
+    findByUsername(username: string): Promise<User | null>;
+    updateLastLogin(userId: string): Promise<void>;
+    markEmailVerified(userId: string): Promise<void>;
+    scheduleForDeletion(userId: string, deletionDate: Date): Promise<void>;
+    findByReferralCode(referralCode: string): Promise<User | null>;
+    incrementReferralCount(userId: string): Promise<void>;
+    findScheduledForDeletion(): Promise<User[]>;
+}

package/dist/repositories/user.repository.js

@@ -0,0 +1,89 @@
+"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.UserRepository = 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_entity_1 = require("../entities/user.entity");
+let UserRepository = class UserRepository extends base_repository_1.BaseRepository {
+    constructor(userRepository) {
+        super(userRepository);
+        this.userRepository = userRepository;
+    }
+    async findByEmail(email) {
+        return this.userRepository.findOne({
+            where: { email },
+        });
+    }
+    async findByAuth0UserId(auth0UserId) {
+        return this.userRepository.findOne({
+            where: { auth0UserId },
+        });
+    }
+    async findByStripeCustomerId(stripeCustomerId) {
+        return this.userRepository.findOne({
+            where: { stripeCustomerId },
+        });
+    }
+    async findByUsername(username) {
+        return this.userRepository.findOne({
+            where: { username },
+        });
+    }
+    async updateLastLogin(userId) {
+        await this.userRepository.update(userId, {
+            lastLoginAt: new Date(),
+        });
+    }
+    async markEmailVerified(userId) {
+        await this.userRepository.update(userId, {
+            emailVerified: true,
+            emailVerifiedAt: new Date(),
+        });
+    }
+    async scheduleForDeletion(userId, deletionDate) {
+        await this.userRepository.update(userId, {
+            scheduledDeletionAt: deletionDate,
+        });
+    }
+    async findByReferralCode(referralCode) {
+        return this.userRepository.findOne({
+            where: { referralCode },
+        });
+    }
+    async incrementReferralCount(userId) {
+        await this.userRepository
+            .createQueryBuilder()
+            .update()
+            .set({ referralCount: () => 'referral_count + 1' })
+            .where('id = :userId', { userId })
+            .execute();
+    }
+    async findScheduledForDeletion() {
+        return this.userRepository
+            .createQueryBuilder('user')
+            .where('user.scheduledDeletionAt IS NOT NULL')
+            .andWhere('user.scheduledDeletionAt <= :now', { now: new Date() })
+            .andWhere('user.status = :status', { status: 'deleted' })
+            .getMany();
+    }
+};
+exports.UserRepository = UserRepository;
+exports.UserRepository = UserRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(user_entity_1.User)),
+    __metadata("design:paramtypes", [typeorm_1.Repository])
+], UserRepository);

package/dist/repositories/video-render.repository.d.ts

@@ -0,0 +1,28 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { VideoRender, VideoRenderStatus } from '../entities/video-render.entity';
+export declare class VideoRenderRepository extends BaseRepository<VideoRender> {
+    private readonly videoRenderRepository;
+    constructor(videoRenderRepository: Repository<VideoRender>);
+    findByUserId(userId: string): Promise<VideoRender[]>;
+    findByProjectId(projectId: string): Promise<VideoRender[]>;
+    findByStatus(status: VideoRenderStatus): Promise<VideoRender[]>;
+    updateRender(id: string, data: {
+        title?: string;
+        s3Url?: string;
+        s3ImageUrl?: string;
+        status?: VideoRenderStatus;
+        data?: any;
+    }): Promise<VideoRender | null>;
+    createWithId(data: {
+        id: string;
+        userId: string;
+        projectId?: string;
+        title?: string;
+        s3Url?: string;
+        s3ImageUrl?: string;
+        status?: VideoRenderStatus;
+        data?: any;
+    }): Promise<VideoRender>;
+    getAll(): Promise<VideoRender[]>;
+}

package/dist/repositories/video-render.repository.js

@@ -0,0 +1,63 @@
+"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.VideoRenderRepository = 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 video_render_entity_1 = require("../entities/video-render.entity");
+let VideoRenderRepository = class VideoRenderRepository extends base_repository_1.BaseRepository {
+    constructor(videoRenderRepository) {
+        super(videoRenderRepository);
+        this.videoRenderRepository = videoRenderRepository;
+    }
+    async findByUserId(userId) {
+        return this.videoRenderRepository.find({
+            where: { userId },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async findByProjectId(projectId) {
+        return this.videoRenderRepository.find({
+            where: { projectId },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async findByStatus(status) {
+        return this.videoRenderRepository.find({
+            where: { status },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async updateRender(id, data) {
+        await this.videoRenderRepository.update(id, data);
+        return this.findById(id);
+    }
+    async createWithId(data) {
+        const entity = this.videoRenderRepository.create(data);
+        return this.videoRenderRepository.save(entity);
+    }
+    async getAll() {
+        return this.videoRenderRepository.find({
+            order: { createdAt: 'DESC' },
+        });
+    }
+};
+exports.VideoRenderRepository = VideoRenderRepository;
+exports.VideoRenderRepository = VideoRenderRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(video_render_entity_1.VideoRender)),
+    __metadata("design:paramtypes", [typeorm_1.Repository])
+], VideoRenderRepository);

package/dist/repositories/video-transcode.repository.d.ts

@@ -0,0 +1,23 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { VideoTranscode, VideoTranscodeStatus } from '../entities/video-transcode.entity';
+export declare class VideoTranscodeRepository extends BaseRepository<VideoTranscode> {
+    private readonly videoTranscodeRepository;
+    constructor(videoTranscodeRepository: Repository<VideoTranscode>);
+    findByProjectId(projectId: string): Promise<VideoTranscode[]>;
+    findByStatus(status: VideoTranscodeStatus): Promise<VideoTranscode[]>;
+    updateTranscode(id: string, data: {
+        status?: VideoTranscodeStatus;
+        s3Key?: string;
+        data?: any;
+        queueStatus?: string;
+    }): Promise<VideoTranscode | null>;
+    createWithId(data: {
+        id: string;
+        projectId?: string;
+        s3Key?: string;
+        status?: VideoTranscodeStatus;
+        data?: any;
+        queueStatus?: string;
+    }): Promise<VideoTranscode>;
+}

package/dist/repositories/video-transcode.repository.js

@@ -0,0 +1,52 @@
+"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.VideoTranscodeRepository = 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 video_transcode_entity_1 = require("../entities/video-transcode.entity");
+let VideoTranscodeRepository = class VideoTranscodeRepository extends base_repository_1.BaseRepository {
+    constructor(videoTranscodeRepository) {
+        super(videoTranscodeRepository);
+        this.videoTranscodeRepository = videoTranscodeRepository;
+    }
+    async findByProjectId(projectId) {
+        return this.videoTranscodeRepository.find({
+            where: { projectId },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async findByStatus(status) {
+        return this.videoTranscodeRepository.find({
+            where: { status },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async updateTranscode(id, data) {
+        await this.videoTranscodeRepository.update(id, data);
+        return this.findById(id);
+    }
+    async createWithId(data) {
+        const entity = this.videoTranscodeRepository.create(data);
+        return this.videoTranscodeRepository.save(entity);
+    }
+};
+exports.VideoTranscodeRepository = VideoTranscodeRepository;
+exports.VideoTranscodeRepository = VideoTranscodeRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(video_transcode_entity_1.VideoTranscode)),
+    __metadata("design:paramtypes", [typeorm_1.Repository])
+], VideoTranscodeRepository);

package/dist/repositories/workspace-member.repository.d.ts

@@ -0,0 +1,13 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { WorkspaceMember } from '../entities/workspace-member.entity';
+export declare class WorkspaceMemberRepository extends BaseRepository<WorkspaceMember> {
+    private readonly memberRepository;
+    constructor(memberRepository: Repository<WorkspaceMember>);
+    findByWorkspaceAndUser(workspaceId: string, userId: string): Promise<WorkspaceMember | null>;
+    findByWorkspace(workspaceId: string): Promise<WorkspaceMember[]>;
+    findByUser(userId: string): Promise<WorkspaceMember[]>;
+    findAdmins(workspaceId: string): Promise<WorkspaceMember[]>;
+    isAdmin(workspaceId: string, userId: string): Promise<boolean>;
+    countMembers(workspaceId: string): Promise<number>;
+}

package/dist/repositories/workspace-member.repository.js

@@ -0,0 +1,79 @@
+"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.WorkspaceMemberRepository = 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 workspace_member_entity_1 = require("../entities/workspace-member.entity");
+let WorkspaceMemberRepository = class WorkspaceMemberRepository extends base_repository_1.BaseRepository {
+    constructor(memberRepository) {
+        super(memberRepository);
+        this.memberRepository = memberRepository;
+    }
+    async findByWorkspaceAndUser(workspaceId, userId) {
+        return this.memberRepository.findOne({
+            where: {
+                workspaceId,
+                userId,
+            }
+        });
+    }
+    async findByWorkspace(workspaceId) {
+        return this.memberRepository.find({
+            where: { workspaceId },
+            relations: ['user'],
+            order: { createdAt: 'DESC' }
+        });
+    }
+    async findByUser(userId) {
+        return this.memberRepository.find({
+            where: { userId },
+            relations: ['workspace'],
+            order: { createdAt: 'DESC' }
+        });
+    }
+    async findAdmins(workspaceId) {
+        return this.memberRepository.find({
+            where: {
+                workspaceId,
+                role: workspace_member_entity_1.WorkspaceMemberRole.ADMIN,
+            },
+            relations: ['user'],
+            order: { createdAt: 'ASC' }
+        });
+    }
+    async isAdmin(workspaceId, userId) {
+        const member = await this.memberRepository.findOne({
+            where: {
+                workspaceId,
+                userId,
+                role: workspace_member_entity_1.WorkspaceMemberRole.ADMIN,
+            }
+        });
+        return !!member;
+    }
+    async countMembers(workspaceId) {
+        return this.memberRepository.count({
+            where: { workspaceId }
+        });
+    }
+};
+exports.WorkspaceMemberRepository = WorkspaceMemberRepository;
+exports.WorkspaceMemberRepository = WorkspaceMemberRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(workspace_member_entity_1.WorkspaceMember)),
+    __metadata("design:paramtypes", [typeorm_1.Repository])
+], WorkspaceMemberRepository);

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

@@ -0,0 +1,13 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { Workspace } from '../entities/workspace.entity';
+export declare class WorkspaceRepository extends BaseRepository<Workspace> {
+    private readonly workspaceRepository;
+    constructor(workspaceRepository: Repository<Workspace>);
+    findByOwner(ownerId: string): Promise<Workspace[]>;
+    findWithMembers(workspaceId: string): Promise<Workspace | null>;
+    findWithProjects(workspaceId: string): Promise<Workspace | null>;
+    findShared(): Promise<Workspace[]>;
+    countByOwner(ownerId: string): Promise<number>;
+    findByOwnerId(ownerId: string): Promise<Workspace[]>;
+}

package/dist/repositories/workspace.repository.js

@@ -0,0 +1,64 @@
+"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.WorkspaceRepository = 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 workspace_entity_1 = require("../entities/workspace.entity");
+let WorkspaceRepository = class WorkspaceRepository extends base_repository_1.BaseRepository {
+    constructor(workspaceRepository) {
+        super(workspaceRepository);
+        this.workspaceRepository = workspaceRepository;
+    }
+    async findByOwner(ownerId) {
+        return this.workspaceRepository.find({
+            where: { ownerId },
+            order: { createdAt: 'DESC' }
+        });
+    }
+    async findWithMembers(workspaceId) {
+        return this.workspaceRepository.findOne({
+            where: { id: workspaceId },
+            relations: ['users']
+        });
+    }
+    async findWithProjects(workspaceId) {
+        return this.workspaceRepository.findOne({
+            where: { id: workspaceId },
+            relations: ['projects']
+        });
+    }
+    async findShared() {
+        return this.workspaceRepository.find({
+            where: { isShared: true },
+            order: { createdAt: 'DESC' }
+        });
+    }
+    async countByOwner(ownerId) {
+        return this.workspaceRepository.count({
+            where: { ownerId }
+        });
+    }
+    async findByOwnerId(ownerId) {
+        return this.findByOwner(ownerId);
+    }
+};
+exports.WorkspaceRepository = WorkspaceRepository;
+exports.WorkspaceRepository = WorkspaceRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(workspace_entity_1.Workspace)),
+    __metadata("design:paramtypes", [typeorm_1.Repository])
+], WorkspaceRepository);

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "clhq-postgres-module",
+  "version": "1.1.0-alpha.90",
+  "description": "PostgreSQL module using TypeORM for Clippy",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/reacthub-pricematch/clhq-api-monorepo"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "bugs": {
+    "url": "https://github.com/reacthub-pricematch/clhq-api-monorepo/issues"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "typeorm": "typeorm-ts-node-commonjs",
+    "db:setup": "env-cmd -f ../../.env.dev npx ts-node scripts/setup-database.ts",
+    "db:migrate": "npx ts-node scripts/run-migrations.ts --all",
+    "db:migrate:002": "npx ts-node scripts/run-migrations.ts 002",
+    "db:migrate:003": "npx ts-node scripts/run-migrations.ts 003",
+    "db:migrate:004": "npx ts-node scripts/run-migrations.ts 004",
+    "db:migrate:008": "npx ts-node scripts/run-migrations.ts 008",
+    "db:migrate:009": "npx ts-node scripts/run-migrations.ts 009",
+    "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",
+    "db:drop": "env-cmd -f ../../.env.dev  npm run typeorm schema:drop -- -d src/config/data-source.ts"
+  },
+  "dependencies": {
+    "@nestjs/common": "^11.1.5",
+    "@nestjs/config": "^4",
+    "@nestjs/core": "^11.1.5",
+    "@nestjs/typeorm": "^10.0.0",
+    "@supabase/supabase-js": "^2.39.0",
+    "class-transformer": "0.5.1",
+    "class-validator": "0.14.2",
+    "dotenv": "^16.3.1",
+    "pg": "^8.11.3",
+    "reflect-metadata": "0.2.2",
+    "rxjs": "^7.8.1",
+    "typeorm": "^0.3.17"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.4",
+    "@types/pg": "^8.10.9",
+    "env-cmd": "^10.1.0",
+    "ts-node": "10.9.2",
+    "typescript": "^5.8.3"
+  }
+}