@relayfile/adapter-core 0.3.37 → 0.3.38

package/dist/src/alias-lifecycle.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Stale alias lifecycle cleanup (issue #106).
+ *
+ * Adapters mirror provider records to a canonical path plus lookup aliases
+ * (`by-title/…`, `by-name/…`). Aliases duplicate the canonical bytes
+ * verbatim, and the title-independent `by-id` alias is rewritten on every
+ * ingest — so the bytes sitting at the `by-id` alias path *before* a
+ * re-ingest are a faithful snapshot of the previous record version. That
+ * snapshot is the prior state consumed here: callers read it before
+ * overwriting, derive the candidate alias paths the previous version may
+ * occupy (base + collision variants), and this helper deletes every
+ * candidate that still holds the previous record bytes.
+ *
+ * Content equality is the ownership proof: a candidate is deleted only when
+ * its bytes match `previousContent`. This guarantees we never delete
+ * (a) an alias owned by a different record that happens to share a slug
+ * (collision case), (b) the freshly written alias for the current version
+ * (its bytes are the new content), or (c) anything when the previous
+ * version was never mirrored.
+ *
+ * Relayfile contract: a title change is an alias cleanup, never a record
+ * deletion. Callers must only pass alias paths as candidates — canonical
+ * record paths are never deleted by this helper's callers.
+ *
+ * See also `PriorAliasReader` in `emit-auxiliary` — the same "by-id alias
+ * as prior-state anchor" convention for adapters built on the auxiliary
+ * emitter client. This module is the IO-agnostic deletion side, usable
+ * with both `RelayFileClientLike` and duck-typed `VfsLike` backends.
+ */
+export interface StaleAliasCleanupIo {
+    /** Returns file content, or `undefined` when missing/unreadable. */
+    readFile(path: string): Promise<string | undefined> | string | undefined;
+    /** Deletes the file at `path`. */
+    deleteFile(path: string): Promise<unknown> | unknown;
+}
+export interface StaleAliasCleanupInput {
+    /**
+     * Bytes of the record as previously mirrored — read from a
+     * title-independent alias (e.g. `by-id/…`) before it was overwritten.
+     */
+    previousContent: string;
+    /**
+     * Alias paths the previous record version may occupy. Derive from the
+     * previous title/name (base + collision variants).
+     */
+    candidatePaths: readonly string[];
+    /**
+     * Alias paths belonging to the current record version. Never deleted,
+     * even when a candidate path matches.
+     */
+    keepPaths?: readonly string[];
+}
+export interface StaleAliasCleanupResult {
+    deletedPaths: string[];
+    errors: Array<{
+        path: string;
+        error: string;
+    }>;
+}
+/**
+ * Deletes stale alias files left behind when a record's alias-relevant
+ * field (title/name) changed between ingests. Failures are captured per
+ * path and never thrown — a leftover stale alias is benign, while failing
+ * the surrounding ingest is not.
+ */
+export declare function cleanupStaleAliases(io: StaleAliasCleanupIo, input: StaleAliasCleanupInput): Promise<StaleAliasCleanupResult>;
+/**
+ * Extracts a top-level string field from mirrored JSON record content.
+ * Returns `undefined` when the content is not parseable JSON or the field
+ * is missing/non-string — callers treat that as "no prior alias to clean".
+ */
+export declare function readAliasKeyFromContent(content: string, ...fieldPath: readonly string[]): string | undefined;
+//# sourceMappingURL=alias-lifecycle.d.ts.map

package/dist/src/alias-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alias-lifecycle.d.ts","sourceRoot":"","sources":["../../src/alias-lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,MAAM,WAAW,mBAAmB;IAClC,oEAAoE;IACpE,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,MAAM,GAAG,SAAS,CAAC;IACzE,kCAAkC;IAClC,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;CACtD;AAED,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,eAAe,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC;;;OAGG;IACH,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,uBAAuB;IACtC,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAChD;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,mBAAmB,EACvB,KAAK,EAAE,sBAAsB,GAC5B,OAAO,CAAC,uBAAuB,CAAC,CAgClC;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CAgB5G"}

package/dist/src/alias-lifecycle.js

@@ -0,0 +1,90 @@
+/**
+ * Stale alias lifecycle cleanup (issue #106).
+ *
+ * Adapters mirror provider records to a canonical path plus lookup aliases
+ * (`by-title/…`, `by-name/…`). Aliases duplicate the canonical bytes
+ * verbatim, and the title-independent `by-id` alias is rewritten on every
+ * ingest — so the bytes sitting at the `by-id` alias path *before* a
+ * re-ingest are a faithful snapshot of the previous record version. That
+ * snapshot is the prior state consumed here: callers read it before
+ * overwriting, derive the candidate alias paths the previous version may
+ * occupy (base + collision variants), and this helper deletes every
+ * candidate that still holds the previous record bytes.
+ *
+ * Content equality is the ownership proof: a candidate is deleted only when
+ * its bytes match `previousContent`. This guarantees we never delete
+ * (a) an alias owned by a different record that happens to share a slug
+ * (collision case), (b) the freshly written alias for the current version
+ * (its bytes are the new content), or (c) anything when the previous
+ * version was never mirrored.
+ *
+ * Relayfile contract: a title change is an alias cleanup, never a record
+ * deletion. Callers must only pass alias paths as candidates — canonical
+ * record paths are never deleted by this helper's callers.
+ *
+ * See also `PriorAliasReader` in `emit-auxiliary` — the same "by-id alias
+ * as prior-state anchor" convention for adapters built on the auxiliary
+ * emitter client. This module is the IO-agnostic deletion side, usable
+ * with both `RelayFileClientLike` and duck-typed `VfsLike` backends.
+ */
+/**
+ * Deletes stale alias files left behind when a record's alias-relevant
+ * field (title/name) changed between ingests. Failures are captured per
+ * path and never thrown — a leftover stale alias is benign, while failing
+ * the surrounding ingest is not.
+ */
+export async function cleanupStaleAliases(io, input) {
+    const result = { deletedPaths: [], errors: [] };
+    const keep = new Set(input.keepPaths ?? []);
+    const seen = new Set();
+    for (const candidate of input.candidatePaths) {
+        if (!candidate || keep.has(candidate) || seen.has(candidate)) {
+            continue;
+        }
+        seen.add(candidate);
+        let existing;
+        try {
+            existing = await io.readFile(candidate);
+        }
+        catch (error) {
+            result.errors.push({ path: candidate, error: formatError(error) });
+            continue;
+        }
+        if (existing === undefined || existing !== input.previousContent) {
+            continue;
+        }
+        try {
+            await io.deleteFile(candidate);
+            result.deletedPaths.push(candidate);
+        }
+        catch (error) {
+            result.errors.push({ path: candidate, error: formatError(error) });
+        }
+    }
+    return result;
+}
+/**
+ * Extracts a top-level string field from mirrored JSON record content.
+ * Returns `undefined` when the content is not parseable JSON or the field
+ * is missing/non-string — callers treat that as "no prior alias to clean".
+ */
+export function readAliasKeyFromContent(content, ...fieldPath) {
+    let value;
+    try {
+        value = JSON.parse(content);
+    }
+    catch {
+        return undefined;
+    }
+    for (const field of fieldPath) {
+        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+            return undefined;
+        }
+        value = value[field];
+    }
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function formatError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=alias-lifecycle.js.map

package/dist/src/alias-lifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"alias-lifecycle.js","sourceRoot":"","sources":["../../src/alias-lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAgCH;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,EAAuB,EACvB,KAA6B;IAE7B,MAAM,MAAM,GAA4B,EAAE,YAAY,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;IACzE,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC;IAC5C,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAE/B,KAAK,MAAM,SAAS,IAAI,KAAK,CAAC,cAAc,EAAE,CAAC;QAC7C,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;YAC7D,SAAS;QACX,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAEpB,IAAI,QAA4B,CAAC;QACjC,IAAI,CAAC;YACH,QAAQ,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;QAC1C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YACnE,SAAS;QACX,CAAC;QAED,IAAI,QAAQ,KAAK,SAAS,IAAI,QAAQ,KAAK,KAAK,CAAC,eAAe,EAAE,CAAC;YACjE,SAAS;QACX,CAAC;QAED,IAAI,CAAC;YACH,MAAM,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;YAC/B,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACtC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QACrE,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,uBAAuB,CAAC,OAAe,EAAE,GAAG,SAA4B;IACtF,IAAI,KAAc,CAAC;IACnB,IAAI,CAAC;QACH,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAC9B,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,KAAK,MAAM,KAAK,IAAI,SAAS,EAAE,CAAC;QAC9B,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACxE,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,KAAK,GAAI,KAAiC,CAAC,KAAK,CAAC,CAAC;IACpD,CAAC;IAED,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;AAC3E,CAAC;AAED,SAAS,WAAW,CAAC,KAAc;IACjC,OAAO,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAChE,CAAC"}

package/dist/src/http/index.d.ts

@@ -0,0 +1,3 @@
+export { RetryExhaustedError, executeWithRetry, fetchWithRetry, isTransientNetworkError, parseRetryAfterMs, withProxyRetry, } from './retry.js';
+export type { FetchRetryOptions, ProxyCapable, ProxyResponseLike, RetryOptions, RetryRequestInit, RetryResponseLike, } from './retry.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/http/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/http/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,cAAc,EACd,uBAAuB,EACvB,iBAAiB,EACjB,cAAc,GACf,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,iBAAiB,EACjB,YAAY,EACZ,iBAAiB,EACjB,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,YAAY,CAAC"}

package/dist/src/http/index.js

@@ -0,0 +1,2 @@
+export { RetryExhaustedError, executeWithRetry, fetchWithRetry, isTransientNetworkError, parseRetryAfterMs, withProxyRetry, } from './retry.js';
+//# sourceMappingURL=index.js.map

package/dist/src/http/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/http/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,cAAc,EACd,uBAAuB,EACvB,iBAAiB,EACjB,cAAc,GACf,MAAM,YAAY,CAAC"}

package/dist/src/http/retry.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Shared HTTP rate-limit / retry helpers.
+ *
+ * Adapters in this repo talk to providers through one of two transports:
+ *
+ * 1. A `fetch`-shaped client (Notion's raw token path, the X search client).
+ *    Wrap those call sites with {@link fetchWithRetry}.
+ * 2. A relayfile `ConnectionProvider.proxy()` call. Wrap the provider with
+ *    {@link withProxyRetry} at the call site:
+ *
+ *        const response = await withProxyRetry(provider).proxy({ ... });
+ *
+ * Both honor `Retry-After` (delta-seconds and HTTP-date forms), retry on 429,
+ * 5xx, and transient network errors with exponential backoff plus jitter, and
+ * never retry non-idempotent requests (POST/PATCH) unless the caller opts in
+ * via `retryNonIdempotent: true`.
+ *
+ * Exhaustion semantics:
+ * - If the final attempt produced an HTTP response, that response is returned
+ *   so existing status handling in adapters keeps working unchanged. Callers
+ *   that want a typed failure instead can pass
+ *   `throwOnExhaustedRetryableStatus: true` to receive a
+ *   {@link RetryExhaustedError}.
+ * - If the final attempt failed with a transient network error, a
+ *   {@link RetryExhaustedError} is thrown with the underlying error as
+ *   `cause`.
+ */
+export interface RetryOptions {
+    /** Total attempts, including the first one. Default 3. */
+    maxAttempts?: number;
+    /** Give up once this much wall-clock time has been spent. Default 30s. */
+    maxElapsedMs?: number;
+    /** Base delay before the first retry. Default 250ms. */
+    initialDelayMs?: number;
+    /** Upper bound for a single computed backoff delay. Default 10s. */
+    maxDelayMs?: number;
+    /** Exponential growth factor. Default 2. */
+    backoffFactor?: number;
+    /**
+     * Retry POST/PATCH requests too. Default false: only idempotent methods
+     * (GET, HEAD, OPTIONS, PUT, DELETE, TRACE) are retried.
+     */
+    retryNonIdempotent?: boolean;
+    /** Status classifier. Default: 429 or any 5xx is retryable. */
+    isRetryableStatus?: (status: number) => boolean;
+    /** Error classifier. Default: {@link isTransientNetworkError}. */
+    isRetryableError?: (error: unknown) => boolean;
+    /**
+     * Throw a {@link RetryExhaustedError} instead of returning the final
+     * response when attempts run out while the response is still retryable
+     * (e.g. a persistent 429). Default false.
+     */
+    throwOnExhaustedRetryableStatus?: boolean;
+    /** Abort retries (and in-flight sleeps) when this signal fires. */
+    signal?: AbortSignal;
+    /** Injectable sleep, for tests. */
+    sleep?: (ms: number) => Promise<void>;
+    /** Injectable jitter source, for tests. Must return [0, 1). */
+    random?: () => number;
+    /** Injectable clock, for tests. Returns epoch milliseconds. */
+    now?: () => number;
+}
+/** Typed error surfaced when retries are exhausted. */
+export declare class RetryExhaustedError extends Error {
+    readonly code = "RETRY_EXHAUSTED";
+    /** Number of attempts that were made. */
+    readonly attempts: number;
+    /** Wall-clock time spent across all attempts, in milliseconds. */
+    readonly elapsedMs: number;
+    /** Status of the final response, when the final attempt got one. */
+    readonly lastStatus?: number;
+    constructor(message: string, details: {
+        attempts: number;
+        elapsedMs: number;
+        lastStatus?: number;
+        cause?: unknown;
+    });
+}
+/** True for errors that look like transient network failures worth retrying. */
+export declare function isTransientNetworkError(error: unknown): boolean;
+/**
+ * Parse a `Retry-After` header value: either delta-seconds or an HTTP-date.
+ * Returns the wait in milliseconds, or `undefined` when unparseable.
+ */
+export declare function parseRetryAfterMs(value: string | null | undefined, nowMs: number): number | undefined;
+type HeadersLike = {
+    get(name: string): string | null;
+} | Record<string, string | string[] | undefined>;
+interface AttemptInspection {
+    retryable: boolean;
+    status: number;
+    retryAfterMs?: number;
+}
+/**
+ * Core retry loop shared by {@link fetchWithRetry} and {@link withProxyRetry}.
+ *
+ * `attempt` performs one request; `inspect` classifies its result. Thrown
+ * errors are retried only when `isRetryableError` says so and the request is
+ * idempotent (or `retryNonIdempotent` is set).
+ */
+export declare function executeWithRetry<R>(args: {
+    attempt: () => Promise<R>;
+    inspect: (result: R) => AttemptInspection;
+    idempotent: boolean;
+    describe: string;
+    options: RetryOptions;
+}): Promise<R>;
+/** Minimal response surface required by {@link fetchWithRetry}. */
+export interface RetryResponseLike {
+    status: number;
+    headers?: HeadersLike;
+}
+/** Permissive `RequestInit` so any fetch implementation can be wrapped. */
+export interface RetryRequestInit {
+    method?: string;
+    signal?: AbortSignal | null;
+    [key: string]: unknown;
+}
+export interface FetchRetryOptions<R extends RetryResponseLike> extends RetryOptions {
+    /** Fetch implementation. Defaults to `globalThis.fetch`. */
+    fetch?: (input: string | URL, init?: RetryRequestInit) => Promise<R>;
+    /**
+     * Force the idempotency classification instead of deriving it from
+     * `init.method`. Useful for POST endpoints that are semantically reads.
+     */
+    idempotent?: boolean;
+}
+/**
+ * `fetch` with rate-limit aware retries.
+ *
+ * Retries 429/5xx responses (honoring `Retry-After`) and transient network
+ * errors with exponential backoff plus jitter. Non-idempotent methods
+ * (POST/PATCH) are never retried unless the caller opts in via
+ * `retryNonIdempotent` or `idempotent: true`.
+ *
+ * Returns the final response even when it is still an error status, unless
+ * `throwOnExhaustedRetryableStatus` is set; network-error exhaustion throws a
+ * {@link RetryExhaustedError}.
+ */
+export declare function fetchWithRetry<R extends RetryResponseLike = Response>(input: string | URL, init?: RetryRequestInit, options?: FetchRetryOptions<R>): Promise<R>;
+/** Minimal proxy response surface required by {@link withProxyRetry}. */
+export interface ProxyResponseLike {
+    status: number;
+    headers?: Record<string, string>;
+}
+/**
+ * Minimal provider surface required by {@link withProxyRetry}. The `never`
+ * parameter type makes any concrete `proxy(request)` method assignable here
+ * (method parameters are checked bivariantly).
+ */
+export interface ProxyCapable {
+    proxy(request: never): Promise<ProxyResponseLike>;
+}
+/**
+ * Wrap a `ConnectionProvider`-shaped object so `proxy()` retries 429/5xx
+ * responses (honoring `Retry-After`) and transient network errors. The
+ * wrapper preserves the provider's full type, so call sites change from
+ * `provider.proxy({...})` to `withProxyRetry(provider).proxy({...})`.
+ *
+ * POST/PATCH requests pass through without retries unless
+ * `retryNonIdempotent` is set.
+ */
+export declare function withProxyRetry<P extends ProxyCapable>(provider: P, options?: RetryOptions): P;
+export {};
+//# sourceMappingURL=retry.d.ts.map

package/dist/src/http/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../../src/http/retry.ts"],"names":[],"mappings":"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"}