clhq-dynamodb-module 1.1.0-alpha.90

package/dist/entities/user.entity.d.ts

@@ -0,0 +1,32 @@
+export declare enum UserRole {
+    USER = "user",
+    ADMIN = "admin",
+    MODERATOR = "moderator"
+}
+export declare enum UserStatus {
+    ACTIVE = "active",
+    INACTIVE = "inactive",
+    SUSPENDED = "suspended",
+    DELETED = "deleted"
+}
+export declare class User {
+    id: string;
+    workspaceId: string;
+    email: string;
+    username?: string;
+    auth0UserId: string;
+    passwordHash: string;
+    emailVerified: boolean;
+    status: UserStatus;
+    role: UserRole;
+    isActive: boolean;
+    isEmailVerified: boolean;
+    verificationToken?: string;
+    stripeCustomerId?: string;
+    lastLoginAt?: string;
+    emailVerifiedAt?: string;
+    deletedAt?: string;
+    scheduledDeletionAt?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}

package/dist/entities/user.entity.js

@@ -0,0 +1,133 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.User = exports.UserStatus = exports.UserRole = void 0;
+const class_validator_1 = require("class-validator");
+var UserRole;
+(function (UserRole) {
+    UserRole["USER"] = "user";
+    UserRole["ADMIN"] = "admin";
+    UserRole["MODERATOR"] = "moderator";
+})(UserRole || (exports.UserRole = UserRole = {}));
+var UserStatus;
+(function (UserStatus) {
+    UserStatus["ACTIVE"] = "active";
+    UserStatus["INACTIVE"] = "inactive";
+    UserStatus["SUSPENDED"] = "suspended";
+    UserStatus["DELETED"] = "deleted";
+})(UserStatus || (exports.UserStatus = UserStatus = {}));
+class User {
+    id;
+    workspaceId = '';
+    email;
+    username;
+    auth0UserId;
+    passwordHash;
+    emailVerified = false;
+    status = UserStatus.ACTIVE;
+    role = UserRole.USER;
+    isActive = true;
+    isEmailVerified = false;
+    verificationToken;
+    stripeCustomerId;
+    lastLoginAt;
+    emailVerifiedAt;
+    deletedAt;
+    scheduledDeletionAt;
+    createdAt;
+    updatedAt;
+}
+exports.User = User;
+__decorate([
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], User.prototype, "id", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], User.prototype, "workspaceId", void 0);
+__decorate([
+    (0, class_validator_1.IsEmail)(),
+    __metadata("design:type", String)
+], User.prototype, "email", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", String)
+], User.prototype, "username", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], User.prototype, "auth0UserId", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], User.prototype, "passwordHash", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)(),
+    __metadata("design:type", Boolean)
+], User.prototype, "emailVerified", void 0);
+__decorate([
+    (0, class_validator_1.IsEnum)(UserStatus),
+    __metadata("design:type", String)
+], User.prototype, "status", void 0);
+__decorate([
+    (0, class_validator_1.IsEnum)(UserRole),
+    __metadata("design:type", String)
+], User.prototype, "role", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)(),
+    __metadata("design:type", Boolean)
+], User.prototype, "isActive", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)(),
+    __metadata("design:type", Boolean)
+], User.prototype, "isEmailVerified", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", String)
+], User.prototype, "verificationToken", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", String)
+], User.prototype, "stripeCustomerId", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", String)
+], User.prototype, "lastLoginAt", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", String)
+], User.prototype, "emailVerifiedAt", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", String)
+], User.prototype, "deletedAt", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", String)
+], User.prototype, "scheduledDeletionAt", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", String)
+], User.prototype, "createdAt", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", String)
+], User.prototype, "updatedAt", void 0);

package/dist/entities/workspace-member.entity.d.ts

@@ -0,0 +1,8 @@
+export declare class WorkspaceMember {
+    id: string;
+    workspaceId: string;
+    userId: string;
+    role?: string;
+    permissions?: string[];
+    joinedAt?: string;
+}

package/dist/entities/workspace-member.entity.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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceMember = void 0;
+const class_validator_1 = require("class-validator");
+class WorkspaceMember {
+    id;
+    workspaceId;
+    userId;
+    role;
+    permissions;
+    joinedAt;
+}
+exports.WorkspaceMember = WorkspaceMember;
+__decorate([
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], WorkspaceMember.prototype, "id", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], WorkspaceMember.prototype, "workspaceId", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], WorkspaceMember.prototype, "userId", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", String)
+], WorkspaceMember.prototype, "role", void 0);
+__decorate([
+    (0, class_validator_1.IsArray)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", Array)
+], WorkspaceMember.prototype, "permissions", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", String)
+], WorkspaceMember.prototype, "joinedAt", void 0);

package/dist/entities/workspace.entity.d.ts

