clhq-dynamodb-module 1.1.0-alpha.90

package/dist/repositories/track.repository.js

@@ -0,0 +1,61 @@
+"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 TrackRepository_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrackRepository = void 0;
+const common_1 = require("@nestjs/common");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const base_repository_1 = require("./base.repository");
+let TrackRepository = TrackRepository_1 = class TrackRepository extends base_repository_1.BaseRepository {
+    logger = new common_1.Logger(TrackRepository_1.name);
+    constructor(dynamoDbClient) {
+        super(dynamoDbClient, `track-${process.env.STAGE}`);
+    }
+    async findByTimelineId(timelineId) {
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            IndexName: 'timelineId-orderIndex-index',
+            KeyConditionExpression: 'timelineId = :timelineId',
+            ExpressionAttributeValues: {
+                ':timelineId': timelineId,
+            },
+        });
+        return result.Items || [];
+    }
+    async findByTrackType(timelineId, trackType) {
+        const result = await this.dynamoDb.query({
+            TableName: this.tableName,
+            IndexName: 'timelineId-trackType-index',
+            KeyConditionExpression: 'timelineId = :timelineId AND trackType = :trackType',
+            ExpressionAttributeValues: {
+                ':timelineId': timelineId,
+                ':trackType': trackType,
+            },
+        });
+        return result.Items || [];
+    }
+    async reorderTracks(timelineId, trackOrders) {
+        const updatePromises = trackOrders.map(({ id, orderIndex }) => this.dynamoDb.update({
+            TableName: this.tableName,
+            Key: { id },
+            UpdateExpression: 'SET orderIndex = :orderIndex',
+            ExpressionAttributeValues: {
+                ':orderIndex': orderIndex,
+            },
+        }));
+        await Promise.all(updatePromises);
+    }
+};
+exports.TrackRepository = TrackRepository;
+exports.TrackRepository = TrackRepository = TrackRepository_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [client_dynamodb_1.DynamoDB])
+], TrackRepository);

package/dist/repositories/user-onboarding-response.repository.d.ts

@@ -0,0 +1,11 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { UserOnboardingResponse } from '../entities/user-onboarding-response.entity';
+export declare class UserOnboardingResponseRepository extends BaseRepository<UserOnboardingResponse> {
+    private readonly logger;
+    constructor(dynamoDbClient: DynamoDB);
+    findByUserId(userId: string): Promise<UserOnboardingResponse[]>;
+    findByUserAndQuestion(userId: string, questionKey: string): Promise<UserOnboardingResponse | undefined>;
+    findByQuestionKey(questionKey: string): Promise<UserOnboardingResponse[]>;
+    upsertResponse(userId: string, questionKey: string, responseValue: string): Promise<UserOnboardingResponse>;
+}

package/dist/repositories/user-onboarding-response.repository.js

@@ -0,0 +1,58 @@
+"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 UserOnboardingResponseRepository_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserOnboardingResponseRepository = void 0;
+const common_1 = require("@nestjs/common");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const base_repository_1 = require("./base.repository");
+let UserOnboardingResponseRepository = UserOnboardingResponseRepository_1 = class UserOnboardingResponseRepository extends base_repository_1.BaseRepository {
+    logger = new common_1.Logger(UserOnboardingResponseRepository_1.name);
+    constructor(dynamoDbClient) {
+        super(dynamoDbClient, `user-onboarding-response-${process.env.STAGE}`);
+    }
+    async findByUserId(userId) {
+        return this.find({ userId });
+    }
+    async findByUserAndQuestion(userId, questionKey) {
+        const result = await this.find({ userId, questionKey });
+        return result[0];
+    }
+    async findByQuestionKey(questionKey) {
+        return this.find({ questionKey });
+    }
+    async upsertResponse(userId, questionKey, responseValue) {
+        const existing = await this.findByUserAndQuestion(userId, questionKey);
+        if (existing) {
+            const updated = await this.update(existing.id, {
+                responseValue,
+                updatedAt: new Date().toISOString(),
+            });
+            return updated;
+        }
+        else {
+            const newResponse = {
+                id: `${userId}-${questionKey}`,
+                userId,
+                questionKey,
+                responseValue,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+            };
+            return await this.create(newResponse);
+        }
+    }
+};
+exports.UserOnboardingResponseRepository = UserOnboardingResponseRepository;
+exports.UserOnboardingResponseRepository = UserOnboardingResponseRepository = UserOnboardingResponseRepository_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [client_dynamodb_1.DynamoDB])
+], UserOnboardingResponseRepository);

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

