@serve.zone/dcrouter 16.4.1 → 16.5.0

package/ts_web/appstate/email-domains.ts

@@ -8,10 +8,26 @@ import { getActionContext } from './login.js';
 // Email Domains State
 // ============================================================================
 
+export type TEmailDomainOperationName =
+  | 'create'
+  | 'update'
+  | 'delete'
+  | 'validate'
+  | 'provision'
+  | 'reconcile'
+  | 'rotate';
+
+export interface IEmailDomainOperationState extends interfaces.requests.IEmailDomainActionResult {
+  operation: TEmailDomainOperationName;
+  completedAt: number;
+}
+
 export interface IEmailDomainsState {
   domains: interfaces.data.IEmailDomain[];
   settings: interfaces.data.IEmailServerSettings | null;
   isLoading: boolean;
+  error: string | null;
+  lastOperation: IEmailDomainOperationState | null;
   lastUpdated: number;
 }
 
@@ -21,11 +37,84 @@ export const emailDomainsStatePart = await appState.getStatePart<IEmailDomainsSt
     domains: [],
     settings: null,
     isLoading: false,
+    error: null,
+    lastOperation: null,
     lastUpdated: 0,
   },
   'soft',
 );
 
+const createOperationState = (
+  operationArg: TEmailDomainOperationName,
+  responseArg: interfaces.requests.IEmailDomainActionResult,
+): IEmailDomainOperationState => ({
+  operation: operationArg,
+  completedAt: Date.now(),
+  ...responseArg,
+});
+
+const createFailedOperationState = (
+  operationArg: TEmailDomainOperationName,
+  errorArg: unknown,
+  fallbackMessageArg: string,
+): IEmailDomainOperationState => ({
+  operation: operationArg,
+  completedAt: Date.now(),
+  success: false,
+  message: errorArg instanceof Error ? errorArg.message : fallbackMessageArg,
+  code: 'EMAIL_DOMAIN_REQUEST_FAILED',
+  errors: [
+    {
+      code: 'EMAIL_DOMAIN_REQUEST_FAILED',
+      message: errorArg instanceof Error ? errorArg.message : fallbackMessageArg,
+      retryable: true,
+    },
+  ],
+});
+
+export const formatEmailDomainOperationMessage = (
+  operationArg: IEmailDomainOperationState,
+  fallbackMessageArg: string,
+): string => {
+  const primaryMessage = operationArg.message || fallbackMessageArg;
+  const messageParts = [
+    operationArg.code ? `${primaryMessage} [${operationArg.code}]` : primaryMessage,
+  ];
+  for (const error of operationArg.errors || []) {
+    const location = error.recordKey ? `${error.recordKey}: ` : '';
+    const detail = `${location}${error.message} [${error.code}]`;
+    const duplicatesPrimary =
+      !error.recordKey &&
+      error.message === primaryMessage &&
+      error.code === operationArg.code;
+    if (!duplicatesPrimary && !messageParts.includes(detail)) {
+      messageParts.push(detail);
+    }
+  }
+  if (operationArg.lifecycleStatus && operationArg.lifecycleStatus !== 'active') {
+    messageParts.push(`Lifecycle: ${operationArg.lifecycleStatus}`);
+  }
+  if (operationArg.capability === 'unsupported' && !messageParts.some((part) => part.includes('unsupported'))) {
+    messageParts.push('Required capability is unsupported');
+  }
+  if (operationArg.retryAt) {
+    messageParts.push(`Retry scheduled for ${operationArg.retryAt}`);
+  }
+  return messageParts.join(' — ');
+};
+
+const applyOperationState = (
+  stateArg: IEmailDomainsState,
+  operationArg: IEmailDomainOperationState,
+  fallbackMessageArg: string,
+): IEmailDomainsState => ({
+  ...stateArg,
+  error: operationArg.success
+    ? null
+    : formatEmailDomainOperationMessage(operationArg, fallbackMessageArg),
+  lastOperation: operationArg,
+});
+
 export const fetchEmailDomainsAction = emailDomainsStatePart.createAction(
   async (statePartArg): Promise<IEmailDomainsState> => {
     const context = getActionContext();
@@ -46,10 +135,15 @@ export const fetchEmailDomainsAction = emailDomainsStatePart.createAction(
         domains: response.domains,
         settings: settingsResponse.settings,
         isLoading: false,
+        error: null,
         lastUpdated: Date.now(),
       };
-    } catch {
-      return { ...currentState, isLoading: false };
+    } catch (error: unknown) {
+      return {
+        ...currentState,
+        isLoading: false,
+        error: error instanceof Error ? error.message : 'Failed to fetch email domains',
+      };
     }
   },
 );