@@ -0,0 +1,9 @@
+export declare class Workspace {
+    id: string;
+    name: string;
+    description?: string;
+    ownerId: string;
+    isShared: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+}

package/dist/entities/workspace.entity.js

@@ -0,0 +1,54 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Workspace = void 0;
+const class_validator_1 = require("class-validator");
+class Workspace {
+    id;
+    name;
+    description;
+    ownerId;
+    isShared = false;
+    createdAt;
+    updatedAt;
+}
+exports.Workspace = Workspace;
+__decorate([
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], Workspace.prototype, "id", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], Workspace.prototype, "name", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", String)
+], Workspace.prototype, "description", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], Workspace.prototype, "ownerId", void 0);
+__decorate([
+    (0, class_validator_1.IsBoolean)(),
+    __metadata("design:type", Boolean)
+], Workspace.prototype, "isShared", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", String)
+], Workspace.prototype, "createdAt", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", String)
+], Workspace.prototype, "updatedAt", void 0);

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './entities';
+export * from './repositories';
+export * from './common/enums';
+export { DynamoDbRepoModule } from './app.module';

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoDbRepoModule = void 0;
+__exportStar(require("./entities"), exports);
+__exportStar(require("./repositories"), exports);
+__exportStar(require("./common/enums"), exports);
+var app_module_1 = require("./app.module");
+Object.defineProperty(exports, "DynamoDbRepoModule", { enumerable: true, get: function () { return app_module_1.DynamoDbRepoModule; } });

package/dist/main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/main.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@nestjs/core");
+const app_module_1 = require("./app.module");
+async function bootstrap() {
+    const app = await core_1.NestFactory.create(app_module_1.DynamoDbRepoModule);
+    await app.listen(process.env.PORT ?? 8083);
+    console.log('DynamoDB Service is running on port: http://localhost:', process.env.PORT ?? 8083);
+}
+bootstrap();

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

@@ -0,0 +1,15 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { Asset, AssetType, AssetStatus } from '../entities/asset.entity';
+export declare class AssetRepository extends BaseRepository<Asset> {
+    constructor(dynamoDbClient: DynamoDB);
+    findByWorkspaceId(workspaceId: string): Promise<Asset[]>;
+    findByFileType(fileType: AssetType, workspaceId?: string): Promise<Asset[]>;
+    findByUploadStatus(status: AssetStatus): Promise<Asset[]>;
+    findByUploadedBy(userId: string): Promise<Asset[]>;
+    findByTags(tags: string[], workspaceId?: string): Promise<Asset[]>;
+    searchAssets(searchTerm: string, workspaceId?: string): Promise<Asset[]>;
+    updateUsage(assetId: string): Promise<void>;
+    getWorkspaceStorageUsage(workspaceId: string): Promise<number>;
+    findPublicAssets(fileType?: AssetType): Promise<Asset[]>;
+}

package/dist/repositories/asset.repository.js

@@ -0,0 +1,101 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetRepository = 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 AssetRepository = class AssetRepository extends base_repository_1.BaseRepository {
+    constructor(dynamoDbClient) {
+        super(dynamoDbClient, `asset-${process.env.STAGE}`);
+    }
+    async findByWorkspaceId(workspaceId) {
+        return this.find({ workspaceId });
+    }
+    async findByFileType(fileType, workspaceId) {
+        if (workspaceId) {
+            return this.find({ workspaceId, fileType });
+        }
+        return this.find({ fileType });
+    }
+    async findByUploadStatus(status) {
+        return this.find({ uploadStatus: status });
+    }
+    async findByUploadedBy(userId) {
+        return this.find({ uploadedBy: userId });
+    }
+    async findByTags(tags, workspaceId) {
+        const tagConditions = tags
+            .map((_, index) => `contains(tags, :tag${index})`)
+            .join(' OR ');
+        let filterExpression = `(${tagConditions})`;
+        const expressionAttributeValues = {};
+        tags.forEach((tag, index) => {
+            expressionAttributeValues[`:tag${index}`] = tag;
+        });
+        if (workspaceId) {
+            filterExpression += ' AND workspaceId = :workspaceId';
+            expressionAttributeValues[':workspaceId'] = workspaceId;
+        }
+        const result = await this.dynamoDb.scan({
+            TableName: this.tableName,
+            FilterExpression: filterExpression,
+            ExpressionAttributeValues: expressionAttributeValues,
+        });
+        return result.Items || [];
+    }
+    async searchAssets(searchTerm, workspaceId) {
+        let filterExpression = 'contains(#name, :searchTerm) OR contains(originalFilename, :searchTerm)';
+        const expressionAttributeNames = {
+            '#name': 'name',
+        };
+        const expressionAttributeValues = {
+            ':searchTerm': searchTerm,
+        };
+        if (workspaceId) {
+            filterExpression += ' AND workspaceId = :workspaceId';
+            expressionAttributeValues[':workspaceId'] = workspaceId;
+        }
+        const result = await this.dynamoDb.scan({
+            TableName: this.tableName,
+            FilterExpression: filterExpression,
+            ExpressionAttributeNames: expressionAttributeNames,
+            ExpressionAttributeValues: expressionAttributeValues,
+        });
+        return result.Items || [];
+    }
+    async updateUsage(assetId) {
+        await this.dynamoDb.update({
+            TableName: this.tableName,
+            Key: { id: assetId },
+            UpdateExpression: 'ADD usageCount :increment SET lastUsedAt = :timestamp',
+            ExpressionAttributeValues: {
+                ':increment': 1,
+                ':timestamp': new Date().toISOString(),
+            },
+        });
+    }
+    async getWorkspaceStorageUsage(workspaceId) {
+        const assets = await this.find({ workspaceId });
+        return assets.reduce((total, asset) => total + (asset.fileSize || 0), 0);
+    }
+    async findPublicAssets(fileType) {
+        if (fileType) {
+            return this.find({ isPublic: true, fileType });
+        }
+        return this.find({ isPublic: true });
+    }
+};
+exports.AssetRepository = AssetRepository;
+exports.AssetRepository = AssetRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [client_dynamodb_1.DynamoDB])
+], AssetRepository);

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

