adapty 0.8.4 → 0.8.5

package/dist/lib/asa-client.js

@@ -5,13 +5,16 @@ import { buildUserAgent } from './client-from-config.js';
 import { AuthRequiredError, NetworkError } from './errors.js';
 export const ASA_API_URL = 'https://api-asa-admin.adapty.io/api/v1/cli';
 export const ASA_API_URL_ENV_VAR = 'ADAPTY_ASA_API_URL';
-export async function createAsaClient(config) {
+export async function createAsaClient(command) {
+    const { config } = command;
     const token = await resolveToken(config.configDir);
-    if (!token)
+    if (!token) {
         throw new AuthRequiredError();
+    }
     return new ApiClient({
         defaultBaseUrl: ASA_API_URL,
         errorFormat: 'asa',
+        quiet: command.jsonEnabled(),
         token,
         urlEnvVar: ASA_API_URL_ENV_VAR,
         userAgent: buildUserAgent(config),
@@ -34,13 +37,15 @@ export async function asaWrite(client, method, path, opts = {}) {
         return { replayed, result };
     }
     catch (error) {
-        if (!(error instanceof NetworkError))
+        if (!(error instanceof NetworkError)) {
             throw error;
+        }
         const result = await send();
         return { replayed, result };
     }
 }
 export function noteReplay(replayed, log) {
-    if (replayed)
+    if (replayed) {
         log('Already applied earlier — showing the stored result.');
+    }
 }

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

@@ -50,25 +50,25 @@ export declare const metricsScopeFlags: {
     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[];
+    'ad-group'?: string[] | undefined;
+    'app'?: string[] | undefined;
+    'campaign'?: string[] | undefined;
 }): {
-    campaign_id?: string[] | undefined;
-    app_id?: string[] | undefined;
-    ad_group_id?: string[] | undefined;
+    campaign_id?: string[];
+    app_id?: string[];
+    ad_group_id?: string[];
 };
 export declare const statusFilter: (options: string[]) => {
     status: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
 };
-interface ScopeFlags {
-    'ad-group'?: string[];
-    app?: string[];
-    campaign?: string[];
-    'campaign-group'?: string[];
-    search?: string;
-    status?: string;
-}
+type ScopeFlags = {
+    'ad-group'?: string[] | undefined;
+    'app'?: string[] | undefined;
+    'campaign'?: string[] | undefined;
+    'campaign-group'?: string[] | undefined;
+    'search'?: string | undefined;
+    'status'?: string | undefined;
+};
 export declare function scopeParams(flags: ScopeFlags): QueryParams;
 export declare const scheduleFlags: {
     'end-time': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
@@ -80,8 +80,8 @@ export declare const pricingModelFlag: {
 export declare function startOfDayUtc(date: string | undefined): string | undefined;
 export declare function todayUtc(): string;
 export declare function periodParams(flags: {
-    'date-from'?: string;
-    'date-to'?: string;
+    'date-from'?: string | undefined;
+    'date-to'?: string | undefined;
 }): Record<string, string>;
 export declare function moneyFlag(description: string, opts?: {
     required?: boolean;
@@ -118,17 +118,17 @@ export declare const invoiceFlags: {
     'invoice-contact-name': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     'invoice-order-number': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
 };
-export declare function locInvoiceDetails(flags: Partial<Record<InvoiceFlagName, string>>): Record<keyof AsaLocInvoiceDetails, string> | undefined;
+export declare function locInvoiceDetails(flags: Partial<Record<InvoiceFlagName, string | undefined>>): Record<keyof AsaLocInvoiceDetails, string> | undefined;
 export declare function reportServingState(campaign: null | {
     internal_id: string;
     serving_state_reasons?: null | string[];
     serving_status?: null | string;
 }, warn: (msg: string) => void): void;
-interface BulkOutcome {
+type BulkOutcome = {
     applied: unknown[];
     errors: AsaMutationError[];
     isValidationFailure: boolean;
     kind: string;
-}
+};
 export declare function reportBulkOutcome({ applied, errors, isValidationFailure, kind }: BulkOutcome, log: (msg: string) => void): void;
 export {};

package/dist/lib/asa-flags.js

@@ -9,7 +9,7 @@ export const MAX_BY_DAYS = 16;
 export const ASA_METRIC_ENTITIES = ['ad', 'ad-group', 'campaign', 'keyword'];
 export const ASA_GROUP_BY_DIMENSIONS = ['country', 'day', 'month', 'quarter', 'week', 'year'];
 export const asaPaginationFlags = {
-    page: Flags.integer({
+    'page': Flags.integer({
         default: 1,
         description: 'Page number',
         min: 1,
@@ -27,9 +27,11 @@ export const byDaysFlag = {
         multiple: true,
     }),
 };
+// eslint-disable-next-line @typescript-eslint/require-await -- FIXME if you see this
 export async function parseDate(input) {
-    if (!DATE_REGEX.test(input))
+    if (!DATE_REGEX.test(input)) {
         throw new Error('Dates must be written as YYYY-MM-DD.');
+    }
     return input;
 }
 export const periodFlags = {
@@ -42,9 +44,11 @@ export const periodFlags = {
         parse: parseDate,
     }),
 };
+// eslint-disable-next-line @typescript-eslint/require-await -- FIXME if you see this
 async function parseId(input) {
-    if (!isValidUuid(input))
+    if (!isValidUuid(input)) {
         throw new Error('Ids are the UUIDs printed by the matching list command.');
+    }
     return input;
 }
 function idFilter(entity) {
@@ -52,7 +56,7 @@ function idFilter(entity) {
 }
 const searchFilter = { search: Flags.string({ description: 'Case-insensitive substring match on the name' }) };
 export const assetScopeFlags = {
-    app: idFilter('app'),
+    'app': idFilter('app'),
     'campaign-group': idFilter('campaign group'),
 };
 export const orgScopeFlags = { ...assetScopeFlags, ...searchFilter };
@@ -60,14 +64,14 @@ export const campaignScopeFlags = { ...orgScopeFlags, campaign: idFilter('campai
 export const adGroupScopeFlags = { ...campaignScopeFlags, 'ad-group': idFilter('ad group') };
 export const adScopeFlags = {
     'ad-group': idFilter('ad group'),
-    campaign: idFilter('campaign'),
+    'campaign': idFilter('campaign'),
     'campaign-group': idFilter('campaign group'),
     ...searchFilter,
 };
 export const metricsScopeFlags = {
     'ad-group': idFilter('ad group'),
-    app: idFilter('app'),
-    campaign: idFilter('campaign'),
+    'app': idFilter('app'),
+    'campaign': idFilter('campaign'),
 };
 export function metricsScopeBody(flags) {
     return {
@@ -108,22 +112,26 @@ export function todayUtc() {
 }
 export function periodParams(flags) {
     const params = {};
-    if (flags['date-from'])
+    if (flags['date-from']) {
         params.date_from = flags['date-from'];
-    if (flags['date-to'])
+    }
+    if (flags['date-to']) {
         params.date_to = flags['date-to'];
+    }
     return params;
 }
+// eslint-disable-next-line @typescript-eslint/require-await -- FIXME if you see this
 async function parseMoney(input) {
-    if (!MONEY_REGEX.test(input))
+    if (!MONEY_REGEX.test(input)) {
         throw new Error('Amounts must be plain numbers, e.g. 50 or 12.50.');
+    }
     return input;
 }
 export function moneyFlag(description, opts = {}) {
     return Flags.string({
         description: `${description} (amount, e.g. 50 or 12.50)`,
         parse: parseMoney,
-        required: opts.required,
+        ...(opts.required === undefined ? {} : { required: opts.required }),
     });
 }
 export const currencyFlag = {
@@ -135,8 +143,8 @@ export const currencyFlag = {
 // --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',
+        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({
@@ -147,7 +155,7 @@ export const addKeywordActionFlags = {
         description: 'Match type of the created keyword; the API has no default',
         options: KEYWORD_MATCH_TYPES,
     }),
-    negate: Flags.string({
+    '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,
@@ -198,32 +206,37 @@ export const invoiceFlags = {
 };
 export function locInvoiceDetails(flags) {
     const names = Object.keys(INVOICE_FIELDS);
-    const missing = names.filter((name) => flags[name] === undefined);
-    if (missing.length === names.length)
+    const missing = names.filter(name => flags[name] === undefined);
+    if (missing.length === names.length) {
         return undefined;
+    }
     if (missing.length > 0) {
-        throw new Error(`Invoicing Options need all five flags; missing: ${missing.map((name) => `--${name}`).join(', ')}`);
+        throw new Error(`Invoicing Options need all five flags; missing: ${missing.map(name => `--${name}`).join(', ')}`);
     }
-    return Object.fromEntries(names.map((name) => [INVOICE_FIELDS[name], flags[name]]));
+    return Object.fromEntries(names.map(name => [INVOICE_FIELDS[name], flags[name]]));
 }
 const SERVING_HINTS = {
-    AUTOMATED_KEYWORDS_REQUIRED_AD_GROUP_MISSING: (campaignId) => `Max Conversions campaign needs an automated ad group: adapty asa ad-groups create --campaign ${campaignId} --name "Automated Max Conv" --automated`,
-    MISSING_BO_OR_INVOICING_FIELDS: (campaignId) => `This organization bills by line of credit — add Invoicing Options: adapty asa campaigns update ${campaignId} --invoice-advertiser ... --invoice-order-number ... --invoice-contact-name ... --invoice-contact-email ... --invoice-billing-email ...`,
+    AUTOMATED_KEYWORDS_REQUIRED_AD_GROUP_MISSING: campaignId => `Max Conversions campaign needs an automated ad group: adapty asa ad-groups create --campaign ${campaignId} --name "Automated Max Conv" --automated`,
+    MISSING_BO_OR_INVOICING_FIELDS: campaignId => `This organization bills by line of credit — add Invoicing Options: adapty asa campaigns update ${campaignId} --invoice-advertiser ... --invoice-order-number ... --invoice-contact-name ... --invoice-contact-email ... --invoice-billing-email ...`,
 };
 export function reportServingState(campaign, warn) {
-    if (campaign?.serving_status !== 'NOT_RUNNING' || !campaign.serving_state_reasons?.length)
+    if (campaign?.serving_status !== 'NOT_RUNNING' || !campaign.serving_state_reasons?.length) {
         return;
+    }
     const reasons = campaign.serving_state_reasons;
-    if (reasons.length === 1 && reasons[0] === 'PAUSED_BY_USER')
+    if (reasons.length === 1 && reasons[0] === 'PAUSED_BY_USER') {
         return;
+    }
     for (const reason of reasons) {
         const hint = SERVING_HINTS[reason];
-        if (hint)
+        if (hint) {
             warn(hint(campaign.internal_id));
+        }
     }
-    const other = reasons.filter((reason) => !SERVING_HINTS[reason]);
-    if (other.length > 0)
+    const other = reasons.filter(reason => !SERVING_HINTS[reason]);
+    if (other.length > 0) {
         warn(`Not serving: ${other.join(', ')}`);
+    }
 }
 export function reportBulkOutcome({ applied, errors, isValidationFailure, kind }, log) {
     if (isValidationFailure) {

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

@@ -2,16 +2,16 @@ 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 type AddKeywordActionFlags = {
+    'cpt-bid'?: string | undefined;
+    'cpt-bid-type'?: string | undefined;
+    'match-type'?: string | undefined;
+    'negate'?: string | undefined;
+    'no-negate'?: boolean | undefined;
+    'pause-original'?: boolean | undefined;
+    'skip-enable-duplicates'?: boolean | undefined;
+    'target-ad-group'?: string[] | undefined;
+};
 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>;

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

@@ -29,15 +29,17 @@ function asRecord(value) {
 }
 function isFlagSet(flags, name) {
     const value = flags[name];
-    if (value === undefined)
+    if (value === undefined) {
         return false;
-    if (Array.isArray(value))
+    }
+    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));
+    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
@@ -64,46 +66,54 @@ function storedBoolean(value) {
 }
 function storedNegate(params) {
     const { enabled, type } = asRecord(params.negate);
-    if (typeof enabled !== 'boolean')
+    if (typeof enabled !== 'boolean') {
         return undefined;
-    if (type === null || type === 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)
+    if (flags.negate !== undefined) {
         return { enabled: true, type: flags.negate };
-    if (flags['no-negate'] === true)
+    }
+    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')
+    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)
+    if (operateWith === SEARCH_TERM) {
         return true;
-    if (operateWith === TARGETING_KEYWORD)
+    }
+    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)
+    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(', ')}.`);
+    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]}`);
+    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) {
@@ -112,23 +122,28 @@ export function buildAddKeywordParams(operateWith, stored, flags) {
     const params = asRecord(stored);
     const missing = [];
     const internalIds = flags['target-ad-group'] ?? storedInternalIds(params);
-    if (internalIds.length === 0)
+    if (internalIds.length === 0) {
         missing.push('target-ad-group');
+    }
     const matchType = flags['match-type'] ?? storedMatchType(params);
-    if (matchType === undefined)
+    if (matchType === undefined) {
         missing.push('match-type');
+    }
     const cptBidType = flags['cpt-bid-type'] ?? storedCptBidType(params);
-    if (cptBidType === undefined)
+    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)
+    if (cptBidValue === undefined) {
         missing.push('cpt-bid');
-    if (missing.length > 0)
+    }
+    if (missing.length > 0) {
         throw missingFlagsError(missing);
+    }
     const built = {
         cpt_bid: { type: cptBidType, value: cptBidValue ?? null },
         match_type: matchType,
@@ -136,12 +151,12 @@ export function buildAddKeywordParams(operateWith, stored, flags) {
     };
     if (searchTerm) {
         built.negate = resolveNegate(flags, params);
-        built.skip_enable_duplicate_keywords =
-            flags['skip-enable-duplicates'] ?? storedBoolean(params.skip_enable_duplicate_keywords) ?? false;
+        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;
+        built.pause_in_original_ad_group
+            = flags['pause-original'] ?? storedBoolean(params.pause_in_original_ad_group) ?? false;
     }
     return built;
 }