@contrail/cli 3.1.8 → 3.3.0-alpha

package/dist/commands/entities/get.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const core_1 = require("@oclif/core");
+const basecommand_1 = require("../../basecommand");
+const sdk_1 = require("@contrail/sdk");
+const login_1 = require("../../auth/login");
+const types_1 = require("../../api/types");
+const propertySpecifications_1 = require("../../helpers/propertySpecifications/propertySpecifications");
+let SHOULD_USE_PAGINATED_FIND = false;
+class GetEntity extends basecommand_1.BaseCommand {
+    static description = '(BETA) Get an entity';
+    static examples = [`contrail entities get color -- id=123`];
+    static flags = {
+        ...basecommand_1.BaseCommand.baseFlags,
+        outputFile: core_1.Flags.string({
+            char: 'o',
+            description: 'File to save the output (optional)',
+            required: false,
+        }),
+        skipHydrateRelationships: core_1.Flags.boolean({
+            char: 's',
+            description: 'Skip hydrating relationships when fetching the entity',
+            required: false,
+            default: false,
+        }),
+        relations: core_1.Flags.string({
+            char: 'r',
+            description: 'Comma-separated list of relations to include in the output',
+            required: false,
+        }),
+        propertySlugs: core_1.Flags.string({
+            char: 'p',
+            description: 'Comma-separated list of property slugs to include in the output',
+            required: false,
+        }),
+        paginated: core_1.Flags.boolean({
+            char: 'P',
+            description: 'If true, fetches all entities in a paginated manner',
+            required: false,
+            default: false,
+        }),
+    };
+    static args = {
+        typePath: core_1.Args.string({
+            description: 'The name of the entity type to fetch',
+            required: true,
+        }),
+    };
+    static strict = false;
+    async run() {
+        this.log('🚨 This command is in BETA and may change or be removed at any time.');
+        await (0, login_1.authUser)();
+        const { args, flags, argv } = await this.parse(GetEntity);
+        const { typePath } = args;
+        const { outputFile, propertySlugs, relations: relationString, skipHydrateRelationships, paginated: shouldUsePaginatedFind, } = flags;
+        SHOULD_USE_PAGINATED_FIND = shouldUsePaginatedFind;
+        const propertySpecificationArgs = argv
+            .slice(1, argv.length)
+            .filter(propertySpecifications_1.isValidPropertySpecification);
+        const propertySpecBySlug = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(propertySpecificationArgs);
+        const relations = relationString
+            ? relationString
+                .split(',')
+                .map((r) => r.trim())
+                .filter(Boolean)
+            : [];
+        const propertySlugsArray = propertySlugs
+            ? propertySlugs
+                .split(',')
+                .map((s) => s.trim())
+                .filter(Boolean)
+            : [];
+        try {
+            const response = await getEntityByTypePath(typePath, propertySpecBySlug, {
+                skipHydrateRelationships,
+                relations,
+                propertySlugs: propertySlugsArray,
+            });
+            if (outputFile) {
+                fs_1.default.writeFileSync(outputFile, JSON.stringify(response, null, 2));
+                this.log(`Output saved to ${outputFile}`);
+            }
+            else {
+                this.log(JSON.stringify(response, null, 2));
+            }
+        }
+        catch (e) {
+            this.error(`Error fetching entity: ${e.message}`);
+        }
+    }
+}
+exports.default = GetEntity;
+async function getEntityByTypePath(typePath, propertySpec, options = {}) {
+    const { propertySlugs, relations, skipHydrateRelationships } = options;
+    const id = propertySpec?.get('id')?.toString() || undefined;
+    const { root: entityName } = (0, types_1.parseTypePath)(typePath);
+    let criteria = {};
+    if (entityName === 'custom-entity' && !id) {
+        criteria.typePath = typePath;
+    }
+    else {
+        criteria = convertPropertySpecIntoCriteria(propertySpec || new Map());
+    }
+    return SHOULD_USE_PAGINATED_FIND
+        ? paginatedFind(entityName, { skipHydrateRelationships, relations, propertySlugs, criteria })
+        : find(entityName, { id, skipHydrateRelationships, relations, propertySlugs, criteria });
+}
+function convertPropertySpecIntoCriteria(propertySpec) {
+    const criteria = {};
+    propertySpec.forEach((value, slug) => {
+        criteria[slug] = value;
+    });
+    return criteria;
+}
+async function find(entityName, options = {}) {
+    const client = new sdk_1.Entities();
+    const { criteria, id, propertySlugs, skipHydrateRelationships, relations } = options;
+    const queryOptions = {
+        entityName,
+        skipHydrateRelationships,
+        relations,
+    };
+    if (propertySlugs && propertySlugs.length > 0) {
+        queryOptions.customParams = { propertySlugs: propertySlugs.join(',') };
+    }
+    return id ? client.get({ id, ...queryOptions }) : client.get({ criteria, ...queryOptions });
+}
+async function paginatedFind(entityName, options = {}) {
+    const client = new sdk_1.Entities();
+    const entities = [];
+    let nextPageKey = undefined;
+    while (true) {
+        const response = await client.get({
+            ...options,
+            entityName,
+            apiVersion: sdk_1.API_VERSION.V2,
+            nextPageKey,
+            customParams: {
+                propertySlugs: options.propertySlugs?.join(','),
+            },
+        });
+        nextPageKey = response.nextPageKey;
+        if (!response.results || response.results?.length === 0) {
+            break;
+        }
+        entities.push(...response.results);
+    }
+    return entities;
+}