@@ -61,17 +155,62 @@ export const createEmailDomainAction = emailDomainsStatePart.createAction<{
   dkimKeySize?: number;
   rotateKeys?: boolean;
   rotationIntervalDays?: number;
+  remoteIngress?: interfaces.data.IEmailDomainRemoteIngress;
 }>(async (statePartArg, args, actionContext) => {
   const context = getActionContext();
   const currentState = statePartArg.getState()!;
+  if (!context.identity) {
+    const operation = createFailedOperationState('create', new Error('Not authenticated'), 'Not authenticated');
+    return applyOperationState(currentState, operation, 'Failed to create email domain');
+  }
   try {
     const request = new plugins.domtools.plugins.typedrequest.TypedRequest<
       interfaces.requests.IReq_CreateEmailDomain
     >('/typedrequest', 'createEmailDomain');
-    await request.fire({ identity: context.identity!, ...args });
-    return await actionContext!.dispatch(fetchEmailDomainsAction, null);
-  } catch {
-    return currentState;
+    const response = await request.fire({ identity: context.identity, ...args });
+    const operation = createOperationState('create', response);
+    if (!response.success) {
+      return applyOperationState(currentState, operation, 'Failed to create email domain');
+    }
+    const refreshedState = await actionContext!.dispatch(fetchEmailDomainsAction, null);
+    return applyOperationState(refreshedState, operation, 'Email domain created');
+  } catch (error: unknown) {
+    const operation = createFailedOperationState('create', error, 'Failed to create email domain');
+    return applyOperationState(currentState, operation, 'Failed to create email domain');
+  }
+});
+
+export const updateEmailDomainAction = emailDomainsStatePart.createAction<{
+  id: string;
+  rotateKeys?: boolean;
+  rotationIntervalDays?: number;
+  rateLimits?: interfaces.data.IEmailDomain['rateLimits'];
+  remoteIngress?: interfaces.data.IEmailDomainRemoteIngress | null;
+}>(async (statePartArg, args, actionContext) => {
+  const context = getActionContext();
+  const currentState = statePartArg.getState()!;
+  if (!context.identity) {
+    const operation = createFailedOperationState(
+      'update',
+      new Error('Not authenticated'),
+      'Not authenticated',
+    );
+    return applyOperationState(currentState, operation, 'Failed to update email domain');
+  }
+  try {
+    const request = new plugins.domtools.plugins.typedrequest.TypedRequest<
+      interfaces.requests.IReq_UpdateEmailDomain
+    >('/typedrequest', 'updateEmailDomain');
+    const response = await request.fire({ identity: context.identity, ...args });
+    const operation = createOperationState('update', response);
+    if (!response.success) {
+      return applyOperationState(currentState, operation, 'Failed to update email domain');
+    }
+    const refreshedState = await actionContext!.dispatch(fetchEmailDomainsAction, null);
+    return applyOperationState(refreshedState, operation, 'Email domain updated');
+  } catch (error: unknown) {
+    const operation = createFailedOperationState('update', error, 'Failed to update email domain');
+    return applyOperationState(currentState, operation, 'Failed to update email domain');
   }
 });
 
@@ -98,14 +237,24 @@ export const deleteEmailDomainAction = emailDomainsStatePart.createAction<string
   async (statePartArg, id, actionContext) => {
     const context = getActionContext();
     const currentState = statePartArg.getState()!;
+    if (!context.identity) {
+      const operation = createFailedOperationState('delete', new Error('Not authenticated'), 'Not authenticated');
+      return applyOperationState(currentState, operation, 'Failed to delete email domain');
+    }
     try {
       const request = new plugins.domtools.plugins.typedrequest.TypedRequest<
         interfaces.requests.IReq_DeleteEmailDomain
       >('/typedrequest', 'deleteEmailDomain');
-      await request.fire({ identity: context.identity!, id });
-      return await actionContext!.dispatch(fetchEmailDomainsAction, null);
-    } catch {
-      return currentState;
+      const response = await request.fire({ identity: context.identity, id });
+      const operation = createOperationState('delete', response);
+      if (!response.success) {
+        return applyOperationState(currentState, operation, 'Failed to delete email domain');
+      }
+      const refreshedState = await actionContext!.dispatch(fetchEmailDomainsAction, null);
+      return applyOperationState(refreshedState, operation, 'Email domain deleted');
+    } catch (error: unknown) {
+      const operation = createFailedOperationState('delete', error, 'Failed to delete email domain');
+      return applyOperationState(currentState, operation, 'Failed to delete email domain');
     }
   },
 );
