@xube/kit-aws 0.0.70 → 0.0.71

package/dist/resources/dynamodb/query.d.ts

@@ -1,7 +1,25 @@
 import { XubeResponse } from "@xube/kit-request";
 import { XubeLog } from "@xube/kit-log";
-import { PartialTableKey, TableItem } from "@xube/kit-aws-schema";
-export declare const queryItemsFromTable: (tableName: string, keys: PartialTableKey, indexName: string | undefined, keyLabels?: {
+import { TableItem } from "@xube/kit-aws-schema";
+type PartialTableKey = {
+    PK: string;
+    SK?: string;
+};
+export declare const queryItemsFromTableBetween: (tableName: string, keys: {
+    PK: string;
+    SKstart: string;
+    SKend: string;
+}, indexName?: string, keyLabels?: {
     partitionKey: string;
     sortKey?: string;
 }, log?: XubeLog) => Promise<XubeResponse<TableItem[]>>;
+export declare const queryItemsFromTableBeginsWith: (tableName: string, keys: PartialTableKey, indexName: string | undefined, keyLabels?: {
+    partitionKey: string;
+    sortKey?: string;
+}, log?: XubeLog) => Promise<XubeResponse<TableItem[]>>;
+export declare const queryItemsFromTableUsingPKOnly: (tableName: string, keys: {
+    PK: string;
+}, indexName: string | undefined, keyLabels?: {
+    partitionKey: string;
+}, log?: XubeLog) => Promise<XubeResponse<TableItem[]>>;
+export {};

package/dist/resources/dynamodb/query.js

@@ -1,52 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.queryItemsFromTable = void 0;
+exports.queryItemsFromTableUsingPKOnly = exports.queryItemsFromTableBeginsWith = exports.queryItemsFromTableBetween = void 0;
 const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
 const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
 const kit_request_1 = require("@xube/kit-request");
 const kit_log_1 = require("@xube/kit-log");
 const kit_aws_schema_1 = require("@xube/kit-aws-schema");
+const kit_constants_1 = require("@xube/kit-constants");
 const ddbClient = new client_dynamodb_1.DynamoDBClient({ region: process.env.AWS_REGION });
 const ddbDocClient = lib_dynamodb_1.DynamoDBDocumentClient.from(ddbClient);
-const queryItemsFromTable = async (tableName, keys, indexName, keyLabels = {
-    partitionKey: kit_aws_schema_1.PARTITION_KEY,
-    sortKey: kit_aws_schema_1.SORT_KEY,
-}, log = kit_log_1.XubeLog.getInstance()) => {
-    let KeyConditionExpression = "#pk = :pkValue";
-    let ExpressionAttributeNames = {
+const buildQueryParams = (tableName, keys, indexName, keyLabels, condition) => {
+    const ExpressionAttributeNames = {
         "#pk": keyLabels.partitionKey,
     };
-    let ExpressionAttributeValues = {
-        ":pkValue": keys[kit_aws_schema_1.PARTITION_KEY],
+    const ExpressionAttributeValues = {
+        ":pkValue": keys.PK,
     };
-    if (keys[kit_aws_schema_1.SORT_KEY]) {
-        KeyConditionExpression += " AND begins_with(#sk, :skPrefix)";
-        ExpressionAttributeNames["#sk"] = keyLabels.sortKey ?? kit_aws_schema_1.SORT_KEY;
-        ExpressionAttributeValues[":skPrefix"] = keys[kit_aws_schema_1.SORT_KEY];
+    let conditionExpression = "";
+    let additionalExpressionValues = {};
+    if (condition) {
+        const conditionResult = condition(ExpressionAttributeNames);
+        conditionExpression = conditionResult.conditionExpression;
+        additionalExpressionValues = conditionResult.expressionValues;
     }
-    const params = {
+    return {
         TableName: tableName,
         IndexName: indexName,
-        KeyConditionExpression,
+        KeyConditionExpression: `#pk = :pkValue ${conditionExpression}`.trim(),
         ExpressionAttributeNames,
-        ExpressionAttributeValues,
+        ExpressionAttributeValues: {
+            ...ExpressionAttributeValues,
+            ...additionalExpressionValues,
+        },
     };
+};
+const executeQuery = async (params) => {
     try {
         const response = await ddbDocClient.send(new lib_dynamodb_1.QueryCommand(params));
         if (!response.Items || !response.Items.length) {
             return new kit_request_1.XubeResponse({
-                statusCode: 404,
+                statusCode: kit_constants_1.StatusCode.NotFound,
                 error: `No items found.`,
             });
         }
         if (!(0, kit_aws_schema_1.areTableItems)(response.Items)) {
             return new kit_request_1.XubeResponse({
-                statusCode: 500,
+                statusCode: kit_constants_1.StatusCode.InternalError,
                 error: `Items returned from DynamoDB are not valid TableItems.`,
             });
         }
         return new kit_request_1.XubeResponse({
-            statusCode: 200,
+            statusCode: kit_constants_1.StatusCode.OK,
             data: response.Items,
         });
     }
@@ -55,4 +59,45 @@ const queryItemsFromTable = async (tableName, keys, indexName, keyLabels = {
         throw error;
     }
 };
-exports.queryItemsFromTable = queryItemsFromTable;
+const queryItemsFromTableBetween = async (tableName, keys, indexName, keyLabels = {
+    partitionKey: kit_aws_schema_1.PARTITION_KEY,
+    sortKey: kit_aws_schema_1.SORT_KEY,
+}, log = kit_log_1.XubeLog.getInstance()) => {
+    const params = buildQueryParams(tableName, keys, indexName, keyLabels, (ExpressionAttributeNames) => {
+        ExpressionAttributeNames["#sk"] = keyLabels.sortKey ?? kit_aws_schema_1.SORT_KEY;
+        return {
+            conditionExpression: "AND #sk BETWEEN :skStart AND :skEnd",
+            expressionValues: { ":skStart": keys.SKstart, ":skEnd": keys.SKend },
+        };
+    });
+    return executeQuery(params);
+};
+exports.queryItemsFromTableBetween = queryItemsFromTableBetween;
+const queryItemsFromTableBeginsWith = async (tableName, keys, indexName, keyLabels = {
+    partitionKey: kit_aws_schema_1.PARTITION_KEY,
+    sortKey: kit_aws_schema_1.SORT_KEY,
+}, log = kit_log_1.XubeLog.getInstance()) => {
+    let condition;
+    if (keys.SK) {
+        condition = (ExpressionAttributeNames) => {
+            ExpressionAttributeNames["#sk"] = keyLabels.sortKey ?? kit_aws_schema_1.SORT_KEY;
+            return {
+                conditionExpression: "AND begins_with(#sk, :skPrefix)",
+                expressionValues: { ":skPrefix": keys.SK },
+            };
+        };
+    }
+    else {
+        condition = undefined;
+    }
+    const params = buildQueryParams(tableName, keys, indexName, keyLabels, condition);
+    return executeQuery(params);
+};
+exports.queryItemsFromTableBeginsWith = queryItemsFromTableBeginsWith;
+const queryItemsFromTableUsingPKOnly = async (tableName, keys, indexName, keyLabels = {
+    partitionKey: kit_aws_schema_1.PARTITION_KEY,
+}, log = kit_log_1.XubeLog.getInstance()) => {
+    const params = buildQueryParams(tableName, keys, indexName, keyLabels);
+    return executeQuery(params);
+};
+exports.queryItemsFromTableUsingPKOnly = queryItemsFromTableUsingPKOnly;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xube/kit-aws",
-  "version": "0.0.70",
+  "version": "0.0.71",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -18,7 +18,7 @@
   "homepage": "https://github.com/XubeLtd/dev-kit#readme",
   "devDependencies": {
     "@types/aws-lambda": "^8.10.119",
-    "@xube/kit-build": "^0.0.70"
+    "@xube/kit-build": "^0.0.71"
   },
   "dependencies": {
     "@aws-sdk/client-cognito-identity-provider": "^3.433.0",
@@ -26,10 +26,10 @@
     "@aws-sdk/client-ssm": "^3.433.0",
     "@aws-sdk/lib-dynamodb": "^3.433.0",
     "@aws-sdk/util-dynamodb": "^3.433.0",
-    "@xube/kit-aws-schema": "^0.0.70",
-    "@xube/kit-log": "^0.0.70",
-    "@xube/kit-request": "^0.0.70",
-    "@xube/kit-schema": "^0.0.70",
+    "@xube/kit-aws-schema": "^0.0.71",
+    "@xube/kit-log": "^0.0.71",
+    "@xube/kit-request": "^0.0.71",
+    "@xube/kit-schema": "^0.0.71",
     "zod": "^3.22.4"
   }
 }

package/src/resources/dynamodb/query.ts

@@ -2,65 +2,97 @@ import { DynamoDBDocumentClient, QueryCommand } from "@aws-sdk/lib-dynamodb";
 import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
 import { XubeResponse } from "@xube/kit-request";
 import { XubeLog } from "@xube/kit-log";
-import { PARTITION_KEY, PartialTableKey, SORT_KEY, TableItem, areTableItems } from "@xube/kit-aws-schema";
+import {
+  PARTITION_KEY,
+  SORT_KEY,
+  TableItem,
+  areTableItems,
+} from "@xube/kit-aws-schema";
+import { StatusCode } from "@xube/kit-constants";
 
 const ddbClient = new DynamoDBClient({ region: process.env.AWS_REGION });
 const ddbDocClient = DynamoDBDocumentClient.from(ddbClient);
+type DynamoDbParams = {
+  TableName: string;
+  IndexName?: string;
+  KeyConditionExpression: string;
+  ExpressionAttributeNames: { [key: string]: string };
+  ExpressionAttributeValues: { [key: string]: string };
+};
+
+type ConditionReturn = {
+  conditionExpression: string;
+  expressionValues: { [key: string]: string };
+};
+
+type PartialTableKey = {
+  PK: string;
+  SK?: string;
+};
 
-export const queryItemsFromTable = async (
+const buildQueryParams = (
   tableName: string,
   keys: PartialTableKey,
   indexName: string | undefined,
   keyLabels: {
     partitionKey: string;
     sortKey?: string;
-  } = {
-    partitionKey: PARTITION_KEY,
-    sortKey: SORT_KEY,
   },
-  log: XubeLog = XubeLog.getInstance()
-): Promise<XubeResponse<TableItem[]>> => {
-  let KeyConditionExpression = "#pk = :pkValue";
-  let ExpressionAttributeNames: { [key: string]: string } = {
+  condition?: (ExpressionAttributeNames: {
+    [key: string]: string;
+  }) => ConditionReturn
+): DynamoDbParams => {
+  const ExpressionAttributeNames: { [key: string]: string } = {
     "#pk": keyLabels.partitionKey,
   };
-  let ExpressionAttributeValues: { [key: string]: string } = {
-    ":pkValue": keys[PARTITION_KEY],
+
+  const ExpressionAttributeValues: { [key: string]: string } = {
+    ":pkValue": keys.PK,
   };
 
-  if (keys[SORT_KEY]) {
-    KeyConditionExpression += " AND begins_with(#sk, :skPrefix)";
-    ExpressionAttributeNames["#sk"] = keyLabels.sortKey ?? SORT_KEY;
-    ExpressionAttributeValues[":skPrefix"] = keys[SORT_KEY];
+  let conditionExpression = "";
+  let additionalExpressionValues: { [key: string]: string } = {};
+
+  if (condition) {
+    const conditionResult = condition(ExpressionAttributeNames);
+    conditionExpression = conditionResult.conditionExpression;
+    additionalExpressionValues = conditionResult.expressionValues;
   }
 
-  const params = {
+  return {
     TableName: tableName,
     IndexName: indexName,
-    KeyConditionExpression,
+    KeyConditionExpression: `#pk = :pkValue ${conditionExpression}`.trim(),
     ExpressionAttributeNames,
-    ExpressionAttributeValues,
+    ExpressionAttributeValues: {
+      ...ExpressionAttributeValues,
+      ...additionalExpressionValues,
+    },
   };
+};
 
+const executeQuery = async (
+  params: DynamoDbParams
+): Promise<XubeResponse<TableItem[]>> => {
   try {
     const response = await ddbDocClient.send(new QueryCommand(params));
 
     if (!response.Items || !response.Items.length) {
       return new XubeResponse({
-        statusCode: 404,
+        statusCode: StatusCode.NotFound,
         error: `No items found.`,
       });
     }
 
     if (!areTableItems(response.Items)) {
       return new XubeResponse({
-        statusCode: 500,
+        statusCode: StatusCode.InternalError,
         error: `Items returned from DynamoDB are not valid TableItems.`,
       });
     }
 
     return new XubeResponse({
-      statusCode: 200,
+      statusCode: StatusCode.OK,
       data: response.Items,
     });
   } catch (error) {
@@ -68,3 +100,90 @@ export const queryItemsFromTable = async (
     throw error;
   }
 };
+
+export const queryItemsFromTableBetween = async (
+  tableName: string,
+  keys: {
+    PK: string;
+    SKstart: string;
+    SKend: string;
+  },
+  indexName?: string,
+  keyLabels: {
+    partitionKey: string;
+    sortKey?: string;
+  } = {
+    partitionKey: PARTITION_KEY,
+    sortKey: SORT_KEY,
+  },
+  log: XubeLog = XubeLog.getInstance()
+): Promise<XubeResponse<TableItem[]>> => {
+  const params = buildQueryParams(
+    tableName,
+    keys,
+    indexName,
+    keyLabels,
+    (ExpressionAttributeNames) => {
+      ExpressionAttributeNames["#sk"] = keyLabels.sortKey ?? SORT_KEY;
+      return {
+        conditionExpression: "AND #sk BETWEEN :skStart AND :skEnd",
+        expressionValues: { ":skStart": keys.SKstart, ":skEnd": keys.SKend },
+      };
+    }
+  );
+
+  return executeQuery(params);
+};
+
+export const queryItemsFromTableBeginsWith = async (
+  tableName: string,
+  keys: PartialTableKey,
+  indexName: string | undefined,
+  keyLabels: {
+    partitionKey: string;
+    sortKey?: string;
+  } = {
+    partitionKey: PARTITION_KEY,
+    sortKey: SORT_KEY,
+  },
+  log: XubeLog = XubeLog.getInstance()
+): Promise<XubeResponse<TableItem[]>> => {
+  let condition;
+
+  if (keys.SK) {
+    condition = (ExpressionAttributeNames) => {
+      ExpressionAttributeNames["#sk"] = keyLabels.sortKey ?? SORT_KEY;
+      return {
+        conditionExpression: "AND begins_with(#sk, :skPrefix)",
+        expressionValues: { ":skPrefix": keys.SK },
+      };
+    };
+  } else {
+    condition = undefined;
+  }
+
+  const params = buildQueryParams(
+    tableName,
+    keys,
+    indexName,
+    keyLabels,
+    condition
+  );
+
+  return executeQuery(params);
+};
+
+export const queryItemsFromTableUsingPKOnly = async (
+  tableName: string,
+  keys: { PK: string },
+  indexName: string | undefined,
+  keyLabels: {
+    partitionKey: string;
+  } = {
+    partitionKey: PARTITION_KEY,
+  },
+  log: XubeLog = XubeLog.getInstance()
+): Promise<XubeResponse<TableItem[]>> => {
+  const params = buildQueryParams(tableName, keys, indexName, keyLabels);
+  return executeQuery(params);
+};