@pilely/simple-email 0.4.3 → 0.5.0

package/dist/api.js

@@ -1,7 +1,12 @@
-// The simple_email service's 13 POST routes, one function each. This is the
-// internal layer the hooks in hooks.ts call; the package exports the hooks,
-// not these. app_id moves between the body and the path from route to
-// route on this service.
+// The simple_email service's page-side POST routes, one function each: the
+// template send and the owner's account and template management. This is
+// the layer the hooks in hooks.ts call; the package exports the hooks and
+// `sendTemplate`, not the rest. app_id is in the path on every route but
+// `accounts/create` (body) and `accounts/list` (none). Every function takes
+// `{ challenge }` — a bot-check answer, or a function asked once per
+// request — and every request it sends carries it. The freestyle send is
+// not here: only an app's backend may make it, so it lives in send.ts,
+// which needs no browser runtime.
 import { appId, call, collectPages, isMockMode, registerMockService } from "@pilely/core";
 import { createSimpleEmailFake } from "./mock.js";
 // Importing this package (its hooks import this module) is all an app does
@@ -25,65 +30,32 @@ function requireAppId() {
 }
 // ── Sending ──────────────────────────────────────────────────────────────
 /**
- * `app_id` is added from core's `appId()` — it is not a caller parameter.
- * Body size is capped on this route (like `createTemplate`/`updateTemplate`):
- * an oversize body is rejected by the server before any handler runs, so
- * the failure is not an `{ok:false}` envelope and the thrown `PilelyError`
- * carries a null `code`.
+ * The template send: `POST /accounts/{app_id}/templates/{template_id}/send`
+ * with the page's own app id. Sends that template, filled from `variables`,
+ * to the one recipient the owner stored on it — the caller can never point
+ * it anywhere else. `variables` is the body itself: each placeholder of the
+ * template's subject and html is read from the field of the same name, and
+ * every other field is ignored. A missing placeholder is a 400 and nothing
+ * is sent. The service admits the caller only when it is in the template's
+ * `send_group` and not in its `deny_group`; everyone else, an unknown
+ * template and an exhausted owner balance alike, gets the uniform 404.
  */
