@ttoss/lambda-postgres-query 0.3.17 → 0.3.18

package/README.md

@@ -1,28 +1,22 @@
 # @ttoss/lambda-postgres-query
 
-This package creates an AWS Lambda function that can query an RDS Postgres database inside a private subnet of a VPC.
+Create an AWS Lambda function to securely query a PostgreSQL database in a private VPC subnet without exposing the database to the internet.
 
-The goal of this package is to provide a way to query a Postgres database from a Lambda function without exposing the database to the internet. If your project needs to query a Postgres database and access to the internet, you can follow two approaches:
+## When to Use
 
-1. Create a Lambda function inside a VPC and use a NAT Gateway to access the internet. This approach is expensive because you need to pay for the NAT Gateway.
-
-2. Decompose your architecture into multiple Lambdas—some inside the VPC and some outside the VPC. The Lambda inside the VPC can query the database, and the Lambda outside the VPC can query the Lambda inside the VPC. On this approach, Lambdas outside the VPC invoke Lambdas inside the VPC using the AWS SDK to query the database. This approach is complex and requires more effort to maintain.
-
-_Check this StackOverflow question for more information: [Why can't an AWS lambda function inside a public subnet in a VPC connect to the internet?](https://stackoverflow.com/questions/52992085/why-cant-an-aws-lambda-function-inside-a-public-subnet-in-a-vpc-connect-to-the)_
+This package solves the challenge of querying a PostgreSQL database from AWS Lambda functions without internet access. Traditional approaches require expensive NAT Gateways or complex multi-Lambda architectures. This package provides a simpler solution by deploying a dedicated Lambda function within your VPC.
 
 ## Installation
 
-To install this package, you need to run the following command:
-
 ```bash
 pnpm install @ttoss/lambda-postgres-query
 ```
 
-## Usage
+## Setup
 
-### CloudFormation
+### CloudFormation Template
 
-Create a `src/cloudformation.ts` file with the following content:
+Create a CloudFormation template to deploy the Lambda function:
 
 ```typescript
 import { createLambdaPostgresQueryTemplate } from '@ttoss/lambda-postgres-query/cloudformation';
@@ -32,26 +26,32 @@ const template = createLambdaPostgresQueryTemplate();
 export default template;
 ```
 
-Create a `src/handler.ts` file with the following content:
+### Lambda Handler
+
+Create a handler file that exports the Lambda function:
 
 ```typescript
 export { handler } from '@ttoss/lambda-postgres-query';
 ```
 
-Provide the following environment variables in the `.env` file:
+### Environment Variables
+
+Configure the following environment variables:
 
 ```env
-DATABASE_NAME=
-DATABASE_USERNAME=
-DATABASE_PASSWORD=
-DATABASE_HOST=
-DATABASE_HOST_READ_ONLY=
-DATABASE_PORT=
-SECURITY_GROUP_IDS=
-SUBNET_IDS=
+DATABASE_NAME=your_database_name
+DATABASE_USERNAME=your_username
+DATABASE_PASSWORD=your_password
+DATABASE_HOST=your_database_host
+DATABASE_HOST_READ_ONLY=your_read_only_host  # Optional
+DATABASE_PORT=5432
+SECURITY_GROUP_IDS=sg-xxxxx,sg-yyyyy
+SUBNET_IDS=subnet-xxxxx,subnet-yyyyy
 ```
 
-Add the `deploy` script to the `package.json` file:
+### Deployment
+
+Add a deploy script to your `package.json`:
 
 ```json
 {
@@ -61,44 +61,94 @@ Add the `deploy` script to the `package.json` file:
 }
 ```
 
-[Deploy](https://ttoss.dev/docs/carlin/commands/deploy) them using the following command:
+Deploy using Carlin:
 
 ```bash
 pnpm deploy
 ```
 
-_**Note:** When deploying using carlin, you need to set `lambdaFormat: 'cjs'` because `pg` package doesn't support ESM format._
+**Note:** Set `lambdaFormat: 'cjs'` in your Carlin configuration, as the `pg` package requires CommonJS.
 
-It'll create the necessary resources to query the Postgres database and display the name of the Lambda function created.
+## Usage
 
-### Querying the database
+### Querying from External Lambdas
 
-To query the database from Lambdas outside the VPC, do the following:
+Query the database from Lambda functions outside the VPC:
 
 ```typescript
 import { query } from '@ttoss/lambda-postgres-query';
 import type { Handler } from 'aws-lambda';
 
 export const handler: Handler = async (event) => {
-  const text = 'SELECT * FROM table_name';
-  const result = await query({ text });
+  const result = await query('SELECT * FROM users');
   return result.rows;
 };
 ```
 
-## API
+### Advanced Query Options
+
+```typescript
+import { query } from '@ttoss/lambda-postgres-query';
 
-### `createLambdaQueryTemplate`
+// Query with parameters
+const result = await query({
+  text: 'SELECT * FROM users WHERE id = $1',
+  values: [userId],
+});
+
+// Use read-only connection
+const result = await query({
+  text: 'SELECT * FROM users',
+  readOnly: true, // Defaults to true
+});
+
+// Disable automatic camelCase conversion
+const result = await query({
+  text: 'SELECT * FROM users',
+  camelCaseKeys: false, // Defaults to true
+});
+
+// Specify custom Lambda function name
+const result = await query({
+  text: 'SELECT * FROM users',
+  lambdaPostgresQueryFunction: 'custom-function-name',
+});
+```
 
-This function creates a CloudFormation template to deploy the Lambda function that queries the Postgres database.
+## API Reference
 
-### `query`
+### `createLambdaPostgresQueryTemplate(options?)`
 
-This function queries the Postgres database using the environment variables provided. It uses the [`pg`](https://node-postgres.com/) package to connect to the database.
+Creates a CloudFormation template for the PostgreSQL query Lambda function.
 
 #### Parameters
 
-It accepts all the [`QueryConfig` object from the `pg` package](https://node-postgres.com/apis/client#queryconfig) with the following additional properties:
+- `handler` (string, optional): Lambda handler function name. Default: `'handler.handler'`
+- `memorySize` (number, optional): Lambda memory size in MB. Default: `128`
+- `timeout` (number, optional): Lambda timeout in seconds. Default: `30`
+
+#### Returns
+
+A CloudFormation template object.
+
+### `query(params)`
+
+Queries the PostgreSQL database by invoking the VPC Lambda function.
+
+#### Parameters
+
+Accepts either a SQL string or an options object extending [`QueryConfig`](https://node-postgres.com/apis/client#queryconfig) with additional properties:
+
+- `text` (string): SQL query text
+- `values` (array, optional): Query parameter values
+- `readOnly` (boolean, optional): Use read-only database host if available. Default: `true`
+- `lambdaPostgresQueryFunction` (string, optional): Name of the query Lambda function. Default: `LAMBDA_POSTGRES_QUERY_FUNCTION` environment variable
+- `camelCaseKeys` (boolean, optional): Convert snake_case column names to camelCase. Default: `true`
+
+#### Returns
+
+A [`QueryResult`](https://node-postgres.com/apis/result) object with transformed rows.
+
+### `handler`
 
-- `readOnly`: A boolean that indicates if the query should be executed on the read-only database, in case you provided the `DATABASE_HOST_READ_ONLY` value. Default is `true`.
-- `lambdaPostgresQueryFunction`: The name of the Lambda function that queries the database. Default is the value of the `LAMBDA_POSTGRES_QUERY_FUNCTION` environment variable.
+AWS Lambda handler function for processing database queries within the VPC.

package/dist/cloudformation/index.d.cts

@@ -0,0 +1,18 @@
+import { CloudFormationTemplate } from '@ttoss/cloudformation';
+export { CloudFormationTemplate } from '@ttoss/cloudformation';
+import { Handler } from 'aws-lambda';
+import { QueryParams } from '../index.cjs';
+import 'pg';
+
+declare const HANDLER_DEFAULT = "handler.handler";
+declare const MEMORY_SIZE_DEFAULT = 128;
+declare const TIMEOUT_DEFAULT = 30;
+declare const createLambdaPostgresQueryTemplate: ({ handler, memorySize, timeout, }?: {
+    handler?: string;
+    memorySize?: number;
+    timeout?: number;
+}) => CloudFormationTemplate;
+
+declare const handler: Handler<QueryParams>;
+
+export { HANDLER_DEFAULT, MEMORY_SIZE_DEFAULT, TIMEOUT_DEFAULT, createLambdaPostgresQueryTemplate, handler };

package/dist/cloudformation/index.d.ts

@@ -0,0 +1,18 @@
+import { CloudFormationTemplate } from '@ttoss/cloudformation';
+export { CloudFormationTemplate } from '@ttoss/cloudformation';
+import { Handler } from 'aws-lambda';
+import { QueryParams } from '../index.js';
+import 'pg';
+
+declare const HANDLER_DEFAULT = "handler.handler";
+declare const MEMORY_SIZE_DEFAULT = 128;
+declare const TIMEOUT_DEFAULT = 30;
+declare const createLambdaPostgresQueryTemplate: ({ handler, memorySize, timeout, }?: {
+    handler?: string;
+    memorySize?: number;
+    timeout?: number;
+}) => CloudFormationTemplate;
+
+declare const handler: Handler<QueryParams>;
+
+export { HANDLER_DEFAULT, MEMORY_SIZE_DEFAULT, TIMEOUT_DEFAULT, createLambdaPostgresQueryTemplate, handler };

package/dist/cloudformation/index.js

@@ -0,0 +1,240 @@
+/** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", {
+  value,
+  configurable: true
+});
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+
+// src/cloudformation/index.ts
+var cloudformation_exports = {};
+__export(cloudformation_exports, {
+  HANDLER_DEFAULT: () => HANDLER_DEFAULT,
+  MEMORY_SIZE_DEFAULT: () => MEMORY_SIZE_DEFAULT,
+  TIMEOUT_DEFAULT: () => TIMEOUT_DEFAULT,
+  createLambdaPostgresQueryTemplate: () => createLambdaPostgresQueryTemplate,
+  handler: () => handler
+});
+module.exports = __toCommonJS(cloudformation_exports);
+
+// src/cloudformation/createLambdaPostgresQueryTemplate.ts
+var HANDLER_DEFAULT = "handler.handler";
+var MEMORY_SIZE_DEFAULT = 128;
+var TIMEOUT_DEFAULT = 30;
+var createLambdaPostgresQueryTemplate = /* @__PURE__ */__name(({
+  handler: handler2 = HANDLER_DEFAULT,
+  memorySize = 128,
+  timeout = 30
+} = {}) => {
+  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: handler2,
+          Role: {
+            "Fn::GetAtt": ["LambdaQueryExecutionRole", "Arn"]
+          },
+          Runtime: "nodejs22.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"
+            }
+          }
+        }
+      },
+      LambdaQueryFunctionLogs: {
+        Type: "AWS::Logs::LogGroup",
+        DependsOn: "LambdaQueryFunction",
+        Properties: {
+          LogGroupName: {
+            "Fn::Join": ["", ["/aws/lambda/", {
+              Ref: "LambdaQueryFunction"
+            }]]
+          },
+          RetentionInDays: 7
+        }
+      }
+    },
+    Outputs: {
+      LambdaPostgresQueryFunction: {
+        Description: "Lambda function to query PostgreSQL.",
+        Value: {
+          Ref: "LambdaQueryFunction"
+        }
+      },
+      LambdaPostgresQueryFunctionArn: {
+        Description: "Lambda function to query PostgreSQL ARN.",
+        Value: {
+          "Fn::GetAtt": ["LambdaQueryFunction", "Arn"]
+        }
+      }
+    }
+  };
+}, "createLambdaPostgresQueryTemplate");
+
+// src/cloudformation/lambdaQueryHandler.ts
+var import_pg = require("pg");
+var database = process.env.DATABASE_NAME;
+var username = process.env.DATABASE_USERNAME;
+var password = process.env.DATABASE_PASSWORD;
+var host = process.env.DATABASE_HOST;
+var hostReadOnly = process.env.DATABASE_HOST_READ_ONLY;
+var port = process.env.DATABASE_PORT;
+var handler = /* @__PURE__ */__name(async event => {
+  try {
+    const client = new import_pg.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) {
+    console.error("Error running query", {
+      error,
+      event
+    });
+    throw error;
+  }
+}, "handler");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HANDLER_DEFAULT,
+  MEMORY_SIZE_DEFAULT,
+  TIMEOUT_DEFAULT,
+  createLambdaPostgresQueryTemplate,
+  handler
+});