@@ -0,0 +1,18 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { UserProfile, NotificationPreferences, ExportPreferences, WorkspacePreferences } from '../entities/user-profile.entity';
+export declare class UserProfileRepository extends BaseRepository<UserProfile> {
+    private readonly logger;
+    constructor(dynamoDbClient: DynamoDB);
+    findByUserId(userId: string): Promise<UserProfile | undefined>;
+    findByDisplayName(displayName: string): Promise<UserProfile[]>;
+    findByCompany(company: string): Promise<UserProfile[]>;
+    findByCountry(country: string): Promise<UserProfile[]>;
+    findProfilesNearingStorageLimit(threshold?: number): Promise<UserProfile[]>;
+    updateStorageUsed(userId: string, storageUsed: number): Promise<UserProfile>;
+    updateStorageLimit(userId: string, storageLimit: number): Promise<UserProfile>;
+    updateNotificationPreferences(userId: string, preferences: NotificationPreferences): Promise<UserProfile>;
+    updateExportPreferences(userId: string, preferences: ExportPreferences): Promise<UserProfile>;
+    updateWorkspacePreferences(userId: string, preferences: WorkspacePreferences): Promise<UserProfile>;
+    updateAvatar(userId: string, avatarUrl: string): Promise<UserProfile>;
+}

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

@@ -0,0 +1,62 @@
+"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 UserProfileRepository_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserProfileRepository = void 0;
+const common_1 = require("@nestjs/common");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const base_repository_1 = require("./base.repository");
+let UserProfileRepository = UserProfileRepository_1 = class UserProfileRepository extends base_repository_1.BaseRepository {
+    logger = new common_1.Logger(UserProfileRepository_1.name);
+    constructor(dynamoDbClient) {
+        super(dynamoDbClient, `user-profile-${process.env.STAGE}`);
+    }
+    async findByUserId(userId) {
+        const results = await this.find({ userId });
+        return results[0];
+    }
+    async findByDisplayName(displayName) {
+        return this.find({ displayName });
+    }
+    async findByCompany(company) {
+        return this.find({ company });
+    }
+    async findByCountry(country) {
+        return this.find({ country });
+    }
+    async findProfilesNearingStorageLimit(threshold = 0.9) {
+        const results = await this.findAll();
+        return results.filter((profile) => profile.storageUsed / profile.storageLimit >= threshold);
+    }
+    async updateStorageUsed(userId, storageUsed) {
+        return this.update(userId, { storageUsed });
+    }
+    async updateStorageLimit(userId, storageLimit) {
+        return this.update(userId, { storageLimit });
+    }
+    async updateNotificationPreferences(userId, preferences) {
+        return this.update(userId, { notificationPreferences: preferences });
+    }
+    async updateExportPreferences(userId, preferences) {
+        return this.update(userId, { exportPreferences: preferences });
+    }
+    async updateWorkspacePreferences(userId, preferences) {
+        return this.update(userId, { workspacePreferences: preferences });
+    }
+    async updateAvatar(userId, avatarUrl) {
+        return this.update(userId, { avatarUrl });
+    }
+};
+exports.UserProfileRepository = UserProfileRepository;
+exports.UserProfileRepository = UserProfileRepository = UserProfileRepository_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [client_dynamodb_1.DynamoDB])
+], UserProfileRepository);

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

@@ -0,0 +1,13 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { UserSubscription, SubscriptionStatus } from '../entities/user-subscription.entity';
+export declare class UserSubscriptionRepository extends BaseRepository<UserSubscription> {
+    private readonly logger;
+    constructor(dynamoDbClient: DynamoDB);
+    findByUserId(userId: string): Promise<UserSubscription | undefined>;
+    findByStripeSubscriptionId(stripeSubscriptionId: string): Promise<UserSubscription | undefined>;
+    findByPlanId(planId: string): Promise<UserSubscription[]>;
+    findByStatus(status: SubscriptionStatus): Promise<UserSubscription[]>;
+    findExpiringSubscriptions(beforeDate: string): Promise<UserSubscription[]>;
+    findTrialEndingSoon(beforeDate: string): Promise<UserSubscription[]>;
+}

