@cloudnux/local-cloud-provider 0.19.0 → 0.21.0

package/dist/index.js

@@ -677,11 +677,11 @@ function stringToArray(string) {
 var stringToArray_default = stringToArray;
 
 // ../../../node_modules/lodash-es/_hasPath.js
-function hasPath(object, path3, hasFunc) {
-  path3 = castPath_default(path3, object);
-  var index = -1, length = path3.length, result = false;
+function hasPath(object, path4, hasFunc) {
+  path4 = castPath_default(path4, object);
+  var index = -1, length = path4.length, result = false;
   while (++index < length) {
-    var key = toKey_default(path3[index]);
+    var key = toKey_default(path4[index]);
     if (!(result = object != null && hasFunc(object, key))) {
       break;
     }
@@ -704,8 +704,8 @@ function baseHas(object, key) {
 var baseHas_default = baseHas;
 
 // ../../../node_modules/lodash-es/has.js
-function has(object, path3) {
-  return object != null && hasPath_default(object, path3, baseHas_default);
+function has(object, path4) {
+  return object != null && hasPath_default(object, path4, baseHas_default);
 }
 var has_default = has;
 
@@ -823,147 +823,11 @@ var utils = {
 };
 var env = Object.assign(_env, utils);
 
-// ../../utils/src/auth/token.ts
-import * as crypto from "crypto";
-function parseTimeToMs(time) {
-  if (typeof time === "number") return time * 1e3;
-  const match = time.match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/);
-  if (!match) return 0;
-  const value = parseFloat(match[1]);
-  const unit = match[2];
-  switch (unit) {
-    case "ms":
-      return value;
-    case "s":
-      return value * 1e3;
-    case "m":
-      return value * 60 * 1e3;
-    case "h":
-      return value * 60 * 60 * 1e3;
-    case "d":
-      return value * 24 * 60 * 60 * 1e3;
-    default:
-      return 0;
-  }
-}
-function base64UrlEncode(input) {
-  const str = typeof input === "string" ? input : input.toString("base64");
-  return str.replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
-}
-function base64UrlDecode(input) {
-  let str = input.replace(/-/g, "+").replace(/_/g, "/");
-  while (str.length % 4) {
-    str += "=";
-  }
-  return Buffer.from(str, "base64");
-}
-function createAccessToken(claims, privateKey, expiresIn = "1h") {
-  const now = Math.floor(Date.now() / 1e3);
-  const header = {
-    alg: "HS256",
-    typ: "JWT"
-  };
-  const payload = {
-    ...claims,
-    aud: ["*"],
-    iat: now,
-    iss: "vcg-identity",
-    jti: Date.now().toString()
-  };
-  if (expiresIn) {
-    const expiryMs = parseTimeToMs(expiresIn);
-    payload.exp = now + Math.floor(expiryMs / 1e3);
-  }
-  const notBefore = "100ms";
-  if (notBefore) {
-    const notBeforeMs = parseTimeToMs(notBefore);
-    payload.nbf = now + Math.floor(notBeforeMs / 1e3);
-  }
-  const encodedHeader = base64UrlEncode(JSON.stringify(header));
-  const encodedPayload = base64UrlEncode(JSON.stringify(payload));
-  const signatureInput = `${encodedHeader}.${encodedPayload}`;
-  const signature = crypto.createHmac("sha256", privateKey).update(signatureInput).digest();
-  const encodedSignature = base64UrlEncode(signature);
-  return `${encodedHeader}.${encodedPayload}.${encodedSignature}`;
-}
-function createRefreshToken() {
-  const bytes = crypto.randomBytes(16);
-  bytes[6] = bytes[6] & 15 | 64;
-  bytes[8] = bytes[8] & 63 | 128;
-  return bytes.toString("hex");
-}
-function decode(token) {
-  try {
-    const parts = token.split(".");
-    if (parts.length !== 3) return null;
-    const payload = JSON.parse(
-      base64UrlDecode(parts[1]).toString("utf8")
-    );
-    return payload;
-  } catch {
-    return null;
-  }
-}
-function verify(token, privateKey, options = {}) {
-  return new Promise((resolve, reject) => {
-    try {
-      const parts = token.split(".");
-      if (parts.length !== 3) {
-        return reject(new Error("Invalid token format"));
-      }
-      const [encodedHeader, encodedPayload, encodedSignature] = parts;
-      const signatureInput = `${encodedHeader}.${encodedPayload}`;
-      const expectedSignature = crypto.createHmac("sha256", privateKey).update(signatureInput).digest();
-      const providedSignature = base64UrlDecode(encodedSignature);
-      const signatureValid = crypto.timingSafeEqual(
-        expectedSignature,
-        providedSignature
-      );
-      if (!signatureValid) {
-        return reject(new Error("Invalid signature"));
-      }
-      const payload = JSON.parse(
-        base64UrlDecode(encodedPayload).toString("utf8")
-      );
-      if (!options.ignoreExpiration && payload.exp) {
-        const now = Math.floor(Date.now() / 1e3);
-        if (now >= payload.exp) {
-          return reject(new Error("Token expired"));
-        }
-      }
-      if (payload.nbf) {
-        const now = Math.floor(Date.now() / 1e3);
-        if (now < payload.nbf) {
-          return reject(new Error("Token not yet valid"));
-        }
-      }
-      if (options.issuer && payload.iss !== options.issuer) {
-        return reject(new Error("Invalid issuer"));
-      }
-      if (options.audience) {
-        const audiences = Array.isArray(options.audience) ? options.audience : [options.audience];
-        const tokenAudiences = Array.isArray(payload.aud) ? payload.aud : [payload.aud];
-        const validAudience = audiences.some(
-          (aud) => tokenAudiences.includes(aud)
-        );
-        if (!validAudience) {
-          return reject(new Error("Invalid audience"));
-        }
-      }
-      resolve(payload);
-    } catch (error) {
-      reject(error);
-    }
-  });
-}
-var tokenUtils = {
-  createAccessToken,
-  createRefreshToken,
-  decodeAccessToken: decode,
-  verifyAccessToken: verify
-};
-
 // src/services/event-broker.ts
+var TOPIC_PREFIX = "topic:";
+function isTopicTarget(target) {
+  return target.startsWith(TOPIC_PREFIX);
+}
 function createLocalEventBrokerService() {
   const baseURL = env("DEV_CLOUD_EVENT_BROKER_URL");
   function getQueueUrl(queueName) {
@@ -972,6 +836,10 @@ function createLocalEventBrokerService() {
     }
     return `${baseURL}/${queueName}`;
   }
+  function getTopicUrl(target) {
+    const topicName = target.slice(TOPIC_PREFIX.length);
+    return `${baseURL}/topics/${topicName}`;
+  }
   function parseMessage(data) {
     const body = typeof data.body === "object" ? JSON.stringify(data.body) : data.body ?? "";
     return {
@@ -993,7 +861,7 @@ function createLocalEventBrokerService() {
     async publish(target, message, options) {
       if (!target)
         throw new Error("Target queue name or URL is required for publishing a message.");
-      const queueUrl = getQueueUrl(target);
+      const publishUrl = isTopicTarget(target) ? getTopicUrl(target) : getQueueUrl(target);
       const headers = {};
       if (options?.attributes) {
         Object.entries(options.attributes).forEach(([key, value]) => {
@@ -1010,7 +878,7 @@ function createLocalEventBrokerService() {
         headers["x-delay-seconds"] = options.delaySeconds.toString();
       }
       const body = typeof message === "string" ? message : message;
-      await axios.post(queueUrl, body, { headers });
+      await axios.post(publishUrl, body, { headers });
     },
     /**
      * Peek at messages in a queue without removing them
@@ -1586,6 +1454,7 @@ function createLocalLocationService() {
 // src/services/functions.ts
 import * as querystring from "querystring";
 import "fastify-raw-body";
+import { parseCookieHeader } from "@cloudnux/core-cloud-provider";
 var getFullUrlFromRequest = (request) => {
   const protocol = request.protocol;
   const hostname = request.hostname;
@@ -1601,13 +1470,11 @@ function createLocalFunctionsService() {
   return {
     createHttRequest(request) {
       const rawBody = request.rawBody;
-      const isAuth = env("DEV_IDENTITY");
-      const index = request.raw.rawHeaders ? request.raw.rawHeaders?.indexOf("Authorization") : -1;
-      const authorization = index !== -1 ? request.raw.rawHeaders[index + 1] : null;
-      const token = authorization ? authorization.replace(/^bearer\s+/i, "") : null;
+      const cookieHeader = request.headers.cookie;
       const httpRequest = {
         body: String(rawBody),
         headers: request.headers,
+        cookies: parseCookieHeader(Array.isArray(cookieHeader) ? cookieHeader.join("; ") : cookieHeader),
         method: request.method,
         url: getFullUrlFromRequest(request),
         matchingKey: request.routeOptions.url,
@@ -1617,28 +1484,7 @@ function createLocalFunctionsService() {
         requestId: request.id,
         moduleName: request.routeOptions.config?.module
       };
-      const jwtClaims = token && tokenUtils.decodeAccessToken(token);
-      const httpAuth = isAuth ? {
-        appId: env("DEV_APP_ID"),
-        memberId: env("DEV_MEMBER_ID"),
-        customerId: env("DEV_CUSTOMER_ID"),
-        identity: env("DEV_IDENTITY"),
-        token: token ?? "",
-        claims: {
-          app_id: env("DEV_APP_ID"),
-          member_id: env("DEV_MEMBER_ID"),
-          customer_id: env("DEV_CUSTOMER_ID"),
-          identity: env("DEV_IDENTITY", "facebook")
-        }
-      } : jwtClaims ? {
-        token,
-        claims: jwtClaims,
-        appId: jwtClaims.app_id,
-        memberId: jwtClaims.member_id,
-        customerId: jwtClaims.customer_id,
-        identity: jwtClaims.identity
-      } : void 0;
-      return [httpRequest, httpAuth];
+      return [httpRequest];
     },
     createScheduleRequest: (job, execution) => {
       const scheduleName = job.name;
@@ -1685,7 +1531,11 @@ function createLocalFunctionsService() {
       return [invokeRequest];
     },
     buildHttpResponse: (context, _, reply) => {
-      reply.headers(context.response.headers ?? {}).status(context.response.status).send(context.response.body);
+      const headers = { ...context.response.headers ?? {} };
+      if (context.response.cookies?.length) {
+        headers["set-cookie"] = context.response.cookies;
+      }
+      reply.headers(headers).status(context.response.status).send(context.response.body);
     },
     buildScheduleResponse: (context) => {
       if (context.response.status === "error") {
@@ -1883,6 +1733,168 @@ function createLocalLoggerService() {
   return logger;
 }
 
+// src/services/email.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { randomUUID } from "crypto";
+import { getService as getService3 } from "@cloudnux/core-cloud-provider";
+var { mkdir: mkdir3, writeFile: writeFile3, readdir, readFile: readFile3, unlink: unlink2 } = fs3.promises;
+var MAX_HISTORY = 100;
+var PREVIEW_LENGTH = 150;
+function resolveBaseDir() {
+  return env("DEV_CLOUD_EMAIL_DIR", path3.join(process.cwd(), ".local-email"));
+}
+function toArray(value) {
+  if (!value) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function assertValidMessage(message) {
+  if (!message.to || Array.isArray(message.to) && message.to.length === 0) {
+    throw new Error("At least one recipient (to) is required");
+  }
+  if (!message.from) {
+    throw new Error("Sender (from) is required");
+  }
+  if (!message.subject) {
+    throw new Error("Subject is required");
+  }
+  if (!message.html && !message.text) {
+    throw new Error("At least one of html or text is required");
+  }
+}
+function slugify(subject) {
+  const slug = subject.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return (slug || "email").slice(0, 50);
+}
+function stripHtml(html) {
+  return html.replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<[^>]+>/g, " ");
+}
+function buildPreview(message) {
+  const source = message.text ?? stripHtml(message.html ?? "");
+  const collapsed = source.replace(/\s+/g, " ").trim();
+  return collapsed.length > PREVIEW_LENGTH ? collapsed.slice(0, PREVIEW_LENGTH).trimEnd() + "\u2026" : collapsed;
+}
+function encodeHeaderValue(value) {
+  return /^[\x00-\x7F]*$/.test(value) ? value : `=?UTF-8?B?${Buffer.from(value, "utf8").toString("base64")}?=`;
+}
+function randomBoundary() {
+  return `----=_Part_${randomUUID().replace(/-/g, "")}`;
+}
+function base64Wrap(data) {
+  return data.toString("base64").replace(/(.{76})/g, "$1\r\n");
+}
+function textPart(contentType, data) {
+  return [
+    `Content-Type: ${contentType}; charset=UTF-8`,
+    "Content-Transfer-Encoding: base64",
+    "",
+    base64Wrap(Buffer.from(data, "utf8"))
+  ].join("\r\n");
+}
+function attachmentContent(attachment) {
+  return Buffer.isBuffer(attachment.content) ? attachment.content : Buffer.from(attachment.content, "base64");
+}
+function attachmentPart(attachment) {
+  return [
+    `Content-Type: ${attachment.contentType}; name="${attachment.filename}"`,
+    `Content-Disposition: attachment; filename="${attachment.filename}"`,
+    "Content-Transfer-Encoding: base64",
+    "",
+    base64Wrap(attachmentContent(attachment))
+  ].join("\r\n");
+}
+function multipart(boundary, type, parts) {
+  const body = parts.map((part) => `--${boundary}\r
+${part}`).join("\r\n");
+  return `Content-Type: multipart/${type}; boundary="${boundary}"\r
+\r
+${body}\r
+--${boundary}--`;
+}
+function buildEml(message, messageId) {
+  const headers = [
+    `From: ${message.from}`,
+    `To: ${toArray(message.to).join(", ")}`
+  ];
+  const cc = toArray(message.cc);
+  if (cc.length) headers.push(`Cc: ${cc.join(", ")}`);
+  const bcc = toArray(message.bcc);
+  if (bcc.length) headers.push(`Bcc: ${bcc.join(", ")}`);
+  if (message.replyTo) headers.push(`Reply-To: ${message.replyTo}`);
+  headers.push(`Subject: ${encodeHeaderValue(message.subject)}`);
+  headers.push(`Date: ${(/* @__PURE__ */ new Date()).toUTCString()}`);
+  headers.push(`Message-ID: <${messageId}@local-cloud-provider>`);
+  headers.push("MIME-Version: 1.0");
+  const bodyParts = [];
+  if (message.text) bodyParts.push(textPart("text/plain", message.text));
+  if (message.html) bodyParts.push(textPart("text/html", message.html));
+  const bodyContent = bodyParts.length > 1 ? multipart(randomBoundary(), "alternative", bodyParts) : bodyParts[0];
+  if (!message.attachments?.length) {
+    return [...headers, bodyContent].join("\r\n");
+  }
+  const attachmentParts = message.attachments.map(attachmentPart);
+  const mixedBody = multipart(randomBoundary(), "mixed", [bodyContent, ...attachmentParts]);
+  return [...headers, mixedBody].join("\r\n");
+}
+async function listEntryIds(baseDir) {
+  if (!fs3.existsSync(baseDir)) return [];
+  const files = await readdir(baseDir);
+  return files.filter((file) => file.endsWith(".json")).map((file) => file.slice(0, -".json".length)).sort().reverse();
+}
+async function enforceRetention(baseDir, logger2) {
+  const ids = await listEntryIds(baseDir);
+  const overflow = ids.length - MAX_HISTORY;
+  if (overflow <= 0) return;
+  const toRemove = ids.slice(-overflow);
+  await Promise.all(toRemove.map(async (id) => {
+    try {
+      await unlink2(path3.join(baseDir, `${id}.eml`));
+      await unlink2(path3.join(baseDir, `${id}.json`));
+    } catch (error) {
+      logger2.warn({ error }, `Failed to prune local email history entry ${id}`);
+    }
+  }));
+}
+function createLocalEmailService() {
+  const baseDir = resolveBaseDir();
+  const logger2 = getService3("logger");
+  if (!fs3.existsSync(baseDir)) {
+    fs3.mkdirSync(baseDir, { recursive: true });
+  }
+  return {
+    async send(message) {
+      assertValidMessage(message);
+      const messageId = randomUUID();
+      const id = `${Date.now()}-${slugify(message.subject)}-${Math.random().toString(36).slice(2, 7)}`;
+      try {
+        await mkdir3(baseDir, { recursive: true });
+        const eml = buildEml(message, messageId);
+        await writeFile3(path3.join(baseDir, `${id}.eml`), eml, "utf8");
+        const metadata = {
+          id,
+          messageId,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          from: message.from,
+          to: toArray(message.to),
+          cc: toArray(message.cc).length ? toArray(message.cc) : void 0,
+          subject: message.subject,
+          preview: buildPreview(message),
+          hasAttachments: !!message.attachments?.length,
+          attachmentCount: message.attachments?.length || void 0,
+          configurationSet: message.configurationSet,
+          status: "sent"
+        };
+        await writeFile3(path3.join(baseDir, `${id}.json`), JSON.stringify(metadata, null, 2), "utf8");
+        await enforceRetention(baseDir, logger2);
+        return { status: "sent", messageId };
+      } catch (error) {
+        logger2.error({ error }, "Failed to write local email");
+        return { status: "failed", error: error instanceof Error ? error.message : String(error) };
+      }
+    }
+  };
+}
+
 // src/router/index.ts
 import Fastify from "fastify";
 import fastifyRawBody from "fastify-raw-body";
@@ -1899,7 +1911,9 @@ function createRouter() {
     encoding: "utf8"
   });
   fastify.register(cors, {
-    "methods": ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"]
+    methods: ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"],
+    origin: true,
+    credentials: true
   });
   fastify.register(fastifyPrintRoutes);
   fastify.addHook("onRequest", (request, _reply, done) => {
@@ -1936,7 +1950,8 @@ var localCloudProvider = {
   createFunctionsService: createLocalFunctionsService,
   createWebSocketService: createLocalWebSocketService,
   createInvokeService: createLocalInvokeService,
-  createLoggerService: createLocalLoggerService
+  createLoggerService: createLocalLoggerService,
+  createEmailService: createLocalEmailService
 };
 export {
   createRouter,