effortless-aws 0.36.1 → 0.38.0

package/dist/chunk-JFNBO4K3.js

@@ -0,0 +1,243 @@
+import {
+  lazyImport
+} from "./chunk-U56MLLWP.js";
+
+// src/runtime/table-client.ts
+import { marshall, unmarshall } from "@aws-sdk/util-dynamodb";
+var loadSdk = () => lazyImport("@aws-sdk/client-dynamodb");
+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 = async (tableName, options) => {
+  const { DynamoDB: DynamoDBClient } = await loadSdk();
+  let client = null;
+  const getClient = () => client ??= new DynamoDBClient({});
+  const tagField = options?.tagField ?? "tag";
+  return {
+    tableName,
+    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 getClient().putItem({
+        TableName: tableName,
+        Item: marshall(dynamoItem, { removeUndefinedValues: true }),
+        ...putOptions?.ifNotExists ? { ConditionExpression: "attribute_not_exists(pk)" } : {}
+      });
+    },
+    async get(key) {
+      const result = await getClient().getItem({
+        TableName: tableName,
+        Key: marshallKey(key)
+      });
+      return result.Item ? unmarshall(result.Item) : void 0;
+    },
+    async delete(key) {
+      await getClient().deleteItem({
+        TableName: tableName,
+        Key: marshallKey(key)
+      });
+    },
+    async update(key, actions) {
+      const names = {};
+      const values = {};
+      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(`${DATA_ALIAS}.${alias} = ${valAlias}`);
+          counter++;
+        }
+      }
+      if (actions.increment) {
+        for (const [attr, val] of Object.entries(actions.increment)) {
+          needsDataAlias = true;
+          const alias = `#a${counter}`;
+          const valAlias = `:v${counter}`;
+          const zeroAlias = `:zero${counter}`;
+          names[alias] = attr;
+          values[valAlias] = val;
+          values[zeroAlias] = 0;
+          setClauses.push(`${DATA_ALIAS}.${alias} = if_not_exists(${DATA_ALIAS}.${alias}, ${zeroAlias}) + ${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(`${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(`${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;
+      const request = {
+        TableName: tableName,
+        Key: marshallKey(key),
+        UpdateExpression: parts.join(" "),
+        ExpressionAttributeNames: names,
+        ...Object.keys(values).length ? { ExpressionAttributeValues: marshall(values, { removeUndefinedValues: true }) } : {}
+      };
+      try {
+        await getClient().updateItem(request);
+      } catch (err) {
+        if (needsDataAlias && err.name === "ValidationException") {
+          const dataMap = {};
+          if (actions.set) Object.assign(dataMap, actions.set);
+          if (actions.increment) Object.assign(dataMap, actions.increment);
+          if (actions.append) Object.assign(dataMap, actions.append);
+          const retryNames = { "#data": "data" };
+          const retryValues = { ":fullData": dataMap };
+          const retrySets = ["#data = :fullData"];
+          if (actions.tag !== void 0) {
+            retryNames["#tag"] = "tag";
+            retryValues[":tagVal"] = actions.tag;
+            retrySets.push("#tag = :tagVal");
+          }
+          if (actions.ttl !== void 0 && actions.ttl !== null) {
+            retryNames["#ttl"] = "ttl";
+            retryValues[":ttlVal"] = actions.ttl;
+            retrySets.push("#ttl = :ttlVal");
+          }
+          const retryParts = [`SET ${retrySets.join(", ")}`];
+          if (actions.ttl === null) {
+            retryNames["#ttl"] = "ttl";
+            retryParts.push("REMOVE #ttl");
+          }
+          await getClient().updateItem({
+            TableName: tableName,
+            Key: marshallKey(key),
+            UpdateExpression: retryParts.join(" "),
+            ExpressionAttributeNames: retryNames,
+            ExpressionAttributeValues: marshall(retryValues, { removeUndefinedValues: true })
+          });
+        } else {
+          throw err;
+        }
+      }
+    },
+    async query(params) {
+      const names = { "#pk": "pk" };
+      const values = { ":pk": params.pk };
+      let keyCondition = "#pk = :pk";
+      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 getClient().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 getClient().query({
+        TableName: tableName,
+        IndexName: GSI_TAG_PK,
+        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));
+    }
+  };
+};
+
+export {
+  createTableClient
+};

package/dist/chunk-U56MLLWP.js

@@ -0,0 +1,6 @@
+// src/runtime/lazy-import.ts
+var lazyImport = (pkg) => import(pkg);
+
+export {
+  lazyImport
+};

package/dist/chunk-UU3AKDJU.js

@@ -0,0 +1,159 @@
+import {
+  lazyImport
+} from "./chunk-U56MLLWP.js";
+
+// src/runtime/bucket-client.ts
+var loadSdk = () => lazyImport("@aws-sdk/client-s3");
+var createBucketMethods = (getClient, bucketName) => ({
+  bucketName,
+  async put(key, body, options) {
+    await getClient().putObject({
+      Bucket: bucketName,
+      Key: key,
+      Body: typeof body === "string" ? Buffer.from(body) : body,
+      ...options?.contentType ? { ContentType: options.contentType } : {}
+    });
+  },
+  async get(key) {
+    try {
+      const result = await getClient().getObject({
+        Bucket: bucketName,
+        Key: key
+      });
+      const chunks = [];
+      const stream = result.Body;
+      for await (const chunk of stream) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      }
+      return {
+        body: Buffer.concat(chunks),
+        contentType: result.ContentType
+      };
+    } catch (error) {
+      if (error instanceof Error && (error.name === "NoSuchKey" || error.$metadata?.httpStatusCode === 404)) {
+        return void 0;
+      }
+      throw error;
+    }
+  },
+  async delete(key) {
+    await getClient().deleteObject({
+      Bucket: bucketName,
+      Key: key
+    });
+  },
+  async list(prefix) {
+    const items = [];
+    let continuationToken;
+    do {
+      const result = await getClient().listObjectsV2({
+        Bucket: bucketName,
+        ...prefix ? { Prefix: prefix } : {},
+        ...continuationToken ? { ContinuationToken: continuationToken } : {}
+      });
+      for (const obj of result.Contents ?? []) {
+        if (obj.Key) {
+          items.push({
+            key: obj.Key,
+            size: obj.Size ?? 0,
+            lastModified: obj.LastModified
+          });
+        }
+      }
+      continuationToken = result.IsTruncated ? result.NextContinuationToken : void 0;
+    } while (continuationToken);
+    return items;
+  }
+});
+var createEntityClient = (getClient, bucketName, entityName, cacheSeconds) => {
+  const entityKey = (id) => `${entityName}/${id}.json`;
+  return {
+    async put(id, data) {
+      await getClient().putObject({
+        Bucket: bucketName,
+        Key: entityKey(id),
+        Body: JSON.stringify(data),
+        ContentType: "application/json",
+        ...cacheSeconds != null ? { CacheControl: `public, max-age=${cacheSeconds}` } : {}
+      });
+    },
+    async get(id) {
+      try {
+        const result = await getClient().getObject({
+          Bucket: bucketName,
+          Key: entityKey(id)
+        });
+        const chunks = [];
+        const stream = result.Body;
+        for await (const chunk of stream) {
+          chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        }
+        return JSON.parse(Buffer.concat(chunks).toString("utf-8"));
+      } catch (error) {
+        if (error instanceof Error && (error.name === "NoSuchKey" || error.$metadata?.httpStatusCode === 404)) {
+          return void 0;
+        }
+        throw error;
+      }
+    },
+    async delete(id) {
+      await getClient().deleteObject({
+        Bucket: bucketName,
+        Key: entityKey(id)
+      });
+    },
+    async list() {
+      const items = [];
+      let continuationToken;
+      const prefix = `${entityName}/`;
+      do {
+        const result = await getClient().listObjectsV2({
+          Bucket: bucketName,
+          Prefix: prefix,
+          ...continuationToken ? { ContinuationToken: continuationToken } : {}
+        });
+        for (const obj of result.Contents ?? []) {
+          if (!obj.Key || !obj.Key.endsWith(".json")) continue;
+          const id = obj.Key.slice(prefix.length, -".json".length);
+          try {
+            const getResult = await getClient().getObject({
+              Bucket: bucketName,
+              Key: obj.Key
+            });
+            const chunks = [];
+            const stream = getResult.Body;
+            for await (const chunk of stream) {
+              chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            }
+            items.push({ id, data: JSON.parse(Buffer.concat(chunks).toString("utf-8")) });
+          } catch {
+          }
+        }
+        continuationToken = result.IsTruncated ? result.NextContinuationToken : void 0;
+      } while (continuationToken);
+      return items;
+    }
+  };
+};
+var createBucketClient = async (bucketName) => {
+  const { S3: S3Client } = await loadSdk();
+  let client = null;
+  const getClient = () => client ??= new S3Client({});
+  return createBucketMethods(getClient, bucketName);
+};
+var createBucketClientWithEntities = async (bucketName, entitiesConfig) => {
+  const { S3: S3Client } = await loadSdk();
+  let client = null;
+  const getClient = () => client ??= new S3Client({});
+  const base = createBucketMethods(getClient, bucketName);
+  const result = { ...base };
+  for (const [entityName, config] of Object.entries(entitiesConfig)) {
+    result[entityName] = createEntityClient(getClient, bucketName, entityName, config.cacheSeconds);
+  }
+  return result;
+};
+
+export {
+  createBucketClient,
+  createBucketClientWithEntities
+};

package/dist/chunk-VONNUUEN.js

@@ -0,0 +1,16 @@
+// src/handlers/handler-options.ts
+var toSeconds = (d) => {
+  if (typeof d === "number") return d;
+  const match = d.match(/^(\d+(?:\.\d+)?)(s|m|h|d)$/);
+  if (!match) throw new Error(`Invalid duration: "${d}"`);
+  const n = Number(match[1]);
+  const unit = match[2];
+  if (unit === "d") return n * 86400;
+  if (unit === "h") return n * 3600;
+  if (unit === "m") return n * 60;
+  return n;
+};
+
+export {
+  toSeconds
+};

package/dist/email-client-RMDQDOYI.js

@@ -0,0 +1,34 @@
+import {
+  lazyImport
+} from "./chunk-U56MLLWP.js";
+
+// src/runtime/email-client.ts
+var loadSdk = () => lazyImport("@aws-sdk/client-sesv2");
+var createEmailClient = async () => {
+  const { SESv2Client: Cls, SendEmailCommand } = await loadSdk();
+  let client = null;
+  const getClient = () => client ??= new Cls({});
+  return {
+    async send({ from, to, subject, html, text }) {
+      const toAddresses = Array.isArray(to) ? to : [to];
+      await getClient().send(
+        new SendEmailCommand({
+          FromEmailAddress: from,
+          Destination: { ToAddresses: toAddresses },
+          Content: {
+            Simple: {
+              Subject: { Data: subject },
+              Body: {
+                ...html ? { Html: { Data: html } } : {},
+                ...text ? { Text: { Data: text } } : {}
+              }
+            }
+          }
+        })
+      );
+    }
+  };
+};
+export {
+  createEmailClient
+};