@commercelayer/cli-plugin-metrics 1.0.0

package/lib/commands/metrics/search.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+const common_1 = require("../../common");
+const cli_core_1 = require("@commercelayer/cli-core");
+const request_1 = require("../../request");
+class MetricsSearch extends base_1.BaseResourceCommand {
+    static operation = 'search';
+    static aliases = [MetricsSearch.operation];
+    static description = 'perform a search query on the Metrics API endpoint';
+    static examples = [
+        'commercelayewr metrics:search orders -l 5 -s asc -b order.placed_at -f order.id,order.number,order.placed_at,customer.email'
+    ];
+    static flags = {
+        limit: core_1.Flags.integer({
+            char: 'l',
+            description: 'the maximum number of records shown in the response',
+            min: 1,
+            max: 100
+        }),
+        sort: core_1.Flags.string({
+            char: 's',
+            description: 'the way you want the results of the query to be sorted',
+            options: common_1.sorts,
+            dependsOn: ['sort_by']
+        }),
+        sort_by: core_1.Flags.string({
+            char: 'b',
+            description: 'the date field you want the results of the query sorted by'
+        }),
+        fields: core_1.Flags.string({
+            char: 'f',
+            description: 'comma-separated list of fields you want to be returned for each record in the response',
+            required: true,
+            multiple: true
+        }),
+        cursor: core_1.Flags.string({
+            char: 'c',
+            description: 'the cursor pointing to a specific page in the paginated search results'
+        })
+    };
+    static args = {
+        ...base_1.BaseResourceCommand.args
+    };
+    async run() {
+        const { args, flags } = await this.parse(MetricsSearch);
+        this.checkAcessTokenData(flags.accessToken, flags);
+        const resource = args.resource;
+        const fields = this.multivalFlag(flags.fields);
+        const querySearch = {
+            fields,
+            limit: flags.limit,
+            sort: flags.sort,
+            sort_by: flags.sort_by,
+            cursor: flags.cursor
+        };
+        const filterObject = this.filterFlag(flags.filter);
+        const query = {
+            search: querySearch,
+            filter: filterObject
+        };
+        const response = await (0, request_1.metricsRequest)(MetricsSearch.operation, query, resource, flags);
+        const res = response.clone();
+        await this.printResponse(response);
+        // Print pagination info
+        if (res.ok) {
+            const pagination = (await res.json()).meta.pagination;
+            this.log(`Record count: ${cli_core_1.clColor.yellowBright(pagination.record_count)}`);
+            if (pagination.cursor)
+                this.log(`Cursor: ${cli_core_1.clColor.cyanBright(pagination.cursor)}`);
+            this.log();
+        }
+    }
+}
+exports.default = MetricsSearch;

package/lib/commands/metrics/stats.d.ts

