effortless-aws 0.36.1 → 0.37.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
+};

package/dist/queue-client-WDAJYGQO.js

@@ -0,0 +1,57 @@
+import {
+  lazyImport
+} from "./chunk-U56MLLWP.js";
+
+// src/runtime/queue-client.ts
+var loadSdk = () => lazyImport("@aws-sdk/client-sqs");
+var createQueueClient = async (queueName) => {
+  const { SQS: SQSClient } = await loadSdk();
+  let client = null;
+  const getClient = () => client ??= new SQSClient({});
+  let resolvedUrl;
+  const getQueueUrl = async () => {
+    if (resolvedUrl) return resolvedUrl;
+    const result = await getClient().getQueueUrl({ QueueName: `${queueName}.fifo` });
+    resolvedUrl = result.QueueUrl;
+    return resolvedUrl;
+  };
+  return {
+    queueName,
+    async send(input) {
+      const queueUrl = await getQueueUrl();
+      await getClient().sendMessage({
+        QueueUrl: queueUrl,
+        MessageBody: JSON.stringify(input.body),
+        MessageGroupId: input.groupId,
+        ...input.deduplicationId ? { MessageDeduplicationId: input.deduplicationId } : {},
+        ...input.messageAttributes ? {
+          MessageAttributes: Object.fromEntries(
+            Object.entries(input.messageAttributes).map(([k, v]) => [k, {
+              DataType: v.dataType,
+              StringValue: v.stringValue
+            }])
+          )
+        } : {}
+      });
+    },
+    async sendBatch(messages) {
+      const queueUrl = await getQueueUrl();
+      const entries = messages.map((msg, i) => ({
+        Id: String(i),
+        MessageBody: JSON.stringify(msg.body),
+        MessageGroupId: msg.groupId,
+        ...msg.deduplicationId ? { MessageDeduplicationId: msg.deduplicationId } : {}
+      }));
+      const result = await getClient().sendMessageBatch({
+        QueueUrl: queueUrl,
+        Entries: entries
+      });
+      if (result.Failed && result.Failed.length > 0) {
+        throw new Error(`Failed to send ${result.Failed.length} message(s): ${result.Failed.map((f) => f.Message).join(", ")}`);
+      }
+    }
+  };
+};
+export {
+  createQueueClient
+};

package/dist/runtime/wrap-api.js

