@benclmnt/postmock 0.0.1

package/dist/src/api/templates/routes.js

@@ -0,0 +1,164 @@
+import { z } from "zod";
+import { apiError } from "../../errors.js";
+import { absent, queryInt } from "../../http/normalize.js";
+import { Unsupported } from "../../http/respond.js";
+import { defineRoute } from "../../http/routes.js";
+import { sendBatchWithTemplates, sendWithTemplate } from "./send.js";
+import { activeTemplate, checkCanCreate, checkLayoutChange, checkTemplate, findTemplate, generatedAlias, parseOrReject, parseTemplateType, TEMPLATE_TYPES, templateJson, templateListJson, templateNotFound, templateSummaryJson, } from "./templates.js";
+import { validateTemplate } from "./validate.js";
+// Templates API (docs/06 §3). Template push (`PUT /templates/push`) belongs to the account API.
+const text = absent(z.string());
+// dotnet sends every key, null when unset (docs/08 §1.3). `LayoutTemplate: ""` clears the layout
+// (refs/api_templates-api.md:545), so it keeps "" apart from null.
+const templateBody = z.object({
+    Name: text,
+    Subject: text,
+    HtmlBody: text,
+    TextBody: text,
+    Alias: text,
+    TemplateType: text,
+    LayoutTemplate: z.string().nullable().optional(),
+});
+defineRoute({
+    method: "GET",
+    path: "/templates",
+    auth: "server",
+    handler: ({ store, query, auth }) => {
+        const paging = query.pick(z.object({ count: queryInt, offset: queryInt }));
+        // refs/api_templates-api.md:694-695: both required. Messages INFERRED.
+        if (!paging.success || paging.data.count < 1 || paging.data.offset < 0) {
+            throw apiError(1100, {
+                message: "The 'Count' and 'Offset' query parameters are required non-negative integers.",
+            });
+        }
+        const filter = query.get("TemplateType") ?? "All";
+        if (filter !== "All" && !TEMPLATE_TYPES.some((t) => t === filter)) {
+            throw apiError(1100, {
+                message: `Invalid 'TemplateType': '${filter}'. Use All, Standard or Layout.`,
+            });
+        }
+        const layout = query.get("LayoutTemplate");
+        // A deleted template leaves the list (sdk/postmark-dotnet/src/Postmark.Tests/ClientTemplateTests.cs:150-155).
+        const templates = [...store.state.templates.values()]
+            .filter((t) => t.ServerID === auth.server.ID &&
+            t.Active &&
+            (filter === "All" || t.TemplateType === filter) &&
+            (layout === undefined || t.LayoutTemplate === layout))
+            .sort((a, b) => a.TemplateId - b.TemplateId);
+        const { count, offset } = paging.data;
+        return {
+            TotalCount: templates.length,
+            Templates: templates.slice(offset, offset + count).map(templateListJson),
+        };
+    },
+});
+// A deleted template stays readable with `Active: false`
+// (sdk/postmark-dotnet/src/Postmark.Tests/ClientTemplateTests.cs:112-115).
+defineRoute({
+    method: "GET",
+    path: "/templates/:idOrAlias",
+    auth: "server",
+    handler: ({ store, params, auth }) => {
+        const template = findTemplate(store.state, auth.server.ID, params.idOrAlias ?? "");
+        if (template === undefined)
+            throw templateNotFound(params.idOrAlias ?? "");
+        return templateJson(template);
+    },
+});
+defineRoute({
+    method: "POST",
+    path: "/templates",
+    auth: "server",
+    handler: ({ store, body, auth }) => {
+        // An empty body is 1109 (refs/api_overview.md:86; INFERRED trigger).
+        if (body === undefined || JSON.stringify(body) === "{}") {
+            throw apiError(1109);
+        }
+        const input = parseOrReject(templateBody, body);
+        const { state } = store;
+        checkCanCreate(state, auth.server.ID);
+        const draft = {
+            TemplateId: 0,
+            ServerID: auth.server.ID,
+            Name: input.Name ?? "",
+            Alias: input.Alias ?? null,
+            Subject: input.Subject ?? null,
+            HtmlBody: input.HtmlBody ?? null,
+            TextBody: input.TextBody ?? null,
+            TemplateType: parseTemplateType(input.TemplateType),
+            LayoutTemplate: input.LayoutTemplate || null,
+            Active: true,
+        };
+        checkTemplate(state, draft);
+        const created = { ...draft, TemplateId: store.nextId("template") };
+        const template = {
+            ...created,
+            Alias: created.Alias ?? generatedAlias(state, created),
+        };
+        state.templates.set(template.TemplateId, template);
+        return templateSummaryJson(template);
+    },
+});
+// Edit changes only the fields sent: postmark.js sends `{Name}` alone, php sends only a layout
+// (sdk/postmark.js/test/integration/Templates.test.ts:100; sdk/postmark-php/tests/PostmarkClientTemplatesTest.php:86).
+defineRoute({
+    method: "PUT",
+    path: "/templates/:idOrAlias",
+    auth: "server",
+    handler: ({ store, body, params, auth }) => {
+        const input = parseOrReject(templateBody, body ?? {});
+        const { state } = store;
+        const before = activeTemplate(state, auth.server.ID, params.idOrAlias ?? "");
+        if (input.TemplateType !== undefined &&
+            parseTemplateType(input.TemplateType) !== before.TemplateType) {
+            // "After creation, it's not possible to change a template type." (refs/api_templates-api.md:544)
+            throw new Unsupported("the response to a TemplateType change is not captured");
+        }
+        const after = {
+            ...before,
+            Name: input.Name ?? before.Name,
+            Alias: input.Alias ?? before.Alias,
+            Subject: input.Subject ?? before.Subject,
+            HtmlBody: input.HtmlBody ?? before.HtmlBody,
+            TextBody: input.TextBody ?? before.TextBody,
+            LayoutTemplate: input.LayoutTemplate === undefined || input.LayoutTemplate === null
+                ? before.LayoutTemplate
+                : input.LayoutTemplate || null,
+        };
+        checkTemplate(state, after);
+        checkLayoutChange(state, before, after);
+        state.templates.set(after.TemplateId, after);
+        return templateSummaryJson(after);
+    },
+});
+defineRoute({
+    method: "DELETE",
+    path: "/templates/:idOrAlias",
+    auth: "server",
+    handler: ({ store, params, auth }) => {
+        const { state } = store;
+        const template = activeTemplate(state, auth.server.ID, params.idOrAlias ?? "");
+        checkLayoutChange(state, template, null);
+        state.templates.set(template.TemplateId, { ...template, Active: false });
+        // refs/api_templates-api.md:769-771.
+        return { ErrorCode: 0, Message: `Template ${template.TemplateId} removed.` };
+    },
+});
+defineRoute({
+    method: "POST",
+    path: "/templates/validate",
+    auth: "server",
+    handler: ({ store, body, auth }) => validateTemplate(store.state, auth.server.ID, body ?? {}),
+});
+defineRoute({
+    method: "POST",
+    path: "/email/withTemplate",
+    auth: "server",
+    handler: (ctx) => sendWithTemplate(ctx, ctx.auth, ctx.body),
+});
+defineRoute({
+    method: "POST",
+    path: "/email/batchWithTemplates",
+    auth: "server",
+    handler: (ctx) => sendBatchWithTemplates(ctx, ctx.auth, ctx.body),
+});