@@ -114,14 +263,24 @@ export const validateEmailDomainAction = emailDomainsStatePart.createAction<stri
   async (statePartArg, id, actionContext) => {
     const context = getActionContext();
     const currentState = statePartArg.getState()!;
+    if (!context.identity) {
+      const operation = createFailedOperationState('validate', new Error('Not authenticated'), 'Not authenticated');
+      return applyOperationState(currentState, operation, 'Failed to validate email domain DNS');
+    }
     try {
       const request = new plugins.domtools.plugins.typedrequest.TypedRequest<
         interfaces.requests.IReq_ValidateEmailDomain
       >('/typedrequest', 'validateEmailDomain');
-      await request.fire({ identity: context.identity!, id });
-      return await actionContext!.dispatch(fetchEmailDomainsAction, null);
-    } catch {
-      return currentState;
+      const response = await request.fire({ identity: context.identity, id });
+      const operation = createOperationState('validate', response);
+      if (!response.success) {
+        return applyOperationState(currentState, operation, 'Failed to validate email domain DNS');
+      }
+      const refreshedState = await actionContext!.dispatch(fetchEmailDomainsAction, null);
+      return applyOperationState(refreshedState, operation, 'Email domain DNS validated');
+    } catch (error: unknown) {
+      const operation = createFailedOperationState('validate', error, 'Failed to validate email domain DNS');
+      return applyOperationState(currentState, operation, 'Failed to validate email domain DNS');
     }
   },
 );
@@ -130,14 +289,24 @@ export const provisionEmailDomainDnsAction = emailDomainsStatePart.createAction<
   async (statePartArg, id, actionContext) => {
     const context = getActionContext();
     const currentState = statePartArg.getState()!;
+    if (!context.identity) {
+      const operation = createFailedOperationState('provision', new Error('Not authenticated'), 'Not authenticated');
+      return applyOperationState(currentState, operation, 'Failed to provision email domain DNS');
+    }
     try {
       const request = new plugins.domtools.plugins.typedrequest.TypedRequest<
         interfaces.requests.IReq_ProvisionEmailDomainDns
       >('/typedrequest', 'provisionEmailDomainDns');
-      await request.fire({ identity: context.identity!, id });
-      return await actionContext!.dispatch(fetchEmailDomainsAction, null);
-    } catch {
-      return currentState;
+      const response = await request.fire({ identity: context.identity, id });
+      const operation = createOperationState('provision', response);
+      if (!response.success) {
+        return applyOperationState(currentState, operation, 'Failed to provision email domain DNS');
+      }
+      const refreshedState = await actionContext!.dispatch(fetchEmailDomainsAction, null);
+      return applyOperationState(refreshedState, operation, 'Email domain DNS provisioned');
+    } catch (error: unknown) {
+      const operation = createFailedOperationState('provision', error, 'Failed to provision email domain DNS');
+      return applyOperationState(currentState, operation, 'Failed to provision email domain DNS');
     }
   },
 );

package/ts_web/elements/email/ops-view-email-domains.ts

