devflare 1.0.0-next.19 → 1.0.0-next.20

package/dist/index-kgstnk6g.js

@@ -0,0 +1,239 @@
+// src/utils/send-email.ts
+var RAW_EMAIL = "EmailMessage::raw";
+var wrappedSendEmailBindings = new WeakMap;
+var wrappedEnvBindings = new WeakMap;
+var localSendEmailBindings = new Map;
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isSendEmailBinding(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  try {
+    return typeof value.send === "function" && typeof value.sendBatch !== "function";
+  } catch {
+    return false;
+  }
+}
+function isComposableSendEmailMessage(message) {
+  return isRecord(message) && typeof message.from === "string" && (typeof message.to === "string" || Array.isArray(message.to));
+}
+function formatEmailAddress(value) {
+  if (!value) {
+    return;
+  }
+  return typeof value === "string" ? value : String(value);
+}
+function formatEmailList(value) {
+  if (!value) {
+    return;
+  }
+  return Array.isArray(value) ? value.join(", ") : value;
+}
+function normalizeBodyText(value) {
+  return value.replace(/\r?\n/g, `\r
+`);
+}
+function buildMultipartAlternativeBody(message, boundary) {
+  const parts = [];
+  if (message.text) {
+    parts.push(`--${boundary}`, "Content-Type: text/plain; charset=UTF-8", "", normalizeBodyText(message.text));
+  }
+  if (message.html) {
+    parts.push(`--${boundary}`, "Content-Type: text/html; charset=UTF-8", "", normalizeBodyText(message.html));
+  }
+  parts.push(`--${boundary}--`);
+  return parts.join(`\r
+`);
+}
+function buildRawEmail(message) {
+  const lines = [];
+  const messageId = `<${Date.now()}-${Math.random().toString(36).slice(2)}@devflare.dev>`;
+  lines.push(`From: ${message.from}`);
+  lines.push(`To: ${formatEmailList(message.to)}`);
+  lines.push(`Date: ${new Date().toUTCString()}`);
+  lines.push(`Message-ID: ${messageId}`);
+  if (message.subject) {
+    lines.push(`Subject: ${message.subject}`);
+  }
+  const replyTo = formatEmailAddress(message.replyTo);
+  if (replyTo) {
+    lines.push(`Reply-To: ${replyTo}`);
+  }
+  const cc = formatEmailList(message.cc);
+  if (cc) {
+    lines.push(`Cc: ${cc}`);
+  }
+  const bcc = formatEmailList(message.bcc);
+  if (bcc) {
+    lines.push(`Bcc: ${bcc}`);
+  }
+  if (message.headers) {
+    for (const [key, value] of Object.entries(message.headers)) {
+      lines.push(`${key}: ${value}`);
+    }
+  }
+  lines.push("MIME-Version: 1.0");
+  if (message.text && message.html) {
+    const boundary = `devflare-alt-${crypto.randomUUID()}`;
+    lines.push(`Content-Type: multipart/alternative; boundary="${boundary}"`);
+    lines.push("");
+    lines.push(buildMultipartAlternativeBody(message, boundary));
+    return lines.join(`\r
+`);
+  }
+  lines.push(`Content-Type: ${message.html ? "text/html" : "text/plain"}; charset=UTF-8`);
+  lines.push("");
+  lines.push(normalizeBodyText(message.html ?? message.text ?? ""));
+  return lines.join(`\r
+`);
+}
+function createEmailMessageRaw(raw) {
+  if (typeof raw === "string" || raw instanceof ReadableStream) {
+    return raw;
+  }
+  if (raw instanceof Uint8Array) {
+    const copy = new Uint8Array(raw.byteLength);
+    copy.set(raw);
+    return new Blob([copy]).stream();
+  }
+  if (raw instanceof ArrayBuffer) {
+    return new Blob([new Uint8Array(raw.slice(0))]).stream();
+  }
+  throw new Error("Unsupported EmailMessage raw payload");
+}
+function normalizeSendEmailMessage(message) {
+  if (!isComposableSendEmailMessage(message)) {
+    return message;
+  }
+  if (hasOwn(message, RAW_EMAIL)) {
+    return message;
+  }
+  if (hasOwn(message, "raw") && message.raw !== undefined) {
+    return {
+      from: message.from,
+      to: message.to,
+      [RAW_EMAIL]: createEmailMessageRaw(message.raw)
+    };
+  }
+  return {
+    from: message.from,
+    to: message.to,
+    [RAW_EMAIL]: createEmailMessageRaw(buildRawEmail(message))
+  };
+}
+function wrapSendEmailBinding(binding) {
+  const cached = wrappedSendEmailBindings.get(binding);
+  if (cached) {
+    return cached;
+  }
+  const wrapped = new Proxy(binding, {
+    get(target, prop, receiver) {
+      if (prop === "send") {
+        return async (message) => target.send(normalizeSendEmailMessage(message));
+      }
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+  wrappedSendEmailBindings.set(binding, wrapped);
+  return wrapped;
+}
+function createLocalSendEmailBinding(config = {}, options = {}) {
+  return {
+    async send(message) {
+      const normalized = normalizeSendEmailMessage(message);
+      if (isRecord(normalized)) {
+        const from = typeof normalized.from === "string" ? normalized.from : undefined;
+        const recipients = Array.isArray(normalized.to) ? normalized.to.filter((value) => typeof value === "string") : typeof normalized.to === "string" ? [normalized.to] : [];
+        if (from && config.allowedSenderAddresses && !config.allowedSenderAddresses.includes(from)) {
+          throw new Error(`email from ${from} not allowed`);
+        }
+        for (const recipient of recipients) {
+          if (config.destinationAddress !== undefined && recipient !== config.destinationAddress) {
+            throw new Error(`email to ${recipient} not allowed`);
+          }
+          if (config.allowedDestinationAddresses !== undefined && !config.allowedDestinationAddresses.includes(recipient)) {
+            throw new Error(`email to ${recipient} not allowed`);
+          }
+        }
+      }
+      await options.onSend?.(normalized);
+      return;
+    }
+  };
+}
+function setLocalSendEmailBindings(bindings) {
+  localSendEmailBindings.clear();
+  for (const [name, config] of Object.entries(bindings)) {
+    localSendEmailBindings.set(name, createLocalSendEmailBinding(config));
+  }
+}
+function clearLocalSendEmailBindings() {
+  localSendEmailBindings.clear();
+}
+function needsEnvSendEmailWrapping(env) {
+  if (localSendEmailBindings.size > 0) {
+    return true;
+  }
+  for (const key of Reflect.ownKeys(env)) {
+    const value = Reflect.get(env, key);
+    if (isSendEmailBinding(value)) {
+      return true;
+    }
+  }
+  return false;
+}
+function wrapEnvSendEmailBindings(env) {
+  if (!isRecord(env)) {
+    return env;
+  }
+  if (!needsEnvSendEmailWrapping(env)) {
+    return env;
+  }
+  const cached = wrappedEnvBindings.get(env);
+  if (cached) {
+    return cached;
+  }
+  const wrapped = new Proxy(env, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (value === undefined && typeof prop === "string") {
+        return localSendEmailBindings.get(prop);
+      }
+      return isSendEmailBinding(value) ? wrapSendEmailBinding(value) : value;
+    },
+    has(target, prop) {
+      return Reflect.has(target, prop) || typeof prop === "string" && localSendEmailBindings.has(prop);
+    },
+    ownKeys(target) {
+      return Array.from(new Set([
+        ...Reflect.ownKeys(target),
+        ...localSendEmailBindings.keys()
+      ]));
+    },
+    getOwnPropertyDescriptor(target, prop) {
+      const descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+      if (descriptor) {
+        return descriptor;
+      }
+      if (typeof prop === "string" && localSendEmailBindings.has(prop)) {
+        return {
+          configurable: true,
+          enumerable: true,
+          writable: false,
+          value: localSendEmailBindings.get(prop)
+        };
+      }
+      return;
+    }
+  });
+  wrappedEnvBindings.set(env, wrapped);
+  return wrapped;
+}
+
+export { createEmailMessageRaw, normalizeSendEmailMessage, wrapSendEmailBinding, createLocalSendEmailBinding, setLocalSendEmailBindings, clearLocalSendEmailBindings, wrapEnvSendEmailBindings };

package/dist/index-khnw972v.js

@@ -0,0 +1,117 @@
+import {
+  normalizeSecretsStoreBinding
+} from "./index-syscwrjp.js";
+
+// src/secrets/local-secrets.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+var LOCAL_SECRETS_PATH = join(".devflare", "secrets.local.json");
+function createEmptyLocalSecretsFile() {
+  return {
+    version: 1,
+    stores: {}
+  };
+}
+function getLocalSecretsFilePath(cwd) {
+  return join(cwd, LOCAL_SECRETS_PATH);
+}
+function parseLocalSecretsFile(raw) {
+  const parsed = JSON.parse(raw);
+  if (parsed.version !== 1 || !parsed.stores || typeof parsed.stores !== "object") {
+    return createEmptyLocalSecretsFile();
+  }
+  return {
+    version: 1,
+    stores: parsed.stores
+  };
+}
+function readLocalSecretsFile(cwd) {
+  const filePath = getLocalSecretsFilePath(cwd);
+  if (!existsSync(filePath)) {
+    return createEmptyLocalSecretsFile();
+  }
+  return parseLocalSecretsFile(readFileSync(filePath, "utf8"));
+}
+function writeLocalSecretsFile(cwd, file) {
+  const filePath = getLocalSecretsFilePath(cwd);
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, `${JSON.stringify(file, null, "\t")}
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+}
+function writeLocalSecret({ cwd, storeId, name, value }) {
+  const file = readLocalSecretsFile(cwd);
+  file.stores[storeId] ??= {};
+  file.stores[storeId][name] = {
+    value,
+    updatedAt: new Date().toISOString()
+  };
+  writeLocalSecretsFile(cwd, file);
+}
+function readLocalSecret({ cwd, storeId, name }) {
+  return readLocalSecretsFile(cwd).stores[storeId]?.[name]?.value;
+}
+function deleteLocalSecret({ cwd, storeId, name }) {
+  const file = readLocalSecretsFile(cwd);
+  const store = file.stores[storeId];
+  if (!store || !(name in store)) {
+    return false;
+  }
+  delete store[name];
+  if (Object.keys(store).length === 0) {
+    delete file.stores[storeId];
+  }
+  writeLocalSecretsFile(cwd, file);
+  return true;
+}
+function listLocalSecrets({ cwd, storeId }) {
+  const file = readLocalSecretsFile(cwd);
+  const stores = storeId ? { [storeId]: file.stores[storeId] ?? {} } : file.stores;
+  return Object.entries(stores).flatMap(([currentStoreId, secrets]) => Object.entries(secrets).map(([name, secret]) => ({
+    storeId: currentStoreId,
+    name,
+    hasValue: typeof secret.value === "string",
+    updatedAt: secret.updatedAt
+  })));
+}
+function resolveLocalSecretValuesForBindings(config, cwd) {
+  const values = {};
+  for (const [bindingName, binding] of Object.entries(config.bindings?.secretsStore ?? {})) {
+    const normalized = normalizeSecretsStoreBinding(binding, config.secretsStoreId, bindingName);
+    const value = readLocalSecret({
+      cwd,
+      storeId: normalized.storeId,
+      name: normalized.secretName
+    });
+    if (value !== undefined) {
+      values[bindingName] = value;
+    }
+  }
+  return values;
+}
+async function getSecretAdmin(miniflare, bindingName) {
+  const adminOrFactory = await miniflare.getSecretsStoreSecretAPI(bindingName);
+  return typeof adminOrFactory === "function" ? adminOrFactory() : adminOrFactory;
+}
+async function upsertMiniflareSecret(admin, value) {
+  if (admin.list && admin.update) {
+    const [existing] = await admin.list();
+    const id = existing?.metadata?.uuid ?? existing?.name;
+    if (id) {
+      await admin.update(value, id);
+      return;
+    }
+  }
+  await admin.create(value);
+}
+async function seedMiniflareLocalSecrets(miniflare, config, cwd) {
+  const values = resolveLocalSecretValuesForBindings(config, cwd);
+  for (const [bindingName, value] of Object.entries(values)) {
+    const admin = await getSecretAdmin(miniflare, bindingName);
+    await upsertMiniflareSecret(admin, value);
+  }
+}
+
+export { writeLocalSecret, deleteLocalSecret, listLocalSecrets, resolveLocalSecretValuesForBindings, seedMiniflareLocalSecrets };