package/dist/esm/chunk-V4MHYKRI.js

@@ -0,0 +1,7 @@
+/** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+  value,
+  configurable: true
+});
+export { __name };

package/dist/esm/cloudformation/index.js

@@ -0,0 +1,195 @@
+/** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
+import { __name } from "../chunk-V4MHYKRI.js";
+
+// src/cloudformation/createLambdaPostgresQueryTemplate.ts
+var HANDLER_DEFAULT = "handler.handler";
+var MEMORY_SIZE_DEFAULT = 128;
+var TIMEOUT_DEFAULT = 30;
+var createLambdaPostgresQueryTemplate = /* @__PURE__ */__name(({
+  handler: handler2 = HANDLER_DEFAULT,
+  memorySize = 128,
+  timeout = 30
+} = {}) => {
+  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: handler2,
+          Role: {
+            "Fn::GetAtt": ["LambdaQueryExecutionRole", "Arn"]
+          },
+          Runtime: "nodejs22.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"
+            }
+          }
+        }
+      },
+      LambdaQueryFunctionLogs: {
+        Type: "AWS::Logs::LogGroup",
+        DependsOn: "LambdaQueryFunction",
+        Properties: {
+          LogGroupName: {
+            "Fn::Join": ["", ["/aws/lambda/", {
+              Ref: "LambdaQueryFunction"
+            }]]
+          },
+          RetentionInDays: 7
+        }
+      }
+    },
+    Outputs: {
+      LambdaPostgresQueryFunction: {
+        Description: "Lambda function to query PostgreSQL.",
+        Value: {
+          Ref: "LambdaQueryFunction"
+        }
+      },
+      LambdaPostgresQueryFunctionArn: {
+        Description: "Lambda function to query PostgreSQL ARN.",
+        Value: {
+          "Fn::GetAtt": ["LambdaQueryFunction", "Arn"]
+        }
+      }
+    }
+  };
+}, "createLambdaPostgresQueryTemplate");
+
+// src/cloudformation/lambdaQueryHandler.ts
+import { Client } from "pg";
+var database = process.env.DATABASE_NAME;
+var username = process.env.DATABASE_USERNAME;
+var password = process.env.DATABASE_PASSWORD;
+var host = process.env.DATABASE_HOST;
+var hostReadOnly = process.env.DATABASE_HOST_READ_ONLY;
+var port = process.env.DATABASE_PORT;
+var handler = /* @__PURE__ */__name(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) {
+    console.error("Error running query", {
+      error,
+      event
+    });
+    throw error;
+  }
+}, "handler");
+export { HANDLER_DEFAULT, MEMORY_SIZE_DEFAULT, TIMEOUT_DEFAULT, createLambdaPostgresQueryTemplate, handler };

