@serve.zone/coremail 1.0.0

package/dist_ts/classes.storage.js

@@ -0,0 +1,317 @@
+import * as plugins from './plugins.js';
+const digestBuffer = (bufferArg) => plugins.serveZoneInterfaces.data.normalizeCoreMailSha256(`sha256:${plugins.nodeCrypto.createHash('sha256').update(bufferArg).digest('hex')}`);
+const hashAndBoundStream = (streamArg, maximumBytesArg, expectedLengthArg, expectedSha256Arg, signalArg, idleTimeoutMsArg) => {
+    const hash = plugins.nodeCrypto.createHash('sha256');
+    let lengthBytes = 0;
+    let resolveCompletion;
+    let rejectCompletion;
+    const completion = new Promise((resolveArg, rejectArg) => {
+        resolveCompletion = resolveArg;
+        rejectCompletion = rejectArg;
+    });
+    const reader = streamArg.getReader();
+    let settled = false;
+    let readerReleased = false;
+    let idleTimer = null;
+    const releaseReader = () => {
+        if (!readerReleased) {
+            try {
+                reader.releaseLock();
+                readerReleased = true;
+            }
+            catch {
+                // A pending read releases the lock after cancellation settles.
+            }
+        }
+    };
+    const cancelReader = async (reasonArg) => {
+        const cancellation = reader.cancel(reasonArg).catch(() => undefined);
+        releaseReader();
+        const timeout = new Promise((resolveArg) => {
+            const timer = setTimeout(resolveArg, 1_000);
+            timer.unref?.();
+            void cancellation.finally(() => clearTimeout(timer));
+        });
+        await Promise.race([cancellation, timeout]);
+        releaseReader();
+        void cancellation.finally(releaseReader);
+    };
+    const settleError = (errorArg) => {
+        if (!settled) {
+            settled = true;
+            rejectCompletion(errorArg);
+        }
+    };
+    const cancel = async (reasonArg) => {
+        signalArg?.removeEventListener('abort', onAbort);
+        if (settled) {
+            releaseReader();
+            return;
+        }
+        const error = reasonArg instanceof Error
+            ? reasonArg
+            : new Error('CoreMail transfer was cancelled.');
+        settleError(error);
+        if (idleTimer) {
+            clearTimeout(idleTimer);
+            idleTimer = null;
+        }
+        await cancelReader(error);
+    };
+    const onAbort = () => {
+        void cancel(signalArg?.reason);
+    };
+    if (signalArg) {
+        if (signalArg.aborted) {
+            void cancel(signalArg.reason);
+        }
+        else {
+            signalArg.addEventListener('abort', onAbort, { once: true });
+        }
+    }
+    const stream = new ReadableStream({
+        async pull(controllerArg) {
+            try {
+                signalArg?.throwIfAborted();
+                if (idleTimeoutMsArg !== undefined) {
+                    idleTimer = setTimeout(() => {
+                        void cancel(new Error('CoreMail transfer exceeded its idle deadline.'));
+                    }, idleTimeoutMsArg);
+                    idleTimer.unref?.();
+                }
+                const next = await reader.read();
+                if (idleTimer) {
+                    clearTimeout(idleTimer);
+                    idleTimer = null;
+                }
+                if (!next.done) {
+                    if (!(next.value instanceof Uint8Array)) {
+                        throw new Error('CoreMail transfer emitted a non-byte chunk.');
+                    }
+                    lengthBytes += next.value.byteLength;
+                    if (lengthBytes > maximumBytesArg) {
+                        throw new Error('CoreMail transfer exceeded its byte budget.');
+                    }
+                    hash.update(next.value);
+                    controllerArg.enqueue(next.value);
+                    return;
+                }
+                const sha256 = plugins.serveZoneInterfaces.data.normalizeCoreMailSha256(`sha256:${hash.digest('hex')}`);
+                if ((expectedLengthArg !== undefined && lengthBytes !== expectedLengthArg)
+                    || (expectedSha256Arg !== undefined && sha256 !== expectedSha256Arg)) {
+                    throw new Error('CoreMail object integrity verification failed.');
+                }
+                settled = true;
+                resolveCompletion({ lengthBytes, sha256 });
+                controllerArg.close();
+                signalArg?.removeEventListener('abort', onAbort);
+                releaseReader();
+            }
+            catch (error) {
+                const normalized = error instanceof Error ? error : new Error(String(error));
+                if (idleTimer) {
+                    clearTimeout(idleTimer);
+                    idleTimer = null;
+                }
+                settleError(normalized);
+                controllerArg.error(normalized);
+                await cancelReader(normalized);
+                signalArg?.removeEventListener('abort', onAbort);
+            }
+        },
+        async cancel(reasonArg) {
+            signalArg?.removeEventListener('abort', onAbort);
+            await cancel(reasonArg);
+        },
+    });
+    void completion.catch(() => undefined);
+    return {
+        stream,
+        completion,
+        cancel,
+    };
+};
+export class CoreMailStorage {
+    bucketName;
+    smartBucket;
+    bucket;
+    exactUploadCapability;
+    exactPurgeCapability;
+    constructor(storageDescriptorArg, bucketName) {
+        this.bucketName = bucketName;
+        this.smartBucket = new plugins.smartbucket.SmartBucket(storageDescriptorArg);
+    }
+    async start() {
+        try {
+            const readiness = await this.smartBucket.checkReadiness(this.bucketName, {
+                timeoutMs: 5_000,
+            });
+            if (!readiness.ready) {
+                throw new Error(`CoreMail object storage is unavailable: ${readiness.reason}`);
+            }
+            this.bucket = await this.smartBucket.getBucketByName(this.bucketName);
+            const exactUpload = await this.bucket.probeExactUploadCapability({
+                signal: AbortSignal.timeout(30_000),
+            });
+            if (!exactUpload.supported) {
+                throw new Error(`CoreMail requires exact object publication: ${exactUpload.reason}`);
+            }
+            this.exactUploadCapability = exactUpload.capability;
+            const exactPurge = await this.bucket.probeExactPathPurgeCapability({
+                signal: AbortSignal.timeout(30_000),
+            });
+            if (!exactPurge.supported) {
+                throw new Error(`CoreMail requires exact object retention: ${exactPurge.reason}`);
+            }
+            this.exactPurgeCapability = exactPurge.capability;
+        }
+        catch (error) {
+            await this.smartBucket.close().catch(() => undefined);
+            throw error;
+        }
+    }
+    async checkReadiness() {
+        const readiness = await this.smartBucket.checkReadiness(this.bucketName, {
+            timeoutMs: 1_500,
+        });
+        return readiness.ready
+            && Boolean(this.exactUploadCapability)
+            && Boolean(this.exactPurgeCapability);
+    }
+    async stop() {
+        await this.smartBucket.close();
+    }
+    async purgeExact(objectKeyArg, signalArg) {
+        if (!this.exactPurgeCapability
+            || !/^[A-Za-z0-9][A-Za-z0-9._/-]{0,1023}$/.test(objectKeyArg)
+            || objectKeyArg.startsWith('/')
+            || objectKeyArg.includes('//')
+            || objectKeyArg.split('/').some((partArg) => partArg === '..')) {
+            throw new Error('CoreMail exact purge capability or object key is invalid.');
+        }
+        await this.bucket.purgeExactPath({
+            capability: this.exactPurgeCapability,
+            path: objectKeyArg,
+            timeoutMs: 30_000,
+            signal: signalArg,
+        });
+    }
+    async putExact(objectKeyArg, streamArg, lengthBytesArg, sha256Arg, contentTypeArg, maximumBytesArg, signalArg) {
+        if (!this.exactUploadCapability) {
+            throw new Error('CoreMail exact upload capability is unavailable.');
+        }
+        if (!Number.isSafeInteger(lengthBytesArg)
+            || lengthBytesArg < 0
+            || lengthBytesArg > maximumBytesArg) {
+            throw new Error('CoreMail exact upload length is outside its byte budget.');
+        }
+        const monitored = hashAndBoundStream(streamArg, maximumBytesArg, lengthBytesArg, sha256Arg, signalArg, plugins.serveZoneInterfaces.data.coreMailLimits.transferIdleTimeoutMs);
+        let uploadError;
+        try {
+            await this.bucket.fastPutStreamExact({
+                capability: this.exactUploadCapability,
+                path: objectKeyArg,
+                readableStream: monitored.stream,
+                contentLength: lengthBytesArg,
+                nativeMetadata: {
+                    'coremail-sha256': sha256Arg.slice('sha256:'.length),
+                },
+                nativeObjectProperties: {
+                    contentType: contentTypeArg,
+                },
+                requestedPartSize: 5 * 1024 * 1024,
+                requestedConcurrency: 2,
+                failureSettlementTimeoutMs: 30_000,
+                signal: signalArg,
+            });
+            await monitored.completion;
+        }
+        catch (error) {
+            uploadError = error;
+            await monitored.cancel(error);
+            await monitored.completion.catch(() => undefined);
+        }
+        if (uploadError) {
+            try {
+                await this.verifyObject(objectKeyArg, lengthBytesArg, sha256Arg, maximumBytesArg, signalArg);
+                return;
+            }
+            catch {
+                throw uploadError;
+            }
+        }
+        await this.verifyObject(objectKeyArg, lengthBytesArg, sha256Arg, maximumBytesArg, signalArg);
+    }
+    async putBytesExact(objectKeyArg, bytesArg, contentTypeArg, maximumBytesArg, signalArg) {
+        if (bytesArg.byteLength > maximumBytesArg) {
+            throw new Error('CoreMail object exceeds its byte budget.');
+        }
+        const sha256 = digestBuffer(bytesArg);
+        await this.putExact(objectKeyArg, new ReadableStream({
+            start(controllerArg) {
+                controllerArg.enqueue(bytesArg);
+                controllerArg.close();
+            },
+        }), bytesArg.byteLength, sha256, contentTypeArg, maximumBytesArg, signalArg);
+        return { lengthBytes: bytesArg.byteLength, sha256 };
+    }
+    async getVerifiedStream(objectKeyArg, lengthBytesArg, sha256Arg, maximumBytesArg, signalArg) {
+        signalArg?.throwIfAborted();
+        const stat = await this.bucket.fastStat({
+            path: objectKeyArg,
+            signal: signalArg,
+        });
+        if (stat.ContentLength !== lengthBytesArg || lengthBytesArg > maximumBytesArg) {
+            throw new Error('CoreMail object length does not match persisted integrity.');
+        }
+        return hashAndBoundStream(await this.bucket.fastGetStream({
+            path: objectKeyArg,
+            signal: signalArg,
+        }, 'webstream'), maximumBytesArg, lengthBytesArg, sha256Arg, signalArg, plugins.serveZoneInterfaces.data.coreMailLimits.transferIdleTimeoutMs);
+    }
+    async getVerifiedBytes(objectKeyArg, lengthBytesArg, sha256Arg, maximumBytesArg) {
+        const verified = await this.getVerifiedStream(objectKeyArg, lengthBytesArg, sha256Arg, maximumBytesArg, AbortSignal.timeout(plugins.serveZoneInterfaces.data.coreMailLimits.transferOverallTimeoutMs));
+        const reader = verified.stream.getReader();
+        const chunks = [];
+        let total = 0;
+        try {
+            while (true) {
+                const next = await reader.read();
+                if (next.done)
+                    break;
+                chunks.push(next.value);
+                total += next.value.byteLength;
+            }
+            await verified.completion;
+        }
+        finally {
+            await reader.cancel().catch(() => undefined);
+            reader.releaseLock();
+        }
+        const result = new Uint8Array(total);
+        let offset = 0;
+        for (const chunk of chunks) {
+            result.set(chunk, offset);
+            offset += chunk.byteLength;
+        }
+        return result;
+    }
+    async verifyObject(objectKeyArg, lengthBytesArg, sha256Arg, maximumBytesArg, signalArg) {
+        signalArg?.throwIfAborted();
+        const verified = await this.getVerifiedStream(objectKeyArg, lengthBytesArg, sha256Arg, maximumBytesArg, signalArg);
+        const reader = verified.stream.getReader();
+        try {
+            while (!(await reader.read()).done) {
+                signalArg?.throwIfAborted();
+            }
+            await verified.completion;
+        }
+        finally {
+            await reader.cancel().catch(() => undefined);
+            reader.releaseLock();
+        }
+    }
+}
+export const createSha256 = (valueArg) => plugins.serveZoneInterfaces.data.normalizeCoreMailSha256(`sha256:${plugins.nodeCrypto.createHash('sha256').update(valueArg).digest('hex')}`);
+export const createOpaqueToken = () => plugins.nodeCrypto.randomBytes(32).toString('base64url');
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.storage.js","sourceRoot":"","sources":["../ts/classes.storage.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.submissions.d.ts

