@sequenceholdings/managed-functions 0.3.4 → 0.4.0

package/dist/processes-contract.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionProcessReadError = exports.functionProcessReadRequestSchema = exports.functionProcessRunsPageSchema = exports.functionProcessRunsPageQuerySchema = exports.functionProcessRunQuerySchema = exports.functionProcessRunSummarySchema = exports.functionProcessRunStatusSchema = exports.functionProcessReadScopesSchema = exports.FUNCTION_PROCESS_READ_PATH = exports.FUNCTION_PROCESS_TOKEN_HEADER = void 0;
+exports.readFunctionProcessScopes = readFunctionProcessScopes;
+const zod_1 = require("zod");
+exports.FUNCTION_PROCESS_TOKEN_HEADER = 'x-sequence-process-service-token';
+exports.FUNCTION_PROCESS_READ_PATH = '/api/managed-functions/processes/read';
+const processId = zod_1.z
+    .string()
+    .min(1)
+    .max(255)
+    .regex(/^[A-Za-z0-9._-]+$/);
+const entityId = zod_1.z.string().min(1).max(255);
+exports.functionProcessReadScopesSchema = zod_1.z.strictObject({
+    read: zod_1.z
+        .array(processId)
+        .min(1)
+        .max(64)
+        .refine((ids) => new Set(ids).size === ids.length, 'Process ids must be distinct')
+        .refine((ids) => ids.reduce((bytes, id) => bytes + id.length, 0) <= 8192, 'Process ids must fit within 8192 bytes'),
+});
+function readFunctionProcessScopes(manifest) {
+    if (typeof manifest !== 'object' || manifest === null)
+        return [];
+    const capabilities = Reflect.get(manifest, 'capabilities');
+    if (typeof capabilities !== 'object' || capabilities === null)
+        return [];
+    const processes = Reflect.get(capabilities, 'processes');
+    if (processes === undefined)
+        return [];
+    return exports.functionProcessReadScopesSchema.parse(processes).read;
+}
+exports.functionProcessRunStatusSchema = zod_1.z.enum([
+    'pending',
+    'running',
+    'completed',
+    'failed',
+    'cancelled',
+    'timed_out',
+]);
+exports.functionProcessRunSummarySchema = zod_1.z.object({
+    id: zod_1.z.string().min(1).max(255),
+    processId,
+    status: exports.functionProcessRunStatusSchema,
+    entityType: zod_1.z.string().max(255).nullable(),
+    entityId: zod_1.z.string().max(255).nullable(),
+    startedAt: zod_1.z.iso.datetime({ offset: true }),
+    completedAt: zod_1.z.iso.datetime({ offset: true }).nullable(),
+});
+exports.functionProcessRunQuerySchema = zod_1.z.strictObject({
+    process: processId,
+    runId: zod_1.z.string().min(1).max(255),
+});
+exports.functionProcessRunsPageQuerySchema = zod_1.z.strictObject({
+    process: processId,
+    statuses: zod_1.z.array(exports.functionProcessRunStatusSchema).min(1).max(6).optional(),
+    entity: zod_1.z
+        .strictObject({
+        type: entityId,
+        id: entityId.optional(),
+        ids: zod_1.z.array(entityId).min(1).max(500).optional(),
+    })
+        .refine((value) => value.id === undefined || value.ids === undefined, 'Name one entity id or a set, not both')
+        .optional(),
+    limit: zod_1.z.number().int().min(1).max(500).optional(),
+    cursor: zod_1.z.string().min(1).max(8192).optional(),
+    archived: zod_1.z.boolean().optional(),
+});
+exports.functionProcessRunsPageSchema = zod_1.z.object({
+    runs: zod_1.z.array(exports.functionProcessRunSummarySchema).max(500),
+    nextCursor: zod_1.z.string().nullable(),
+});
+exports.functionProcessReadRequestSchema = zod_1.z.discriminatedUnion('operation', [
+    exports.functionProcessRunQuerySchema.extend({ operation: zod_1.z.literal('getRun') }),
+    exports.functionProcessRunsPageQuerySchema.extend({
+        operation: zod_1.z.literal('listRunsPage'),
+    }),
+]);
+class FunctionProcessReadError extends Error {
+    status;
+    code;
+    name = 'FunctionProcessReadError';
+    constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+    }
+}
+exports.FunctionProcessReadError = FunctionProcessReadError;

package/dist/processes.d.ts

@@ -0,0 +1,14 @@
+import { type FunctionProcessRunQuery, type FunctionProcessRunSummary, type FunctionProcessRunsPage, type FunctionProcessRunsPageQuery } from './processes-contract';
+export * from './processes-contract';
+export interface FunctionServiceProcessesOptions {
+    request: {
+        headers: Pick<Headers, 'get'> | Readonly<Record<string, string | readonly string[] | undefined>>;
+    };
+    baseUrl: string;
+    fetchImpl?: typeof globalThis.fetch;
+}
+export interface FunctionServiceProcessesClient {
+    getRun(query: FunctionProcessRunQuery): Promise<FunctionProcessRunSummary>;
+    listRunsPage(query: FunctionProcessRunsPageQuery): Promise<FunctionProcessRunsPage>;
+}
+export declare function createFunctionServiceProcessesClient({ request, baseUrl, fetchImpl, }: FunctionServiceProcessesOptions): FunctionServiceProcessesClient;

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;
+        },
+    };
+}