@serve.zone/coremail 1.1.0 → 1.3.0

package/ts/classes.models.ts

@@ -1,11 +1,16 @@
 import * as plugins from './plugins.js';
-import type { ISubmissionPartRecord, TTransferGrantPurpose } from './interfaces.js';
+import type {
+  ISubmissionPartRecord,
+  TCoreMailSubmissionSource,
+  TTransferGrantPurpose,
+} from './interfaces.js';
 import {
   assertCoreMailDesiredSnapshotRecord,
   assertCoreMailInboundDeliveryRecord,
   assertCoreMailInboundHandoffRecord,
   assertCoreMailQuotaCounterRecord,
   assertCoreMailRecipientHandleRecord,
+  assertCoreMailStatCounterRecord,
   assertCoreMailStateRecord,
   assertCoreMailSubmissionRecord,
   assertCoreMailTransferGrantRecord,
@@ -14,6 +19,7 @@ import {
   type ICoreMailInboundHandoffRecord,
   type ICoreMailQuotaCounterRecord,
   type ICoreMailRecipientHandleRecord,
+  type ICoreMailStatCounterRecord,
   type ICoreMailStateRecord,
   type ICoreMailSubmissionRecord,
   type ICoreMailTransferGrantRecord,
@@ -111,6 +117,33 @@ export class CoreMailTransferGrantDoc extends plugins.smartdata.SmartDataDbDoc<
   public consumedAt?: number;
 }
 
+@plugins.smartdata.exactPersistence({
+  assertDocument: assertCoreMailStatCounterRecord,
+  reconcileBy: 'statId',
+})
+export class CoreMailStatCounterDoc extends plugins.smartdata.SmartDataDbDoc<
+  CoreMailStatCounterDoc,
+  ICoreMailStatCounterRecord
+> implements ICoreMailStatCounterRecord {
+  declare public static exact: plugins.smartdata.TExact<CoreMailStatCounterDoc>;
+  public statId!: TCoreMailSha256;
+  public tenantId!: string;
+  public serviceId!: string;
+  public bindingId!: string;
+  public dayUtc!: number;
+  public submittedApi!: number;
+  public submittedSmtp!: number;
+  public delivered!: number;
+  public deferred!: number;
+  public failed!: number;
+  public deadLettered!: number;
+  public received!: number;
+  public acknowledgedProcessed!: number;
+  public acknowledgedDiscarded!: number;
+  public createdAt!: number;
+  public updatedAt!: number;
+}
+
 @plugins.smartdata.exactPersistence({
   assertDocument: assertCoreMailSubmissionRecord,
   reconcileBy: 'submissionId',
@@ -129,6 +162,8 @@ export class CoreMailSubmissionDoc extends plugins.smartdata.SmartDataDbDoc<
   public idempotencyKey!: string;
   public submissionDigest!: TCoreMailSha256;
   public state!: plugins.serveZoneInterfaces.data.TCoreMailSubmissionState;
+  public source?: TCoreMailSubmissionSource;
+  public statsSubmittedCountedAt?: number;
   public message!: plugins.serveZoneInterfaces.data.ICoreMailOutboundMessageDescriptor;
   public parts!: ISubmissionPartRecord[];
   public mimeObjectKey?: string;
@@ -237,6 +272,7 @@ export interface ICoreMailModels {
   State: typeof CoreMailStateDoc;
   DesiredSnapshot: typeof CoreMailDesiredSnapshotDoc;
   QuotaCounter: typeof CoreMailQuotaCounterDoc;
+  StatCounter: typeof CoreMailStatCounterDoc;
   TransferGrant: typeof CoreMailTransferGrantDoc;
   Submission: typeof CoreMailSubmissionDoc;
   InboundDelivery: typeof CoreMailInboundDeliveryDoc;
@@ -310,6 +346,34 @@ export const createCoreMailModels = (
         key: { state: 1, updatedAt: 1 },
       },
     ]) as typeof CoreMailDesiredSnapshotDoc,
+    StatCounter: bind(CoreMailStatCounterDoc, 'CoreMailStatCounter', [
+      'statId',
+      'tenantId',
+      'serviceId',
+      'bindingId',
+      'dayUtc',
+      'submittedApi',
+      'submittedSmtp',
+      'delivered',
+      'deferred',
+      'failed',
+      'deadLettered',
+      'received',
+      'acknowledgedProcessed',
+      'acknowledgedDiscarded',
+      'createdAt',
+      'updatedAt',
+    ], 'statId', [
+      {
+        name: 'authority_day_unique',
+        key: { tenantId: 1, serviceId: 1, bindingId: 1, dayUtc: 1 },
+        options: { unique: true },
+      },
+      {
+        name: 'day_retention',
+        key: { dayUtc: 1, statId: 1 },
+      },
+    ]) as typeof CoreMailStatCounterDoc,
     QuotaCounter: bind(CoreMailQuotaCounterDoc, 'CoreMailQuotaCounter', [
       'counterId',
       'tenantId',
@@ -375,6 +439,8 @@ export const createCoreMailModels = (
       'idempotencyKey',
       'submissionDigest',
       'state',
+      'source',
+      'statsSubmittedCountedAt',
       'message',
       'parts',
       'mimeObjectKey',

package/ts/classes.server.ts

@@ -10,6 +10,8 @@ import {
 import type { CoreMailDesiredStateService } from './classes.desiredstate.js';
 import type { CoreMailGateway } from './classes.gateway.js';
 import type { CoreMailInboundService } from './classes.inbound.js';
+import type { ICoreMailModels } from './classes.models.js';
+import type { CoreMailSmtpSubmissionServer } from './classes.smtpsubmission.js';
 import type { CoreMailStorage } from './classes.storage.js';
 import type { CoreMailSubmissionService } from './classes.submissions.js';
 import type { CoreMailTransferService } from './classes.transfer.js';
@@ -19,72 +21,13 @@ import type {
   ICoreMailReadiness,
   ICoreMailWorkloadSession,
 } from './interfaces.js';
-import { CoreMailQuotaExceededError } from './coremail.quota.js';
-import { logCoreMailFailure } from './coremail.log.js';
-
-type TErrorCode = plugins.serveZoneInterfaces.data.TCoreMailErrorCode;
+import { addPrivacySafeTypedHandler } from './coremail.errors.js';
+import { listCoreMailServiceMailStatistics } from './coremail.stats.js';
 
 interface ICoreMailTypedTools {
   localData: Record<string, unknown>;
 }
 
-export const privacySafeError = (
-  errorArg: unknown,
-): plugins.typedrequest.TypedResponseError => {
-  let code: TErrorCode = 'INVALID_REQUEST';
-  let retryable = false;
-  if (errorArg instanceof CoreMailAuthenticationError) {
-    code = 'AUTHENTICATION_FAILED';
-  } else if (errorArg instanceof CoreMailCapabilityDeniedError) {
-    code = 'CAPABILITY_DENIED';
-  } else if (errorArg instanceof CoreMailAuthorizationError) {
-    code = 'AUTHORITY_REVOKED';
-  } else if (errorArg instanceof CoreMailQuotaExceededError) {
-    return new plugins.typedrequest.TypedResponseError('CoreMail request rejected.', {
-      code: 'QUOTA_EXCEEDED',
-      retryable: true,
-      ...(errorArg.retryAfterMs === undefined
-        ? {}
-        : { retryAfterMs: errorArg.retryAfterMs }),
-    } satisfies plugins.serveZoneInterfaces.data.ICoreMailErrorData);
-  } else if (
-    errorArg instanceof plugins.serveZoneInterfaces.data.CoreMailContractError
-  ) {
-    code = errorArg.code;
-  } else if (
-    errorArg instanceof Error
-    && errorArg.message.includes('gateway')
-    && errorArg.message.includes('unavailable')
-  ) {
-    code = 'GATEWAY_UNAVAILABLE';
-    retryable = true;
-  } else if (
-    errorArg instanceof Error
-    && errorArg.message.includes('idempotency')
-  ) {
-    code = 'IDEMPOTENCY_CONFLICT';
-  } else if (
-    errorArg instanceof Error
-    && errorArg.message.includes('fence')
-  ) {
-    code = 'STATE_CONFLICT';
-    retryable = true;
-  } else if (
-    errorArg instanceof Error
-    && (
-      errorArg.message.includes('byte budget')
-      || errorArg.message.includes('content budget')
-      || errorArg.message.includes('exceeds')
-    )
-  ) {
-    code = 'PAYLOAD_LIMIT_EXCEEDED';
-  }
-  return new plugins.typedrequest.TypedResponseError('CoreMail request rejected.', {
-    code,
-    retryable,
-  } satisfies plugins.serveZoneInterfaces.data.ICoreMailErrorData);
-};
-
 const asPeer = (
   toolsArg: ICoreMailTypedTools | undefined,
 ): ICoreMailPeer => {
@@ -146,6 +89,7 @@ export class CoreMailServer {
   public constructor(
     private readonly config: ICoreMailConfig,
     private readonly database: plugins.smartdata.SmartdataDb,
+    private readonly models: ICoreMailModels,
     private readonly storage: CoreMailStorage,
     private readonly transfers: CoreMailTransferService,
     private readonly desiredState: CoreMailDesiredStateService,
@@ -153,6 +97,7 @@ export class CoreMailServer {
     private readonly submissions: CoreMailSubmissionService,
     private readonly inbound: CoreMailInboundService,
     private readonly gateway: CoreMailGateway,
+    private readonly smtpSubmission: CoreMailSmtpSubmissionServer,
     private readonly now: () => number = Date.now,
   ) {
     this.registerHandlers();
@@ -295,6 +240,10 @@ export class CoreMailServer {
       exactPurge: objectStorage,
       controlBootstrap: true,
       gateway: Boolean(desiredState) && this.gateway.isReady(),
+      // An absent or disabled listener is ready by omission; one the desired
+      // state asks for is ready only while it is actually accepting.
+      smtpSubmission: !desiredState?.smtp?.enabled
+        || this.smtpSubmission.isReady(),
     };
   }
 
@@ -343,6 +292,12 @@ export class CoreMailServer {
       this.auth.requireControlSession(asPeer(toolsArg));
       return { status: await this.desiredState.getStatus(requestArg) };
     });
+    this.addHandler<
+      plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailGetServiceMailStatistics
+    >('coreMailGetServiceMailStatistics', async (requestArg, toolsArg) => {
+      this.auth.requireControlSession(asPeer(toolsArg));
+      return await listCoreMailServiceMailStatistics(this.models, requestArg);
+    });
     this.addHandler<
       plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailPrepareOutboundSubmission
     >('coreMailPrepareOutboundSubmission', async (requestArg, toolsArg) => {
@@ -426,30 +381,18 @@ export class CoreMailServer {
     });
   }
 
+  /** Register one typed workload handler with uniform failure redaction. */
   private addHandler<
     TRequest extends plugins.typedrequestInterfaces.ITypedRequest,
   >(
     methodArg: TRequest['method'],
-    handlerArg: (
-      requestArg: TRequest['request'],
-      toolsArg: ICoreMailTypedTools | undefined,
-    ) => Promise<TRequest['response']>,
+    handlerArg: plugins.typedrequest.THandlerFunction<TRequest>,
   ): void {
-    this.router.addTypedHandler(new plugins.typedrequest.TypedHandler<TRequest>(
+    addPrivacySafeTypedHandler<TRequest>(
+      this.router,
+      'server',
       methodArg,
-      async (requestArg, toolsArg) => {
-        try {
-          return await handlerArg(requestArg, toolsArg);
-        } catch (error) {
-          const safeError = privacySafeError(error);
-          if (safeError.errorData?.code === 'INVALID_REQUEST') {
-            await logCoreMailFailure('server', 'UNEXPECTED_HANDLER_FAILURE', error, {
-              method: methodArg,
-            }).catch(() => undefined);
-          }
-          throw safeError;
-        }
-      },
-    ));
+      handlerArg,
+    );
   }
 }