package/dist/commands/entities/update.d.ts

@@ -0,0 +1,17 @@
+import { BaseCommand } from '../../basecommand';
+export default class UpdateEntity extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        skipHydrateRelationships: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        dryRun: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        alwaysConfirmEnv: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        logLevel: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        entityName: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+        id: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    static strict: boolean;
+    run(): Promise<void>;
+}

package/dist/commands/entities/update.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const basecommand_1 = require("../../basecommand");
+const sdk_1 = require("@contrail/sdk");
+const login_1 = require("../../auth/login");
+const propertySpecifications_1 = require("../../helpers/propertySpecifications/propertySpecifications");
+class UpdateEntity extends basecommand_1.BaseCommand {
+    static description = '(BETA) Update an entity';
+    static examples = ['contrail entities update color 123 -- name=obsidian hex=000000'];
+    static flags = {
+        ...basecommand_1.BaseCommand.baseFlags,
+        skipHydrateRelationships: core_1.Flags.boolean({
+            char: 's',
+            description: 'Skip hydrating relationships when updating the entity',
+            required: false,
+            default: false,
+        }),
+        dryRun: core_1.Flags.boolean({
+            char: 'd',
+            description: 'If true, does not create the entity but simulates the creation',
+            required: false,
+            default: false,
+        }),
+    };
+    static args = {
+        entityName: core_1.Args.string({
+            description: 'The name of the entity type to update',
+            required: true,
+        }),
+        id: core_1.Args.string({
+            description: 'The unique identifier of the entity',
+            required: true,
+        }),
+    };
+    static strict = false;
+    async run() {
+        this.log('🚨 This command is in BETA and may change or be removed at any time.');
+        await (0, login_1.authUser)();
+        const { args, argv } = await this.parse(UpdateEntity);
+        const { id, entityName } = args;
+        const { dryRun: isDryRun, skipHydrateRelationships } = this.flags;
+        const propertySpecArgs = argv.slice(1, argv.length).filter(propertySpecifications_1.isValidPropertySpecification);
+        const propertySpec = (0, propertySpecifications_1.parsePropertySpecificationsIntoMap)(propertySpecArgs);
+        if (propertySpec.size === 0) {
+            throw new Error('No valid properties provided for update');
+        }
+        if (propertySpec.has('id') && propertySpec.get('id') !== id) {
+            throw new Error(`Provided ID ${propertySpec.get('id')} does not match the entity ID ${id}`);
+        }
+        const changes = [...propertySpec.entries()].reduce((acc, [key, value]) => {
+            if (key === 'id') {
+                return acc;
+            }
+            acc[key] = value;
+            return acc;
+        }, {});
+        try {
+            const response = isDryRun
+                ? await mockUpdateById(entityName, id, changes, { skipHydrateRelationships })
+                : await updateEntityById(entityName, id, changes, { skipHydrateRelationships });
+            const messagePrefix = isDryRun
+                ? 'Dry run. Update skipped. Changes would be:'
+                : 'Entity updated successfully:';
+            this.log(`${messagePrefix}\n\n${JSON.stringify(response, null, 2)}`);
+        }
+        catch (e) {
+            this.error(`Error fetching entity: ${e.message}`);
+        }
+    }
+}
+exports.default = UpdateEntity;
+async function updateEntityById(entityName, id, changes, options = {}) {
+    const client = new sdk_1.Entities();
+    const { skipHydrateRelationships } = options;
+    return client.update({ entityName, id, object: changes, skipHydrateRelationships });
+}
+async function mockUpdateById(entityName, id, changes, options = {}) {
+    const client = new sdk_1.Entities();
+    const { skipHydrateRelationships } = options;
+    const entity = await client.get({ entityName, id, skipHydrateRelationships });
+    if (!entity) {
+        return null;
+    }
+    return { ...entity, ...changes };
+}

