@oxy.so/core 1.18.1 → 3.0.0

package/dist/cjs/OxyServices.js

@@ -1,72 +1,275 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.oxyClient = exports.OXY_API_URL = exports.OXY_CLOUD_URL = exports.ServiceAssetMetadataError = exports.OxyAuthenticationTimeoutError = exports.OxyAuthenticationError = exports.AssetUrlResolutionError = exports.OxyServices = void 0;
-const OxyServices_errors_1 = require("./OxyServices.errors");
-Object.defineProperty(exports, "AssetUrlResolutionError", { enumerable: true, get: function () { return OxyServices_errors_1.AssetUrlResolutionError; } });
-Object.defineProperty(exports, "OxyAuthenticationError", { enumerable: true, get: function () { return OxyServices_errors_1.OxyAuthenticationError; } });
-Object.defineProperty(exports, "OxyAuthenticationTimeoutError", { enumerable: true, get: function () { return OxyServices_errors_1.OxyAuthenticationTimeoutError; } });
-Object.defineProperty(exports, "ServiceAssetMetadataError", { enumerable: true, get: function () { return OxyServices_errors_1.ServiceAssetMetadataError; } });
-// Import mixin composition helper
-const mixins_1 = require("./mixins");
+exports.OxyServices = exports.OXY_API_URL = exports.OXY_CLOUD_URL = void 0;
 /**
- * OxyServices - Unified client library for interacting with the Oxy API
- *
- * This class provides all API functionality in one simple, easy-to-use interface.
+ * `OxyServices` — the Oxy API client.
  *
- * ## Architecture
- * - **HttpService**: Unified HTTP service handling authentication, caching, deduplication, queuing, and retry
- * - **OxyServices**: Provides high-level API methods
+ * ```ts
+ * import { OxyServices } from '@oxy.so/core';
  *
- * ## Mixin Composition
- * The class is composed using TypeScript mixins for better code organization:
- * - **Base**: Core infrastructure (HTTP client, request management, error handling)
- * - **Auth**: Authentication and session management
- * - **User**: User profiles, follow, notifications
- * - **Privacy**: Blocked and restricted users
- * - **Language**: Language detection and metadata
- * - **Payment**: Payment processing
- * - **Reputation**: Reputation system (Oxy Trust)
- * - **Assets**: File upload and asset management
- * - **Accounts**: Unified account graph (tree, members, roles, bot credentials)
- *   and the applications owned within it (Application = OAuth client)
- * - **Connected apps**: OAuth-consent surface (public app identity, grants)
- * - **Location**: Location-based features
- * - **Analytics**: Analytics tracking
- * - **Devices**: Device management
- * - **Utility**: Utility methods and Express middleware
+ * const oxy = new OxyServices({ baseURL: 'https://api.oxy.so' });
  *
- * @example
- * ```typescript
- * const oxy = new OxyServices({
- *   baseURL: 'https://api.oxy.so',
- *   cloudURL: 'https://cloud.oxy.so'
- * });
+ * const me = await oxy.users.me();
+ * const people = await oxy.users.getMany(ids);
+ * const { id } = await oxy.assets.upload(file);
+ * await oxy.follows.follow(userId);
  * ```
+ *
+ * The client itself is small — the transport (`request`, `http`), the response
+ * cache, and `createLinkedClient` for an app's own backend. Everything else is a
+ * namespace (`oxy.users`, `oxy.assets`, …), created on first access and kept for
+ * the client's life.
+ *
+ * Servers use `OxyServer` from `@oxy.so/core/server`: the same client plus the
+ * service-token lane and the Express / Socket.IO middleware.
  */
