@contentstack/cli-utilities 1.4.5 → 1.5.1

package/lib/fs-utility/core.d.ts

@@ -0,0 +1,140 @@
+/// <reference types="node" />
+import { Chunk, PageInfo, WriteFileOptions, FsConstructorOptions, ChunkFilesGetterType } from './types';
+export default class FsUtility {
+    private prefixKey;
+    private basePath;
+    private fileExt;
+    private moduleName;
+    private currentFileName;
+    private keepMetadata;
+    private indexFileName;
+    private chunkFileSize;
+    private omitKeys;
+    private defaultInitContent;
+    private metaPickKeys;
+    private currentFileRelativePath;
+    private writableStream;
+    private metaData;
+    private readIndexer;
+    private writeIndexer;
+    private metaHandler;
+    pageInfo: PageInfo;
+    constructor(options?: FsConstructorOptions);
+    get isNewFsStructure(): boolean;
+    get isIndexFileExist(): boolean;
+    get currentPageDetails(): PageInfo;
+    get indexFileContent(): Record<string, any>;
+    /**
+     * @method readChunkFiles
+     * @returns Object
+     */
+    get readChunkFiles(): {
+        next: () => ChunkFilesGetterType;
+        previous: () => ChunkFilesGetterType;
+        get: (index: number) => ChunkFilesGetterType;
+    };
+    /**
+     * @method readFile
+     * @param filePath string
+     * @param parse boolean | undefined
+     * @returns string | undefined
+     */
+    readFile(filePath: string, parse?: boolean | undefined): string | Record<string, unknown> | Record<string, unknown>[] | undefined;
+    /**
+     * @method writeFile
+     * @param filePath string
+     * @param data Object | undefined
+     * @return void
+     */
+    writeFile(filePath: string, data: Chunk, mapKeyVal?: boolean): void;
+    /**
+     * @method makeDirectory
+     * @param path string
+     * @return Promise<string | undefined>
+     */
+    makeDirectory(path: string): Promise<string | undefined>;
+    /**
+     * @method readdir
+     * @param dirPath string | Buffer | URL
+     * @returns [string]
+     */
+    readdir(dirPath: string | Buffer | URL): string[] | [];
+    /**
+     * @method createFolderIfNotExist
+     * @param path string
+     * @return {void}
+     */
+    createFolderIfNotExist(path: string): void;
+    /**
+     * @method writeIntoFile
+     * @param {String|Object|Array} chunk Record<string, string>[]
+     * @param {WriteFileOptions} options WriteFileOptions
+     * @return void
+     */
+    writeIntoFile(chunk: Record<string, string>[], options?: WriteFileOptions): void;
+    /**
+     * @method createNewFile
+     * @return {void}
+     * @description creating new chunk file
+     */
+    protected createNewFile(): void;
+    /**
+     * @method writeIntoExistingFile
+     * @param chunk Record<string, string>[] | object | Array<any> | string;
+     * @param options WriteFileOptions
+     * @returns void
+     */
+    protected writeIntoExistingFile(chunk: Chunk, options?: WriteFileOptions): void;
+    /**
+     * @method handleKeyValMapAndMetaData
+     * @param chunk Chunk
+     * @param keyName string
+     * @returns Chunk
+     */
+    handleKeyValMapAndMetaData(chunk: Chunk, keyName?: string | string[] | undefined): Chunk;
+    /**
+     * @method completeFile
+     * @param closeIndexer boolean
+     * @return {void}
+     * @description writing chunks into existing file
+     */
+    completeFile(closeIndexer?: boolean): void;
+    /**
+     * @method closeFile
+     * @param closeIndexer boolean
+     * @return {void}
+     * @description closing current write stream
+     */
+    protected closeFile(closeIndexer?: boolean): void;
+    saveMeta(meta: Chunk): void;
+    getPlainMeta(basePath?: string): Record<string, unknown>;
+    /**
+     * @method getFileByIndex
+     * @param _self FsUtility
+     * @param index number
+     * @returns Promise<string>
+     */
+    protected getFileByIndex(index?: number): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+    /**
+     * @method next
+     * @returns Promise<string>
+     */
+    protected next(): Promise<Record<string, unknown> | Record<string, unknown>[]>;
+    /**
+     * @method previous
+     * @param _self FsUtility
+     * @returns Promise<string>
+     */
+    protected previous(): Promise<Record<string, unknown> | Record<string, unknown>[] | Error>;
+    /**
+     * @method updatePageInfo
+     * @param _self FsUtility
+     * @param isNext boolean
+     * @param index number
+     * @returns void
+     */
+    updatePageInfo(isNext?: boolean | null, index?: number | null): void;
+    removeFile(path: string): void;
+}
+export declare function getDirectories(source: string): string[] | [];
+export declare function getFileList(dirName: string, onlyName?: boolean): Promise<string[] | []>;

