@prospera/eprospera-cli 0.1.0

package/dist/completions/eprospera.bash

@@ -0,0 +1,7 @@
+# Generated by scripts/gen-completions.ts.
+_eprospera_completions() {
+  local cur
+  cur="${COMP_WORDS[COMP_CWORD]}"
+  COMPREPLY=( $(compgen -W 'eprospera entity verify search get documents application list create pay watch me profile residency id-verification auth login whoami logout config set unset completion bash zsh fish powershell schema --json --raw --fields --quiet --yes -y --api-key --dry-run --help -h --version --no-auto-json --skip-scope-check --file --coupon --timeout --initial-interval --max-interval --agent-key --standard-key --scopes' -- "$cur") )
+}
+complete -F _eprospera_completions eprospera

package/dist/completions/eprospera.fish

@@ -0,0 +1,2 @@
+# Generated by scripts/gen-completions.ts.
+complete -c eprospera -f -a 'eprospera entity verify search get documents application list create pay watch me profile residency id-verification auth login whoami logout config set unset completion bash zsh fish powershell schema --json --raw --fields --quiet --yes -y --api-key --dry-run --help -h --version --no-auto-json --skip-scope-check --file --coupon --timeout --initial-interval --max-interval --agent-key --standard-key --scopes'

package/dist/completions/eprospera.ps1

@@ -0,0 +1,7 @@
+# Generated by scripts/gen-completions.ts.
+Register-ArgumentCompleter -Native -CommandName eprospera -ScriptBlock {
+  param($wordToComplete)
+  'eprospera', 'entity', 'verify', 'search', 'get', 'documents', 'application', 'list', 'create', 'pay', 'watch', 'me', 'profile', 'residency', 'id-verification', 'auth', 'login', 'whoami', 'logout', 'config', 'set', 'unset', 'completion', 'bash', 'zsh', 'fish', 'powershell', 'schema', '--json', '--raw', '--fields', '--quiet', '--yes', '-y', '--api-key', '--dry-run', '--help', '-h', '--version', '--no-auto-json', '--skip-scope-check', '--file', '--coupon', '--timeout', '--initial-interval', '--max-interval', '--agent-key', '--standard-key', '--scopes' | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+  }
+}

package/dist/completions/eprospera.zsh

@@ -0,0 +1,4 @@
+#compdef eprospera
+# Generated by scripts/gen-completions.ts.
+local -a commands=("eprospera" "entity" "verify" "search" "get" "documents" "application" "list" "create" "pay" "watch" "me" "profile" "residency" "id-verification" "auth" "login" "whoami" "logout" "config" "set" "unset" "completion" "bash" "zsh" "fish" "powershell" "schema" "--json" "--raw" "--fields" "--quiet" "--yes" "-y" "--api-key" "--dry-run" "--help" "-h" "--version" "--no-auto-json" "--skip-scope-check" "--file" "--coupon" "--timeout" "--initial-interval" "--max-interval" "--agent-key" "--standard-key" "--scopes")
+_describe 'eprospera command' commands

package/dist/src/api/client.d.ts

@@ -0,0 +1,29 @@
+import { type Client } from "openapi-fetch";
+import type { paths } from "./generated.js";
+export declare const PRODUCTION_BASE_URL = "https://portal.eprospera.com";
+export declare const STAGING_BASE_URL = "https://staging-portal.eprospera.com";
+export declare const DEFAULT_MAX_RETRIES = 3;
+export type TokenProvider = string | (() => string | Promise<string | undefined>) | undefined;
+export type RetryOptions = {
+    maxRetries?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    random?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+};
+export type ApiClientOptions = {
+    baseUrl?: string;
+    env?: NodeJS.ProcessEnv;
+    token?: TokenProvider;
+    fetch?: (input: Request) => Promise<Response>;
+    idempotencyKey?: () => string;
+    retry?: RetryOptions;
+};
+export type EProsperaApiClient = {
+    baseUrl: string;
+    raw: Client<paths>;
+};
+export declare function resolveBaseUrl(env?: NodeJS.ProcessEnv): string;
+export declare function createApiClient(options?: ApiClientOptions): EProsperaApiClient;
+export declare function parseRetryAfter(value: string | null): number | undefined;
+export declare function computeRetryDelayMs(attempt: number, response: Response, options: Required<Pick<RetryOptions, "baseDelayMs" | "maxDelayMs" | "random">>): number;

