@commercelayer/cli-plugin-provisioning 1.0.0

package/lib/base.js

@@ -0,0 +1,496 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cliux = exports.Args = exports.Flags = exports.BaseFilterCommand = exports.BaseCommand = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+Object.defineProperty(exports, "Flags", { enumerable: true, get: function () { return core_1.Flags; } });
+Object.defineProperty(exports, "Args", { enumerable: true, get: function () { return core_1.Args; } });
+Object.defineProperty(exports, "cliux", { enumerable: true, get: function () { return core_1.ux; } });
+const resources_1 = require("./util/resources");
+const output_1 = require("./output");
+const csv_1 = require("./csv");
+const fs_1 = require("fs");
+const provisioning_sdk_1 = tslib_1.__importStar(require("@commercelayer/provisioning-sdk"));
+// import { availableLanguages, buildCommand, getLanguageArg, languageInfo, promptLanguage, type RequestData } from './lang'
+const cli_core_1 = require("@commercelayer/cli-core");
+// import { aliasExists, checkAlias, type CommandParams, loadCommandData, type ResourceOperation, saveCommandData } from './commands'
+// import type { ResourceId, ResourceType } from '@commercelayer/provisioning-sdk/lib/cjs/resource'
+const pkg = require('../package.json');
+// export const FLAG_SAVE_PARAMS = 'save-args'
+// export const FLAG_LOAD_PARAMS = 'load-args'
+class BaseCommand extends core_1.Command {
+    checkApplication(accessToken, kinds) {
+        const info = cli_core_1.clToken.decodeAccessToken(accessToken);
+        if (info === null)
+            this.error('Invalid access token provided');
+        else if (!kinds.includes(info.application.kind))
+            this.error(`Invalid application kind: ${cli_core_1.clColor.msg.error(info.application.kind)}. Application kind must be one of the following: ${cli_core_1.clColor.cyanBright(kinds.join(', '))}`);
+        return true;
+    }
+    checkResourceId(resource, resourceId, required = true) {
+        let res = resource;
+        let id = resourceId;
+        const si = res.indexOf('/');
+        if (si >= 0) {
+            const rt = res.split('/');
+            if (id && rt[1])
+                this.error(`Double definition of resource id: [${res}, ${id}]`, { suggestions: [`Define resource id as command argument (${cli_core_1.clColor.italic(id)}) or as part of the resource itself (${cli_core_1.clColor.italic(res)}) but not both`] });
+            else
+                id = rt[1];
+            res = rt[0];
+        }
+        const res_ = (0, resources_1.findResource)(res, { singular: true });
+        const singleton = res_?.singleton || false;
+        if (id) {
+            if (singleton)
+                this.error(`Singleton resource ${cli_core_1.clColor.api.resource(res)} does not require id`);
+            if (id.includes('/'))
+                this.error(`Invalid resourde id: ${cli_core_1.clColor.msg.error(id)}`);
+        }
+        else if (required && !singleton)
+            this.error('Resource id not defined');
+        return {
+            res,
+            id,
+            singleton,
+        };
+    }
+    checkResource(res, { required = true, singular = false } = {}) {
+        if (!res && required)
+            this.error('Resource type not defined');
+        const resource = (0, resources_1.findResource)(res, { singular });
+        if (resource === undefined)
+            this.error(`Invalid resource ${cli_core_1.clColor.style.error(res)}`, { suggestions: [`Execute command ${cli_core_1.clColor.style.command('resources')} to get a list of all available CLI resources`] });
+        return resource;
+    }
+    initCommerceLayer(flags, ...options) {
+        const domain = flags.domain;
+        const accessToken = flags.accessToken;
+        const userAgent = cli_core_1.clUtil.userAgent(this.config);
+        const cl = (0, provisioning_sdk_1.default)({ domain, accessToken, userAgent, ...options });
+        if ('cl' in this)
+            this.cl = cl;
+        return cl;
+    }
+    checkOperation(sdk, name, attributes) {
+        if (!sdk[name]) {
+            // resource attributes reference, reference_origin and metadata are always updatable
+            if ((name === 'update') && attributes) {
+                if (!Object.keys(attributes).some(attr => !['reference', 'reference_origin', 'metadata'].includes(attr)))
+                    return true;
+            }
+            this.error(`Operation not supported for resource ${cli_core_1.clColor.api.resource(sdk.type())}: ${cli_core_1.clColor.msg.error(name)}`);
+        }
+        return true;
+    }
+    printOutput(output, flags) {
+        if (output && !flags['headers-only'])
+            this.log((0, output_1.formatOutput)(output, flags));
+    }
+    printHeaders(headers, flags) {
+        if (headers) {
+            if (flags.headers || flags['headers-only']) {
+                this.log('---------- Response Headers ----------');
+                if (Object.keys(headers).length === 0)
+                    this.log(cli_core_1.clColor.italic('No headers'));
+                else
+                    this.log((0, output_1.formatOutput)(headers, flags));
+                this.log('---------- ---------------- ----------');
+            }
+        }
+    }
+    printError(error, flags, args) {
+        let err = error;
+        if (provisioning_sdk_1.CommerceLayerProvisioningStatic.isApiError(err)) {
+            err = err.errors || `Unable to find resource of type ${cli_core_1.clColor.msg.error(args.resource)} and id ${cli_core_1.clColor.msg.error(args.id)}`;
+        }
+        else if (error.response) {
+            if (error.response.status === 401)
+                this.error(cli_core_1.clColor.bg.red(`${error.response.statusText} [${error.response.status}]`), { suggestions: ['Execute login to get access to the selected resource'] });
+            else if (error.response.status === 500)
+                this.error(`We're sorry, but something went wrong (${error.response.status})`);
+            else if (error.response.status === 429)
+                this.error(`You have done too many requests in the last 5 minutes (${error.response.status})`);
+            else
+                err = error.response.data.errors;
+        }
+        else if (error.message)
+            err = error.message;
+        this.error((0, output_1.formatOutput)(err, flags));
+    }
+    _keyvalFlag(flag, type = 'attribute') {
+        const param = {};
+        if (flag && (flag.length > 0)) {
+            flag.forEach(f => {
+                const eqi = f.indexOf('=');
+                if (eqi < 1)
+                    this.error(`Invalid ${type.toLowerCase()} ${cli_core_1.clColor.msg.error(f)}`, {
+                        suggestions: [`${cli_core_1.clText.capitalize(type)} flags must be defined using the format ${cli_core_1.clColor.cli.value('name=value')}`],
+                    });
+                const name = f.substr(0, eqi);
+                const value = f.substr(eqi + 1);
+                if (param[name])
+                    this.warn(`${cli_core_1.clText.capitalize(type)} ${cli_core_1.clColor.msg.warning(name)} has already been defined`);
+                param[name] = value;
+            });
+        }
+        return param;
+    }
+    attributeFlag(flag) {
+        const attr = this._keyvalFlag(flag, 'attribute');
+        const attributes = {};
+        Object.entries(attr).forEach(([k, v]) => {
+            attributes[k] = (v === 'null') ? null : v;
+        });
+        return attributes;
+    }
+}
+exports.BaseCommand = BaseCommand;
+BaseCommand.baseFlags = {
+    domain: core_1.Flags.string({
+        char: 'd',
+        required: false,
+        hidden: true,
+        env: 'CL_CLI_DOMAIN',
+    }),
+    accessToken: core_1.Flags.string({
+        hidden: true,
+        required: true,
+        env: 'CL_CLI_ACCESS_TOKEN',
+    })
+};
+class BaseFilterCommand extends BaseCommand {
+    // INIT (override)
+    async init() {
+        // Check for plugin updates only if in visible mode
+        if (!this.argv.includes('--blind') && !this.argv.includes('--silent') && !this.argv.includes('--quiet'))
+            cli_core_1.clUpdate.checkUpdate(pkg);
+        return await super.init();
+    }
+    // CATCH (override)
+    async catch(error) {
+        if (error.message?.match(/Missing \d required args?:\nresource/))
+            this.error(`Missing argument ${cli_core_1.clColor.style.error('resource')}`, { suggestions: [`Execute command ${cli_core_1.clColor.style.command('resources')} to get a list of all available Provisioning resources`] });
+        // else throw error				// overwrite command catch method
+        else
+            return await super.catch(error); // extend command catch method
+    }
+    // -- CUSTOM METHODS -- //
+    includeFlag(flag, relationships, force) {
+        const values = [];
+        if (flag) {
+            const flagValues = flag.map(f => f.split(',').map(t => t.trim()));
+            flagValues.forEach(a => values.push(...a));
+            if (values.some(f => f.split('.').length > 3) && !force)
+                this.error('Can be only included resources within the 3rd level of depth');
+        }
+        if (relationships) {
+            Object.keys(relationships).forEach(r => {
+                if (!values.includes(r))
+                    values.push(r);
+            });
+        }
+        return values;
+    }
+    objectFlag(flag) {
+        const objects = {};
+        if (flag && (flag.length > 0)) {
+            flag.forEach(f => {
+                const slashSep = f.indexOf('/');
+                if (slashSep < 0)
+                    this.error(`No name or fields defined in flag object${cli_core_1.clColor.style.flag(f)}`);
+                const name = f.substring(0, slashSep);
+                if (name === '')
+                    this.error(`No name defined in flag object ${f}`);
+                const fields = f.substring(slashSep + 1).split(/(?<!\\),/g).map(v => v.trim()); // escape ',' in value with \\ (double back slash)
+                if (fields[0].trim() === '')
+                    this.error(`No fields defined for object field ${cli_core_1.clColor.style.attribute(name)}`);
+                const obj = {};
+                fields.forEach(f => {
+                    const eqi = f.indexOf('=');
+                    if (eqi < 0)
+                        this.error(`No value defined for object field ${cli_core_1.clColor.style.attribute(f)} of object ${cli_core_1.clColor.style.attribute(name)}`);
+                    const n = f.substring(0, eqi);
+                    const v = f.substring(eqi + 1).replace(/\\,/g, ',');
+                    obj[n] = cli_core_1.clCommand.fixValueType(v);
+                });
+                if (objects[name] === undefined)
+                    objects[name] = {};
+                objects[name] = { ...objects[name], ...obj };
+            });
+        }
+        return objects;
+    }
+    fieldsFlag(flag, type) {
+        const fields = {};
+        if (flag && (flag.length > 0)) {
+            flag.forEach(f => {
+                let res = type;
+                let val = f;
+                if (f.includes('/')) {
+                    const kv = f.split('/');
+                    if (kv.length > 2)
+                        this.error('Can be defined only one resource for each fields flag', { suggestions: [`Split the value ${cli_core_1.clColor.style.attribute(f)} into two fields flags`] });
+                    res = kv[0].replace('[', '').replace(']', '');
+                    this.checkResource(res);
+                    val = kv[1];
+                }
+                const values = val.split(',').map(v => v.trim());
+                if (values[0].trim() === '')
+                    this.error(`No fields defined for resource ${cli_core_1.clColor.api.resource(res)}`);
+                if (fields[res] === undefined)
+                    fields[res] = [];
+                fields[res].push(...values);
+            });
+        }
+        return fields;
+    }
+    whereFlag(flag) {
+        const wheres = {};
+        if (flag && (flag.length > 0)) {
+            flag.forEach(f => {
+                const wt = f.split('=');
+                if (wt.length < 2)
+                    this.error(`Filter flag must be in the form ${cli_core_1.clColor.style.attribute('predicate=value')}`);
+                const w = wt[0];
+                if (!cli_core_1.clFilter.available(w))
+                    this.error(`Invalid query filter: ${cli_core_1.clColor.style.error(w)}`, {
+                        suggestions: [`Execute command ${cli_core_1.clColor.style.command('resources:filters')} to get a full list of all available filter predicates`],
+                        ref: 'https://docs.commercelayer.io/api/filtering-data#list-of-predicates',
+                    });
+                const v = wt[1];
+                wheres[w] = v;
+            });
+        }
+        return wheres;
+    }
+    sortFlag(flag) {
+        const sort = {};
+        if (flag && (flag.length > 0)) {
+            if (flag.some(f => {
+                const ft = f.split(',');
+                return (ft.includes('asc') || ft.includes('desc'));
+            })) {
+                flag.forEach(f => {
+                    const ot = f.split(',');
+                    if (ot.length > 2)
+                        this.error('Can be defined only one field for each sort flag', { suggestions: [`Split the value ${cli_core_1.clColor.style.attribute(f)} into two or more sort flags`] });
+                    const of = ot[0];
+                    if (of.startsWith('-'))
+                        this.error('You cannot mix two ordering syntaxes', { suggestions: [`Choose between the style ${cli_core_1.clColor.cli.value('<field>,<order>')} and the style ${cli_core_1.clColor.cli.value('[-]<field>')}`] });
+                    const sd = ot[1] || 'asc';
+                    if (!['asc', 'desc'].includes(sd))
+                        this.error(`Invalid sort flag: ${cli_core_1.clColor.msg.error(f)}`, { suggestions: [`Sort direction can assume only the values ${cli_core_1.clColor.cli.value('asc')} or ${cli_core_1.clColor.cli.value('desc')}`] });
+                    sort[of] = sd;
+                });
+            }
+            else {
+                flag.forEach(fl => {
+                    fl.split(',').forEach(f => {
+                        const desc = f.startsWith('-');
+                        const of = desc ? f.slice(1) : f;
+                        const sd = desc ? 'desc' : 'asc';
+                        sort[of] = sd;
+                    });
+                });
+            }
+        }
+        return sort;
+    }
+    metadataFlag(flag, { fixTypes = false } = {}) {
+        const md = this._keyvalFlag(flag, 'metadata');
+        const metadata = {};
+        Object.keys(md).forEach(k => {
+            metadata[k] = fixTypes ? cli_core_1.clCommand.fixValueType(md[k]) : md[k];
+        });
+        return metadata;
+    }
+    relationshipFlag(flag) {
+        const relationships = {};
+        if (flag && (flag.length > 0)) {
+            flag.forEach(f => {
+                let rel;
+                let name;
+                let id;
+                let type;
+                const rt = f.split('=');
+                if (rt.length === 2) {
+                    if ((name = rt[0]) === '')
+                        this.error('Relationship attribute name is empty');
+                    if ((rel = rt[1]) === '')
+                        this.error('Relationship value is empty');
+                }
+                else
+                    this.error(`Invalid relationship flag: ${cli_core_1.clColor.msg.error(f)}`, { suggestions: [`Define the relationship using the format ${cli_core_1.clColor.cli.value('attribute_name=resource_type/resource_id')}`] });
+                const vt = rel.split('/');
+                if (vt.length === 2) {
+                    if ((type = vt[0]) === '')
+                        this.error('Relationship type is empty');
+                    if ((id = vt[1]) === '')
+                        this.error('Relationship resource id is empty');
+                }
+                else {
+                    id = vt[0];
+                    const res = (0, resources_1.findResource)(name, { singular: true });
+                    if (res)
+                        type = res.api;
+                    else
+                        this.error('Relationship type is empty');
+                }
+                // const res = this.checkResource(type)
+                if (relationships[name])
+                    this.warn(`Relationship ${cli_core_1.clColor.yellow(name)} has already been defined`);
+                relationships[name] = { id, type };
+            });
+        }
+        return relationships;
+    }
+    extractFlag(flag) {
+        const extract = {};
+        if (flag && (flag.length > 0)) {
+            flag.forEach(f => {
+                const kv = f.split('/');
+                if (kv.length > 2)
+                    this.error('Can be defined only one field for each extract flag', { suggestions: [`Split the value ${cli_core_1.clColor.cli.value(f)} into two extract flags`] });
+                else if (kv.length === 1)
+                    this.error(`No fields defined for object ${cli_core_1.clColor.cli.value(kv[0])}`);
+                const name = kv[0];
+                if (name === '')
+                    this.error(`No name defined in flag extract ${f}`);
+                if (kv[1].trim() === '')
+                    this.error(`No fields defined for object ${cli_core_1.clColor.cli.value(kv[0])}`);
+                const fields = kv[1].split(/(?<!\\),/g).map(v => v.trim()); // escape ',' in value with \\ (double back slash)
+                if (fields[0].trim() === '')
+                    this.error(`No fields defined for object field ${cli_core_1.clColor.cli.value(name)}`);
+                if (extract[name] === undefined)
+                    extract[name] = [];
+                extract[name].push(...fields);
+            });
+        }
+        return extract;
+    }
+    extractObjectFields(fields, obj) {
+        Object.entries(fields).forEach(([extObj, extFields]) => {
+            const objPath = extObj.split('.');
+            let curObj = obj;
+            for (const op of objPath) {
+                if (curObj)
+                    curObj = curObj[op]; // if not undefined go to next level object
+                else
+                    break; // if undefined stop search in depth
+            }
+            // if leaf field is an object and it is not a relationship then extract its fields
+            if (curObj && (typeof curObj === 'object') && !curObj.id && !curObj.type)
+                // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+                for (const k of Object.keys(curObj))
+                    if (!extFields.includes(k))
+                        delete curObj[k];
+        });
+    }
+    saveOutput(output, flags) {
+        try {
+            let filePath = flags.save || flags['save-path'];
+            if (!filePath)
+                this.warn('Undefined output save path');
+            filePath = cli_core_1.clUtil.specialFolder(filePath, flags['save-path']);
+            const fileExport = flags.csv ? csv_1.exportCsv : output_1.exportOutput;
+            fileExport(output, flags, filePath)
+                .then(() => {
+                if ((0, fs_1.existsSync)(filePath))
+                    this.log(`Command output saved to file ${cli_core_1.clColor.style.path(filePath)}\n`);
+            })
+                .catch(() => this.error(`Unable to save command output to file ${cli_core_1.clColor.style.path(filePath)}`, { suggestions: ['Please check you have the right file system permissions'] }));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                this.warn(`Path not found ${cli_core_1.clColor.msg.error(error.path)}: execute command with flag ${cli_core_1.clColor.cli.flag('-X')} to force path creation`);
+            else
+                throw error;
+        }
+        finally {
+            this.log();
+        }
+    }
+}
+exports.BaseFilterCommand = BaseFilterCommand;
+BaseFilterCommand.flags = {
+    include: core_1.Flags.string({
+        char: 'i',
+        multiple: true,
+        description: 'comma separated resources to include',
+    }),
+    fields: core_1.Flags.string({
+        char: 'f',
+        multiple: true,
+        description: 'comma separeted list of fields in the format [resourceType/]field1,field2...',
+    }),
+    json: core_1.Flags.boolean({
+        char: 'j',
+        description: 'convert output in standard JSON format',
+    }),
+    unformatted: core_1.Flags.boolean({
+        char: 'u',
+        description: 'print unformatted JSON output',
+        dependsOn: ['json'],
+    }),
+    raw: core_1.Flags.boolean({
+        char: 'R',
+        description: 'print out the raw API response',
+        hidden: false,
+    }),
+    /*
+    doc: Flags.boolean({
+      description: 'show the CLI command in a specific language',
+      exclusive: ['raw'],
+      helpGroup: 'documentation',
+    }),
+    lang: Flags.string({
+      char: 'l',
+      description: 'show the CLI command in the specified language syntax',
+      exclusive: availableLanguages,
+      options: availableLanguages,
+      dependsOn: ['doc'],
+      helpGroup: 'documentation',
+    }),
+    curl: Flags.boolean({
+      description: `show the equivalent ${languageInfo.curl.label} of the CLI command`,
+      exclusive: ['lang', ...availableLanguages.filter(l => l !== 'curl')],
+      parse: async (): Promise<string> => await Promise.resolve('curl'),
+      hidden: !availableLanguages.includes('curl'),
+      dependsOn: ['doc'],
+      helpGroup: 'documentation',
+    }),
+    node: Flags.boolean({
+      description: `show the equivalent ${languageInfo.node.label} of the CLI command`,
+      exclusive: ['lang', ...availableLanguages.filter(l => l !== 'node')],
+      parse: async (): Promise<string> => await Promise.resolve('node'),
+      hidden: !availableLanguages.includes('node'),
+      dependsOn: ['doc'],
+      helpGroup: 'documentation',
+    }),
+    [FLAG_SAVE_PARAMS]: Flags.string({
+      description: 'save command data to file for future use',
+    }),
+    [FLAG_LOAD_PARAMS]: Flags.string({
+      description: 'load previously saved command arguments',
+    }),
+    */
+    headers: core_1.Flags.boolean({
+        char: 'H',
+        description: 'show response headers',
+        dependsOn: ['raw'],
+        exclusive: ['headers-only'],
+    }),
+    'headers-only': core_1.Flags.boolean({
+        char: 'Y',
+        description: 'show only response headers',
+        dependsOn: ['raw'],
+        exclusive: ['headers', 'fields', 'include'],
+    }),
+};
+class default_1 extends BaseFilterCommand {
+}
+default_1.args = {
+    resource: core_1.Args.string({ name: 'resource', description: 'the resource type', required: true }),
+};
+exports.default = default_1;

