zcatalyst-cli 1.26.2 → 1.27.0

package/lib/docs/pull/features/functions/index.toml

@@ -0,0 +1,24 @@
+[E_NON_INTERACTIVE_FNS_PULL-1]
+context = '''In Non-Interactive mode the functions to pull must be specified using the ${arg[0]} option.'''
+aid = '''Use the ${arg[0]} option to specify the functions to pull in non-interactive mode.
+
+For example:  ${arg[1]}
+
+Available functions to pull:
+${arg[2]}
+'''
+
+[E_NON_INTERACTIVE_FNS_PULL-2]
+context = '''The functions specified in the ${arg[0]} option is not valid.'''
+aid = '''Use the ${arg[1]} option to specify only the valid functions to pull in non-interactive mode.
+
+Valid functions to pull:
+${arg[2]}
+'''
+
+[E_NON_INTERACTIVE_FNS_PULL-3]
+context = '''Unable to pull as the function with the same name${arg[0]} already exists in the local environment.'''
+aid = '''Use the ${arg[1]} command with the ${arg[2]} option to overwrite the existing function in the local environment.
+
+Example: ${arg[3]}
+'''

package/lib/endpoints/lib/slate.d.ts

@@ -1,6 +1,16 @@
 import { ReadStream } from 'fs-extra';
 import { IAPIOptions } from '../../internal/api';
-import { FrameworkType, ISlateAppInfo } from '../../util_modules/config/lib/slate';
+import { FrameworkType, ISlateAppInfo, ISlateDeploymentInfo, SlateBuildInfo } from '../../util_modules/config/lib/slate';
+export interface ISlateBuildLogRecord {
+    _zl_timestamp: number;
+    job_id: string;
+    message: string;
+}
+export interface ISlateBuildLogsResponse {
+    identifier: number;
+    records: Array<string>;
+    next_token: string;
+}
 declare class Slate {
     opts: IAPIOptions;
     projectId: string;
@@ -11,5 +21,8 @@ declare class Slate {
     getAllApps(): Promise<Array<ISlateAppInfo>>;
     downloadTemplate(): Promise<unknown>;
     deploy(sourceStream: ReadStream, contentLength: number, appName: string, deploymentName?: string, appId?: string, config?: string, msg?: string): Promise<unknown>;
+    getBuildStatus(appId: string, deploymentId: string, buildId: string): Promise<SlateBuildInfo>;
+    getBuildLogs(appId: string, deploymentId: string, buildId: string, nextToken?: string, limit?: number): Promise<ISlateBuildLogsResponse>;
+    getDeployment(appId: string, deploymentId: string): Promise<ISlateDeploymentInfo>;
 }
 export default Slate;

package/lib/endpoints/lib/slate.js

@@ -15,6 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const error_1 = __importDefault(require("../../error"));
 const api_1 = __importDefault(require("../../internal/api"));
 const logger_1 = require("../../util_modules/logger");
+const constants_1 = require("../../util_modules/constants");
 class Slate {
     constructor(projectId, opts) {
         this.opts = opts;
@@ -87,5 +88,39 @@ class Slate {
             });
         });
     }