package/dist/src/api/templates/send.d.ts

@@ -0,0 +1,13 @@
+import type { RequestContext, ServerAuth } from "../../http/routes.ts";
+export declare function sendWithTemplate(ctx: RequestContext, auth: ServerAuth, body: unknown): Promise<{
+    To: string;
+    SubmittedAt: string;
+    MessageID: string;
+    ErrorCode: number;
+    Message: string;
+}>;
+/**
+ * One item per message in request order (docs/03 §2). Every item is validated before any is
+ * stored, as on `/email/batch`.
+ */
+export declare function sendBatchWithTemplates(ctx: RequestContext, auth: ServerAuth, body: unknown): Promise<import("../../errors.ts").ErrorBody[]>;

package/dist/src/api/templates/send.js

@@ -0,0 +1,105 @@
+import { z } from "zod";
+import { ApiError, apiError } from "../../errors.js";
+import { absent } from "../../http/normalize.js";
+import { Unsupported } from "../../http/respond.js";
+import { acceptOutbound, acceptOutbounds, draftFromJson, refuseSenderAfterDataError, validateOutbound, } from "../../pipeline/submit.js";
+import { batchItem, sendResponse } from "../email/json.js";
+import { renderContent } from "./content.js";
+import { CONTENT_PARTS, parseOrReject, sendTemplate, templateIdField, templateModelField, } from "./templates.js";
+// `/email/withTemplate` and `/email/batchWithTemplates` (docs/03 §1.4–§1.5, docs/06 §3.6).
+const MAX_BATCH_MESSAGES = 500;
+/** The template fields of a message; the send fields go through `draftFromJson`. */
+const templateFields = z.object({
+    TemplateId: templateIdField,
+    TemplateAlias: absent(z.string()),
+    TemplateModel: templateModelField,
+    InlineCss: absent(z.boolean()),
+});
+/**
+ * Renders one templated message and validates the result. Check order is INFERRED: templated vs
+ * content fields (1123), template (1101), model (1120), then the pipeline checks. A template error
+ * throws `ApiError`.
+ */
+function validateTemplated(ctx, auth, raw) {
+    const draft = draftFromJson(raw);
+    try {
+        return validateRendered(ctx, auth, raw, draft);
+    }
+    catch (error) {
+        if (error instanceof ApiError)
+            refuseSenderAfterDataError(ctx, auth, draft.From);
+        throw error;
+    }
+}
+function validateRendered(ctx, auth, raw, draft) {
+    const message = parseOrReject(templateFields, raw);
+    for (const part of CONTENT_PARTS) {
+        // R9: null and "" are absent (docs/08).
+        if (draft[part] !== undefined && draft[part] !== null && draft[part] !== "") {
+            throw apiError(1123, {
+                message: `The '${part}' field cannot be used when sending with a template.`,
+            });
+        }
+    }
+    const { template, layout } = sendTemplate(ctx.store.state, auth.server.ID, message);
+    if (message.TemplateModel === undefined) {
+        throw apiError(1120, { message: "The 'TemplateModel' field is required." });
+    }
+    const rendered = renderContent(template, layout, message.TemplateModel, message.InlineCss ?? true);
+    if (!rendered.ok)
+        throw new Error(`stored template ${template.TemplateId} does not parse`);
+    return validateOutbound(ctx, {
+        auth,
+        channel: "rest",
+        draft: {
+            ...draft,
+            Subject: rendered.content.Subject ?? undefined,
+            HtmlBody: rendered.content.HtmlBody ?? undefined,
+            TextBody: rendered.content.TextBody ?? undefined,
+        },
+        request: raw,
+        bulkRequestId: null,
+        templateId: template.TemplateId,
+    });
+}
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+export async function sendWithTemplate(ctx, auth, body) {
+    if (!isObject(body))
+        throw new Unsupported("a send body that is not a JSON object");
+    const validation = validateTemplated(ctx, auth, body);
+    if (validation.outcome === "rejected")
+        return sendResponse(validation, "");
+    const { outbound } = validation;
+    return sendResponse(await acceptOutbound(ctx, outbound), outbound.draft.To);
+}
+const batchBody = z.object({ Messages: z.array(z.unknown()) });
+/**
+ * One item per message in request order (docs/03 §2). Every item is validated before any is
+ * stored, as on `/email/batch`.
+ */
+export async function sendBatchWithTemplates(ctx, auth, body) {
+    const { Messages } = parseOrReject(batchBody, body);
+    if (!Messages.every(isObject))
+        throw new Unsupported("a batch message that is not an object");
+    if (Messages.length > MAX_BATCH_MESSAGES)
+        throw apiError(410);
+    const validations = Messages.map((raw) => {
+        try {
+            return validateTemplated(ctx, auth, raw);
+        }
+        catch (error) {
+            if (!(error instanceof ApiError))
+                throw error;
+            return { outcome: "rejected", field: "", error: error.body };
+        }
+    });
+    // Whether 1235 is per item or for the whole request is not captured (docs/03 §8 Q14).
+    if (validations.some((v) => v.outcome === "rejected" && v.error.ErrorCode === 1235)) {
+        throw new Unsupported("an unknown MessageStream in a batch (docs/03 §8 Q14)");
+    }
+    const accepted = await acceptOutbounds(ctx, validations.flatMap((v) => (v.outcome === "valid" ? [v.outbound] : [])));
+    let next = 0;
+    return validations.map((validation) => validation.outcome === "rejected"
+        ? batchItem(validation, "")
+        : batchItem(accepted[next++], validation.outbound.draft.To));
+}

