@antelopejs/dms-mailing 0.3.3 → 0.4.0

package/frontend-vue/app/components/editor/EditorVariables.vue

@@ -1,163 +0,0 @@
-<script setup lang="ts">
-import { computed, ref } from 'vue'
-import type { VariableDefinition, VariableType } from '../../types/mailing'
-import { VARIABLE_TYPES } from '../../types/mailing'
-import { useEditorContext } from '../../composables/useEditorContext'
-import { collectContentPaths } from '../../utils/paths'
-import { mergeVariables } from '../../utils/variables'
-
-const DEFAULT_TYPE: VariableType = 'string'
-
-const emit = defineEmits<{ insert: [string] }>()
-
-const { t } = useI18n()
-const { api, editor, templateId, variables, detectedVariables } =
-	useEditorContext()
-
-// `detectedVariables` comes from the server and only refreshes on save, so on
-// its own it strikes through a path the moment it is wired into a condition.
-// Union it with what the editor currently holds: the server list still covers
-// what a save has seen, and the live one covers what the author just did.
-const detected = computed(() => [
-	...new Set([
-		...detectedVariables.value,
-		...collectContentPaths(editor.content),
-	]),
-])
-
-const merged = computed(() => mergeVariables(detected.value, variables.value))
-const undeclared = computed(() =>
-	merged.value
-		.filter((entry) => entry.usage === 'detected')
-		.map((entry) => entry.path),
-)
-
-const declaring = ref(false)
-const saving = ref(false)
-const draft = ref<VariableDefinition>({
-	path: '',
-	type: DEFAULT_TYPE,
-	required: false,
-})
-
-function reset(): void {
-	draft.value = { path: '', type: DEFAULT_TYPE, required: false }
-	declaring.value = false
-}
-
-function startDeclaring(): void {
-	draft.value = {
-		path: undeclared.value[0] ?? '',
-		type: DEFAULT_TYPE,
-		required: false,
-	}
-	declaring.value = true
-}
-
-async function declare(): Promise<void> {
-	if (!draft.value.path) return
-	saving.value = true
-	try {
-		const next = [...variables.value, { ...draft.value }]
-		const response = await api.saveVariables(templateId, next)
-		variables.value = response.variables ?? next
-		reset()
-	} finally {
-		saving.value = false
-	}
-}
-</script>
-
-<template>
-	<section class="flex flex-col gap-2">
-		<p class="text-muted text-[11px] font-semibold uppercase tracking-wide">
-			{{ t('dms_mailing.editor.groups.variables') }}
-		</p>
-
-		<p v-if="merged.length === 0" class="text-muted text-[11px]">
-			{{ t('dms_mailing.editor.variables.empty') }}
-		</p>
-
-		<button
-			v-for="variable in merged"
-			:key="variable.path"
-			type="button"
-			class="border-default hover:border-primary flex items-center gap-2 rounded-md border px-2 py-1.5 text-left transition"
-			:title="t('dms_mailing.editor.variables.insert')"
-			@click="emit('insert', variable.path)"
-		>
-			<code
-				class="min-w-0 flex-1 truncate font-mono text-[11px]"
-				:class="variable.usage === 'unused' ? 'text-muted line-through' : ''"
-			>
-				{{ variable.path }}
-			</code>
-			<UBadge
-				v-if="variable.usage === 'unused'"
-				size="sm"
-				variant="subtle"
-				color="warning"
-			>
-				{{ t('dms_mailing.editor.variables.unused') }}
-			</UBadge>
-			<UBadge size="sm" variant="subtle" color="neutral">
-				{{ variable.type }}
-			</UBadge>
-			<UBadge
-				v-if="variable.required"
-				size="sm"
-				variant="subtle"
-				color="warning"
-			>
-				{{ t('dms_mailing.editor.variables.required') }}
-			</UBadge>
-		</button>
-
-		<UButton
-			v-if="!declaring"
-			size="xs"
-			variant="outline"
-			color="neutral"
-			icon="i-ph-plus"
-			@click="startDeclaring()"
-		>
-			{{ t('dms_mailing.editor.variables.declare') }}
-		</UButton>
-
-		<div
-			v-else
-			class="border-default flex flex-col gap-2 rounded-md border p-2"
-		>
-			<UFormField :label="t('dms_mailing.editor.variables.path')" size="xs">
-				<UInput
-					v-model="draft.path"
-					class="w-full"
-					placeholder="order.total"
-					list="editor-detected-paths"
-				/>
-				<datalist id="editor-detected-paths">
-					<option v-for="path in undeclared" :key="path" :value="path" />
-				</datalist>
-			</UFormField>
-			<UFormField :label="t('dms_mailing.editor.variables.type')" size="xs">
-				<USelect v-model="draft.type" class="w-full" :items="VARIABLE_TYPES" />
-			</UFormField>
-			<UFormField :label="t('dms_mailing.editor.variables.required')" size="xs">
-				<USwitch v-model="draft.required" />
-			</UFormField>
-			<div class="flex items-center gap-2">
-				<UButton
-					size="xs"
-					:loading="saving"
-					:disabled="!draft.path"
-					@click="declare()"
-				>
-					{{ t('dms_mailing.editor.variables.add') }}
-				</UButton>
-				<UButton size="xs" variant="ghost" color="neutral" @click="reset()">
-					{{ t('dms_mailing.editor.variables.cancel') }}
-				</UButton>
-			</div>
-		</div>
-	</section>
-</template>

