@serve.zone/coremail 1.0.0

package/dist_ts/classes.server.js

@@ -0,0 +1,309 @@
+import * as plugins from './plugins.js';
+import { CoreMailAuthenticationError, CoreMailAuthorizationError, CoreMailCapabilityDeniedError, CoreMailAuth, coreMailPreAuthDeadlineKey, coreMailSessionKey, } from './classes.auth.js';
+import { CoreMailQuotaExceededError } from './coremail.quota.js';
+const privacySafeError = (errorArg) => {
+    let code = '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 }),
+        });
+    }
+    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,
+    });
+};
+const asPeer = (toolsArg) => {
+    const peer = toolsArg?.localData?.peer;
+    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, bindingArg, configEpochArg) => {
+    const counts = new Map();
+    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 {
+    config;
+    database;
+    storage;
+    transfers;
+    desiredState;
+    auth;
+    submissions;
+    inbound;
+    gateway;
+    now;
+    router = new plugins.typedrequest.TypedRouter();
+    typedServer;
+    preAuthSweepTimer = null;
+    constructor(config, database, storage, transfers, desiredState, auth, submissions, inbound, gateway, now = Date.now) {
+        this.config = config;
+        this.database = database;
+        this.storage = storage;
+        this.transfers = transfers;
+        this.desiredState = desiredState;
+        this.auth = auth;
+        this.submissions = submissions;
+        this.inbound = inbound;
+        this.gateway = gateway;
+        this.now = 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',
+                    },
+                }],
+        });
+    }
+    async start() {
+        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?.();
+    }
+    async stop() {
+        if (this.preAuthSweepTimer) {
+            clearInterval(this.preAuthSweepTimer);
+            this.preAuthSweepTimer = null;
+        }
+        await this.typedServer.stop();
+    }
+    activeSessionCounts(bindingArg, configEpochArg) {
+        if (!this.typedServer.smartServe) {
+            return [];
+        }
+        return countCoreMailActiveSessions(this.typedServer.smartServe.getWebSocketConnections().map((peerArg) => peerArg.data.get(coreMailSessionKey)), bindingArg, configEpochArg);
+    }
+    async getReadiness() {
+        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(),
+        };
+    }
+    registerHandlers() {
+        this.addHandler('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('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('coreMailPrepareDesiredStateUpload', async (requestArg, toolsArg) => {
+            this.auth.requireControlSession(asPeer(toolsArg));
+            return await this.desiredState.prepare(requestArg);
+        });
+        this.addHandler('coreMailApplyDesiredState', async (requestArg, toolsArg) => {
+            this.auth.requireControlSession(asPeer(toolsArg));
+            return { status: await this.desiredState.apply(requestArg) };
+        });
+        this.addHandler('coreMailGetReconciliationStatus', async (requestArg, toolsArg) => {
+            this.auth.requireControlSession(asPeer(toolsArg));
+            return { status: await this.desiredState.getStatus(requestArg) };
+        });
+        this.addHandler('coreMailPrepareOutboundSubmission', async (requestArg, toolsArg) => {
+            const { session, binding } = await this.auth.requireWorkloadSession(asPeer(toolsArg), 'coreMailPrepareOutboundSubmission');
+            return await this.submissions.prepare(session, binding, requestArg);
+        });
+        this.addHandler('coreMailPrepareOutboundPartUpload', async (requestArg, toolsArg) => {
+            const { session } = await this.auth.requireWorkloadSession(asPeer(toolsArg), 'coreMailPrepareOutboundPartUpload');
+            return await this.submissions.preparePartUpload(session, requestArg);
+        });
+        this.addHandler('coreMailCompleteOutboundPartUpload', async (requestArg, toolsArg) => {
+            const { session } = await this.auth.requireWorkloadSession(asPeer(toolsArg), 'coreMailCompleteOutboundPartUpload');
+            return await this.submissions.completePartUpload(session, requestArg);
+        });
+        this.addHandler('coreMailFinalizeOutboundSubmission', async (requestArg, toolsArg) => {
+            const { session } = await this.auth.requireWorkloadSession(asPeer(toolsArg), 'coreMailFinalizeOutboundSubmission');
+            return await this.submissions.finalize(session, requestArg);
+        });
+        this.addHandler('coreMailGetOutboundSubmission', async (requestArg, toolsArg) => {
+            const { session } = await this.auth.requireWorkloadSession(asPeer(toolsArg), 'coreMailGetOutboundSubmission');
+            return await this.submissions.get(session, requestArg);
+        });
+        this.addHandler('coreMailListInboundDeliveries', async (requestArg, toolsArg) => {
+            const { session } = await this.auth.requireWorkloadSession(asPeer(toolsArg), 'coreMailListInboundDeliveries');
+            return await this.inbound.listDeliveries(session, requestArg);
+        });
+        this.addHandler('coreMailPrepareInboundFetch', async (requestArg, toolsArg) => {
+            const { session } = await this.auth.requireWorkloadSession(asPeer(toolsArg), 'coreMailPrepareInboundFetch');
+            return await this.inbound.prepareFetch(session, requestArg);
+        });
+        this.addHandler('coreMailCompleteInboundFetch', async (requestArg, toolsArg) => {
+            const { session } = await this.auth.requireWorkloadSession(asPeer(toolsArg), 'coreMailCompleteInboundFetch');
+            return await this.inbound.completeFetch(session, requestArg);
+        });
+        this.addHandler('coreMailAcknowledgeInboundDelivery', async (requestArg, toolsArg) => {
+            const { session } = await this.auth.requireWorkloadSession(asPeer(toolsArg), 'coreMailAcknowledgeInboundDelivery');
+            return await this.inbound.acknowledge(session, requestArg);
+        });
+    }
+    addHandler(methodArg, handlerArg) {
+        this.router.addTypedHandler(new plugins.typedrequest.TypedHandler(methodArg, async (requestArg, toolsArg) => {
+            try {
+                return await handlerArg(requestArg, toolsArg);
+            }
+            catch (error) {
+                throw privacySafeError(error);
+            }
+        }));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.server.js","sourceRoot":"","sources":["../ts/classes.server.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.storage.d.ts

@@ -0,0 +1,32 @@
+import * as plugins from './plugins.js';
+type TCoreMailSha256 = plugins.serveZoneInterfaces.data.TCoreMailSha256;
+export declare class CoreMailStorage {
+    readonly bucketName: string;
+    readonly smartBucket: plugins.smartbucket.SmartBucket;
+    bucket: plugins.smartbucket.Bucket;
+    private exactUploadCapability?;
+    private exactPurgeCapability?;
+    constructor(storageDescriptorArg: Record<string, unknown>, bucketName: string);
+    start(): Promise<void>;
+    checkReadiness(): Promise<boolean>;
+    stop(): Promise<void>;
+    purgeExact(objectKeyArg: string, signalArg?: AbortSignal): Promise<void>;
+    putExact(objectKeyArg: string, streamArg: ReadableStream<Uint8Array>, lengthBytesArg: number, sha256Arg: TCoreMailSha256, contentTypeArg: string, maximumBytesArg: number, signalArg?: AbortSignal): Promise<void>;
+    putBytesExact(objectKeyArg: string, bytesArg: Uint8Array, contentTypeArg: string, maximumBytesArg: number, signalArg?: AbortSignal): Promise<{
+        lengthBytes: number;
+        sha256: TCoreMailSha256;
+    }>;
+    getVerifiedStream(objectKeyArg: string, lengthBytesArg: number, sha256Arg: TCoreMailSha256, maximumBytesArg: number, signalArg?: AbortSignal): Promise<{
+        stream: ReadableStream<Uint8Array>;
+        completion: Promise<{
+            lengthBytes: number;
+            sha256: TCoreMailSha256;
+        }>;
+        cancel: (reasonArg?: unknown) => Promise<void>;
+    }>;
+    getVerifiedBytes(objectKeyArg: string, lengthBytesArg: number, sha256Arg: TCoreMailSha256, maximumBytesArg: number): Promise<Uint8Array>;
+    verifyObject(objectKeyArg: string, lengthBytesArg: number, sha256Arg: TCoreMailSha256, maximumBytesArg: number, signalArg?: AbortSignal): Promise<void>;
+}
+export declare const createSha256: (valueArg: Uint8Array | string) => TCoreMailSha256;
+export declare const createOpaqueToken: () => string;
+export {};