@wervt/nuxt 0.2.14 → 0.2.16

package/dist/runtime/server/email-preview.js

@@ -0,0 +1,30 @@
+import { renderEmail } from "../email/render.js";
+import { createError, defineEventHandler, getQuery } from "nuxt/server";
+import { templates } from "#wervt/emails";
+//#region src/runtime/server/email-preview.ts
+const list = templates;
+const page = (body) => new Response(`<!doctype html><meta charset="utf-8"><title>Emails</title><body style="font:15px/1.6 system-ui;margin:40px">${body}</body>`, { headers: { "content-type": "text/html; charset=utf-8" } });
+const escape = (value) => value.replace(/[&<>"]/g, (c) => ({
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;"
+})[c]);
+var email_preview_default = defineEventHandler(async (event) => {
+	const name = decodeURIComponent(new URL(event.req.url).pathname.replace(/^\/_wervt\/emails\/?/, ""));
+	if (!name) {
+		const names = Object.keys(list);
+		return page(names.length ? `<h1>Email templates</h1><ul>${names.map((n) => `<li><a href="/_wervt/emails/${n}">${escape(n)}</a> · <a href="/_wervt/emails/${n}?text">text</a></li>`).join("")}</ul>` : "<h1>No email templates</h1><p>Add <code>emails/*.vue</code> and restart <code>nuxt dev</code>.</p>");
+	}
+	const load = list[name];
+	if (!load) throw createError({
+		status: 404,
+		message: `No email template "${name}"`
+	});
+	const template = await load();
+	const mail = await renderEmail(template.default, template.previewProps);
+	if ("text" in getQuery(event)) return new Response(`Subject: ${mail.subject}\n\n${mail.text}\n`, { headers: { "content-type": "text/plain; charset=utf-8" } });
+	return new Response(mail.html, { headers: { "content-type": "text/html; charset=utf-8" } });
+});
+//#endregion
+export { email_preview_default as default };

package/dist/runtime/server/index.d.ts

@@ -1,10 +1,13 @@
 import { WervtUser } from "../shared/user.js";
+import { EmailProps, RenderedEmail, renderEmail } from "../email/render.js";
 import { useDb } from "./db.js";
 import { createEvlogError, log, useLogger } from "./logger.js";
+import { SendMailOptions, sendMail } from "./mail.js";
 import { McpTokenContext } from "./mcp-auth.js";
-import { ShapeOptions, proxyShape } from "./shape.js";
+import { ShapeResponse } from "../shared/shape.js";
+import { ShapeOptions, ShapeRow, proxyShape } from "./shape.js";
 import { Task, TaskEvent, TaskResult, defineTask } from "./tasks.js";
 import { SafeResult, useSafeValidatedBody, useSafeValidatedParams, useSafeValidatedQuery, useValidatedBody, useValidatedParams, useValidatedQuery, vh } from "./validate.js";
 import { Tool, defineTool } from "./tools.js";
 import { useWervtUser } from "./user.js";
-export { type McpTokenContext, type SafeResult, type ShapeOptions, type Task, type TaskEvent, type TaskResult, type Tool, type WervtUser, createEvlogError, defineTask, defineTool, log, proxyShape, useDb, useLogger, useSafeValidatedBody, useSafeValidatedParams, useSafeValidatedQuery, useValidatedBody, useValidatedParams, useValidatedQuery, useWervtUser, vh };
+export { type EmailProps, type McpTokenContext, type RenderedEmail, type SafeResult, type SendMailOptions, type ShapeOptions, type ShapeResponse, type ShapeRow, type Task, type TaskEvent, type TaskResult, type Tool, type WervtUser, createEvlogError, defineTask, defineTool, log, proxyShape, renderEmail, sendMail, useDb, useLogger, useSafeValidatedBody, useSafeValidatedParams, useSafeValidatedQuery, useValidatedBody, useValidatedParams, useValidatedQuery, useWervtUser, vh };

package/dist/runtime/server/index.js

@@ -1,8 +1,10 @@
+import { renderEmail } from "../email/render.js";
 import { useDb } from "./db.js";
 import { createEvlogError, log, useLogger } from "./logger.js";