package/lib/fs-utility/core.js

@@ -0,0 +1,374 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFileList = exports.getDirectories = void 0;
+const tslib_1 = require("tslib");
+const mkdirp_1 = tslib_1.__importDefault(require("mkdirp"));
+const keys_1 = tslib_1.__importDefault(require("lodash/keys"));
+const uuid_1 = require("uuid");
+const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
+const node_path_1 = require("node:path");
+const node_fs_1 = require("node:fs");
+const helper_1 = require("./helper");
+class FsUtility {
+    constructor(options = {}) {
+        var _a;
+        this.prefixKey = '';
+        this.currentFileName = '';
+        this.keepMetadata = false;
+        this.metaData = {};
+        this.readIndexer = {};
+        this.writeIndexer = {};
+        this.pageInfo = {
+            after: 0,
+            before: 0,
+            hasNextPage: false,
+            hasPreviousPage: false,
+            pageInfoUpdated: false,
+        };
+        const { fileExt, omitKeys, basePath, moduleName, metaHandler, keepMetadata, metaPickKeys, chunkFileSize, indexFileName, defaultInitContent, createDirIfNotExist = true, } = options;
+        this.metaHandler = metaHandler;
+        this.basePath = basePath || '';
+        this.omitKeys = omitKeys || [];
+        this.fileExt = fileExt || 'json';
+        this.metaPickKeys = metaPickKeys || [];
+        this.moduleName = moduleName || 'chunk';
+        this.chunkFileSize = chunkFileSize || 10;
+        this.keepMetadata = keepMetadata || ((_a = keepMetadata === undefined) !== null && _a !== void 0 ? _a : true);
+        this.indexFileName = indexFileName || 'index.json';
+        this.pageInfo.hasNextPage = (0, keys_1.default)(this.indexFileContent).length > 0;
+        this.defaultInitContent = defaultInitContent || (this.fileExt === 'json' ? '{' : '');
+        if (createDirIfNotExist) {
+            this.createFolderIfNotExist(this.basePath);
+        }
+    }
+    get isNewFsStructure() {
+        return (0, node_fs_1.existsSync)(`${this.basePath}/metadata.json`) && (0, node_fs_1.existsSync)(`${this.basePath}/files`);
+    }
+    get isIndexFileExist() {
+        return (0, node_fs_1.existsSync)(`${this.basePath}/${this.indexFileName}`);
+    }
+    get currentPageDetails() {
+        return this.pageInfo;
+    }
+    get indexFileContent() {
+        let indexData = {};
+        const indexPath = `${this.basePath}/${this.indexFileName}`;
+        if ((0, node_fs_1.existsSync)(indexPath)) {
+            indexData = JSON.parse((0, node_fs_1.readFileSync)(indexPath, 'utf-8'));
+        }
+        return indexData;
+    }
+    /**
+     * @method readChunkFiles
+     * @returns Object
+     */
+    get readChunkFiles() {
+        return {
+            next: this.next.bind(this),
+            previous: this.previous.bind(this),
+            get: this.getFileByIndex.bind(this),
+        };
+    }
+    // STUB old utility methods
+    /**
+     * @method readFile
+     * @param filePath string
+     * @param parse boolean | undefined
+     * @returns string | undefined
+     */
+    readFile(filePath, parse = undefined) {
+        let data;
+        filePath = (0, node_path_1.resolve)(filePath);
+        parse = typeof parse === 'undefined' ? true : parse;
+        if ((0, node_fs_1.existsSync)(filePath)) {
+            data = parse ? JSON.parse((0, node_fs_1.readFileSync)(filePath, 'utf-8')) : data;
+        }
+        return data;
+    }
+    /**
+     * @method writeFile
+     * @param filePath string
+     * @param data Object | undefined
+     * @return void
+     */
+    writeFile(filePath, data, mapKeyVal = false) {
+        if (mapKeyVal) {
+            data = (0, helper_1.mapKeyAndVal)(data, 'uid', this.omitKeys); // NOTE Map values as Key/value pair object
+        }
+        data = typeof data === 'object' ? JSON.stringify(data) : data || '{}';
+        (0, node_fs_1.writeFileSync)(filePath, data);
+    }
+    /**
+     * @method makeDirectory
+     * @param path string
+     * @return Promise<string | undefined>
+     */
+    makeDirectory(path) {
+        return (0, mkdirp_1.default)(path);
+    }
+    /**
+     * @method readdir
+     * @param dirPath string | Buffer | URL
+     * @returns [string]
+     */
+    readdir(dirPath) {
+        return (0, node_fs_1.existsSync)(dirPath) ? (0, node_fs_1.readdirSync)(dirPath) : [];
+    }
+    // STUB End of old utility
+    /**
+     * @method createFolderIfNotExist
+     * @param path string
+     * @return {void}
+     */
+    createFolderIfNotExist(path) {
+        if (path && !(0, node_fs_1.existsSync)(path)) {
+            (0, node_fs_1.mkdirSync)(path, { recursive: true });
+        }
+    }
+    /**
+     * @method writeIntoFile
+     * @param {String|Object|Array} chunk Record<string, string>[]
+     * @param {WriteFileOptions} options WriteFileOptions
+     * @return void
+     */
+    writeIntoFile(chunk, options) {
+        if (!this.writableStream) {
+            this.createNewFile();
+        }
+        this.writeIntoExistingFile(chunk, options);
+    }
+    /**
+     * @method createNewFile
+     * @return {void}
+     * @description creating new chunk file
+     */
+    createNewFile() {
+        const fileName = `${(0, uuid_1.v4)()}-${this.moduleName || 'chunk'}.${this.fileExt}`;
+        this.currentFileName = fileName;
+        this.writeIndexer[(0, keys_1.default)(this.writeIndexer).length + 1] = fileName;
+        this.currentFileRelativePath = `${this.basePath}/${fileName}`;
+        (0, node_fs_1.writeFileSync)(this.currentFileRelativePath, this.defaultInitContent);
+        this.writableStream = (0, node_fs_1.createWriteStream)(this.currentFileRelativePath, {
+            flags: 'a',
+        });
+    }
+    /**
+     * @method writeIntoExistingFile
+     * @param chunk Record<string, string>[] | object | Array<any> | string;
+     * @param options WriteFileOptions
+     * @returns void
+     */
+    writeIntoExistingFile(chunk, options) {
+        var _a;
+        let fileContent = chunk;
+        let fileSizeReachedLimit = false;
+        const { keyName, mapKeyVal } = options || {
+            keyName: 'uid',
+            mapKeyVal: false,
+        };
+        if (mapKeyVal) {
+            fileContent = this.handleKeyValMapAndMetaData(chunk, keyName); // NOTE Map values as Key/value pair object
+        }
+        if (typeof fileContent === 'object') {
+            fileContent = JSON.stringify(fileContent).slice(1, -1);
+        }
+        const { size } = (0, node_fs_1.statSync)(this.currentFileRelativePath);
+        if ((options === null || options === void 0 ? void 0 : options.closeFile) === true || size / (1024 * 1024) >= this.chunkFileSize) {
+            // NOTE Each chunk file size Ex. 5 (MB)
+            fileSizeReachedLimit = true;
+        }
+        const suffix = fileSizeReachedLimit ? '}' : '';
+        fileContent = this.fileExt === 'json' ? `${this.prefixKey}${fileContent}${suffix}` : fileContent;
+        (_a = this.writableStream) === null || _a === void 0 ? void 0 : _a.write(fileContent);
+        if (!this.prefixKey)
+            this.prefixKey = ',';
+        if (fileSizeReachedLimit) {
+            this.closeFile((options === null || options === void 0 ? void 0 : options.closeFile) === true);
+        }
+    }
+    /**
+     * @method handleKeyValMapAndMetaData
+     * @param chunk Chunk
+     * @param keyName string
+     * @returns Chunk
+     */
+    handleKeyValMapAndMetaData(chunk, keyName) {
+        const fileContent = (0, helper_1.mapKeyAndVal)(chunk, keyName || 'uid', this.omitKeys); // NOTE Map values as Key/value pair object
+        // NOTE update metadata
+        if (this.keepMetadata) {
+            const metadata = (0, helper_1.getMetaData)(chunk, this.metaPickKeys, this.metaHandler);
+            if (metadata && !(0, isEmpty_1.default)(metadata)) {
+                if ((0, isEmpty_1.default)(this.metaData[this.currentFileName]))
+                    this.metaData[this.currentFileName] = [];
+                this.metaData[this.currentFileName].push(...metadata);
+            }
+        }
+        return fileContent;
+    }
+    /**
+     * @method completeFile
+     * @param closeIndexer boolean
+     * @return {void}
+     * @description writing chunks into existing file
+     */
+    completeFile(closeIndexer) {
+        if (this.writableStream) {
+            if (this.fileExt === 'json') {
+                this.writableStream.write('}');
+            }
+            this.closeFile(closeIndexer);
+        }
+    }
+    /**
+     * @method closeFile
+     * @param closeIndexer boolean
+     * @return {void}
+     * @description closing current write stream
+     */
+    closeFile(closeIndexer = true) {
+        if (closeIndexer) {
+            // NOTE write file index details into a file
+            (0, node_fs_1.writeFileSync)(`${this.basePath}/${this.indexFileName}`, JSON.stringify(this.writeIndexer));
+            // NOTE write metadata into a file
+            if (this.keepMetadata) {
+                (0, node_fs_1.writeFileSync)(`${this.basePath}/metadata.json`, JSON.stringify(this.metaData));
+            }
+        }
+        if (this.writableStream instanceof node_fs_1.WriteStream) {
+            this.writableStream.end();
+            this.prefixKey = '';
+            this.writableStream = null;
+        }
+    }
+    saveMeta(meta) {
+        (0, node_fs_1.writeFileSync)(`${this.basePath}/metadata.json`, JSON.stringify(meta));
+    }
+    getPlainMeta(basePath) {
+        const path = basePath || (0, node_path_1.resolve)(this.basePath, 'metadata.json');
+        if (!(0, node_fs_1.existsSync)(path))
+            return {};
+        return JSON.parse((0, node_fs_1.readFileSync)(path, { encoding: 'utf-8' }));
+    }
+    /**
+     * @method getFileByIndex
+     * @param _self FsUtility
+     * @param index number
+     * @returns Promise<string>
+     */
+    getFileByIndex(index = 1) {
+        return new Promise((resolve, reject) => {
+            if (index <= 0) {
+                reject(new Error('Invalid index'));
+                return;
+            }
+            this.updatePageInfo(null, index);
+            if ((0, isEmpty_1.default)(this.readIndexer[index])) {
+                reject(new Error('File not found!'));
+                return;
+            }
+            const fileContent = (0, node_fs_1.readFileSync)((0, node_path_1.resolve)(this.basePath, this.readIndexer[index]), {
+                encoding: 'utf-8',
+            });
+            resolve(this.fileExt === 'json' ? JSON.parse(fileContent) : fileContent);
+        });
+    }
+    /**
+     * @method next
+     * @returns Promise<string>
+     */
+    next() {
+        return new Promise((resolve, reject) => {
+            this.updatePageInfo(true);
+            if ((0, isEmpty_1.default)(this.readIndexer[this.pageInfo.after])) {
+                reject(new Error('File not found!'));
+                return;
+            }
+            const fileContent = (0, node_fs_1.readFileSync)((0, node_path_1.resolve)(this.basePath, this.readIndexer[this.pageInfo.after]), {
+                encoding: 'utf-8',
+            });
+            resolve(this.fileExt === 'json' ? JSON.parse(fileContent) : fileContent);
+        });
+    }
+    /**
+     * @method previous
+     * @param _self FsUtility
+     * @returns Promise<string>
+     */
+    previous() {
+        return new Promise((resolve, reject) => {
+            this.updatePageInfo(false);
+            if ((0, isEmpty_1.default)(this.readIndexer[this.pageInfo.before])) {
+                reject(new Error('File not found'));
+                return;
+            }
+            const fileContent = (0, node_fs_1.readFileSync)((0, node_path_1.resolve)(this.basePath, this.readIndexer[this.pageInfo.before]), {
+                encoding: 'utf-8',
+            });
+            resolve(this.fileExt === 'json' ? JSON.parse(fileContent) : fileContent);
+        });
+    }
+    /**
+     * @method updatePageInfo
+     * @param _self FsUtility
+     * @param isNext boolean
+     * @param index number
+     * @returns void
+     */
+    updatePageInfo(isNext = true, index = null) {
+        if (!this.pageInfo.pageInfoUpdated) {
+            this.readIndexer = this.indexFileContent;
+            this.pageInfo.pageInfoUpdated = true;
+        }
+        const { after, before } = this.pageInfo;
+        if (isNext === true) {
+            this.pageInfo.before = 1;
+            this.pageInfo.after = after + 1;
+        }
+        else if (isNext === false) {
+            this.pageInfo.after = 0;
+            this.pageInfo.before = before - 1;
+        }
+        else {
+            this.pageInfo.after = index || 0;
+            this.pageInfo.before = 1;
+        }
+        /* eslint-disable unicorn/consistent-destructuring */
+        if (!(0, isEmpty_1.default)(this.readIndexer[this.pageInfo.after + 1])) {
+            this.pageInfo.hasNextPage = true;
+        }
+        /* eslint-disable unicorn/consistent-destructuring */
+        if (!(0, isEmpty_1.default)(this.readIndexer[this.pageInfo.after - 1])) {
+            this.pageInfo.hasPreviousPage = true;
+        }
+    }
+    removeFile(path) {
+        if ((0, node_fs_1.existsSync)(path))
+            (0, node_fs_1.unlinkSync)(path);
+    }
+}
+exports.default = FsUtility;
+function getDirectories(source) {
+    if (!(0, node_fs_1.existsSync)(source))
+        return [];
+    return (0, node_fs_1.readdirSync)(source, { withFileTypes: true })
+        .filter((dirent) => dirent.isDirectory())
+        .map((dirent) => dirent.name);
+}
+exports.getDirectories = getDirectories;
+async function getFileList(dirName, onlyName = true) {
+    if (!(0, node_fs_1.existsSync)(dirName))
+        return [];
+    let files = [];
+    const items = (0, node_fs_1.readdirSync)(dirName, { withFileTypes: true });
+    for (const item of items) {
+        if (item.isDirectory()) {
+            /* eslint-disable no-await-in-loop */
+            files = [...files, ...(await getFileList(`${dirName}/${item.name}`))];
+        }
+        else {
+            files.push(onlyName ? item.name : `${dirName}/${item.name}`);
+        }
+    }
+    return files;
+}
+exports.getFileList = getFileList;

