adapty 0.8.7 → 0.8.8

package/dist/commands/products/list.js

@@ -1,13 +1,14 @@
 import { Command } from '@oclif/core';
+import { appIdFlag } from '../../cli/flags.js';
 import { createAuthenticatedClient } from '../../lib/client-from-config.js';
-import { appFlag, paginationFlags, paginationParams } from '../../lib/flags.js';
+import { paginationFlags, paginationParams } from '../../lib/flags.js';
 import { printList } from '../../lib/output.js';
 export default class ProductsList extends Command {
     static description = 'List products for an app';
     static enableJsonFlag = true;
     static examples = ['<%= config.bin %> products list --app 550e8400-...'];
     static flags = {
-        ...appFlag,
+        ...appIdFlag,
         ...paginationFlags,
     };
     async run() {

package/dist/commands/products/update.js

@@ -1,6 +1,7 @@
 import { Args, Command, Flags } from '@oclif/core';
+import { appIdFlag } from '../../cli/flags.js';
 import { createAuthenticatedClient } from '../../lib/client-from-config.js';
-import { appFlag, isValidUuid } from '../../lib/flags.js';
+import { isValidUuid } from '../../lib/flags.js';
 import { printResponse } from '../../lib/output.js';
 export default class ProductsUpdate extends Command {
     static args = {
@@ -12,7 +13,7 @@ export default class ProductsUpdate extends Command {
         '<%= config.bin %> products update --app UUID 550e8400-... --title "Monthly" --access-level-id UUID',
     ];
     static flags = {
-        ...appFlag,
+        ...appIdFlag,
         'access-level-id': Flags.string({ description: 'Access level ID (UUID)', required: true }),
         'title': Flags.string({ description: 'Product title', required: true }),
     };

package/dist/commands/segments/get.js

@@ -1,6 +1,7 @@
 import { Args, Command } from '@oclif/core';
+import { appIdFlag } from '../../cli/flags.js';
 import { createAuthenticatedClient } from '../../lib/client-from-config.js';
-import { appFlag, isValidUuid } from '../../lib/flags.js';
+import { isValidUuid } from '../../lib/flags.js';
 import { printResponse } from '../../lib/output.js';
 export default class SegmentsGet extends Command {
     static args = {
@@ -10,7 +11,7 @@ export default class SegmentsGet extends Command {
     static enableJsonFlag = true;
     static examples = ['<%= config.bin %> segments get --app UUID 550e8400-e29b-41d4-a716-446655440000'];
     static flags = {
-        ...appFlag,
+        ...appIdFlag,
     };
     async run() {
         const { args, flags } = await this.parse(SegmentsGet);

package/dist/commands/segments/list.js

@@ -1,13 +1,14 @@
 import { Command } from '@oclif/core';
+import { appIdFlag } from '../../cli/flags.js';
 import { createAuthenticatedClient } from '../../lib/client-from-config.js';
-import { appFlag, paginationFlags, paginationParams } from '../../lib/flags.js';
+import { paginationFlags, paginationParams } from '../../lib/flags.js';
 import { printList } from '../../lib/output.js';
 export default class SegmentsList extends Command {
     static description = 'List segments for an app';
     static enableJsonFlag = true;
     static examples = ['<%= config.bin %> segments list --app 550e8400-...'];
     static flags = {
-        ...appFlag,
+        ...appIdFlag,
         ...paginationFlags,
     };
     async run() {

package/dist/lib/flags.d.ts

@@ -1,7 +1,4 @@
 export declare function isValidUuid(value: string): boolean;
-export declare const appFlag: {
-    app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
-};
 export type PaginatedResponse<T> = {
     data: T[];
     meta: {

package/dist/lib/flags.js

@@ -3,19 +3,6 @@ const UUID_REGEX = /^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/i;
 export function isValidUuid(value) {
     return UUID_REGEX.test(value);
 }
-export const appFlag = {
-    app: Flags.string({
-        description: 'App ID (UUID)',
-        // eslint-disable-next-line @typescript-eslint/require-await -- FIXME if you see this
-        async parse(input) {
-            if (!isValidUuid(input)) {
-                throw new Error('Invalid app ID format. Run `adapty apps list` to find your app ID.');
-            }
-            return input;
-        },
-        required: true,
-    }),
-};
 export const paginationFlags = {
     'page': Flags.integer({
         default: 1,

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

@@ -0,0 +1,51 @@
+/**
+ * The vocabulary the backend describes itself with: which metrics a report can ask for and which
+ * dimensions it can group or filter by. Read-only and not scoped to an app, so the catalog is what
+ * an agent reads before it builds a report. Passed through as the server sends it, in snake_case.
+ */
+export type MetricUnit = 'count' | 'per_mille' | 'percent' | 'usd';
+export type Metric = {
+    /** Whether the totals row may sum this metric across groups. */
+    additive: boolean;
+    /** The metrics a ratio is computed from; null for a plain metric. */
+    denominator: null | string[];
+    description: string;
+    example: null | string;
+    family: string;
+    label: string;
+    name: string;
+    /** A name template for a family of metrics (e.g. a day horizon); null for a fixed name. */
+    pattern: null | string;
+    spend_based: boolean;
+    unit: MetricUnit;
+};
+/** The caps a report is held to, so a request can be sized before it is sent rather than refused. */
+export type ReportLimits = {
+    max_filter_values: number;
+    max_keyword_length: number;
+    max_metrics: number;
+    max_prediction_day: number;
+    max_prediction_horizons: number;
+    max_prediction_non_date_dimensions: number;
+    max_rows: number;
+    /** The widest period in days, both ends counted: per date granularity, and `no_date_grouping`. */
+    max_window_days: Record<string, number>;
+};
+export type MetricCatalog = {
+    limits: ReportLimits;
+    metrics: Metric[];
+};
+/** id: items are entities with an id, a name and a channel. value: items are bare values. */
+export type DimensionIdentity = 'id' | 'value';
+export type Dimension = {
+    filterable: boolean;
+    /** The granularities a date grouping accepts; null for every other dimension. */
+    granularities: null | string[];
+    groupable: boolean;
+    identity: DimensionIdentity;
+    label: string;
+    name: string;
+};
+export type DimensionCatalog = {
+    dimensions: Dimension[];
+};

package/dist/sdk/attribution/catalog.js

@@ -0,0 +1,6 @@
+/**
+ * The vocabulary the backend describes itself with: which metrics a report can ask for and which
+ * dimensions it can group or filter by. Read-only and not scoped to an app, so the catalog is what
+ * an agent reads before it builds a report. Passed through as the server sends it, in snake_case.
+ */
+export {};

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

@@ -0,0 +1,10 @@
+import type { ErrorParser } from '../core/http/index.js';
+/**
+ * How the attribution backend words a rejection: `{ errors: [{ message, error_code, status_code,
+ * field_name }] }`. The code comes from the first item; the message joins every item, each prefixed
+ * with the field it names, so "metrics: Unknown metric" reaches the user instead of an HTTP status.
+ *
+ * A body without the envelope (a proxy page, a framework-level 404) is read the default way.
+ * A 401 never gets here: the transport turns it into AuthRequiredError whatever the body says.
+ */
+export declare const attributionErrorParser: ErrorParser;

package/dist/sdk/attribution/errors.js

@@ -0,0 +1,43 @@
+import { defaultErrorParser } from '../core/http/index.js';
+/**
+ * How the attribution backend words a rejection: `{ errors: [{ message, error_code, status_code,
+ * field_name }] }`. The code comes from the first item; the message joins every item, each prefixed
+ * with the field it names, so "metrics: Unknown metric" reaches the user instead of an HTTP status.
+ *
+ * A body without the envelope (a proxy page, a framework-level 404) is read the default way.
+ * A 401 never gets here: the transport turns it into AuthRequiredError whatever the body says.
+ */
+export const attributionErrorParser = (status, body) => {
+    if (typeof body !== 'object' || body === null) {
+        return {};
+    }
+    const { errors } = body;
+    if (!Array.isArray(errors) || errors.length === 0) {
+        return defaultErrorParser(status, body);
+    }
+    const items = errors;
+    const code = codeOf(items[0]);
+    // The bare code as the fallback message: still better than an HTTP status
+    return { code, message: itemMessages(items) ?? code };
+};
+const codeOf = (item) => {
+    if (typeof item !== 'object' || item === null) {
+        return undefined;
+    }
+    const { error_code: errorCode } = item;
+    return typeof errorCode === 'string' && errorCode !== '' ? errorCode : undefined;
+};
+const itemMessages = (items) => {
+    const parts = [];
+    for (const item of items) {
+        if (typeof item !== 'object' || item === null) {
+            continue;
+        }
+        const { field_name: fieldName, message } = item;
+        if (typeof message !== 'string' || message === '') {
+            continue;
+        }
+        parts.push(typeof fieldName === 'string' && fieldName !== '' ? `${fieldName}: ${message}` : message);
+    }
+    return parts.length > 0 ? parts.join('; ') : undefined;
+};

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

@@ -0,0 +1,30 @@
+import type { AttributionApi } from './resource.js';
+import type { Clock } from '../core/clock.js';
+import type { RetryAttempt } from '../core/http/index.js';
+export { attributionErrorParser } from './errors.js';
+export { granularities, ISO_DATE, reportGroupBy, revenueBases, sortDirections, validateReport } from './report.js';
+export { validateValues } from './values.js';
+export type { Dimension, DimensionCatalog, DimensionIdentity, Metric, MetricCatalog, MetricUnit, ReportLimits, } from './catalog.js';
+export type { Granularity, ReportData, ReportFilter, ReportGroupBy, ReportInput, ReportMeta, ReportRow, ReportSort, RevenueBasis, SortDirection, } from './report.js';
+export type { AttributionApi, AttributionResponse, DimensionsResponse, MetricsResponse, ReportResponse, ValuesResponse, } from './resource.js';
+export type { ValuesData, ValuesInput, ValuesItemById, ValuesItemByValue, ValuesMeta } from './values.js';
+/** Exported because the adapter compares the resolved URL with it and warns when they differ. */
+export declare const DEFAULT_ATTRIBUTION_API_URL = "https://api-ua.adapty.io/api/v1/cli";
+/**
+ * Narrower than HttpOptions on purpose, like AdaptyOptions: the error parser, the retry rule and
+ * the path style are product knowledge, not something an adapter should override.
+ */
+export type AttributionOptions = {
+    baseUrl?: string | undefined;
+    clock?: Clock | undefined;
+    fetch?: typeof globalThis.fetch | undefined;
+    onRetry?: ((info: RetryAttempt) => void) | undefined;
+    signal?: AbortSignal | undefined;
+    /** The Adapty developer token: the same bearer, no app header. */
+    token?: string | undefined;
+    /** Comes from the adapter, so server logs can tell the CLI from an MCP server. */
+    userAgent?: string | undefined;
+};
+export type Attribution = AttributionApi;
+/** The assembly point of the attribution backend: one transport, the endpoints on top of it. */
+export declare const createAttribution: (options?: AttributionOptions) => Attribution;

package/dist/sdk/attribution/index.js

@@ -0,0 +1,33 @@
+import { ApiError } from '../core/errors.js';
+import { createHttp, defaultRetryPolicy, defaultShouldRetry } from '../core/http/index.js';
+import { attributionErrorParser } from './errors.js';
+import { attribution } from './resource.js';
+export { attributionErrorParser } from './errors.js';
+export { granularities, ISO_DATE, reportGroupBy, revenueBases, sortDirections, validateReport } from './report.js';
+export { validateValues } from './values.js';
+/** Exported because the adapter compares the resolved URL with it and warns when they differ. */
+export const DEFAULT_ATTRIBUTION_API_URL = 'https://api-ua.adapty.io/api/v1/cli';
+/**
+ * The server's Retry-After is honoured only up to the transport's longest backoff. A longer wait
+ * (60 s while Core is down) surfaces at once as an error carrying the delay, instead of a silent sleep.
+ */
+const shouldRetry = (error, attempt) => (error instanceof ApiError && (error.retryAfterMs ?? 0) > defaultRetryPolicy.maxDelayMs
+    ? false
+    : defaultShouldRetry(error, attempt));
+/** The assembly point of the attribution backend: one transport, the endpoints on top of it. */
+export const createAttribution = (options = {}) => {
+    const http = createHttp({
+        baseUrl: options.baseUrl ?? DEFAULT_ATTRIBUTION_API_URL,
+        clock: options.clock,
+        fetch: options.fetch,
+        headers: options.userAgent === undefined ? undefined : { 'user-agent': options.userAgent },
+        onRetry: options.onRetry,
+        parseError: attributionErrorParser,
+        shouldRetry,
+        signal: options.signal,
+        token: options.token,
+        // The backend routes are FastAPI paths without a trailing slash, unlike the developer API
+        trailingSlash: false,
+    });
+    return attribution(http);
+};

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

@@ -0,0 +1,75 @@
+import type { Issue } from '../core/errors.js';
+/** In the order the backend documents them, so a flag's help reads the same way. */
+export declare const reportGroupBy: readonly ["date", "campaign", "adset", "ad", "keyword", "channel", "country", "store"];
+export type ReportGroupBy = (typeof reportGroupBy)[number];
+export declare const granularities: readonly ["day", "week", "month", "quarter", "year"];
+export type Granularity = (typeof granularities)[number];
+export declare const revenueBases: readonly ["gross", "proceeds", "net"];
+export type RevenueBasis = (typeof revenueBases)[number];
+export declare const sortDirections: readonly ["asc", "desc"];
+export type SortDirection = (typeof sortDirections)[number];
+/** One value filters by equality, several by any of them. */
+export type ReportFilter = {
+    dimension: string;
+    values: readonly string[];
+};
+export type ReportSort = {
+    direction: SortDirection;
+    field: string;
+};
+/** Dates are inclusive days in the app's timezone, `YYYY-MM-DD`. */
+export type ReportInput = {
+    appId: string;
+    dateFrom: string;
+    dateTo: string;
+    filters?: readonly ReportFilter[] | undefined;
+    granularity?: Granularity | undefined;
+    groupBy: readonly ReportGroupBy[];
+    /** Catalog names, as `attribution.metrics()` lists them. */
+    metrics: readonly string[];
+    revenueBasis?: RevenueBasis | undefined;
+    sort?: ReportSort | undefined;
+};
+type ReportRequest = {
+    app_id: string;
+    date_from: string;
+    date_to: string;
+    filters?: {
+        dimension: string;
+        values: string[];
+    }[];
+    granularity?: Granularity;
+    group_by: ReportGroupBy[];
+    metrics: string[];
+    revenue_basis?: RevenueBasis;
+    sort?: {
+        direction: SortDirection;
+        field: string;
+    };
+};
+/** Group keys and metric values by name; a metric that cannot be computed is null. */
+export type ReportRow = Record<string, unknown>;
+export type ReportData = {
+    rows: ReportRow[];
+    totals: null | Record<string, unknown>;
+};
+export type ReportMeta = {
+    /** The query as the backend resolved it: timezone, currency and defaults filled in. */
+    query: Record<string, unknown>;
+};
+/** The `YYYY-MM-DD` shape alone, shared with the adapter's date flag parser. */
+export declare const ISO_DATE: RegExp;
+/** Shared with values: both read a day range, and both are refused the same way. */
+export declare const validateDateRange: (input: {
+    dateFrom: string;
+    dateTo: string;
+}) => Issue[];
+/**
+ * The rules a report can break without asking the server. Which metric and dimension names exist
+ * is the catalog's knowledge, so the backend checks those. An Issue path names an input field
+ * (camelCase) and the adapter turns it into the flag the user typed.
+ */
+export declare const validateReport: (input: ReportInput) => Issue[];
+/** An absent optional field is left out of the body: the backend applies its own default. */
+export declare const toReportRequest: (input: ReportInput) => ReportRequest;
+export {};

package/dist/sdk/attribution/report.js

@@ -0,0 +1,81 @@
+/** In the order the backend documents them, so a flag's help reads the same way. */
+export const reportGroupBy = ['date', 'campaign', 'adset', 'ad', 'keyword', 'channel', 'country', 'store'];
+export const granularities = ['day', 'week', 'month', 'quarter', 'year'];
+export const revenueBases = ['gross', 'proceeds', 'net'];
+export const sortDirections = ['asc', 'desc'];
+/** The `YYYY-MM-DD` shape alone, shared with the adapter's date flag parser. */
+export const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+/** The shape alone lets 2026-02-30 through; a round trip through Date does not. */
+const isIsoDate = (value) => {
+    if (!ISO_DATE.test(value)) {
+        return false;
+    }
+    const date = new Date(`${value}T00:00:00Z`);
+    return !Number.isNaN(date.getTime()) && date.toISOString().startsWith(value);
+};
+/** Shared with values: both read a day range, and both are refused the same way. */
+export const validateDateRange = (input) => {
+    const issues = [];
+    const fromValid = isIsoDate(input.dateFrom);
+    const toValid = isIsoDate(input.dateTo);
+    if (!fromValid) {
+        issues.push({ message: 'must be a date in YYYY-MM-DD form', path: 'dateFrom' });
+    }
+    if (!toValid) {
+        issues.push({ message: 'must be a date in YYYY-MM-DD form', path: 'dateTo' });
+    }
+    // ISO days order as strings, but only two real days are worth comparing
+    if (fromValid && toValid && input.dateTo < input.dateFrom) {
+        issues.push({ message: 'must not be before the start date', path: 'dateTo' });
+    }
+    return issues;
+};
+/**
+ * The rules a report can break without asking the server. Which metric and dimension names exist
+ * is the catalog's knowledge, so the backend checks those. An Issue path names an input field
+ * (camelCase) and the adapter turns it into the flag the user typed.
+ */
+export const validateReport = (input) => {
+    const issues = validateDateRange(input);
+    if (input.metrics.length === 0) {
+        issues.push({ message: 'at least one metric is required', path: 'metrics' });
+    }
+    if (input.groupBy.length === 0) {
+        issues.push({ message: 'at least one grouping is required', path: 'groupBy' });
+    }
+    const groupsByDate = input.groupBy.includes('date');
+    if (input.granularity !== undefined && !groupsByDate) {
+        issues.push({ message: 'applies only when grouping by date', path: 'granularity' });
+    }
+    // The backend's rule, in its wording: without a bucket a date grouping is refused there anyway
+    if (input.granularity === undefined && groupsByDate) {
+        issues.push({
+            message: `grouping by date requires exactly one granularity: ${granularities.join(', ')}`,
+            path: 'granularity',
+        });
+    }
+    return issues;
+};
+/** An absent optional field is left out of the body: the backend applies its own default. */
+export const toReportRequest = (input) => {
+    const body = {
+        app_id: input.appId,
+        date_from: input.dateFrom,
+        date_to: input.dateTo,
+        group_by: [...input.groupBy],
+        metrics: [...input.metrics],
+    };
+    if (input.filters !== undefined) {
+        body.filters = input.filters.map(filter => ({ dimension: filter.dimension, values: [...filter.values] }));
+    }
+    if (input.granularity !== undefined) {
+        body.granularity = input.granularity;
+    }
+    if (input.revenueBasis !== undefined) {
+        body.revenue_basis = input.revenueBasis;
+    }
+    if (input.sort !== undefined) {
+        body.sort = { direction: input.sort.direction, field: input.sort.field };
+    }
+    return body;
+};

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

@@ -0,0 +1,30 @@
+import type { DimensionCatalog, MetricCatalog } from './catalog.js';
+import type { ReportData, ReportInput, ReportMeta } from './report.js';
+import type { ValuesData, ValuesInput, ValuesMeta } from './values.js';
+import type { Http } from '../core/http/index.js';
+/** Every success of this service, passed through unchanged: that object is what --json prints. */
+export type AttributionResponse<Data, Meta> = {
+    data: Data;
+    meta: Meta;
+    success: true;
+};
+export type MetricsResponse = AttributionResponse<MetricCatalog, null>;
+export type DimensionsResponse = AttributionResponse<DimensionCatalog, null>;
+export type ReportResponse = AttributionResponse<ReportData, ReportMeta>;
+export type ValuesResponse = AttributionResponse<ValuesData, ValuesMeta>;
+/**
+ * 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 declare const attribution: (http: Http) => {
+    dimensions: () => Promise<DimensionsResponse>;
+    metrics: () => Promise<MetricsResponse>;
+    report: (input: ReportInput) => Promise<ReportResponse>;
+    values: (input: ValuesInput) => Promise<ValuesResponse>;
+};
+export type AttributionApi = ReturnType<typeof attribution>;

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;
+};