nuxt-generation-emails 1.4.5 → 1.4.7

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": ">=4.0.0"
   },
-  "version": "1.4.5",
+  "version": "1.4.7",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -1,6 +1,6 @@
 import { defineNuxtModule, createResolver, addTypeTemplate, addTemplate, addImports, addServerImports, extendPages, addServerHandler } from '@nuxt/kit';
 import fs from 'node:fs';
-import { join, relative } from 'pathe';
+import { resolve, dirname, join, relative } from 'pathe';
 import { consola } from 'consola';
 import { parse, compileScript } from 'vue/compiler-sfc';
 
@@ -175,7 +175,7 @@ function extractPropsFromSFC(filePath) {
       const type = propTypes[name] ?? "unknown";
       props.push({ name, type });
     }
-    const defaultValues = extractDefaults(compiled.scriptSetupAst, descriptor.scriptSetup.content);
+    const defaultValues = extractDefaults(compiled.scriptSetupAst, descriptor.scriptSetup.content, filePath);
     for (const [name, value] of Object.entries(defaultValues)) {
       defaults[name] = value;
       const existing = props.find((p) => p.name === name);
@@ -194,12 +194,209 @@ function asAstNode(value) {
   if (typeof node.type !== "string") return null;
   return node;
 }
-function extractDefaults(scriptSetupAst, scriptContent) {
-  const astDefaults = extractDefaultsFromAst(scriptSetupAst);
+function isValidIdentifierName(value) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value);
+}
+function parseNamedValueImports(scriptContent) {
+  const imports = [];
+  const importPattern = /import\s+(?!type\b)(?:[A-Za-z_$][A-Za-z0-9_$]*\s*,\s*)?\{([\s\S]*?)\}\s*from\s*['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = importPattern.exec(scriptContent)) !== null) {
+    const specifiers = match[1] ?? "";
+    const source = match[2] ?? "";
+    for (const rawToken of specifiers.split(",")) {
+      const token = rawToken.trim();
+      if (!token) continue;
+      const cleaned = token.replace(/^type\s+/, "").trim();
+      if (!cleaned) continue;
+      const aliasMatch = cleaned.match(/^([A-Za-z_$][A-Za-z0-9_$]*)\s+as\s+([A-Za-z_$][A-Za-z0-9_$]*)$/);
+      if (aliasMatch) {
+        imports.push({
+          source,
+          importedName: aliasMatch[1],
+          localName: aliasMatch[2]
+        });
+        continue;
+      }
+      if (isValidIdentifierName(cleaned)) {
+        imports.push({
+          source,
+          importedName: cleaned,
+          localName: cleaned
+        });
+      }
+    }
+  }
+  return imports;
+}
+function resolveImportModulePath(sfcFilePath, importSource) {
+  if (!importSource.startsWith(".")) return null;
+  const basePath = resolve(dirname(sfcFilePath), importSource);
+  const candidates = [
+    basePath,
+    `${basePath}.ts`,
+    `${basePath}.mts`,
+    `${basePath}.cts`,
+    `${basePath}.js`,
+    `${basePath}.mjs`,
+    `${basePath}.cjs`,
+    join(basePath, "index.ts"),
+    join(basePath, "index.mts"),
+    join(basePath, "index.cts"),
+    join(basePath, "index.js"),
+    join(basePath, "index.mjs"),
+    join(basePath, "index.cjs")
+  ];
+  for (const candidate of candidates) {
+    if (!fs.existsSync(candidate)) continue;
+    try {
+      if (fs.statSync(candidate).isFile()) {
+        return candidate;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function extractTopLevelExpression(source, startIndex) {
+  let i = startIndex;
+  while (i < source.length && /\s/.test(source[i])) i++;
+  if (i >= source.length) return null;
+  const expressionStart = i;
+  let depthParen = 0;
+  let depthBrace = 0;
+  let depthBracket = 0;
+  let seenContent = false;
+  while (i < source.length) {
+    const ch = source[i];
+    if (ch === "'" || ch === '"') {
+      seenContent = true;
+      const quote = ch;
+      i++;
+      while (i < source.length) {
+        if (source[i] === "\\") {
+          i += 2;
+          continue;
+        }
+        if (source[i] === quote) break;
+        i++;
+      }
+      i++;
+      continue;
+    }
+    if (ch === "`") {
+      seenContent = true;
+      i++;
+      while (i < source.length) {
+        if (source[i] === "\\") {
+          i += 2;
+          continue;
+        }
+        if (source[i] === "`") break;
+        if (source[i] === "$" && source[i + 1] === "{") {
+          i += 2;
+          let templateDepth = 1;
+          while (i < source.length && templateDepth > 0) {
+            if (source[i] === "{") templateDepth++;
+            else if (source[i] === "}") templateDepth--;
+            if (templateDepth > 0) i++;
+          }
+        }
+        i++;
+      }
+      i++;
+      continue;
+    }
+    if (ch === "/" && source[i + 1] === "/") {
+      i = source.indexOf("\n", i);
+      if (i === -1) break;
+      continue;
+    }
+    if (ch === "/" && source[i + 1] === "*") {
+      const blockEnd = source.indexOf("*/", i + 2);
+      if (blockEnd === -1) break;
+      i = blockEnd + 2;
+      continue;
+    }
+    if (ch === "(") depthParen++;
+    else if (ch === ")") depthParen = Math.max(0, depthParen - 1);
+    else if (ch === "{") depthBrace++;
+    else if (ch === "}") {
+      if (depthBrace > 0) depthBrace--;
+      else break;
+    } else if (ch === "[") depthBracket++;
+    else if (ch === "]") depthBracket = Math.max(0, depthBracket - 1);
+    if (!/\s/.test(ch)) {
+      seenContent = true;
+    }
+    const atTopLevel = depthParen === 0 && depthBrace === 0 && depthBracket === 0;
+    if (atTopLevel && ch === ";") {
+      break;
+    }
+    if (atTopLevel && ch === "\n" && seenContent) {
+      const rest = source.slice(i + 1).trimStart();
+      if (!rest || rest.startsWith("export ") || rest.startsWith("const ") || rest.startsWith("interface ") || rest.startsWith("type ")) {
+        break;
+      }
+    }
+    i++;
+  }
+  const expressionText = source.slice(expressionStart, i).trim();
+  if (!expressionText) return null;
+  return { text: expressionText, end: i + 1 };
+}
+function evaluateExpressionText(expressionText) {
+  const normalized = expressionText.replace(/\s+as\s+const\s*$/, "").replace(/\s+satisfies\s+[A-Za-z_$][A-Za-z0-9_$<>,\s.\[\]|&?]*\s*$/, "");
+  try {
+    const fn = new Function(`return (${normalized})`);
+    return { ok: true, value: fn() };
+  } catch {
+    return { ok: false, value: void 0 };
+  }
+}
+function extractExportedConstValues(moduleFilePath) {
+  const source = fs.readFileSync(moduleFilePath, "utf-8");
+  const exportsMap = {};
+  const exportConstPattern = /export\s+const\s+([A-Za-z_$][A-Za-z0-9_$]*)(?:\s*:[^=]+)?\s*=/g;
+  let match;
+  while ((match = exportConstPattern.exec(source)) !== null) {
+    const exportName = match[1];
+    const expression = extractTopLevelExpression(source, exportConstPattern.lastIndex);
+    if (!expression) continue;
+    const evaluated = evaluateExpressionText(expression.text);
+    if (evaluated.ok) {
+      exportsMap[exportName] = evaluated.value;
+    }
+    exportConstPattern.lastIndex = expression.end;
+  }
+  return exportsMap;
+}
+function buildImportScope(scriptContent, sfcFilePath) {
+  const scope = {};
+  const imports = parseNamedValueImports(scriptContent);
+  const moduleExportsCache = /* @__PURE__ */ new Map();
+  for (const importInfo of imports) {
+    const modulePath = resolveImportModulePath(sfcFilePath, importInfo.source);
+    if (!modulePath) continue;
+    let moduleExports = moduleExportsCache.get(modulePath);
+    if (!moduleExports) {
+      moduleExports = extractExportedConstValues(modulePath);
+      moduleExportsCache.set(modulePath, moduleExports);
+    }
+    if (Object.prototype.hasOwnProperty.call(moduleExports, importInfo.importedName)) {
+      scope[importInfo.localName] = moduleExports[importInfo.importedName];
+    }
+  }
+  return scope;
+}
+function extractDefaults(scriptSetupAst, scriptContent, sfcFilePath) {
+  const evalScope = buildImportScope(scriptContent, sfcFilePath);
+  const astDefaults = extractDefaultsFromAst(scriptSetupAst, evalScope);
   if (astDefaults) return astDefaults;
-  return extractDefaultsFromSource(scriptContent);
+  return extractDefaultsFromSource(scriptContent, evalScope);
 }
-function extractDefaultsFromAst(scriptSetupAst) {
+function extractDefaultsFromAst(scriptSetupAst, evalScope) {
   if (!Array.isArray(scriptSetupAst)) return null;
   for (const root of scriptSetupAst) {
     const rootNode = asAstNode(root);
@@ -207,12 +404,11 @@ function extractDefaultsFromAst(scriptSetupAst) {
     const found = findWithDefaultsSecondArg(rootNode);
     if (!found) continue;
     try {
-      const evaluated = evaluateAstExpression(found);
+      const evaluated = evaluateAstExpression(found, evalScope);
       if (evaluated && typeof evaluated === "object" && !Array.isArray(evaluated)) {
         return evaluated;
       }
     } catch (error) {
-      debugLog("Failed AST-based withDefaults extraction; falling back to source parser", error);
     }
   }
   return null;
@@ -243,7 +439,7 @@ function findWithDefaultsSecondArg(node) {
   }
   return null;
 }
-function evaluateAstExpression(node) {
+function evaluateAstExpression(node, evalScope) {
   switch (node.type) {
     case "ObjectExpression": {
       const result = {};
@@ -257,13 +453,13 @@ function evaluateAstExpression(node) {
         if (!key) continue;
         const valueNode = asAstNode(prop.value);
         if (!valueNode) continue;
-        result[key] = evaluateAstExpression(valueNode);
+        result[key] = evaluateAstExpression(valueNode, evalScope);
       }
       return result;
     }
     case "ArrayExpression": {
       const elements = Array.isArray(node.elements) ? node.elements : [];
-      return elements.map((element) => asAstNode(element)).filter((element) => !!element).map((element) => evaluateAstExpression(element));
+      return elements.map((element) => asAstNode(element)).filter((element) => !!element).map((element) => evaluateAstExpression(element, evalScope));
     }
     case "StringLiteral":
       return node.value;
@@ -292,20 +488,57 @@ function evaluateAstExpression(node) {
         const statements = Array.isArray(body.body) ? body.body : [];
         const returnStmt = statements.map((stmt) => asAstNode(stmt)).find((stmt) => stmt?.type === "ReturnStatement");
         const arg = returnStmt ? asAstNode(returnStmt.argument) : null;
-        return arg ? evaluateAstExpression(arg) : void 0;
+        return arg ? evaluateAstExpression(arg, evalScope) : void 0;
       }
-      return evaluateAstExpression(body);
+      return evaluateAstExpression(body, evalScope);
     }
     case "ParenthesizedExpression": {
       const expr = asAstNode(node.expression);
-      return expr ? evaluateAstExpression(expr) : void 0;
+      return expr ? evaluateAstExpression(expr, evalScope) : void 0;
     }
     case "TSAsExpression": {
       const expr = asAstNode(node.expression);
-      return expr ? evaluateAstExpression(expr) : void 0;
+      return expr ? evaluateAstExpression(expr, evalScope) : void 0;
+    }
+    case "TSSatisfiesExpression": {
+      const expr = asAstNode(node.expression);
+      return expr ? evaluateAstExpression(expr, evalScope) : void 0;
+    }
+    case "TSNonNullExpression": {
+      const expr = asAstNode(node.expression);
+      return expr ? evaluateAstExpression(expr, evalScope) : void 0;
+    }
+    case "MemberExpression": {
+      const objectNode = asAstNode(node.object);
+      if (!objectNode) {
+        throw new Error("Unsupported MemberExpression object in defaults");
+      }
+      const targetValue = evaluateAstExpression(objectNode, evalScope);
+      if (targetValue === null || typeof targetValue !== "object") {
+        return void 0;
+      }
+      const propertyNode = asAstNode(node.property);
+      const computed = node.computed === true;
+      let propertyKey = null;
+      if (computed) {
+        if (!propertyNode) {
+          throw new Error("Unsupported computed MemberExpression property in defaults");
+        }
+        const keyValue = evaluateAstExpression(propertyNode, evalScope);
+        if (typeof keyValue === "string" || typeof keyValue === "number") {
+          propertyKey = String(keyValue);
+        }
+      } else {
+        propertyKey = propertyNode?.type === "Identifier" ? String(propertyNode.name) : propertyNode?.type === "StringLiteral" ? String(propertyNode.value) : null;
+      }
+      if (!propertyKey) return void 0;
+      return targetValue[propertyKey];
     }
     case "Identifier": {
       if (node.name === "undefined") return void 0;
+      if (typeof node.name === "string" && Object.prototype.hasOwnProperty.call(evalScope, node.name)) {
+        return evalScope[node.name];
+      }
       throw new Error(`Unsupported identifier in defaults: ${String(node.name)}`);
     }
     default:
@@ -434,11 +667,14 @@ function parsePropEntries(typeBody, result) {
     if (i < cleaned.length && (cleaned[i] === ";" || cleaned[i] === "\n")) i++;
   }
 }
-function extractDefaultsFromSource(scriptContent) {
+function extractDefaultsFromSource(scriptContent, evalScope) {
   const defaultsText = extractDefaultsObjectText(scriptContent);
   if (!defaultsText) return {};
   try {
-    const fn = new Function(`
+    const scopeEntries = Object.entries(evalScope).filter(([name]) => isValidIdentifierName(name));
+    const argNames = scopeEntries.map(([name]) => name);
+    const argValues = scopeEntries.map(([, value]) => value);
+    const fn = new Function(...argNames, `
       const _defaults = (${defaultsText});
       const _result = {};
       for (const [k, v] of Object.entries(_defaults)) {
@@ -446,7 +682,7 @@ function extractDefaultsFromSource(scriptContent) {
       }
       return _result;
     `);
-    return fn();
+    return fn(...argValues);
   } catch {
     return extractPrimitivesFromObjectLiteral(defaultsText);
   }
@@ -589,11 +825,11 @@ import Handlebars from 'handlebars'
  * Register all .mjml files from the components directory as Handlebars partials.
  * This lets templates use {{> partialName}} to include reusable MJML snippets.
  */
-function registerMjmlPartials(emailsDir: string): void {
+function registerMjmlPartials(emailsDir) {
   const componentsDir = join(emailsDir, 'components')
   if (!existsSync(componentsDir)) return
 
-  const walk = (dir: string) => {
+  const walk = (dir) => {
     const entries = readdirSync(dir, { withFileTypes: true })
 
     for (const entry of entries) {
@@ -620,21 +856,6 @@ function registerMjmlPartials(emailsDir: string): void {
   walk(componentsDir)
 }
 
-type SendData<TAdditional extends Record<string, unknown> = Record<string, unknown>> = {
-  to?: string
-  from?: string
-  subject?: string
-} & TAdditional
-
-type NuxtGenEmailsApiBody<
-  TTemplateData extends Record<string, unknown> = Record<string, unknown>,
-  TSendData extends Record<string, unknown> = SendData,
-> = {
-  templateData: TTemplateData
-  sendData: TSendData
-  stopSend?: boolean
-}
-
 defineRouteMeta({
   openAPI: {
     tags: ['nuxt-generation-emails'],
@@ -712,14 +933,14 @@ defineRouteMeta({
 })
 
 export default defineEventHandler(async (event) => {
-  const body = await readBody<NuxtGenEmailsApiBody>(event)
+  const body = await readBody(event)
 
   const templateData = body?.templateData ?? {}
   const sendData = body?.sendData ?? {}
   const stopSend = body?.stopSend === true
 
   try {
-    const { emailsDir } = useRuntimeConfig().nuxtGenEmails as { emailsDir: string }
+    const { emailsDir } = useRuntimeConfig().nuxtGenEmails
     registerMjmlPartials(emailsDir)
     const mjmlSource = readFileSync(join(emailsDir, '${mjmlPath}.mjml'), 'utf-8')
     const compiledTemplate = Handlebars.compile(mjmlSource)
@@ -738,7 +959,7 @@ export default defineEventHandler(async (event) => {
 
     return { success: true, message: 'Email rendered successfully', html }
   }
-  catch (error: unknown) {
+  catch (error) {
     const message = error instanceof Error ? error.message : 'Failed to render or send email'
     throw createError({ statusCode: 500, statusMessage: message })
   }
@@ -774,13 +995,9 @@ function normalizeApiEmailPath(emailsDir, routePrefix, emailName) {
   }
   return rawPath;
 }
-function generateServerRoutes(emailsDir, buildDir) {
+function generateServerRoutes(emailsDir, _buildDir) {
   if (!fs.existsSync(emailsDir)) return [];
-  const handlersDir = join(buildDir, "email-handlers");
   const handlers = [];
-  if (!fs.existsSync(handlersDir)) {
-    fs.mkdirSync(handlersDir, { recursive: true });
-  }
   function processEmailDirectory(dirPath, routePrefix = "") {
     const entries = fs.readdirSync(dirPath);
     for (const entry of entries) {
@@ -804,23 +1021,18 @@ function generateServerRoutes(emailsDir, buildDir) {
           console.warn(`[nuxt-generation-emails] MJML template "${mjmlTemplateName}.mjml" referenced by ${emailName}.vue not found \u2014 skipping API route. Expected: ${mjmlPath}`);
           continue;
         }
-        const handlerDir = routePrefix ? join(handlersDir, routePrefix.replace(/^\//, "")) : handlersDir;
-        if (!fs.existsSync(handlerDir)) {
-          fs.mkdirSync(handlerDir, { recursive: true });
-        }
         const { defaults } = extractPropsFromSFC(fullPath);
         const sanitized = sanitizeForOpenApi(defaults);
         const sanitizedDefaults = sanitized && typeof sanitized === "object" && !Array.isArray(sanitized) ? sanitized : {};
         const examplePayload = Object.keys(sanitizedDefaults).length > 0 ? JSON.stringify(sanitizedDefaults, null, 2) : "{}";
-        const handlerFileName = `${emailName}.ts`;
-        const handlerFilePath = join(handlerDir, handlerFileName);
+        const handlerFilePath = routePrefix ? join("email-handlers", routePrefix.replace(/^\//, ""), `${emailName}.ts`) : join("email-handlers", `${emailName}.ts`);
         const handlerContent = generateApiRoute(emailName, emailPath, examplePayload, mjmlTemplateName);
-        fs.writeFileSync(handlerFilePath, handlerContent, "utf-8");
-        console.log(`[nuxt-generation-emails] Generated API handler: ${handlerFilePath}`);
+        console.log(`[nuxt-generation-emails] Generated API handler template: ${handlerFilePath}`);
         handlers.push({
           route: `/api/emails/${emailPath}`,
           method: "post",
-          handlerPath: handlerFilePath
+          handlerPath: handlerFilePath,
+          handlerContent
         });
       }
     }
@@ -1036,10 +1248,15 @@ export function useNgeTemplate(name: string, props: Record<string, unknown>): vo
     }
     const handlers = generateServerRoutes(emailsDir, nuxt.options.buildDir);
     for (const handler of handlers) {
+      const template = addTemplate({
+        filename: handler.handlerPath,
+        write: true,
+        getContents: () => handler.handlerContent
+      });
       addServerHandler({
         route: handler.route,
         method: handler.method,
-        handler: handler.handlerPath
+        handler: template.dst
       });
     }
     if (nuxt.options.dev && fs.existsSync(emailsDir)) {

package/dist/runtime/components/ApiTester.vue

@@ -1,10 +1,12 @@
 <script setup>
 import { ref, computed } from "vue";
-import { useRoute, useCookie } from "#imports";
+import { useRoute, useCookie, useRouter } from "#imports";
+import { resolveApiEndpointFromPreviewPath } from "../utils/email-route";
 const props = defineProps({
   dataObject: { type: Object, required: true }
 });
 const route = useRoute();
+const router = useRouter();
 const isLoading = ref(false);
 const response = ref("");
 const responseData = ref(null);
@@ -19,8 +21,8 @@ const testEmailTo = ref(lastUsedEmail.value || "");
 const sendStatus = ref("idle");
 let sendStatusTimeout = null;
 const apiEndpoint = computed(() => {
-  const templatePath = route.path.replace("/__emails/", "");
-  return `/api/emails/${templatePath}`;
+  const availablePreviewPaths = router.getRoutes().filter((route2) => route2.path.startsWith("/__emails/")).map((route2) => route2.path);
+  return resolveApiEndpointFromPreviewPath(route.path, availablePreviewPaths);
 });
 const htmlResponse = computed(() => {
   if (!responseData.value || typeof responseData.value !== "object") return "";

package/dist/runtime/utils/email-route.d.ts

@@ -0,0 +1,3 @@
+export declare function toTemplatePath(previewPath: string): string;
+export declare function normalizeApiTemplatePath(templatePath: string, availableTemplatePaths: string[]): string;
+export declare function resolveApiEndpointFromPreviewPath(currentPreviewPath: string, availablePreviewPaths: string[]): string;

package/dist/runtime/utils/email-route.js

@@ -0,0 +1,30 @@
+const PREVIEW_PREFIX = "/__emails/";
+function stripLeadingSlash(value) {
+  return value.replace(/^\/+/, "");
+}
+export function toTemplatePath(previewPath) {
+  if (previewPath.startsWith(PREVIEW_PREFIX)) {
+    return stripLeadingSlash(previewPath.slice(PREVIEW_PREFIX.length));
+  }
+  return stripLeadingSlash(previewPath);
+}
+export function normalizeApiTemplatePath(templatePath, availableTemplatePaths) {
+  if (!templatePath || templatePath === "index") {
+    return templatePath;
+  }
+  if (!templatePath.endsWith("/index")) {
+    return templatePath;
+  }
+  const indexlessPath = templatePath.slice(0, -"/index".length);
+  const hasSiblingTemplate = availableTemplatePaths.includes(indexlessPath);
+  if (hasSiblingTemplate) {
+    return templatePath;
+  }
+  return indexlessPath;
+}
+export function resolveApiEndpointFromPreviewPath(currentPreviewPath, availablePreviewPaths) {
+  const templatePath = toTemplatePath(currentPreviewPath);
+  const availableTemplatePaths = availablePreviewPaths.map(toTemplatePath);
+  const normalizedTemplatePath = normalizeApiTemplatePath(templatePath, availableTemplatePaths);
+  return `/api/emails/${normalizedTemplatePath}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-generation-emails",
-  "version": "1.4.5",
+  "version": "1.4.7",
   "description": "A Nuxt module for authoring, previewing, and sending transactional email templates with MJML and Handlebars.",
   "author": "nullcarry@icloud.com",
   "repository": {