@commercelayer/cli-plugin-provisioning 1.0.0

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

@@ -0,0 +1,21 @@
+import Command from '../../base';
+export default class ProvisioningRetrieve extends Command {
+    static description: string;
+    static aliases: string[];
+    static examples: string[];
+    static flags: {
+        extract: 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>;
+    };
+    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>;
+}

package/lib/commands/provisioning/retrieve.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const base_1 = tslib_1.__importStar(require("../../base"));
+// import { addRequestReader, isRequestInterrupted } from '../../lang'
+// import { mergeCommandParams } from '../../commands'
+const OPERATION = 'retrieve';
+class ProvisioningRetrieve extends base_1.default {
+    async run() {
+        const { args, flags } = await this.parse(ProvisioningRetrieve);
+        const { res, id } = this.checkResourceId(args.resource, args.id);
+        const resource = this.checkResource(res, { 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'];
+        // Include flags
+        const include = this.includeFlag(flags.include);
+        // Fields flags
+        const fields = this.fieldsFlag(flags.fields, resource.api);
+        const cl = this.initCommerceLayer(flags);
+        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.retrieve(id, params);
+            const out = (flags.raw && rawReader) ? rawReader.rawResponse : res;
+            if (flags.extract) {
+                const ext = this.extractFlag(flags.extract);
+                this.extractObjectFields(ext, out);
+            }
+            this.printHeaders(rawReader?.headers, flags);
+            this.printOutput(out, flags);
+            // Save command output
+            // if (flags.save || flags['save-path']) this.saveOutput(out, flags)
+            // Save command arguments
+            // if (saveCmd) this.saveParams(saveCmd, { type: resource.api, id }, 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, flags, args);
+        }
+    }
+}
+ProvisioningRetrieve.description = 'fetch a single resource';
+ProvisioningRetrieve.aliases = ['prov:retrieve', 'pr', 'pretrieve'];
+ProvisioningRetrieve.examples = [
+    '$ commercelayer provisioning:retrieve roles/<roleId>',
+    '$ commercelayer prov:retrieve roles <roleId>',
+    '$ cl prov:retrieve roles <roleId>',
+    '$ clayer pr roles/<roleId>',
+];
+ProvisioningRetrieve.flags = {
+    ...base_1.default.flags,
+    /*
+    save: Flags.string({
+      char: 'x',
+      description: 'save command output to file',
+      multiple: false,
+      exclusive: ['save-path'],
+    }),
+    'save-path': Flags.string({
+      char: 'X',
+      description: 'save command output to file and create missing path directories',
+      multiple: false,
+      exclusive: ['save'],
+    }),
+    */
+    extract: base_1.Flags.string({
+        char: 'e',
+        description: 'extract subfields from object attributes',
+        multiple: true,
+        exclusive: ['raw'],
+    }),
+};
+ProvisioningRetrieve.args = {
+    ...base_1.default.args,
+    id: base_1.Args.string({ name: 'id', description: 'id of the resource to retrieve', required: false }),
+};
+exports.default = ProvisioningRetrieve;

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

@@ -0,0 +1,26 @@
+import Command from '../../base';
+export default class ProvisioningUpdate 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>;
+        'metadata-replace': 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>;
+    };
+    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>;
+}

package/lib/commands/provisioning/update.js

