adapty 0.8.4 → 0.8.6

package/dist/sdk/core/http/url.js

@@ -0,0 +1,19 @@
+export const buildUrl = (baseUrl, path, query, trailingSlash) => {
+    // A relative path against a base ending in a slash keeps a prefix like /api/v1/developer
+    const base = baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
+    let relative = path.replace(/^\/+/, '');
+    if (trailingSlash && relative !== '' && !relative.endsWith('/')) {
+        relative += '/';
+    }
+    const url = new URL(relative, base);
+    for (const [key, value] of Object.entries(query ?? {})) {
+        if (value === undefined) {
+            continue;
+        }
+        const items = typeof value === 'object' ? value : [value];
+        for (const item of items) {
+            url.searchParams.append(key, String(item));
+        }
+    }
+    return url.toString();
+};

package/dist/sdk/core/session.d.ts

@@ -0,0 +1,20 @@
+export type SessionUser = {
+    email: string;
+    name: string;
+};
+export type Session = {
+    token: string;
+    user?: SessionUser | undefined;
+};
+/**
+ * Where the session lives is a port, not a path: a keychain, a CI secret store or an in-memory
+ * store for an MCP server plug into this same type without touching a command.
+ */
+export type SessionStore = {
+    clear(): Promise<void>;
+    load(): Promise<Session | undefined>;
+    readonly path: string;
+    save(session: Session): Promise<void>;
+};
+/** A file under a directory the adapter picks: the sdk touches neither HOME nor process.env. */
+export declare const createFileSessionStore: (dir: string) => SessionStore;

package/dist/sdk/core/session.js