package/dist/src/api/templates/templates.d.ts

@@ -0,0 +1,100 @@
+import { z } from "zod";
+import type { State } from "../../state/store.ts";
+import type { Template } from "../../state/types.ts";
+export declare const TEMPLATE_TYPES: readonly ["Standard", "Layout"];
+export type TemplateType = (typeof TEMPLATE_TYPES)[number];
+export declare const CONTENT_PARTS: readonly ["Subject", "HtmlBody", "TextBody"];
+export type ContentPart = (typeof CONTENT_PARTS)[number];
+export type Content = Record<ContentPart, string | null>;
+/** ErrorCode 403 for a field of the wrong type, as in the send pipeline (docs/02 §9 Q13, INFERRED). */
+export declare const invalidField: (field: string) => import("../../errors.ts").ApiError;
+/** Parses a body with zod; a failure is 403 naming the first bad field. */
+export declare function parseOrReject<S extends z.ZodType>(schema: S, body: unknown): z.output<S>;
+/** `Standard` (default) or `Layout` (refs/api_templates-api.md:544); another value is 1122 (INFERRED text). */
+export declare function parseTemplateType(value: string | undefined): TemplateType;
+/**
+ * The template a path or send names: digits are an ID (an alias starts with a letter), anything
+ * else an alias. An alias matches exactly, active templates first (INFERRED).
+ */
+export declare function findTemplate(state: State, serverId: number, idOrAlias: string): Template | undefined;
+export declare const templateNotFound: (idOrAlias: string) => import("../../errors.ts").ApiError;
+export declare function activeTemplate(state: State, serverId: number, idOrAlias: string): Template;
+/** An active layout by alias; a missing or standard one is 1101 (refs/api_overview.md:84). */
+export declare function activeLayout(state: State, serverId: number, alias: string): Template;
+/**
+ * The placeholder rule for one part: a layout body holds `{{{ @content }}}` exactly once
+ * (refs/api_templates-api.md:541-542); a standard template holds none (INFERRED).
+ */
+export declare function layoutRuleError(type: TemplateType, part: ContentPart, placeholders: number): string | undefined;
+/** A template before create: `Alias` is null when the request sets none. */
+export type TemplateDraft = Omit<Template, "Alias"> & {
+    Alias: string | null;
+};
+/**
+ * Checks a template as it will be stored, after create or edit. Error codes per docs/02 §4.4;
+ * every message is INFERRED except the 1131 prefix the postmark.js live test reads
+ * (sdk/postmark.js/test/integration/Templates.test.ts:122).
+ */
+export declare function checkTemplate(state: State, template: TemplateDraft): void;
+export declare function checkCanCreate(state: State, serverId: number): void;
+/** A layout that templates use keeps its alias and cannot be deleted. */
+export declare function checkLayoutChange(state: State, before: Template, after: Template | null): void;
+/**
+ * A new template without an alias gets one. The dotnet and php live tests read a layout alias they
+ * never set (sdk/postmark-php/tests/PostmarkClientTemplatesTest.php:55-57). The postmark-cli pull
+ * test creates a standard template without an alias and expects every template pulled: pull stops
+ * at the first template without one (sdk/postmark-cli/test/integration/templates.pull.test.ts:47-50,
+ * sdk/postmark-cli/src/commands/templates/pull.ts:142-151). The format is INFERRED.
+ */
+export declare function generatedAlias(state: State, template: Omit<Template, "Alias">): string;
+/** GET response, doc field order (refs/api_templates-api.md:457-468). */
+export declare const templateJson: (t: Template) => {
+    Name: string;
+    TemplateId: number;
+    Subject: string | null;
+    HtmlBody: string | null;
+    TextBody: string | null;
+    AssociatedServerId: number;
+    Active: boolean;
+    Alias: string;
+    TemplateType: "Layout" | "Standard";
+    LayoutTemplate: string | null;
+};
+/** List item (refs/api_templates-api.md:712-731). */
+export declare const templateListJson: (t: Template) => {
+    Active: boolean;
+    TemplateId: number;
+    Name: string;
+    Alias: string;
+    TemplateType: "Layout" | "Standard";
+    LayoutTemplate: string | null;
+};
+/**
+ * Create and edit response (refs/api_templates-api.md:565-585). The edit doc omits `TemplateType`;
+ * postmark-python requires it (sdk/postmark-python/postmark/models/templates/schemas.py:114).
+ */
+export declare const templateSummaryJson: (t: Template) => {
+    TemplateId: number;
+    Name: string;
+    Active: boolean;
+    Alias: string;
+    TemplateType: "Layout" | "Standard";
+    LayoutTemplate: string | null;
+};
+/** A nullable optional value: null is absent (docs/08 R9). */
+export declare const nullable: <S extends z.ZodType>(schema: S) => z.ZodPreprocess<z.ZodOptional<S>, unknown>;
+/** php sends `TemplateId: 0` beside an alias (docs/08 R10). */
+export declare const templateIdField: z.ZodPreprocess<z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>>, unknown>;
+/** php sends an empty model as `[]` (docs/08 R10). */
+export declare const templateModelField: z.ZodPreprocess<z.ZodOptional<z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodUnknown>, unknown>>, unknown>;
+/**
+ * The standard template and layout a send names. `TemplateId` wins over `TemplateAlias`
+ * (refs/api_templates-api.md:181-182). A layout or no reference is 1101 (INFERRED).
+ */
+export declare function sendTemplate(state: State, serverId: number, reference: {
+    TemplateId?: number | undefined;
+    TemplateAlias?: string | undefined;
+}): {
+    template: Template;
+    layout: Template | null;
+};