@@ -0,0 +1,157 @@
+"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");
+const OPERATION = 'update';
+class ProvisioningUpdate extends base_1.default {
+    async run() {
+        const { args, flags } = await this.parse(ProvisioningUpdate);
+        const { res, id } = this.checkResourceId(args.resource, args.id);
+        const resource = this.checkResource(res, { 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.Update, baseUrl, accessToken, resource: resource.api }, cli_core_1.clApi.request.readDataFile(flags.data), id);
+                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')} updated resource of type ${cli_core_1.clColor.style.resource(resource.api)} with id ${cli_core_1.clColor.style.id(rawRes.id)}\n`);
+                return out;
+            }
+            catch (error) {
+                this.printError(error);
+            }
+        }
+        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 || flags['metadata-replace']);
+        // Relationships
+        if (relationships && Object.keys(relationships).length > 0)
+            Object.entries(relationships).forEach(([key, value]) => {
+                const relSdk = cl[value.type];
+                const rel = relSdk.relationship(((value.id === null) || (value.id === 'null')) ? null : 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 flags ${cli_core_1.clColor.style.flag('-m/-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, attributes);
+            if (include && (include.length > 0))
+                params.include = include;
+            if (fields && (Object.keys(fields).length > 0))
+                params.fields = fields;
+            // Metadata attributes merge
+            if (flags.metadata) {
+                const params = { fields: { [resource.api]: ['metadata'] } };
+                const remRes = await resSdk.retrieve(id, params);
+                const remMeta = remRes.metadata;
+                if (remMeta && (Object.keys(remMeta).length > 0))
+                    attributes.metadata = { ...remMeta, ...metadata };
+            }
+            attributes.id = id;
+            // Load saved command arguments
+            // if (loadParams) {
+            //   const savedParams = this.loadParams(loadParams, resource.api, OPERATION)
+            //   if (savedParams) mergeCommandParams(params, savedParams)
+            // }
+            const res = await resSdk.update(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')} updated 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, undefined, flags)
+              cl.removeInterceptor('request', reqReader.id)
+            } else */ this.printError(error, flags, args);
+        }
+    }
+}
+ProvisioningUpdate.description = 'update an existing resource';
+ProvisioningUpdate.aliases = ['prov:update', 'pu', 'pupdate', 'pupd'];
+ProvisioningUpdate.examples = [
+    '$ commercelayer provisioning:update roles/<roleId> -a reference=referenceId',
+    '$ commercelayer prov:update roles <roleId> -a reference_origin="Ref Origin"',
+    '$ cl prov:update roles/<roleId> -m meta_key="meta value"',
+    '$ cl pu roles <roleId> -M meta_key="metadata overwrite',
+    '$ clayer prov:update roles <roleId> -D /path/to/data/file/data.json',
+];
+ProvisioningUpdate.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 and merge it with the metadata already present in the remote resource',
+        multiple: true,
+        exclusive: ['metadata-replace'],
+    }),
+    'metadata-replace': base_1.Flags.string({
+        char: 'M',
+        description: 'define a metadata attribute and replace every item already present in the remote resource',
+        multiple: true,
+        exclusive: ['metadata'],
+    }),
+    data: base_1.Flags.string({
+        char: 'D',
+        description: 'the data file to use as request body',
+        multiple: false,
+        exclusive: ['attribute', 'relationship', 'metadata', 'metadata-replace', 'doc' /*, FLAG_LOAD_PARAMS, FLAG_SAVE_PARAMS */],
+    })
+};
+ProvisioningUpdate.args = {
+    ...base_1.default.args,
+    id: base_1.Args.string({ name: 'id', description: 'id of the resource to update', required: false }),
+};
+exports.default = ProvisioningUpdate;

package/lib/csv.d.ts

@@ -0,0 +1,3 @@
+declare const formatCsv: (obj: object[], flags?: any) => string;
+declare const exportCsv: (output: any, flags: any, path: string) => Promise<boolean>;
+export { formatCsv, exportCsv };

package/lib/csv.js