@@ -0,0 +1,17 @@
+import { BaseResourceCommand } from '../../base';
+import type { MetricsOperation } from '../../common';
+export default class MetricsStats extends BaseResourceCommand {
+    static operation: MetricsOperation;
+    static aliases: string[];
+    static description: string;
+    static examples: string[];
+    static flags: {
+        field: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        operator: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        description: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        resource: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/metrics/stats.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+const common_1 = require("../../common");
+const cliux = tslib_1.__importStar(require("@commercelayer/cli-ux"));
+const cli_core_1 = require("@commercelayer/cli-core");
+const request_1 = require("../../request");
+class MetricsStats extends base_1.BaseResourceCommand {
+    static operation = 'stats';
+    static aliases = [MetricsStats.operation];
+    static description = 'perform a stats query on the Metrics API endpoint';
+    static examples = [
+        'commercelayer metrics:stats orders -f order.total_amount_with_taxes --op avg',
+        'cl stats orders -f order.total_amount_with_taxes -O stats'
+    ];
+    static flags = {
+        field: core_1.Flags.string({
+            char: 'f',
+            description: 'the field you want the metrics or statistics computed on',
+            required: true
+        }),
+        operator: core_1.Flags.string({
+            char: 'O',
+            aliases: ['op'],
+            description: 'the computing operator',
+            options: common_1.operators,
+            required: true
+        }),
+        description: core_1.Flags.boolean({
+            char: 'D',
+            description: 'show the description of the operator used for the query',
+            hidden: true
+        }),
+    };
+    static args = {
+        ...base_1.BaseResourceCommand.args
+    };
+    async run() {
+        const { args, flags } = await this.parse(MetricsStats);
+        this.checkAcessTokenData(flags.accessToken, flags);
+        const resource = args.resource;
+        const field = flags.field;
+        const operator = flags.operator;
+        const queryStats = {
+            field,
+            operator
+        };
+        const filterObject = this.filterFlag(flags.filter);
+        const query = {
+            stats: queryStats,
+            filter: filterObject
+        };
+        const response = await (0, request_1.metricsRequest)(MetricsStats.operation, query, resource, flags);
+        if (response.ok) {
+            cliux.action.stop(cli_core_1.clColor.msg.success('Done'));
+            const operatorInfo = common_1.operatorMap[operator];
+            if (flags.description)
+                this.log(cli_core_1.clColor.italic(`\n${operatorInfo.description}`));
+            const func = `${cli_core_1.clColor.cyan(`${operator}(`)}${cli_core_1.clColor.italic(field)}${cli_core_1.clColor.cyan(')')}`;
+            const jsonRes = await response.json();
+            const value = jsonRes.data.value;
+            this.log();
+            if (operatorInfo.type === 'Object') {
+                this.log(`${func} = {`);
+                ['count', 'min', 'max', 'avg', 'sum'].forEach((op) => {
+                    this.log(`  ${op.padStart(5, ' ')}: ${cli_core_1.clColor.yellow(value[op])}`);
+                });
+                this.log('}');
+            }
+            else
+                this.log(`${func} = ${cli_core_1.clColor.yellow(value)}`);
+            this.log();
+        }
+        else
+            await this.printResponse(response);
+    }
+}
+exports.default = MetricsStats;

package/lib/common.d.ts

@@ -0,0 +1,117 @@
+export declare const analysisOperations: string[];
+declare const operationList: readonly ["search", "stats", "breakdown", "date_breakdown", ...string[]];
+export type MetricsOperation = typeof operationList[number];
+export declare const operations: string[];
+declare const resourceList: readonly ["orders", "returns", "carts"];
+export type MetricsResource = typeof resourceList[number];
+export declare const resources: string[];
+declare const intervalList: readonly ["hour", "day", "week", "month", "year"];
+export type MetricsInterval = typeof intervalList[number];
+export declare const intervals: string[];
+export declare const operatorMap: {
+    readonly avg: {
+        readonly type: "Float";
+        readonly description: "A single-value metrics aggregation that computes the average of numeric values extracted from specific numeric fields of the aggregated records";
+    };
+    readonly cardinality: {
+        readonly type: "Integer";
+        readonly description: "A single-value metrics aggregation that calculates an approximate count of distinct values";
+    };
+    readonly max: {
+        readonly type: "Float";
+        readonly description: "A single-value metrics aggregation that keeps track and returns the maximum value among the numeric values extracted from specific numeric fields of the aggregated records";
+    };
+    readonly min: {
+        readonly type: "Float";
+        readonly description: "A single-value metrics aggregation that keeps track and returns the minimum value among the numeric values extracted from specific numeric fields of the aggregated records";
+    };
+    readonly percentiles: {
+        readonly type: "Float";
+        readonly description: "A multi-value metrics aggregation that calculates one or more percentiles (i.e. the point at which a certain percentage of observed values occurs) over numeric values extracted from specific numeric fields of the aggregated records";
+    };
+    readonly stats: {
+        readonly type: "Object";
+        readonly description: "A multi-value metrics aggregation that computes stats over numeric values extracted from specific numeric fields of the aggregated records. The stats that are returned consist of: count, min, max, avg, and sum";
+    };
+    readonly sum: {
+        readonly type: "Float";
+        readonly description: "A single-value metrics aggregation that sums up numeric values extracted from specific numeric fields of the aggregated records";
+    };
+    readonly value_count: {
+        readonly type: "Integer";
+        readonly description: "A single-value metrics aggregation that counts the number of values extracted from specific fields of the aggregated records";
+    };
+};
+export type MetricsOperator = keyof typeof operatorMap;
+export declare const operators: string[];
+declare const conditionList: readonly ["eq", "ne", "gt", "gte", "lt", "lte", "gt_lt", "gte_lte", "gte_lt", "gt_lte"];
+export type MetricsConditionKey = typeof conditionList[number];
+export declare const conditions: string[];
+export type MetricsCondition = {
+    [key in MetricsConditionKey]?: (number | [number, number]);
+};
+declare const sortList: readonly ["asc", "desc"];
+export type MetricsSort = typeof sortList[number];
+export declare const sorts: string[];
+export type MetricsQuerySearch = {
+    limit?: number;
+    sort?: MetricsSort;
+    sort_by?: string;
+    fields: string[];
+    cursor?: string;
+};
+export type MetricsQueryStats = {
+    field: string;
+    operator: MetricsOperator;
+};
+export type MetricsQueryBreakdown = {
+    by: string;
+    field: string;
+    operator: MetricsOperator;
+    condition?: MetricsCondition;
+    sort?: MetricsSort;
+    limit?: number;
+    breakdown?: MetricsQueryBreakdown;
+};
+export type MetricsQueryBreakdownResponse = {
+    label: string;
+    value: string | number;
+} & {
+    key?: MetricsQueryBreakdown;
+};
+export type MetricsQueryDateBreakdown = {
+    by: string;
+    field: string;
+    operator: MetricsOperator;
+    interval?: MetricsInterval;
+    breakdown?: MetricsQueryBreakdown;
+};
+export type MetricsQueryDateBreakdownResponse = {
+    date: string;
+    value: any;
+} & {
+    key?: MetricsQueryBreakdown;
+};
+export type MetricsFilter = Record<string, any>;
+export type MetricsFilterFbt = {
+    line_items: {
+        item_ids: {
+            in: string[];
+        };
+    };
+};
+export type MetricsQueryFbt = {
+    filter: MetricsFilterFbt;
+};
+export type MetricsQuery = (({
+    search: MetricsQuerySearch;
+} | {
+    stats: MetricsQueryStats;
+} | {
+    breakdown: MetricsQueryBreakdown;
+} | {
+    date_breakdown: MetricsQueryDateBreakdown;
+}) & {
+    filter?: MetricsFilter;
+}) | MetricsQueryFbt;
+export {};

package/lib/common.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sorts = exports.conditions = exports.operators = exports.operatorMap = exports.intervals = exports.resources = exports.operations = exports.analysisOperations = void 0;
+// Operations
+exports.analysisOperations = ['fbt'];
+const operationList = ['search', 'stats', 'breakdown', 'date_breakdown', ...exports.analysisOperations];
+exports.operations = operationList;
+// Resources
+const resourceList = ['orders', 'returns', 'carts'];
+exports.resources = resourceList;
+// Intervals
+const intervalList = ['hour', 'day', 'week', 'month', 'year'];
+exports.intervals = intervalList;
+// Operators
+exports.operatorMap = {
+    avg: { type: 'Float', description: 'A single-value metrics aggregation that computes the average of numeric values extracted from specific numeric fields of the aggregated records' },
+    cardinality: { type: 'Integer', description: 'A single-value metrics aggregation that calculates an approximate count of distinct values' },
+    max: { type: 'Float', description: 'A single-value metrics aggregation that keeps track and returns the maximum value among the numeric values extracted from specific numeric fields of the aggregated records' },
+    min: { type: 'Float', description: 'A single-value metrics aggregation that keeps track and returns the minimum value among the numeric values extracted from specific numeric fields of the aggregated records' },
+    percentiles: { type: 'Float', description: 'A multi-value metrics aggregation that calculates one or more percentiles (i.e. the point at which a certain percentage of observed values occurs) over numeric values extracted from specific numeric fields of the aggregated records' },
+    stats: { type: 'Object', description: 'A multi-value metrics aggregation that computes stats over numeric values extracted from specific numeric fields of the aggregated records. The stats that are returned consist of: count, min, max, avg, and sum' },
+    sum: { type: 'Float', description: 'A single-value metrics aggregation that sums up numeric values extracted from specific numeric fields of the aggregated records' },
+    value_count: { type: 'Integer', description: 'A single-value metrics aggregation that counts the number of values extracted from specific fields of the aggregated records' }
+};
+exports.operators = Object.keys(exports.operatorMap);
+// Conditions
+const conditionList = ['eq', 'ne', 'gt', 'gte', 'lt', 'lte', 'gt_lt', 'gte_lte', 'gte_lt', 'gt_lte'];
+exports.conditions = conditionList;
+const sortList = ['asc', 'desc'];
+exports.sorts = sortList;

package/lib/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/lib/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var core_1 = require("@oclif/core");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return core_1.run; } });

