@novha/anlia-core-lib 0.1.0 → 0.2.0

package/dist/src/s3/service/S3ServiceImpl.js

@@ -0,0 +1,104 @@
+"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.S3ServiceImpl = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_path_1 = require("node:path");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const common_1 = require("@nestjs/common");
+let S3ServiceImpl = class S3ServiceImpl {
+    constructor(options) {
+        this.bucket = options.bucket;
+        this.s3Client = new client_s3_1.S3Client({
+            region: options.region ?? process.env.AWS_REGION ?? 'us-east-1',
+            endpoint: options.endpoint || undefined,
+            forcePathStyle: options.forcePathStyle ?? false,
+        });
+    }
+    async uploadFile(request) {
+        const bucket = this.getBucketName();
+        const key = this.buildObjectKey(request.file.originalname, request.folder);
+        const contentType = request.file.mimetype || 'application/octet-stream';
+        try {
+            await this.s3Client.send(new client_s3_1.PutObjectCommand({
+                Bucket: bucket,
+                Key: key,
+                Body: request.file.buffer,
+                ContentType: contentType,
+                ContentLength: request.file.size,
+                Metadata: {
+                    originalname: request.file.originalname,
+                },
+            }));
+            return {
+                bucket,
+                key,
+                contentType,
+                size: request.file.size,
+            };
+        }
+        catch (error) {
+            console.error('Error uploading file to S3:', error);
+            throw new common_1.InternalServerErrorException('Unable to upload file to S3.');
+        }
+    }
+    async fetchFile(key) {
+        const bucket = this.getBucketName();
+        try {
+            const response = await this.s3Client.send(new client_s3_1.GetObjectCommand({
+                Bucket: bucket,
+                Key: key,
+            }));
+            if (!response.Body) {
+                throw new common_1.NotFoundException(`No file found for key: ${key}`);
+            }
+            return {
+                body: Buffer.from(await response.Body.transformToByteArray()),
+                contentType: response.ContentType,
+                contentLength: response.ContentLength,
+                fileName: response.Metadata?.originalname ?? this.getFileNameFromKey(key),
+            };
+        }
+        catch (error) {
+            if (error instanceof common_1.NotFoundException) {
+                throw error;
+            }
+            if (error instanceof Error && ['NoSuchKey', 'NotFound'].includes(error.name)) {
+                throw new common_1.NotFoundException(`No file found for key: ${key}`);
+            }
+            throw new common_1.InternalServerErrorException('Unable to fetch file from S3.');
+        }
+    }
+    getBucketName() {
+        return this.bucket;
+    }
+    buildObjectKey(originalName, folder) {
+        const extension = (0, node_path_1.extname)(originalName);
+        const baseName = (0, node_path_1.basename)(originalName, extension)
+            .trim()
+            .replace(/[^a-zA-Z0-9_-]+/g, '-')
+            .replace(/^-+|-+$/g, '') || 'file';
+        const normalizedFolder = folder
+            ?.trim()
+            .replace(/^\/+|\/+$/g, '')
+            .replace(/\.\./g, '');
+        const fileName = `${baseName}-${(0, node_crypto_1.randomUUID)()}${extension}`;
+        return normalizedFolder ? `${normalizedFolder}/${fileName}` : fileName;
+    }
+    getFileNameFromKey(key) {
+        return key.split('/').at(-1) ?? key;
+    }
+};
+exports.S3ServiceImpl = S3ServiceImpl;
+exports.S3ServiceImpl = S3ServiceImpl = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [Object])
+], S3ServiceImpl);

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@novha/anlia-core-lib",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "private": false,
-  "main": "dist/index.js",
-  "types": "dist/types/index.d.ts",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
   "bin": {
     "anlia-core-lib.js": "bin/anlia-core-lib.js"
   },
