@qlever-llc/trellis 0.7.0 → 0.8.0-rc.3

package/esm/npm/src/transfer.js

@@ -0,0 +1,416 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _BaseTransferHandle_nc, _BaseTransferHandle_auth, _BaseTransferHandle_timeoutMs, _SendTransferHandle_grant, _ReceiveTransferHandle_grant;
+import { AsyncResult, isErr, Result, } from "@qlever-llc/result";
+import { createInbox, headers as natsHeaders, } from "@nats-io/nats-core";
+import Type from "typebox";
+import { verifyProof } from "./auth/proof.js";
+import { base64urlEncode, sha256 } from "./auth/utils.js";
+import { TransferError } from "./errors/TransferError.js";
+const TRANSFER_SEQUENCE_HEADER = "trellis-transfer-seq";
+const TRANSFER_EOF_HEADER = "trellis-transfer-eof";
+export const FileInfoSchema = Type.Object({
+    key: Type.String({ minLength: 1 }),
+    size: Type.Integer({ minimum: 0 }),
+    updatedAt: Type.String({ minLength: 1 }),
+    digest: Type.Optional(Type.String({ minLength: 1 })),
+    contentType: Type.Optional(Type.String({ minLength: 1 })),
+    metadata: Type.Record(Type.String({ minLength: 1 }), Type.String()),
+}, { additionalProperties: false });
+const TransferGrantBaseSchema = Type.Object({
+    type: Type.Literal("TransferGrant"),
+    service: Type.String({ minLength: 1 }),
+    sessionKey: Type.String({ minLength: 1 }),
+    transferId: Type.String({ minLength: 1 }),
+    subject: Type.String({ minLength: 1 }),
+    expiresAt: Type.String({ minLength: 1 }),
+    chunkBytes: Type.Integer({ minimum: 1 }),
+}, { additionalProperties: false });
+export const SendTransferGrantSchema = Type.Object({
+    ...TransferGrantBaseSchema.properties,
+    direction: Type.Literal("send"),
+    maxBytes: Type.Optional(Type.Integer({ minimum: 1 })),
+    contentType: Type.Optional(Type.String({ minLength: 1 })),
+    metadata: Type.Optional(Type.Record(Type.String({ minLength: 1 }), Type.String())),
+}, { additionalProperties: false });
+export const ReceiveTransferGrantSchema = Type.Object({
+    ...TransferGrantBaseSchema.properties,
+    direction: Type.Literal("receive"),
+    info: FileInfoSchema,
+}, { additionalProperties: false });
+export const TransferGrantSchema = Type.Union([
+    SendTransferGrantSchema,
+    ReceiveTransferGrantSchema,
+]);
+async function createTransferProof(auth, subject, payload) {
+    const payloadHash = await sha256(payload);
+    const proofOk = await auth.sign(await sha256(buildTransferProofInput(auth.sessionKey, subject, payloadHash)));
+    return base64urlEncode(proofOk);
+}
+function buildTransferProofInput(sessionKey, subject, payloadHash) {
+    const enc = new TextEncoder();
+    const sessionKeyBytes = enc.encode(sessionKey);
+    const subjectBytes = enc.encode(subject);
+    const buf = new Uint8Array(4 + sessionKeyBytes.length + 4 + subjectBytes.length + 4 +
+        payloadHash.length);
+    const view = new DataView(buf.buffer);
+    let offset = 0;
+    view.setUint32(offset, sessionKeyBytes.length);
+    offset += 4;
+    buf.set(sessionKeyBytes, offset);
+    offset += sessionKeyBytes.length;
+    view.setUint32(offset, subjectBytes.length);
+    offset += 4;
+    buf.set(subjectBytes, offset);
+    offset += subjectBytes.length;
+    view.setUint32(offset, payloadHash.length);
+    offset += 4;
+    buf.set(payloadHash, offset);
+    return buf;
+}
+function expired(expiresAt) {
+    return Date.now() >= Date.parse(expiresAt);
+}
+function asUint8Array(body) {
+    return body instanceof Uint8Array ? body : new Uint8Array(body);
+}
+function streamFromAsyncIterable(iterable) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    return new ReadableStream({
+        async pull(controller) {
+            const next = await iterator.next();
+            if (next.done) {
+                controller.close();
+                return;
+            }
+            controller.enqueue(next.value);
+        },
+        async cancel(reason) {
+            await iterator.return?.(reason);
+        },
+    });
+}
+function streamFromBody(body) {
+    if (body instanceof Uint8Array || body instanceof ArrayBuffer) {
+        const bytes = asUint8Array(body);
+        return new ReadableStream({
+            start(controller) {
+                controller.enqueue(bytes);
+                controller.close();
+            },
+        });
+    }
+    return body instanceof ReadableStream ? body : streamFromAsyncIterable(body);
+}
+async function* chunkBody(body, chunkBytes) {
+    const reader = streamFromBody(body).getReader();
+    try {
+        while (true) {
+            const next = await reader.read();
+            if (next.done) {
+                return;
+            }
+            let offset = 0;
+            while (offset < next.value.length) {
+                const end = Math.min(offset + chunkBytes, next.value.length);
+                yield next.value.slice(offset, end);
+                offset = end;
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function parseTransferAck(msg, operation) {
+    if (msg.headers?.get("status") === "error") {
+        return Result.err(deserializeTransferError(msg, operation));
+    }
+    try {
+        const value = JSON.parse(msg.string());
+        return Result.ok(value);
+    }
+    catch (cause) {
+        return Result.err(new TransferError({ operation, cause }));
+    }
+}
+function deserializeTransferError(msg, operation) {
+    try {
+        const value = JSON.parse(msg.string());
+        return new TransferError({
+            operation: value.operation ?? operation,
+            context: value.context,
+            cause: value.message ? new Error(value.message) : undefined,
+        });
+    }
+    catch (cause) {
+        return new TransferError({ operation, cause });
+    }
+}
+function receiveStream(sub, timeoutMs) {
+    const iterator = sub[Symbol.asyncIterator]();
+    return new ReadableStream({
+        async pull(controller) {
+            try {
+                const next = await new Promise((resolve, reject) => {
+                    const timer = setTimeout(() => {
+                        reject(new TransferError({
+                            operation: "stream",
+                            context: { reason: "timeout" },
+                        }));
+                    }, timeoutMs);
+                    iterator.next().then((value) => {
+                        clearTimeout(timer);
+                        resolve(value);
+                    }, (error) => {
+                        clearTimeout(timer);
+                        reject(error);
+                    });
+                });
+                if (next.done) {
+                    throw new TransferError({
+                        operation: "stream",
+                        context: { reason: "stream_closed" },
+                    });
+                }
+                const msg = next.value;
+                if (msg.headers?.get("status") === "error") {
+                    throw deserializeTransferError(msg, "stream");
+                }
+                if (msg.data.length > 0) {
+                    controller.enqueue(msg.data);
+                }
+                if (msg.headers?.get(TRANSFER_EOF_HEADER) === "true") {
+                    controller.close();
+                    sub.unsubscribe();
+                }
+            }
+            catch (cause) {
+                sub.unsubscribe();
+                controller.error(cause instanceof TransferError
+                    ? cause
+                    : new TransferError({ operation: "stream", cause }));
+            }
+        },
+        cancel() {
+            sub.unsubscribe();
+        },
+    });
+}
+async function collectStream(stream) {
+    const reader = stream.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        while (true) {
+            const next = await reader.read();
+            if (next.done) {
+                const merged = new Uint8Array(total);
+                let offset = 0;
+                for (const chunk of chunks) {
+                    merged.set(chunk, offset);
+                    offset += chunk.length;
+                }
+                return Result.ok(merged);
+            }
+            chunks.push(next.value);
+            total += next.value.length;
+        }
+    }
+    catch (cause) {
+        return Result.err(cause instanceof TransferError
+            ? cause
+            : new TransferError({ operation: "bytes", cause }));
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+class BaseTransferHandle {
+    constructor(nc, auth, timeoutMs) {
+        _BaseTransferHandle_nc.set(this, void 0);
+        _BaseTransferHandle_auth.set(this, void 0);
+        _BaseTransferHandle_timeoutMs.set(this, void 0);
+        __classPrivateFieldSet(this, _BaseTransferHandle_nc, nc, "f");
+        __classPrivateFieldSet(this, _BaseTransferHandle_auth, auth, "f");
+        __classPrivateFieldSet(this, _BaseTransferHandle_timeoutMs, timeoutMs, "f");
+    }
+    get nc() {
+        return __classPrivateFieldGet(this, _BaseTransferHandle_nc, "f");
+    }
+    get auth() {
+        return __classPrivateFieldGet(this, _BaseTransferHandle_auth, "f");
+    }
+    get timeoutMs() {
+        return __classPrivateFieldGet(this, _BaseTransferHandle_timeoutMs, "f");
+    }
+    validateGrant(grant, operation) {
+        if (expired(grant.expiresAt)) {
+            return Result.err(new TransferError({
+                operation,
+                context: { reason: "expired", transferId: grant.transferId },
+            }));
+        }
+        if (grant.sessionKey !== __classPrivateFieldGet(this, _BaseTransferHandle_auth, "f").sessionKey) {
+            return Result.err(new TransferError({
+                operation,
+                context: {
+                    reason: "session_mismatch",
+                    expectedSessionKey: grant.sessionKey,
+                    actualSessionKey: __classPrivateFieldGet(this, _BaseTransferHandle_auth, "f").sessionKey,
+                },
+            }));
+        }
+        return Result.ok(undefined);
+    }
+    async buildHeaders(subject, payload, seq, eof) {
+        const headers = natsHeaders();
+        headers.set("session-key", __classPrivateFieldGet(this, _BaseTransferHandle_auth, "f").sessionKey);
+        headers.set("proof", await createTransferProof(__classPrivateFieldGet(this, _BaseTransferHandle_auth, "f"), subject, payload));
+        if (seq !== undefined) {
+            headers.set(TRANSFER_SEQUENCE_HEADER, String(seq));
+        }
+        if (eof) {
+            headers.set(TRANSFER_EOF_HEADER, "true");
+        }
+        return headers;
+    }
+}
+_BaseTransferHandle_nc = new WeakMap(), _BaseTransferHandle_auth = new WeakMap(), _BaseTransferHandle_timeoutMs = new WeakMap();
+export class SendTransferHandle extends BaseTransferHandle {
+    constructor(nc, auth, timeoutMs, grant) {
+        super(nc, auth, timeoutMs);
+        _SendTransferHandle_grant.set(this, void 0);
+        __classPrivateFieldSet(this, _SendTransferHandle_grant, grant, "f");
+    }
+    send(body) {
+        return AsyncResult.from((async () => {
+            const valid = this.validateGrant(__classPrivateFieldGet(this, _SendTransferHandle_grant, "f"), "send").take();
+            if (isErr(valid)) {
+                return Result.err(valid.error);
+            }
+            let sentBytes = 0;
+            let seq = 0;
+            let completed = null;
+            for await (const chunk of chunkBody(body, __classPrivateFieldGet(this, _SendTransferHandle_grant, "f").chunkBytes)) {
+                sentBytes += chunk.length;
+                if (__classPrivateFieldGet(this, _SendTransferHandle_grant, "f").maxBytes !== undefined &&
+                    sentBytes > __classPrivateFieldGet(this, _SendTransferHandle_grant, "f").maxBytes) {
+                    return Result.err(new TransferError({
+                        operation: "send",
+                        context: {
+                            reason: "max_bytes_exceeded",
+                            maxBytes: __classPrivateFieldGet(this, _SendTransferHandle_grant, "f").maxBytes,
+                            attemptedBytes: sentBytes,
+                        },
+                    }));
+                }
+                const headers = await this.buildHeaders(__classPrivateFieldGet(this, _SendTransferHandle_grant, "f").subject, chunk, seq, false);
+                const response = await AsyncResult.try(() => this.nc.request(__classPrivateFieldGet(this, _SendTransferHandle_grant, "f").subject, chunk, {
+                    timeout: this.timeoutMs,
+                    headers,
+                })).take();
+                if (isErr(response)) {
+                    return Result.err(new TransferError({ operation: "send", cause: response.error }));
+                }
+                const ack = parseTransferAck(response, "send").take();
+                if (isErr(ack)) {
+                    return Result.err(ack.error);
+                }
+                if (ack.status === "complete") {
+                    completed = ack.info;
+                }
+                seq += 1;
+            }
+            const finalHeaders = await this.buildHeaders(__classPrivateFieldGet(this, _SendTransferHandle_grant, "f").subject, new Uint8Array(), seq, true);
+            const finalResponse = await AsyncResult.try(() => this.nc.request(__classPrivateFieldGet(this, _SendTransferHandle_grant, "f").subject, new Uint8Array(), {
+                timeout: this.timeoutMs,
+                headers: finalHeaders,
+            })).take();
+            if (isErr(finalResponse)) {
+                return Result.err(new TransferError({
+                    operation: "send",
+                    cause: finalResponse.error,
+                }));
+            }
+            const finalAck = parseTransferAck(finalResponse, "send").take();
+            if (isErr(finalAck)) {
+                return Result.err(finalAck.error);
+            }
+            if (finalAck.status !== "complete") {
+                return Result.err(new TransferError({
+                    operation: "send",
+                    context: { reason: "missing_completion" },
+                }));
+            }
+            return Result.ok(finalAck.info ?? completed);
+        })());
+    }
+}
+_SendTransferHandle_grant = new WeakMap();
+export class ReceiveTransferHandle extends BaseTransferHandle {
+    constructor(nc, auth, timeoutMs, grant) {
+        super(nc, auth, timeoutMs);
+        _ReceiveTransferHandle_grant.set(this, void 0);
+        __classPrivateFieldSet(this, _ReceiveTransferHandle_grant, grant, "f");
+    }
+    stream() {
+        return AsyncResult.from((async () => {
+            const valid = this.validateGrant(__classPrivateFieldGet(this, _ReceiveTransferHandle_grant, "f"), "stream").take();
+            if (isErr(valid)) {
+                return Result.err(valid.error);
+            }
+            const inbox = createInbox(`_INBOX.${this.auth.sessionKey.slice(0, 16)}`);
+            const sub = this.nc.subscribe(inbox);
+            const payload = new Uint8Array();
+            const headers = await this.buildHeaders(__classPrivateFieldGet(this, _ReceiveTransferHandle_grant, "f").subject, payload);
+            try {
+                this.nc.publish(__classPrivateFieldGet(this, _ReceiveTransferHandle_grant, "f").subject, payload, {
+                    headers,
+                    reply: inbox,
+                });
+                await this.nc.flush();
+            }
+            catch (cause) {
+                sub.unsubscribe();
+                return Result.err(new TransferError({ operation: "stream", cause }));
+            }
+            return Result.ok(receiveStream(sub, this.timeoutMs));
+        })());
+    }
+    bytes() {
+        return AsyncResult.from((async () => {
+            const streamResult = await this.stream().take();
+            if (isErr(streamResult)) {
+                return Result.err(streamResult.error);
+            }
+            return await collectStream(streamResult);
+        })());
+    }
+}
+_ReceiveTransferHandle_grant = new WeakMap();
+export function createTransferHandle(nc, auth, timeoutMs, grant) {
+    return grant.direction === "send"
+        ? new SendTransferHandle(nc, auth, timeoutMs, grant)
+        : new ReceiveTransferHandle(nc, auth, timeoutMs, grant);
+}
+export async function verifyTransferMessage(args) {
+    if (!args.proof || !args.sessionKey ||
+        args.sessionKey !== args.expectedSessionKey) {
+        return false;
+    }
+    return await verifyProof(args.expectedSessionKey, {
+        sessionKey: args.sessionKey,
+        subject: args.subject,
+        payloadHash: await sha256(args.payload),
+    }, args.proof);
+}