package/frontend-vue/app/composables/useMailingPeriodData.ts

@@ -1,39 +0,0 @@
-import type { Ref } from 'vue'
-import { periodQuery } from '../utils/period'
-
-export interface PeriodDataState<T> {
-	data: Ref<T | null>
-	loading: Ref<boolean>
-	refresh: () => Promise<void>
-}
-
-/**
- * Reads a DMS period-selector scope and re-runs `load` whenever the window
- * changes. The scope registers when the selector mounts, so the first run is
- * driven by the watcher rather than by `onMounted`.
- */
-export function useMailingPeriodData<T>(
-	scope: string,
-	load: (query: Record<string, string>) => Promise<T>,
-): PeriodDataState<T> {
-	const period = usePeriodScope(scope)
-	const data = ref(null) as Ref<T | null>
-	const loading = ref(false)
-
-	async function refresh(): Promise<void> {
-		const state = period.value
-		if (!state) return
-		loading.value = true
-		try {
-			data.value = await load(periodQuery(state))
-		} catch {
-			data.value = null
-		} finally {
-			loading.value = false
-		}
-	}
-
-	watch(period, refresh, { immediate: true })
-
-	return { data, loading, refresh }
-}

package/src/antelope-modules.ts

@@ -1,48 +0,0 @@
-/**
- * The package modules the playground and the test stack both run.
- *
- * Declared once so a version bump lands in a single place: the two configs
- * previously repeated these, and an upgrade that missed one failed the whole
- * test run with `Incompatible interface package resolution` — the harness
- * resolves its own module set, so a stale pin there is not caught by the
- * module's own `package.json`.
- *
- * Only the *source* is shared. Each config supplies its own per-module
- * `config`, since the playground talks to a real Mongo and Ethereal while the
- * tests drive a memory replica set and an SMTP fixture.
- *
- * Modules only one stack needs — the playground's `dms-automation`, the local
- * checkouts — stay in their own config.
- */
-export const SHARED_MODULE_SOURCES = {
-  dms: {
-    type: "package",
-    package: "@antelopejs/dms",
-    version: ">=0.4.3 <1.0.0",
-  },
-  mongodb: {
-    type: "package",
-    package: "@antelopejs/mongodb",
-    version: "^1.3.1",
-  },
-  "auth-jwt": {
-    type: "package",
-    package: "@antelopejs/auth-jwt",
-    version: "^1.0.3",
-  },
-  api: {
-    type: "package",
-    package: "@antelopejs/api",
-    version: "^1.3.0",
-  },
-  "file-storage-local": {
-    type: "package",
-    package: "@antelopejs/file-storage-local",
-    version: "^0.1.5",
-  },
-  nodemailer: {
-    type: "package",
-    package: "@antelopejs/nodemailer",
-    version: "^0.0.5",
-  },
-} as const;