-// Compose all mixins into the final OxyServices class. The composed runtime
-// class augments OxyServicesBase with every mixin's methods (see mixins/index.ts).
-// Statically, TypeScript sees this as a constructor producing OxyServicesBase;
-// the additional methods are exposed via interface merging on `OxyServices` below.
-const OxyServicesComposed = (0, mixins_1.composeOxyServices)();
-// Export as a named class to avoid TypeScript issues with anonymous class types.
-// We extend the composed constructor directly — its public surface is broadened
-// to the full mixin set via the interface declaration that follows.
-class OxyServices extends OxyServicesComposed {
+const HttpService_1 = require("./HttpService");
+const OxyServices_errors_1 = require("./OxyServices.errors");
+const session_1 = require("./api/session");
+const auth_1 = require("./api/auth");
+const users_1 = require("./api/users");
+const follows_1 = require("./api/follows");
+const privacy_1 = require("./api/privacy");
+const notifications_1 = require("./api/notifications");
+const assets_1 = require("./api/assets");
+const identity_1 = require("./api/identity");
+const accounts_1 = require("./api/accounts");
+const apps_1 = require("./api/apps");
+const linkedAccounts_1 = require("./api/linkedAccounts");
+const agency_1 = require("./api/agency");
+const store_1 = require("./api/store");
+const billing_1 = require("./api/billing");
+const reputation_1 = require("./api/reputation");
+const civic_1 = require("./api/civic");
+const nodes_1 = require("./api/nodes");
+const devices_1 = require("./api/devices");
+const topics_1 = require("./api/topics");
+const appData_1 = require("./api/appData");
+const contacts_1 = require("./api/contacts");
+/** Default Oxy Cloud URL — used when no `cloudURL` is given. */
+exports.OXY_CLOUD_URL = 'https://cloud.oxy.so';
+/** Default Oxy API URL. */
+exports.OXY_API_URL = 'https://api.oxy.so';
+class OxyServices {
     constructor(config) {
-        super(config);
+        /** The response cache (GETs only, identity-scoped). */
+        this.cache = {
+            /** Drop every cached response. */
+            clear: () => this.http.clearCache(),
+            /** Drop one cached response by key (`GET:/path`), every identity's variant. */
+            delete: (key) => this.http.clearCacheEntry(key),
+            /** Drop every cached response whose key starts with `prefix`; returns how many. */
+            deletePrefix: (prefix) => this.http.clearCacheByPrefix(prefix),
+            stats: () => this.http.getCacheStats(),
+        };
+        if (!config || typeof config !== 'object') {
+            throw new Error('OxyConfig is required');
+        }
+        this.config = config;
+        this.cloudURL = config.cloudURL || exports.OXY_CLOUD_URL;
+        this.http = new HttpService_1.HttpService(config);
+        this.context = {
+            oxy: this,
+            http: this.http,
+            request: (method, url, data, options) => this.request(method, url, data, options),
+            service: null,
+        };
+    }
+    /** The Oxy API origin this client talks to. */
+    get baseURL() {
+        return this.http.getBaseURL();
+    }
+    /**
+     * One authenticated request to the Oxy API — the primitive every namespace is
+     * built on, for the routes no namespace covers yet. GET sends `data` as the
+     * query string, every other method as the body. Rejects with `OxyApiError`.
+     */
+    async request(method, url, data, options = {}) {
+        try {
+            return await this.http.request({
+                method,
+                url,
+                data: method !== 'GET' ? data : undefined,
+                params: method === 'GET' ? data : undefined,
+                ...options,
+            });
+        }
+        catch (error) {
+            throw (0, OxyServices_errors_1.toOxyApiError)(error);
+        }
+    }
+    /** `GET /health`. */
+    async health() {
+        return this.request('GET', '/health', undefined, { cache: false, retry: false, timeout: 5000 });
+    }
+    /**
+     * An HTTP client for an app's own backend (e.g. `https://api.syra.fm`) that
+     * shares this client's session: its bearer follows this session's token and
+     * its 401 refresh delegates here.
+     *
+     * GET caching is OFF by default: the SDK cannot invalidate another backend's
+     * resources, so caching there belongs to the consumer's own layer (React
+     * Query). Pass `enableCache: true` to opt in.
+     */
+    createLinkedClient(config) {
+        const client = new HttpService_1.HttpService({ ...config, enableCache: config.enableCache ?? false });
+        const syncToken = (accessToken) => {
+            const current = client.getAccessToken();
+            if (accessToken) {
+                if (current !== accessToken)
+                    client.setTokens(accessToken);
+                return;
+            }
+            if (current)
+                client.clearTokens();
+        };
+        syncToken(this.http.getAccessToken());
+        const unsubscribe = this.http.addTokenChangeListener(syncToken);
+        client.setAccessTokenProvider(() => this.http.getAccessToken());
+        client.setAuthRefreshHandler(async (reason) => {
+            const refreshed = await this.http.refreshAccessToken(reason);
+            if (!refreshed)
+                return null;
+            syncToken(refreshed);
+            return refreshed;
+        });
+        return {
+            client,
+            dispose: () => {
+                unsubscribe();
+                client.setAuthRefreshHandler(null);
+                client.setAccessTokenProvider(null);
+                client.clearTokens();
+            },
+        };
+    }
+    /** Release this client: its cache stops being swept and its session ends. */
+    dispose() {
+        this.http.dispose();
+    }
+    /** This client's auth state (token, user id) and its server session. */
+    get session() {
+        if (!this._session)
+            this._session = new session_1.SessionApi(this.context);
+        return this._session;
+    }
+    /** Signing in, signing up, and the account's credentials. */
+    get auth() {
+        if (!this._auth)
+            this._auth = new auth_1.AuthApi(this.context);
+        return this._auth;
+    }
+    /** People and their profiles. */
+    get users() {
+        if (!this._users)
+            this._users = new users_1.UsersApi(this.context);
+        return this._users;
+    }
+    /** The follow graph: people and every other followable target. */
+    get follows() {
+        if (!this._follows)
+            this._follows = new follows_1.FollowsApi(this.context);
+        return this._follows;
+    }
+    /** Privacy settings, blocks and restrictions. */
+    get privacy() {
+        if (!this._privacy)
+            this._privacy = new privacy_1.PrivacyApi(this.context);
+        return this._privacy;
+    }
+    /** The in-app inbox and push tokens. */
+    get notifications() {
+        if (!this._notifications)
+            this._notifications = new notifications_1.NotificationsApi(this.context);
+        return this._notifications;
+    }
+    /** Files: upload, link, URLs, content. */
+    get assets() {
+        if (!this._assets)
+            this._assets = new assets_1.AssetsApi(this.context);
+        return this._assets;
+    }
+    /** DID, keys, identity links, domains, backup and the signed export. */
+    get identity() {
+        if (!this._identity)
+            this._identity = new identity_1.IdentityApi(this.context);
+        return this._identity;
+    }
+    /** The account graph: accounts and their members. */
+    get accounts() {
+        if (!this._accounts)
+            this._accounts = new accounts_1.AccountsApi(this.context);
+        return this._accounts;
+    }
+    /** Applications an account owns, and the ones this user granted access. */
+    get apps() {
+        if (!this._apps)
+            this._apps = new apps_1.AppsApi(this.context);
+        return this._apps;
+    }
+    /** External accounts (Mastodon, Bluesky) linked by OAuth. */
+    get linkedAccounts() {
+        if (!this._linkedAccounts)
+            this._linkedAccounts = new linkedAccounts_1.LinkedAccountsApi(this.context);
+        return this._linkedAccounts;
+    }
+    /** Delegated capabilities for agents. */
+    get agency() {
+        if (!this._agency)
+            this._agency = new agency_1.AgencyApi(this.context);
+        return this._agency;
+    }
+    /** The app store: storefront, reviews, and a publisher's listing. */
+    get store() {
+        if (!this._store)
+            this._store = new store_1.StoreApi(this.context);
+        return this._store;
+    }
+    /** Subscription, wallet and payments. */
+    get billing() {
+        if (!this._billing)
+            this._billing = new billing_1.BillingApi(this.context);
+        return this._billing;
+    }
+    /** Oxy Trust reputation (read-only for people; apps award it). */
+    get reputation() {
+        if (!this._reputation)
+            this._reputation = new reputation_1.ReputationApi(this.context);
+        return this._reputation;
+    }
+    /** Oxy ID: cards, attestations, vouching, personhood, credentials. */
+    get civic() {
+        if (!this._civic)
+            this._civic = new civic_1.CivicApi(this.context);
+        return this._civic;
+    }
+    /** The user's personal data node. */
+    get nodes() {
+        if (!this._nodes)
+            this._nodes = new nodes_1.NodesApi(this.context);
+        return this._nodes;
+    }
+    /** This user's devices, their sessions, and device sign-in. */
+    get devices() {
+        if (!this._devices)
+            this._devices = new devices_1.DevicesApi(this.context);
+        return this._devices;
+    }
+    get topics() {
+        if (!this._topics)
+            this._topics = new topics_1.TopicsApi(this.context);
+        return this._topics;
+    }
+    /** Per-app key/value data stored on the user's account. */
+    get appData() {
+        if (!this._appData)
+            this._appData = new appData_1.AppDataApi(this.context);
+        return this._appData;
+    }
+    get contacts() {
+        if (!this._contacts)
+            this._contacts = new contacts_1.ContactsApi(this.context);
+        return this._contacts;
     }
 }
 exports.OxyServices = OxyServices;
-/**
- * Default Oxy Cloud URL — used when no `cloudURL` is provided to OxyServices.
- */
-exports.OXY_CLOUD_URL = 'https://cloud.oxy.so';
-/**
- * Export the default Oxy API URL (for documentation)
- */
-exports.OXY_API_URL = (typeof process !== 'undefined' && process.env && process.env.OXY_API_URL) || 'https://api.oxy.so';
-/**
- * Pre-configured client instance for easy import
- * Uses OXY_API_URL as baseURL and OXY_CLOUD_URL as cloudURL
- */
-exports.oxyClient = new OxyServices({ baseURL: exports.OXY_API_URL, cloudURL: exports.OXY_CLOUD_URL });

package/dist/cjs/api/accounts.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountsApi = exports.AccountMembersApi = exports.kindAcceptsAccountCategories = exports.isSelectableAccountCategoryId = exports.isOperatorSwitchTargetKind = exports.isDelegatedActAsEligibleKind = exports.SELECTABLE_ACCOUNT_CATEGORY_IDS = exports.MAX_ACCOUNT_CATEGORIES = exports.ACCOUNT_KINDS = exports.ACCOUNT_CATEGORY_IDS = void 0;
+const userIdentity_1 = require("../utils/userIdentity");
+const identityCacheSweep_1 = require("../utils/identityCacheSweep");
+const accountCacheSweep_1 = require("../utils/accountCacheSweep");
+const MEDIUM_TTL = 2 * 60 * 1000;
+const LONG_TTL = 5 * 60 * 1000;
+const enc = encodeURIComponent;
+var contracts_1 = require("@oxy.so/contracts");
+Object.defineProperty(exports, "ACCOUNT_CATEGORY_IDS", { enumerable: true, get: function () { return contracts_1.ACCOUNT_CATEGORY_IDS; } });
+Object.defineProperty(exports, "ACCOUNT_KINDS", { enumerable: true, get: function () { return contracts_1.ACCOUNT_KINDS; } });
+Object.defineProperty(exports, "MAX_ACCOUNT_CATEGORIES", { enumerable: true, get: function () { return contracts_1.MAX_ACCOUNT_CATEGORIES; } });
+Object.defineProperty(exports, "SELECTABLE_ACCOUNT_CATEGORY_IDS", { enumerable: true, get: function () { return contracts_1.SELECTABLE_ACCOUNT_CATEGORY_IDS; } });
+Object.defineProperty(exports, "isDelegatedActAsEligibleKind", { enumerable: true, get: function () { return contracts_1.isDelegatedActAsEligibleKind; } });
+Object.defineProperty(exports, "isOperatorSwitchTargetKind", { enumerable: true, get: function () { return contracts_1.isOperatorSwitchTargetKind; } });
+Object.defineProperty(exports, "isSelectableAccountCategoryId", { enumerable: true, get: function () { return contracts_1.isSelectableAccountCategoryId; } });
+Object.defineProperty(exports, "kindAcceptsAccountCategories", { enumerable: true, get: function () { return contracts_1.kindAcceptsAccountCategories; } });
+/** `oxy.accounts.members` — who can act on an account, and with what role. */
+class AccountMembersApi {
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /**
+     * List the members of an account: the membership rows ON it, plus the rows
+     * on its ancestors that cascade into it. Each entry carries `source`
+     * (`direct` | `inherited`) saying which it is.
+     *
+     * Inherited entries are members in every sense the server enforces — an
+     * ancestor row with `inherit: true` confers every account permission on the
+     * descendant, `account:act_as` included.
+     *
+     * An entry's `accountId` is the account its ROW lives on, so an inherited
+     * entry names an ancestor; and the member-mutation endpoints only accept rows
+     * on the account in the path, so gate any edit/remove/transfer affordance on
+     * `source === 'direct'`.
+     *
+     * To ask what the CALLER holds over an account, use `accounts.get`, whose
+     * `callerMembership` is the server's own resolution.
+     *
+     * @param accountId - The account's `_id`.
+     */
+    async list(accountId) {
+        const res = await this.ctx.request('GET', `/accounts/${enc(accountId)}/members`, undefined, { cache: true, cacheTTL: MEDIUM_TTL });
+        return res.members ?? [];
+    }
+    /**
+     * Add a member to an account.
+     * @param accountId - The account's `_id`.
+     * @param data - Target user's username or email and role (never `owner`).
+     *   The server resolves `usernameOrEmail` to a personal account; an unknown
+     *   value yields a 404 "User not found".
+     */
+    async invite(accountId, data) {
+        const res = await this.ctx.request('POST', `/accounts/${enc(accountId)}/members`, data, { cache: false });
+        invalidateAccountMembership(this.ctx, accountId);
+        return res.member;
+    }
+    /**
+     * Change a member's role or inheritance.
+     * @param accountId - The account's `_id`.
+     * @param memberId - The member's `_id`.
+     * @param data - New role (never `owner`), inheritance, permission overrides.
+     */
+    async update(accountId, memberId, data) {
+        const res = await this.ctx.request('PATCH', `/accounts/${enc(accountId)}/members/${enc(memberId)}`, data, { cache: false });
+        invalidateAccountMembership(this.ctx, accountId);
+        return res.member;
+    }
+    /**
+     * Remove a member from an account.
+     * @param accountId - The account's `_id`.
+     * @param memberId - The member's `_id`.
+     */
+    async remove(accountId, memberId) {
+        const result = await this.ctx.request('DELETE', `/accounts/${enc(accountId)}/members/${enc(memberId)}`, undefined, { cache: false });
+        invalidateAccountMembership(this.ctx, accountId);
+        return result;
+    }
+}
+exports.AccountMembersApi = AccountMembersApi;
+class AccountsApi {
+    constructor(ctx) {
+        this.ctx = ctx;
+        this.members = new AccountMembersApi(ctx);
+    }
+    /**
+     * List the accounts the caller can access: their own personal (root)
+     * account, accounts they own, and accounts shared with them (including
+     * external organisations), plus the reachable subtree of each.
+     *
+     * @param opts - `{ tree: true }` requests the nested tree representation
+     *   (`children` populated) instead of a flat list. The flag is part of the
+     *   path (`?tree=true`), so the flat and tree variants never share a cache key.
+     */
+    async list(opts) {
+        const path = opts?.tree ? '/accounts?tree=true' : '/accounts';
+        const res = await this.ctx.request('GET', path, undefined, {
+            cache: true,
+            cacheTTL: MEDIUM_TTL,
+        });
+        return res.accounts ?? [];
+    }
+    /**
+     * Fetch a single account node by id.
+     * @param accountId - The account's `_id`.
+     */
+    async get(accountId) {
+        const res = await this.ctx.request('GET', `/accounts/${enc(accountId)}`, undefined, {
+            cache: true,
+            cacheTTL: LONG_TTL,
+        });
+        return res.account;
+    }
+    /**
+     * Switch the active session INTO a managed account.
+     *
+     * `POST /accounts/:id/switch` with the signed-in operator's bearer. The
+     * server authorises the operator (must hold `account:act_as` over the
+     * target, directly or inherited — else 403; 404 if missing/archived; 403 if
+     * the target is a personal account), then mints a REAL session for the
+     * target account in the canonical login shape.
+     *
+     * The returned session IS the new identity: its `accessToken` is planted as
+     * the active token, so every subsequent request authenticates as the target
+     * account. The server registers the switched session into the operator's
+     * device set, so the switch survives a reload and syncs cross-domain like a
+     * normal login.
+     *
+     * The SDK's identity-scoped GET cache is then fully cleared so every cached
+     * read re-fetches as the new account (a same-user token refresh deliberately
+     * keeps the warm cache, so the sweep here is explicit).
+     *
+     * @param accountId - The target account's `_id`.
+     * @returns The minted session, already planted as the active session.
+     */
+    async actAs(accountId) {
+        const res = await this.ctx.request('POST', `/accounts/${enc(accountId)}/switch`, undefined, {
+            cache: false,
+        });
+        if (res?.accessToken) {
+            this.ctx.oxy.session.setAccessToken(res.accessToken);
+        }
+        const authuser = res?.authuser;
+        // Identity changed → drop the entire GET response cache so no entry
+        // personalised for the previous identity is reused.
+        this.ctx.oxy.cache.clear();
+        return {
+            ...res,
+            ...(typeof authuser === 'number' ? { authuser } : {}),
+            user: (0, userIdentity_1.normalizeUserIdentity)(res.user),
+        };
+    }
+    /**
+     * Create a new (non-personal) account. The caller becomes its `owner`.
+     * @param data - Account configuration: kind, optional parent, and profile.
+     */
+    async create(data) {
+        const res = await this.ctx.request('POST', '/accounts', data, { cache: false });
+        // A new account changes the accessible forest — bust every cached list.
+        (0, accountCacheSweep_1.evictOxyAccountForestCache)(this.ctx.http);
+        return res.account;
+    }
+    /**
+     * Update an account's mutable profile fields. Tree placement changes
+     * (reparenting) go through the dedicated move endpoint, not here.
+     *
+     * An account IS a user, so this write changes identity: every identity read
+     * of it (`GET /users/<id>`, `GET /profiles/username/<handle>`, …) is evicted
+     * too, not only the account-graph keys — see `evictOxyIdentityCache`.
+     *
+     * @param accountId - The account's `_id`.
+     * @param data - Subset of updatable profile fields.
+     */
+    async update(accountId, data) {
+        const res = await this.ctx.request('PATCH', `/accounts/${enc(accountId)}`, data, {
+            cache: false,
+        });
+        (0, accountCacheSweep_1.evictOxyAccountForestCache)(this.ctx.http, accountId);
+        // The parent's children list embeds this account's profile and is keyed by
+        // the PARENT id, so it is reachable only from the response node.
+        const parentAccountId = res.account?.parentAccountId;
+        if (parentAccountId) {
+            this.ctx.oxy.cache.delete(`GET:/accounts/${enc(parentAccountId)}/children`);
+        }
+        (0, identityCacheSweep_1.evictOxyIdentityCache)(this.ctx.http, accountId);
+        return res.account;
+    }
+    /**
+     * Archive an account (soft delete). Not `users.deleteMe`, which is the GDPR
+     * self-deletion flow.
+     * @param accountId - The account's `_id`.
+     */
+    async archive(accountId) {
+        const result = await this.ctx.request('DELETE', `/accounts/${enc(accountId)}`, undefined, {
+            cache: false,
+        });
+        this.ctx.http.invalidateCache({
+            keys: [`GET:/accounts/${enc(accountId)}/members`, `GET:/accounts/${enc(accountId)}/credentials`],
+        });
+        (0, accountCacheSweep_1.evictOxyAccountForestCache)(this.ctx.http, accountId);
+        return result;
+    }
+    /**
+     * Transfer ownership of an account to another member (owner only).
+     * @param accountId - The account's `_id`.
+     * @param data - Target user id.
+     */
+    async transferOwnership(accountId, data) {
+        const result = await this.ctx.request('POST', `/accounts/${enc(accountId)}/transfer-ownership`, data, { cache: false });
+        // Ownership changes roles in the member list AND the detail, and which
+        // accounts the caller "owns" in the list view.
+        invalidateAccountMembership(this.ctx, accountId);
+        (0, accountCacheSweep_1.evictOxyAccountForestCache)(this.ctx.http);
+        return result;
+    }
+}
+exports.AccountsApi = AccountsApi;
+/**
+ * Bust the cached member list and detail after a membership mutation. Inherited
+ * rows on descendant rosters derive from this account's membership, so every
+ * per-account sub-resource key (`GET:/accounts/<id>…`) goes, in one pass; the
+ * forest list keys (`GET:/accounts`, `GET:/accounts?…`) are excluded by the
+ * trailing slash on the prefix.
+ */
+function invalidateAccountMembership(ctx, accountId) {
+    ctx.http.invalidateCache({
+        keys: [`GET:/accounts/${enc(accountId)}/members`, (0, accountCacheSweep_1.oxyAccountDetailCacheKey)(accountId)],
+        prefixes: [accountCacheSweep_1.OXY_ACCOUNT_PER_ACCOUNT_CACHE_PREFIX],
+    });
+}

package/dist/cjs/api/agency.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgencyApi = exports.ExecutionAuthorizationsApi = exports.CapabilityPoliciesApi = exports.DelegationGrantsApi = void 0;
+const SHORT_TTL = 60 * 1000;
+const MEDIUM_TTL = 2 * 60 * 1000;
+const enc = encodeURIComponent;
+function query(path, key, value) {
+    return `${path}?${key}=${enc(value)}`;
+}
+const grantsKey = (ownerAccountId) => `GET:${query('/capabilities/grants', 'ownerAccountId', ownerAccountId)}`;
+const policiesKey = (accountId) => `GET:${query('/capabilities/account-policies', 'accountId', accountId)}`;
+const authorizationsKey = (ownerAccountId) => `GET:${query('/capabilities/execution-authorizations', 'ownerAccountId', ownerAccountId)}`;
+/** `oxy.agency.grants` — what an owner account delegated to an actor. */
+class DelegationGrantsApi {
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /** The delegation grants an owner account issued. */
+    async list(ownerAccountId) {
+        const res = await this.ctx.request('GET', query('/capabilities/grants', 'ownerAccountId', ownerAccountId), undefined, { cache: true, cacheTTL: SHORT_TTL });
+        return res.grants;
+    }
+    /** Issue a delegation grant. */
+    async create(input) {
+        const res = await this.ctx.request('POST', '/capabilities/grants', input, {
+            cache: false,
+        });
+        this.ctx.oxy.cache.delete(grantsKey(input.ownerAccountId));
+        return res.grant;
+    }
+    /** Change a grant's capabilities, limits or autonomy. */
+    async update(grantId, ownerAccountId, input) {
+        const res = await this.ctx.request('PUT', `/capabilities/grants/${enc(grantId)}`, input, { cache: false });
+        this.ctx.oxy.cache.delete(grantsKey(ownerAccountId));
+        return res.grant;
+    }
+    /** Revoke a grant. */
+    async revoke(grantId, ownerAccountId) {
+        await this.ctx.request('DELETE', `/capabilities/grants/${enc(grantId)}`, undefined, { cache: false });
+        this.ctx.oxy.cache.delete(grantsKey(ownerAccountId));
+    }
+}
+exports.DelegationGrantsApi = DelegationGrantsApi;
+/** `oxy.agency.policies` — an account's per-app autonomy policy. */
+class CapabilityPoliciesApi {
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /** An account's capability policies, one per app. */
+    async list(accountId) {
+        const res = await this.ctx.request('GET', query('/capabilities/account-policies', 'accountId', accountId), undefined, { cache: true, cacheTTL: SHORT_TTL });
+        return res.policies;
+    }
+    /** Set an account's policy for one app. */
+    async put(appId, input) {
+        const res = await this.ctx.request('PUT', `/capabilities/account-policies/${enc(appId)}`, input, { cache: false });
+        this.ctx.oxy.cache.delete(policiesKey(input.accountId));
+        return res.policy;
+    }
+    /** Drop an account's policy for one app. */
+    async delete(appId, accountId) {
+        await this.ctx.request('DELETE', `/capabilities/account-policies/${enc(appId)}?accountId=${enc(accountId)}`, undefined, { cache: false });
+        this.ctx.oxy.cache.delete(policiesKey(accountId));
+    }
+}
+exports.CapabilityPoliciesApi = CapabilityPoliciesApi;
+/** `oxy.agency.authorizations` — live execution authorizations. */
+class ExecutionAuthorizationsApi {
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /** An owner account's execution authorizations. */
+    async list(ownerAccountId) {
+        const res = await this.ctx.request('GET', query('/capabilities/execution-authorizations', 'ownerAccountId', ownerAccountId), undefined, { cache: true, cacheTTL: SHORT_TTL });
+        return res.authorizations;
+    }
+    /** Revoke an execution authorization. */
+    async revoke(authorizationId, ownerAccountId) {
+        await this.ctx.request('DELETE', `/capabilities/execution-authorizations/${enc(authorizationId)}`, undefined, { cache: false });
+        this.ctx.oxy.cache.delete(authorizationsKey(ownerAccountId));
+    }
+}
+exports.ExecutionAuthorizationsApi = ExecutionAuthorizationsApi;
+class AgencyApi {
+    constructor(ctx) {
+        this.ctx = ctx;
+        this.grants = new DelegationGrantsApi(ctx);
+        this.policies = new CapabilityPoliciesApi(ctx);
+        this.authorizations = new ExecutionAuthorizationsApi(ctx);
+    }
+    /** The capability catalogs available to an account. */
+    async catalogs(accountId) {
+        const res = await this.ctx.request('GET', query('/capabilities/catalogs/available', 'accountId', accountId), undefined, { cache: true, cacheTTL: MEDIUM_TTL });
+        return res.catalogs;
+    }
+    /** An account's capability audit trail. */
+    async auditEvents(accountId) {
+        const res = await this.ctx.request('GET', query('/capabilities/audit', 'accountId', accountId), undefined, { cache: true, cacheTTL: SHORT_TTL });
+        return res.events;
+    }
+}
+exports.AgencyApi = AgencyApi;