+    getBuildStatus(appId, deploymentId, buildId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield new api_1.default(Object.assign({ origin: constants_1.ORIGIN.zgraphql }, this.opts)).get(`/slate/v1/project/${this.projectId}/app/${appId}/deployment/${deploymentId}/build/${buildId}`);
+            if (response.body && response.body.data) {
+                return response.body.data;
+            }
+            (0, logger_1.debug)('get build status response from server : ' + response.body);
+            throw new error_1.default('Error while fetching build status', { exit: 2 });
+        });
+    }
+    getBuildLogs(appId_1, deploymentId_1, buildId_1, nextToken_1) {
+        return __awaiter(this, arguments, void 0, function* (appId, deploymentId, buildId, nextToken, limit = 50) {
+            const qs = { limit };
+            if (nextToken) {
+                qs.next_token = nextToken;
+            }
+            const response = yield new api_1.default(Object.assign({ origin: constants_1.ORIGIN.zgraphql }, this.opts)).get(`/slate/v1/project/${this.projectId}/app/${appId}/deployment/${deploymentId}/build/${buildId}/logs`, { qs });
+            if (response.body && response.body.data) {
+                return response.body.data;
+            }
+            (0, logger_1.debug)('get build logs response from server : ' + response.body);
+            throw new error_1.default('Error while fetching build logs', { exit: 2 });
+        });
+    }
+    getDeployment(appId, deploymentId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield new api_1.default(Object.assign({ origin: constants_1.ORIGIN.zgraphql }, this.opts)).get(`/slate/v1/project/${this.projectId}/app/${appId}/deployment/${deploymentId}`);
+            if (response.body && response.body.data) {
+                return response.body.data;
+            }
+            (0, logger_1.debug)('get deployment response from server : ' + response.body);
+            throw new error_1.default('Error while fetching deployment details', { exit: 2 });
+        });
+    }
 }
 exports.default = Slate;

package/lib/error/context-help.js