package/lib/fs-utility/helper.d.ts

@@ -0,0 +1,3 @@
+declare function mapKeyAndVal(array: Array<Record<string, any>>, keyName: string | string[], omitKeys?: Array<string>): Record<string, unknown>;
+declare function getMetaData(array: Array<Record<string, any>>, pickKeys: Array<string>, handler?: (array: Array<Record<string, any>>) => void): Array<Record<string, unknown>> | undefined;
+export { mapKeyAndVal, getMetaData };

package/lib/fs-utility/helper.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetaData = exports.mapKeyAndVal = void 0;
+const tslib_1 = require("tslib");
+const map_1 = tslib_1.__importDefault(require("lodash/map"));
+const omit_1 = tslib_1.__importDefault(require("lodash/omit"));
+const pick_1 = tslib_1.__importDefault(require("lodash/pick"));
+const assign_1 = tslib_1.__importDefault(require("lodash/assign"));
+const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
+const forEach_1 = tslib_1.__importDefault(require("lodash/forEach"));
+function getKeysFromArray(keys, obj) {
+    let keyName = "";
+    (0, forEach_1.default)(keys, (key) => {
+        keyName += keyName ? `_${obj[key]}` : obj[key];
+    });
+    return keyName;
+}
+function mapKeyAndVal(array, keyName, omitKeys = []) {
+    return (0, assign_1.default)({}, ...(0, map_1.default)(array, (row) => {
+        if (Array.isArray(keyName))
+            return { [getKeysFromArray(keyName, row)]: (0, omit_1.default)(row, omitKeys) };
+        return { [row[keyName]]: (0, omit_1.default)(row, omitKeys) };
+    }));
+}
+exports.mapKeyAndVal = mapKeyAndVal;
+function getMetaData(array, pickKeys, handler) {
+    if (handler instanceof Function)
+        handler(array);
+    if ((0, isEmpty_1.default)(array) || (0, isEmpty_1.default)(pickKeys))
+        return;
+    return (0, map_1.default)(array, (row) => (0, pick_1.default)(row, pickKeys));
+}
+exports.getMetaData = getMetaData;