package/dist/repositories/user-subscription.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 UserSubscriptionRepository_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserSubscriptionRepository = void 0;
+const common_1 = require("@nestjs/common");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const base_repository_1 = require("./base.repository");
+const user_subscription_entity_1 = require("../entities/user-subscription.entity");
+let UserSubscriptionRepository = UserSubscriptionRepository_1 = class UserSubscriptionRepository extends base_repository_1.BaseRepository {
+    logger = new common_1.Logger(UserSubscriptionRepository_1.name);
+    constructor(dynamoDbClient) {
+        super(dynamoDbClient, `user-subscription-${process.env.STAGE}`);
+    }
+    async findByUserId(userId) {
+        const result = await this.find({ userId });
+        return result[0];
+    }
+    async findByStripeSubscriptionId(stripeSubscriptionId) {
+        const result = await this.find({ stripeSubscriptionId });
+        return result[0];
+    }
+    async findByPlanId(planId) {
+        return this.find({ planId });
+    }
+    async findByStatus(status) {
+        return this.find({ status });
+    }
+    async findExpiringSubscriptions(beforeDate) {
+        const items = await this.findAll();
+        return items.filter((sub) => sub.currentPeriodEnd <= beforeDate &&
+            sub.status === user_subscription_entity_1.SubscriptionStatus.ACTIVE);
+    }
+    async findTrialEndingSoon(beforeDate) {
+        const items = await this.findAll();
+        return items.filter((sub) => sub.trialEndsAt <= beforeDate &&
+            sub.status === user_subscription_entity_1.SubscriptionStatus.TRIAL);
+    }
+};
+exports.UserSubscriptionRepository = UserSubscriptionRepository;
+exports.UserSubscriptionRepository = UserSubscriptionRepository = UserSubscriptionRepository_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [client_dynamodb_1.DynamoDB])
+], UserSubscriptionRepository);

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

@@ -0,0 +1,20 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { User, UserStatus, UserRole } from '../entities/user.entity';
+export declare class UserRepository extends BaseRepository<User> {
+    private readonly logger;
+    constructor(dynamoDbClient: DynamoDB);
+    findById(id: string): Promise<User | undefined>;
+    findByEmail(email: string): Promise<User | undefined>;
+    findByUsername(username: string): Promise<User | undefined>;
+    findByStripeCustomerId(stripeCustomerId: string): Promise<User | undefined>;
+    findByRole(role: UserRole): Promise<User[]>;
+    findByStatus(status: UserStatus): Promise<User[]>;
+    findActiveUsers(): Promise<User[]>;
+    findByCreatedAtRange(startDate: string, endDate: string): Promise<User[]>;
+    findRecentlyActive(sinceDate: string): Promise<User[]>;
+    updateLastLogin(userId: string): Promise<User>;
+    verifyEmail(userId: string): Promise<User>;
+    softDelete(userId: string): Promise<User>;
+    updatePassword(userId: string, passwordHash: string): Promise<User>;
+}

package/dist/repositories/user.repository.js

