@serve.zone/coremail 1.1.0 → 1.3.0

package/ts/coremail.validation.ts

@@ -93,107 +93,17 @@ export const normalizeCoreMailEnvelope = (
   return { mailFrom, rcptTo };
 };
 
-export const normalizeCoreMailConnectionInfo = (
-  valueArg: unknown,
-): plugins.serveZoneInterfaces.data.IMailConnectionInfo => {
-  const value = requirePlainRecord(valueArg, 'connectionInfo');
-  requireExactKeys(
-    value,
-    ['protocol'],
-    [
-      'remoteAddress',
-      'proxyAddress',
-      'heloName',
-      'tls',
-      'authUsername',
-      'authenticatedCredentialId',
-    ],
-    'connectionInfo',
-  );
-  if (
-    value.protocol !== 'smtp'
-    && value.protocol !== 'submission'
-    && value.protocol !== 'api'
-  ) {
-    throw new Error('CoreMail gateway connection protocol is invalid.');
-  }
-  for (const key of [
-    'remoteAddress',
-    'proxyAddress',
-    'heloName',
-    'authUsername',
-    'authenticatedCredentialId',
-  ] as const) {
-    if (
-      value[key] !== undefined
-      && (
-        typeof value[key] !== 'string'
-        || value[key].length === 0
-        || Buffer.byteLength(value[key], 'utf8') > 512
-        || value[key].trim() !== value[key]
-      )
-    ) {
-      throw new Error(`CoreMail gateway connection ${key} is invalid.`);
-    }
-  }
-  if (value.tls !== undefined && typeof value.tls !== 'boolean') {
-    throw new Error('CoreMail gateway connection TLS state is invalid.');
-  }
-  return {
-    protocol: value.protocol,
-    ...(value.remoteAddress === undefined
-      ? {}
-      : { remoteAddress: value.remoteAddress as string }),
-    ...(value.proxyAddress === undefined
-      ? {}
-      : { proxyAddress: value.proxyAddress as string }),
-    ...(value.heloName === undefined
-      ? {}
-      : { heloName: value.heloName as string }),
-    ...(value.tls === undefined ? {} : { tls: value.tls }),
-    ...(value.authUsername === undefined
-      ? {}
-      : { authUsername: value.authUsername as string }),
-    ...(value.authenticatedCredentialId === undefined
-      ? {}
-      : {
-          authenticatedCredentialId:
-            value.authenticatedCredentialId as string,
-        }),
-  };
-};
-
-export const normalizeCoreMailGatewayMessage = (
-  valueArg: unknown,
-): plugins.serveZoneInterfaces.data.ICoreMailGatewayMessageDescriptor => {
-  const value = requirePlainRecord(valueArg, 'gatewayMessage');
-  requireExactKeys(value, ['envelope', 'rawMime'], [], 'gatewayMessage');
-  const rawMime = requirePlainRecord(value.rawMime, 'gatewayMessage.rawMime');
-  requireExactKeys(
-    rawMime,
-    ['sha256', 'lengthBytes', 'contentType'],
-    [],
-    'gatewayMessage.rawMime',
-  );
-  if (
-    rawMime.contentType !== 'message/rfc822'
-    || !Number.isSafeInteger(rawMime.lengthBytes)
-    || Number(rawMime.lengthBytes) < 1
-    || Number(rawMime.lengthBytes)
-      > plugins.serveZoneInterfaces.data.coreMailLimits.serializedMimeBytes
-  ) {
-    throw new Error('CoreMail gateway MIME descriptor is invalid.');
+/**
+ * The single sender-authorization rule every outbound path applies: the
+ * envelope sender must be an exact member of the binding's allowed senders.
+ */
+export const assertCoreMailSenderAllowed = (
+  senderAddressArg: string,
+  bindingArg: plugins.serveZoneInterfaces.data.ICoreMailBindingDesiredState,
+): void => {
+  if (!bindingArg.allowedSenders.includes(senderAddressArg)) {
+    throw new Error('CoreMail sender is not authorized by the binding.');
   }
-  return {
-    envelope: normalizeCoreMailEnvelope(value.envelope),
-    rawMime: {
-      sha256: plugins.serveZoneInterfaces.data.normalizeCoreMailSha256(
-        rawMime.sha256,
-      ),
-      lengthBytes: Number(rawMime.lengthBytes),
-      contentType: 'message/rfc822',
-    },
-  };
 };
 
 export const normalizeCoreMailOutboundMessage = (
@@ -202,12 +112,30 @@ export const normalizeCoreMailOutboundMessage = (
 ): TMessage => {
   const message = plugins.serveZoneInterfaces.data
     .normalizeCoreMailOutboundMessageDescriptor(valueArg);
-  if (!bindingArg.allowedSenders.includes(message.sender.address)) {
-    throw new Error('CoreMail sender is not authorized by the binding.');
-  }
+  assertCoreMailSenderAllowed(message.sender.address, bindingArg);
   return message;
 };
 
+/**
+ * Build the outbound message descriptor of an exact-byte SMTP submission.
+ *
+ * An SMTP submission has no CoreMail-composed body: the bytes are opaque and
+ * are owned by the immutable MIME tuple, so the descriptor carries only the
+ * SMTP envelope. `parts` is therefore empty, which is why such a descriptor is
+ * deliberately not routed through
+ * `normalizeCoreMailOutboundMessageDescriptor` (it requires at least one part).
+ */
+export const createCoreMailRawOutboundMessage = (
+  envelopeArg: plugins.serveZoneInterfaces.data.ICoreMailEnvelope,
+): TMessage => ({
+  sender: { address: envelopeArg.mailFrom },
+  recipients: {
+    to: envelopeArg.rcptTo.map((recipientArg) => ({ address: recipientArg })),
+  },
+  subject: '',
+  parts: [],
+});
+
 export const createCoreMailSubmissionDigest = (
   idempotencyKeyArg: string,
   messageArg: TMessage,

package/ts/interfaces.ts

@@ -70,6 +70,24 @@ export interface ITransferAuthority {
   bindingId: string;
 }
 
+/**
+ * How an outbound submission entered CoreMail. Records persisted before this
+ * discriminator existed carry no value and are read as 'api'.
+ */
+export type TCoreMailSubmissionSource = 'api' | 'smtp';
+
+/**
+ * Exact-byte SMTP submission handed to CoreMail by an authenticated MSA
+ * session. CoreMail never parses or rewrites `rawMime`.
+ */
+export interface ICoreMailRawSubmissionInput {
+  envelope: {
+    from: string;
+    to: string[];
+  };
+  rawMime: Uint8Array;
+}
+
 export interface ISubmissionPartRecord {
   partId: string;
   kind: plugins.serveZoneInterfaces.data.TCoreMailPartKind;
@@ -91,6 +109,8 @@ export interface ICoreMailReadiness {
   exactPurge: boolean;
   controlBootstrap: boolean;
   gateway: boolean;
+  /** False whenever the desired state asks for an SMTP listener that is not accepting submissions. */
+  smtpSubmission: boolean;
 }
 
 export interface ICoreMailAuthLimiterSnapshot {

package/ts/plugins.ts

@@ -6,6 +6,7 @@ export * as projectinfo from '@push.rocks/projectinfo';
 export * as smartbucket from '@push.rocks/smartbucket';
 export * as smartdata from '@push.rocks/smartdata';
 export * as smartlog from '@push.rocks/smartlog';
+export * as smartmta from '@push.rocks/smartmta';
 export * as serveZoneInterfaces from '@serve.zone/interfaces';
 export * as argon2 from 'argon2';
 export * as nodeCrypto from 'node:crypto';