@@ -0,0 +1,98 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportCsv = exports.formatCsv = void 0;
+const json_2_csv_1 = require("json-2-csv");
+const fs_1 = require("fs");
+const cli_core_1 = require("@commercelayer/cli-core");
+const formatCsv = (obj, flags) => {
+    return cli_core_1.clOutput.printCSV(obj, flags);
+};
+exports.formatCsv = formatCsv;
+const analyzeItem = (name, item, flags) => {
+    const keys = new Set();
+    if (item)
+        if (Array.isArray(item)) {
+            for (const i of item) {
+                const ks = analyzeItem(name, i, flags);
+                ks.forEach(k => keys.add(k));
+            }
+        }
+        else if (typeof item === 'object') {
+            const type = item.type;
+            const fields = [];
+            flags.fields.forEach((f) => {
+                if (!name && (!f.includes('/')))
+                    fields.push(...f.split(','));
+                else if (type && f.startsWith(type + '/'))
+                    fields.push(...f.substring(f.indexOf('/') + 1).split(','));
+            });
+            for (const [k, v] of Object.entries(item)) {
+                // exclude 'type' fields
+                if (k === 'type')
+                    continue;
+                // exclude 'id' fields that are not explicitly included
+                if ((k === 'id') && !fields.includes(k))
+                    continue;
+                const ks = analyzeItem(`${name ? name + '.' : ''}${k}`, v, flags);
+                ks.forEach(k => keys.add(k));
+            }
+        }
+        else if (name && (name !== 'type') && !name.endsWith('.type')) {
+            // 'type' field can't be included in CLI filter but is always included in API response
+            keys.add(name);
+        }
+    return keys;
+};
+const exportCsv = async (output, flags, path) => {
+    // Rename header fields
+    const header = {};
+    if (flags.header) {
+        flags.header.join(',').split(',').forEach((h) => {
+            const ft = h.split(':');
+            header[ft[0]] = ft[1];
+        });
+    }
+    // Include fields
+    const keys = analyzeItem(undefined, output, flags);
+    const includeKeys = [...keys].map(k => {
+        return { field: k, title: header[k] || k };
+    });
+    // Exclude fields
+    const excludeKeys = [];
+    if (flags.fields) {
+        if (!flags.fields.includes('id'))
+            excludeKeys.push('id');
+        if (!flags.fields.includes('type'))
+            excludeKeys.push('type');
+    }
+    if (flags.include) {
+        const include = [];
+        flags.include.forEach((i) => include.push(...i.split(',')));
+        include.forEach((i) => {
+            // excludeKeys.push(`${i}.id`)
+            excludeKeys.push(`${i}.type`);
+        });
+    }
+    // Delimiter
+    let delimiter = flags.delimiter || ',';
+    if (delimiter && (delimiter === 'TAB'))
+        delimiter = '\t';
+    const csv = (0, json_2_csv_1.json2csv)(output, {
+        excelBOM: true,
+        expandArrayObjects: true,
+        prependHeader: true,
+        sortHeader: false,
+        unwindArrays: true,
+        useDateIso8601Format: true,
+        emptyFieldValue: '',
+        // excludeKeys,
+        keys: includeKeys,
+        delimiter: {
+            field: delimiter,
+        },
+    });
+    (0, fs_1.writeFileSync)(path, csv);
+    return await Promise.resolve(true);
+};
+exports.exportCsv = exportCsv;

package/lib/output.d.ts

@@ -0,0 +1,5 @@
+declare const formatOutput: (out: any, flags?: any, { color }?: {
+    color?: boolean | undefined;
+}) => string;
+declare const exportOutput: (output: any, flags: any, filePath: string) => Promise<boolean>;
+export { formatOutput, exportOutput };

package/lib/output.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportOutput = exports.formatOutput = void 0;
+const fs_1 = require("fs");
+const cli_core_1 = require("@commercelayer/cli-core");
+const formatOutput = (out, flags, { color = true } = {}) => {
+    return cli_core_1.clOutput.formatOutput(out, flags, { color });
+};
+exports.formatOutput = formatOutput;
+const exportOutput = async (output, flags, filePath) => {
+    const out = formatOutput(output, flags, { color: false });
+    (0, fs_1.writeFileSync)(filePath, out);
+    return await Promise.resolve(true);
+};
+exports.exportOutput = exportOutput;

package/lib/util/resources/available.d.ts

@@ -0,0 +1,35 @@
+declare const RESOURCES: readonly [{
+    readonly name: "api_credential";
+    readonly api: "api_credentials";
+    readonly model: "ApiCredential";
+}, {
+    readonly name: "application_membership";
+    readonly api: "application_memberships";
+    readonly model: "ApplicationMembership";
+}, {
+    readonly name: "membership";
+    readonly api: "memberships";
+    readonly model: "Membership";
+}, {
+    readonly name: "organization";
+    readonly api: "organizations";
+    readonly model: "Organization";
+}, {
+    readonly name: "permission";
+    readonly api: "permissions";
+    readonly model: "Permission";
+}, {
+    readonly name: "role";
+    readonly api: "roles";
+    readonly model: "Role";
+}, {
+    readonly name: "user";
+    readonly api: "user";
+    readonly model: "User";
+    readonly singleton: true;
+}, {
+    readonly name: "version";
+    readonly api: "versions";
+    readonly model: "Version";
+}];
+export default RESOURCES;