package/src/test/antelope.test.ts

@@ -1,190 +0,0 @@
-import { mkdtemp, rm } from "node:fs/promises";
-import { createServer, type Server, type Socket } from "node:net";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { defineConfig } from "@antelopejs/interface-core/config";
-import { MongoMemoryReplSet } from "mongodb-memory-server-core";
-import { SHARED_MODULE_SOURCES } from "../antelope-modules";
-
-const API_PORT = 5019;
-const JWT_SECRET = "test-jwt-secret";
-const MONGO_BINARY_VERSION = "8.0.8";
-const SMTP_HOST = "127.0.0.1";
-const EPHEMERAL_PORT = 0;
-const TEST_SENDER = "dms-mailing@test.local";
-const SMTP_RESPONSES: Record<string, string> = {
-  EHLO: "250-dms-mailing.test\r\n250 PIPELINING\r\n",
-  HELO: "250 dms-mailing.test\r\n",
-  MAIL: "250 OK\r\n",
-  RCPT: "250 OK\r\n",
-  DATA: "354 End data with <CR><LF>.<CR><LF>\r\n",
-  RSET: "250 OK\r\n",
-  NOOP: "250 OK\r\n",
-  QUIT: "221 Bye\r\n",
-};
-
-interface SmtpConnectionState {
-  pending: string;
-  isReadingData: boolean;
-}
-
-let mongod: MongoMemoryReplSet;
-let storageDir: string;
-let smtpServer: Server;
-
-function processSmtpLine(
-  socket: Socket,
-  state: SmtpConnectionState,
-  line: string,
-): void {
-  if (state.isReadingData) {
-    if (line === ".") {
-      state.isReadingData = false;
-      socket.write("250 Queued\r\n");
-    }
-    return;
-  }
-  const command = line.split(" ", 1)[0]?.toUpperCase() ?? "";
-  state.isReadingData = command === "DATA";
-  const response = SMTP_RESPONSES[command] ?? "250 OK\r\n";
-  if (command === "QUIT") socket.end(response);
-  else socket.write(response);
-}
-
-function createSmtpFixture(): Server {
-  return createServer((socket) => {
-    const state: SmtpConnectionState = { pending: "", isReadingData: false };
-    socket.setEncoding("utf8");
-    socket.write("220 dms-mailing.test ESMTP\r\n");
-    socket.on("data", (chunk) => {
-      state.pending += chunk;
-      const lines = state.pending.split(/\r?\n/);
-      state.pending = lines.pop() ?? "";
-      for (const line of lines) processSmtpLine(socket, state, line);
-    });
-  });
-}
-
-async function startSmtpFixture(): Promise<number> {
-  smtpServer = createSmtpFixture();
-  await new Promise<void>((resolve, reject) => {
-    const onError = (error: Error) => reject(error);
-    smtpServer.once("error", onError);
-    smtpServer.listen(EPHEMERAL_PORT, SMTP_HOST, () => {
-      smtpServer.off("error", onError);
-      resolve();
-    });
-  });
-  const address = smtpServer.address();
-  if (!address || typeof address === "string")
-    throw new Error("Invalid SMTP address");
-  return address.port;
-}
-
-function stopSmtpFixture(): Promise<void> {
-  if (!smtpServer) return Promise.resolve();
-  return new Promise((resolve, reject) => {
-    smtpServer.close((error) => (error ? reject(error) : resolve()));
-  });
-}
-
-export default defineConfig({
-  name: "dms-mailing-test",
-  cacheFolder: ".antelope/cache",
-  logging: {
-    channelFilter: {
-      "*": "warn",
-    },
-  },
-  modules: {
-    local: {
-      source: {
-        type: "local",
-        path: ".",
-        installCommand: ["pnpm build"],
-      },
-      config: { useHtmlRender: false },
-    },
-    dms: {
-      source: SHARED_MODULE_SOURCES.dms,
-      config: {
-        auth: {
-          jwtSecret: JWT_SECRET,
-        },
-      },
-    },
-    mongodb: {
-      source: SHARED_MODULE_SOURCES.mongodb,
-    },
-    "auth-jwt": {
-      source: SHARED_MODULE_SOURCES["auth-jwt"],
-      config: {
-        secret: JWT_SECRET,
-      },
-    },
-    api: {
-      source: SHARED_MODULE_SOURCES.api,
-      config: {
-        servers: [{ protocol: "http", host: "127.0.0.1", port: API_PORT }],
-        // Required outside development, which the test run is not.
-        publicBaseUrl: `http://127.0.0.1:${API_PORT}`,
-      },
-    },
-    "file-storage-local": {
-      source: SHARED_MODULE_SOURCES["file-storage-local"],
-    },
-    nodemailer: {
-      source: SHARED_MODULE_SOURCES.nodemailer,
-      config: {
-        host: SMTP_HOST,
-        port: EPHEMERAL_PORT,
-        secure: false,
-        defaults: { from: TEST_SENDER },
-      },
-    },
-  },
-  test: {
-    folder: process.env.DMS_MAILING_TEST_DIR ?? "dist/test",
-    async setup() {
-      const smtpPort = await startSmtpFixture();
-      mongod = await MongoMemoryReplSet.create({
-        replSet: { count: 1 },
-        binary: { version: MONGO_BINARY_VERSION },
-      });
-      storageDir = await mkdtemp(join(tmpdir(), "dms-mailing-test-storage-"));
-
-      const mongoUrl = mongod.getUri();
-      process.env.TEST_MONGO_URL = mongoUrl;
-      process.env.TEST_API_BASE_URL = `http://127.0.0.1:${API_PORT}`;
-      process.env.TEST_JWT_SECRET = JWT_SECRET;
-
-      return {
-        modules: {
-          mongodb: {
-            config: { url: mongoUrl, database: "dms-mailing-test" },
-          },
-          "file-storage-local": {
-            config: {
-              storagePath: storageDir,
-              baseUrl: `http://127.0.0.1:${API_PORT}`,
-              defaultVisibility: "private",
-            },
-          },
-          nodemailer: {
-            config: { port: smtpPort },
-          },
-        },
-      };
-    },
-    async cleanup() {
-      try {
-        await Promise.all([
-          mongod ? mongod.stop() : Promise.resolve(),
-          stopSmtpFixture(),
-        ]);
-      } finally {
-        if (storageDir) await rm(storageDir, { recursive: true, force: true });
-      }
-    },
-  },
-});