@@ -0,0 +1,31 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb';
+export interface IBaseRepository<T> {
+    create(item: T): Promise<T>;
+    findById(id: string): Promise<T | undefined>;
+    findAll(): Promise<T[]>;
+    update(id: string, item: Partial<T>): Promise<T>;
+    delete(id: string): Promise<void>;
+}
+export declare abstract class BaseRepository<T> implements IBaseRepository<T> {
+    protected readonly tableName: string;
+    protected readonly dynamoDb: DynamoDBDocument;
+    protected readonly dynamoDbClient: DynamoDB;
+    constructor(dynamoDbClient: DynamoDB, tableName: string);
+    create(item: T): Promise<T>;
+    findById(id: string): Promise<T | undefined>;
+    findAll(limit?: number): Promise<T[]>;
+    update(id: string, item: Partial<T>): Promise<T>;
+    delete(id: string): Promise<void>;
+    batchCreate(items: T[]): Promise<T[]>;
+    findAllPaginated(lastEvaluatedKey?: any, limit?: number): Promise<{
+        items: T[];
+        lastEvaluatedKey?: any;
+    }>;
+    exists(id: string): Promise<boolean>;
+    find(conditions: Partial<T>, options?: {
+        indexName?: string;
+        keyConditionExpression?: string;
+    }): Promise<T[]>;
+    count(): Promise<number>;
+}