@@ -0,0 +1,94 @@
+"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 UserRepository_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserRepository = void 0;
+const common_1 = require("@nestjs/common");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const base_repository_1 = require("./base.repository");
+const user_entity_1 = require("../entities/user.entity");
+let UserRepository = UserRepository_1 = class UserRepository extends base_repository_1.BaseRepository {
+    logger = new common_1.Logger(UserRepository_1.name);
+    constructor(dynamoDbClient) {
+        super(dynamoDbClient, `users-${process.env.STAGE}`);
+    }
+    async findById(id) {
+        this.logger.debug(`UserRepository -> Finding user by ID: ${id}`);
+        const user = await super.findById(id);
+        if (user && !user.workspaceId) {
+            user.workspaceId = `default-workspace-${user.id}`;
+        }
+        return user;
+    }
+    async findByEmail(email) {
+        const results = await this.find({ email });
+        const user = results[0];
+        if (user && !user.workspaceId) {
+            user.workspaceId = `default-workspace-${user.id}`;
+        }
+        return user;
+    }
+    async findByUsername(username) {
+        if (!username)
+            return undefined;
+        const results = await this.find({ username });
+        return results[0];
+    }
+    async findByStripeCustomerId(stripeCustomerId) {
+        if (!stripeCustomerId)
+            return undefined;
+        const results = await this.find({ stripeCustomerId });
+        return results[0];
+    }
+    async findByRole(role) {
+        return this.find({ role });
+    }
+    async findByStatus(status) {
+        return this.find({ status });
+    }
+    async findActiveUsers() {
+        return this.find({ isActive: true, status: user_entity_1.UserStatus.ACTIVE });
+    }
+    async findByCreatedAtRange(startDate, endDate) {
+        const results = await this.findAll();
+        return results.filter((user) => user.createdAt >= startDate && user.createdAt <= endDate);
+    }
+    async findRecentlyActive(sinceDate) {
+        const results = await this.find({ status: user_entity_1.UserStatus.ACTIVE });
+        return results.filter((user) => user.lastLoginAt && user.lastLoginAt >= sinceDate);
+    }
+    async updateLastLogin(userId) {
+        return this.update(userId, { lastLoginAt: new Date().toISOString() });
+    }
+    async verifyEmail(userId) {
+        const now = new Date().toISOString();
+        return this.update(userId, {
+            emailVerified: true,
+            emailVerifiedAt: now,
+        });
+    }
+    async softDelete(userId) {
+        const now = new Date().toISOString();
+        return this.update(userId, {
+            status: user_entity_1.UserStatus.DELETED,
+            deletedAt: now,
+            isActive: false,
+        });
+    }
+    async updatePassword(userId, passwordHash) {
+        return this.update(userId, { passwordHash });
+    }
+};
+exports.UserRepository = UserRepository;
+exports.UserRepository = UserRepository = UserRepository_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [client_dynamodb_1.DynamoDB])
+], UserRepository);

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

@@ -0,0 +1,10 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { WorkspaceMember } from '../entities/workspace-member.entity';
+export declare class WorkspaceMemberRepository extends BaseRepository<WorkspaceMember> {
+    private readonly logger;
+    constructor(dynamoDbClient: DynamoDB);
+    findByWorkspaceId(workspaceId: string): Promise<WorkspaceMember[]>;
+    findByUserId(userId: string): Promise<WorkspaceMember[]>;
+    findByWorkspaceAndUser(workspaceId: string, userId: string): Promise<WorkspaceMember | undefined>;
+}

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

@@ -0,0 +1,37 @@
+"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 WorkspaceMemberRepository_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceMemberRepository = void 0;
+const common_1 = require("@nestjs/common");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const base_repository_1 = require("./base.repository");
+let WorkspaceMemberRepository = WorkspaceMemberRepository_1 = class WorkspaceMemberRepository extends base_repository_1.BaseRepository {
+    logger = new common_1.Logger(WorkspaceMemberRepository_1.name);
+    constructor(dynamoDbClient) {
+        super(dynamoDbClient, `workspace-members-${process.env.STAGE}`);
+    }
+    async findByWorkspaceId(workspaceId) {
+        return this.find({ workspaceId });
+    }
+    async findByUserId(userId) {
+        return this.find({ userId });
+    }
+    async findByWorkspaceAndUser(workspaceId, userId) {
+        const results = await this.find({ workspaceId, userId });
+        return results[0];
+    }
+};
+exports.WorkspaceMemberRepository = WorkspaceMemberRepository;
+exports.WorkspaceMemberRepository = WorkspaceMemberRepository = WorkspaceMemberRepository_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [client_dynamodb_1.DynamoDB])
+], WorkspaceMemberRepository);

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