+import { sendMail } from "./mail.js";
 import { proxyShape } from "./shape.js";
 import { defineTask } from "./tasks.js";
 import { defineTool } from "./tools.js";
 import { useWervtUser } from "./user.js";
 import { useSafeValidatedBody, useSafeValidatedParams, useSafeValidatedQuery, useValidatedBody, useValidatedParams, useValidatedQuery, vh } from "./validate.js";
-export { createEvlogError, defineTask, defineTool, log, proxyShape, useDb, useLogger, useSafeValidatedBody, useSafeValidatedParams, useSafeValidatedQuery, useValidatedBody, useValidatedParams, useValidatedQuery, useWervtUser, vh };
+export { createEvlogError, defineTask, defineTool, log, proxyShape, renderEmail, sendMail, useDb, useLogger, useSafeValidatedBody, useSafeValidatedParams, useSafeValidatedQuery, useValidatedBody, useValidatedParams, useValidatedQuery, useWervtUser, vh };

package/dist/runtime/server/mail.d.ts

@@ -0,0 +1,23 @@
+import { EmailProps } from "../email/render.js";
+import { Component } from "vue";
+//#region src/runtime/server/mail.d.ts
+export interface SendMailOptions<T extends Component> {
+  /** One recipient. */
+  to: string;
+  /** A template from `emails/` (a component with `<WervtEmail>` at its root). */
+  template: T;
+  props?: EmailProps<T>;
+  /** Where replies go. The sender is always `<app> <mail@wervt.app>`. */
+  replyTo?: string;
+}
+/**
+ * Renders a template and sends it through wervt. Throws on failure, with the status the platform
+ * answered: 400 (invalid mail), 429 (the app's or the recipient's hourly limit), 502/503.
+ *
+ * In `nuxt dev` nothing is sent: the mail is printed to the terminal, and `/_wervt/emails`
+ * previews the templates.
+ */
+export declare function sendMail<T extends Component>(options: SendMailOptions<T>): Promise<{
+  id: string;
+}>;
+//#endregion

package/dist/runtime/server/mail.js

@@ -0,0 +1,43 @@
+import { renderEmail } from "../email/render.js";
+import { createError } from "nuxt/server";
+//#region src/runtime/server/mail.ts
+/**
+* Renders a template and sends it through wervt. Throws on failure, with the status the platform
+* answered: 400 (invalid mail), 429 (the app's or the recipient's hourly limit), 502/503.
+*
+* In `nuxt dev` nothing is sent: the mail is printed to the terminal, and `/_wervt/emails`
+* previews the templates.
+*/
+async function sendMail(options) {
+	const { subject, html, text } = await renderEmail(options.template, options.props);
+	const template = options.template.__name;
+	const runtime = process.env.WERVT_RUNTIME_URL;
+	if (!runtime) {
+		console.info(`[mail] to ${options.to}: ${subject}\n${text}`);
+		return { id: "dev" };
+	}
+	const res = await fetch(new URL("/_wervt/mail", runtime), {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			"x-wervt-app": process.env.WERVT_APP ?? "",
+			"x-wervt-token": process.env.WERVT_TOKEN ?? ""
+		},
+		body: JSON.stringify({
+			to: options.to,
+			subject,
+			html,
+			text,
+			replyTo: options.replyTo,
+			template
+		})
+	});
+	const body = await res.json().catch(() => ({}));
+	if (!res.ok) throw createError({
+		status: res.status,
+		message: body.error ?? `sending mail failed (${res.status})`
+	});
+	return { id: body.id ?? "" };
+}
+//#endregion
+export { sendMail };

package/dist/runtime/server/shape.d.ts

@@ -1,19 +1,26 @@
+import { ShapeResponse } from "../shared/shape.js";
 import { RequestEvent } from "nuxt/server";
+import { InferSelectModel, Table } from "drizzle-orm";
 //#region src/runtime/server/shape.d.ts
