@ttoss/lambda-postgres-query 0.2.13 → 0.2.15

package/src/cloudformation/createLambdaPostgresQueryTemplate.ts

@@ -1,133 +0,0 @@
-import type { CloudFormationTemplate } from '@ttoss/cloudformation';
-
-export type { CloudFormationTemplate };
-
-export const HANDLER_DEFAULT = 'handler.handler';
-
-export const MEMORY_SIZE_DEFAULT = 128;
-
-export const TIMEOUT_DEFAULT = 30;
-
-export const createLambdaPostgresQueryTemplate = ({
-  handler = HANDLER_DEFAULT,
-  memorySize = 128,
-  timeout = 30,
-}: {
-  handler?: string;
-  memorySize?: number;
-  timeout?: number;
-} = {}): CloudFormationTemplate => {
-  return {
-    AWSTemplateFormatVersion: '2010-09-09',
-    Description: 'A Lambda function to query PostgreSQL.',
-    Parameters: {
-      DatabaseHost: {
-        Type: 'String',
-        Description: 'Database host.',
-      },
-      DatabaseHostReadOnly: {
-        Type: 'String',
-        Description: 'Database host read only.',
-      },
-      DatabaseName: {
-        Type: 'String',
-        Description: 'Database name.',
-      },
-      DatabaseUsername: {
-        Type: 'String',
-        Description: 'Database username.',
-      },
-      DatabasePassword: {
-        Type: 'String',
-        Description: 'Database password.',
-      },
-      DatabasePort: {
-        Type: 'String',
-        Default: '5432',
-        Description: 'Database port.',
-      },
-      LambdaS3Bucket: {
-        Type: 'String',
-        Description: 'The S3 bucket where the Lambda code is stored.',
-      },
-      LambdaS3Key: {
-        Type: 'String',
-        Description: 'The S3 key where the Lambda code is stored.',
-      },
-      LambdaS3ObjectVersion: {
-        Type: 'String',
-        Description: 'The S3 object version of the Lambda code.',
-      },
-      SecurityGroupIds: {
-        Description: 'Security Group IDs',
-        Type: 'List<AWS::EC2::SecurityGroup::Id>',
-      },
-      SubnetIds: {
-        Description: 'Subnet IDs',
-        Type: 'List<AWS::EC2::Subnet::Id>',
-      },
-    },
-    Resources: {
-      LambdaQueryExecutionRole: {
-        Type: 'AWS::IAM::Role',
-        Properties: {
-          AssumeRolePolicyDocument: {
-            Version: '2012-10-17',
-            Statement: [
-              {
-                Effect: 'Allow',
-                Principal: {
-                  Service: 'lambda.amazonaws.com',
-                },
-                Action: 'sts:AssumeRole',
-              },
-            ],
-          },
-          ManagedPolicyArns: [
-            'arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole',
-            'arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole',
-          ],
-        },
-      },
-      LambdaQueryFunction: {
-        Type: 'AWS::Lambda::Function',
-        Properties: {
-          Code: {
-            S3Bucket: { Ref: 'LambdaS3Bucket' },
-            S3Key: { Ref: 'LambdaS3Key' },
-            S3ObjectVersion: { Ref: 'LambdaS3ObjectVersion' },
-          },
-          MemorySize: memorySize,
-          Timeout: timeout,
-          Handler: handler,
-          Role: { 'Fn::GetAtt': ['LambdaQueryExecutionRole', 'Arn'] },
-          Runtime: 'nodejs20.x',
-          Environment: {
-            Variables: {
-              DATABASE_HOST: { Ref: 'DatabaseHost' },
-              DATABASE_HOST_READ_ONLY: { Ref: 'DatabaseHostReadOnly' },
-              DATABASE_NAME: { Ref: 'DatabaseName' },
-              DATABASE_USERNAME: { Ref: 'DatabaseUsername' },
-              DATABASE_PASSWORD: { Ref: 'DatabasePassword' },
-              DATABASE_PORT: { Ref: 'DatabasePort' },
-            },
-          },
-          VpcConfig: {
-            SecurityGroupIds: { Ref: 'SecurityGroupIds' },
-            SubnetIds: { Ref: 'SubnetIds' },
-          },
-        },
-      },
-    },
-    Outputs: {
-      LambdaPostgresQueryFunction: {
-        Description: 'Lambda function to query PostgreSQL.',
-        Value: { Ref: 'LambdaQueryFunction' },
-      },
-      LambdaPostgresQueryFunctionArn: {
-        Description: 'Lambda function to query PostgreSQL ARN.',
-        Value: { 'Fn::GetAtt': ['LambdaQueryFunction', 'Arn'] },
-      },
-    },
-  };
-};