@@ -14,17 +14,22 @@
     "cdk": "cdk"
   },
   "devDependencies": {
+    "@types/aws-lambda": "^8.10.162",
     "@types/jest": "^29.5.12",
     "@types/node": "20.12.7",
     "aws-cdk": "2.142.1",
+    "esbuild": "^0.28.1",
     "jest": "^29.7.0",
     "ts-jest": "^29.1.2",
     "ts-node": "^10.9.2",
     "typescript": "~5.4.5"
   },
   "dependencies": {
+    "@aws-sdk/client-dynamodb": "^3.1095.0",
     "@aws-sdk/client-eventbridge": "^3.1090.0",
+    "@aws-sdk/client-s3": "^3.1095.0",
     "@aws-sdk/client-secrets-manager": "^3.721.0",
+    "@aws-sdk/lib-dynamodb": "^3.1095.0",
     "@nestjs/common": "^11.1.28",
     "@nestjs/core": "^11.1.28",
     "aws-cdk-lib": "^2.261.0",

package/src/dynamoDb/DynamoDbModule.ts

@@ -0,0 +1,18 @@
+import { Module } from '@nestjs/common';
+import { DynamoDbSymbols } from './ioc';
+import { DynamoDbServiceImpl } from './service/DynamoDbServiceImpl';
+
+@Module({
+	providers: [
+		{
+			provide: DynamoDbSymbols.DynamoDbService,
+			useFactory: () =>
+				new DynamoDbServiceImpl({
+					region: process.env.AWS_REGION ?? 'us-east-1',
+					endpoint: process.env.DYNAMODB_ENDPOINT,
+				}),
+		},
+	],
+	exports: [DynamoDbSymbols.DynamoDbService],
+})
+export class DynamoDbModule {}

package/src/dynamoDb/index.ts

@@ -0,0 +1,4 @@
+export * from "./DynamoDbModule";
+export * from "./ioc";
+export type { IDynamoDbService, QueryParams, ScanParams, UpdateParams } from "./service/DynamoDbService";
+export type { DynamoDbOptions } from "./service/DynamoDbServiceImpl";

package/src/dynamoDb/ioc/index.ts

@@ -0,0 +1,3 @@
+export const DynamoDbSymbols = {
+	DynamoDbService: Symbol('DynamoDbService'),
+};

package/src/dynamoDb/service/DynamoDbService.ts

@@ -0,0 +1,37 @@
+export interface QueryParams {
+	tableName: string;
+	keyConditionExpression: string;
+	expressionAttributeValues: Record<string, unknown>;
+	expressionAttributeNames?: Record<string, string>;
+	filterExpression?: string;
+	indexName?: string;
+	limit?: number;
+	exclusiveStartKey?: Record<string, unknown>;
+}
+
+export interface ScanParams {
+	tableName: string;
+	filterExpression?: string;
+	expressionAttributeValues?: Record<string, unknown>;
+	expressionAttributeNames?: Record<string, string>;
+	limit?: number;
+	exclusiveStartKey?: Record<string, unknown>;
+}
+
+export interface UpdateParams {
+	tableName: string;
+	key: Record<string, unknown>;
+	updateExpression: string;
+	expressionAttributeValues: Record<string, unknown>;
+	expressionAttributeNames?: Record<string, string>;
+	conditionExpression?: string;
+}
+
+export interface IDynamoDbService {
+	get<T>(tableName: string, key: Record<string, unknown>): Promise<T | undefined>;
+	put(tableName: string, item: Record<string, unknown>): Promise<void>;
+	update(params: UpdateParams): Promise<void>;
+	delete(tableName: string, key: Record<string, unknown>): Promise<void>;
+	query<T>(params: QueryParams): Promise<T[]>;
+	scan<T>(params: ScanParams): Promise<T[]>;
+}

package/src/dynamoDb/service/DynamoDbServiceImpl.ts

@@ -0,0 +1,132 @@
+import { Injectable, InternalServerErrorException, NotFoundException } from '@nestjs/common';
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import {
+	DynamoDBDocumentClient,
+	GetCommand,
+	PutCommand,
+	UpdateCommand,
+	DeleteCommand,
+	QueryCommand,
+	ScanCommand,
+} from '@aws-sdk/lib-dynamodb';
+import type { IDynamoDbService, QueryParams, ScanParams, UpdateParams } from './DynamoDbService';
+
+export interface DynamoDbOptions {
+	region?: string;
+	/** Local DynamoDB endpoint, e.g. http://localhost:8000 */
+	endpoint?: string;
+}
+
+@Injectable()
+export class DynamoDbServiceImpl implements IDynamoDbService {
+	private readonly client: DynamoDBDocumentClient;
+
+	constructor(options: DynamoDbOptions = {}) {
+		const base = new DynamoDBClient({
+			region: options.region ?? process.env.AWS_REGION ?? 'us-east-1',
+			endpoint: options.endpoint || undefined,
+		});
+		this.client = DynamoDBDocumentClient.from(base, {
+			marshallOptions: { removeUndefinedValues: true },
+		});
+	}
+
+	async get<T>(tableName: string, key: Record<string, unknown>): Promise<T | undefined> {
+		try {
+			const { Item } = await this.client.send(
+				new GetCommand({ TableName: tableName, Key: key }),
+			);
+			return Item as T | undefined;
+		} catch (error) {
+			throw new InternalServerErrorException(
+				`DynamoDB get failed for table "${tableName}": ${(error as Error).message}`,
+			);
+		}
+	}
+
+	async put(tableName: string, item: Record<string, unknown>): Promise<void> {
+		try {
+			await this.client.send(new PutCommand({ TableName: tableName, Item: item }));
+		} catch (error) {
+			throw new InternalServerErrorException(
+				`DynamoDB put failed for table "${tableName}": ${(error as Error).message}`,
+			);
+		}
+	}
+
+	async update(params: UpdateParams): Promise<void> {
+		try {
+			await this.client.send(
+				new UpdateCommand({
+					TableName: params.tableName,
+					Key: params.key,
+					UpdateExpression: params.updateExpression,
+					ExpressionAttributeValues: params.expressionAttributeValues,
+					ExpressionAttributeNames: params.expressionAttributeNames,
+					ConditionExpression: params.conditionExpression,
+				}),
+			);
+		} catch (error) {
+			if ((error as Error).name === 'ConditionalCheckFailedException') {
+				throw new NotFoundException(
+					`Item not found in table "${params.tableName}".`,
+				);
+			}
+			throw new InternalServerErrorException(
+				`DynamoDB update failed for table "${params.tableName}": ${(error as Error).message}`,
+			);
+		}
+	}
+
+	async delete(tableName: string, key: Record<string, unknown>): Promise<void> {
+		try {
+			await this.client.send(new DeleteCommand({ TableName: tableName, Key: key }));
+		} catch (error) {
+			throw new InternalServerErrorException(
+				`DynamoDB delete failed for table "${tableName}": ${(error as Error).message}`,
+			);
+		}
+	}
+
+	async query<T>(params: QueryParams): Promise<T[]> {
+		try {
+			const { Items } = await this.client.send(
+				new QueryCommand({
+					TableName: params.tableName,
+					IndexName: params.indexName,
+					KeyConditionExpression: params.keyConditionExpression,
+					FilterExpression: params.filterExpression,
+					ExpressionAttributeValues: params.expressionAttributeValues,
+					ExpressionAttributeNames: params.expressionAttributeNames,
+					Limit: params.limit,
+					ExclusiveStartKey: params.exclusiveStartKey as Record<string, unknown>,
+				}),
+			);
+			return (Items ?? []) as T[];
+		} catch (error) {
+			throw new InternalServerErrorException(
+				`DynamoDB query failed for table "${params.tableName}": ${(error as Error).message}`,
+			);
+		}
+	}
+
+	async scan<T>(params: ScanParams): Promise<T[]> {
+		try {
+			const { Items } = await this.client.send(
+				new ScanCommand({
+					TableName: params.tableName,
+					FilterExpression: params.filterExpression,
+					ExpressionAttributeValues: params.expressionAttributeValues,
+					ExpressionAttributeNames: params.expressionAttributeNames,
+					Limit: params.limit,
+					ExclusiveStartKey: params.exclusiveStartKey as Record<string, unknown>,
+				}),
+			);
+			return (Items ?? []) as T[];
+		} catch (error) {
+			throw new InternalServerErrorException(
+				`DynamoDB scan failed for table "${params.tableName}": ${(error as Error).message}`,
+			);
+		}
+	}
+}

package/src/eventBridge/EventBridgeModule.ts

@@ -6,7 +6,12 @@ import { EventBridgeSymbols } from "./ioc";
 	providers: [
 		{
 			provide: EventBridgeSymbols.EventBridgeService,
-			useClass: EventBridgeServiceImpl,
+			useFactory: () =>
+				new EventBridgeServiceImpl({
+					eventBusName: process.env.EVENT_BUS_NAME ?? "default",
+					source: process.env.EVENT_SOURCE ?? "com.anlia",
+					region: process.env.AWS_REGION ?? "us-east-1",
+				}),
 		},
 	],
 	exports: [EventBridgeSymbols.EventBridgeService],

package/src/handlers/EventLoggerHandler.ts

@@ -0,0 +1,11 @@
+import { SQSEvent } from "aws-lambda";
+
+export const handler = async (event: SQSEvent): Promise<void> => {
+    for (const record of event.Records) {
+        console.log(JSON.stringify({
+            messageId: record.messageId,
+            eventSource: record.eventSource,
+            body: JSON.parse(record.body),
+        }));
+    }
+};

package/src/index.ts

@@ -1,4 +1,6 @@
 export * from "./events";
 export * from "./enums";
 export * from "./orders";
-export * from "./interfaces";
+export * from "./interfaces";
+export * from "./s3";
+export * from "./dynamoDb";

package/src/orders/index.ts

@@ -4,4 +4,5 @@ export * from "./domain/Enums";
 export * from "./ioc";
 export * from "./OrderModule";
 export * from "./domain/posDto/SquareOrder";
-export { SquareOrderServiceImpl as SquareOrderService } from "./services/square/SquareOrderServiceImpl";
+export { SquareOrderServiceImpl as SquareOrderService } from "./services/square/SquareOrderServiceImpl";
+export type { ISquareOrderService } from "./services/square/SquareOrderService";

package/src/s3/S3Module.ts

@@ -0,0 +1,20 @@
+import { Module } from '@nestjs/common';
+import { S3Symbols } from './ioc';
+import { S3ServiceImpl } from './service/S3ServiceImpl';
+
+@Module({
+	providers: [
+		{
+			provide: S3Symbols.S3Service,
+			useFactory: () =>
+				new S3ServiceImpl({
+					bucket: process.env.AWS_S3_BUCKET ?? '',
+					region: process.env.AWS_REGION ?? 'us-east-1',
+					endpoint: process.env.AWS_S3_ENDPOINT,
+					forcePathStyle: process.env.AWS_S3_FORCE_PATH_STYLE === 'true',
+				}),
+		},
+	],
+	exports: [S3Symbols.S3Service],
+})
+export class S3Module {}

package/src/s3/index.ts

@@ -0,0 +1,4 @@
+export * from "./S3Module";
+export * from "./ioc";
+export type { S3Service, S3UploadFile, UploadS3FileRequest, UploadS3FileResponse, FetchS3FileResponse } from "./service/S3Service";
+export type { S3Options } from "./service/S3ServiceImpl";

package/src/s3/ioc/index.ts

@@ -0,0 +1,3 @@
+export const S3Symbols = {
+	S3Service: Symbol('S3Service'),
+};

package/src/s3/service/S3Service.ts

@@ -0,0 +1,30 @@
+export type S3UploadFile = {
+	buffer: Buffer;
+	originalname: string;
+	mimetype: string;
+	size: number;
+};
+
+export type UploadS3FileRequest = {
+	file: S3UploadFile;
+	folder?: string;
+};
+
+export type UploadS3FileResponse = {
+	bucket: string;
+	key: string;
+	contentType: string;
+	size: number;
+};
+
+export type FetchS3FileResponse = {
+	body: Buffer;
+	contentType?: string;
+	contentLength?: number;
+	fileName: string;
+};
+
+export interface S3Service {
+	uploadFile(request: UploadS3FileRequest): Promise<UploadS3FileResponse>;
+	fetchFile(key: string): Promise<FetchS3FileResponse>;
+}

package/src/s3/service/S3ServiceImpl.ts

@@ -0,0 +1,116 @@
+import { randomUUID } from 'node:crypto';
+import { basename, extname } from 'node:path';
+import { GetObjectCommand, PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
+import { Injectable, InternalServerErrorException, NotFoundException } from '@nestjs/common';
+import type { FetchS3FileResponse, S3Service, UploadS3FileRequest, UploadS3FileResponse } from './S3Service';
+
+export interface S3Options {
+	bucket: string;
+	region?: string;
+	endpoint?: string;
+	forcePathStyle?: boolean;
+}
+
+@Injectable()
+export class S3ServiceImpl implements S3Service {
+	private readonly s3Client: S3Client;
+	private readonly bucket: string;
+
+	constructor(options: S3Options) {
+		this.bucket = options.bucket;
+		this.s3Client = new S3Client({
+			region: options.region ?? process.env.AWS_REGION ?? 'us-east-1',
+			endpoint: options.endpoint || undefined,
+			forcePathStyle: options.forcePathStyle ?? false,
+		});
+	}
+
+	async uploadFile(request: UploadS3FileRequest): Promise<UploadS3FileResponse> {
+		const bucket = this.getBucketName();
+		const key = this.buildObjectKey(request.file.originalname, request.folder);
+		const contentType = request.file.mimetype || 'application/octet-stream';
+
+		try {
+			await this.s3Client.send(
+				new PutObjectCommand({
+					Bucket: bucket,
+					Key: key,
+					Body: request.file.buffer,
+					ContentType: contentType,
+					ContentLength: request.file.size,
+					Metadata: {
+						originalname: request.file.originalname,
+					},
+				}),
+			);
+
+			return {
+				bucket,
+				key,
+				contentType,
+				size: request.file.size,
+			};
+		} catch (error) {
+			console.error('Error uploading file to S3:', error);
+			throw new InternalServerErrorException('Unable to upload file to S3.');
+		}
+	}
+
+	async fetchFile(key: string): Promise<FetchS3FileResponse> {
+		const bucket = this.getBucketName();
+
+		try {
+			const response = await this.s3Client.send(
+				new GetObjectCommand({
+					Bucket: bucket,
+					Key: key,
+				}),
+			);
+
+			if (!response.Body) {
+				throw new NotFoundException(`No file found for key: ${key}`);
+			}
+
+			return {
+				body: Buffer.from(await response.Body.transformToByteArray()),
+				contentType: response.ContentType,
+				contentLength: response.ContentLength,
+				fileName: response.Metadata?.originalname ?? this.getFileNameFromKey(key),
+			};
+		} catch (error) {
+			if (error instanceof NotFoundException) {
+				throw error;
+			}
+
+			if (error instanceof Error && ['NoSuchKey', 'NotFound'].includes(error.name)) {
+				throw new NotFoundException(`No file found for key: ${key}`);
+			}
+
+			throw new InternalServerErrorException('Unable to fetch file from S3.');
+		}
+	}
+
+	private getBucketName(): string {
+		return this.bucket;
+	}
+
+	private buildObjectKey(originalName: string, folder?: string): string {
+		const extension = extname(originalName);
+		const baseName =
+			basename(originalName, extension)
+				.trim()
+				.replace(/[^a-zA-Z0-9_-]+/g, '-')
+				.replace(/^-+|-+$/g, '') || 'file';
+		const normalizedFolder = folder
+			?.trim()
+			.replace(/^\/+|\/+$/g, '')
+			.replace(/\.\./g, '');
+		const fileName = `${baseName}-${randomUUID()}${extension}`;
+
+		return normalizedFolder ? `${normalizedFolder}/${fileName}` : fileName;
+	}
+
+	private getFileNameFromKey(key: string): string {
+		return key.split('/').at(-1) ?? key;
+	}
+}

package/tsconfig.json

@@ -2,7 +2,6 @@
   "compilerOptions": {
     "target": "ES2020",
     "module": "commonjs",
-    "moduleResolution": "node",
     "lib": ["es2020"],
     "declaration": true,
     "strict": true,
@@ -12,7 +11,7 @@
     "emitDecoratorMetadata": true,
     "skipLibCheck": true,
     "types": ["node", "jest"],
-    "outDir": "dist"
+    "outDir": "dist",
   },
   "include": ["cdk/**/*.ts", "src/**/*.ts"]
 }

package/cdk/lib/infrastructure.ts

@@ -1,37 +0,0 @@
-import { CfnOutput, Stack } from "aws-cdk-lib";
-import { Construct } from "constructs";
-import { EventBus } from "aws-cdk-lib/aws-events";
-import { Bucket } from "aws-cdk-lib/aws-s3";
-import { CommonProps } from "../bin/project-names";
-
-export class InfrastructureStack extends Stack {
-    constructor(scope: Construct, id: string, props: CommonProps) {
-        super(scope, id, props);
-
-        const eventBus = new EventBus(this, "EventBus", {
-            eventBusName: `${props.projectName}-${props.stage}-event-bus`,
-        });
-
-        const bucket = new Bucket(this, "Bucket");
-
-        new CfnOutput(this, "EventBusArn", {
-            value: eventBus.eventBusArn,
-            exportName: `${props.projectName}-${props.stage}-event-bus-arn`,
-        });
-
-        new CfnOutput(this, "EventBusName", {
-            value: eventBus.eventBusName,
-            exportName: `${props.projectName}-${props.stage}-event-bus-name`,
-        });
-
-        new CfnOutput(this, "BucketArn", {
-            value: bucket.bucketArn,
-            exportName: `${props.projectName}-${props.stage}-bucket-arn`,
-        });
-
-        new CfnOutput(this, "BucketName", {
-            value: bucket.bucketName,
-            exportName: `${props.projectName}-${props.stage}-bucket-name`,
-        });
-    }
-}