package/dist/repositories/base.repository.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseRepository = void 0;
+const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
+const lib_dynamodb_2 = require("@aws-sdk/lib-dynamodb");
+class BaseRepository {
+    tableName;
+    dynamoDb;
+    dynamoDbClient;
+    constructor(dynamoDbClient, tableName) {
+        const marshallOptions = {
+            convertEmptyValues: false,
+            removeUndefinedValues: true,
+            convertClassInstanceToMap: false,
+        };
+        const unmarshallOptions = {
+            wrapNumbers: false,
+        };
+        const translateConfig = { marshallOptions, unmarshallOptions };
+        this.tableName = tableName;
+        this.dynamoDbClient = dynamoDbClient;
+        this.dynamoDb = lib_dynamodb_1.DynamoDBDocument.from(dynamoDbClient, translateConfig);
+    }
+    async create(item) {
+        const itemWithTimestamps = {
+            ...item,
+            createdAt: item.createdAt || new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+        const command = new lib_dynamodb_2.PutCommand({
+            TableName: this.tableName,
+            Item: itemWithTimestamps,
+            ConditionExpression: 'attribute_not_exists(id)',
+        });
+        await this.dynamoDb.send(command);
+        return itemWithTimestamps;
+    }
+    async findById(id) {
+        const command = new lib_dynamodb_2.GetCommand({
+            TableName: this.tableName,
+            Key: { id },
+        });
+        const result = await this.dynamoDb.send(command);
+        return result.Item;
+    }
+    async findAll(limit) {
+        const command = new lib_dynamodb_2.ScanCommand({
+            TableName: this.tableName,
+            Limit: limit,
+        });
+        const result = await this.dynamoDb.send(command);
+        return result.Items || [];
+    }
+    async update(id, item) {
+        const updateExpressions = [];
+        const expressionAttributeNames = {};
+        const expressionAttributeValues = {};
+        const itemWithTimestamp = {
+            ...item,
+            updatedAt: new Date().toISOString(),
+        };
+        Object.entries(itemWithTimestamp).forEach(([key, value]) => {
+            if (value !== undefined && key !== 'id') {
+                updateExpressions.push(`#${key} = :${key}`);
+                expressionAttributeNames[`#${key}`] = key;
+                expressionAttributeValues[`:${key}`] = value;
+            }
+        });
+        if (updateExpressions.length === 0) {
+            throw new Error('No valid fields to update');
+        }
+        const command = new lib_dynamodb_2.UpdateCommand({
+            TableName: this.tableName,
+            Key: { id },
+            UpdateExpression: `SET ${updateExpressions.join(', ')}`,
+            ExpressionAttributeNames: expressionAttributeNames,
+            ExpressionAttributeValues: expressionAttributeValues,
+            ReturnValues: 'ALL_NEW',
+            ConditionExpression: 'attribute_exists(id)',
+        });
+        const result = await this.dynamoDb.send(command);
+        return result.Attributes;
+    }
+    async delete(id) {
+        const command = new lib_dynamodb_2.DeleteCommand({
+            TableName: this.tableName,
+            Key: { id },
+            ConditionExpression: 'attribute_exists(id)',
+        });
+        await this.dynamoDb.send(command);
+    }
+    async batchCreate(items) {
+        const batchSize = 25;
+        const results = [];
+        for (let i = 0; i < items.length; i += batchSize) {
+            const batch = items.slice(i, i + batchSize);
+            const batchResults = await Promise.all(batch.map((item) => this.create(item)));
+            results.push(...batchResults);
+        }
+        return results;
+    }
+    async findAllPaginated(lastEvaluatedKey, limit = 50) {
+        const command = new lib_dynamodb_2.ScanCommand({
+            TableName: this.tableName,
+            Limit: limit,
+            ExclusiveStartKey: lastEvaluatedKey,
+        });
+        const result = await this.dynamoDb.send(command);
+        return {
+            items: result.Items || [],
+            lastEvaluatedKey: result.LastEvaluatedKey,
+        };
+    }
+    async exists(id) {
+        const item = await this.findById(id);
+        return !!item;
+    }
+    async find(conditions, options) {
+        if ((!conditions || Object.keys(conditions).length === 0) &&
+            !options?.keyConditionExpression) {
+            throw new Error('At least one condition or keyConditionExpression is required for find()');
+        }
+        const expressionAttributeNames = {};
+        const expressionAttributeValues = {};
+        const filterExpressions = [];
+        Object.entries(conditions).forEach(([key, value]) => {
+            filterExpressions.push(`#${key} = :${key}`);
+            expressionAttributeNames[`#${key}`] = key;
+            expressionAttributeValues[`:${key}`] = value;
+        });
+        if (options?.keyConditionExpression) {
+            const result = await this.dynamoDb.send(new lib_dynamodb_1.QueryCommand({
+                TableName: this.tableName,
+                IndexName: options.indexName,
+                KeyConditionExpression: options.keyConditionExpression,
+                FilterExpression: filterExpressions.length
+                    ? filterExpressions.join(' AND ')
+                    : undefined,
+                ExpressionAttributeNames: Object.keys(expressionAttributeNames).length
+                    ? expressionAttributeNames
+                    : undefined,
+                ExpressionAttributeValues: Object.keys(expressionAttributeValues)
+                    .length
+                    ? expressionAttributeValues
+                    : undefined,
+            }));
+            return result.Items || [];
+        }
+        const result = await this.dynamoDb.send(new lib_dynamodb_2.ScanCommand({
+            TableName: this.tableName,
+            FilterExpression: filterExpressions.length
+                ? filterExpressions.join(' AND ')
+                : undefined,
+            ExpressionAttributeNames: Object.keys(expressionAttributeNames).length
+                ? expressionAttributeNames
+                : undefined,
+            ExpressionAttributeValues: Object.keys(expressionAttributeValues).length
+                ? expressionAttributeValues
+                : undefined,
+        }));
+        return result.Items || [];
+    }
+    async count() {
+        const command = new lib_dynamodb_2.ScanCommand({
+            TableName: this.tableName,
+            Select: 'COUNT',
+        });
+        const result = await this.dynamoDb.send(command);
+        return result.Count || 0;
+    }
+}
+exports.BaseRepository = BaseRepository;

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

@@ -0,0 +1,9 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { BaseRepository } from './base.repository';
+import { ClipEffect } from '../entities/clip-effect.entity';
+export declare class ClipEffectRepository extends BaseRepository<ClipEffect> {
+    private readonly logger;
+    constructor(dynamoDbClient: DynamoDB);
+    findByClipId(clipId: string): Promise<ClipEffect[]>;
+    findByEffectId(effectId: string): Promise<ClipEffect[]>;
+}