package/lib/fs-utility/index.d.ts

@@ -0,0 +1,4 @@
+import FsUtility, { getDirectories, getFileList } from './core';
+export * from './types';
+export { mapKeyAndVal } from './helper';
+export { FsUtility, getDirectories, getFileList };

package/lib/fs-utility/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFileList = exports.getDirectories = exports.FsUtility = exports.mapKeyAndVal = void 0;
+const tslib_1 = require("tslib");
+const core_1 = tslib_1.__importStar(require("./core"));
+exports.FsUtility = core_1.default;
+Object.defineProperty(exports, "getDirectories", { enumerable: true, get: function () { return core_1.getDirectories; } });
+Object.defineProperty(exports, "getFileList", { enumerable: true, get: function () { return core_1.getFileList; } });
+tslib_1.__exportStar(require("./types"), exports);
+var helper_1 = require("./helper");
+Object.defineProperty(exports, "mapKeyAndVal", { enumerable: true, get: function () { return helper_1.mapKeyAndVal; } });

package/lib/fs-utility/types.d.ts

@@ -0,0 +1,69 @@
+type FileType = "json" | "txt";
+type Chunk = Record<string, unknown>[] | Record<string, unknown> | Array<unknown> | string;
+type PageInfo = {
+    after: number;
+    before: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    pageInfoUpdated?: boolean;
+};
+type WriteFileOptions = {
+    keyName?: string | string[];
+    closeFile?: boolean;
+    mapKeyVal?: boolean;
+    closeIndexer?: boolean;
+};
+type FsConstructorOptions = {
+    createDirIfNotExist?: boolean;
+    /**
+     * basePath is used to pass base paths of an content to be written to
+     *
+     * Example: ```./contents/data```
+     */
+    basePath?: string;
+    /**
+     * chunk file extension
+     *
+     * Ex: ```fileExt: 'json' | 'txt'```
+     */
+    fileExt?: FileType;
+    /**
+     * Name of the module data which is going to be written to drive
+     *
+     * Ex: ```moduleName: 'assets' | 'entries' | 'content-type'```
+     */
+    moduleName?: string;
+    /**
+     * Name of the index manager file name. Which will have all chunk file details
+     *
+     * ```defaultValue: index.json```
+     *
+     * Ex: ```indexFileName: 'assets.json' | 'index.json'```
+     */
+    indexFileName?: string;
+    /**
+     * Chunk file size in megabytes
+     *
+     * ```chunkFileSize: 5``` => 5Mb
+     */
+    chunkFileSize?: number;
+    omitKeys?: Array<string>;
+    /**
+     * on initialization if any content needs to be put in the file which can be passed through this key
+     *
+     * Ex: ```defaultInitContent: '{ title: "test" }'```
+     */
+    defaultInitContent?: string;
+    /**
+     * metaPickKeys is to pik list of key to keep like an index key of entity
+     *
+     * Ex. ```['title'] | handler: () => {}```
+     *
+     * Result will be in metadata file: ```{ title: ['title1', 'title2'], versionedAssets: [{ 89987iu89434: 4 }] }```
+     */
+    metaPickKeys?: Array<string>;
+    keepMetadata?: boolean;
+    metaHandler?: (array: any) => any;
+};
+type ChunkFilesGetterType = Promise<Record<string, unknown> | Record<string, unknown>[] | Error>;
+export { Chunk, FileType, PageInfo, WriteFileOptions, FsConstructorOptions, ChunkFilesGetterType };

