@pilely/simple-email 0.4.5 → 0.5.0

package/dist/hooks.d.ts

@@ -1,58 +1,65 @@
 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";
+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(options?: ChallengeOption): 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 and
  *  credit. */
 export declare function useEmailAccount(options?: ChallengeOption): 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(options?: ChallengeOption): UseMutationResult<Account, Error, string | null | void | CreateEmailAccountInput>;
+/** 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(options?: ChallengeOption): 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(options?: ChallengeOption): UseMutationResult<Account, Error, string | null | SetEmailAccountAccessInput>;
 /** 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. */

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,26 +9,16 @@ 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(options = {}) {
+/** 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("useSend", {
-        mutationFn: (input) => send(input, { challenge }),
-        invalidates: () => [sendsKey()],
-    });
-}
-/** This app's outbox, newest first, as an infinite query. */
-export function useSends(options = {}) {
-    const { limit, challenge } = options;
-    return useServiceInfiniteQuery("useSends", {
-        queryKey: [...sendsKey(), { limit }],
-        fetchPage: async (cursor) => {
-            const page = await listSends({ limit, ...(cursor ?? {}) }, { challenge });
-            return { rows: page.sends, nextCursor: page.next_cursor };
-        },
+    return useServiceMutation("useSendTemplate", {
+        mutationFn: ({ templateId, variables }) => sendTemplate(templateId, variables, { challenge }),
+        invalidates: () => [accountKey()],
     });
 }
 // ── Accounts ─────────────────────────────────────────────────────────────
@@ -54,14 +42,12 @@ export function useEmailAccount(options = {}) {
         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? }`. */
+/** 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, { challenge })
-            : createAccount(input ?? undefined, undefined, undefined, { challenge }),
+        mutationFn: (input) => createAccount(input ? input.reply_to : undefined, { challenge }),
         invalidates: () => [accountsKey(), accountKey()],
     });
 }
@@ -73,17 +59,6 @@ export function useDeleteEmailAccount(options = {}) {
         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(options = {}) {
-    const { challenge } = options;
-    return useServiceMutation("useSetEmailAccountAccess", {
-        mutationFn: (input) => typeof input === "object" && input !== null
-            ? setAccountAccess(input.send_group, input.account_senders, { challenge })
-            : setAccountAccess(input, undefined, { challenge }),
-        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. */
@@ -118,14 +93,14 @@ export function useTemplate(templateId, options = {}) {
 export function useCreateTemplate(options = {}) {
     const { challenge } = options;
     return useServiceMutation("useCreateTemplate", {
-        mutationFn: ({ name, subject, html }) => createTemplate(name, subject, html, { challenge }),
+        mutationFn: (input) => createTemplate(input, { challenge }),
         invalidates: () => [templatesKey()],
     });
 }
 export function useUpdateTemplate(options = {}) {
     const { challenge } = options;
     return useServiceMutation("useUpdateTemplate", {
-        mutationFn: ({ templateId, subject, html }) => updateTemplate(templateId, { subject, html }, { challenge }),
+        mutationFn: ({ templateId, ...body }) => updateTemplate(templateId, body, { challenge }),
         invalidates: (_template, { 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;