@sequenceholdings/managed-functions 0.3.2 → 0.3.5

package/dist/processes.js

@@ -0,0 +1,133 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFunctionServiceProcessesClient = createFunctionServiceProcessesClient;
+const zod_1 = require("zod");
+const processes_contract_1 = require("./processes-contract");
+__exportStar(require("./processes-contract"), exports);
+const invalidContext = () => new processes_contract_1.FunctionProcessReadError(401, 'invalid_context', 'This invocation has no valid process-read credential');
+function readCredential({ request, }) {
+    const { headers } = request;
+    const matches = typeof headers.get === 'function'
+        ? [headers.get(processes_contract_1.FUNCTION_PROCESS_TOKEN_HEADER)]
+        : Object.entries(headers)
+            .filter(([name]) => name.toLowerCase() === processes_contract_1.FUNCTION_PROCESS_TOKEN_HEADER)
+            .map(([, value]) => value);
+    const token = matches[0];
+    if (matches.length !== 1 ||
+        typeof token !== 'string' ||
+        token.length > 16_384)
+        throw invalidContext();
+    const envelope = /^([A-Za-z0-9_-]+)\.([A-Za-z0-9_-]{43})$/.exec(token);
+    if (!envelope?.[1])
+        throw invalidContext();
+    let value;
+    try {
+        value = JSON.parse(Buffer.from(envelope[1], 'base64url').toString('utf8'));
+    }
+    catch {
+        throw invalidContext();
+    }
+    const parsed = zod_1.z
+        .object({
+        audience: zod_1.z.literal('atlas-managed-function-process-read'),
+        sub: zod_1.z.string().startsWith('service-account|'),
+        functionId: zod_1.z.string().min(1),
+        invocationId: zod_1.z.string().min(1),
+        exp: zod_1.z.number().int(),
+    })
+        .safeParse(value);
+    if (!parsed.success)
+        throw invalidContext();
+    return { token, expiresAt: parsed.data.exp };
+}
+function origin(baseUrl) {
+    let url;
+    try {
+        url = new URL(baseUrl);
+    }
+    catch {
+        throw new processes_contract_1.FunctionProcessReadError(400, 'invalid_configuration', 'Configure a trusted Atlas origin');
+    }
+    const loopback = url.protocol === 'http:' &&
+        ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname);
+    if ((!loopback && url.protocol !== 'https:') ||
+        url.username ||
+        url.password ||
+        url.pathname !== '/' ||
+        url.search ||
+        url.hash) {
+        throw new processes_contract_1.FunctionProcessReadError(400, 'invalid_configuration', 'Configure an HTTPS Atlas origin without credentials, path, query or fragment');
+    }
+    return url.origin;
+}
+function createFunctionServiceProcessesClient({ request, baseUrl, fetchImpl = globalThis.fetch, }) {
+    const url = `${origin(baseUrl)}${processes_contract_1.FUNCTION_PROCESS_READ_PATH}`;
+    const { token, expiresAt } = readCredential({ request });
+    async function read({ body, schema, }) {
+        if (expiresAt <= Date.now() / 1000)
+            throw new processes_contract_1.FunctionProcessReadError(401, 'expired_context', 'The process-read credential expired; start a new invocation');
+        const parsed = processes_contract_1.functionProcessReadRequestSchema.parse(body);
+        const response = await fetchImpl(url, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                [processes_contract_1.FUNCTION_PROCESS_TOKEN_HEADER]: token,
+            },
+            body: JSON.stringify(parsed),
+            redirect: 'error',
+            signal: AbortSignal.timeout(30_000),
+        });
+        const result = await response.json().catch(() => null);
+        if (!response.ok) {
+            const error = zod_1.z
+                .object({
+                code: zod_1.z.string().max(128).optional(),
+                detail: zod_1.z.string().max(2000).optional(),
+            })
+                .safeParse(result);
+            throw new processes_contract_1.FunctionProcessReadError(response.status, error.success
+                ? (error.data.code ?? 'process_read_failed')
+                : 'process_read_failed', error.success
+                ? (error.data.detail ?? 'Process read failed')
+                : 'Process read failed');
+        }
+        const validated = schema.safeParse(result);
+        if (!validated.success)
+            throw new processes_contract_1.FunctionProcessReadError(502, 'malformed_response', 'Atlas returned an invalid process-read response');
+        return validated.data;
+    }
+    return {
+        async getRun(query) {
+            const run = await read({
+                body: { ...query, operation: 'getRun' },
+                schema: processes_contract_1.functionProcessRunSummarySchema,
+            });
+            if (run.id !== query.runId || run.processId !== query.process)
+                throw new processes_contract_1.FunctionProcessReadError(502, 'malformed_response', 'Atlas returned a different process run');
+            return run;
+        },
+        async listRunsPage(query) {
+            const page = await read({
+                body: { ...query, operation: 'listRunsPage' },
+                schema: processes_contract_1.functionProcessRunsPageSchema,
+            });
+            if (page.runs.some((run) => run.processId !== query.process))
+                throw new processes_contract_1.FunctionProcessReadError(502, 'malformed_response', 'Atlas returned runs from a different process');
+            return page;
+        },
+    };
+}