@oxyhq/core 3.15.0 → 3.16.1

package/dist/esm/mixins/OxyServices.assets.js

@@ -16,51 +16,30 @@ export function OxyServicesAssetsMixin(Base) {
             }
         }
         /**
-         * Build a synchronous file URL from an Oxy asset id.
+         * Build a synchronous, `<img src>`-ready file URL from an Oxy asset id.
          *
-         * This is the single chokepoint every Oxy app uses to turn a stored file id
-         * (avatars, post media, etc.) into a `<img src>`-ready URL, so it resolves to
-         * one of two forms depending on whether the caller needs a signed/private URL:
-         *
-         * - **Public asset (default)** — no access token planted on the client AND no
-         *   `expiresIn` requested → returns the clean CDN form
-         *   `${cloudURL}/<id>[?variant=...]` (e.g. `https://cloud.oxy.so/<id>?variant=thumb`).
-         *   CloudFront resolves the id against the public media origin. No token,
-         *   `fallback`, or origin query params are emitted — these URLs are cacheable
-         *   and shareable.
-         * - **Signed / private asset** — an access token is present on the client OR
-         *   `expiresIn` was passed (the caller explicitly wants an expiring/authorized
-         *   URL) → keeps the authenticated origin form
-         *   `${baseURL}/assets/<id>/stream?...&token=...`. Private assets are NOT on
-         *   the public CDN, so they must go through the API origin that can authorize
-         *   the request.
-         *
-         * `cloudURL` (default `https://cloud.oxy.so`) is configured once on the
-         * `OxyServices` constructor and read via `getCloudURL()`; the API origin is
-         * `getBaseURL()` (e.g. `https://api.oxy.so`).
-         *
-         * For a CDN-signed URL fetched from the API, use {@link getFileDownloadUrlAsync}.
+         * This method must never embed the caller's general access token in the
+         * returned URL. The URL is commonly rendered into DOM attributes, browser
+         * network panels, caches, and logs. Public asset URLs use the clean CDN
+         * origin; callers that need authorized/private access should use
+         * {@link getFileDownloadUrlAsync}, which asks the API for a scoped download
+         * URL instead of exposing the in-memory bearer token in a query string.
          */