@@ -0,0 +1,33 @@
+import * as plugins from './plugins.js';
+import { type ICoreMailModels } from './classes.models.js';
+import { CoreMailStorage } from './classes.storage.js';
+import { CoreMailTransferService } from './classes.transfer.js';
+import type { ICoreMailWorkloadSession } from './interfaces.js';
+type TBinding = plugins.serveZoneInterfaces.data.ICoreMailBindingDesiredState;
+type TSubmission = plugins.serveZoneInterfaces.data.ICoreMailSubmission;
+export declare class CoreMailSubmissionService {
+    private readonly database;
+    private readonly models;
+    private readonly storage;
+    private readonly transfers;
+    private readonly now;
+    constructor(database: plugins.smartdata.SmartdataDb, models: ICoreMailModels, storage: CoreMailStorage, transfers: CoreMailTransferService, now?: () => number);
+    prepare(sessionArg: ICoreMailWorkloadSession, bindingArg: TBinding, requestArg: plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailPrepareOutboundSubmission['request']): Promise<{
+        submission: TSubmission;
+        replayed: boolean;
+    }>;
+    preparePartUpload(sessionArg: ICoreMailWorkloadSession, requestArg: plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailPrepareOutboundPartUpload['request']): Promise<{
+        grant: plugins.serveZoneInterfaces.data.ICoreMailUploadGrant;
+    }>;
+    completePartUpload(sessionArg: ICoreMailWorkloadSession, requestArg: plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailCompleteOutboundPartUpload['request']): Promise<{
+        submission: TSubmission;
+    }>;
+    finalize(sessionArg: ICoreMailWorkloadSession, requestArg: plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailFinalizeOutboundSubmission['request']): Promise<{
+        submission: TSubmission;
+    }>;
+    get(sessionArg: ICoreMailWorkloadSession, requestArg: plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailGetOutboundSubmission['request']): Promise<{
+        submission: TSubmission;
+    }>;
+    private requireSubmission;
+}
+export {};