-export interface ShapeOptions {
-  /** Table name without schema. */
-  table: string;
+export interface ShapeOptions<T extends Table | string = Table | string> {
+  /**
+   * The Drizzle table (`todos` from `server/db/schema`), or its name without schema. With the
+   * table, `useShape` knows the row type from the route.
+   */
+  table: T;
   /** SQL where clause. Use `$1`, `$2`, … placeholders with `params` for values. */
   where?: string;
   /** Values for the `$n` placeholders in `where`. */
   params?: (string | number | boolean)[];
-  columns?: string[];
+  columns?: (T extends Table ? keyof InferSelectModel<T> & string : string)[];
 }
+/** The rows a shape of `T` streams: the table's select model, or untyped for a table name. */
+export type ShapeRow<T extends Table | string> = T extends Table ? InferSelectModel<T> : Record<string, unknown>;
 /**
  * Serves an Electric shape from a route. Do auth checks before calling it.
  *
  * In production the request goes through the wervt runtime gateway, which pins the
  * table to this app's schema. In dev it goes to Electric directly (ELECTRIC_URL).
  */
-export declare function proxyShape(event: RequestEvent, { table, where, params, columns }: ShapeOptions): Promise<Response>;
+export declare function proxyShape<T extends Table | string>(event: RequestEvent, { table: tableOrName, where, params, columns }: ShapeOptions<T>): Promise<ShapeResponse<ShapeRow<T>>>;
 //#endregion

package/dist/runtime/server/shape.js

@@ -1,3 +1,4 @@
+import { getTableName, isTable } from "drizzle-orm";
 //#region src/runtime/server/shape.ts
 const CLIENT_PARAMS = [
 	"offset",
@@ -14,7 +15,8 @@ const CLIENT_PARAMS = [
 * In production the request goes through the wervt runtime gateway, which pins the
 * table to this app's schema. In dev it goes to Electric directly (ELECTRIC_URL).
 */
-async function proxyShape(event, { table, where, params, columns }) {
+async function proxyShape(event, { table: tableOrName, where, params, columns }) {
+	const table = isTable(tableOrName) ? getTableName(tableOrName) : tableOrName;
 	const runtime = process.env.WERVT_RUNTIME_URL;
 	const url = runtime ? new URL("/_wervt/electric/v1/shape", runtime) : new URL("/v1/shape", process.env.ELECTRIC_URL ?? "http://localhost:3000");
 	const query = new URL(event.req.url).searchParams;

package/dist/runtime/shared/shape.d.ts

@@ -0,0 +1,18 @@
+//#region src/runtime/shared/shape.d.ts
+declare const shapeRow: unique symbol;
+export type ShapeResponse<Row> = Response & {
+  readonly [shapeRow]?: Row;
+};
+/** The row type of a shape route's handler, `never` if it doesn't serve a typed shape. */
+export type ShapeRowOf<Handler> = Handler extends ((...args: never[]) => infer Result) ? Awaited<Result> extends ShapeResponse<infer Row> ? Row : never : never;
+/**
+ * Postgres text of a `timestamp`/`timestamptz` as a Date, like Drizzle's default `mode: 'date'`
+ * reads it. Drizzle stores `timestamp` without time zone as UTC, so it's read as UTC too.
+ */
+export declare function parseTimestamp(value: string): Date;
+/** Electric parsers for the types Drizzle reads differently from Electric's defaults. */
+export declare const shapeParser: {
+  timestamp: typeof parseTimestamp;
+  timestamptz: typeof parseTimestamp;
+};
+//#endregion

package/dist/runtime/shared/shape.js

@@ -0,0 +1,16 @@
+//#region src/runtime/shared/shape.ts
+/**
+* Postgres text of a `timestamp`/`timestamptz` as a Date, like Drizzle's default `mode: 'date'`
+* reads it. Drizzle stores `timestamp` without time zone as UTC, so it's read as UTC too.
+*/
+function parseTimestamp(value) {
+	const iso = value.replace(" ", "T").replace(/([+-]\d{2})$/, "$1:00");
+	return new Date(/(Z|[+-]\d{2}:\d{2})$/.test(iso) ? iso : `${iso}Z`);
+}
+/** Electric parsers for the types Drizzle reads differently from Electric's defaults. */
+const shapeParser = {
+	timestamp: parseTimestamp,
+	timestamptz: parseTimestamp
+};
+//#endregion
+export { parseTimestamp, shapeParser };

package/dist/shapes.js

@@ -0,0 +1,67 @@
+import { readdir } from "node:fs/promises";
+import { extname, join, relative, sep } from "node:path";
+//#region src/shapes.ts
+const ROUTE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".ts",
+	".mts",
+	".js",
+	".mjs"
+]);
+/** The GET routes among `files` (relative to `server/api/shapes`), as Nitro would serve them. */
+function shapeRoutes(files, base = "/api/shapes") {
+	const routes = [];
+	for (const file of files.toSorted((a, b) => a.localeCompare(b))) {
+		const ext = extname(file);
+		if (!ROUTE_EXTENSIONS.has(ext) || file.endsWith(`.d${ext}`)) continue;
+		const parts = file.slice(0, -ext.length).split(sep).join("/").split("/");
+		const last = parts.pop();
+		const method = last.match(/\.(get|post|put|patch|delete|head|options)$/)?.[1];
+		if (method && method !== "get") continue;
+		const name = method ? last.slice(0, -method.length - 1) : last;
+		if (name !== "index") parts.push(name);
+		let dynamic = false;
+		const segments = parts.map((segment) => {
+			if (!/^\[.+\]$/.test(segment)) return segment;
+			dynamic = true;
+			return "${string}";
+		});
+		routes.push({
+			route: [base, ...segments].join("/"),
+			dynamic,
+			file
+		});
+	}
+	return routes;
+}
+async function findShapeRoutes(dir) {
+	return shapeRoutes(await readdir(dir, { recursive: true }).catch(() => [])).map((entry) => ({
+		...entry,
+		file: join(dir, entry.file)
+	}));
+}
+/** The `.d.ts` declaring `WervtShapeRoutes`; paths are made relative to `typesDir`. */
+function shapeRoutesTypes(routes, typesDir, shapeTypes) {
+	const importPath = (file) => {
+		const path = relative(typesDir, file).split(sep).join("/");
+		const ext = extname(path);
+		const withoutExt = ext ? path.slice(0, -ext.length) : path;
+		return withoutExt.startsWith(".") ? withoutExt : `./${withoutExt}`;
+	};
+	const entries = routes.map(({ route, dynamic, file }) => {
+		return `    ${dynamic ? `[path: \`${route}\`]` : JSON.stringify(route)}: ShapeRowOf<typeof import(${JSON.stringify(importPath(file))}).default>`;
+	});
+	return [
+		`import type { ShapeRowOf } from ${JSON.stringify(importPath(shapeTypes))}`,
+		"",
+		"declare global {",
+		"  interface WervtShapeRoutes {",
+		...entries,
+		"  }",
+		"}",
+		"",
+		"export {}",
+		""
+	].join("\n");
+}
+//#endregion
+export { findShapeRoutes, shapeRoutes, shapeRoutesTypes };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wervt/nuxt",
-  "version": "0.2.14",
+  "version": "0.2.16",
   "description": "Nuxt module for apps hosted on wervt: database, live data, MCP and runtime setup.",
   "keywords": [
     "drizzle",
@@ -33,6 +33,10 @@
       "types": "./dist/runtime/server/index.d.ts",
       "default": "./dist/runtime/server/index.js"
     },
+    "./email": {
+      "types": "./dist/runtime/email/index.d.ts",
+      "default": "./dist/runtime/email/index.js"
+    },
     "./provision": {
       "types": "./dist/provision.d.ts",
       "default": "./dist/provision.js"
@@ -44,11 +48,13 @@
     "aws4fetch": "^1.0.20",
     "evlog": "^2.30.1",
     "h3-mcp": "0.2.0",
+    "html-to-text": "^9.0.5",
     "jose": "^6.2.12",
     "postgres": "^3.4.9",
     "valibot": "^1.5.0"
   },
   "devDependencies": {
+    "@types/html-to-text": "^9.0.4",
     "drizzle-orm": "1.0.0-rc.4",
     "h3": "2.0.2",
     "nitro": "3.0.260903-beta",