package/lib/fs-utility/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/index.d.ts

@@ -7,6 +7,7 @@ export { default as configHandler } from './config-handler';
 export { default as managementSDKClient, managementSDKInitiator, ContentstackClient, ContentstackConfig, } from './contentstack-management-sdk';
 export { default as printFlagDeprecation } from './flag-deprecation-check';
 export * from './http-client';
+export * from './fs-utility';
 export { default as NodeCrypto } from './encrypter';
 export { Args as args, Flags as flags, Command } from './cli-ux';
 export * from './helpers';

package/lib/index.js

@@ -20,6 +20,7 @@ Object.defineProperty(exports, "managementSDKInitiator", { enumerable: true, get
 var flag_deprecation_check_1 = require("./flag-deprecation-check");
 Object.defineProperty(exports, "printFlagDeprecation", { enumerable: true, get: function () { return tslib_1.__importDefault(flag_deprecation_check_1).default; } });
 tslib_1.__exportStar(require("./http-client"), exports);
+tslib_1.__exportStar(require("./fs-utility"), exports);
 var encrypter_1 = require("./encrypter");
 Object.defineProperty(exports, "NodeCrypto", { enumerable: true, get: function () { return tslib_1.__importDefault(encrypter_1).default; } });
 var cli_ux_2 = require("./cli-ux");

package/lib/interfaces/index.d.ts

@@ -1,4 +1,4 @@
-import { IPromptOptions } from "@oclif/core/lib/cli-ux";
+import { IPromptOptions } from '@oclif/core/lib/cli-ux';
 export interface PrintOptions {
     bold?: boolean;
     color?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentstack/cli-utilities",
-  "version": "1.4.5",
+  "version": "1.5.1",
   "description": "Utilities for contentstack projects",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -32,8 +32,8 @@
   "author": "contentstack",
   "license": "MIT",
   "dependencies": {
-    "@contentstack/management": "^1.8.0",
-    "@oclif/core": "^2.8.2",
+    "@contentstack/management": "~1.10.0",
+    "@oclif/core": "^2.9.3",
     "axios": "1.3.4",
     "chalk": "^4.0.0",
     "cli-cursor": "^3.1.0",
@@ -44,6 +44,7 @@
     "inquirer": "8.2.4",
     "inquirer-search-checkbox": "^1.0.0",
     "inquirer-search-list": "^1.2.6",
+    "mkdirp": "^1.0.4",
     "lodash": "^4.17.15",
     "open": "^8.4.2",
     "ora": "^5.4.0",
@@ -77,4 +78,4 @@
     "tslib": "^1.13.0",
     "typescript": "^4.9.3"
   }
-}
+}