@@ -0,0 +1,10 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { Workspace } from '../entities/workspace.entity';
+export declare class WorkspaceRepository extends BaseRepository<Workspace> {
+    private readonly logger;
+    constructor(dynamoDbClient: DynamoDB);
+    findByOwnerId(ownerId: string): Promise<Workspace[]>;
+    findSharedWorkspaces(): Promise<Workspace[]>;
+    findByNameContains(searchTerm: string, ownerId?: string): Promise<Workspace[]>;
+}

package/dist/repositories/workspace.repository.js

@@ -0,0 +1,45 @@
+"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 WorkspaceRepository_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceRepository = void 0;
+const common_1 = require("@nestjs/common");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const base_repository_1 = require("./base.repository");
+let WorkspaceRepository = WorkspaceRepository_1 = class WorkspaceRepository extends base_repository_1.BaseRepository {
+    logger = new common_1.Logger(WorkspaceRepository_1.name);
+    constructor(dynamoDbClient) {
+        super(dynamoDbClient, `workspaces-${process.env.STAGE}`);
+    }
+    async findByOwnerId(ownerId) {
+        return this.find({ ownerId }, {
+            indexName: 'ownerId-index',
+            keyConditionExpression: 'ownerId = :ownerId',
+        });
+    }
+    async findSharedWorkspaces() {
+        return this.find({ isShared: true }, {
+            indexName: 'isShared-index',
+            keyConditionExpression: 'isShared = :shared',
+        });
+    }
+    async findByNameContains(searchTerm, ownerId) {
+        const conditions = ownerId ? { ownerId } : {};
+        return this.find(conditions, {
+            keyConditionExpression: ownerId ? 'ownerId = :ownerId' : undefined,
+        }).then(items => items.filter(w => w.name?.toLowerCase().includes(searchTerm.toLowerCase())));
+    }
+};
+exports.WorkspaceRepository = WorkspaceRepository;
+exports.WorkspaceRepository = WorkspaceRepository = WorkspaceRepository_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [client_dynamodb_1.DynamoDB])
+], WorkspaceRepository);

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "clhq-dynamodb-module",
+  "version": "1.1.0-alpha.90",
+  "description": "Reusable DynamoDB service package for the monorepo",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/reacthub-pricematch/clhq-api-monorepo"
+  },
+  "registry": "https://registry.npmjs.org/",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "bugs": {
+    "url": "https://github.com/reacthub-pricematch/clhq-api-monorepo/issues"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "yarn exec tsc -p tsconfig.json",
+    "start": "nest start",
+    "start:dev": "env-cmd -f ../../.env.dev nest start --watch",
+    "start:debug": "nest start --debug --watch",
+    "start:prod": "env-cmd -f ../../.env.dev node dist/main",
+    "start:local": "env-cmd -f .env nest start --watch",
+    "test": "jest",
+    "version:upgrade:alpha": "standard-version --prerelease alpha",
+    "release": "npm publish --tag alpha",
+    "release:alpha": "npm publish --tag alpha",
+    "release:prealpha": "",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+    "clean:build": "rimraf .build",
+    "clean:dist": "rimraf dist",
+    "clean:webpack": "rimraf .webpack",
+    "clean:serverless": "rimraf .serverless",
+    "clean:all": "npm run clean:build&& npm run clean:dist&& npm run clean:webpack&& npm run clean:serverless",
+    "sls:deploy": "sls deploy",
+    "sls:deploy:dev": "env-cmd -f ../../.env.dev sls deploy --stage dev",
+    "sls:remove:dev": "env-cmd -f ../../.env.dev sls remove --stage dev",
+    "sls:offline": "sls offline",
+    "sls:package": "sls package",
+    "sls:package2": "npm run clean:all&& npm run sls:package",
+    "sls:remove": "sls remove"
+  },
+  "devDependencies": {
+    "@aws-sdk/client-dynamodb": "3.128.0",
+    "@aws-sdk/lib-dynamodb": "3.128.0",
+    "@aws-sdk/lib-storage": "3.128.0",
+    "@nestjs/common": "^11.1.5",
+    "@nestjs/config": "^4",
+    "@nestjs/core": "^11.1.5",
+    "@nestjs/platform-express": "^11.1.5",
+    "class-transformer": "0.5.1",
+    "class-validator": "0.14.2",
+    "serverless": "^4",
+    "standard-version": "^9.5.0"
+  }
+}