package/dist/common.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="node" />
 export declare function getSeparatorByPlatform(): string;
 export declare function delay(ms: number): Promise<NodeJS.Timeout>;
-export declare function removeSlash(string: any): string;
+export declare function removeSlash(string: string): string;

package/dist/helpers/app/app-deployer.js

@@ -14,6 +14,7 @@ const logger_1 = tslib_1.__importDefault(require("../../logger"));
 const child_process_1 = tslib_1.__importDefault(require("child_process"));
 const fs_1 = tslib_1.__importDefault(require("fs"));
 const extensions_deployer_1 = require("./extensions-deployer");
+const metadata_extractor_1 = require("./metadata-extractor");
 class AppDeployer {
     debug;
     dryRun;
@@ -165,6 +166,25 @@ class AppDeployer {
     }
 }
 exports.AppDeployer = AppDeployer;
+async function createSourceArchive(tmpDir) {
+    logger_1.default.info('Creating source code archive...');
+    const sourceFiles = ['src/', 'package.json', 'app.yml'];
+    if (fs_1.default.existsSync('package-lock.json')) {
+        sourceFiles.push('package-lock.json');
+    }
+    const sourceDir = `${tmpDir}/source`;
+    fs_1.default.mkdirSync(sourceDir, { recursive: true });
+    sourceFiles.forEach((sourceFile) => {
+        if (!fs_1.default.existsSync(sourceFile))
+            return;
+        const isDirectory = fs_1.default.statSync(sourceFile).isDirectory();
+        const copyOptions = isDirectory ? { recursive: true } : undefined;
+        fs_1.default.cpSync(sourceFile, `${sourceDir}/${sourceFile}`, copyOptions);
+    });
+    await (0, zip_a_folder_1.zip)(`${sourceDir}/`, `${tmpDir}/source-code.zip`);
+    logger_1.default.info('Source code archive created.');
+    return `${tmpDir}/source-code.zip`;
+}
 async function createNodePackage(appIdentifier, debug, dryRun) {
     // zip src code and package.json and package-lock.json files into a zip file
     // and upload as a code package.
@@ -178,6 +198,8 @@ async function createNodePackage(appIdentifier, debug, dryRun) {
             fs_1.default.cpSync('package-lock.json', 'tmp/package-lock.json');
         }
         fs_1.default.mkdirSync('tmp/node_modules', { recursive: true });
+        const buildInfoPath = await (0, metadata_extractor_1.createBuildMetadata)('tmp');
+        const sourceArchivePath = await createSourceArchive('tmp');
         logger_1.default.info('Installing production dependencies started...');
         child_process_1.default.execSync('npm install --omit=dev --prefix tmp/');
         logger_1.default.info('Installing production dependencies done.');
@@ -199,6 +221,9 @@ async function createNodePackage(appIdentifier, debug, dryRun) {
         logger_1.default.info('Copying Assets done.');
         // including the app.yml file in the package at the dist level
         fs_1.default.cpSync('app.yml', 'tmp/dist/app.yml');
+        // Copy build info and source code zip to dist
+        fs_1.default.cpSync(buildInfoPath, 'tmp/dist/build-info.json');
+        fs_1.default.cpSync(sourceArchivePath, 'tmp/dist/source-code.zip');
         logger_1.default.info('Zipping package...');
         await (0, zip_a_folder_1.zip)('tmp/', 'tmp.zip');
         logger_1.default.info('Zipping package done.');

package/dist/helpers/app/{extension-package.js → extension-package-deployer.js}

@@ -96,7 +96,7 @@ async function uploadExtensionPackage(appExtensionPackage, tmpDir, options) {
     });
     logger_1.default.debug(`${chalk_1.default.green.bold('EXTENSION')}      Uploaded extension package to ${appExtensionPackage.uploadURL}`);
     logger_1.default.info(`${chalk_1.default.green.bold('EXTENSION')}      Extension package uploaded. ID: ${appExtensionPackage.id}`);
-    if (result.status !== 200) {
+    if (result.status < 200 || result.status >= 300) {
         logger_1.default.error(`${chalk_1.default.red.bold('EXTENSION')}      Failed to upload extension package. Status: ${result.status}`);
         logger_1.default.error(JSON.stringify(result, null, 2));
         throw new Error(`Failed to upload extension package. Status: ${result.status}`);

package/dist/helpers/app/metadata-extractor.d.ts

@@ -0,0 +1 @@
+export declare function createBuildMetadata(tmpDir: string): string;

package/dist/helpers/app/metadata-extractor.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuildMetadata = void 0;
+const tslib_1 = require("tslib");
+const os = tslib_1.__importStar(require("os"));
+const child_process_1 = require("child_process");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+function createBuildMetadata(tmpDir) {
+    const buildTimestamp = new Date();
+    const systemInfo = {
+        nodeVersion: process.version,
+        platform: process.platform,
+        architecture: process.arch,
+        operatingSystem: os.type(),
+        osRelease: os.release(),
+        hostname: os.hostname(),
+        totalMemory: os.totalmem(),
+        freeMemory: os.freemem(),
+        cpuCount: os.cpus().length,
+        cpuModel: os.cpus()[0]?.model || 'unknown',
+        homeDirectory: os.homedir(),
+        tmpDirectory: os.tmpdir(),
+        processId: process.pid,
+        processTitle: process.title,
+        execPath: process.execPath,
+        workingDirectory: process.cwd(),
+    };
+    const environmentInfo = {
+        shell: process.env.SHELL,
+        term: process.env.TERM,
+        lang: process.env.LANG,
+        timezone: process.env.TZ || Intl.DateTimeFormat().resolvedOptions().timeZone,
+    };
+    let gitInfo = {};
+    try {
+        const gitCommitHash = (0, child_process_1.execSync)('git rev-parse HEAD', {
+            encoding: 'utf8',
+            timeout: 5000,
+        }).trim();
+        const gitBranch = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', {
+            encoding: 'utf8',
+            timeout: 5000,
+        }).trim();
+        const gitRemoteUrl = (0, child_process_1.execSync)('git config --get remote.origin.url', {
+            encoding: 'utf8',
+            timeout: 5000,
+        }).trim();
+        const gitCommitMessage = (0, child_process_1.execSync)('git log -1 --pretty=%B', {
+            encoding: 'utf8',
+            timeout: 5000,
+        }).trim();
+        const gitAuthor = (0, child_process_1.execSync)('git log -1 --pretty=format:"%an <%ae>"', {
+            encoding: 'utf8',
+            timeout: 5000,
+        }).trim();
+        const gitCommitDate = (0, child_process_1.execSync)('git log -1 --pretty=format:"%ai"', {
+            encoding: 'utf8',
+            timeout: 5000,
+        }).trim();
+        const gitTagsOutput = (0, child_process_1.execSync)('git tag --points-at HEAD', {
+            encoding: 'utf8',
+            timeout: 5000,
+        }).trim();
+        const gitTags = gitTagsOutput ? gitTagsOutput.split('\n') : [];
+        gitInfo = {
+            commitHash: gitCommitHash,
+            shortCommitHash: gitCommitHash.substring(0, 8),
+            branch: gitBranch,
+            remoteUrl: gitRemoteUrl,
+            commitMessage: gitCommitMessage,
+            author: gitAuthor,
+            commitDate: gitCommitDate,
+            tags: gitTags,
+        };
+    }
+    catch (error) {
+        gitInfo = {
+            error: 'Git information unavailable',
+            message: error instanceof Error ? error.message : 'Unknown git error',
+        };
+    }
+    const buildInfo = {
+        buildTimestamp: buildTimestamp.toISOString(),
+        buildTimestampUnix: Math.floor(buildTimestamp.getTime() / 1000),
+        buildTool: 'contrail-cli',
+        buildUser: process.env.USER || process.env.USERNAME || 'unknown',
+        system: systemInfo,
+        environment: environmentInfo,
+        git: gitInfo,
+        metadata: {
+            schemaVersion: '1.0.0',
+            generatedBy: 'contrail-cli-app-deployer',
+            purpose: 'Build and deployment metadata for debugging and auditing',
+        },
+    };
+    const buildInfoPath = `${tmpDir}/build-info.json`;
+    fs_1.default.writeFileSync(buildInfoPath, JSON.stringify(buildInfo, null, 2));
+    return buildInfoPath;
+}
+exports.createBuildMetadata = createBuildMetadata;

package/dist/helpers/entities/assortment-items.d.ts

@@ -0,0 +1,10 @@
+import { Item } from '@contrail/entity-types';
+export declare function throwIfInvalidAssortmentId(assortmentId: string): Promise<void>;
+export declare function createAssortmentItem(assortmentItem: {
+    assortmentId: string;
+    itemId: string;
+    [key: string]: any;
+}, { skipHydrateRelationships }?: {
+    skipHydrateRelationships: boolean;
+}): Promise<any>;
+export declare function findItemsNotInAssortment(assortmentId: string): Promise<Item[]>;

package/dist/helpers/entities/assortment-items.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findItemsNotInAssortment = exports.createAssortmentItem = exports.throwIfInvalidAssortmentId = void 0;
+const sdk_1 = require("@contrail/sdk");
+const batchFetch_1 = require("./batchFetch");
+const items_1 = require("./items");
+async function throwIfInvalidAssortmentId(assortmentId) {
+    if (!(await doesAssortmentExistById(assortmentId))) {
+        throw new Error(`Assortment with ID ${assortmentId} does not exist`);
+    }
+}
+exports.throwIfInvalidAssortmentId = throwIfInvalidAssortmentId;
+async function doesAssortmentExistById(id) {
+    const client = new sdk_1.Entities();
+    const assortment = await client.get({ entityName: 'assortment', id });
+    return !!assortment;
+}
+async function createAssortmentItem(assortmentItem, { skipHydrateRelationships } = { skipHydrateRelationships: false }) {
+    const client = new sdk_1.Entities();
+    const { assortmentId, itemId } = assortmentItem;
+    // add item to assortment
+    await client.create({
+        entityName: 'assortment',
+        id: assortmentId,
+        relation: 'items',
+        object: { itemIds: [itemId] },
+    });
+    // Update assortment item with properties
+    const updated = await client.update({
+        entityName: 'assortment-item',
+        id: `${assortmentId}:${itemId}`,
+        object: assortmentItem,
+        skipHydrateRelationships,
+    });
+    return updated;
+}
+exports.createAssortmentItem = createAssortmentItem;
+// Methods to find an item not in the assortment
+const ASSORTMENT_ITEMS_CACHE_BY_ASSORTMENT_ID = new Map();
+const ASSORTMENT_ITEMS_CACHE_BY_ITEM_ID = new Map();
+async function cacheAssortmentItemsByAssortmentId(assortmentId) {
+    if (!assortmentId) {
+        throw new Error('Assortment ID is required to cache assortment items');
+    }
+    if (ASSORTMENT_ITEMS_CACHE_BY_ASSORTMENT_ID.has(assortmentId)) {
+        return; // Already cached
+    }
+    const assortmentItems = await (0, batchFetch_1.batchFetch)('assortment-item', {
+        criteria: { assortmentId },
+        customParams: { propertySlugs: 'id,assortmentId,itemId' },
+    });
+    ASSORTMENT_ITEMS_CACHE_BY_ASSORTMENT_ID.set(assortmentId, assortmentItems);
+    assortmentItems.forEach((item) => {
+        if (!ASSORTMENT_ITEMS_CACHE_BY_ITEM_ID.has(item.itemId)) {
+            ASSORTMENT_ITEMS_CACHE_BY_ITEM_ID.set(item.itemId, []);
+        }
+        ASSORTMENT_ITEMS_CACHE_BY_ITEM_ID.get(item.itemId).push(item);
+    });
+}
+async function getAssortmentItemsByAssortmentId(assortmentId) {
+    if (!assortmentId) {
+        throw new Error('Assortment ID is required to get assortment items');
+    }
+    await cacheAssortmentItemsByAssortmentId(assortmentId);
+    const assortmentItems = ASSORTMENT_ITEMS_CACHE_BY_ASSORTMENT_ID.get(assortmentId);
+    if (!assortmentItems) {
+        throw new Error(`No assortment items found for assortment ID ${assortmentId}`);
+    }
+    return assortmentItems;
+}
+async function findItemsNotInAssortment(assortmentId) {
+    if (!assortmentId) {
+        throw new Error('Assortment ID is required to find items not in assortment');
+    }
+    const [assortmentItemsInAssortment, allItems] = await Promise.all([
+        getAssortmentItemsByAssortmentId(assortmentId),
+        (0, items_1.getAllItems)(),
+    ]);
+    const assortmentItemIds = new Set(assortmentItemsInAssortment.map((ai) => ai.itemId));
+    const itemsNotInAssortment = allItems.filter((item) => !assortmentItemIds.has(item.id));
+    if (itemsNotInAssortment.length === 0) {
+        throw new Error(`All items are already in assortment ${assortmentId}`);
+    }
+    return itemsNotInAssortment.sort((a, b) => a.id.localeCompare(b.id)); // sorting ensures consistent order of response
+}
+exports.findItemsNotInAssortment = findItemsNotInAssortment;

package/dist/helpers/entities/batchFetch.d.ts

@@ -0,0 +1,8 @@
+import { AssortmentItem, Item, ProjectItem } from '@contrail/entity-types';
+import { EntitiesClientGetOptions } from '@contrail/sdk';
+export interface BatchFetchableEntityMap {
+    item: Item;
+    'project-item': ProjectItem;
+    'assortment-item': AssortmentItem;
+}
+export declare function batchFetch<K extends keyof BatchFetchableEntityMap>(entityName: K, options: EntitiesClientGetOptions): Promise<BatchFetchableEntityMap[K][]>;

package/dist/helpers/entities/batchFetch.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batchFetch = void 0;
+const sdk_1 = require("@contrail/sdk");
+const util_1 = require("@contrail/util");
+async function batchFetch(entityName, options) {
+    const response = await requestBatchFetch(entityName, options);
+    return parseBatchFetchResponse(response);
+}
+exports.batchFetch = batchFetch;
+async function requestBatchFetch(entityName, options) {
+    const client = new sdk_1.Entities();
+    // NOTE: There is probably a helper somewhere else that manages this conversion
+    const optionsClone = { ...options };
+    if (optionsClone.criteria) {
+        optionsClone.where = optionsClone.criteria;
+    }
+    return client.create({
+        entityName: entityName,
+        suffix: 'batch-fetch',
+        object: optionsClone,
+    });
+}
+async function parseBatchFetchResponse(response) {
+    if ('results' in response) {
+        return response.results;
+    }
+    else if ('resultsCompressedString' in response) {
+        const compressedString = response.resultsCompressedString;
+        const jsonData = (0, util_1.decompressFromString)(compressedString);
+        return jsonData;
+    }
+    else if ('resultsDownloadUrl' in response) {
+        const downloadUrl = response.resultsDownloadUrl;
+        const data = await fetch(downloadUrl).then((res) => res.json());
+        return data;
+    }
+    else {
+        throw new Error('Invalid batch fetch response format');
+    }
+}

package/dist/helpers/entities/index.d.ts

@@ -0,0 +1,3 @@
+export * from './assortment-items';
+export * from './items';
+export * from './project-items';

package/dist/helpers/entities/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./assortment-items"), exports);
+tslib_1.__exportStar(require("./items"), exports);
+tslib_1.__exportStar(require("./project-items"), exports);

package/dist/helpers/entities/items.d.ts

@@ -0,0 +1,10 @@
+import { Item } from '@contrail/entity-types';
+export declare function throwIfInvalidItemId(itemId: string): Promise<void>;
+export type SparseItem = Pick<Item, 'id' | 'familyId' | 'roles' | 'name'>;
+export declare function getAllItemsUsingCacheFallback(): Promise<SparseItem[]>;
+export declare function getAllItems(): Promise<SparseItem[]>;
+export declare function getItemFamilies(): Promise<SparseItem[] | undefined>;
+export declare function getFamilyName(item: SparseItem): Promise<string[] | undefined>;
+export declare const Roles: readonly ["option", "family"];
+export type Role = (typeof Roles)[number];
+export declare function throwIfInvalidItemLevel(role: string): asserts role is Role;