package/dist/esm/index.js

@@ -0,0 +1,61 @@
+/** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
+import { __name } from "./chunk-V4MHYKRI.js";
+
+// src/query.ts
+import { InvokeCommand, LambdaClient } from "@aws-sdk/client-lambda";
+import camelcaseKeys from "camelcase-keys";
+var lambdaClient = new LambdaClient();
+var textDecoder = new TextDecoder("utf-8");
+var query = /* @__PURE__ */__name(async params => {
+  try {
+    const {
+      readOnly = true,
+      // eslint-disable-next-line turbo/no-undeclared-env-vars
+      lambdaPostgresQueryFunction = process.env.LAMBDA_POSTGRES_QUERY_FUNCTION,
+      camelCaseKeys = true,
+      ...pgParams
+    } = typeof params === "string" ? {
+      text: params
+    } : params;
+    const input = {
+      FunctionName: lambdaPostgresQueryFunction,
+      Payload: JSON.stringify({
+        readOnly,
+        ...pgParams
+      })
+    };
+    const {
+      Payload
+    } = await lambdaClient.send(new InvokeCommand(input));
+    if (!Payload) {
+      console.error("No payload returned from lambda query", {
+        input
+      });
+      throw new Error("No payload returned from lambda query");
+    }
+    const data = textDecoder.decode(Payload);
+    const result = JSON.parse(data);
+    if ("errorType" in result) {
+      throw new Error(result.errorMessage);
+    }
+    return {
+      ...result,
+      rows: result.rows.map(row => {
+        if (!camelCaseKeys) {
+          return row;
+        }
+        return {
+          ...row,
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          ...camelcaseKeys(row, {
+            deep: true
+          })
+        };
+      })
+    };
+  } catch (error) {
+    console.error("Error invoking lambda-postgres-query: ", error);
+    throw error;
+  }
+}, "query");
+export { query };