@@ -24,7 +24,7 @@ function help() {
         };
     };
     logKeys.forEach((key) => {
-        const errQueue = logs[key];
+        const errQueue = logs[key].filter((err) => !err.skipHelp);
         if (!Array.isArray(errQueue) || errQueue.length === 0) {
             return;
         }

package/lib/error/index.js

@@ -17,20 +17,16 @@ class CatalystError extends Error {
         this.arg = options.arg;
         this.skipHelp = options.skipHelp || false;
         try {
-            if (!this.skipHelp) {
-                const stackArr = ((_a = this.stack) === null || _a === void 0 ? void 0 : _a.split(/\n {4}at /)) || [];
-                const errorPath = options.filePath === undefined && stackArr[1] !== undefined
-                    ? stackArr[1].replace(/\.[^.]+$/, '').replace(/^[^(]+\(/, '')
-                    : (_b = options.filePath) === null || _b === void 0 ? void 0 : _b.replace(/\.[^.]+$/, '');
-                if (!errorPath) {
-                    throw new CatalystError('Invalid error path', { skipHelp: true });
-                }
-                options.docPath = options.docPath || DEFAULT_DOC;
-                this.filePath = errorPath.replace((0, path_1.dirname)(options.docPath), options.docPath);
-                utils_js_1.runtime.set(['context.log', this.filePath], utils_js_1.runtime
-                    .get(['context.log', this.filePath], [])
-                    .concat(this));
+            const stackArr = ((_a = this.stack) === null || _a === void 0 ? void 0 : _a.split(/\n {4}at /)) || [];
+            const errorPath = options.filePath === undefined && stackArr[1] !== undefined
+                ? stackArr[1].replace(/\.[^.]+$/, '').replace(/^[^(]+\(/, '')
+                : (_b = options.filePath) === null || _b === void 0 ? void 0 : _b.replace(/\.[^.]+$/, '');
+            if (!errorPath) {
+                throw new CatalystError('Invalid error path', { skipHelp: true });
             }
+            options.docPath = options.docPath || DEFAULT_DOC;
+            this.filePath = errorPath.replace((0, path_1.dirname)(options.docPath), options.docPath);
+            utils_js_1.runtime.set(['context.log', this.filePath], utils_js_1.runtime.get(['context.log', this.filePath], []).concat(this));
         }
         catch (e) {
             utils_js_1.runtime.set('context.log.faultyError', utils_js_1.runtime.get('context.log.faultyError', []).concat(this));

package/lib/execute/command-utils.d.ts

@@ -0,0 +1,5 @@
+import { IFnTarget } from '../fn-utils/lib/common';
+export declare function getInputs(exeTarget: IFnTarget, inputData?: Record<string, Record<string, unknown>>): Promise<{
+    key: string;
+    ip?: Record<string, unknown>;
+}>;

package/lib/execute/command-utils.js

@@ -0,0 +1,86 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInputs = getInputs;
+const path_1 = require("path");
+const ansi_colors_1 = require("ansi-colors");
+const index_js_1 = require("../util_modules/constants/index.js");
+const async_js_1 = require("../util_modules/fs/lib/async.js");
+const sync_js_1 = require("../util_modules/fs/lib/sync.js");
+const project_js_1 = require("../util_modules/project.js");
+const error_1 = __importDefault(require("../error"));
+const option_1 = require("../util_modules/option");
+const index_js_2 = __importDefault(require("../prompt/index.js"));
+function readInputFile(exeTarget) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const inputsFile = (0, path_1.resolve)(exeTarget.source, typeof exeTarget.inputs === 'string' ? exeTarget.inputs : index_js_1.FILENAME.catalyst_inputs);
+        const projectRoot = (0, project_js_1.getProjectRoot)();
+        if (!(0, sync_js_1.isPathInside)(projectRoot, inputsFile)) {
+            throw new error_1.default(`Input file path ${exeTarget.inputs} is outside the project directory.`, {
+                exit: 1,
+                context: {
+                    resolvePath: inputsFile,
+                    targetSource: projectRoot,
+                    inputs: exeTarget.inputs
+                }
+            });
+        }
+        return (0, async_js_1.readJSONFile)(inputsFile).catch((err) => {
+            throw new error_1.default('Unable to read the inputs file', {
+                original: err,
+                exit: 1,
+                errorId: 'FEXE-2',
+                arg: [(0, ansi_colors_1.italic)(inputsFile), ansi_colors_1.italic.red(err || '')]
+            });
+        });
+    });
+}
+function getInputs(exeTarget, inputData) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const targetInputs = inputData || (yield readInputFile(exeTarget));
+        if (!targetInputs || Object.keys(targetInputs).length === 0) {
+            throw new error_1.default('Empty inputs', {
+                exit: 0,
+                errorId: 'FEXE-3',
+                arg: [
+                    (0, ansi_colors_1.bold)(index_js_1.FILENAME.catalyst_inputs),
+                    (0, ansi_colors_1.bold)(index_js_1.FILENAME.catalyst_config),
+                    (0, ansi_colors_1.bold)('execution.test_inputs')
+                ]
+            });
+        }
+        const inputKeys = Object.keys(targetInputs);
+        const keyOpt = (0, option_1.getOptionValue)('key', undefined);
+        if (keyOpt && !(keyOpt in targetInputs)) {
+            throw new error_1.default('Key not present in inputs', {
+                exit: 0,
+                errorId: 'FEXE-4',
+                arg: [
+                    ansi_colors_1.bold.italic('--key ' + (0, ansi_colors_1.red)(keyOpt)),
+                    (0, ansi_colors_1.bold)(inputKeys.map((key) => '* ' + key).join('\n'))
+                ]
+            });
+        }
+        const selectedKey = yield index_js_2.default.ask(index_js_2.default.question('key', 'Please select the input', {
+            type: 'list',
+            choices: inputKeys.map((key) => index_js_2.default.choice(key, { value: key, short: key })),
+            when: !keyOpt && inputKeys.length > 1
+        }));
+        return inputKeys.length === 1
+            ? { key: inputKeys.at(0) || 'unknown', ip: targetInputs[inputKeys[0]] }
+            : targetInputs[selectedKey.key]
+                ? { key: selectedKey.key, ip: targetInputs[selectedKey.key] }
+                : { key: keyOpt, ip: targetInputs[keyOpt] };
+    });
+}

package/lib/execute/execute-input-resolver.d.ts

@@ -0,0 +1,29 @@
+import { readJSONFile, fileExists } from '../util_modules/fs/lib/async.js';
+import { getStdinType } from '../util_modules/fs/lib/sync.js';
+import CatalystError from '../error/index.js';
+export type InputResolutionFailureReason = 'no-usable-input' | 'invalid-json' | 'file-not-found' | 'file-unreadable' | 'empty-stdin' | 'stdin-not-piped' | 'stdin-timeout';
+type InputResolutionFailure = {
+    ok: false;
+    reason: InputResolutionFailureReason;
+    details?: string;
+    original?: unknown;
+};
+type InputResolutionSuccess = {
+    ok: true;
+    value: unknown;
+};
+export type InputResolutionResult = InputResolutionSuccess | InputResolutionFailure;
+type ResolverDeps = {
+    stdin?: NodeJS.ReadableStream;
+    stdinTypeResolver?: typeof getStdinType;
+    jsonFileReader?: typeof readJSONFile;
+    fileExistsChecker?: typeof fileExists;
+    projectRoot?: string;
+    cwd?: string;
+    idleTimeoutMs?: number;
+};
+export declare function resolveExecuteInputOption(inputValue: string, deps?: ResolverDeps): Promise<InputResolutionResult>;
+export declare function resolveInputError(resolvedInput: InputResolutionResult & {
+    ok: false;
+}, inputOption: string): CatalystError;
+export {};

package/lib/execute/execute-input-resolver.js

@@ -0,0 +1,207 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveExecuteInputOption = resolveExecuteInputOption;
+exports.resolveInputError = resolveInputError;
+const path_1 = require("path");
+const ansi_colors_1 = require("ansi-colors");
+const async_js_1 = require("../util_modules/fs/lib/async.js");
+const sync_js_1 = require("../util_modules/fs/lib/sync.js");
+const project_js_1 = require("../util_modules/project.js");
+const index_js_1 = __importDefault(require("../error/index.js"));
+const STDIN_IDLE_TIMEOUT_MS = 5000;
+function getFirstNonWhitespaceChar(value) {
+    const trimmed = value.trimStart();
+    return trimmed.length > 0 ? trimmed[0] : '';
+}
+function parseJSON(value) {
+    try {
+        return { ok: true, value: JSON.parse(value) };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reason: 'invalid-json',
+            details: value,
+            original: error
+        };
+    }
+}
+function resolveFromStdin(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ stdin, stdinTypeResolver, idleTimeoutMs }) {
+        const stdinType = stdinTypeResolver();
+        if (stdinType !== 'pipe' && stdinType !== 'file') {
+            return { ok: false, reason: 'stdin-not-piped' };
+        }
+        return new Promise((resolveResult) => {
+            const chunks = [];
+            let idleTimer;
+            const clearTimer = () => {
+                if (idleTimer) {
+                    clearTimeout(idleTimer);
+                    idleTimer = undefined;
+                }
+            };
+            const cleanup = () => {
+                clearTimer();
+                stdin.removeListener('data', onData);
+                stdin.removeListener('end', onEnd);
+                stdin.removeListener('error', onError);
+                if (typeof stdin.pause === 'function') {
+                    stdin.pause();
+                }
+            };
+            const resetIdleTimer = () => {
+                clearTimer();
+                idleTimer = setTimeout(() => {
+                    cleanup();
+                    resolveResult({ ok: false, reason: 'stdin-timeout' });
+                }, idleTimeoutMs);
+            };
+            const onData = (chunk) => {
+                chunks.push(typeof chunk === 'string' ? chunk : chunk.toString());
+                resetIdleTimer();
+            };
+            const onEnd = () => {
+                cleanup();
+                const value = chunks.join('').trimEnd();
+                if (value.trim().length === 0) {
+                    resolveResult({ ok: false, reason: 'empty-stdin' });
+                    return;
+                }
+                resolveResult(parseJSON(value));
+            };
+            const onError = (error) => {
+                cleanup();
+                resolveResult({
+                    ok: false,
+                    reason: 'file-unreadable',
+                    details: 'stdin',
+                    original: error
+                });
+            };
+            stdin.on('data', onData);
+            stdin.once('end', onEnd);
+            stdin.once('error', onError);
+            resetIdleTimer();
+            if (typeof stdin.resume === 'function') {
+                stdin.resume();
+            }
+        });
+    });
+}
+function resolveExecuteInputOption(inputValue_1) {
+    return __awaiter(this, arguments, void 0, function* (inputValue, deps = {}) {
+        var _a;
+        const value = inputValue !== null && inputValue !== void 0 ? inputValue : '';
+        const trimmed = value.trim();
+        if (trimmed.length === 0) {
+            return { ok: false, reason: 'no-usable-input' };
+        }
+        if (trimmed === '-') {
+            return resolveFromStdin({
+                stdin: deps.stdin || process.stdin,
+                stdinTypeResolver: deps.stdinTypeResolver || sync_js_1.getStdinType,
+                idleTimeoutMs: (_a = deps.idleTimeoutMs) !== null && _a !== void 0 ? _a : STDIN_IDLE_TIMEOUT_MS
+            });
+        }
+        const firstChar = getFirstNonWhitespaceChar(value);
+        if (firstChar === '{' || firstChar === '[') {
+            return parseJSON(value);
+        }
+        const cwd = deps.cwd || process.cwd();
+        const absolutePath = (0, path_1.resolve)(cwd, value);
+        const projectRoot = deps.projectRoot || (0, project_js_1.getProjectRoot)();
+        if (!(0, sync_js_1.isPathInside)(projectRoot, absolutePath)) {
+            return {
+                ok: false,
+                reason: 'file-unreadable',
+                details: `${value} (outside project directory)`
+            };
+        }
+        const doesFileExist = deps.fileExistsChecker || async_js_1.fileExists;
+        if (!(yield doesFileExist(absolutePath))) {
+            return { ok: false, reason: 'file-not-found', details: value };
+        }
+        try {
+            const jsonFileReader = deps.jsonFileReader || async_js_1.readJSONFile;
+            const parsedJSON = yield jsonFileReader(absolutePath);
+            return { ok: true, value: parsedJSON };
+        }
+        catch (error) {
+            const message = (error === null || error === void 0 ? void 0 : error.message) || '';
+            if (/JSON|Unexpected token|parse/i.test(message)) {
+                return {
+                    ok: false,
+                    reason: 'invalid-json',
+                    details: value,
+                    original: error
+                };
+            }
+            return {
+                ok: false,
+                reason: 'file-unreadable',
+                details: value,
+                original: error
+            };
+        }
+    });
+}
+function resolveInputError(resolvedInput, inputOption) {
+    switch (resolvedInput.reason) {
+        case 'no-usable-input':
+            return new index_js_1.default('No usable input provided with --input', {
+                exit: 1,
+                errorId: 'FEXE-7',
+                arg: [ansi_colors_1.bold.italic('--input')]
+            });
+        case 'stdin-timeout':
+            return new index_js_1.default('Timed out waiting for stdin input', {
+                exit: 1,
+                errorId: 'FEXE-8',
+                arg: [ansi_colors_1.bold.italic('--input -')]
+            });
+        case 'stdin-not-piped':
+            return new index_js_1.default('Stdin is not piped', {
+                exit: 1,
+                errorId: 'FEXE-9',
+                arg: [ansi_colors_1.bold.italic('--input -')]
+            });
+        case 'empty-stdin':
+            return new index_js_1.default('Received empty stdin content', {
+                exit: 1,
+                errorId: 'FEXE-10',
+                arg: [ansi_colors_1.bold.italic('--input -')]
+            });
+        case 'file-not-found':
+            return new index_js_1.default('Input file not found', {
+                exit: 1,
+                errorId: 'FEXE-11',
+                arg: [(0, ansi_colors_1.italic)(resolvedInput.details || inputOption)]
+            });
+        case 'file-unreadable':
+            return new index_js_1.default('Unable to read input source', {
+                exit: 1,
+                errorId: 'FEXE-12',
+                arg: [(0, ansi_colors_1.italic)(resolvedInput.details || inputOption)]
+            });
+        case 'invalid-json':
+        default:
+            return new index_js_1.default('Error parsing the JSON input', {
+                exit: 1,
+                errorId: 'FEXE-6',
+                arg: [ansi_colors_1.italic.red(resolvedInput.details || inputOption)]
+            });
+    }
+}