-export async function send(input) {
-    const app_id = requireAppId();
-    const idempotency_key = input.idempotency_key;
-    const body = input.to_account !== undefined
-        ? { app_id, to_account: input.to_account, template_id: input.template_id, variables: input.variables, idempotency_key }
-        : "template_id" in input
-            ? { app_id, to: input.to, template_id: input.template_id, variables: input.variables, idempotency_key }
-            : { app_id, to: input.to, subject: input.subject, html: input.html, idempotency_key };
-    return call({
-        service: "simple-email",
-        path: "/send",
-        body,
-    });
-}
-/** `app_id` lives in the body here, like `send` — not in the path. The
- *  paged primitive; use `listAllSends` to walk to the end. */
-export async function listSends(options = {}) {
+export async function sendTemplate(templateId, variables = {}, { challenge } = {}) {
     const json = await call({
         service: "simple-email",
-        path: "/sends/list",
-        body: {
-            app_id: requireAppId(),
-            limit: options.limit,
-            after_created_time_stamp: options.after_created_time_stamp,
-            after_send_id: options.after_send_id,
-        },
-    });
-    return { sends: json.sends, next_cursor: json.next_cursor };
-}
-export async function listAllSends() {
-    return collectPages(async (cursor) => {
-        const page = await listSends({ limit: 100, ...(cursor ?? {}) });
-        return { rows: page.sends, nextCursor: page.next_cursor };
+        path: `/accounts/${requireAppId()}/templates/${templateId}/send`,
+        body: variables,
+        challenge,
     });
+    return { send_id: json.send_id };
 }
 // ── Accounts ─────────────────────────────────────────────────────────────
-/** `sendGroup` is optional here — omit it (or pass `undefined`) and the
- *  key is left off the wire, meaning owner-only. `setAccountAccess` below
- *  is the opposite: its key is always required. `accountSenders` is
- *  optional too, and left off the wire when `undefined` (the server then
- *  uses `"send_group"`; it refuses an explicit `null` with a 400).
- *  `replyTo` is optional as well: `undefined` leaves the key off the wire,
- *  and omitted or `null` both mean no reply-to. */
-export async function createAccount(sendGroup, accountSenders, replyTo) {
-    const body = {
-        app_id: requireAppId(),
-    };
-    if (sendGroup !== undefined) {
-        body.send_group = sendGroup;
-    }
-    if (accountSenders !== undefined) {
-        body.account_senders = accountSenders;
-    }
+/** `replyTo` is optional: `undefined` leaves the key off the wire, and
+ *  omitted or `null` both mean no reply-to. The account carries no send
+ *  access of its own — who may send is each template's groups, and the
+ *  app's backend. */
+export async function createAccount(replyTo, { challenge } = {}) {
+    const body = { app_id: requireAppId() };
     if (replyTo !== undefined) {
         body.reply_to = replyTo;
     }
@@ -91,13 +63,14 @@ export async function createAccount(sendGroup, accountSenders, replyTo) {
         service: "simple-email",
         path: "/accounts/create",
         body,
+        challenge,
     });
     return json.account;
 }
 /** No `app_id` anywhere on this route — `after_app_id` is a cursor field,
  *  not a selector. The paged primitive; use `listAllAccounts` to walk to
  *  the end. */
-export async function listAccounts(options = {}) {
+export async function listAccounts(options = {}, { challenge } = {}) {
     const json = await call({
         service: "simple-email",
         path: "/accounts/list",
@@ -106,58 +79,44 @@ export async function listAccounts(options = {}) {
             after_created_time_stamp: options.after_created_time_stamp,
             after_app_id: options.after_app_id,
         },
+        challenge,
     });
     return { accounts: json.accounts, next_cursor: json.next_cursor };
 }
-export async function listAllAccounts() {
+export async function listAllAccounts(request = {}) {
     return collectPages(async (cursor) => {
-        const page = await listAccounts({ limit: 100, ...(cursor ?? {}) });
+        const page = await listAccounts({ limit: 100, ...(cursor ?? {}) }, request);
         return { rows: page.accounts, nextCursor: page.next_cursor };
     });
 }
 /** Returns the account plus its live operational state — the four extra
  *  fields are nullable siblings of `account`, not nested inside it. */
-export async function accountInfo() {
+export async function accountInfo({ challenge } = {}) {
     const json = await call({
         service: "simple-email",
         path: `/accounts/${requireAppId()}/info`,
+        challenge,
     });
     return {
         account: json.account,
         daily_cap: json.daily_cap,
         sent_today: json.sent_today,
         credit_blocked: json.credit_blocked,
-        phone_verified: json.phone_verified,
     };
 }
-export async function deleteAccount() {
-    await call({ service: "simple-email", path: `/accounts/${requireAppId()}/delete` });
-}
-/** `sendGroup` is REQUIRED here and its key is always sent, even `null` —
- *  the opposite of `createAccount`, where the key is optional. `null`
- *  means owner-only. `accountSenders` is optional: `undefined` leaves the
- *  key off the wire, which KEEPS the account's current value. */
-export async function setAccountAccess(sendGroup, accountSenders) {
-    const body = { send_group: sendGroup };
-    if (accountSenders !== undefined) {
-        body.account_senders = accountSenders;
-    }
-    const json = await call({
-        service: "simple-email",
-        path: `/accounts/${requireAppId()}/access/set`,
-        body,
-    });
-    return json.account;
+export async function deleteAccount({ challenge } = {}) {
+    await call({ service: "simple-email", path: `/accounts/${requireAppId()}/delete`, challenge });
 }
 /** `replyTo` is REQUIRED and its key is always sent, even `null` — the
  *  server refuses a missing key with a 400, so a typo can never silently
  *  clear it. An address sets where recipients' replies go (every send from
  *  the account carries it as its `Reply-To`); `null` clears it. */
-export async function setReplyTo(replyTo) {
+export async function setReplyTo(replyTo, { challenge } = {}) {
     const json = await call({
         service: "simple-email",
         path: `/accounts/${requireAppId()}/set_reply_to`,
         body: { reply_to: replyTo },
+        challenge,
     });
     return json.account;
 }
@@ -165,20 +124,21 @@ export async function setReplyTo(replyTo) {
 /** Returns metadata only — no `html`. Use `templateInfo` to read the body
  *  back.
  *
- *  `name` is nullable because the service accepts a nameless template. It
- *  stays a required POSITIONAL parameter — pass an explicit `null`, not
- *  nothing — and `TemplateMeta.name` then comes back `null`. */
-export async function createTemplate(name, subject, html) {
+ *  `name` is nullable because the service accepts a nameless template: pass
+ *  an explicit `null`, and `TemplateMeta.name` comes back `null`. An
+ *  omitted group is left off the wire (an empty group). */
+export async function createTemplate(body, { challenge } = {}) {
     const json = await call({
         service: "simple-email",
         path: `/accounts/${requireAppId()}/templates/create`,
-        body: { name, subject, html },
+        body,
+        challenge,
     });
     return json.template;
 }
 /** The paged primitive; use `listAllTemplates` to walk to the end. Rows
  *  carry metadata only — no `html`. */
-export async function listTemplates(options = {}) {
+export async function listTemplates(options = {}, { challenge } = {}) {
     const json = await call({
         service: "simple-email",
         path: `/accounts/${requireAppId()}/templates/list`,
@@ -187,39 +147,45 @@ export async function listTemplates(options = {}) {
             after_created_time_stamp: options.after_created_time_stamp,
             after_template_id: options.after_template_id,
         },
+        challenge,
     });
     return { templates: json.templates, next_cursor: json.next_cursor };
 }
-export async function listAllTemplates() {
+export async function listAllTemplates(request = {}) {
     return collectPages(async (cursor) => {
-        const page = await listTemplates({ limit: 100, ...(cursor ?? {}) });
+        const page = await listTemplates({ limit: 100, ...(cursor ?? {}) }, request);
         return { rows: page.templates, nextCursor: page.next_cursor };
     });
 }
 /** The only template route whose answer carries `html`. */
-export async function templateInfo(templateNanoid) {
+export async function templateInfo(templateNanoid, { challenge } = {}) {
     const json = await call({
         service: "simple-email",
         path: `/accounts/${requireAppId()}/templates/${templateNanoid}/info`,
+        challenge,
     });
     return json.template;
 }
 /**
- * A FULL REPLACE of both `subject` and `html` — never a patch — and `name`
- * is not updatable at all. Returns metadata only, like `createTemplate`.
- * Subject to the same oversize-body caveat as `send`/`createTemplate`.
+ * A FULL REPLACE of both `subject` and `html`; `recipient`, `send_group` and
+ * `deny_group` change only when their key is sent. `name` is not updatable
+ * at all. Returns metadata only, like `createTemplate`. An oversize body is
+ * rejected by the server before any handler runs, so the thrown
+ * `PilelyError` carries a null `code`.
  */
-export async function updateTemplate(templateNanoid, body) {
+export async function updateTemplate(templateNanoid, body, { challenge } = {}) {
     const json = await call({
         service: "simple-email",
         path: `/accounts/${requireAppId()}/templates/${templateNanoid}/update`,
         body,
+        challenge,
     });
     return json.template;
 }
-export async function deleteTemplate(templateNanoid) {
+export async function deleteTemplate(templateNanoid, { challenge } = {}) {
     await call({
         service: "simple-email",
         path: `/accounts/${requireAppId()}/templates/${templateNanoid}/delete`,
+        challenge,
     });
 }

package/dist/hooks.d.ts

@@ -1,65 +1,73 @@
+import type { ChallengeOption } from "@pilely/core";
 import type { UseInfiniteQueryResult, UseMutationResult, UseQueryResult } from "@tanstack/react-query";
-import type { SendInput, SendResult } from "./api.js";
-import type { Account, AccountInfoEnvelope, AccountSenders, SendRow, Template, TemplateMeta } from "./types.js";
-export interface PageOptions {
+import type { TemplateSendResult } from "./api.js";
+import type { Account, AccountInfoEnvelope, Template, TemplateMeta } from "./types.js";
+export interface PageOptions extends ChallengeOption {
     /** Rows per page; the server defaults to 50 and caps at 100. */
     limit?: number;
 }
+/** `recipient` is required: the ONE address the template's sends go to.
+ *  An omitted (or `null`) group is empty: an empty `send_group` admits
+ *  nobody, an empty `deny_group` refuses nobody. */
 export interface CreateTemplateInput {
     /** `null` for a nameless template. */
     name: string | null;
     subject: string;
     html: string;
+    recipient: string;
+    /** An owner group, or the platform-wide anonymous or authenticated group. */
+    send_group?: string | null;
+    /** An owner group only. */
+    deny_group?: string | null;
 }
-/** `useCreateEmailAccount`'s object form. Every key is optional: an omitted
- *  `send_group` means owner-only, an omitted `account_senders` means
- *  `"send_group"`, and an omitted (or `null`) `reply_to` means no reply-to. */
+/** `useCreateEmailAccount`'s object form. An omitted (or `null`) `reply_to`
+ *  means no reply-to. */
 export interface CreateEmailAccountInput {
-    send_group?: string | null;
-    account_senders?: AccountSenders;
     /** The address recipients' replies go to. */
     reply_to?: string | null;
 }
-/** `useSetEmailAccountAccess`'s object form. `send_group` is required (`null`
- *  = owner-only); an omitted `account_senders` keeps the current value. */
-export interface SetEmailAccountAccessInput {
-    send_group: string | null;
-    account_senders?: AccountSenders;
-}
-/** A full replace of both `subject` and `html`; `name` is not updatable. */
+/** A full replace of both `subject` and `html`; `name` is not updatable. An
+ *  omitted `recipient`, `send_group` or `deny_group` keeps the stored value;
+ *  `null` empties a group. */
 export interface UpdateTemplateInput {
     templateId: string;
     subject: string;
     html: string;
+    recipient?: string;
+    send_group?: string | null;
+    deny_group?: string | null;
+}
+/** `useSendTemplate`'s variables: the template and its placeholder values. */
+export interface SendTemplateInput {
+    templateId: string;
+    /** One string per placeholder of the template's subject and html; omitted
+     *  is `{}`, for a template without placeholders. */
+    variables?: Record<string, string>;
 }
-/** Sends one email from this app's account: a raw send (`to`) or an account
- *  send (`to_account: "self" | "owner"`). Not optimistic: a send counts only
- *  once the server accepted it. A repeat carrying the same `idempotency_key`
- *  answers the first send with `replayed: true`. */
-export declare function useSend(): UseMutationResult<SendResult, Error, SendInput>;
-/** This app's outbox, newest first, as an infinite query. */
-export declare function useSends(options?: PageOptions): UseInfiniteQueryResult<SendRow[], Error>;
+/** The template send, from a page: the template, filled from `variables`,
+ *  to the one recipient its owner stored on it. Not optimistic: a send
+ *  counts only once the server accepted it. The answer is `{ send_id }`,
+ *  never the address. It counts toward the app's daily send cap, so it
+ *  refreshes `useEmailAccount()`. */
+export declare function useSendTemplate(options?: ChallengeOption): UseMutationResult<TemplateSendResult, Error, SendTemplateInput>;
 /** The caller's email accounts across apps, as an infinite query. */
 export declare function useEmailAccounts(options?: PageOptions): UseInfiniteQueryResult<Account[], Error>;
-/** This app's account with its live state: daily cap, sent today, credit
- *  and phone verification. */
-export declare function useEmailAccount(): UseQueryResult<AccountInfoEnvelope, Error>;
-/** Creates this app's account; the variable is its optional send group
- *  (`null` or omitted: owner-only), or `{ send_group?, account_senders?, reply_to? }`. */
-export declare function useCreateEmailAccount(): UseMutationResult<Account, Error, string | null | void | CreateEmailAccountInput>;
+/** This app's account with its live state: daily cap, sent today and
+ *  credit. */
+export declare function useEmailAccount(options?: ChallengeOption): UseQueryResult<AccountInfoEnvelope, Error>;
+/** Creates this app's account; the variable is optional, or
+ *  `{ reply_to? }`. */
+export declare function useCreateEmailAccount(options?: ChallengeOption): UseMutationResult<Account, Error, void | CreateEmailAccountInput>;
 /** Deletes this app's account and the templates under it. */
-export declare function useDeleteEmailAccount(): UseMutationResult<void, Error, void>;
-/** Replaces this app's send group (`null` means owner-only); the object form
- *  `{ send_group, account_senders? }` also sets who may make account sends. */
-export declare function useSetEmailAccountAccess(): UseMutationResult<Account, Error, string | null | SetEmailAccountAccessInput>;
+export declare function useDeleteEmailAccount(options?: ChallengeOption): UseMutationResult<void, Error, void>;
 /** Sets this app's reply-to address — where recipients' replies go; every
  *  send from the account carries it as its `Reply-To` — or clears it with
  *  `null`. The variable is required: there is no "keep" form. */
-export declare function useSetEmailReplyTo(): UseMutationResult<Account, Error, string | null>;
+export declare function useSetEmailReplyTo(options?: ChallengeOption): UseMutationResult<Account, Error, string | null>;
 /** This app's templates (metadata only), as an infinite query. */
 export declare function useTemplates(options?: PageOptions): UseInfiniteQueryResult<TemplateMeta[], Error>;
 /** One template with its `html`. An `undefined` id disables the query. */
-export declare function useTemplate(templateId: string | undefined): UseQueryResult<Template, Error>;
-export declare function useCreateTemplate(): UseMutationResult<TemplateMeta, Error, CreateTemplateInput>;
-export declare function useUpdateTemplate(): UseMutationResult<TemplateMeta, Error, UpdateTemplateInput>;
-export declare function useDeleteTemplate(): UseMutationResult<void, Error, string>;
+export declare function useTemplate(templateId: string | undefined, options?: ChallengeOption): UseQueryResult<Template, Error>;
+export declare function useCreateTemplate(options?: ChallengeOption): UseMutationResult<TemplateMeta, Error, CreateTemplateInput>;
+export declare function useUpdateTemplate(options?: ChallengeOption): UseMutationResult<TemplateMeta, Error, UpdateTemplateInput>;
+export declare function useDeleteTemplate(options?: ChallengeOption): UseMutationResult<void, Error, string>;

package/dist/hooks.js

@@ -1,7 +1,5 @@
 import { serviceQueryKey, useServiceInfiniteQuery, useServiceMutation, useServiceQuery } from "@pilely/core";
-import { accountInfo, createAccount, createTemplate, deleteAccount, deleteTemplate, listAccounts, listSends, listTemplates, send, setAccountAccess, setReplyTo, templateInfo, updateTemplate, } from "./api.js";
-/** `["pilely", "simple-email", "sends", options]` */
-const sendsKey = () => serviceQueryKey("simple-email", "sends");
+import { accountInfo, createAccount, createTemplate, deleteAccount, deleteTemplate, listAccounts, listTemplates, sendTemplate, setReplyTo, templateInfo, updateTemplate, } from "./api.js";
 /** `["pilely", "simple-email", "accounts", options]` */
 const accountsKey = () => serviceQueryKey("simple-email", "accounts");
 /** `["pilely", "simple-email", "account"]` — this app's account info. */
@@ -11,115 +9,105 @@ const templatesKey = () => serviceQueryKey("simple-email", "templates");
 /** `["pilely", "simple-email", "template", templateId]` */
 const templateKey = (templateId) => serviceQueryKey("simple-email", "template", templateId);
 // ── Sending ──────────────────────────────────────────────────────────────
-/** Sends one email from this app's account: a raw send (`to`) or an account
- *  send (`to_account: "self" | "owner"`). Not optimistic: a send counts only
- *  once the server accepted it. A repeat carrying the same `idempotency_key`
- *  answers the first send with `replayed: true`. */
-export function useSend() {
-    return useServiceMutation("useSend", {
-        mutationFn: send,
-        invalidates: () => [sendsKey()],
-    });
-}
-/** This app's outbox, newest first, as an infinite query. */
-export function useSends(options = {}) {
-    const { limit } = options;
-    return useServiceInfiniteQuery("useSends", {
-        queryKey: [...sendsKey(), { limit }],
-        fetchPage: async (cursor) => {
-            const page = await listSends({ limit, ...(cursor ?? {}) });
-            return { rows: page.sends, nextCursor: page.next_cursor };
-        },
+/** The template send, from a page: the template, filled from `variables`,
+ *  to the one recipient its owner stored on it. Not optimistic: a send
+ *  counts only once the server accepted it. The answer is `{ send_id }`,
+ *  never the address. It counts toward the app's daily send cap, so it
+ *  refreshes `useEmailAccount()`. */
+export function useSendTemplate(options = {}) {
+    const { challenge } = options;
+    return useServiceMutation("useSendTemplate", {
+        mutationFn: ({ templateId, variables }) => sendTemplate(templateId, variables, { challenge }),
+        invalidates: () => [accountKey()],
     });
 }
 // ── Accounts ─────────────────────────────────────────────────────────────
 /** The caller's email accounts across apps, as an infinite query. */
 export function useEmailAccounts(options = {}) {
-    const { limit } = options;
+    const { limit, challenge } = options;
     return useServiceInfiniteQuery("useEmailAccounts", {
         queryKey: [...accountsKey(), { limit }],
         fetchPage: async (cursor) => {
-            const page = await listAccounts({ limit, ...(cursor ?? {}) });
+            const page = await listAccounts({ limit, ...(cursor ?? {}) }, { challenge });
             return { rows: page.accounts, nextCursor: page.next_cursor };
         },
     });
 }
-/** This app's account with its live state: daily cap, sent today, credit
- *  and phone verification. */
-export function useEmailAccount() {
-    return useServiceQuery("useEmailAccount", { queryKey: accountKey(), queryFn: accountInfo });
+/** This app's account with its live state: daily cap, sent today and
+ *  credit. */
+export function useEmailAccount(options = {}) {
+    const { challenge } = options;
+    return useServiceQuery("useEmailAccount", {
+        queryKey: accountKey(),
+        queryFn: () => accountInfo({ challenge }),
+    });
 }
-/** Creates this app's account; the variable is its optional send group
- *  (`null` or omitted: owner-only), or `{ send_group?, account_senders?, reply_to? }`. */
-export function useCreateEmailAccount() {
+/** Creates this app's account; the variable is optional, or
+ *  `{ reply_to? }`. */
+export function useCreateEmailAccount(options = {}) {
+    const { challenge } = options;
     return useServiceMutation("useCreateEmailAccount", {
-        mutationFn: (input) => typeof input === "object" && input !== null
-            ? createAccount(input.send_group, input.account_senders, input.reply_to)
-            : createAccount(input ?? undefined),
+        mutationFn: (input) => createAccount(input ? input.reply_to : undefined, { challenge }),
         invalidates: () => [accountsKey(), accountKey()],
     });
 }
 /** Deletes this app's account and the templates under it. */
-export function useDeleteEmailAccount() {
+export function useDeleteEmailAccount(options = {}) {
+    const { challenge } = options;
     return useServiceMutation("useDeleteEmailAccount", {
-        mutationFn: () => deleteAccount(),
+        mutationFn: () => deleteAccount({ challenge }),
         invalidates: () => [accountsKey(), accountKey(), templatesKey(), serviceQueryKey("simple-email", "template")],
     });
 }
-/** Replaces this app's send group (`null` means owner-only); the object form
- *  `{ send_group, account_senders? }` also sets who may make account sends. */
-export function useSetEmailAccountAccess() {
-    return useServiceMutation("useSetEmailAccountAccess", {
-        mutationFn: (input) => typeof input === "object" && input !== null
-            ? setAccountAccess(input.send_group, input.account_senders)
-            : setAccountAccess(input),
-        invalidates: () => [accountsKey(), accountKey()],
-    });
-}
 /** Sets this app's reply-to address — where recipients' replies go; every
  *  send from the account carries it as its `Reply-To` — or clears it with
  *  `null`. The variable is required: there is no "keep" form. */
-export function useSetEmailReplyTo() {
+export function useSetEmailReplyTo(options = {}) {
+    const { challenge } = options;
     return useServiceMutation("useSetEmailReplyTo", {
-        mutationFn: (replyTo) => setReplyTo(replyTo),
+        mutationFn: (replyTo) => setReplyTo(replyTo, { challenge }),
         invalidates: () => [accountsKey(), accountKey()],
     });
 }
 // ── Templates ────────────────────────────────────────────────────────────
 /** This app's templates (metadata only), as an infinite query. */
 export function useTemplates(options = {}) {
-    const { limit } = options;
+    const { limit, challenge } = options;
     return useServiceInfiniteQuery("useTemplates", {
         queryKey: [...templatesKey(), { limit }],
         fetchPage: async (cursor) => {
-            const page = await listTemplates({ limit, ...(cursor ?? {}) });
+            const page = await listTemplates({ limit, ...(cursor ?? {}) }, { challenge });
             return { rows: page.templates, nextCursor: page.next_cursor };
         },
     });
 }
 /** One template with its `html`. An `undefined` id disables the query. */
-export function useTemplate(templateId) {
+export function useTemplate(templateId, options = {}) {
+    const { challenge } = options;
     return useServiceQuery("useTemplate", {
         queryKey: templateKey(templateId),
-        queryFn: () => templateInfo(templateId),
+        queryFn: () => templateInfo(templateId, { challenge }),
         enabled: templateId !== undefined,
     });
 }
-export function useCreateTemplate() {
+export function useCreateTemplate(options = {}) {
+    const { challenge } = options;
     return useServiceMutation("useCreateTemplate", {
-        mutationFn: ({ name, subject, html }) => createTemplate(name, subject, html),
+        mutationFn: (input) => createTemplate(input, { challenge }),
         invalidates: () => [templatesKey()],
     });
 }
-export function useUpdateTemplate() {
+export function useUpdateTemplate(options = {}) {
+    const { challenge } = options;
     return useServiceMutation("useUpdateTemplate", {
-        mutationFn: ({ templateId, subject, html }) => updateTemplate(templateId, { subject, html }),
+        mutationFn: ({ templateId, ...body }) => updateTemplate(templateId, body, { challenge }),
         invalidates: (_template, { templateId }) => [templatesKey(), templateKey(templateId)],
     });
 }
-export function useDeleteTemplate() {
+export function useDeleteTemplate(options = {}) {
+    const { challenge } = options;
     return useServiceMutation("useDeleteTemplate", {
-        mutationFn: deleteTemplate,
+        mutationFn: (templateId) => deleteTemplate(templateId, { challenge }),
         invalidates: (_none, templateId) => [templatesKey(), templateKey(templateId)],
     });
 }

package/dist/index.d.ts

@@ -1,4 +1,7 @@
-export { useCreateEmailAccount, useCreateTemplate, useDeleteEmailAccount, useDeleteTemplate, useEmailAccount, useEmailAccounts, useSend, useSends, useSetEmailAccountAccess, useSetEmailReplyTo, useTemplate, useTemplates, useUpdateTemplate, } from "./hooks.js";
-export type { CreateEmailAccountInput, CreateTemplateInput, PageOptions, SetEmailAccountAccessInput, UpdateTemplateInput, } from "./hooks.js";
-export type { AccountSendInput, RawSendInput, SendContent, SendInput, SendKey, SendResult } from "./api.js";
-export type { Account, AccountSenders, SimpleEmailErrorCode, AccountCursor, AccountInfoEnvelope, SendCursor, SendRow, Template, TemplateCursor, TemplateMeta, ToAccount, } from "./types.js";
+export { useCreateEmailAccount, useCreateTemplate, useDeleteEmailAccount, useDeleteTemplate, useEmailAccount, useEmailAccounts, useSendTemplate, useSetEmailReplyTo, useTemplate, useTemplates, useUpdateTemplate, } from "./hooks.js";
+export type { CreateEmailAccountInput, CreateTemplateInput, PageOptions, SendTemplateInput, UpdateTemplateInput, } from "./hooks.js";
+export { sendTemplate } from "./api.js";
+export type { TemplateSendResult } from "./api.js";
+export { SIMPLE_EMAIL_ORIGIN, SendError, send } from "./send.js";
+export type { SendContent, SendInput, SendKey, SendOptions, SendResult } from "./send.js";
+export type { Account, SimpleEmailErrorCode, AccountCursor, AccountInfoEnvelope, Template, TemplateCursor, TemplateMeta, } from "./types.js";

package/dist/index.js

@@ -1,4 +1,9 @@
 // @pilely/simple-email — React hooks over the simple_email service: a query
 // hook for every read, a mutation hook for every write. Render them inside
-// @pilely/core's <PilelyProvider>.
-export { useCreateEmailAccount, useCreateTemplate, useDeleteEmailAccount, useDeleteTemplate, useEmailAccount, useEmailAccounts, useSend, useSends, useSetEmailAccountAccess, useSetEmailReplyTo, useTemplate, useTemplates, useUpdateTemplate, } from "./hooks.js";
+// @pilely/core's <PilelyProvider>. `sendTemplate` is the template send a
+// page makes, as a plain function. `send` is the freestyle send for an
+// app's backend only; a server imports it from `@pilely/simple-email/send`,
+// which loads none of this entry's peers.
+export { useCreateEmailAccount, useCreateTemplate, useDeleteEmailAccount, useDeleteTemplate, useEmailAccount, useEmailAccounts, useSendTemplate, useSetEmailReplyTo, useTemplate, useTemplates, useUpdateTemplate, } from "./hooks.js";
+export { sendTemplate } from "./api.js";
+export { SIMPLE_EMAIL_ORIGIN, SendError, send } from "./send.js";

package/dist/mock.d.ts

@@ -1,2 +1,9 @@
 import type { MockServiceFactory } from "@pilely/core";
+/** The fake's ids for the two platform-wide groups: fixed test values, not
+ *  the production ids. `@pilely/simple-group`'s fake answers the same two
+ *  from `groups/anonymous` and `groups/authenticated`, so in mock mode an id
+ *  read from `anonymousGroupId()` / `authenticatedGroupId()` works as a
+ *  template's `send_group` here. Not part of the package's public surface. */
+export declare const MOCK_ANON_GROUP = "mockAnonymousGroup0001";
+export declare const MOCK_AUTH_GROUP = "mockAuthenticatedGrp01";
 export declare const createSimpleEmailFake: MockServiceFactory;