package/dist/index.d.cts

@@ -0,0 +1,22 @@
+import * as pg from 'pg';
+import { QueryConfig, QueryResultRow } from 'pg';
+
+type QueryParams = {
+    readOnly?: boolean;
+    lambdaPostgresQueryFunction?: string;
+    camelCaseKeys?: boolean;
+} & QueryConfig;
+type LambdaError = {
+    errorType: 'Error';
+    errorMessage: string;
+    trace: string[];
+};
+declare const query: <Rows extends QueryResultRow = any>(params: QueryParams | string) => Promise<{
+    rows: any[];
+    command: string;
+    rowCount: number | null;
+    oid: number;
+    fields: pg.FieldDef[];
+}>;
+
+export { type LambdaError, type QueryParams, query };

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+import * as pg from 'pg';
+import { QueryConfig, QueryResultRow } from 'pg';
+
+type QueryParams = {
+    readOnly?: boolean;
+    lambdaPostgresQueryFunction?: string;
+    camelCaseKeys?: boolean;
+} & QueryConfig;
+type LambdaError = {
+    errorType: 'Error';
+    errorMessage: string;
+    trace: string[];
+};
+declare const query: <Rows extends QueryResultRow = any>(params: QueryParams | string) => Promise<{
+    rows: any[];
+    command: string;
+    rowCount: number | null;
+    oid: number;
+    fields: pg.FieldDef[];
+}>;
+
+export { type LambdaError, type QueryParams, query };

