effortless-aws 0.8.1 → 0.10.0

package/dist/{chunk-B4P7ZKNM.js → chunk-HINWSFWC.js}

@@ -1,28 +1,67 @@
 // src/runtime/table-client.ts
 import { DynamoDB } from "@aws-sdk/client-dynamodb";
 import { marshall, unmarshall } from "@aws-sdk/util-dynamodb";
-var createTableClient = (tableName) => {
+var GSI_TAG_PK = "tag-pk-index";
+var marshallKey = (key) => marshall(key, { removeUndefinedValues: true });
+var buildSkCondition = (sk) => {
+  const names = { "#sk": "sk" };
+  if (typeof sk === "string") {
+    return { expression: "AND #sk = :sk", names, values: { ":sk": sk } };
+  }
+  if ("begins_with" in sk) {
+    return { expression: "AND begins_with(#sk, :sk)", names, values: { ":sk": sk.begins_with } };
+  }
+  if ("gt" in sk) {
+    return { expression: "AND #sk > :sk", names, values: { ":sk": sk.gt } };
+  }
+  if ("gte" in sk) {
+    return { expression: "AND #sk >= :sk", names, values: { ":sk": sk.gte } };
+  }
+  if ("lt" in sk) {
+    return { expression: "AND #sk < :sk", names, values: { ":sk": sk.lt } };
+  }
+  if ("lte" in sk) {
+    return { expression: "AND #sk <= :sk", names, values: { ":sk": sk.lte } };
+  }
+  if ("between" in sk) {
+    return { expression: "AND #sk BETWEEN :sk1 AND :sk2", names, values: { ":sk1": sk.between[0], ":sk2": sk.between[1] } };
+  }
+  return { expression: "", names: {}, values: {} };
+};
+var createTableClient = (tableName, options) => {
   let client2 = null;
   const getClient2 = () => client2 ??= new DynamoDB({});
+  const tagField = options?.tagField ?? "tag";
   return {
     tableName,
-    async put(item) {
+    async put(item, putOptions) {
+      const dataObj = item.data;
+      const tag = dataObj?.[tagField] || "";
+      if (!tag) throw new Error(`tag is required: data must include a "${tagField}" field`);
+      const dynamoItem = {
+        pk: item.pk,
+        sk: item.sk,
+        tag,
+        data: item.data
+      };
+      if (item.ttl !== void 0) dynamoItem.ttl = item.ttl;
       await getClient2().putItem({
         TableName: tableName,
-        Item: marshall(item, { removeUndefinedValues: true })
+        Item: marshall(dynamoItem, { removeUndefinedValues: true }),
+        ...putOptions?.ifNotExists ? { ConditionExpression: "attribute_not_exists(pk)" } : {}
       });
     },
     async get(key) {
       const result = await getClient2().getItem({
         TableName: tableName,
-        Key: marshall(key, { removeUndefinedValues: true })
+        Key: marshallKey(key)
       });
       return result.Item ? unmarshall(result.Item) : void 0;
     },
     async delete(key) {
       await getClient2().deleteItem({
         TableName: tableName,
-        Key: marshall(key, { removeUndefinedValues: true })
+        Key: marshallKey(key)
       });
     },
     async update(key, actions) {
@@ -31,63 +70,108 @@ var createTableClient = (tableName) => {
       const setClauses = [];
       const removeClauses = [];
       let counter = 0;
+      const DATA_ALIAS = "#data";
+      let needsDataAlias = false;
       if (actions.set) {
         for (const [attr, val] of Object.entries(actions.set)) {
+          needsDataAlias = true;
           const alias = `#a${counter}`;
           const valAlias = `:v${counter}`;
           names[alias] = attr;
           values[valAlias] = val;
-          setClauses.push(`${alias} = ${valAlias}`);
+          setClauses.push(`${DATA_ALIAS}.${alias} = ${valAlias}`);
           counter++;
         }
       }
       if (actions.append) {
         for (const [attr, val] of Object.entries(actions.append)) {
+          needsDataAlias = true;
           const alias = `#a${counter}`;
           const valAlias = `:v${counter}`;
           const emptyAlias = `:empty${counter}`;
           names[alias] = attr;
           values[valAlias] = val;
           values[emptyAlias] = [];
-          setClauses.push(`${alias} = list_append(if_not_exists(${alias}, ${emptyAlias}), ${valAlias})`);
+          setClauses.push(`${DATA_ALIAS}.${alias} = list_append(if_not_exists(${DATA_ALIAS}.${alias}, ${emptyAlias}), ${valAlias})`);
           counter++;
         }
       }
       if (actions.remove) {
         for (const attr of actions.remove) {
+          needsDataAlias = true;
           const alias = `#a${counter}`;
           names[alias] = attr;
-          removeClauses.push(alias);
+          removeClauses.push(`${DATA_ALIAS}.${alias}`);
           counter++;
         }
       }
+      if (needsDataAlias) {
+        names[DATA_ALIAS] = "data";
+      }
+      if (actions.tag !== void 0) {
+        names["#tag"] = "tag";
+        values[":tagVal"] = actions.tag;
+        setClauses.push("#tag = :tagVal");
+      }
+      if (actions.ttl !== void 0) {
+        names["#ttl"] = "ttl";
+        if (actions.ttl === null) {
+          removeClauses.push("#ttl");
+        } else {
+          values[":ttlVal"] = actions.ttl;
+          setClauses.push("#ttl = :ttlVal");
+        }
+      }
       const parts = [];
       if (setClauses.length) parts.push(`SET ${setClauses.join(", ")}`);
       if (removeClauses.length) parts.push(`REMOVE ${removeClauses.join(", ")}`);
       if (!parts.length) return;
       await getClient2().updateItem({
         TableName: tableName,
-        Key: marshall(key, { removeUndefinedValues: true }),
+        Key: marshallKey(key),
         UpdateExpression: parts.join(" "),
         ExpressionAttributeNames: names,
         ...Object.keys(values).length ? { ExpressionAttributeValues: marshall(values, { removeUndefinedValues: true }) } : {}
       });
     },
     async query(params) {
-      const names = { "#pk": params.pk.name };
-      const values = { ":pk": params.pk.value };
+      const names = { "#pk": "pk" };
+      const values = { ":pk": params.pk };
       let keyCondition = "#pk = :pk";
-      if (params.sk) {
-        names["#sk"] = params.sk.name;
-        values[":sk"] = params.sk.value;
-        if (params.sk.condition === "begins_with") {
-          keyCondition += " AND begins_with(#sk, :sk)";
-        } else {
-          keyCondition += ` AND #sk ${params.sk.condition} :sk`;
+      if (params.sk !== void 0) {
+        const skCond = buildSkCondition(params.sk);
+        keyCondition += ` ${skCond.expression}`;
+        Object.assign(names, skCond.names);
+        Object.assign(values, skCond.values);
+      }
+      const result = await getClient2().query({
+        TableName: tableName,
+        KeyConditionExpression: keyCondition,
+        ExpressionAttributeNames: names,
+        ExpressionAttributeValues: marshall(values, { removeUndefinedValues: true }),
+        ...params.limit ? { Limit: params.limit } : {},
+        ...params.scanIndexForward !== void 0 ? { ScanIndexForward: params.scanIndexForward } : {}
+      });
+      return (result.Items ?? []).map((item) => unmarshall(item));
+    },
+    async queryByTag(params) {
+      const names = { "#tag": "tag" };
+      const values = { ":tag": params.tag };
+      let keyCondition = "#tag = :tag";
+      if (params.pk !== void 0) {
+        const pkCond = buildSkCondition(params.pk);
+        const remapped = pkCond.expression.replace(/#sk/g, "#pk").replace(/:sk/g, ":pk");
+        keyCondition += ` ${remapped}`;
+        for (const [k, v] of Object.entries(pkCond.names)) {
+          names[k === "#sk" ? "#pk" : k] = v === "sk" ? "pk" : v;
+        }
+        for (const [k, v] of Object.entries(pkCond.values)) {
+          values[k.replace(":sk", ":pk")] = v;
         }
       }
       const result = await getClient2().query({
         TableName: tableName,
+        IndexName: GSI_TAG_PK,
         KeyConditionExpression: keyCondition,
         ExpressionAttributeNames: names,
         ExpressionAttributeValues: marshall(values, { removeUndefinedValues: true }),
@@ -167,7 +251,7 @@ var buildParams = async (params) => {
   return result;
 };
 var readStatic = (filePath) => readFileSync(join(process.cwd(), filePath), "utf-8");
-var createHandlerRuntime = (handler, handlerType, logLevel = "info") => {
+var createHandlerRuntime = (handler, handlerType, logLevel = "info", extraSetupArgs) => {
   const handlerName = process.env.EFF_HANDLER ?? "unknown";
   const rank = LOG_RANK[logLevel];
   let ctx = null;
@@ -187,7 +271,8 @@ var createHandlerRuntime = (handler, handlerType, logLevel = "info") => {
       const args = {};
       if (params) args.config = params;
       if (deps) args.deps = deps;
-      ctx = Object.keys(args).length > 0 ? await handler.setup(args) : await handler.setup();
+      if (extraSetupArgs) Object.assign(args, extraSetupArgs());
+      ctx = Object.keys(args).length > 0 || extraSetupArgs ? await handler.setup(args) : await handler.setup();
     }
     return ctx;
   };