package/lib/request.d.ts

@@ -0,0 +1,2 @@
+import { type MetricsOperation, type MetricsResource } from "./common";
+export declare function metricsRequest(operation: MetricsOperation, query: any, resource?: MetricsResource, flags?: any): Promise<Response>;

package/lib/request.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metricsRequest = metricsRequest;
+const tslib_1 = require("tslib");
+const cli_core_1 = require("@commercelayer/cli-core");
+const common_1 = require("./common");
+const cliux = tslib_1.__importStar(require("@commercelayer/cli-ux"));
+async function metricsRequest(operation, query, resource, flags) {
+    console.log();
+    cliux.action.start(`Performing ${cli_core_1.clColor.yellow(operation)} operation ${resource ? `on ${cli_core_1.clColor.api.resource(resource)}` : ''}`);
+    const baseUrl = cli_core_1.clApi.baseURL('metrics', flags.organization, flags.domain);
+    const analysisPath = common_1.analysisOperations.includes(operation) ? 'analysis/' : '';
+    const resourcePath = resource ? `${resource}/` : '';
+    const endpoint = `${baseUrl}/${cli_core_1.clConfig.metrics.default_path}/${resourcePath}${analysisPath}${operation}`;
+    const body = JSON.stringify(query);
+    const headers = {
+        'Accept': 'application/vnd.api.v1+json',
+        'Content-Type': 'application/vnd.api+json',
+        'Authorization': `Bearer ${flags.accessToken}`
+    };
+    const response = fetch(endpoint, {
+        method: "POST",
+        headers,
+        body
+    });
+    return await response;
+}