package/src/test/helpers/http.ts

@@ -1,23 +0,0 @@
-import axios, { type AxiosInstance } from "axios";
-
-const DEFAULT_BASE_URL = "http://127.0.0.1:5019";
-
-export function getBaseUrl(): string {
-  return process.env.TEST_API_BASE_URL ?? DEFAULT_BASE_URL;
-}
-
-export function createClient(): AxiosInstance {
-  return axios.create({
-    baseURL: getBaseUrl(),
-    validateStatus: () => true,
-    headers: {
-      "x-antelopejs-namespace": "default",
-    },
-  });
-}
-
-export function authorizedClient(token: string): AxiosInstance {
-  const client = createClient();
-  client.defaults.headers.common.Authorization = `Bearer ${token}`;
-  return client;
-}

package/src/test/helpers/owner.ts

@@ -1,37 +0,0 @@
-import { createClient } from "./http";
-
-const OWNER_EMAIL = "owner@test.local";
-const OWNER_PASSWORD = "TestPassw0rd!";
-const OWNER_NAME = "Test Owner";
-const HTTP_BAD_REQUEST = 400;
-
-export interface OwnerSession {
-  accessToken: string;
-  email: string;
-}
-
-export async function ensureOwnerSession(): Promise<OwnerSession> {
-  const client = createClient();
-  const registration = await client.post("/api/onboarding/register", {
-    name: OWNER_NAME,
-    email: OWNER_EMAIL,
-    password: OWNER_PASSWORD,
-  });
-  const isRegistered = registration.status < HTTP_BAD_REQUEST;
-  const isAlreadyRegistered = registration.status === HTTP_BAD_REQUEST;
-  if (!isRegistered && !isAlreadyRegistered) {
-    throw new Error(
-      `Onboarding failed [${registration.status}]: ${JSON.stringify(registration.data)}`,
-    );
-  }
-  const login = await client.post("/api/auth/login", {
-    email: OWNER_EMAIL,
-    password: OWNER_PASSWORD,
-  });
-  if (login.status >= HTTP_BAD_REQUEST) {
-    throw new Error(
-      `Login failed [${login.status}]: ${JSON.stringify(login.data)}`,
-    );
-  }
-  return { accessToken: login.data.access_token, email: OWNER_EMAIL };
-}