package/dist/index.js

@@ -0,0 +1,109 @@
+/** Powered by @ttoss/config. https://ttoss.dev/docs/modules/packages/config/ */
+"use strict";
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", {
+  value,
+  configurable: true
+});
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  query: () => query
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/query.ts
+var import_client_lambda = require("@aws-sdk/client-lambda");
+var import_camelcase_keys = __toESM(require("camelcase-keys"), 1);
+var lambdaClient = new import_client_lambda.LambdaClient();
+var textDecoder = new TextDecoder("utf-8");
+var query = /* @__PURE__ */__name(async params => {
+  try {
+    const {
+      readOnly = true,
+      // eslint-disable-next-line turbo/no-undeclared-env-vars
+      lambdaPostgresQueryFunction = process.env.LAMBDA_POSTGRES_QUERY_FUNCTION,
+      camelCaseKeys = true,
+      ...pgParams
+    } = typeof params === "string" ? {
+      text: params
+    } : params;
+    const input = {
+      FunctionName: lambdaPostgresQueryFunction,
+      Payload: JSON.stringify({
+        readOnly,
+        ...pgParams
+      })
+    };
+    const {
+      Payload
+    } = await lambdaClient.send(new import_client_lambda.InvokeCommand(input));
+    if (!Payload) {
+      console.error("No payload returned from lambda query", {
+        input
+      });
+      throw new Error("No payload returned from lambda query");
+    }
+    const data = textDecoder.decode(Payload);
+    const result = JSON.parse(data);
+    if ("errorType" in result) {
+      throw new Error(result.errorMessage);
+    }
+    return {
+      ...result,
+      rows: result.rows.map(row => {
+        if (!camelCaseKeys) {
+          return row;
+        }
+        return {
+          ...row,
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          ...(0, import_camelcase_keys.default)(row, {
+            deep: true
+          })
+        };
+      })
+    };
+  } catch (error) {
+    console.error("Error invoking lambda-postgres-query: ", error);
+    throw error;
+  }
+}, "query");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  query
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttoss/lambda-postgres-query",
-  "version": "0.3.17",
+  "version": "0.3.18",
   "description": "Create a Lambda function that queries a PostgreSQL database.",
   "license": "MIT",
   "author": "ttoss",
@@ -40,8 +40,8 @@
     "aws-sdk-client-mock": "^4.1.0",
     "jest": "^30.2.0",
     "tsup": "^8.5.1",
-    "@ttoss/test-utils": "^4.0.2",
-    "@ttoss/config": "^1.35.12"
+    "@ttoss/config": "^1.35.12",
+    "@ttoss/test-utils": "^4.0.2"
   },
   "keywords": [
     "aws",