@johannc-dev/zyrk 0.0.0-stage → 0.2.0

package/dist/client.js

@@ -0,0 +1,416 @@
+import { Cause, Config, Context, Effect, Exit, Layer, Option, Redacted, Schema, } from "effect";
+import { decode, Job, Json, ProgramSummary, Started, toJobResult, } from "./contracts.js";
+import { ApiError, ConfigError, DecodeError, ExecutionEnded, ExecutionFailed, Failure, messageOf, NetworkError, WaitTimeout, } from "./errors.js";
+export * from "./errors.js";
+const ServerError = Schema.Struct({
+    error: Schema.Union([Schema.String, Failure]),
+    message: Schema.optionalKey(Schema.String),
+});
+const apiError = (status, body) => {
+    const parsed = Schema.decodeUnknownOption(ServerError)(body);
+    if (Option.isNone(parsed))
+        return new ApiError({
+            status,
+            code: `http_${status}`,
+            message: `HTTP ${status}`,
+            body,
+        });
+    const { error, message } = parsed.value;
+    return typeof error === "string"
+        ? new ApiError({ status, code: error, message: message ?? error, body })
+        : new ApiError({
+            status,
+            code: error.code,
+            message: error.message,
+            failure: error,
+            body,
+        });
+};
+const parseJson = (text) => {
+    if (text === "")
+        return Option.some(null);
+    try {
+        return Option.some(JSON.parse(text));
+    }
+    catch {
+        return Option.none();
+    }
+};
+const segment = encodeURIComponent;
+const isFinal = (r) => r.status !== "queued" && r.status !== "running";
+export const make = (config) => {
+    const base = `${config.url.replace(/\/$/, "")}/v1/functions/`;
+    const request = Effect.fnUntraced(function* (method, path, body) {
+        const url = base + path;
+        const response = yield* Effect.tryPromise({
+            try: async (signal) => {
+                const response = await fetch(url, {
+                    method,
+                    headers: {
+                        authorization: `Bearer ${config.apiKey}`,
+                        "content-type": "application/json",
+                    },
+                    ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+                    redirect: "error",
+                    signal,
+                });
+                return {
+                    status: response.status,
+                    ok: response.ok,
+                    text: await response.text(),
+                };
+            },
+            catch: (cause) => new NetworkError({
+                url,
+                message: `${method} ${url}: ${messageOf(cause)}`,
+                cause,
+            }),
+        });
+        const parsed = parseJson(response.text);
+        if (!response.ok)
+            return yield* apiError(response.status, Option.getOrElse(parsed, () => response.text));
+        if (Option.isNone(parsed))
+            return yield* new DecodeError({
+                what: `${method} ${path}`,
+                message: "Response body is not JSON",
+            });
+        return yield* decode(Json, `${method} ${path}`)(parsed.value);
+    });
+    const execution = (id) => request("GET", `executions/${segment(id)}`).pipe(Effect.flatMap(decode(Job, "execution")));
+    const result = (id) => {
+        const follow = (current, hops) => execution(current).pipe(Effect.flatMap((job) => job.status === "continued" && hops < 10_000
+            ? follow(job.nextExecutionId, hops + 1)
+            : Effect.succeed({ ...toJobResult(job), id })));
+        return follow(id, 0);
+    };
+    const poll = (check, options, onTimeout) => {
+        const deadline = options.timeoutMs === undefined
+            ? Infinity
+            : Date.now() + options.timeoutMs;
+        const step = check.pipe(Effect.flatMap(Option.match({
+            onSome: Effect.succeed,
+            onNone: () => {
+                const left = deadline - Date.now();
+                if (left <= 0)
+                    return onTimeout();
+                return Effect.sleep(Math.min(options.pollMs ?? 1000, left)).pipe(Effect.flatMap(() => step));
+            },
+        })));
+        return step;
+    };
+    const wait = (id, options = {}) => poll(result(id).pipe(Effect.flatMap((r) => {
+        switch (r.status) {
+            case "succeeded":
+                return Effect.succeed(Option.some(r.result));
+            case "failed":
+                return Effect.fail(new ExecutionFailed({ executionId: id, failure: r.error }));
+            case "cancelled":
+            case "expired":
+            case "acknowledged":
+                return Effect.fail(new ExecutionEnded({ executionId: id, status: r.status }));
+            case "queued":
+            case "running":
+                return Effect.succeed(Option.none());
+        }
+    })), options, () => Effect.fail(new WaitTimeout({
+        executionId: id,
+        timeoutMs: options.timeoutMs ?? 0,
+    })));
+    const waitAll = (ids, options = {}) => {
+        const latest = new Map();
+        const snapshot = () => ids.map((id) => latest.get(id));
+        const check = Effect.forEach(ids.filter((id) => !latest.has(id) || !isFinal(latest.get(id))), (id) => result(id).pipe(Effect.tap((r) => Effect.sync(() => latest.set(id, r)))), { concurrency: 8 }).pipe(Effect.map(() => ids.every((id) => isFinal(latest.get(id)))
+            ? Option.some(snapshot())
+            : Option.none()));
+        return poll(check, options, () => Effect.sync(snapshot));
+    };
+    const start = (program, input) => request("POST", `programs/${segment(program)}/invoke`, {
+        ...input,
+        requestId: input.requestId ?? crypto.randomUUID(),
+    }).pipe(Effect.flatMap(decode(Started, "start response")), Effect.map((started) => started.id));
+    return {
+        request,
+        deploy: (program, code, options = {}) => request("PUT", `programs/${segment(program)}`, {
+            code,
+            force: options.force ?? false,
+        }),
+        programs: () => request("GET", "programs").pipe(Effect.flatMap(decode(Schema.Array(ProgramSummary), "programs"))),
+        inspect: (program) => request("GET", `programs/${segment(program)}`),
+        pause: (program, paused = true) => request("POST", `programs/${segment(program)}/pause`, { paused }),
+        executions: (program) => request("GET", `programs/${segment(program)}/executions`),
+        start,
+        execution,
+        result,
+        wait,
+        waitAll,
+        run: (program, input, options) => start(program, input).pipe(Effect.flatMap((id) => wait(id, options))),
+        acknowledge: (id) => request("POST", `executions/${segment(id)}/ack`, {}),
+        cancel: (id) => request("POST", `executions/${segment(id)}/cancel`, {}),
+        events: (afterSeq) => request("GET", afterSeq === undefined ? "events" : `events?after_seq=${afterSeq}`),
+        measurements: () => request("GET", "measurements"),
+        webhook: () => request("GET", "webhook"),
+        setWebhook: (config) => request("PUT", "webhook", config),
+        deleteWebhook: () => request("DELETE", "webhook"),
+        rotateWebhookSecret: (options = {}) => request("POST", "webhook/rotate", options),
+        testWebhook: () => request("POST", "webhook/test", {}),
+        webhookDeliveries: (limit) => request("GET", limit === undefined
+            ? "webhook/deliveries"
+            : `webhook/deliveries?limit=${limit}`),
+    };
+};
+export const clientConfig = Config.all({
+    url: Config.String("TH_API_URL"),
+    apiKey: Config.Redacted("TH_API_KEY"),
+}).pipe(Effect.map(({ url, apiKey }) => ({ url, apiKey: Redacted.value(apiKey) })), Effect.mapError((error) => new ConfigError({
+    message: `Set TH_API_URL and TH_API_KEY: ${error.message.split("\n")[0]}`,
+})));
+export class ZyrkClient extends Context.Service()("@johannc-dev/zyrk/ZyrkClient") {
+    static layer = (config) => Layer.succeed(ZyrkClient, make(config));
+    static layerConfig = Layer.effect(ZyrkClient, Effect.map(clientConfig, make));
+}
+const runPromise = async (effect, signal) => {
+    signal?.throwIfAborted();
+    const exit = await Effect.runPromiseExit(effect, { signal });
+    if (Exit.isSuccess(exit))
+        return exit.value;
+    if (signal?.aborted && Cause.hasInterrupts(exit.cause))
+        throw signal.reason;
+    throw Cause.squash(exit.cause);
+};
+export class FunctionsClient {
+    client;
+    config;
+    constructor(config) {
+        this.client = make(config);
+        this.config = config;
+    }
+    storage(area) {
+        return httpStorageArea(this.config, area);
+    }
+    request(method, path, body, signal) {
+        return runPromise(this.client.request(method, path, body), signal);
+    }
+    deploy(program, code, options = {}) {
+        return runPromise(this.client.deploy(program, code, options), options.signal);
+    }
+    programs(signal) {
+        return runPromise(this.client.programs(), signal);
+    }
+    inspect(program, signal) {
+        return runPromise(this.client.inspect(program), signal);
+    }
+    pause(program, paused = true, signal) {
+        return runPromise(this.client.pause(program, paused), signal);
+    }
+    executions(program, signal) {
+        return runPromise(this.client.executions(program), signal);
+    }
+    start(program, input, signal) {
+        return runPromise(this.client.start(program, input), signal);
+    }
+    execution(id, signal) {
+        return runPromise(this.client.execution(id), signal);
+    }
+    result(id, signal) {
+        return runPromise(this.client.result(id), signal);
+    }
+    wait(id, options = {}) {
+        return runPromise(this.client.wait(id, options), options.signal);
+    }
+    waitAll(ids, options = {}) {
+        return runPromise(this.client.waitAll(ids, options), options.signal);
+    }
+    run(program, input, options = {}) {
+        return runPromise(this.client.run(program, input, options), options.signal);
+    }
+    acknowledge(id, signal) {
+        return runPromise(this.client.acknowledge(id), signal);
+    }
+    cancel(id, signal) {
+        return runPromise(this.client.cancel(id), signal);
+    }
+    events(afterSeq, signal) {
+        return runPromise(this.client.events(afterSeq), signal);
+    }
+    measurements(signal) {
+        return runPromise(this.client.measurements(), signal);
+    }
+    webhook(signal) {
+        return runPromise(this.client.webhook(), signal);
+    }
+    setWebhook(config, signal) {
+        return runPromise(this.client.setWebhook(config), signal);
+    }
+    deleteWebhook(signal) {
+        return runPromise(this.client.deleteWebhook(), signal);
+    }
+    rotateWebhookSecret(options = {}, signal) {
+        return runPromise(this.client.rotateWebhookSecret(options), signal);
+    }
+    testWebhook(signal) {
+        return runPromise(this.client.testWebhook(), signal);
+    }
+    webhookDeliveries(limit, signal) {
+        return runPromise(this.client.webhookDeliveries(limit), signal);
+    }
+    replay(program, request, signal) {
+        return this.request("POST", `programs/${encodeURIComponent(program)}/replay`, request, signal);
+    }
+    replayStatus(id, signal) {
+        return this.request("GET", `replays/${encodeURIComponent(id)}`, undefined, signal);
+    }
+    cancelReplay(id, signal) {
+        return this.request("POST", `replays/${encodeURIComponent(id)}/cancel`, {}, signal);
+    }
+    replayExecutions(id, after = 0, signal) {
+        return this.request("GET", `replays/${encodeURIComponent(id)}/executions?after=${after}`, undefined, signal);
+    }
+    replayEmits(id, afterSeq = 0, signal) {
+        return this.request("GET", `replays/${encodeURIComponent(id)}/emits?after_seq=${afterSeq}`, undefined, signal);
+    }
+}
+export const storageKeyPath = (key) => {
+    const parts = key.split("/");
+    if (key === "" || parts.some((p) => p === "" || p === "." || p === ".."))
+        throw new ApiError({
+            status: 400,
+            code: "invalid_request",
+            message: "Over HTTP, a key cannot have empty, '.' or '..' parts",
+            body: null,
+        });
+    return parts.map(encodeURIComponent).join("/");
+};
+const httpStorageArea = (config, area) => {
+    const base = `${config.url.replace(/\/$/, "")}/v1/functions/storage/`;
+    const call = async (method, path, init = {}) => {
+        const url = base + path;
+        try {
+            return await fetch(url, {
+                method,
+                headers: { authorization: `Bearer ${config.apiKey}`, ...init.headers },
+                ...(init.body === undefined ? {} : { body: init.body }),
+                redirect: "error",
+                ...(init.signal ? { signal: init.signal } : {}),
+            });
+        }
+        catch (cause) {
+            throw new NetworkError({
+                url,
+                message: `${method} ${url}: ${messageOf(cause)}`,
+                cause,
+            });
+        }
+    };
+    const fail = async (response) => {
+        const text = await response.text();
+        throw apiError(response.status, Option.getOrElse(parseJson(text), () => text));
+    };
+    const json = async (response) => {
+        if (!response.ok)
+            return fail(response);
+        return (await response.json());
+    };
+    const headOf = (key, response) => {
+        const h = response.headers;
+        const metadata = {};
+        h.forEach((value, name) => {
+            if (name.startsWith("x-meta-"))
+                metadata[name.slice(7)] = value;
+        });
+        const range = h.get("content-range");
+        const total = range
+            ? Number(range.split("/")[1])
+            : Number(h.get("content-length") ?? 0);
+        return {
+            key,
+            size: total,
+            contentType: h.get("content-type") ?? "application/octet-stream",
+            metadata,
+            lastModified: h.get("last-modified") ?? "",
+            expiresAt: h.get("x-expires-at"),
+            etag: (h.get("etag") ?? "").replace(/^"|"$/g, ""),
+        };
+    };
+    const objectPath = (key) => `${area}/${storageKeyPath(key)}`;
+    return {
+        get: async (key, options = {}) => {
+            if (options.length === 0) {
+                const response = await call("HEAD", objectPath(key), {
+                    signal: options.signal,
+                });
+                if (response.status === 404)
+                    return null;
+                if (!response.ok)
+                    return fail(response);
+                return { ...headOf(key, response), body: new Uint8Array(0) };
+            }
+            const headers = {};
+            if (options.offset !== undefined || options.length !== undefined) {
+                const start = options.offset ?? 0;
+                headers.range =
+                    options.length === undefined
+                        ? `bytes=${start}-`
+                        : `bytes=${start}-${start + options.length - 1}`;
+            }
+            const response = await call("GET", objectPath(key), {
+                headers,
+                signal: options.signal,
+            });
+            if (response.status === 404)
+                return null;
+            if (!response.ok)
+                return fail(response);
+            return {
+                ...headOf(key, response),
+                body: new Uint8Array(await response.arrayBuffer()),
+            };
+        },
+        head: async (key, signal) => {
+            const response = await call("HEAD", objectPath(key), { signal });
+            if (response.status === 404)
+                return null;
+            if (!response.ok)
+                return fail(response);
+            return headOf(key, response);
+        },
+        put: async (key, body, options = {}) => {
+            const headers = {
+                "content-type": options.contentType ??
+                    (typeof body === "string"
+                        ? "text/plain; charset=utf-8"
+                        : "application/octet-stream"),
+            };
+            for (const [name, value] of Object.entries(options.metadata ?? {}))
+                headers[`x-meta-${name}`] = value;
+            if (options.ifAbsent)
+                headers["if-none-match"] = "*";
+            if (options.ifMatch !== undefined)
+                headers["if-match"] = `"${options.ifMatch}"`;
+            return json(await call("PUT", objectPath(key), {
+                headers,
+                body: body,
+                signal: options.signal,
+            }));
+        },
+        delete: async (key, options = {}) => {
+            const headers = {};
+            if (options.ifMatch !== undefined)
+                headers["if-match"] = `"${options.ifMatch}"`;
+            const response = await call("DELETE", objectPath(key), {
+                headers,
+                signal: options.signal,
+            });
+            if (!response.ok)
+                await fail(response);
+        },
+        list: async (prefix = "", options = {}) => {
+            const query = new URLSearchParams({ prefix });
+            if (options.cursor)
+                query.set("cursor", options.cursor);
+            if (options.limit !== undefined)
+                query.set("limit", String(options.limit));
+            return (await json(await call("GET", `${area}?${query}`, { signal: options.signal })));
+        },
+        usage: async (signal) => json(await call("GET", "usage", { signal })),
+    };
+};