@@ -1,7 +1,10 @@
 import {
-  AUTH_COOKIE_NAME,
+  AUTH_COOKIE_NAME
+} from "../chunk-4UKWMWM5.js";
+import {
   createHandlerRuntime
-} from "../chunk-Q3ZDMZF3.js";
+} from "../chunk-3NKYT4OX.js";
+import "../chunk-VONNUUEN.js";
 
 // src/runtime/wrap-api.ts
 var CONTENT_TYPE_MAP = {
@@ -213,9 +216,11 @@ var wrapApi = (handler) => {
   if (isStream) {
     const streamify = globalThis.awslambda?.streamifyResponse;
     if (!streamify) {
-      return async (event) => handleRequest(event);
+      const fn3 = async (event) => handleRequest(event);
+      fn3.__preload = () => rt.preload();
+      return fn3;
     }
-    return streamify(async (event, rawStream) => {
+    const fn2 = streamify(async (event, rawStream) => {
       const HttpResponseStream = globalThis.awslambda?.HttpResponseStream;
       let streamUsed = false;
       let sseMode = false;
@@ -263,11 +268,15 @@ var wrapApi = (handler) => {
         rawStream.end();
       }
     });
+    fn2.__preload = () => rt.preload();
+    return fn2;
   }
-  return async (event) => {
+  const fn = async (event) => {
     const result = await handleRequest(event);
     return result ?? notFound();
   };
+  fn.__preload = () => rt.preload();
+  return fn;
 };
 export {
   wrapApi

package/dist/runtime/wrap-bucket.js

@@ -1,9 +1,14 @@
 import {
   createBucketClient,
-  createBucketClientWithEntities,
-  createHandlerRuntime,
+  createBucketClientWithEntities
+} from "../chunk-UU3AKDJU.js";
+import "../chunk-U56MLLWP.js";
+import {
+  createHandlerRuntime
+} from "../chunk-3NKYT4OX.js";
+import {
   toSeconds
-} from "../chunk-Q3ZDMZF3.js";
+} from "../chunk-VONNUUEN.js";
 
 // src/runtime/wrap-bucket.ts
 var ENV_DEP_SELF = "EFF_DEP_SELF";
@@ -34,7 +39,7 @@ var wrapBucket = (handler) => {
     return bucket ? { bucket } : {};
   });
   const handleError = handler.onError ?? (({ error }) => console.error(`[effortless:${rt.handlerName}]`, error));
-  return async (event) => {
+  const fn = async (event) => {
     const startTime = Date.now();
     rt.patchConsole();
     let ctxProps = {};
@@ -83,6 +88,8 @@ var wrapBucket = (handler) => {
       rt.restoreConsole();
     }
   };
+  fn.__preload = () => rt.preload();
+  return fn;
 };
 export {
   wrapBucket

package/dist/runtime/wrap-cron.js

@@ -1,6 +1,7 @@
 import {
   createHandlerRuntime
-} from "../chunk-Q3ZDMZF3.js";
+} from "../chunk-3NKYT4OX.js";
+import "../chunk-VONNUUEN.js";
 
 // src/runtime/wrap-cron.ts
 var wrapCron = (handler) => {
@@ -9,7 +10,7 @@ var wrapCron = (handler) => {
   }
   const rt = createHandlerRuntime(handler, "cron", handler.__spec.lambda?.logLevel ?? "info");
   const handleError = handler.onError ?? (({ error }) => console.error(`[effortless:${rt.handlerName}]`, error));
-  return async () => {
+  const fn = async () => {
     const startTime = Date.now();
     rt.patchConsole();
     let ctxProps = {};
@@ -34,6 +35,8 @@ var wrapCron = (handler) => {
       rt.restoreConsole();
     }
   };
+  fn.__preload = () => rt.preload();
+  return fn;
 };
 export {
   wrapCron

package/dist/runtime/wrap-fifo-queue.js

@@ -1,6 +1,7 @@
 import {
   createHandlerRuntime
-} from "../chunk-Q3ZDMZF3.js";
+} from "../chunk-3NKYT4OX.js";
+import "../chunk-VONNUUEN.js";
 
 // src/runtime/wrap-fifo-queue.ts
 var parseMessages = (rawRecords, schema) => {
@@ -34,7 +35,7 @@ var wrapFifoQueue = (handler) => {
   }
   const rt = createHandlerRuntime(handler, "fifo-queue", handler.__spec.lambda?.logLevel ?? "info");
   const handleError = handler.onError ?? (({ error }) => console.error(`[effortless:${rt.handlerName}]`, error));
-  return async (event) => {
+  const fn = async (event) => {
     const startTime = Date.now();
     rt.patchConsole();
     let ctxProps = {};
@@ -98,6 +99,8 @@ var wrapFifoQueue = (handler) => {
       rt.restoreConsole();
     }
   };
+  fn.__preload = () => rt.preload();
+  return fn;
 };
 export {
   wrapFifoQueue

package/dist/runtime/wrap-mcp.js

@@ -1,6 +1,7 @@
 import {
   createHandlerRuntime
-} from "../chunk-Q3ZDMZF3.js";
+} from "../chunk-3NKYT4OX.js";
+import "../chunk-VONNUUEN.js";
 
 // src/runtime/wrap-mcp.ts
 var ErrorCode = {
@@ -77,7 +78,7 @@ var wrapMcp = (handler) => {
   const serverName = handler.__spec.name;
   const serverVersion = handler.__spec.version ?? "1.0.0";
   const instructions = handler.__spec.instructions;
-  return async (event) => {
+  const fn = async (event) => {
     const startTime = Date.now();
     rt.patchConsole();
     let ctxProps = {};
@@ -135,6 +136,8 @@ var wrapMcp = (handler) => {
       rt.restoreConsole();
     }
   };
+  fn.__preload = () => rt.preload();
+  return fn;
 };
 async function handleMethod(req, ctx, tools, resourceMap, prompts, serverName, serverVersion, instructions) {
   switch (req.method) {