package/lib/util/resources/available.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const RESOURCES = [
+    { name: 'api_credential', api: 'api_credentials', model: 'ApiCredential' },
+    { name: 'application_membership', api: 'application_memberships', model: 'ApplicationMembership' },
+    { name: 'membership', api: 'memberships', model: 'Membership' },
+    { name: 'organization', api: 'organizations', model: 'Organization' },
+    { name: 'permission', api: 'permissions', model: 'Permission' },
+    { name: 'role', api: 'roles', model: 'Role' },
+    { name: 'user', api: 'user', model: 'User', singleton: true },
+    { name: 'version', api: 'versions', model: 'Version' },
+];
+exports.default = RESOURCES;

package/lib/util/resources/build.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/util/resources/build.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const provisioning_sdk_1 = require("@commercelayer/provisioning-sdk");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const cli_core_1 = require("@commercelayer/cli-core");
+const isSingleton = (res) => {
+    return (cli_core_1.clText.singularize(res) === res);
+};
+const parseResourcesSdk = async () => {
+    const resList = provisioning_sdk_1.CommerceLayerProvisioningStatic.resources().map(r => {
+        const singular = cli_core_1.clText.singularize(r);
+        const item = {
+            name: singular,
+            api: r,
+            model: cli_core_1.clText.camelize(singular),
+            singleton: isSingleton(r),
+        };
+        return item;
+    });
+    return resList;
+};
+const exportResources = async ({ source = 'sdk', variable = false, name = 'resources', array = false, tab = false, immutable = false } = {}) => {
+    if (source !== 'sdk')
+        throw new Error(`Only 'sdk' source is currently supported`);
+    const resources = await parseResourcesSdk();
+    console.log('Parsed resources from source: ' + source);
+    const lines = [''];
+    if (variable || array)
+        lines.push((variable ? `const ${name} = ` : '') + (array ? '[' : ''));
+    const resLines = resources.map(res => {
+        let item = `${tab ? '\t' : ''}{ `;
+        item += `name: '${res.name}', api: '${res.api}', model: '${res.model}'`;
+        if (res.singleton)
+            item += ', singleton: true';
+        item += ' },';
+        return item;
+    });
+    lines.push(...resLines);
+    if (array)
+        lines.push(`]${immutable ? ' as const' : ''}\n`);
+    lines.push(`\n\nexport default ${name}\n`);
+    (0, fs_1.writeFileSync)((0, path_1.join)(__dirname, 'available.ts'), lines.join('\n'), { encoding: 'utf-8' });
+    console.log('Generated resource list');
+};
+const source = (process.argv.length > 2) ? (['sdk', 'online'].includes(process.argv[2]) ? process.argv[2] : 'sdk') : undefined;
+void exportResources({ source, variable: true, name: 'RESOURCES', array: true, tab: true, immutable: true });

package/lib/util/resources/index.d.ts

@@ -0,0 +1,12 @@
+import type { ResourceTypeLock } from '@commercelayer/provisioning-sdk/lib/cjs/api';
+interface Resource {
+    name: string;
+    api: ResourceTypeLock;
+    model: string;
+    singleton?: boolean;
+}
+declare const findResource: (res: string, { singular }?: {
+    singular?: boolean | undefined;
+}) => (Resource | undefined);
+declare const resourceList: (field: 'name' | 'api' | 'model') => string[];
+export { findResource, resourceList, type Resource };

package/lib/util/resources/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resourceList = exports.findResource = void 0;
+const tslib_1 = require("tslib");
+const available_1 = tslib_1.__importDefault(require("./available"));
+const resources = available_1.default;
+const findResource = (res, { singular = false } = {}) => {
+    if (res === undefined)
+        return undefined;
+    const lowRes = res.toLowerCase();
+    return resources.find(r => {
+        return (lowRes === r.api) || (singular && (lowRes === r.name));
+    });
+};
+exports.findResource = findResource;
+const resourceList = (field) => {
+    return resources.map(r => r[field]);
+};
+exports.resourceList = resourceList;