package/dist/src/api/client.js

@@ -0,0 +1,131 @@
+import { randomUUID } from "node:crypto";
+import createClient from "openapi-fetch";
+import { apiErrorFromResponse, networkErrorFromCause } from "./errors.js";
+export const PRODUCTION_BASE_URL = "https://portal.eprospera.com";
+export const STAGING_BASE_URL = "https://staging-portal.eprospera.com";
+export const DEFAULT_MAX_RETRIES = 3;
+export function resolveBaseUrl(env = process.env) {
+    const explicitBaseUrl = env.EPROSPERA_BASE_URL?.trim();
+    if (explicitBaseUrl) {
+        return trimTrailingSlash(explicitBaseUrl);
+    }
+    if (env.EPROSPERA_ENV === "staging") {
+        return STAGING_BASE_URL;
+    }
+    return PRODUCTION_BASE_URL;
+}
+export function createApiClient(options = {}) {
+    const baseUrl = trimTrailingSlash(options.baseUrl ?? resolveBaseUrl(options.env));
+    const fetchWithRetry = createRetryingFetch(options.fetch ?? globalThis.fetch, options.retry);
+    const raw = createClient({
+        baseUrl,
+        fetch: fetchWithRetry,
+    });
+    raw.use(createAuthAndIdempotencyMiddleware({
+        token: options.token,
+        idempotencyKey: options.idempotencyKey ?? randomUUID,
+    }), createErrorMiddleware());
+    return { baseUrl, raw };
+}
+export function parseRetryAfter(value) {
+    if (!value) {
+        return undefined;
+    }
+    const seconds = Number(value);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+        return seconds * 1000;
+    }
+    const date = Date.parse(value);
+    if (!Number.isNaN(date)) {
+        return Math.max(0, date - Date.now());
+    }
+    return undefined;
+}
+export function computeRetryDelayMs(attempt, response, options) {
+    const retryAfterMs = parseRetryAfter(response.headers.get("Retry-After"));
+    if (retryAfterMs !== undefined) {
+        return retryAfterMs;
+    }
+    const cap = Math.min(options.maxDelayMs, options.baseDelayMs * 2 ** attempt);
+    return Math.floor(options.random() * cap);
+}
+function createAuthAndIdempotencyMiddleware(options) {
+    return {
+        async onRequest({ request }) {
+            const headers = new Headers(request.headers);
+            const token = await resolveToken(options.token);
+            if (token) {
+                headers.set("Authorization", `Bearer ${token}`);
+            }
+            if (requiresIdempotencyKey(request) && !headers.has("Idempotency-Key")) {
+                headers.set("Idempotency-Key", options.idempotencyKey());
+            }
+            return new Request(request, { headers });
+        },
+    };
+}
+function createErrorMiddleware() {
+    return {
+        async onResponse({ response }) {
+            if (response.ok) {
+                return undefined;
+            }
+            throw apiErrorFromResponse(response, await readResponseBody(response.clone()));
+        },
+        onError({ error }) {
+            return networkErrorFromCause(error);
+        },
+    };
+}
+function createRetryingFetch(fetchImpl, retry = {}) {
+    const retryOptions = {
+        maxRetries: retry.maxRetries ?? DEFAULT_MAX_RETRIES,
+        baseDelayMs: retry.baseDelayMs ?? 250,
+        maxDelayMs: retry.maxDelayMs ?? 4_000,
+        random: retry.random ?? Math.random,
+        sleep: retry.sleep ?? sleep,
+    };
+    return async (request) => {
+        for (let attempt = 0;; attempt += 1) {
+            const response = await fetchImpl(request.clone());
+            if (!shouldRetry(response) || attempt >= retryOptions.maxRetries) {
+                return response;
+            }
+            await retryOptions.sleep(computeRetryDelayMs(attempt, response, retryOptions));
+        }
+    };
+}
+async function readResponseBody(response) {
+    const text = await response.text();
+    if (!text) {
+        return null;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+async function resolveToken(provider) {
+    if (typeof provider === "function") {
+        return provider();
+    }
+    return provider;
+}
+function shouldRetry(response) {
+    return response.status === 429 || response.status >= 500;
+}
+function requiresIdempotencyKey(request) {
+    if (request.method !== "POST") {
+        return false;
+    }
+    return new URL(request.url).pathname.startsWith("/api/v1/legal_entity_applications");
+}
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/, "");
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=client.js.map

package/dist/src/api/errors.d.ts

@@ -0,0 +1,11 @@
+import { type ExitCode, ExitError } from "../errors.js";
+export type UpstreamErrorBody = {
+    error?: unknown;
+    error_description?: string;
+    errorDescription?: string;
+    message?: string;
+    details?: unknown;
+};
+export declare function mapHttpStatusToExitCode(status: number): ExitCode;
+export declare function apiErrorFromResponse(response: Response, body: unknown): ExitError;
+export declare function networkErrorFromCause(error: unknown): ExitError;

package/dist/src/api/errors.js

@@ -0,0 +1,125 @@
+import { ExitCodes, ExitError } from "../errors.js";
+export function mapHttpStatusToExitCode(status) {
+    if (status === 400 || status === 422) {
+        return ExitCodes.Validation;
+    }
+    if (status === 401) {
+        return ExitCodes.Authentication;
+    }
+    if (status === 403) {
+        return ExitCodes.Authorization;
+    }
+    if (status === 404) {
+        return ExitCodes.NotFound;
+    }
+    if (status === 409) {
+        return ExitCodes.Conflict;
+    }
+    if (status === 408 || status === 504) {
+        return ExitCodes.Timeout;
+    }
+    if (status === 429) {
+        return ExitCodes.RateLimit;
+    }
+    return ExitCodes.Generic;
+}
+export function apiErrorFromResponse(response, body) {
+    const upstream = normalizeUpstreamError(body);
+    return new ExitError({
+        code: upstream.code ?? defaultCodeForStatus(response.status),
+        message: upstream.message ?? defaultMessageForStatus(response.status),
+        exitCode: mapHttpStatusToExitCode(response.status),
+        httpStatus: response.status,
+        details: upstream.details ?? null,
+    });
+}
+export function networkErrorFromCause(error) {
+    const message = error instanceof Error ? error.message : "Network request failed";
+    const isTimeout = error instanceof DOMException
+        ? error.name === "AbortError" || error.name === "TimeoutError"
+        : error instanceof Error && error.name === "AbortError";
+    return new ExitError({
+        code: isTimeout ? "TIMEOUT" : "NETWORK_ERROR",
+        message,
+        exitCode: isTimeout ? ExitCodes.Timeout : ExitCodes.Generic,
+        cause: error,
+    });
+}
+function normalizeUpstreamError(body) {
+    if (!isRecord(body)) {
+        return {};
+    }
+    const { error } = body;
+    if (isRecord(error)) {
+        return {
+            code: stringValue(error.code) ?? stringValue(error.error),
+            message: stringValue(error.message) ??
+                stringValue(error.error_description) ??
+                stringValue(error.errorDescription),
+            details: "details" in error ? error.details : body.details,
+        };
+    }
+    return {
+        code: stringValue(error),
+        message: stringValue(body.error_description) ??
+            stringValue(body.errorDescription) ??
+            stringValue(body.message) ??
+            stringValue(error),
+        details: body.details,
+    };
+}
+function defaultCodeForStatus(status) {
+    if (status === 400 || status === 422) {
+        return "VALIDATION_ERROR";
+    }
+    if (status === 401) {
+        return "UNAUTHENTICATED";
+    }
+    if (status === 403) {
+        return "FORBIDDEN";
+    }
+    if (status === 404) {
+        return "NOT_FOUND";
+    }
+    if (status === 409) {
+        return "CONFLICT";
+    }
+    if (status === 429) {
+        return "RATE_LIMITED";
+    }
+    if (status === 408 || status === 504) {
+        return "TIMEOUT";
+    }
+    return "API_ERROR";
+}
+function defaultMessageForStatus(status) {
+    if (status === 400 || status === 422) {
+        return "The API rejected the request as invalid.";
+    }
+    if (status === 401) {
+        return "Authentication failed.";
+    }
+    if (status === 403) {
+        return "The credential is not authorized for this operation.";
+    }
+    if (status === 404) {
+        return "The requested resource was not found.";
+    }
+    if (status === 409) {
+        return "The request conflicts with the current resource state.";
+    }
+    if (status === 429) {
+        return "The API rate limit was exceeded.";
+    }
+    if (status === 408 || status === 504) {
+        return "The request timed out.";
+    }
+    return `The API returned HTTP ${status}.`;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+//# sourceMappingURL=errors.js.map