package/dist/src/api/templates/templates.js

@@ -0,0 +1,218 @@
+import { z } from "zod";
+import { apiError } from "../../errors.js";
+import { intLike, objectOrEmptyArray, parseBody } from "../../http/normalize.js";
+import { Unsupported } from "../../http/respond.js";
+import { parseTemplate } from "../../render/mustachio.js";
+// Templates API rules (docs/06 §3.1–§3.2). Messages marked INFERRED have no documented text.
+export const TEMPLATE_TYPES = ["Standard", "Layout"];
+export const CONTENT_PARTS = ["Subject", "HtmlBody", "TextBody"];
+/** ErrorCode 403 for a field of the wrong type, as in the send pipeline (docs/02 §9 Q13, INFERRED). */
+export const invalidField = (field) => apiError(403, { message: `Invalid request field(s): '${field}'.` });
+/** Parses a body with zod; a failure is 403 naming the first bad field. */
+export function parseOrReject(schema, body) {
+    if (typeof body !== "object" || body === null || Array.isArray(body)) {
+        throw new Unsupported("a send body that is not a JSON object is not captured");
+    }
+    const result = parseBody(schema, body);
+    if (!result.success)
+        throw invalidField(String(result.error.issues[0]?.path[0]));
+    return result.data;
+}
+/** `Standard` (default) or `Layout` (refs/api_templates-api.md:544); another value is 1122 (INFERRED text). */
+export function parseTemplateType(value) {
+    const type = TEMPLATE_TYPES.find((t) => t === (value ?? "Standard"));
+    if (type === undefined) {
+        throw apiError(1122, {
+            message: `Invalid 'TemplateType': '${value}'. Use Standard or Layout.`,
+        });
+    }
+    return type;
+}
+// refs/api_templates-api.md:466.
+const ALIAS = /^[A-Za-z][A-Za-z0-9._-]*$/;
+// refs/api_templates-api.md:6.
+const MAX_TEMPLATES = 100;
+/**
+ * The template a path or send names: digits are an ID (an alias starts with a letter), anything
+ * else an alias. An alias matches exactly, active templates first (INFERRED).
+ */
+export function findTemplate(state, serverId, idOrAlias) {
+    const own = [...state.templates.values()].filter((t) => t.ServerID === serverId);
+    if (/^\d+$/.test(idOrAlias))
+        return own.find((t) => t.TemplateId === Number(idOrAlias));
+    const matches = own.filter((t) => t.Alias === idOrAlias);
+    return matches.find((t) => t.Active) ?? matches[0];
+}
+/**
+ * 1101. The alias text is SDK-quoted (sdk/postmark-dotnet/src/Postmark.Tests/ClientTemplateTests.cs:248);
+ * the ID text follows it (INFERRED, docs/06 Q9).
+ */
+const notFoundField = (idOrAlias) => (/^\d+$/.test(idOrAlias) ? "TemplateId" : "Alias");
+export const templateNotFound = (idOrAlias) => apiError(1101, {
+    message: `The Template's '${notFoundField(idOrAlias)}' associated with this request is not valid or was not found.`,
+});
+export function activeTemplate(state, serverId, idOrAlias) {
+    const template = findTemplate(state, serverId, idOrAlias);
+    if (template?.Active !== true)
+        throw templateNotFound(idOrAlias);
+    return template;
+}
+/** An active layout by alias; a missing or standard one is 1101 (refs/api_overview.md:84). */
+export function activeLayout(state, serverId, alias) {
+    const layout = findTemplate(state, serverId, alias);
+    if (layout?.Active !== true || layout.TemplateType !== "Layout")
+        throw templateNotFound(alias);
+    return layout;
+}
+const layoutUsers = (state, layout) => [...state.templates.values()].filter((t) => t.Active && t.ServerID === layout.ServerID && t.LayoutTemplate === layout.Alias);
+/**
+ * The placeholder rule for one part: a layout body holds `{{{ @content }}}` exactly once
+ * (refs/api_templates-api.md:541-542); a standard template holds none (INFERRED).
+ */
+export function layoutRuleError(type, part, placeholders) {
+    if (type === "Layout" && part !== "Subject" && placeholders !== 1) {
+        return `The layout content placeholder must be present exactly once in the ${part}.`;
+    }
+    if ((type === "Standard" || part === "Subject") && placeholders > 0) {
+        return `The layout content placeholder is only allowed in the body of a layout template.`;
+    }
+    return undefined;
+}
+/**
+ * Checks a template as it will be stored, after create or edit. Error codes per docs/02 §4.4;
+ * every message is INFERRED except the 1131 prefix the postmark.js live test reads
+ * (sdk/postmark.js/test/integration/Templates.test.ts:122).
+ */
+export function checkTemplate(state, template) {
+    if (template.Name === "")
+        throw apiError(1120, { message: "The 'Name' field is required." });
+    if (template.HtmlBody === null && template.TextBody === null) {
+        throw apiError(1120, { message: "Either 'HtmlBody' or 'TextBody' must be specified." });
+    }
+    if (template.Alias !== null) {
+        if (!ALIAS.test(template.Alias)) {
+            throw apiError(1122, {
+                message: `The 'Alias' '${template.Alias}' is invalid. It must start with a letter and contain only letters, numbers, '.', '-' and '_'.`,
+            });
+        }
+        const other = findTemplate(state, template.ServerID, template.Alias);
+        if (other?.Active && other.TemplateId !== template.TemplateId) {
+            throw apiError(1122, { message: `The 'Alias' '${template.Alias}' is already in use.` });
+        }
+    }
+    if (template.TemplateType === "Layout") {
+        if (template.Subject !== null) {
+            throw apiError(1123, { message: "A layout template cannot have a 'Subject'." });
+        }
+        if (template.LayoutTemplate !== null) {
+            throw apiError(1123, { message: "A layout template cannot use a 'LayoutTemplate'." });
+        }
+    }
+    else {
+        if (template.Subject === null) {
+            throw apiError(1120, { message: "The 'Subject' field is required." });
+        }
+        if (template.LayoutTemplate !== null)
+            activeLayout(state, template.ServerID, template.LayoutTemplate);
+    }
+    for (const part of CONTENT_PARTS) {
+        const source = template[part];
+        if (source === null)
+            continue;
+        const parsed = parseTemplate(source);
+        if (!parsed.ok) {
+            throw apiError(1122, {
+                message: `The '${part}' content is invalid: ${parsed.errors[0]?.Message}`,
+            });
+        }
+        const placeholder = layoutRuleError(template.TemplateType, part, parsed.template.contentPlaceholders);
+        if (placeholder !== undefined)
+            throw apiError(1131, { message: placeholder });
+    }
+}
+export function checkCanCreate(state, serverId) {
+    const active = [...state.templates.values()].filter((t) => t.ServerID === serverId && t.Active);
+    if (active.length >= MAX_TEMPLATES)
+        throw apiError(1105);
+}
+/** A layout that templates use keeps its alias and cannot be deleted. */
+export function checkLayoutChange(state, before, after) {
+    if (before.TemplateType !== "Layout" || layoutUsers(state, before).length === 0)
+        return;
+    if (after === null)
+        throw apiError(1130);
+    if (after.Alias !== before.Alias) {
+        throw new Unsupported("renaming the alias of a layout in use is not captured");
+    }
+}
+/**
+ * A new template without an alias gets one. The dotnet and php live tests read a layout alias they
+ * never set (sdk/postmark-php/tests/PostmarkClientTemplatesTest.php:55-57). The postmark-cli pull
+ * test creates a standard template without an alias and expects every template pulled: pull stops
+ * at the first template without one (sdk/postmark-cli/test/integration/templates.pull.test.ts:47-50,
+ * sdk/postmark-cli/src/commands/templates/pull.ts:142-151). The format is INFERRED.
+ */
+export function generatedAlias(state, template) {
+    const prefix = `${template.TemplateType.toLowerCase()}-${template.TemplateId}`;
+    for (let n = 0;; n += 1) {
+        const alias = n === 0 ? prefix : `${prefix}-${n}`;
+        if (findTemplate(state, template.ServerID, alias)?.Active !== true)
+            return alias;
+    }
+}
+/** GET response, doc field order (refs/api_templates-api.md:457-468). */
+export const templateJson = (t) => ({
+    Name: t.Name,
+    TemplateId: t.TemplateId,
+    Subject: t.Subject,
+    HtmlBody: t.HtmlBody,
+    TextBody: t.TextBody,
+    AssociatedServerId: t.ServerID,
+    Active: t.Active,
+    Alias: t.Alias,
+    TemplateType: t.TemplateType,
+    LayoutTemplate: t.LayoutTemplate,
+});
+/** List item (refs/api_templates-api.md:712-731). */
+export const templateListJson = (t) => ({
+    Active: t.Active,
+    TemplateId: t.TemplateId,
+    Name: t.Name,
+    Alias: t.Alias,
+    TemplateType: t.TemplateType,
+    LayoutTemplate: t.LayoutTemplate,
+});
+/**
+ * Create and edit response (refs/api_templates-api.md:565-585). The edit doc omits `TemplateType`;
+ * postmark-python requires it (sdk/postmark-python/postmark/models/templates/schemas.py:114).
+ */
+export const templateSummaryJson = (t) => ({
+    TemplateId: t.TemplateId,
+    Name: t.Name,
+    Active: t.Active,
+    Alias: t.Alias,
+    TemplateType: t.TemplateType,
+    LayoutTemplate: t.LayoutTemplate,
+});
+/** A nullable optional value: null is absent (docs/08 R9). */
+export const nullable = (schema) => z.preprocess((v) => (v === null ? undefined : v), schema.optional());
+/** php sends `TemplateId: 0` beside an alias (docs/08 R10). */
+export const templateIdField = z.preprocess((v) => (v === 0 || v === null ? undefined : v), intLike.optional());
+/** php sends an empty model as `[]` (docs/08 R10). */
+export const templateModelField = nullable(objectOrEmptyArray(z.record(z.string(), z.unknown())));
+/**
+ * The standard template and layout a send names. `TemplateId` wins over `TemplateAlias`
+ * (refs/api_templates-api.md:181-182). A layout or no reference is 1101 (INFERRED).
+ */
+export function sendTemplate(state, serverId, reference) {
+    const idOrAlias = reference.TemplateId === undefined ? reference.TemplateAlias : String(reference.TemplateId);
+    if (idOrAlias === undefined)
+        throw templateNotFound("0");
+    const template = activeTemplate(state, serverId, idOrAlias);
+    if (template.TemplateType !== "Standard")
+        throw templateNotFound(idOrAlias);
+    const layout = template.LayoutTemplate === null
+        ? null
+        : activeLayout(state, serverId, template.LayoutTemplate);
+    return { template, layout };
+}

package/dist/src/api/templates/validate.d.ts

@@ -0,0 +1,15 @@
+import { type TemplateError } from "../../render/mustachio.ts";
+import type { State } from "../../state/store.ts";
+interface PartResult {
+    ContentIsValid: boolean;
+    ValidationErrors: TemplateError[];
+    RenderedContent: string | null;
+}
+export declare function validateTemplate(state: State, serverId: number, body: unknown): {
+    AllContentIsValid: boolean;
+    HtmlBody: PartResult | null;
+    TextBody: PartResult | null;
+    Subject: PartResult | null;
+    SuggestedTemplateModel: Record<string, unknown>;
+};
+export {};