stepzen 0.29.0 → 0.30.0-beta.0

package/lib/commands/import.js

@@ -1,645 +0,0 @@
-"use strict";
-// Copyright (c) 2020,2021,2022,2023, StepZen, Inc.
-Object.defineProperty(exports, "__esModule", { value: true });
-const chalk = require("chalk");
-const fsx = require("fs-extra");
-const path = require("path");
-const core_1 = require("@oclif/core");
-const errors_1 = require("@oclif/core/lib/errors");
-const errors_2 = require("@oclif/core/lib/parser/errors");
-const dsn_parser_1 = require("@soluble/dsn-parser");
-const lodash_1 = require("lodash");
-const inquirer = require("../shared/inquirer");
-const utils_1 = require("../shared/utils");
-const helpers_1 = require("../generate/helpers");
-const curl2sdl_1 = require("../generate/curl2sdl");
-const curl_parser_1 = require("../shared/curl-parser");
-const zen_command_1 = require("../shared/zen-command");
-const graphql2sdl_1 = require("../generate/graphql2sdl");
-const sql2sdl_1 = require("../generate/sql2sdl");
-const constants_1 = require("../shared/constants");
-const path_params_parser_1 = require("../shared/path-params-parser");
-const header_params_parser_1 = require("../shared/header-params-parser");
-const header_1 = require("../shared/header");
-const configuration_1 = require("../shared/configuration");
-const rmtemp_1 = require("../shared/rmtemp");
-const _addDataTypesToDescription = (options) => {
-    const prefix = options?.dataSources
-        ? `[${options?.dataSources.join(', ')}]`
-        : '';
-    return prefix && options?.description
-        ? {
-            ...options,
-            description: `${prefix} ${options.description}`,
-        }
-        : options;
-};
-// extension of Flags from '@oclif/core'
-const Flags = {
-    // Can't figure how to make TS happy. The `options` value is passed
-    // to the original function and the original result is returned
-    // with minimal changes, yet TS is unable to figure out the types.
-    // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
-    // @ts-ignore
-    string: options => ({
-        ...core_1.Flags.string(_addDataTypesToDescription(options)),
-        dataSources: options?.dataSources,
-    }),
-    boolean: options => ({
-        ...core_1.Flags.boolean(_addDataTypesToDescription(options)),
-        dataSources: options?.dataSources,
-    }),
-};
-class Import extends zen_command_1.default {
-    // special parsing to support curl flags and options
-    async parse(options, argv = this.argv) {
-        let parsed;
-        try {
-            parsed = await super.parse(options, argv);
-        }
-        catch (error) {
-            if (!(error instanceof errors_2.CLIParseError)) {
-                throw error;
-            }
-            const { parse: { output }, } = error;
-            const isCurl = output?.args?.source?.toLowerCase() === 'curl';
-            const hasUnsupportedFlags = Boolean(output?.nonExistentFlags?.length);
-            if (isCurl && hasUnsupportedFlags) {
-                const unsupportedFlags = output.nonExistentFlags;
-                throw new errors_1.CLIError(`Unsupported curl flag${unsupportedFlags.length > 1 ? 's' : ''}: ${unsupportedFlags.join(', ')}.` +
-                    ` If this is a blocker for you, please let us know on Discord (${constants_1.STEPZEN_DISCORD_URL})`);
-            }
-            throw error;
-        }
-        const isCurl = parsed.args.source.toLowerCase() === 'curl';
-        if (isCurl) {
-            // "unparse" the curl flags and args into the argv array
-            // (to be parsed again by the curl-parser code later)
-            //
-            // The main reason for this non-optimal approach:
-            //  - In StepZen CLI, a curl command parser with support for
-            //    curl-specific validation and error messages has been historically
-            //    implemented without using the oclif parser. (This was done
-            //    because the curl syntax conventions for command line flags and
-            //    options slightly differ from those in oclif.)
-            //  - The custom curl parser is used in 2 places: to initially parse
-            //    the command line when running the Import command, and also to
-            //    parse the user answer to the "URL or a whole curl command"
-            //    question in the `askCurlQuestions()` function.
-            //  - The workarounds added to the oclif's `parse()` method in the
-            //    ZenCommand base class make it feasible to use the customised
-            //    oclif parser also for the curl command line. However, considering
-            //    the two options:
-            //      1. "unparse" the oclif parser output and keep using a custom
-            //         curl parser as before
-            //      2. remove the custom curl parser and use the oclif parser in
-            //         both places
-            //    the first option seems to provide more specific error messages,
-            //    and it is not drastically more complex than the second one
-            //    (calling the oclif parser directly outisde of the `parse()`
-            //    method is non-trivial).
-            parsed.argv.push(...(parsed.flags.data
-                ? parsed.flags.data.flatMap((data) => ['-d', data])
-                : []), ...(parsed.flags.request ? ['-X', parsed.flags.request] : []), ...(parsed.flags.url ? [parsed.flags.url] : []));
-        }
-        return parsed;
-    }
-    async run() {
-        const { args, argv, flags } = await this.parse(Import);
-        // Get the schema you're asking for; may be a DSN
-        const { source, dsn } = (0, helpers_1.getSource)(args.source);
-        // If using a local StepZen service instance, make sure it's running
-        await this.awaitIntrospectionServiceUpIfLocal();
-        // Get or create a StepZen workspace (possibly interactive)
-        const workspace = await this.ensureStepZenWorkspace({ directory: flags.dir });
-        // Define a sane onConflict behaviour (possibly interactive)
-        const onConflict = await this.ensureOnConflictBehavior(workspace, source, flags);
-        this.warnAboutIgnoredFlags(source, flags);
-        // Common options for all import source
-        const commonOptions = {
-            name: flags.name,
-            source: workspace.schema,
-            onConflict,
-        };
-        let importFn = undefined;
-        switch (source) {
-            case 'curl':
-                if (dsn) {
-                    throw new errors_1.CLIError(`Please use ${chalk.bold('stepzen import curl [url]')}`);
-                }
-                importFn = () => this.importCurl(argv, flags, commonOptions);
-                break;
-            case 'graphql':
-                if (dsn) {
-                    throw new errors_1.CLIError(`Please use ${chalk.bold('stepzen import graphql [url]')}`);
-                }
-                importFn = () => this.importGraphQL(argv, flags, commonOptions);
-                break;
-            case 'mysql':
-            case 'postgresql':
-            case 'snowflake':
-                importFn = () => this.importSql(source, dsn, flags, commonOptions);
-                break;
-            default:
-                throw new errors_1.CLIError(chalk `Unsupported data source: {bold ${source}}.` +
-                    chalk `\n\tStepZen CLI does not support introspection and automatic` +
-                    chalk ` GraphQL schema generation for {bold ${source}} data sources.` +
-                    chalk ` Please write a schema for it manually.` +
-                    chalk `\n\tSee {bold stepzen import --help} for supported data sources.`);
-        }
-        const result = await importFn();
-        try {
-            // Housekeeping
-            fsx.copySync(result, workspace.schema);
-            // Nice message
-            this.log(chalk.green(`Successfully imported ${chalk.bold(source)} data source into your GraphQL schema`));
-        }
-        finally {
-            (0, rmtemp_1.rmtemp)(result);
-        }
-    }
-    async importCurl(argv, flags, commonOptions) {
-        const headers = this.parseHeaderFlags(flags.header, flags['header-param']);
-        let curl2sdlOptions;
-        const curlFlagValues = {
-            queryName: flags['query-name'],
-            rootType: flags['query-type'],
-            typePrefix: flags.prefix,
-            pathParams: flags['path-params'],
-        };
-        if (argv.length === 1) {
-            // no parameters given: start an interactive prompt
-            console.log();
-            console.log('This command introspects the response of a REST endpoint and generates' +
-                ' a GraphQL schema allowing you to access this endpoint through your ' +
-                'StepZen API. curl syntax is supported so that you copy and paste a ' +
-                'curl command instead of the URL.');
-            console.log();
-            const interactiveOptions = await (0, curl2sdl_1.askCurlQuestions)(curlFlagValues);
-            curl2sdlOptions = {
-                ...commonOptions,
-                ...interactiveOptions,
-                // include boths headers passed via flags and headers entered interactively
-                headers: headers.concat(interactiveOptions.curlArgs.headers),
-            };
-        }
-        else {
-            // run non-interactively
-            const argsOrError = (0, curl_parser_1.parseCurlArgv)(argv);
-            if ('error' in argsOrError) {
-                throw new errors_1.CLIError(argsOrError.error);
-            }
-            const parsedPathParamsOrError = (0, path_params_parser_1.parsePathParamsPattern)(argsOrError.url, flags['path-params']);
-            if ('error' in parsedPathParamsOrError) {
-                throw new errors_1.CLIError(parsedPathParamsOrError.error);
-            }
-            const maybeDuplicateParamsMessage = (0, curl2sdl_1.makeDuplicateParamsMessage)(headers, parsedPathParamsOrError, argsOrError.url);
-            if (maybeDuplicateParamsMessage) {
-                throw new errors_1.CLIError(maybeDuplicateParamsMessage);
-            }
-            curl2sdlOptions = {
-                ...commonOptions,
-                ...curlFlagValues,
-                pathParams: parsedPathParamsOrError,
-                headers: headers,
-                curlArgs: argsOrError,
-            };
-        }
-        const configuration = await (0, configuration_1.readConfiguration)();
-        curl2sdlOptions.curlArgs.url = (0, utils_1.rewriteLocalhostToHostGatewayInURL)(configuration, curl2sdlOptions.curlArgs.url);
-        const { outPath } = await this.runImportAndExitOnError(() => (0, curl2sdl_1.curl2sdl)(curl2sdlOptions, configuration), 'Please check that the given curl command is valid.');
-        return outPath;
-    }
-    async importGraphQL(argv, flags, commonOptions) {
-        const headers = this.parseHeaderFlags(flags.header, flags['header-param']);
-        let graphql2sdlOptions;
-        const graphqlFlagValues = {
-            typePrefix: flags.prefix,
-        };
-        if (argv.length === 1) {
-            // no parameters given: start an interactive prompt
-            const interactiveOptions = await (0, graphql2sdl_1.askGraphQLQuestions)(graphqlFlagValues);
-            graphql2sdlOptions = {
-                ...commonOptions,
-                ...interactiveOptions,
-                // include boths headers passed via flags and headers entered interactively
-                headers: headers.concat(interactiveOptions.headers),
-            };
-        }
-        else {
-            // run non-interactively
-            graphql2sdlOptions = {
-                ...commonOptions,
-                ...graphqlFlagValues,
-                endpoint: argv[1],
-                headers: headers,
-            };
-        }
-        const configuration = await (0, configuration_1.readConfiguration)();
-        graphql2sdlOptions.endpoint = (0, utils_1.rewriteLocalhostToHostGatewayInURL)(configuration, graphql2sdlOptions.endpoint);
-        const { outPath } = await this.runImportAndExitOnError(() => (0, graphql2sdl_1.graphql2sdl)(graphql2sdlOptions, configuration));
-        return outPath;
-    }
-    async importSql(source, dsn, flags, fixedOptions) {
-        let sql2sdlOptions;
-        const sqlFlagValues = {
-            ...(dsn ? this.getSqlOptionsFromDSN(dsn) : {}),
-            ...this.getSqlOptionsFromFlags(flags),
-            dbType: source,
-        };
-        const requiredOptions = sqlFlagValues.dbType === 'snowflake'
-            ? ['accountId', 'user', 'password', 'database', 'warehouse']
-            : ['host', 'user', 'password', 'database'];
-        const hasRequiredOptions = requiredOptions.every(option => sqlFlagValues[option] !== undefined);
-        if (hasRequiredOptions) {
-            // an ugly hint for the TS compiler because it is not smart enough to figure this :(
-            const typedSqlFlagValues = sqlFlagValues.dbType === 'snowflake'
-                ? sqlFlagValues
-                : sqlFlagValues;
-            // run non-interactively
-            sql2sdlOptions = {
-                ...fixedOptions,
-                ...typedSqlFlagValues,
-            };
-        }
-        else {
-            // one or more required parameters are missing: start an interactive prompt
-            const interactiveOptions = source === 'mysql'
-                ? {
-                    ...(await (0, sql2sdl_1.askSqlQuestions)(source, sqlFlagValues)),
-                    dbType: source,
-                }
-                : source === 'postgresql'
-                    ? {
-                        ...(await (0, sql2sdl_1.askSqlQuestions)(source, sqlFlagValues)),
-                        dbType: source,
-                    }
-                    : {
-                        ...(await (0, sql2sdl_1.askSqlQuestions)(source, sqlFlagValues)),
-                        dbType: source,
-                    };
-            sql2sdlOptions = {
-                ...fixedOptions,
-                ...interactiveOptions,
-                include: sqlFlagValues.include,
-                introspectionOptions: sqlFlagValues.introspectionOptions,
-            };
-        }
-        const configuration = await (0, configuration_1.readConfiguration)();
-        if ('host' in sql2sdlOptions && sql2sdlOptions.host) {
-            sql2sdlOptions.host = (0, utils_1.rewriteLocalhostToHostGateway)(configuration, sql2sdlOptions.host);
-        }
-        if (sql2sdlOptions.dbType === 'snowflake') {
-            // Snowflake is very particular about the case in the database and schema names
-            sql2sdlOptions.schema = sql2sdlOptions.schema
-                ? sql2sdlOptions.schema.toUpperCase()
-                : 'PUBLIC';
-            sql2sdlOptions.database = sql2sdlOptions.database.toUpperCase();
-        }
-        const { outPath } = await this.runImportAndExitOnError(() => (0, sql2sdl_1.sql2sdl)(source, sql2sdlOptions, configuration), 'Please check that the given database details are valid.');
-        return outPath;
-    }
-    async ensureOnConflictBehavior(workspace, source, flags) {
-        const detectNameConflicts = (0, utils_1.getFeatureFlag)(constants_1.DETECT_NAME_CONFLICTS);
-        if (!detectNameConflicts) {
-            return 'append';
-        }
-        const name = flags.name || source;
-        const hasConflict = fsx.existsSync(path.join(workspace.schema, name));
-        if (!hasConflict) {
-            return 'append';
-        }
-        // No `--name` is given (i.e. naming is automatic)
-        // Using the default name is going to lead to a conflict, and it should
-        // be resolved by inventing a new unique name for the new schema.
-        if (!flags.name) {
-            return 'append';
-        }
-        // `--name` is given and (i.e. naming is namaged by the user)
-        // There is a naming conflict.
-        // The user has explicitly asked to overwrite the existing schema.
-        if (flags.overwrite) {
-            return 'overwrite';
-        }
-        // `--name` is given and (i.e. naming is namaged by the user)
-        // There is a naming conflict.
-        // The user has NOT given an explicit permission to overwrite the existing
-        // schema.
-        // In an interactive mode the CLI asks them for a confirmation.
-        // In a non-interactive mode the CLI throws an error.
-        if (flags['non-interactive']) {
-            throw new errors_1.CLIError(`A schema named ${chalk.bold(flags.name)} already exists in this workspace. Add an ${chalk.bold('--overwrite')} flag to overwrite it.`);
-        }
-        this.log(`A schema named ${chalk.bold(flags.name)} already exists in this workspace. Would you like to overwrite it?`);
-        const answers = await inquirer.prompt('import', [
-            {
-                name: 'overwrite',
-                type: 'confirm',
-                default: false,
-                message: `Overwrite ${flags.name}?`,
-            },
-        ]);
-        if (answers.overwrite) {
-            return 'overwrite';
-        }
-        return this.exit();
-    }
-    // notify the user about any ignored flags
-    warnAboutIgnoredFlags(source, usedFlags) {
-        Object.keys(usedFlags).forEach(flag => {
-            const definition = Import.flags[flag];
-            if (definition &&
-                'dataSources' in definition &&
-                definition.dataSources &&
-                !definition.dataSources.includes(source)) {
-                this.log(chalk.gray(`The ${chalk.bold(`--${flag}`)} flag only applies when importing ${definition.dataSources
-                    .map(source => chalk.bold(source))
-                    .join(', ')}. It will be ignored now.`));
-            }
-        });
-    }
-    parseHeaderFlags(headerFlagValues, headerParamFlagValues) {
-        const headers = [];
-        if (headerFlagValues) {
-            headerFlagValues.forEach(value => {
-                const headerOrError = (0, header_1.parseHeader)(value);
-                if (headerOrError && 'error' in headerOrError) {
-                    throw new errors_1.CLIError(headerOrError.error);
-                }
-                // A `null` from parseCurlHeaderString() means a header should NOT be
-                // sent. This is not supported by zenserv / the introspection service
-                // so the CLI simply omits such headers
-                if (headerOrError) {
-                    headers.push(headerOrError); // header
-                }
-            });
-        }
-        const headersOrError = (0, header_params_parser_1.makeHeaders)(headers, headerParamFlagValues);
-        if ('error' in headersOrError) {
-            throw new errors_1.CLIError(headersOrError.error);
-        }
-        return headersOrError;
-    }
-    getSqlOptionsFromFlags(flags) {
-        const options = {
-            host: flags['db-host'],
-            user: flags['db-user'],
-            password: flags['db-password'],
-            database: flags['db-database'],
-            linkTypes: flags['db-link-types'],
-            schema: flags['db-schema'],
-            include: flags['db-include'],
-            introspectionOptions: {
-                // Use the 2023 naming convention by default, and the 2022 naming
-                // convention only if explicitly requested by the user.
-                naming: flags['db-use-deprecated-2022-naming'] ? '2022' : '2023',
-            },
-            accountId: flags['snowflake-account-id'],
-            warehouse: flags['snowflake-warehouse'],
-        };
-        // Remove `undefined`-valued properties
-        return (0, lodash_1.pickBy)(options, value => value !== undefined);
-    }
-    getSqlOptionsFromDSN(possibleDsn) {
-        const parsed = (0, dsn_parser_1.parseDsn)(possibleDsn);
-        if (parsed.success) {
-            const value = parsed.value;
-            const options = {
-                host: value.driver === 'snowflake'
-                    ? undefined
-                    : value.host + (value.port ? `:${value.port}` : ''),
-                accountId: value.driver === 'snowflake' ? value.host : undefined,
-                user: value.user,
-                password: value.pass,
-                database: value.db,
-                schema: value.params?.schema === undefined
-                    ? undefined
-                    : `${value.params?.schema}`,
-                warehouse: value.params?.warehouse === undefined
-                    ? undefined
-                    : `${value.params?.warehouse}`,
-            };
-            // Remove `undefined`-valued properties
-            return (0, lodash_1.pickBy)(options, value => value !== undefined);
-        }
-        throw new errors_1.CLIError(parsed.message);
-    }
-    async runImportAndExitOnError(importFn, ctaOnError = '') {
-        try {
-            const importPromise = importFn();
-            let timeoutPromise;
-            let resultOrError;
-            core_1.ux.action.start('Starting');
-            timeoutPromise = (0, utils_1.getTimeout)(5 * 1000);
-            resultOrError = await Promise.race([importPromise, timeoutPromise]);
-            if (!resultOrError) {
-                // 5 sec passed, but no result yet
-                core_1.ux.action.start('Creating a GraphQL schema');
-                timeoutPromise = (0, utils_1.getTimeout)(5 * 1000);
-                resultOrError = await Promise.race([importPromise, timeoutPromise]);
-            }
-            if (!resultOrError) {
-                // another 5 sec passed (10 sec total)
-                core_1.ux.action.start('Creating a GraphQL schema (this is taking longer than usual)');
-                timeoutPromise = (0, utils_1.getTimeout)(30 * 1000);
-                resultOrError = await Promise.race([importPromise, timeoutPromise]);
-            }
-            if (!resultOrError) {
-                // another 30 sec passed (40 sec total)
-                core_1.ux.action.start('Creating a GraphQL schema (it may take up to 10 minutes)');
-                timeoutPromise = (0, utils_1.getTimeout)((8 * 60 + 20) * 1000);
-                resultOrError = await Promise.race([importPromise, timeoutPromise]);
-            }
-            if (resultOrError) {
-                timeoutPromise.cancel();
-            }
-            else {
-                // another 8 min 20 sec passed (9 min total)
-                // 9 minutes is the max timeout in the introspection service. If it has
-                // not responsed withing this time, there is no point in waiting longer.
-                resultOrError = {
-                    error: 'The StepZen introspection service has timed out.',
-                };
-            }
-            if ('error' in resultOrError) {
-                core_1.ux.action.stop(chalk.red('fail'));
-                this.log('A problem occurred while processing your import. ' + ctaOnError);
-                this.log(resultOrError.error);
-                this.exit(1);
-            }
-            core_1.ux.action.stop('done');
-            return resultOrError;
-        }
-        catch (error) {
-            core_1.ux.action.stop(chalk.red('fail'));
-            throw error;
-        }
-    }
-}
-exports.default = Import;
-Import.description = 'Import a schema for an external data source or an API endpoint to your GraphQL API.';
-Import.flags = {
-    ...zen_command_1.default.flags,
-    dir: Flags.string({ description: 'Working directory' }),
-    silent: Flags.boolean({ hidden: true }),
-    name: Flags.string({
-        description: 'Subfolder inside the workspace folder to save the imported' +
-            ' schema files to. Defaults to the name of the imported schema.',
-    }),
-    overwrite: Flags.boolean({
-        description: 'Overwrite any existing schema with the same name. Cannot be used' +
-            ' without also providing a --name flag.',
-        dependsOn: ['name'],
-        hidden: true,
-    }),
-    prefix: Flags.string({
-        dataSources: ['curl', 'graphql'],
-        description: 'Prefix to add to every type in the generated schema',
-    }),
-    data: Flags.string({
-        char: 'd',
-        dataSources: ['curl'],
-        hidden: true,
-        aliases: ['data-ascii', 'data-raw', 'data-binary'],
-        multiple: true,
-    }),
-    request: Flags.string({
-        char: 'X',
-        dataSources: ['curl'],
-        hidden: true,
-    }),
-    url: Flags.string({
-        dataSources: ['curl'],
-        hidden: true,
-        multiple: true,
-    }),
-    header: Flags.string({
-        char: 'H',
-        dataSources: ['curl', 'graphql'],
-        description: `Specifies a request header to pass` +
-            `\n` +
-            `\nExample:` +
-            `\nstepzen import curl https://example.com/api/customers \\` +
-            `\n\t-H ${chalk.bold('"Authorization: apikey SecretAPIKeyValue"')}`,
-        multiple: true,
-    }),
-    'header-param': Flags.string({
-        dataSources: ['curl', 'graphql'],
-        description: `Specifies a parameter in a header value.` +
-            ` Can be formed by taking a ${chalk.bold('-H, --header')} flag and replacing the` +
-            ` variable part of the header value with a ${chalk.bold('$paramName')} placeholder. Repeat this flag once for each header with a parameter.` +
-            `\n` +
-            `\nExample:` +
-            `\nstepzen import curl https://example.com/api/customers \\` +
-            `\n\t-H "Authorization: apikey SecretAPIKeyValue" \\` +
-            `\n\t--header-param 'Authorization: apikey ${chalk.bold('$apikey')}'`,
-        multiple: true,
-    }),
-    'query-name': Flags.string({
-        dataSources: ['curl'],
-        description: '[curl] Property name to add to the Query type as a way to' +
-            ' access the imported endpoint',
-    }),
-    'query-type': Flags.string({
-        dataSources: ['curl'],
-        description: 'Name for the type returned by the curl request in the ' +
-            `generated schema. The name specified by ${chalk.bold('--query-type')} is not prefixed by ${chalk.bold('--prefix')} if both flags are present.`,
-    }),
-    'path-params': Flags.string({
-        dataSources: ['curl'],
-        description: `Specifies path parameters in the URL path.` +
-            ` Can be formed by taking the original path and replacing the` +
-            ` variable segments with ${chalk.bold('$paramName')} placeholders.` +
-            `\n` +
-            `\nExample:` +
-            `\nstepzen import curl https://example.com/users/jane/posts/12` +
-            ` --path-params` +
-            ` '/users/${chalk.bold('$userId')}/posts/${chalk.bold('$postId')}'`,
-    }),
-    'db-host': Flags.string({
-        dataSources: ['mysql', 'postgresql'],
-        description: 'Database host and optional port (as HOST[:PORT])',
-    }),
-    'db-user': Flags.string({
-        dataSources: ['mysql', 'postgresql', 'snowflake'],
-        description: 'Database user name',
-    }),
-    'db-password': Flags.string({
-        dataSources: ['mysql', 'postgresql', 'snowflake'],
-        description: 'Database password',
-    }),
-    'db-database': Flags.string({
-        dataSources: ['mysql', 'postgresql', 'snowflake'],
-        description: 'Name of database to import',
-    }),
-    'db-link-types': Flags.boolean({
-        dataSources: ['mysql', 'postgresql', 'snowflake'],
-        description: `Automatically link types based on` +
-            ` foreign key relationships using @materializer` +
-            ` ${chalk.dim('(https://stepzen.com/docs/features/linking-types)')}`,
-    }),
-    'db-include': Flags.string({
-        dataSources: ['mysql', 'postgresql', 'snowflake'],
-        description: `Should the generated GraphQL schema` +
-            ` be based only on database views, only on tables or on both`,
-        options: ['tables-only', 'views-only', 'tables-and-views'],
-    }),
-    'db-schema': Flags.string({
-        dataSources: ['postgresql', 'snowflake'],
-        description: 'Database schema to import tables from (default: public)',
-    }),
-    'db-use-deprecated-2022-naming': Flags.boolean({
-        description: chalk `[mysql, postgresql] Use the {yellow deprecated} pre-2023 naming` +
-            chalk ` convention in the generated GraphQL schema:` +
-            chalk `\n\t- the generated type and property names are auto-capitalized` +
-            chalk ` into PascalCase` +
-            chalk `\n\t- the generated field names use the {italic getCustomer} and` +
-            chalk ` {italic getCustomerList} style.` +
-            chalk `\n` +
-            chalk `\nOn the other hand, when using the default naming convention:` +
-            chalk `\n\t- the generated type and property names match exactly the` +
-            chalk ` DB table and column names` +
-            chalk `\n\t- the generated field names use the {italic customer} and` +
-            chalk ` {italic customerList} style.`,
-    }),
-    'snowflake-account-id': Flags.string({
-        dataSources: ['snowflake'],
-        description: chalk `Snowflake account identifier in the {bold orgname-accountname}` +
-            chalk ` format. For more information, see the Snowflake documentation at` +
-            chalk ` https://docs.snowflake.com/en/user-guide/admin-account-identifier.html.`,
-    }),
-    'snowflake-warehouse': Flags.string({
-        dataSources: ['snowflake'],
-        description: 'Snowflake warehouse',
-    }),
-};
-Import.args = {
-    source: core_1.Args.string({ required: true }),
-};
-Import.flagHelpForSource = (source, exclude) => Object.entries(Import.flags)
-    .filter(([name, value]) => 'dataSources' in value &&
-    value.dataSources?.includes(source) &&
-    (!exclude || !exclude.includes(name)))
-    .map(([f, d]) => `[--${f}${d.type === 'option' ? `=${f.toUpperCase()}` : ''}]`)
-    .join(' ');
-Import.usage = [
-    `import curl [[CURLOPTS] URL] ${Import.flagHelpForSource('curl')}`,
-    `import graphql [URL] ${Import.flagHelpForSource('graphql')}`,
-    `import mysql ${Import.flagHelpForSource('mysql')}`,
-    `import mysql://[USER:PASSWORD@]HOST[:PORT][/DATABASE] ${Import.flagHelpForSource('mysql', ['db-host', 'db-user', 'db-password', 'db-database'])}`,
-    `import postgresql ${Import.flagHelpForSource('postgresql')}`,
-    `import postgresql://[USER:PASSWORD@]HOST[:PORT][/DATABASE] ${Import.flagHelpForSource('postgresql', ['db-host', 'db-user', 'db-password', 'db-database'])}`,
-    `import snowflake ${Import.flagHelpForSource('snowflake', ['db-host'])}`,
-    `import snowflake://[USER[:PASSWORD]@]ACCOUNT_IDENTIFIER[/DATABASE][?schema=<SCHEMA>[&warehouse=<WAREHOUSE>]] ${Import.flagHelpForSource('snowflake', [
-        'db-host',
-        'db-user',
-        'db-password',
-        'db-database',
-        'db-schema',
-        'snowflake-account-id',
-        'snowflake-warehouse',
-    ])}`,
-];
-// allow any number of arguments to support `import curl [url] [curl flags and options]`
-Import.strict = false;
-//# sourceMappingURL=import.js.map