prime-sdk 2.1.1 → 2.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prime-sdk",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "description": "swiss army knife",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -23,10 +23,12 @@
   },
   "dependencies": {
     "@aws-sdk/client-kms": "^3.606.0",
+    "@aws-sdk/client-bedrock-runtime": "^3.620.0",
     "@aws-sdk/client-s3": "^3.572.0",
     "@aws-sdk/client-ses": "^3.572.0",
     "@aws-sdk/client-sns": "^3.572.0",
     "@aws-sdk/client-sqs": "^3.569.0",
+    "@aws-sdk/client-textract": "^3.620.0",
     "@aws-sdk/s3-request-presigner": "^3.572.0",
     "@nestjs/common": "^11.1.5",
     "@nestjs/config": "^4.0.2",

package/src/app.module.ts

@@ -9,6 +9,7 @@ import { CacheModule } from './lib/cache/cache.module';
 import { TypeRedis } from './external/redis/types/ioredis.types';
 import { ICache } from './lib/cache/interfaces/cache.interface';
 import { Cache } from './lib/cache/cache';
+import { DocumentsModule } from './lib/documents/documents.module';
 
 //Example
 @Module({
@@ -53,6 +54,16 @@ import { Cache } from './lib/cache/cache';
       endpoint: 'http://localhost:4566/',
       region: 'us-east-1',
     }),
+    DocumentsModule.forRoot({
+      bedrock: {
+        region: 'us-east-1',
+        endpoint: 'http://localhost:4566/',
+        credentials: {
+          accessKeyId: '',
+          secretAccessKey: '',
+        },
+      },
+    }),
     CacheModule.forRoot({
       type: TypeRedis.SIMPLE,
       connection: {

package/src/external/aws/bedrock/bedrock.provider.ts

@@ -0,0 +1,39 @@
+import { BedrockRuntimeClient } from '@aws-sdk/client-bedrock-runtime';
+import { DynamicModule } from '@nestjs/common';
+
+export type BedrockSetup = {
+  region: string;
+  endpoint?: string;
+  credentials: {
+    accessKeyId: string;
+    secretAccessKey: string;
+  };
+};
+
+const BedrockProvider = (params: BedrockSetup) => {
+  return {
+    provide: 'CONNECTION_BEDROCK_RUNTIME',
+    useFactory: () => {
+      return new BedrockRuntimeClient({
+        credentials: {
+          accessKeyId: params.credentials.accessKeyId,
+          secretAccessKey: params.credentials.secretAccessKey,
+        },
+        ...(params.endpoint && { endpoint: params.endpoint }),
+        region: params.region,
+      });
+    },
+  };
+};
+
+export class BedrockModule {
+  static forRoot(params: BedrockSetup): DynamicModule {
+    const provider = BedrockProvider(params);
+
+    return {
+      module: BedrockModule,
+      providers: [provider],
+      exports: [provider],
+    };
+  }
+}

package/src/external/aws/bedrock/bedrock.service.ts

@@ -0,0 +1,29 @@
+import { Inject, Injectable } from '@nestjs/common';
+import {
+  BedrockRuntimeClient,
+  InvokeModelCommand,
+  InvokeModelCommandOutput,
+} from '@aws-sdk/client-bedrock-runtime';
+import { IBedrock } from '../../../lib/documents/interfaces/documents.interface';
+import { InvokeModelPayload } from '../../../lib/documents/types/bedrock.type';
+
+@Injectable()
+export class Bedrock implements IBedrock {
+  constructor(
+    @Inject('CONNECTION_BEDROCK_RUNTIME')
+    private readonly client: BedrockRuntimeClient,
+  ) {}
+
+  async invokeModel(
+    payload: InvokeModelPayload,
+  ): Promise<InvokeModelCommandOutput> {
+    const command = new InvokeModelCommand({
+      body: payload.body,
+      modelId: payload.modelId,
+      contentType: payload.contentType || 'application/json',
+      accept: payload.accept || 'application/json',
+    });
+
+    return await this.client.send(command);
+  }
+}

package/src/external/aws/s3/s3.service.ts

@@ -34,6 +34,10 @@ export class S3 implements IStorage {
       Bucket: file.bucket,
       Key: `${file.path}/${file.nameFile}`,
       Body: file.file,
+      ...(file.metadata && { Metadata: file.metadata }),
+      ...(file.tagging && {
+        Tagging: file.tagging,
+      }),
     });
 
     const response = await this.client.send(command);

package/src/external/aws/textract/textract.provider.ts

@@ -0,0 +1,39 @@
+import { TextractClient } from '@aws-sdk/client-textract';
+import { DynamicModule } from '@nestjs/common';
+
+export type TextractSetup = {
+  region: string;
+  endpoint?: string;
+  credentials: {
+    accessKeyId: string;
+    secretAccessKey: string;
+  };
+};
+
+const TextractProvider = (params: TextractSetup) => {
+  return {
+    provide: 'CONNECTION_TEXTRACT',
+    useFactory: () => {
+      return new TextractClient({
+        credentials: {
+          accessKeyId: params.credentials.accessKeyId,
+          secretAccessKey: params.credentials.secretAccessKey,
+        },
+        ...(params.endpoint && { endpoint: params.endpoint }),
+        region: params.region,
+      });
+    },
+  };
+};
+
+export class TextractModule {
+  static forRoot(params: TextractSetup): DynamicModule {
+    const provider = TextractProvider(params);
+
+    return {
+      module: TextractModule,
+      providers: [provider],
+      exports: [provider],
+    };
+  }
+}

package/src/external/aws/textract/textract.service.ts

@@ -0,0 +1,167 @@
+import { Inject, Injectable } from '@nestjs/common';
+import {
+  AnalyzeDocumentCommand,
+  AnalyzeDocumentCommandOutput,
+  DetectDocumentTextCommand,
+  DetectDocumentTextCommandOutput,
+  StartDocumentAnalysisCommand,
+  StartDocumentAnalysisCommandOutput,
+  GetDocumentAnalysisCommand,
+  GetDocumentAnalysisCommandOutput,
+  StartDocumentTextDetectionCommand,
+  StartDocumentTextDetectionCommandOutput,
+  GetDocumentTextDetectionCommand,
+  GetDocumentTextDetectionCommandOutput,
+  Document,
+  TextractClient,
+} from '@aws-sdk/client-textract';
+import { ITextract } from '../../../lib/documents/interfaces/documents.interface';
+import {
+  AnalyzeDocumentInput,
+  DetectDocumentTextBytesInput,
+  DetectDocumentTextS3Input,
+  StartDocumentAnalysisInput,
+  GetDocumentAnalysisInput,
+  StartDocumentTextDetectionInput,
+  GetDocumentTextDetectionInput,
+} from '../../../lib/documents/types/textract.type';
+
+@Injectable()
+export class Textract implements ITextract {
+  constructor(
+    @Inject('CONNECTION_TEXTRACT') private readonly client: TextractClient,
+  ) {}
+
+  async detectDocumentTextBytes(
+    input: DetectDocumentTextBytesInput,
+  ): Promise<DetectDocumentTextCommandOutput> {
+    const document: Document = { Bytes: input.bytes };
+    const command = new DetectDocumentTextCommand({ Document: document });
+    return await this.client.send(command);
+  }
+
+  async detectDocumentTextS3(
+    input: DetectDocumentTextS3Input,
+  ): Promise<DetectDocumentTextCommandOutput> {
+    const document: Document = {
+      S3Object: { Bucket: input.bucket, Name: input.name },
+    };
+    const command = new DetectDocumentTextCommand({ Document: document });
+    return await this.client.send(command);
+  }
+
+  async analyzeDocument(
+    input: AnalyzeDocumentInput,
+  ): Promise<AnalyzeDocumentCommandOutput> {
+    const document: Document = input.bytes
+      ? { Bytes: input.bytes }
+      : { S3Object: { Bucket: input.bucket, Name: input.name } };
+
+    const command = new AnalyzeDocumentCommand({
+      Document: document,
+      FeatureTypes: input.featureTypes,
+      ...(input.queriesConfig && { QueriesConfig: input.queriesConfig }),
+      ...(input.adaptersConfig && { AdaptersConfig: input.adaptersConfig }),
+      ...(input.humanLoopConfig && { HumanLoopConfig: input.humanLoopConfig }),
+    });
+
+    return await this.client.send(command);
+  }
+
+  async startDocumentAnalysis(
+    input: StartDocumentAnalysisInput,
+  ): Promise<StartDocumentAnalysisCommandOutput> {
+    const command = new StartDocumentAnalysisCommand({
+      DocumentLocation: {
+        S3Object: {
+          Bucket: input.bucket,
+          Name: input.name,
+          ...(input.version && { Version: input.version }),
+        },
+      },
+      FeatureTypes: input.featureTypes,
+      ...(input.queriesConfig && { QueriesConfig: input.queriesConfig }),
+      ...(input.adaptersConfig && { AdaptersConfig: input.adaptersConfig }),
+      ...(input.clientRequestToken && {
+        ClientRequestToken: input.clientRequestToken,
+      }),
+      ...(input.jobTag && { JobTag: input.jobTag }),
+      ...(input.notificationChannel && {
+        NotificationChannel: {
+          SNSTopicArn: input.notificationChannel.snsTopicArn,
+          RoleArn: input.notificationChannel.roleArn,
+        },
+      }),
+      ...(input.outputConfig && {
+        OutputConfig: {
+          S3Bucket: input.outputConfig.s3Bucket,
+          ...(input.outputConfig.s3Prefix && {
+            S3Prefix: input.outputConfig.s3Prefix,
+          }),
+        },
+      }),
+      ...(input.kmsKeyId && { KMSKeyId: input.kmsKeyId }),
+    });
+
+    return await this.client.send(command);
+  }
+
+  async getDocumentAnalysis(
+    input: GetDocumentAnalysisInput,
+  ): Promise<GetDocumentAnalysisCommandOutput> {
+    const command = new GetDocumentAnalysisCommand({
+      JobId: input.jobId,
+      ...(input.maxResults && { MaxResults: input.maxResults }),
+      ...(input.nextToken && { NextToken: input.nextToken }),
+    });
+
+    return await this.client.send(command);
+  }
+
+  async startDocumentTextDetection(
+    input: StartDocumentTextDetectionInput,
+  ): Promise<StartDocumentTextDetectionCommandOutput> {
+    const command = new StartDocumentTextDetectionCommand({
+      DocumentLocation: {
+        S3Object: {
+          Bucket: input.bucket,
+          Name: input.name,
+          ...(input.version && { Version: input.version }),
+        },
+      },
+      ...(input.clientRequestToken && {
+        ClientRequestToken: input.clientRequestToken,
+      }),
+      ...(input.jobTag && { JobTag: input.jobTag }),
+      ...(input.notificationChannel && {
+        NotificationChannel: {
+          SNSTopicArn: input.notificationChannel.snsTopicArn,
+          RoleArn: input.notificationChannel.roleArn,
+        },
+      }),
+      ...(input.outputConfig && {
+        OutputConfig: {
+          S3Bucket: input.outputConfig.s3Bucket,
+          ...(input.outputConfig.s3Prefix && {
+            S3Prefix: input.outputConfig.s3Prefix,
+          }),
+        },
+      }),
+      ...(input.kmsKeyId && { KMSKeyId: input.kmsKeyId }),
+    });
+
+    return await this.client.send(command);
+  }
+
+  async getDocumentTextDetection(
+    input: GetDocumentTextDetectionInput,
+  ): Promise<GetDocumentTextDetectionCommandOutput> {
+    const command = new GetDocumentTextDetectionCommand({
+      JobId: input.jobId,
+      ...(input.maxResults && { MaxResults: input.maxResults }),
+      ...(input.nextToken && { NextToken: input.nextToken }),
+    });
+
+    return await this.client.send(command);
+  }
+}

package/src/index.ts

@@ -21,6 +21,12 @@ import { ICrypto } from './lib/crypto/interfaces/crypto.interface';
 import { CacheModule } from './lib/cache/cache.module';
 import { Cache } from './lib/cache/cache';
 import { ICache } from './lib/cache/interfaces/cache.interface';
+import { DocumentsModule } from './lib/documents/documents.module';
+import { Documents } from './lib/documents/documents';
+import {
+  IBedrock,
+  ITextract,
+} from './lib/documents/interfaces/documents.interface';
 import {
   SimpleRedisSetup,
   ClusterRedisSetup,
@@ -47,6 +53,10 @@ export {
   CacheModule,
   Cache,
   ICache,
+  DocumentsModule,
+  Documents,
+  IBedrock,
+  ITextract,
   SimpleRedisSetup,
   ClusterRedisSetup,
   TypeRedis,

package/src/lib/documents/documents.module.ts

@@ -0,0 +1,26 @@
+import { DynamicModule, Module } from '@nestjs/common';
+import {
+  BedrockModule as BedrockProviderModule,
+  BedrockSetup,
+} from '../../external/aws/bedrock/bedrock.provider';
+import { Bedrock as BedrockService } from '../../external/aws/bedrock/bedrock.service';
+import { TextractSetup } from '../../external/aws/textract/textract.provider';
+import { Documents } from './documents';
+import { IBedrock } from './interfaces/documents.interface';
+
+export type DocumentsSetup = {
+  bedrock: BedrockSetup;
+  textract?: TextractSetup;
+};
+
+@Module({})
+export class DocumentsModule {
+  static forRoot(params: DocumentsSetup): DynamicModule {
+    return {
+      module: DocumentsModule,
+      imports: [BedrockProviderModule.forRoot(params.bedrock)],
+      providers: [Documents, { provide: IBedrock, useClass: BedrockService }],
+      exports: [Documents, { provide: IBedrock, useClass: BedrockService }],
+    };
+  }
+}

package/src/lib/documents/documents.ts

@@ -0,0 +1,83 @@
+import { Inject, Injectable, Optional } from '@nestjs/common';
+import { IBedrock, ITextract } from './interfaces/documents.interface';
+import { InvokeModelCommandOutput } from '@aws-sdk/client-bedrock-runtime';
+import {
+  AnalyzeDocumentCommandOutput,
+  DetectDocumentTextCommandOutput,
+  StartDocumentAnalysisCommandOutput,
+  GetDocumentAnalysisCommandOutput,
+  StartDocumentTextDetectionCommandOutput,
+  GetDocumentTextDetectionCommandOutput,
+} from '@aws-sdk/client-textract';
+import { InvokeModelPayload } from './types/bedrock.type';
+import {
+  AnalyzeDocumentInput,
+  DetectDocumentTextBytesInput,
+  DetectDocumentTextS3Input,
+  StartDocumentAnalysisInput,
+  GetDocumentAnalysisInput,
+  StartDocumentTextDetectionInput,
+  GetDocumentTextDetectionInput,
+} from './types/textract.type';
+
+@Injectable()
+export class Documents {
+  constructor(
+    @Optional()
+    @Inject(IBedrock)
+    private readonly bedrock: IBedrock,
+    @Optional()
+    @Inject(ITextract)
+    private readonly textract: ITextract,
+  ) {}
+
+  // bedrock
+  async invokeBedrockModel(
+    payload: InvokeModelPayload,
+  ): Promise<InvokeModelCommandOutput> {
+    return await this.bedrock.invokeModel(payload);
+  }
+
+  // textract
+  async detectDocumentTextBytes(
+    input: DetectDocumentTextBytesInput,
+  ): Promise<DetectDocumentTextCommandOutput> {
+    return await this.textract.detectDocumentTextBytes(input);
+  }
+
+  async detectDocumentTextS3(
+    input: DetectDocumentTextS3Input,
+  ): Promise<DetectDocumentTextCommandOutput> {
+    return await this.textract.detectDocumentTextS3(input);
+  }
+
+  async analyzeDocument(
+    input: AnalyzeDocumentInput,
+  ): Promise<AnalyzeDocumentCommandOutput> {
+    return await this.textract.analyzeDocument(input);
+  }
+
+  async startDocumentAnalysis(
+    input: StartDocumentAnalysisInput,
+  ): Promise<StartDocumentAnalysisCommandOutput> {
+    return await this.textract.startDocumentAnalysis(input);
+  }
+
+  async getDocumentAnalysis(
+    input: GetDocumentAnalysisInput,
+  ): Promise<GetDocumentAnalysisCommandOutput> {
+    return await this.textract.getDocumentAnalysis(input);
+  }
+
+  async startDocumentTextDetection(
+    input: StartDocumentTextDetectionInput,
+  ): Promise<StartDocumentTextDetectionCommandOutput> {
+    return await this.textract.startDocumentTextDetection(input);
+  }
+
+  async getDocumentTextDetection(
+    input: GetDocumentTextDetectionInput,
+  ): Promise<GetDocumentTextDetectionCommandOutput> {
+    return await this.textract.getDocumentTextDetection(input);
+  }
+}

package/src/lib/documents/interfaces/documents.interface.ts

@@ -0,0 +1,51 @@
+import { InvokeModelCommandOutput } from '@aws-sdk/client-bedrock-runtime';
+import {
+  AnalyzeDocumentCommandOutput,
+  DetectDocumentTextCommandOutput,
+  StartDocumentAnalysisCommandOutput,
+  GetDocumentAnalysisCommandOutput,
+  StartDocumentTextDetectionCommandOutput,
+  GetDocumentTextDetectionCommandOutput,
+} from '@aws-sdk/client-textract';
+import { InvokeModelPayload } from '../types/bedrock.type';
+import {
+  AnalyzeDocumentInput,
+  DetectDocumentTextBytesInput,
+  DetectDocumentTextS3Input,
+  StartDocumentAnalysisInput,
+  GetDocumentAnalysisInput,
+  StartDocumentTextDetectionInput,
+  GetDocumentTextDetectionInput,
+} from '../types/textract.type';
+
+export interface IBedrock {
+  invokeModel(payload: InvokeModelPayload): Promise<InvokeModelCommandOutput>;
+}
+
+export const IBedrock = Symbol('IBedrock');
+
+export interface ITextract {
+  detectDocumentTextBytes(
+    input: DetectDocumentTextBytesInput,
+  ): Promise<DetectDocumentTextCommandOutput>;
+  detectDocumentTextS3(
+    input: DetectDocumentTextS3Input,
+  ): Promise<DetectDocumentTextCommandOutput>;
+  analyzeDocument(
+    input: AnalyzeDocumentInput,
+  ): Promise<AnalyzeDocumentCommandOutput>;
+  startDocumentAnalysis(
+    input: StartDocumentAnalysisInput,
+  ): Promise<StartDocumentAnalysisCommandOutput>;
+  getDocumentAnalysis(
+    input: GetDocumentAnalysisInput,
+  ): Promise<GetDocumentAnalysisCommandOutput>;
+  startDocumentTextDetection(
+    input: StartDocumentTextDetectionInput,
+  ): Promise<StartDocumentTextDetectionCommandOutput>;
+  getDocumentTextDetection(
+    input: GetDocumentTextDetectionInput,
+  ): Promise<GetDocumentTextDetectionCommandOutput>;
+}
+
+export const ITextract = Symbol('ITextract');

package/src/lib/documents/types/bedrock.type.ts

@@ -0,0 +1,6 @@
+export type InvokeModelPayload = {
+  modelId: string;
+  body: Uint8Array | Buffer | string;
+  contentType?: string;
+  accept?: string;
+};

package/src/lib/documents/types/textract.type.ts

@@ -0,0 +1,78 @@
+import {
+  FeatureType,
+  QueriesConfig,
+  AdaptersConfig,
+  HumanLoopConfig,
+} from '@aws-sdk/client-textract';
+
+export type DetectDocumentTextBytesInput = {
+  bytes: Uint8Array;
+};
+
+export type DetectDocumentTextS3Input = {
+  bucket: string;
+  name: string;
+};
+
+export type AnalyzeDocumentInput =
+  | ({ bytes: Uint8Array; bucket?: never; name?: never } & {
+      featureTypes: FeatureType[];
+      queriesConfig?: QueriesConfig;
+      adaptersConfig?: AdaptersConfig;
+      humanLoopConfig?: HumanLoopConfig;
+    })
+  | ({ bytes?: never; bucket: string; name: string } & {
+      featureTypes: FeatureType[];
+      queriesConfig?: QueriesConfig;
+      adaptersConfig?: AdaptersConfig;
+      humanLoopConfig?: HumanLoopConfig;
+    });
+
+export type StartDocumentAnalysisInput = {
+  bucket: string;
+  name: string;
+  version?: string;
+  featureTypes: FeatureType[];
+  queriesConfig?: QueriesConfig;
+  adaptersConfig?: AdaptersConfig;
+  clientRequestToken?: string;
+  jobTag?: string;
+  notificationChannel?: {
+    snsTopicArn: string;
+    roleArn: string;
+  };
+  outputConfig?: {
+    s3Bucket: string;
+    s3Prefix?: string;
+  };
+  kmsKeyId?: string;
+};
+
+export type GetDocumentAnalysisInput = {
+  jobId: string;
+  maxResults?: number;
+  nextToken?: string;
+};
+
+export type StartDocumentTextDetectionInput = {
+  bucket: string;
+  name: string;
+  version?: string;
+  clientRequestToken?: string;
+  jobTag?: string;
+  notificationChannel?: {
+    snsTopicArn: string;
+    roleArn: string;
+  };
+  outputConfig?: {
+    s3Bucket: string;
+    s3Prefix?: string;
+  };
+  kmsKeyId?: string;
+};
+
+export type GetDocumentTextDetectionInput = {
+  jobId: string;
+  maxResults?: number;
+  nextToken?: string;
+};

package/src/lib/storage/storage.ts

@@ -16,6 +16,7 @@ import {
   ListFiles,
   UploadFile,
 } from './types/storage.type';
+import { Readable } from 'stream';
 
 @Injectable()
 export class Storage {
@@ -48,4 +49,24 @@ export class Storage {
   async copyFile(data: CopyFile): Promise<CopyObjectCommandOutput> {
     return this.storage.copyFile(data);
   }
+
+  async getFileBuffer(file: GetFile): Promise<Buffer> {
+    const response = await this.storage.getFile(file);
+
+    if (!response.Body) {
+      throw new Error('s3_file_empty');
+    }
+
+    return this.streamToBuffer(response.Body as Readable);
+  }
+
+  private async streamToBuffer(stream: Readable): Promise<Buffer> {
+    const chunks = [];
+
+    return new Promise((resolve, reject) => {
+      stream.on('data', (chunk) => chunks.push(chunk));
+      stream.on('end', () => resolve(Buffer.concat(chunks)));
+      stream.on('error', reject);
+    });
+  }
 }

package/src/lib/storage/types/storage.type.ts

@@ -5,6 +5,8 @@ export type UploadFile = {
   nameFile: string;
   file: string | Readable | Buffer;
   bucket: string;
+  metadata?: Record<string, string>;
+  tagging?: string;
 };
 
 export type GetFile = {