@whook/whook/dist/services/command.js

Build strong and efficient REST web services.

import { autoService, location, } from 'knifecycle';
import { pickYErrorWithCode, printStackTrace, YError } from 'yerror';
import { promptArgs } from '../libs/args.js';
import { DEFAULT_COERCION_OPTIONS, } from '../libs/coercion.js';
import { getCasterForSchema } from '../libs/validation.js';
import { ensureResolvedObject } from 'ya-open-api-types';
async function initCommand({ ENV, API, COMMAND_DEFINITION, COERCION_OPTIONS = DEFAULT_COERCION_OPTIONS, commandHandler, schemaValidators, $ready, $instance, $fatalError, args, log, }) {
    async function commandRunner() {
        await $ready;
        try {
            if (COMMAND_DEFINITION.config?.promptArgs && !ENV.CI && !ENV.NO_PROMPT) {
                // Required to ensure any logs are printed
                await Promise.resolve();
                args = await promptArgs({ API, COMMAND_DEFINITION }, args);
            }
            for (const argument of COMMAND_DEFINITION.arguments) {
                const resolvedSchema = (await ensureResolvedObject(API, argument.schema));
                if (typeof args.namedArguments[argument.name] === 'undefined') {
                    if (argument.required) {
                        log('error', `❌ - Argument "${argument.name}" is required.`);
                        throw new YError('E_MISSING_REQUIRED_ARG', [argument.name]);
                    }
                    if ('default' in resolvedSchema &&
                        typeof resolvedSchema.default !== 'undefined') {
                        args.namedArguments[argument.name] =
                            resolvedSchema.default;
                    }
                    continue;
                }
                const caster = await getCasterForSchema({ API, COERCION_OPTIONS }, resolvedSchema);
                const validator = schemaValidators(argument.schema);
                // TODO: Add ajv human readable error builder
                validator(caster(args.namedArguments[argument.name]));
                if (validator.errors?.length) {
                    throw new YError('E_BAD_ARG', [validator.errors]);
                }
            }
            await commandHandler(args);
            await $instance.destroy();
        }
        catch (err) {
            const argError = pickYErrorWithCode(err, 'E_BAD_ARG');
            if (argError) {
                log('debug-stack', printStackTrace(err));
                if (argError.debug[0][0].keyword === 'required') {
                    if (argError.debug[0][0].params.missingProperty) {
                        $fatalError.throwFatalError(err);
                        return;
                    }
                }
                if (argError.debug[0][0].keyword === 'additionalProperties') {
                    if (argError.debug[0][0].params.additionalProperty === '_') {
                        log('error', '💥 - No anonymous arguments allowed.');
                        $fatalError.throwFatalError(err);
                        return;
                    }
                    if (argError.debug[0][0].params.additionalProperty) {
                        log('error', `💥 - Argument "${argError.debug[0][0].params.additionalProperty}" not allowed.`);
                        $fatalError.throwFatalError(err);
                        return;
                    }
                }
                log('error', `💥 - Error parsing arguments: ${argError.debug[0][0].keyword}, ${argError.debug[0][0].params}`);
                $fatalError.throwFatalError(err);
                return;
            }
            log('error-stack', printStackTrace(err));
            $fatalError.throwFatalError(err);
            return;
        }
    }
    commandRunner();
}
export default location(autoService(initCommand), import.meta.url);
//# sourceMappingURL=command.js.map