package/src/cloudformation/index.ts

@@ -1,2 +0,0 @@
-export * from './createLambdaPostgresQueryTemplate';
-export * from './lambdaQueryHandler';

package/src/cloudformation/lambdaQueryHandler.ts

@@ -1,39 +0,0 @@
-/* eslint-disable turbo/no-undeclared-env-vars */
-import { Client } from 'pg';
-import type { Handler } from 'aws-lambda';
-import type { QueryParams } from '../query';
-
-const database = process.env.DATABASE_NAME;
-const username = process.env.DATABASE_USERNAME;
-const password = process.env.DATABASE_PASSWORD;
-const host = process.env.DATABASE_HOST;
-const hostReadOnly = process.env.DATABASE_HOST_READ_ONLY;
-const port = process.env.DATABASE_PORT;
-
-export const handler: Handler<QueryParams> = async (event) => {
-  try {
-    const client = new Client({
-      database,
-      user: username,
-      password,
-      host: event.readOnly && hostReadOnly ? hostReadOnly : host,
-      port: Number(port),
-    });
-
-    await client.connect();
-
-    try {
-      const res = await client.query(event);
-      return res;
-    } finally {
-      await client.end();
-    }
-  } catch (error) {
-    // eslint-disable-next-line no-console
-    console.error('Error running query', {
-      error,
-      event,
-    });
-    throw error;
-  }
-};

package/src/index.ts

@@ -1 +0,0 @@
-export * from './query';

package/src/query.ts

@@ -1,76 +0,0 @@
-import {
-  InvokeCommand,
-  type InvokeCommandInput,
-  LambdaClient,
-} from '@aws-sdk/client-lambda';
-import camelcaseKeys from 'camelcase-keys';
-import type { QueryConfig, QueryResult, QueryResultRow } from 'pg';
-
-const lambdaClient = new LambdaClient();
-
-const asciiDecoder = new TextDecoder('ascii');
-
-export type QueryParams = {
-  readOnly?: boolean;
-  lambdaPostgresQueryFunction?: string;
-} & QueryConfig;
-
-export type LambdaError = {
-  errorType: 'Error';
-  errorMessage: string;
-  trace: string[];
-};
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const query = async <Rows extends QueryResultRow = any>(
-  params: QueryParams | string
-) => {
-  try {
-    const {
-      readOnly = true,
-      // eslint-disable-next-line turbo/no-undeclared-env-vars
-      lambdaPostgresQueryFunction = process.env.LAMBDA_POSTGRES_QUERY_FUNCTION,
-      ...pgParams
-    } = typeof params === 'string'
-      ? {
-          text: params,
-        }
-      : params;
-
-    const input: InvokeCommandInput = {
-      FunctionName: lambdaPostgresQueryFunction,
-      Payload: JSON.stringify({ readOnly, ...pgParams }),
-    };
-
-    const { Payload } = await lambdaClient.send(new InvokeCommand(input));
-
-    if (!Payload) {
-      // eslint-disable-next-line no-console
-      console.error('No payload returned from lambda query', { input });
-      throw new Error('No payload returned from lambda query');
-    }
-
-    const data = asciiDecoder.decode(Payload);
-
-    const result = JSON.parse(data) as QueryResult<Rows> | LambdaError;
-
-    if ('errorType' in result) {
-      throw result;
-    }
-
-    return {
-      ...result,
-      rows: result.rows.map((row) => {
-        return {
-          ...row,
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          ...(camelcaseKeys(row, { deep: true }) as any),
-        };
-      }),
-    };
-  } catch (error) {
-    // eslint-disable-next-line no-console
-    console.error('Error invoking Lambda: ', error);
-    throw error;
-  }
-};