@serve.zone/coremail 1.0.0

package/ts/classes.server.ts

@@ -0,0 +1,444 @@
+import * as plugins from './plugins.js';
+import {
+  CoreMailAuthenticationError,
+  CoreMailAuthorizationError,
+  CoreMailCapabilityDeniedError,
+  CoreMailAuth,
+  coreMailPreAuthDeadlineKey,
+  coreMailSessionKey,
+} from './classes.auth.js';
+import type { CoreMailDesiredStateService } from './classes.desiredstate.js';
+import type { CoreMailGateway } from './classes.gateway.js';
+import type { CoreMailInboundService } from './classes.inbound.js';
+import type { CoreMailStorage } from './classes.storage.js';
+import type { CoreMailSubmissionService } from './classes.submissions.js';
+import type { CoreMailTransferService } from './classes.transfer.js';
+import type {
+  ICoreMailConfig,
+  ICoreMailPeer,
+  ICoreMailReadiness,
+  ICoreMailWorkloadSession,
+} from './interfaces.js';
+import { CoreMailQuotaExceededError } from './coremail.quota.js';
+
+type TErrorCode = plugins.serveZoneInterfaces.data.TCoreMailErrorCode;
+
+interface ICoreMailTypedTools {
+  localData: Record<string, unknown>;
+}
+
+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 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 => {
+  const peer = toolsArg?.localData?.peer as ICoreMailPeer | undefined;
+  if (
+    !peer
+    || typeof peer.id !== 'string'
+    || !(peer.data instanceof Map)
+    || typeof peer.close !== 'function'
+    || typeof peer.terminate !== 'function'
+  ) {
+    throw new CoreMailAuthenticationError();
+  }
+  return peer;
+};
+
+export const countCoreMailActiveSessions = (
+  sessionsArg: Iterable<ICoreMailWorkloadSession | undefined>,
+  bindingArg: plugins.serveZoneInterfaces.data.ICoreMailBindingDesiredState,
+  configEpochArg: number,
+): Array<{ credentialId: string; version: number; count: number }> => {
+  const counts = new Map<
+    string,
+    { credentialId: string; version: number; count: number }
+  >();
+  for (const session of sessionsArg) {
+    if (
+      session?.kind === 'workload'
+      && session.tenantId === bindingArg.tenantId
+      && session.serviceId === bindingArg.serviceId
+      && session.bindingId === bindingArg.bindingId
+      && session.bindingRevision === bindingArg.revision
+      && session.configEpoch === configEpochArg
+    ) {
+      const key = `${session.credentialId}\u0000${session.credentialVersion}`;
+      const count = counts.get(key);
+      counts.set(key, count
+        ? { ...count, count: count.count + 1 }
+        : {
+            credentialId: session.credentialId,
+            version: session.credentialVersion,
+            count: 1,
+          });
+    }
+  }
+  return [...counts.values()].sort((leftArg, rightArg) =>
+    leftArg.version - rightArg.version
+    || leftArg.credentialId.localeCompare(rightArg.credentialId)
+  );
+};
+
+export class CoreMailServer {
+  public readonly router:
+    plugins.typedrequest.TypedRouter<plugins.typedrequestInterfaces.ITypedRequest> =
+      new plugins.typedrequest.TypedRouter();
+  public readonly typedServer: plugins.typedserver.TypedServer;
+  private preAuthSweepTimer: ReturnType<typeof setInterval> | null = null;
+
+  public constructor(
+    private readonly config: ICoreMailConfig,
+    private readonly database: plugins.smartdata.SmartdataDb,
+    private readonly storage: CoreMailStorage,
+    private readonly transfers: CoreMailTransferService,
+    private readonly desiredState: CoreMailDesiredStateService,
+    private readonly auth: CoreMailAuth,
+    private readonly submissions: CoreMailSubmissionService,
+    private readonly inbound: CoreMailInboundService,
+    private readonly gateway: CoreMailGateway,
+    private readonly now: () => number = Date.now,
+  ) {
+    this.registerHandlers();
+    this.typedServer = new plugins.typedserver.TypedServer({
+      port: config.port,
+      cors: false,
+      authorityValidation: 'strict',
+      connectionTimeout: 15_000,
+      headersTimeout: 10_000,
+      requestTimeout: 2 * 60_000,
+      websocketMaxPayloadBytes:
+        plugins.serveZoneInterfaces.data.coreMailLimits.controlMessageBytes,
+      healthzEndpoint: false,
+      noCache: true,
+      compression: false,
+      surfaces: [{
+        name: 'coremail',
+        match: {
+          hostnames: config.hostnames,
+          pathPrefixes: ['/'],
+          websocketPathPrefixes: ['/socket'],
+        },
+        typedRequestPath: false,
+        websocketTypedRouter: this.router,
+        cors: false,
+        noCache: true,
+        includeBuiltinTypedHandlers: false,
+        websocketAdmission: (contextArg) => {
+          if (contextArg.path !== '/socket') {
+            return new Response('Not Found', { status: 404 });
+          }
+          contextArg.state[coreMailPreAuthDeadlineKey] = this.now() + 5_000;
+          return true;
+        },
+        httpHandler: async (contextArg) => {
+          const transferResponse = await this.transfers.handleHttp(contextArg);
+          if (transferResponse) {
+            return transferResponse;
+          }
+          if (
+            (contextArg.method === 'GET' || contextArg.method === 'HEAD')
+            && contextArg.path === '/live'
+          ) {
+            return new Response(
+              contextArg.method === 'HEAD' ? null : JSON.stringify({ live: true }),
+              {
+                status: 200,
+                headers: {
+                  'Content-Type': 'application/json',
+                  'Cache-Control': 'no-store',
+                },
+              },
+            );
+          }
+          if (
+            (contextArg.method === 'GET' || contextArg.method === 'HEAD')
+            && contextArg.path === '/ready'
+          ) {
+            const readiness = await this.getReadiness();
+            const ready = Object.values(readiness).every(Boolean);
+            return new Response(
+              contextArg.method === 'HEAD' ? null : JSON.stringify(readiness),
+              {
+                status: ready ? 200 : 503,
+                headers: {
+                  'Content-Type': 'application/json',
+                  'Cache-Control': 'no-store',
+                },
+              },
+            );
+          }
+          return null;
+        },
+        securityHeaders: {
+          xFrameOptions: 'DENY',
+          xContentTypeOptions: true,
+          referrerPolicy: 'no-referrer',
+          permissionsPolicy: {},
+          crossOriginOpenerPolicy: 'same-origin',
+          crossOriginResourcePolicy: 'same-origin',
+        },
+      }],
+    });
+  }
+
+  public async start(): Promise<void> {
+    await this.typedServer.start();
+    this.preAuthSweepTimer = setInterval(() => {
+      const now = this.now();
+      for (const peer of this.typedServer.smartServe.getWebSocketConnections()) {
+        const deadline = Number(peer.context.state[coreMailPreAuthDeadlineKey]);
+        if (
+          !peer.data.has(coreMailSessionKey)
+          && (!Number.isSafeInteger(deadline) || deadline < now)
+        ) {
+          peer.terminate();
+        }
+      }
+    }, 250);
+    this.preAuthSweepTimer.unref?.();
+  }
+
+  public async stop(): Promise<void> {
+    if (this.preAuthSweepTimer) {
+      clearInterval(this.preAuthSweepTimer);
+      this.preAuthSweepTimer = null;
+    }
+    await this.typedServer.stop();
+  }
+
+  public activeSessionCounts(
+    bindingArg: plugins.serveZoneInterfaces.data.ICoreMailBindingDesiredState,
+    configEpochArg: number,
+  ): Array<{ credentialId: string; version: number; count: number }> {
+    if (!this.typedServer.smartServe) {
+      return [];
+    }
+    return countCoreMailActiveSessions(
+      this.typedServer.smartServe.getWebSocketConnections().map((peerArg) =>
+        peerArg.data.get(coreMailSessionKey) as ICoreMailWorkloadSession | undefined
+      ),
+      bindingArg,
+      configEpochArg,
+    );
+  }
+
+  public async getReadiness(): Promise<ICoreMailReadiness> {
+    const [database, objectStorage, desiredState] = await Promise.all([
+      this.database.checkReadiness({ timeoutMs: 1_500 })
+        .then((resultArg) => resultArg.ready)
+        .catch(() => false),
+      this.storage.checkReadiness().catch(() => false),
+      this.desiredState.getActiveDesiredState().catch(() => null),
+    ]);
+    return {
+      live: true,
+      database,
+      objectStorage,
+      exactUpload: objectStorage,
+      exactPurge: objectStorage,
+      controlBootstrap: true,
+      gateway: Boolean(desiredState) && this.gateway.isReady(),
+    };
+  }
+
+  private registerHandlers(): void {
+    this.addHandler<
+      plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailAuthenticateControl
+    >('coreMailAuthenticateControl', async (requestArg, toolsArg) => {
+      const peer = asPeer(toolsArg);
+      const session = await this.auth.authenticateControl(peer, requestArg);
+      return {
+        authenticated: true,
+        credentialId: session.credentialId,
+        replica: { ...this.config.replica },
+        credentialVersion: session.credentialVersion,
+      };
+    });
+    this.addHandler<
+      plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailAuthenticateWorkload
+    >('coreMailAuthenticateWorkload', async (requestArg, toolsArg) => {
+      const session = await this.auth.authenticateWorkload(asPeer(toolsArg), requestArg);
+      return {
+        authenticated: true,
+        credentialId: session.credentialId,
+        credentialVersion: session.credentialVersion,
+        bindingState: session.bindingState,
+        capabilities: [...session.capabilities],
+        allowedOperations: [...session.allowedOperations],
+        coreMailTransferOrigin: session.coreMailTransferOrigin,
+      };
+    });
+    this.addHandler<
+      plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailPrepareDesiredStateUpload
+    >('coreMailPrepareDesiredStateUpload', async (requestArg, toolsArg) => {
+      this.auth.requireControlSession(asPeer(toolsArg));
+      return await this.desiredState.prepare(requestArg);
+    });
+    this.addHandler<
+      plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailApplyDesiredState
+    >('coreMailApplyDesiredState', async (requestArg, toolsArg) => {
+      this.auth.requireControlSession(asPeer(toolsArg));
+      return { status: await this.desiredState.apply(requestArg) };
+    });
+    this.addHandler<
+      plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailGetReconciliationStatus
+    >('coreMailGetReconciliationStatus', async (requestArg, toolsArg) => {
+      this.auth.requireControlSession(asPeer(toolsArg));
+      return { status: await this.desiredState.getStatus(requestArg) };
+    });
+    this.addHandler<
+      plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailPrepareOutboundSubmission
+    >('coreMailPrepareOutboundSubmission', async (requestArg, toolsArg) => {
+      const { session, binding } = await this.auth.requireWorkloadSession(
+        asPeer(toolsArg),
+        'coreMailPrepareOutboundSubmission',
+      );
+      return await this.submissions.prepare(session, binding, requestArg);
+    });
+    this.addHandler<
+      plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailPrepareOutboundPartUpload
+    >('coreMailPrepareOutboundPartUpload', async (requestArg, toolsArg) => {
+      const { session } = await this.auth.requireWorkloadSession(
+        asPeer(toolsArg),
+        'coreMailPrepareOutboundPartUpload',
+      );
+      return await this.submissions.preparePartUpload(session, requestArg);
+    });
+    this.addHandler<
+      plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailCompleteOutboundPartUpload
+    >('coreMailCompleteOutboundPartUpload', async (requestArg, toolsArg) => {
+      const { session } = await this.auth.requireWorkloadSession(
+        asPeer(toolsArg),
+        'coreMailCompleteOutboundPartUpload',
+      );
+      return await this.submissions.completePartUpload(session, requestArg);
+    });
+    this.addHandler<
+      plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailFinalizeOutboundSubmission
+    >('coreMailFinalizeOutboundSubmission', async (requestArg, toolsArg) => {
+      const { session } = await this.auth.requireWorkloadSession(
+        asPeer(toolsArg),
+        'coreMailFinalizeOutboundSubmission',
+      );
+      return await this.submissions.finalize(session, requestArg);
+    });
+    this.addHandler<
+      plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailGetOutboundSubmission
+    >('coreMailGetOutboundSubmission', async (requestArg, toolsArg) => {
+      const { session } = await this.auth.requireWorkloadSession(
+        asPeer(toolsArg),
+        'coreMailGetOutboundSubmission',
+      );
+      return await this.submissions.get(session, requestArg);
+    });
+    this.addHandler<
+      plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailListInboundDeliveries
+    >('coreMailListInboundDeliveries', async (requestArg, toolsArg) => {
+      const { session } = await this.auth.requireWorkloadSession(
+        asPeer(toolsArg),
+        'coreMailListInboundDeliveries',
+      );
+      return await this.inbound.listDeliveries(session, requestArg);
+    });
+    this.addHandler<
+      plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailPrepareInboundFetch
+    >('coreMailPrepareInboundFetch', async (requestArg, toolsArg) => {
+      const { session } = await this.auth.requireWorkloadSession(
+        asPeer(toolsArg),
+        'coreMailPrepareInboundFetch',
+      );
+      return await this.inbound.prepareFetch(session, requestArg);
+    });
+    this.addHandler<
+      plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailCompleteInboundFetch
+    >('coreMailCompleteInboundFetch', async (requestArg, toolsArg) => {
+      const { session } = await this.auth.requireWorkloadSession(
+        asPeer(toolsArg),
+        'coreMailCompleteInboundFetch',
+      );
+      return await this.inbound.completeFetch(session, requestArg);
+    });
+    this.addHandler<
+      plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailAcknowledgeInboundDelivery
+    >('coreMailAcknowledgeInboundDelivery', async (requestArg, toolsArg) => {
+      const { session } = await this.auth.requireWorkloadSession(
+        asPeer(toolsArg),
+        'coreMailAcknowledgeInboundDelivery',
+      );
+      return await this.inbound.acknowledge(session, requestArg);
+    });
+  }
+
+  private addHandler<
+    TRequest extends plugins.typedrequestInterfaces.ITypedRequest,
+  >(
+    methodArg: TRequest['method'],
+    handlerArg: (
+      requestArg: TRequest['request'],
+      toolsArg: ICoreMailTypedTools | undefined,
+    ) => Promise<TRequest['response']>,
+  ): void {
+    this.router.addTypedHandler(new plugins.typedrequest.TypedHandler<TRequest>(
+      methodArg,
+      async (requestArg, toolsArg) => {
+        try {
+          return await handlerArg(requestArg, toolsArg);
+        } catch (error) {
+          throw privacySafeError(error);
+        }
+      },
+    ));
+  }
+}