package/lib/execute/index.d.ts

@@ -1,3 +1,6 @@
 import { IFnTarget } from '../fn-utils/lib/common.js';
-declare const _default: (target: IFnTarget, input: Record<string, unknown>) => Promise<void>;
+declare const _default: (target: IFnTarget, input: {
+    key: string;
+    ip?: Record<string, unknown>;
+}) => Promise<void>;
 export default _default;

package/lib/execute/index.js

@@ -33,7 +33,8 @@ exports.default = (target, input) => __awaiter(void 0, void 0, void 0, function*
     try {
         (0, index_1.info)();
         (0, index_1.info)((0, ansi_colors_1.bold)('=> Starting function execution'));
-        (0, index_1.info)(`   name: ${(0, ansi_colors_1.green)(target.name)} | type: ${(0, ansi_colors_1.magenta)(target.type ? index_js_3.REMOTE_REF.functions.type[target.type] : '')} | stack: ${(0, ansi_colors_1.cyan)(target.stack || '')}`);
+        const exeInfo = `   name: ${(0, ansi_colors_1.green)(target.name)} | type: ${(0, ansi_colors_1.magenta)(target.type ? index_js_3.REMOTE_REF.functions.type[target.type] : '')} | stack: ${(0, ansi_colors_1.cyan)(target.stack || '')} | input: ${(0, ansi_colors_1.yellow)(input.key)}`;
+        (0, index_1.info)(exeInfo);
         (0, index_1.info)();
         if (yield index_js_4.ASYNC.isPathExists(buildFolder)) {
             try {
@@ -84,7 +85,7 @@ exports.default = (target, input) => __awaiter(void 0, void 0, void 0, function*
             isAlive: null
         }, new stream_1.EventEmitter());
         utils_1.serverEvent.once('stop', () => caller.kill());
-        yield caller.call(input);
+        yield caller.call(input.ip || {});
         utils_1.serverEvent.emit('stop');
         yield index_js_4.ASYNC.deleteDir(buildFolder).catch();
         yield index_js_1.fnUtils.common.executeHook({ prefix: 'post', command: 'serve' });

package/lib/fn-utils/lib/integ.js

@@ -23,6 +23,8 @@ const constants_1 = require("../../util_modules/constants");
 const runtime_1 = __importDefault(require("../../util_modules/constants/lib/runtime"));
 const fs_1 = require("../../util_modules/fs");
 const js_1 = require("../../util_modules/js");
+const prompt_fields_1 = require("../../init/features/functions/prompt-fields");
+const env_js_1 = require("../../util_modules/env.js");
 const serviceChoiceMap = {
     [constants_1.INTEG.services.cliq]: prompt_1.default.choice('Cliq', {
         value: constants_1.INTEG.services.cliq,
@@ -41,7 +43,7 @@ function integHelper(services) {
                 exit: 2
             });
         }
-        const serviceAns = yield prompt_1.default.ask(prompt_1.default.question('service', 'Select one of the services to continue:', {
+        const serviceAns = yield prompt_1.default.ask(prompt_1.default.question(prompt_fields_1.functionsAddPromptFields.get('service'), 'Select one of the services to continue:', {
             type: 'list',
             choices: serviceChoices
         }));
@@ -55,23 +57,26 @@ function integHelper(services) {
                         checked: true
                     });
                 });
-                const handlerSelection = yield prompt_1.default.ask(prompt_1.default.question('selectionAnswer', 'Pick the handlers to be initialised', {
-                    type: 'checkbox',
-                    choices: handlerChoice,
-                    validate: (ansArr) => {
-                        if (js_1.JS.isEmpty(ansArr)) {
-                            return ('Must select at least one handler.\n' +
-                                '(Press ' +
-                                (0, ansi_colors_1.cyan)('<space>') +
-                                ' to select, ' +
-                                (0, ansi_colors_1.cyan)('<a>') +
-                                ' to toggle all, ' +
-                                (0, ansi_colors_1.cyan)('<i>') +
-                                ' to invert selection)');
+                const handlerSelection = (0, env_js_1.isNonInteractiveMode)()
+                    ? { selectionAnswer: constants_1.CLIQ.component_handlers }
+                    : yield prompt_1.default.ask(prompt_1.default.question('selectionAnswer', 'Pick the handlers to be initialized', {
+                        type: 'checkbox',
+                        defaultAns: constants_1.CLIQ.component_handlers,
+                        choices: handlerChoice,
+                        validate: (ansArr) => {
+                            if (js_1.JS.isEmpty(ansArr)) {
+                                return ('Must select at least one handler.\n' +
+                                    '(Press ' +
+                                    (0, ansi_colors_1.cyan)('<space>') +
+                                    ' to select, ' +
+                                    (0, ansi_colors_1.cyan)('<a>') +
+                                    ' to toggle all, ' +
+                                    (0, ansi_colors_1.cyan)('<i>') +
+                                    ' to invert selection)');
+                            }
+                            return true;
                         }
-                        return true;
-                    }
-                }));
+                    }));
                 runtime_store_1.default.set('context.function.integration.cliq.handlers', handlerSelection.selectionAnswer);
                 break;
             default:

package/lib/index.js

@@ -30,6 +30,7 @@ program.option('--token <token>', 'Supply an authentication token for a command'
 program.option('--dc <us|eu|in|au>', 'Supply a data center for a command');
 program.option('--org <org_id>', 'Supply a Org ID to be used for a command');
 program.option('--verbose', 'Change the log level to verbose for debugging purposes');
+program.option('-ni, --non-interactive', 'Do not prompt for input; fail if required answers are not supplied (see also ZCATALYST_NON_INTERACTIVE)');
 program.helpOption('-h, --help', 'Display help for a Catalyst command');
 program.showSuggestionAfterError();
 program.showHelpAfterError(`For more usage information use the ${(0, ansi_colors_1.bold)('catalyst help')} command`);

package/lib/init/dependencies/package-json.js

@@ -20,11 +20,13 @@ const constants_1 = require("../../util_modules/constants");
 const js_1 = require("../../util_modules/js");
 const index_1 = require("../../util_modules/logger/index");
 const project_1 = require("../../util_modules/project");
+const prompt_fields_1 = require("../features/functions/prompt-fields");
+const env_1 = require("../../util_modules/env");
 exports.default = (keys) => __awaiter(void 0, void 0, void 0, function* () {
     const qns = keys.map((qn) => {
         switch (qn) {
             case 'name':
-                return prompt_1.default.question('name', 'package name: ', {
+                return prompt_1.default.question(prompt_fields_1.functionsAddPromptFields.get('name'), 'package name: ', {
                     defaultAns: js_1.JS.snakeCase((0, project_1.getProjectName)('sample') + '_function'),
                     validate: (ans) => {
                         if (ans.match(constants_1.REGEX.functions.package.name)) {
@@ -51,11 +53,13 @@ exports.default = (keys) => __awaiter(void 0, void 0, void 0, function* () {
                 throw new error_1.default('unknown key provided', { exit: 2 });
         }
     });
-    (0, index_1.info)('This utility will ask series of questions with sensible defaults for creating ' +
-        (0, ansi_colors_1.cyan)('package.json') +
-        '\nFeel free to modify them if needed.\n');
-    (0, index_1.info)('Use `' +
-        (0, ansi_colors_1.bold)('npm install <pkg> --save') +
-        '` afterwards to install a package and \nsave it as a dependency in the package.json file.\n');
+    if (!(0, env_1.isNonInteractiveMode)()) {
+        (0, index_1.info)('This utility will ask series of questions with sensible defaults for creating ' +
+            (0, ansi_colors_1.cyan)('package.json') +
+            '\nFeel free to modify them if needed.\n');
+        (0, index_1.info)('Use `' +
+            (0, ansi_colors_1.bold)('npm install <pkg> --save') +
+            '` afterwards to install a package and \nsave it as a dependency in the package.json file.\n');
+    }
     return prompt_1.default.ask(...qns);
 });