adapty 0.8.3-beta.0 → 0.8.3

package/dist/lib/api-schemas.d.ts

@@ -129,20 +129,11 @@ export interface SegmentDTO {
     id: string;
     title: string;
 }
-export interface PlacementPaywallAudienceEntryDTO {
-    content_type: 'paywall';
+export interface PlacementAudienceEntryDTO {
     paywall_id: string;
     priority: number;
     segment_ids?: string[];
 }
-export interface PlacementFlowAudienceEntryDTO {
-    content_type: 'flow';
-    /** The flow must be `published` (not draft) — the backend returns 400 otherwise. */
-    flow_id: string;
-    priority: number;
-    segment_ids?: string[];
-}
-export type PlacementAudienceEntryDTO = PlacementFlowAudienceEntryDTO | PlacementPaywallAudienceEntryDTO;
 export interface PlacementSummaryDTO {
     developer_id: string;
     id: string;

package/dist/lib/asa-flags.d.ts

@@ -44,6 +44,20 @@ export declare const adScopeFlags: {
     campaign: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
     'campaign-group': import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
 };
+export declare const metricsScopeFlags: {
+    'ad-group': import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    app: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    campaign: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+};
+export declare function metricsScopeBody(flags: {
+    'ad-group'?: string[];
+    app?: string[];
+    campaign?: string[];
+}): {
+    campaign_id?: string[] | undefined;
+    app_id?: string[] | undefined;
+    ad_group_id?: string[] | undefined;
+};
 export declare const statusFilter: (options: string[]) => {
     status: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
 };
@@ -75,6 +89,16 @@ export declare function moneyFlag(description: string, opts?: {
 export declare const currencyFlag: {
     currency: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
 };
+export declare const addKeywordActionFlags: {
+    'cpt-bid': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    'cpt-bid-type': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    'match-type': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    negate: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    'no-negate': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    'pause-original': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    'skip-enable-duplicates': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    'target-ad-group': import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+};
 export declare const idempotencyFlags: {
     'idempotency-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
 };

package/dist/lib/asa-flags.js

@@ -1,4 +1,5 @@
 import { Flags } from '@oclif/core';
+import { CPT_BID_TYPES, KEYWORD_MATCH_TYPES, NEGATE_TYPES } from './asa-keyword-action.js';
 import { describeListedError } from './errors.js';
 import { isValidUuid } from './flags.js';
 const DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
@@ -63,6 +64,18 @@ export const adScopeFlags = {
     'campaign-group': idFilter('campaign group'),
     ...searchFilter,
 };
+export const metricsScopeFlags = {
+    'ad-group': idFilter('ad group'),
+    app: idFilter('app'),
+    campaign: idFilter('campaign'),
+};
+export function metricsScopeBody(flags) {
+    return {
+        ...(flags['ad-group'] === undefined ? {} : { ad_group_id: flags['ad-group'] }),
+        ...(flags.app === undefined ? {} : { app_id: flags.app }),
+        ...(flags.campaign === undefined ? {} : { campaign_id: flags.campaign }),
+    };
+}
 export const statusFilter = (options) => ({
     status: Flags.string({ description: 'Keep only rows in this state', options }),
 });
@@ -116,6 +129,47 @@ export function moneyFlag(description, opts = {}) {
 export const currencyFlag = {
     currency: Flags.string({ default: 'USD', description: 'Currency code for the amounts in this call' }),
 };
+// Params of the add-as-keyword-to action, shared by `automations create` and `automations update`.
+// The API picks the params variant by shape, so which of these apply depends on the rule's
+// operate_with: --negate/--no-negate/--skip-enable-duplicates are search-term only,
+// --pause-original is targeting-keyword only. See lib/asa-keyword-action.ts.
+export const addKeywordActionFlags = {
+    'cpt-bid': Flags.string({
+        description: 'cpt_bid.value: the bid itself with --cpt-bid-type set_to, or a percent markup on the entity bid with ' +
+            'search_term_current_cpt / keyword_current_bid; not accepted with ad_group_default_bid',
+        parse: parseMoney,
+    }),
+    'cpt-bid-type': Flags.string({
+        description: 'Where the bid of the created keyword comes from; the API has no default',
+        options: CPT_BID_TYPES,
+    }),
+    'match-type': Flags.string({
+        description: 'Match type of the created keyword; the API has no default',
+        options: KEYWORD_MATCH_TYPES,
+    }),
+    negate: Flags.string({
+        description: 'Also add the search term as a negative keyword at this level (search-term rules)',
+        exclusive: ['no-negate'],
+        options: NEGATE_TYPES,
+    }),
+    'no-negate': Flags.boolean({
+        description: 'Leave no negative keyword behind (search-term rules)',
+        exclusive: ['negate'],
+    }),
+    'pause-original': Flags.boolean({
+        allowNo: true,
+        description: 'Pause the source keyword in its own ad group (targeting-keyword rules)',
+    }),
+    'skip-enable-duplicates': Flags.boolean({
+        allowNo: true,
+        description: 'Skip a keyword that already exists in the target ad group instead of enabling it (search-term rules)',
+    }),
+    'target-ad-group': Flags.string({
+        description: 'Ad group the keyword is added to (UUID), repeatable; a rule without one does nothing',
+        multiple: true,
+        parse: parseId,
+    }),
+};
 export const idempotencyFlags = {
     'idempotency-key': Flags.string({
         description: 'Idempotency key for this write; re-running with the same key replays the stored result instead of applying twice',

package/dist/lib/asa-keyword-action.d.ts

@@ -0,0 +1,18 @@
+export declare const ADD_AS_KEYWORD_ACTION = "add-as-keyword-to";
+export declare const CPT_BID_TYPES: string[];
+export declare const KEYWORD_MATCH_TYPES: string[];
+export declare const NEGATE_TYPES: string[];
+export interface AddKeywordActionFlags {
+    'cpt-bid'?: string;
+    'cpt-bid-type'?: string;
+    'match-type'?: string;
+    negate?: string;
+    'no-negate'?: boolean;
+    'pause-original'?: boolean;
+    'skip-enable-duplicates'?: boolean;
+    'target-ad-group'?: string[];
+}
+export declare function hasAddKeywordActionFlags(flags: AddKeywordActionFlags): boolean;
+export declare function buildAddKeywordParams(operateWith: unknown, stored: unknown, flags: AddKeywordActionFlags): Record<string, unknown>;
+export declare function requireSingleAction(actions: unknown): Record<string, unknown>;
+export declare function rebuildAddKeywordAction(actions: unknown, operateWith: unknown, flags: AddKeywordActionFlags): Record<string, unknown>[];

package/dist/lib/asa-keyword-action.js

@@ -0,0 +1,160 @@
+import { isValidUuid } from './flags.js';
+export const ADD_AS_KEYWORD_ACTION = 'add-as-keyword-to';
+export const CPT_BID_TYPES = ['ad_group_default_bid', 'keyword_current_bid', 'search_term_current_cpt', 'set_to'];
+export const KEYWORD_MATCH_TYPES = ['BROAD', 'EXACT'];
+export const NEGATE_TYPES = ['ad-group', 'campaign'];
+const SEARCH_TERM = 'search-term';
+const TARGETING_KEYWORD = 'targeting-keyword';
+const BID_TYPE_IGNORING_VALUE = 'ad_group_default_bid';
+const BID_TYPES_READING_MARKUP = new Set(['keyword_current_bid', 'search_term_current_cpt']);
+// KeywordMatchType also carries AUTO. --match-type never offers it — an automation creates a
+// keyword, and AUTO is not something a keyword can be — but a rule that already stores AUTO keeps
+// it rather than being pushed onto another match type by an edit that never mentioned match types.
+const STORED_MATCH_TYPES = new Set(['AUTO', ...KEYWORD_MATCH_TYPES]);
+const SHARED_FLAGS = ['target-ad-group', 'match-type', 'cpt-bid-type', 'cpt-bid'];
+const SEARCH_TERM_FLAGS = ['negate', 'no-negate', 'skip-enable-duplicates'];
+const TARGETING_KEYWORD_FLAGS = ['pause-original'];
+const ALL_FLAGS = [...SHARED_FLAGS, ...SEARCH_TERM_FLAGS, ...TARGETING_KEYWORD_FLAGS];
+const MISSING_REASONS = {
+    'cpt-bid': 'the bid to set, required by --cpt-bid-type set_to',
+    'cpt-bid-type': 'where the bid of the new keyword comes from; the API has no default',
+    'match-type': 'BROAD or EXACT; the API has no default',
+    'target-ad-group': 'the ad groups the keyword is added to; a rule with none does nothing',
+};
+function dashed(name) {
+    return `--${name}`;
+}
+function asRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value) ? value : {};
+}
+function isFlagSet(flags, name) {
+    const value = flags[name];
+    if (value === undefined)
+        return false;
+    if (Array.isArray(value))
+        return value.length > 0;
+    // --no-negate has no negated form of its own, so only a true means it was passed.
+    return name === 'no-negate' ? value === true : true;
+}
+export function hasAddKeywordActionFlags(flags) {
+    return ALL_FLAGS.some((name) => isFlagSet(flags, name));
+}
+// Params are rebuilt, not patched: a rule may store the add-as-negative-keyword shape
+// ({target_type, ids}) under an add-as-keyword-to action, and the API picks the params variant by
+// shape without a discriminator — so every stray key silently changes which action gets run.
+// Only what fits the expected shape is carried over; the rest has to come from the flags.
+function storedInternalIds(params) {
+    const ids = asRecord(params.targets).internal_ids;
+    return Array.isArray(ids) ? ids.filter((id) => typeof id === 'string' && isValidUuid(id)) : [];
+}
+function storedMatchType(params) {
+    const matchType = params.match_type;
+    return typeof matchType === 'string' && STORED_MATCH_TYPES.has(matchType) ? matchType : undefined;
+}
+function storedCptBidType(params) {
+    const { type } = asRecord(params.cpt_bid);
+    return typeof type === 'string' && CPT_BID_TYPES.includes(type) ? type : undefined;
+}
+function storedCptBidValue(params) {
+    const { value } = asRecord(params.cpt_bid);
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function storedBoolean(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}
+function storedNegate(params) {
+    const { enabled, type } = asRecord(params.negate);
+    if (typeof enabled !== 'boolean')
+        return undefined;
+    if (type === null || type === undefined)
+        return { enabled, type: null };
+    return typeof type === 'string' && NEGATE_TYPES.includes(type) ? { enabled, type } : undefined;
+}
+function resolveNegate(flags, params) {
+    if (flags.negate !== undefined)
+        return { enabled: true, type: flags.negate };
+    if (flags['no-negate'] === true)
+        return { enabled: false, type: null };
+    return storedNegate(params) ?? { enabled: false, type: null };
+}
+function resolveCptBidValue(cptBidType, bid, params) {
+    if (cptBidType === 'set_to')
+        return bid === undefined ? storedCptBidValue(params) : Number(bid);
+    if (cptBidType !== undefined && BID_TYPES_READING_MARKUP.has(cptBidType)) {
+        return bid === undefined ? (storedCptBidValue(params) ?? null) : Number(bid);
+    }
+    return null;
+}
+function isSearchTermRule(operateWith) {
+    if (operateWith === SEARCH_TERM)
+        return true;
+    if (operateWith === TARGETING_KEYWORD)
+        return false;
+    const shown = typeof operateWith === 'string' && operateWith.length > 0 ? `"${operateWith}"` : 'missing';
+    throw new Error(`${ADD_AS_KEYWORD_ACTION} runs on a "${SEARCH_TERM}" or "${TARGETING_KEYWORD}" rule only; this rule's operate_with is ${shown}.`);
+}
+function rejectForeignFlags(searchTerm, flags) {
+    const foreign = (searchTerm ? TARGETING_KEYWORD_FLAGS : SEARCH_TERM_FLAGS).filter((name) => isFlagSet(flags, name));
+    if (foreign.length === 0)
+        return;
+    const applicable = [...SHARED_FLAGS, ...(searchTerm ? SEARCH_TERM_FLAGS : TARGETING_KEYWORD_FLAGS)];
+    throw new Error(`${foreign.map((name) => dashed(name)).join(', ')} ${foreign.length === 1 ? 'has' : 'have'} no place in the params of an ` +
+        `operate_with "${searchTerm ? SEARCH_TERM : TARGETING_KEYWORD}" rule, and the API drops params it cannot ` +
+        `place. Applicable action flags: ${applicable.map((name) => dashed(name)).join(', ')}.`);
+}
+function missingFlagsError(missing) {
+    const lines = missing.map((name) => `  ${dashed(name)} — ${MISSING_REASONS[name]}`);
+    return new Error(`The ${ADD_AS_KEYWORD_ACTION} params are incomplete. Pass:\n${lines.join('\n')}`);
+}
+export function buildAddKeywordParams(operateWith, stored, flags) {
+    const searchTerm = isSearchTermRule(operateWith);
+    rejectForeignFlags(searchTerm, flags);
+    const params = asRecord(stored);
+    const missing = [];
+    const internalIds = flags['target-ad-group'] ?? storedInternalIds(params);
+    if (internalIds.length === 0)
+        missing.push('target-ad-group');
+    const matchType = flags['match-type'] ?? storedMatchType(params);
+    if (matchType === undefined)
+        missing.push('match-type');
+    const cptBidType = flags['cpt-bid-type'] ?? storedCptBidType(params);
+    if (cptBidType === undefined)
+        missing.push('cpt-bid-type');
+    const bid = flags['cpt-bid'];
+    if (bid !== undefined && cptBidType === BID_TYPE_IGNORING_VALUE) {
+        throw new Error(`--cpt-bid has no meaning with --cpt-bid-type ${BID_TYPE_IGNORING_VALUE}; that type copies the target ad group's default bid.`);
+    }
+    const cptBidValue = resolveCptBidValue(cptBidType, bid, params);
+    if (cptBidValue === undefined)
+        missing.push('cpt-bid');
+    if (missing.length > 0)
+        throw missingFlagsError(missing);
+    const built = {
+        cpt_bid: { type: cptBidType, value: cptBidValue ?? null },
+        match_type: matchType,
+        targets: { internal_ids: internalIds, type: 'ad-group' },
+    };
+    if (searchTerm) {
+        built.negate = resolveNegate(flags, params);
+        built.skip_enable_duplicate_keywords =
+            flags['skip-enable-duplicates'] ?? storedBoolean(params.skip_enable_duplicate_keywords) ?? false;
+    }
+    else {
+        built.pause_in_original_ad_group =
+            flags['pause-original'] ?? storedBoolean(params.pause_in_original_ad_group) ?? false;
+    }
+    return built;
+}
+export function requireSingleAction(actions) {
+    if (!Array.isArray(actions) || actions.length !== 1) {
+        throw new Error('A rule needs exactly one action: the API stores one action and one condition per rule.');
+    }
+    return asRecord(actions[0]);
+}
+export function rebuildAddKeywordAction(actions, operateWith, flags) {
+    const action = requireSingleAction(actions);
+    if (action.type !== ADD_AS_KEYWORD_ACTION) {
+        throw new Error(`The action flags only apply to an ${ADD_AS_KEYWORD_ACTION} action; this rule's action is "${String(action.type)}".`);
+    }
+    return [{ ...action, params: buildAddKeywordParams(operateWith, action.params, flags) }];
+}

package/dist/lib/errors.js

@@ -2,7 +2,8 @@ export function describeListedError(error) {
     const code = error.error_code ?? error.apple_error_code ?? error.validation_error_code ?? undefined;
     const reason = error.message ?? error.apple_error_message ?? error.validation_error_message ?? code ?? 'rejected';
     const position = error.input_ref === null || error.input_ref === undefined ? '' : ` (item ${error.input_ref + 1})`;
-    return { code, text: `${reason}${position}` };
+    const field = error.field_name ? `${error.field_name}: ` : '';
+    return { code, text: `${field}${reason}${position}` };
 }
 export class ApiError extends Error {
     statusCode;