@@ -0,0 +1,69 @@
+import { chmod, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { StorageError } from './errors.js';
+/**
+ * The file and field names the published CLI already writes. A rename would log every existing
+ * user out, so the on-disk contract stays `{ "access_token", "user": { "email", "name" } }`.
+ */
+const FILE_NAME = 'config.json';
+/** A file under a directory the adapter picks: the sdk touches neither HOME nor process.env. */
+export const createFileSessionStore = (dir) => {
+    const path = join(dir, FILE_NAME);
+    return {
+        path,
+        clear: async () => {
+            await rm(path, { force: true });
+        },
+        load: async () => {
+            let raw;
+            try {
+                raw = await readFile(path, 'utf8');
+            }
+            catch (error) {
+                if (isErrno(error, 'ENOENT')) {
+                    return undefined;
+                }
+                // No permission, a broken disk: not ours to paper over as "not logged in"
+                throw error;
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch (error) {
+                throw new StorageError(`Session file is corrupted: ${path}`, path, { cause: error });
+            }
+            // An unknown shape is most likely a file from another version: asking for a fresh
+            // login beats failing every command.
+            return toSession(parsed);
+        },
+        save: async (session) => {
+            await mkdir(dir, { recursive: true, mode: 0o700 });
+            await writeFile(path, `${JSON.stringify(toStored(session), null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+            // `mode` above applies only when the file is created; an existing 0644 one (a hand
+            // edit, a restored backup) would leave the token readable for everyone on the machine.
+            await chmod(path, 0o600);
+        },
+    };
+};
+const toStored = (session) => (session.user === undefined
+    ? { access_token: session.token }
+    : { access_token: session.token, user: session.user });
+/** Not a full schema check: only the minimum the rest of the code leans on. */
+const toSession = (parsed) => {
+    const record = asRecord(parsed);
+    if (record === undefined || typeof record.access_token !== 'string' || record.access_token === '') {
+        return undefined;
+    }
+    const user = toUser(record.user);
+    return user === undefined ? { token: record.access_token } : { token: record.access_token, user };
+};
+const toUser = (value) => {
+    const record = asRecord(value);
+    if (record === undefined || typeof record.email !== 'string' || typeof record.name !== 'string') {
+        return undefined;
+    }
+    return { email: record.email, name: record.name };
+};
+const asRecord = (value) => (typeof value === 'object' && value !== null ? value : undefined);
+const isErrno = (error, code) => error instanceof Error && 'code' in error && error.code === code;

package/dist/sdk/core/testing.d.ts

@@ -0,0 +1,25 @@
+import type { Clock } from './clock.js';
+export type FakeClock = {
+    advance(ms: number): void;
+    /** Durations of every sleep, in order. */
+    readonly sleeps: number[];
+} & Clock;
+/** A clock whose sleep moves time forward instantly. */
+export declare const createFakeClock: (start?: number) => FakeClock;
+export type ScriptedResponse = {
+    body?: unknown;
+    headers?: Record<string, string>;
+    status?: number;
+};
+export type RecordedCall = {
+    body: string | undefined;
+    headers: Headers;
+    method: string;
+    url: string;
+};
+export type ScriptedFetch = {
+    calls: RecordedCall[];
+    fetch: typeof globalThis.fetch;
+};
+/** Answers with the scripted responses in order; an Error in the script is thrown, as fetch would. */
+export declare const createScriptedFetch: (script: readonly (Error | ScriptedResponse)[]) => ScriptedFetch;

package/dist/sdk/core/testing.js

@@ -0,0 +1,46 @@
+/** Fakes for the sdk and its consumers: cli, MCP and any other adapter test with the same tools. */
+import { throwIfAborted } from './clock.js';
+/** A clock whose sleep moves time forward instantly. */
+export const createFakeClock = (start = 0) => {
+    let time = start;
+    const sleeps = [];
+    return {
+        sleeps,
+        now: () => time,
+        advance: (ms) => {
+            time += ms;
+        },
+        sleep: (ms, signal) => {
+            throwIfAborted(signal);
+            sleeps.push(ms);
+            time += ms;
+            return Promise.resolve();
+        },
+    };
+};
+/** Answers with the scripted responses in order; an Error in the script is thrown, as fetch would. */
+export const createScriptedFetch = (script) => {
+    const queue = [...script];
+    const calls = [];
+    const fetch = (input, init) => {
+        calls.push({
+            body: typeof init?.body === 'string' ? init.body : undefined,
+            headers: new Headers(init?.headers),
+            method: init?.method ?? 'GET',
+            url: String(input instanceof Request ? input.url : input),
+        });
+        const next = queue.shift();
+        if (next === undefined) {
+            return Promise.reject(new Error(`scripted fetch: no response for call #${calls.length}`));
+        }
+        if (next instanceof Error) {
+            return Promise.reject(next);
+        }
+        // ResponseInit.headers is readonly in @types/node, so the init is built in one go
+        const status = next.status ?? 200;
+        const responseInit = next.headers ? { headers: next.headers, status } : { status };
+        const body = next.body === undefined ? null : JSON.stringify(next.body);
+        return Promise.resolve(new Response(body, responseInit));
+    };
+    return { calls, fetch };
+};

package/dist/sdk/core/validation.d.ts

@@ -0,0 +1,10 @@
+import type { Issue } from './errors.js';
+/**
+ * Turns a rule's problems into a throw — the only place that does. Rules return lists instead of
+ * throwing, so a table test walks them without an environment and the user sees every problem at
+ * once.
+ *
+ * Call it from an `async` method: a broken rule then arrives as a rejected promise, like a network
+ * failure, instead of a throw the caller has to handle separately.
+ */
+export declare const assertValid: (issues: readonly Issue[]) => void;

package/dist/sdk/core/validation.js

@@ -0,0 +1,14 @@
+import { ValidationError } from './errors.js';
+/**
+ * Turns a rule's problems into a throw — the only place that does. Rules return lists instead of
+ * throwing, so a table test walks them without an environment and the user sees every problem at
+ * once.
+ *
+ * Call it from an `async` method: a broken rule then arrives as a rejected promise, like a network
+ * failure, instead of a throw the caller has to handle separately.
+ */
+export const assertValid = (issues) => {
+    if (issues.length > 0) {
+        throw new ValidationError(issues);
+    }
+};