@apifuse/provider-sdk 2.1.0-beta.6 → 2.1.0-beta.9

package/dist/runtime/state.js

@@ -0,0 +1,344 @@
+import { providerStateRedisUrlFromEnv } from "../config/loader";
+import { ProviderError } from "../errors";
+import { createProviderRedisClient, ensureRedisReady, withRedisTimeout, } from "./redis";
+const DEFAULT_REDIS_TIMEOUT_MS = 250;
+const REDIS_STATE_PREFIX = "apifuse:provider-state:v1";
+const redisBackends = new Map();
+function getRedisBackend(redisUrl) {
+    const existing = redisBackends.get(redisUrl);
+    if (existing)
+        return existing;
+    const redis = createProviderRedisClient({
+        redisUrl,
+        timeoutMs: DEFAULT_REDIS_TIMEOUT_MS,
+        onError: () => {
+            // Runtime state operations fail closed at their call sites. Avoid noisy
+            // unhandled Redis errors from background reconnect attempts.
+        },
+    });
+    const backend = { redis };
+    redisBackends.set(redisUrl, backend);
+    return backend;
+}
+async function withRequiredRedis(operation) {
+    return await withRedisTimeout(operation, {
+        timeoutMs: DEFAULT_REDIS_TIMEOUT_MS,
+        onTimeout: () => {
+            throw new UnsupportedProviderStateError("Provider runtime state Redis timed out");
+        },
+        onError: () => {
+            throw new UnsupportedProviderStateError("Provider runtime state Redis is unavailable");
+        },
+    });
+}
+async function requireRedisReady(redis) {
+    if (await ensureRedisReady(redis, DEFAULT_REDIS_TIMEOUT_MS))
+        return;
+    throw new UnsupportedProviderStateError("Provider runtime state Redis is unavailable");
+}
+function providerStatePrefix(providerId, namespace) {
+    return `${REDIS_STATE_PREFIX}:${providerId ?? "default"}:${namespace}`;
+}
+function providerStateKey(providerId, namespace, key) {
+    return `${providerStatePrefix(providerId, namespace)}:${key}`;
+}
+function publicStateKey(providerId, namespace, redisKey) {
+    const prefix = `${providerStatePrefix(providerId, namespace)}:`;
+    return redisKey.startsWith(prefix) ? redisKey.slice(prefix.length) : redisKey;
+}
+function parseStateDurationMs(ttl) {
+    const match = /^(\d+)(ms|s|m|h|d)$/.exec(ttl ?? "1h");
+    if (!match)
+        return 3_600_000;
+    const amount = Number(match[1]);
+    const unit = match[2];
+    const multiplier = unit === "ms"
+        ? 1
+        : unit === "s"
+            ? 1_000
+            : unit === "m"
+                ? 60_000
+                : unit === "h"
+                    ? 3_600_000
+                    : 86_400_000;
+    return Math.max(1, amount * multiplier);
+}
+function resolveExpiresAt(ttl) {
+    return new Date(Date.now() + parseStateDurationMs(ttl)).toISOString();
+}
+function envelopeFromJson(key, raw) {
+    if (!raw)
+        return null;
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return null;
+    }
+    const record = Object.fromEntries(Object.entries(parsed));
+    if (typeof record.version !== "number" ||
+        typeof record.expiresAt !== "string" ||
+        typeof record.createdAt !== "string" ||
+        typeof record.updatedAt !== "string" ||
+        !("value" in record)) {
+        return null;
+    }
+    return {
+        key,
+        value: record.value,
+        version: record.version,
+        expiresAt: record.expiresAt,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+    };
+}
+function redisEnvelope(value, version, createdAt, expiresAt) {
+    const updatedAt = new Date().toISOString();
+    return { value, version, expiresAt, createdAt, updatedAt };
+}
+class RedisProviderStateNamespace {
+    backend;
+    providerId;
+    namespaceName;
+    options;
+    constructor(backend, providerId, namespaceName, options) {
+        this.backend = backend;
+        this.providerId = providerId;
+        this.namespaceName = namespaceName;
+        this.options = options;
+    }
+    redisKey(key) {
+        return providerStateKey(this.providerId, this.namespaceName, key);
+    }
+    prefix() {
+        return `${providerStatePrefix(this.providerId, this.namespaceName)}:`;
+    }
+    async activeKeys() {
+        await requireRedisReady(this.backend.redis);
+        return await withRequiredRedis(() => this.backend.redis.keys(`${this.prefix()}*`));
+    }
+    enforceValueSize(value) {
+        const bytes = Buffer.byteLength(JSON.stringify(value), "utf8");
+        if (bytes > this.options.maxValueBytes) {
+            throw new UnsupportedProviderStateError(`Provider runtime state value exceeds maxValueBytes (${bytes} > ${this.options.maxValueBytes})`);
+        }
+    }
+    async enforceMaxEntries(key) {
+        const keys = await this.activeKeys();
+        const redisKey = this.redisKey(key);
+        const otherKeys = keys.filter((candidate) => candidate !== redisKey);
+        if (otherKeys.length >= this.options.maxEntries) {
+            throw new UnsupportedProviderStateError(`Provider runtime state namespace quota exceeded (${otherKeys.length + 1} > ${this.options.maxEntries})`);
+        }
+    }
+    async list(options) {
+        const keys = (await this.activeKeys()).filter((key) => {
+            const publicKey = publicStateKey(this.providerId, this.namespaceName, key);
+            return options?.prefix ? publicKey.startsWith(options.prefix) : true;
+        });
+        const limited = keys.slice(0, Math.max(0, options?.limit ?? keys.length));
+        if (limited.length === 0)
+            return [];
+        const values = await withRequiredRedis(() => this.backend.redis.mget(limited));
+        return values.flatMap((raw, index) => {
+            const key = limited[index];
+            if (!key)
+                return [];
+            const value = envelopeFromJson(publicStateKey(this.providerId, this.namespaceName, key), raw);
+            return value ? [value] : [];
+        });
+    }
+    async get(key) {
+        await requireRedisReady(this.backend.redis);
+        const raw = await withRequiredRedis(() => this.backend.redis.get(this.redisKey(key)));
+        return envelopeFromJson(key, raw);
+    }
+    async set(key, value, options) {
+        this.enforceValueSize(value);
+        await this.enforceMaxEntries(key);
+        const current = await this.get(key);
+        const createdAt = current?.createdAt ?? new Date().toISOString();
+        const version = (current?.version ?? 0) + 1;
+        const ttl = options?.ttl ?? this.options.defaultTtl;
+        const ttlMs = parseStateDurationMs(ttl);
+        const expiresAt = resolveExpiresAt(ttl);
+        const envelope = redisEnvelope(value, version, createdAt, expiresAt);
+        await withRequiredRedis(() => this.backend.redis.set(this.redisKey(key), JSON.stringify(envelope), "PX", ttlMs));
+        return {
+            key,
+            value,
+            version,
+            expiresAt,
+            createdAt,
+            updatedAt: envelope.updatedAt,
+        };
+    }
+    async patch(key, partial, options) {
+        const current = (await this.get(key))?.value ?? {};
+        // biome-ignore lint/suspicious/noExplicitAny: patch preserves the caller-provided generic state shape.
+        const merged = { ...current, ...partial };
+        return await this.set(key, merged, options);
+    }
+    async compareAndSet(key, expectedVersion, value, options) {
+        this.enforceValueSize(value);
+        const current = await this.get(key);
+        if ((current?.version ?? 0) !== expectedVersion) {
+            return { ok: false, current };
+        }
+        return { ok: true, value: await this.set(key, value, options) };
+    }
+    async delete(key) {
+        await requireRedisReady(this.backend.redis);
+        await withRequiredRedis(() => this.backend.redis.del(this.redisKey(key)));
+    }
+    async increment(key, field, delta = 1, options) {
+        const current = (await this.get(key))?.value ?? {};
+        const previous = typeof current[field] === "number" ? current[field] : 0;
+        return await this.set(key, { ...current, [field]: previous + delta }, options);
+    }
+}
+class RedisProviderRuntimeState {
+    backend;
+    providerId;
+    constructor(options) {
+        this.backend = getRedisBackend(options.redisUrl);
+        this.providerId = options.providerId;
+    }
+    namespace(name, options) {
+        return new RedisProviderStateNamespace(this.backend, this.providerId, name, options);
+    }
+}
+export class UnsupportedProviderStateError extends ProviderError {
+    constructor(message = "Provider runtime state is not available in this runtime") {
+        super(message, { code: "PROVIDER_STATE_UNSUPPORTED" });
+        this.name = "UnsupportedProviderStateError";
+    }
+}
+class UnsupportedProviderStateNamespace {
+    async list(_options) {
+        throw new UnsupportedProviderStateError();
+    }
+    async get(_key) {
+        throw new UnsupportedProviderStateError();
+    }
+    async set(_key, _value, _options) {
+        throw new UnsupportedProviderStateError();
+    }
+    async patch(_key, _partial, _options) {
+        throw new UnsupportedProviderStateError();
+    }
+    async compareAndSet(_key, _expectedVersion, _value, _options) {
+        throw new UnsupportedProviderStateError();
+    }
+    async delete(_key) {
+        throw new UnsupportedProviderStateError();
+    }
+    async increment(_key, _field, _delta, _options) {
+        throw new UnsupportedProviderStateError();
+    }
+}
+class UnsupportedProviderRuntimeState {
+    namespace(_name, _options) {
+        return new UnsupportedProviderStateNamespace();
+    }
+}
+class MemoryProviderStateNamespace {
+    options;
+    // biome-ignore lint/suspicious/noExplicitAny: in-memory state stores heterogeneous generic values by key.
+    values = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    pruneExpired(nowMs = Date.now()) {
+        for (const [key, row] of this.values.entries()) {
+            if (row.expiresAt && Date.parse(row.expiresAt) <= nowMs) {
+                this.values.delete(key);
+            }
+        }
+    }
+    async list(_options) {
+        this.pruneExpired();
+        const rows = Array.from(this.values.values()).filter((value) => _options?.prefix ? value.key.startsWith(_options.prefix) : true);
+        return rows.slice(0, _options?.limit);
+    }
+    async get(key) {
+        this.pruneExpired();
+        return this.values.get(key) ?? null;
+    }
+    async set(key, value, options) {
+        this.pruneExpired();
+        const now = new Date().toISOString();
+        const current = this.values.get(key);
+        const expiresAt = resolveMemoryStateExpiresAt(options?.ttl ?? this.options.defaultTtl);
+        const row = {
+            key,
+            value,
+            version: (current?.version ?? 0) + 1,
+            expiresAt,
+            createdAt: current?.createdAt ?? now,
+            updatedAt: now,
+        };
+        this.values.set(key, row);
+        return row;
+    }
+    async patch(_key, _partial, _options) {
+        throw new UnsupportedProviderStateError("In-memory provider runtime state does not support patch");
+    }
+    async compareAndSet(_key, _expectedVersion, _value, _options) {
+        throw new UnsupportedProviderStateError("In-memory provider runtime state does not support compareAndSet");
+    }
+    async delete(key) {
+        this.values.delete(key);
+    }
+    async increment(_key, _field, _delta = 1, _options) {
+        throw new UnsupportedProviderStateError("In-memory provider runtime state does not support increment");
+    }
+}
+class MemoryProviderRuntimeState {
+    namespaces = new Map();
+    namespace(name, _options) {
+        const existing = this.namespaces.get(name);
+        if (existing)
+            return existing;
+        const created = new MemoryProviderStateNamespace(_options);
+        this.namespaces.set(name, created);
+        return created;
+    }
+}
+function resolveMemoryStateExpiresAt(ttl) {
+    const match = /^(\d+)(ms|s|m|h|d)$/.exec(ttl ?? "1h");
+    if (!match)
+        return new Date(Date.now() + 3_600_000).toISOString();
+    const amount = Number(match[1]);
+    const unit = match[2];
+    const multiplier = unit === "ms"
+        ? 1
+        : unit === "s"
+            ? 1_000
+            : unit === "m"
+                ? 60_000
+                : unit === "h"
+                    ? 3_600_000
+                    : 86_400_000;
+    return new Date(Date.now() + amount * multiplier).toISOString();
+}
+export function createRedisProviderRuntimeState(options) {
+    return new RedisProviderRuntimeState(options);
+}
+export function createProviderRuntimeStateFromEnv(options = {}) {
+    const redisUrl = providerStateRedisUrlFromEnv();
+    if (redisUrl) {
+        return createRedisProviderRuntimeState({
+            redisUrl,
+            providerId: options.providerId,
+        });
+    }
+    if (options.allowMemoryFallback === true) {
+        return new MemoryProviderRuntimeState();
+    }
+    return createUnsupportedProviderRuntimeState();
+}
+export function createMemoryProviderRuntimeState() {
+    return new MemoryProviderRuntimeState();
+}
+export function createUnsupportedProviderRuntimeState() {
+    return new UnsupportedProviderRuntimeState();
+}

package/dist/runtime/stealth.d.ts

@@ -0,0 +1,18 @@
+import type { ImpitResponse } from "impit";
+import type { ProxyResolutionOptions } from "../config/loader";
+import type { StealthClient, StealthResponse } from "../types";
+export type StealthClientOptions = ProxyResolutionOptions & {
+    warn?: (message: string) => void;
+    /**
+     * Proxy-only stealth transport overrides. Use only for upstream proxy products
+     * that terminate CONNECT with a private CA instead of tunneling the origin
+     * certificate chain.
+     */
+    proxyStealth?: {
+        insecureSkipVerify?: boolean;
+    };
+};
+type StealthTransportResponse = Pick<ImpitResponse, "arrayBuffer" | "headers" | "json" | "ok" | "status" | "text" | "url">;
+export declare function normalizeResponse(response: StealthTransportResponse): Promise<StealthResponse>;
+export declare function createStealthClient(baseUrl: string, defaultProfileOrOptions?: string | StealthClientOptions, clientOptions?: StealthClientOptions): StealthClient;
+export {};