package/src/test/integration/events.test.ts

@@ -1,159 +0,0 @@
-import { expect } from "chai";
-import {
-  clearEmailEventSubscriptions,
-  emailEventTrigger,
-} from "../../automation/email-event-trigger";
-import { authorizedClient, createClient } from "../helpers/http";
-import { ensureOwnerSession } from "../helpers/owner";
-
-const HTTP_OK = 200;
-const HTTP_FORBIDDEN = 403;
-const SECRET_LENGTH = 48;
-const TABLE = "/api/mailing/tables/templates";
-
-interface EventRow {
-  type: string;
-}
-
-describe("[integration] events", () => {
-  it("records a webhook event against the send that carries the provider message id", async () => {
-    const session = await ensureOwnerSession();
-    const client = authorizedClient(session.accessToken);
-    const settings = await client.get("/api/mailing/settings");
-    const created = await client.post(`${TABLE}/new`, {
-      slug: "event-target",
-      name: "Event target",
-      category: "orders",
-    });
-    expect(created.status, JSON.stringify(created.data)).to.equal(HTTP_OK);
-    const sent = await client.post(
-      `/api/mailing/templates/${created.data[0]}/test-send`,
-      { to: ["events@example.test"], locale: "en", data: {} },
-    );
-    expect(sent.status, JSON.stringify(sent.data)).to.equal(HTTP_OK);
-    const sendId = sent.data.results[0].sendId as string;
-
-    const detail = await client.get(`/api/mailing/sends/${sendId}`);
-    const messageId = detail.data.send.providerMessageId as string;
-    expect(messageId, "provider message id").to.be.a("string");
-    expect(messageId.length, "provider message id").to.be.greaterThan(0);
-
-    const hook = await client.post(
-      "/api/mailing/events/manual",
-      { messageId, type: "opened", details: { userAgent: "test" } },
-      { headers: { "x-mailing-webhook-secret": settings.data.webhookSecret } },
-    );
-    expect(hook.status, JSON.stringify(hook.data)).to.equal(HTTP_OK);
-    expect(hook.data.recorded).to.equal(true);
-
-    const after = await client.get(`/api/mailing/sends/${sendId}`);
-    expect(after.data.send.status).to.equal("opened");
-    expect(after.data.send.opens).to.equal(1);
-    expect(after.data.events.map((event: EventRow) => event.type)).to.include(
-      "opened",
-    );
-
-    const rejected = await client.post("/api/mailing/events/manual", {
-      messageId,
-      type: "opened",
-    });
-    expect(rejected.status).to.equal(HTTP_FORBIDDEN);
-  });
-
-  it("records the event even when an automation subscription throws", async () => {
-    const session = await ensureOwnerSession();
-    const client = authorizedClient(session.accessToken);
-    const settings = await client.get("/api/mailing/settings");
-    const created = await client.post(`${TABLE}/new`, {
-      slug: "throwing-subscriber",
-      name: "Throwing subscriber",
-      category: "orders",
-    });
-    expect(created.status, JSON.stringify(created.data)).to.equal(HTTP_OK);
-    const sent = await client.post(
-      `/api/mailing/templates/${created.data[0]}/test-send`,
-      { to: ["throwing@example.test"], locale: "en", data: {} },
-    );
-    expect(sent.status, JSON.stringify(sent.data)).to.equal(HTTP_OK);
-    const sendId = sent.data.results[0].sendId as string;
-    const detail = await client.get(`/api/mailing/sends/${sendId}`);
-    const messageId = detail.data.send.providerMessageId as string;
-
-    await emailEventTrigger.activate({}, () => {
-      throw new Error("subscriber exploded");
-    });
-    try {
-      const hook = await client.post(
-        "/api/mailing/events/manual",
-        { messageId, type: "delivered" },
-        {
-          headers: { "x-mailing-webhook-secret": settings.data.webhookSecret },
-        },
-      );
-      expect(hook.status, JSON.stringify(hook.data)).to.equal(HTTP_OK);
-      expect(hook.data.recorded).to.equal(true);
-    } finally {
-      clearEmailEventSubscriptions();
-    }
-
-    const after = await client.get(`/api/mailing/sends/${sendId}`);
-    expect(after.data.send.status).to.equal("delivered");
-  });
-});
-
-describe("[integration] webhook for a tenant without settings", () => {
-  // The endpoint is unauthenticated and takes the tenant from the body: reading
-  // the secret must not create a settings row for whatever tenant id it names.
-  it("refuses the event and stores nothing", async () => {
-    const { GetModel } =
-      await import("@antelopejs/interface-database-decorators");
-    const { SettingsModel } = await import("../../db");
-    const tenantId = `unknown-tenant-${Date.now()}`;
-
-    const hook = await createClient().post(
-      "/api/mailing/events/manual",
-      { messageId: "unknown-message", type: "opened", tenantId },
-      { headers: { "x-mailing-webhook-secret": "a".repeat(SECRET_LENGTH) } },
-    );
-
-    expect(hook.status).to.equal(HTTP_FORBIDDEN);
-    expect(await GetModel(SettingsModel, tenantId).getAll()).to.have.lengthOf(
-      0,
-    );
-  });
-});
-
-describe("[integration] send event purge", () => {
-  // The retention cron deletes a send's events in one filtered statement. A
-  // wrong predicate there would take another send's history with it, so pin
-  // that it removes exactly one send's rows.
-  it("deletes only the events of the send it targets", async () => {
-    const { GetModel } =
-      await import("@antelopejs/interface-database-decorators");
-    const { DEFAULT_TENANT_ID } =
-      await import("@antelopejs/interface-dms/constants");
-    const { SendEventModel } = await import("../../db");
-    const events = GetModel(SendEventModel, DEFAULT_TENANT_ID);
-
-    const kept = `keep-${Date.now()}`;
-    const purged = `purge-${Date.now()}`;
-    await events.insert({
-      sendId: purged,
-      type: "delivered",
-      at: new Date(),
-      json_details: "{}",
-    });
-    await events.insert({
-      sendId: kept,
-      type: "opened",
-      at: new Date(),
-      json_details: "{}",
-    });
-
-    const removed = await events.deleteBySend(purged);
-
-    expect(removed).to.equal(1);
-    expect(await events.getBySend(purged)).to.have.lengthOf(0);
-    expect(await events.getBySend(kept)).to.have.lengthOf(1);
-  });
-});