effortless-aws 0.1.0 → 0.2.0

package/dist/{chunk-I5TS7O5S.js → chunk-7JVA4742.js}

@@ -99,6 +99,21 @@ var createTableClient = (tableName) => {
   };
 };
 
+// src/runtime/platform-types.ts
+var ENV_PLATFORM_TABLE = "EFF_PLATFORM_TABLE";
+var DEFAULT_TTL_SECONDS = 7 * 24 * 60 * 60;
+var truncateForStorage = (value, maxLength = 4096) => {
+  if (value === void 0 || value === null) return value;
+  const str = typeof value === "string" ? value : JSON.stringify(value);
+  if (str.length <= maxLength) return value;
+  return str.slice(0, maxLength) + "...[truncated]";
+};
+var dateBucket = (date = /* @__PURE__ */ new Date()) => date.toISOString().slice(0, 10);
+var computeTtl = (ttlSeconds = DEFAULT_TTL_SECONDS) => Math.floor(Date.now() / 1e3) + ttlSeconds;
+
+// src/runtime/handler-utils.ts
+import { randomUUID } from "crypto";
+
 // src/runtime/ssm-client.ts
 import { SSM } from "@aws-sdk/client-ssm";
 var client = null;
@@ -120,6 +135,89 @@ var getParameters = async (names) => {
   return map;
 };
 
+// src/runtime/platform-client.ts
+import { DynamoDB as DynamoDB2 } from "@aws-sdk/client-dynamodb";
+import { marshall as marshall2, unmarshall as unmarshall2 } from "@aws-sdk/util-dynamodb";
+var createPlatformClient = () => {
+  const tableName = process.env[ENV_PLATFORM_TABLE];
+  if (!tableName) return void 0;
+  let client2 = null;
+  const getClient2 = () => client2 ??= new DynamoDB2({});
+  const appendToList = async (handlerName, handlerType, listAttr, entry) => {
+    const sk = `EXEC#${dateBucket()}`;
+    try {
+      await getClient2().updateItem({
+        TableName: tableName,
+        Key: marshall2({ pk: `HANDLER#${handlerName}`, sk }),
+        UpdateExpression: "SET #list = list_append(if_not_exists(#list, :empty), :entry), #type = :type, #hn = :hn, #ht = :ht, #ttl = :ttl",
+        ExpressionAttributeNames: {
+          "#list": listAttr,
+          "#type": "type",
+          "#hn": "handlerName",
+          "#ht": "handlerType",
+          "#ttl": "ttl"
+        },
+        ExpressionAttributeValues: marshall2(
+          {
+            ":entry": [entry],
+            ":empty": [],
+            ":type": "execution-log",
+            ":hn": handlerName,
+            ":ht": handlerType,
+            ":ttl": computeTtl()
+          },
+          { removeUndefinedValues: true }
+        )
+      });
+    } catch (err) {
+      console.error("[effortless] Failed to write platform record:", err);
+    }
+  };
+  return {
+    tableName,
+    async appendExecution(handlerName, handlerType, entry) {
+      await appendToList(handlerName, handlerType, "executions", entry);
+    },
+    async appendError(handlerName, handlerType, entry) {
+      await appendToList(handlerName, handlerType, "errors", entry);
+    },
+    async get(pk, sk) {
+      const result = await getClient2().getItem({
+        TableName: tableName,
+        Key: marshall2({ pk, sk })
+      });
+      return result.Item ? unmarshall2(result.Item) : void 0;
+    },
+    async query(pk, skPrefix) {
+      const names = { "#pk": "pk" };
+      const values = { ":pk": pk };
+      let keyCondition = "#pk = :pk";
+      if (skPrefix) {
+        names["#sk"] = "sk";
+        values[":sk"] = skPrefix;
+        keyCondition += " AND begins_with(#sk, :sk)";
+      }
+      const result = await getClient2().query({
+        TableName: tableName,
+        KeyConditionExpression: keyCondition,
+        ExpressionAttributeNames: names,
+        ExpressionAttributeValues: marshall2(values, { removeUndefinedValues: true })
+      });
+      return (result.Items ?? []).map((item) => unmarshall2(item));
+    },
+    async put(entity) {
+      try {
+        await getClient2().putItem({
+          TableName: tableName,
+          Item: marshall2(entity, { removeUndefinedValues: true })
+        });
+      } catch (err) {
+        console.error("[effortless] Failed to write platform record:", err);
+      }
+    }
+  };
+};
+
 // src/runtime/handler-utils.ts
 var ENV_TABLE_PREFIX = "EFF_TABLE_";
 var ENV_PARAM_PREFIX = "EFF_PARAM_";
@@ -155,9 +253,58 @@ var buildParams = async (params) => {
   }
   return result;
 };
+var createHandlerRuntime = (handler, handlerType) => {
+  const platform = createPlatformClient();
+  const handlerName = process.env.EFF_HANDLER ?? "unknown";
+  let ctx = null;
+  let resolvedDeps;
+  let resolvedParams = null;
+  const getDeps = () => resolvedDeps ??= buildDeps(handler.deps);
+  const getParams = async () => {
+    if (resolvedParams !== null) return resolvedParams;
+    resolvedParams = await buildParams(handler.params);
+    return resolvedParams;
+  };
+  const getCtx = async () => {
+    if (ctx !== null) return ctx;
+    if (handler.context) {
+      const params = await getParams();
+      ctx = params ? await handler.context({ params }) : await handler.context();
+    }
+    return ctx;
+  };
+  const commonArgs = async () => {
+    const args = {};
+    if (handler.context) args.ctx = await getCtx();
+    const deps = getDeps();
+    if (deps) args.deps = deps;
+    const params = await getParams();
+    if (params) args.params = params;
+    return args;
+  };
+  const logExecution = (startTime, input, output) => {
+    platform?.appendExecution(handlerName, handlerType, {
+      id: randomUUID(),
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      ms: Date.now() - startTime,
+      in: input,
+      out: truncateForStorage(output)
+    });
+  };
+  const logError = (startTime, input, error) => {
+    platform?.appendError(handlerName, handlerType, {
+      id: randomUUID(),
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      ms: Date.now() - startTime,
+      in: input,
+      err: error instanceof Error ? error.message : String(error)
+    });
+  };
+  return { commonArgs, logExecution, logError, handlerName };
+};
 
 export {
   createTableClient,
-  buildDeps,
-  buildParams
+  truncateForStorage,
+  createHandlerRuntime
 };