package/lib/commands/provisioning/create.d.ts

@@ -0,0 +1,21 @@
+import Command from '../../base';
+export default class ProvisioningCreate extends Command {
+    static description: string;
+    static aliases: string[];
+    static examples: string[];
+    static flags: {
+        attribute: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        object: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        relationship: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        metadata: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        data: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        include: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        fields: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        unformatted: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        raw: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        headers: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'headers-only': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<any>;
+}

package/lib/commands/provisioning/create.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const base_1 = tslib_1.__importStar(require("../../base"));
+const cli_core_1 = require("@commercelayer/cli-core");
+// import { addRequestReader, isRequestInterrupted } from '../../lang'
+// import { mergeCommandParams } from '../../commands'
+const OPERATION = 'create';
+class ProvisioningCreate extends base_1.default {
+    async run() {
+        const { args, flags } = await this.parse(ProvisioningCreate);
+        const resource = this.checkResource(args.resource, { singular: true });
+        // const loadParams = flags[FLAG_LOAD_PARAMS]
+        // const saveCmd = flags[FLAG_SAVE_PARAMS]
+        // if (saveCmd) this.checkAlias(saveCmd, resource.api, OPERATION, this.config)
+        const showHeaders = flags.headers || flags['headers-only'];
+        // Raw request
+        if (flags.data) {
+            try {
+                const baseUrl = cli_core_1.clApi.baseURL(undefined, flags.domain, true);
+                const accessToken = flags.accessToken;
+                const rawRes = await cli_core_1.clApi.request.raw({ operation: cli_core_1.clApi.Operation.Create, baseUrl, accessToken, resource: resource.api }, cli_core_1.clApi.request.readDataFile(flags.data));
+                const out = flags.raw ? rawRes : cli_core_1.clApi.response.denormalize(rawRes);
+                this.printOutput(out, flags);
+                this.log(`\n${cli_core_1.clColor.style.success('Successfully')} created new resource of type ${cli_core_1.clColor.style.resource(resource.api)} with id ${cli_core_1.clColor.style.id(rawRes.data.id)}\n`);
+                return out;
+            }
+            catch (error) {
+                this.printError(error, flags, args);
+            }
+        }
+        const cl = this.initCommerceLayer(flags);
+        // Attributes flags
+        const attributes = this.attributeFlag(flags.attribute);
+        // Objects flags
+        const objects = this.objectFlag(flags.object);
+        // Relationships flags
+        const relationships = this.relationshipFlag(flags.relationship);
+        // Metadata flags
+        const metadata = this.metadataFlag(flags.metadata, { fixTypes: true });
+        // Relationships
+        if (relationships && (Object.keys(relationships).length > 0))
+            Object.entries(relationships).forEach(([key, value]) => {
+                const relSdk = cl[value.type];
+                const rel = relSdk.relationship(value);
+                attributes[key] = rel;
+            });
+        // Objects
+        if (objects && (Object.keys(objects).length > 0)) {
+            for (const o of Object.keys(objects)) {
+                if (Object.keys(attributes).includes(o))
+                    this.warn(`Object ${o} will overwrite attribute ${o}`);
+                else
+                    attributes[o] = objects[o];
+            }
+        }
+        // Metadata
+        if (metadata && (Object.keys(metadata).length > 0)) {
+            if (attributes.metadata)
+                this.warn(`Attribute ${cli_core_1.clColor.style.attribute('metadata')} will be overwritten by the content defined with the flag ${cli_core_1.clColor.style.flag('-m')}`);
+            attributes.metadata = metadata;
+        }
+        // Include flags
+        const include = this.includeFlag(flags.include, relationships);
+        // Fields flags
+        const fields = this.fieldsFlag(flags.fields, resource.api);
+        const rawReader = flags.raw ? cl.addRawResponseReader({ headers: showHeaders }) : undefined;
+        // const reqReader = flags.doc ? addRequestReader(cl) : undefined
+        const params = {};
+        try {
+            const resSdk = cl[resource.api];
+            this.checkOperation(resSdk, OPERATION);
+            if (include && (include.length > 0))
+                params.include = include;
+            if (fields && (Object.keys(fields).length > 0))
+                params.fields = fields;
+            // Load saved command arguments
+            // if (loadParams) {
+            //   const savedParams = this.loadParams(loadParams, resource.api, OPERATION)
+            //   if (savedParams) mergeCommandParams(params, savedParams)
+            // }
+            const res = await resSdk.create(attributes, params);
+            const out = (flags.raw && rawReader) ? rawReader.rawResponse : res;
+            this.printHeaders(rawReader?.headers, flags);
+            this.printOutput(out, flags);
+            this.log(`\n${cli_core_1.clColor.style.success('Successfully')} created new resource of type ${cli_core_1.clColor.style.resource(resource.api)} with id ${cli_core_1.clColor.style.id(res.id)}\n`);
+            // Save command arguments
+            // if (saveCmd) this.saveParams(saveCmd, { type: resource.api }, OPERATION, params)
+            return out;
+        }
+        catch (error) {
+            /*
+            if (isRequestInterrupted(error) && reqReader) {
+              await this.showLiveDocumentation(reqReader.request, params, flags)
+              cl.removeInterceptor('request', reqReader.id)
+            } else */ this.printError(error);
+        }
+    }
+}
+ProvisioningCreate.description = 'create a new resource';
+ProvisioningCreate.aliases = ['prov:create', 'pc', 'pcreate'];
+ProvisioningCreate.examples = [
+    '$ commercelayer provisioning:create organizations -a name=MyOrg',
+    '$ clayer prov:create subscriptions -r plan=plans/<planId>',
+    '$ cl prov:create organization -a name=MyOrg -m meta_key="meta value"',
+    '$ cl pc roles -D /path/to/data/file/data.json',
+];
+ProvisioningCreate.flags = {
+    ...base_1.default.flags,
+    attribute: base_1.Flags.string({
+        char: 'a',
+        description: 'define a resource attribute',
+        multiple: true,
+    }),
+    object: base_1.Flags.string({
+        char: 'O',
+        description: 'define a resource object attribute',
+        multiple: true,
+    }),
+    relationship: base_1.Flags.string({
+        char: 'r',
+        description: 'define a relationship with another resource',
+        multiple: true,
+    }),
+    metadata: base_1.Flags.string({
+        char: 'm',
+        description: 'define a metadata attribute or a set of metadata attributes',
+        multiple: true,
+    }),
+    data: base_1.Flags.string({
+        char: 'D',
+        description: 'the data file to use as request body',
+        multiple: false,
+        exclusive: ['attribute', 'relationship', 'metadata', 'doc' /* , FLAG_LOAD_PARAMS, FLAG_SAVE_PARAMS */],
+    })
+};
+exports.default = ProvisioningCreate;

package/lib/commands/provisioning/delete.d.ts

@@ -0,0 +1,20 @@
+import Command from '../../base';
+export default class ProvisioningDelete extends Command {
+    static description: string;
+    static aliases: string[];
+    static examples: string[];
+    static flags: {
+        include: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        fields: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        unformatted: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        raw: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        headers: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'headers-only': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+        resource: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<any>;
+}