adapty 0.8.6 → 0.8.8

package/dist/sdk/attribution/resource.js

@@ -0,0 +1,51 @@
+import { ApiError } from '../core/errors.js';
+import { assertValid } from '../core/validation.js';
+import { toReportRequest, validateReport } from './report.js';
+import { toValuesRequest, validateValues } from './values.js';
+const isEnvelope = (body) => {
+    if (typeof body !== 'object' || body === null) {
+        return false;
+    }
+    const { data, success } = body;
+    return success === true && typeof data === 'object' && data !== null;
+};
+/**
+ * The transport hands back whatever a success body parsed to, and a proxy's HTML page parses to a
+ * string. Passed on, it would print under --json and exit 0, so a success without this service's
+ * envelope is an error: the counterpart of the legacy client's `malformed_response`.
+ */
+const envelope = async (pending) => {
+    const body = await pending;
+    if (!isEnvelope(body)) {
+        throw new ApiError({
+            code: 'malformed_response',
+            details: body,
+            message: 'The attribution service answered with a success status but not with its response envelope, '
+                + 'so the answer was cut short or came from something in between. Nothing was read.',
+            // The transport keeps the status of an error only, and this service answers every success with 200
+            status: 200,
+        });
+    }
+    return body;
+};
+/**
+ * Every path of the attribution backend in one place. The catalog reads are GETs and keep the
+ * transport's retry. Report and values are POSTs that run analytics queries: sent once, never
+ * retried, so a busy or unavailable backend is not asked to run the same expensive query again —
+ * the ApiError carries the server's Retry-After for the caller to decide.
+ *
+ * The validating methods are async on purpose — a broken rule then arrives as a rejected promise,
+ * like a network failure, and one await covers both.
+ */
+export const attribution = (http) => ({
+    dimensions: () => envelope(http.get('/dimensions')),
+    metrics: () => envelope(http.get('/metrics')),
+    report: async (input) => {
+        assertValid(validateReport(input));
+        return envelope(http.post('/report', toReportRequest(input), { idempotent: false }));
+    },
+    values: async (input) => {
+        assertValid(validateValues(input));
+        return envelope(http.post('/values', toValuesRequest(input), { idempotent: false }));
+    },
+});

package/dist/sdk/attribution/values.d.ts

@@ -0,0 +1,39 @@
+import type { RevenueBasis } from './report.js';
+import type { Issue } from '../core/errors.js';
+/** The values a dimension takes over a day range: what a report filter can be given. */
+export type ValuesInput = {
+    appId: string;
+    dateFrom: string;
+    dateTo: string;
+    dimension: string;
+    revenueBasis?: RevenueBasis | undefined;
+};
+type ValuesRequest = {
+    app_id: string;
+    date_from: string;
+    date_to: string;
+    dimension: string;
+    revenue_basis?: RevenueBasis;
+};
+/** An item of a dimension whose catalog identity is `value`. */
+export type ValuesItemByValue = {
+    /** null for rows the backend could not attribute to any value. */
+    value: null | string;
+};
+/** An item of a dimension whose catalog identity is `id`: an entity of one ad network. */
+export type ValuesItemById = {
+    channel: null | string;
+    id: null | string;
+    name: null | string;
+};
+export type ValuesData = {
+    dimension: string;
+    items: (ValuesItemById | ValuesItemByValue)[];
+};
+export type ValuesMeta = {
+    query: Record<string, unknown>;
+};
+/** Whether the dimension exists is the catalog's knowledge, so the backend checks that. */
+export declare const validateValues: (input: ValuesInput) => Issue[];
+export declare const toValuesRequest: (input: ValuesInput) => ValuesRequest;
+export {};

package/dist/sdk/attribution/values.js

@@ -0,0 +1,21 @@
+import { validateDateRange } from './report.js';
+/** Whether the dimension exists is the catalog's knowledge, so the backend checks that. */
+export const validateValues = (input) => {
+    const issues = validateDateRange(input);
+    if (input.dimension.trim() === '') {
+        issues.push({ message: 'must not be empty', path: 'dimension' });
+    }
+    return issues;
+};
+export const toValuesRequest = (input) => {
+    const body = {
+        app_id: input.appId,
+        date_from: input.dateFrom,
+        date_to: input.dateTo,
+        dimension: input.dimension,
+    };
+    if (input.revenueBasis !== undefined) {
+        body.revenue_basis = input.revenueBasis;
+    }
+    return body;
+};