-        getFileDownloadUrl(fileId, variant, expiresIn, options = {}) {
-            const token = options.omitToken ? undefined : this.getClient().getAccessToken();
-            // Public case: no auth token and no expiry requested → clean CDN URL.
-            // CloudFront serves the public media origin under `${cloudURL}/<id>`.
-            if (!token && !expiresIn) {
+        getFileDownloadUrl(fileId, variant, expiresIn) {
+            // Never embed the in-memory bearer token: this URL is rendered into DOM
+            // attributes, browser network panels, caches, and logs. Public assets get
+            // the clean CDN origin; private/authorized access goes through
+            // `getFileDownloadUrlAsync`.
+            if (!expiresIn) {
                 const variantQs = variant ? `?variant=${encodeURIComponent(variant)}` : '';
                 return `${this.getCloudURL()}/${encodeURIComponent(fileId)}${variantQs}`;
             }
-            // Signed / private case: route through the authenticated API origin's
-            // stream endpoint so the request can be authorized (private assets are not
-            // exposed on the public CDN).
             const base = this.getBaseURL();
             const params = new URLSearchParams();
             if (variant)
                 params.set('variant', variant);
-            if (expiresIn)
-                params.set('expiresIn', String(expiresIn));
+            params.set('expiresIn', String(expiresIn));
             params.set('fallback', 'placeholderVisible');
-            if (token)
-                params.set('token', token);
             const qs = params.toString();
             return `${base}/assets/${encodeURIComponent(fileId)}/stream${qs ? `?${qs}` : ''}`;
         }

package/dist/esm/mixins/OxyServices.auth.js

@@ -546,7 +546,18 @@ export function OxyServicesAuthMixin(Base) {
          */
         async getCommonsApprovalInfo(authorizeCode) {
             try {
-                return await this.makeRequest('GET', `/auth/session/approve-info/${encodeURIComponent(authorizeCode)}`, undefined, { cache: false });
+                const raw = await this.makeRequest('GET', `/auth/session/approve-info/${encodeURIComponent(authorizeCode)}`, undefined, { cache: false });
+                return {
+                    application: raw.application,
+                    scopes: raw.scopes,
+                    boundOrigin: raw.boundOrigin,
+                    // Fail-safe: only a literal boolean `true` counts as verified. A
+                    // missing or non-boolean value (older server, malformed response)
+                    // coerces to `false` so a stale server can never imply trust.
+                    originVerified: raw.originVerified === true,
+                    expiresAt: raw.expiresAt,
+                    status: raw.status,
+                };
             }
             catch (error) {
                 throw this.handleError(error);

package/dist/esm/mixins/OxyServices.links.js

@@ -0,0 +1,65 @@
+import { buildUrl } from '../utils/apiUtils.js';
+/**
+ * Maximum number of URLs sent per `POST /links/previews` request. Matches the
+ * server-side batch cap (`linkPreviewBatchRequestSchema`'s `.max(50)`); larger
+ * inputs are split into multiple chunked calls and the result maps merged,
+ * mirroring how `getUsersByIds` chunks at 100.
+ */
+const LINK_PREVIEWS_CHUNK_SIZE = 50;
+export function OxyServicesLinksMixin(Base) {
+    return class extends Base {
+        constructor(...args) {
+            super(...args);
+        }
+        /**
+         * Resolve a single link preview via `GET /links/preview?url=<encoded>&wait=0|1`.
+         *
+         * @param url - The URL to unfurl. Sent percent-encoded in the query string.
+         * @param opts.wait - When `true`, asks the server to resolve synchronously
+         *   (`wait=1`) instead of returning a `'pending'` placeholder for a
+         *   first-seen URL. Defaults to `false` (`wait=0`).
+         *
+         * Not cached at the SDK layer: a `'pending'` result can become `'resolved'`
+         * on a later read, so caching here would serve the stale placeholder.
+         */
+        async getLinkPreview(url, opts) {
+            try {
+                const path = buildUrl('/links/preview', { url, wait: opts?.wait ? 1 : 0 });
+                return await this.makeRequest('GET', path, undefined, { cache: false });
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        /**
+         * Resolve multiple link previews via `POST /links/previews` (body `{ urls }`).
+         *
+         * Inputs are de-duplicated and split into chunks of {@link LINK_PREVIEWS_CHUNK_SIZE}
+         * (the server-side cap). Chunks run concurrently and their `data` maps are
+         * merged into a single result keyed by the REQUESTED url (the exact string
+         * passed in `urls`) — matching the batch contract — so a caller can always
+         * look its own input back up.
+         *
+         * An empty / whitespace-only input resolves immediately with `{}` and
+         * performs no network call. A failure in any chunk surfaces (via
+         * `handleError`) rather than being swallowed.
+         */
+        async getLinkPreviews(urls) {
+            const uniqueUrls = Array.from(new Set(urls.filter((u) => typeof u === 'string' && u.trim().length > 0)));
+            if (uniqueUrls.length === 0) {
+                return {};
+            }
+            const chunks = [];
+            for (let i = 0; i < uniqueUrls.length; i += LINK_PREVIEWS_CHUNK_SIZE) {
+                chunks.push(uniqueUrls.slice(i, i + LINK_PREVIEWS_CHUNK_SIZE));
+            }
+            try {
+                const responses = await Promise.all(chunks.map((chunk) => this.makeRequest('POST', '/links/previews', { urls: chunk }, { cache: false })));
+                return responses.reduce((merged, response) => Object.assign(merged, response?.data ?? {}), {});
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+    };
+}

package/dist/esm/mixins/index.js

@@ -31,6 +31,7 @@ import { OxyServicesContactsMixin } from './OxyServices.contacts.js';
 import { OxyServicesAppDataMixin } from './OxyServices.appData.js';
 import { OxyServicesCivicMixin } from './OxyServices.civic.js';
 import { OxyServicesNodesMixin } from './OxyServices.nodes.js';
+import { OxyServicesLinksMixin } from './OxyServices.links.js';
 /**
  * Mixin pipeline - applied in order from first to last.
  *
@@ -81,6 +82,9 @@ const MIXIN_PIPELINE = [
     // User nodes / decentralization (Fase 5): register/read/revoke/manage the
     // caller's personal data node + ingest hint.
     OxyServicesNodesMixin,
+    // Link previews / unfurls: SDK-owned link-metadata resolution via oxy-api,
+    // so apps stop scraping link metadata locally.
+    OxyServicesLinksMixin,
     // Utility (last, can use all above)
     OxyServicesUtilityMixin,
 ];