@@ -218,12 +218,11 @@ export class OpsViewEmailDomains extends DeesElement {
               type: ['inRow', 'contextmenu'] as any,
               actionFunc: async (actionData: any) => {
                 const d = actionData.item as interfaces.data.IEmailDomain;
-                await appstate.emailDomainsStatePart.dispatchAction(
+                const nextState = await appstate.emailDomainsStatePart.dispatchAction(
                   appstate.validateEmailDomainAction,
                   d.id,
                 );
-                const { DeesToast } = await import('@design.estate/dees-catalog');
-                DeesToast.show({ message: `DNS validated for ${d.domain}`, type: 'success', duration: 2500 });
+                await this.showOperationToast(nextState, `DNS validated for ${d.domain}`);
               },
             },
             {
@@ -232,12 +231,11 @@ export class OpsViewEmailDomains extends DeesElement {
               type: ['inRow', 'contextmenu'] as any,
               actionFunc: async (actionData: any) => {
                 const d = actionData.item as interfaces.data.IEmailDomain;
-                await appstate.emailDomainsStatePart.dispatchAction(
+                const nextState = await appstate.emailDomainsStatePart.dispatchAction(
                   appstate.provisionEmailDomainDnsAction,
                   d.id,
                 );
-                const { DeesToast } = await import('@design.estate/dees-catalog');
-                DeesToast.show({ message: `DNS records provisioned for ${d.domain}`, type: 'success', duration: 2500 });
+                await this.showOperationToast(nextState, `DNS records provisioned for ${d.domain}`);
               },
             },
             {
@@ -255,10 +253,11 @@ export class OpsViewEmailDomains extends DeesElement {
               type: ['inRow', 'contextmenu'] as any,
               actionFunc: async (actionData: any) => {
                 const d = actionData.item as interfaces.data.IEmailDomain;
-                await appstate.emailDomainsStatePart.dispatchAction(
+                const nextState = await appstate.emailDomainsStatePart.dispatchAction(
                   appstate.deleteEmailDomainAction,
                   d.id,
                 );
+                await this.showOperationToast(nextState, `Email domain ${d.domain} deleted`);
               },
             },
           ]}
@@ -282,6 +281,32 @@ export class OpsViewEmailDomains extends DeesElement {
     return html`<span class="sourceBadge">${label}</span>`;
   }
 
+  private async showOperationToast(
+    stateArg: appstate.IEmailDomainsState,
+    successMessageArg: string,
+  ): Promise<boolean> {
+    const { DeesToast } = await import('@design.estate/dees-catalog');
+    const operation = stateArg.lastOperation;
+    if (!operation) {
+      DeesToast.show({
+        message: stateArg.error || 'Email domain operation returned no result',
+        type: 'error',
+        duration: 5000,
+      });
+      return false;
+    }
+
+    const isPending = operation.success &&
+      operation.lifecycleStatus !== undefined &&
+      operation.lifecycleStatus !== 'active';
+    DeesToast.show({
+      message: appstate.formatEmailDomainOperationMessage(operation, successMessageArg),
+      type: operation.success ? (isPending ? 'warning' : 'success') : 'error',
+      duration: operation.success && !isPending ? 3000 : 6000,
+    });
+    return operation.success;
+  }
+
   private parsePortList(value: string): number[] {
     return value
       .split(',')
@@ -454,7 +479,7 @@ export class OpsViewEmailDomains extends DeesElement {
                 : parseInt(data.dkimKeySize || '2048', 10);
 
             const subdomain = data.subdomain?.trim() || undefined;
-            await appstate.emailDomainsStatePart.dispatchAction(
+            const nextState = await appstate.emailDomainsStatePart.dispatchAction(
               appstate.createEmailDomainAction,
               {
                 linkedDomainId,
@@ -464,7 +489,11 @@ export class OpsViewEmailDomains extends DeesElement {
                 rotateKeys: Boolean(data.rotateKeys),
               },
             );
-            m.destroy();
+            const wasAccepted = await this.showOperationToast(
+              nextState,
+              `Email domain created`,
+            );
+            if (wasAccepted) m.destroy();
           },
         },
       ],
@@ -513,12 +542,15 @@ export class OpsViewEmailDomains extends DeesElement {
         {
           name: 'Auto-Provision All',
           action: async (m: any) => {
-            await appstate.emailDomainsStatePart.dispatchAction(
+            const nextState = await appstate.emailDomainsStatePart.dispatchAction(
               appstate.provisionEmailDomainDnsAction,
               emailDomain.id,
             );
-            DeesToast.show({ message: 'DNS records provisioned', type: 'success', duration: 2500 });
-            m.destroy();
+            const wasAccepted = await this.showOperationToast(
+              nextState,
+              `DNS records provisioned for ${emailDomain.domain}`,
+            );
+            if (wasAccepted) m.destroy();
           },
         },
         { name: 'Close', action: async (m: any) => m.destroy() },