stepzen 0.18.0 → 0.19.0-beta.2

package/README.md

@@ -20,6 +20,7 @@ To verify your  CLI installation, use the `stepzen --version` command:
 * [Installing](#installing)
 * [Verifying your installation](#verifying-your-installation)
 * [Usage](#usage)
+* [QA from cloned repo](#qa-from-cloned-repo)
 * [Commands](#commands)
 <!-- tocstop -->
 # Usage
@@ -29,13 +30,19 @@ $ npm install -g stepzen
 $ stepzen COMMAND
 running command...
 $ stepzen (-v|--version|version)
-stepzen/0.18.0 darwin-arm64 node-v16.15.0
+stepzen/0.19.0-beta.2 darwin-x64 node-v14.19.3
 $ stepzen --help [COMMAND]
 USAGE
   $ stepzen COMMAND
 ...
 ```
 <!-- usagestop -->
+
+# QA from cloned repo 
+<!-- QA -->
+To run from code: `path-to-repo/bin/run start` (start or whatever command you're QAing)
+<!-- QAstop -->
+
 # Commands
 <!-- commands -->
 * [`stepzen deploy DESTINATION`](#stepzen-deploy-destination)
@@ -84,7 +91,7 @@ _See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v5.1.1
 
 ## `stepzen import SCHEMA`
 
-import a schema for an external data source or a API endpoint to your GraphQL API
+import a schema for an external data source or an API endpoint to your GraphQL API
 
 ```
 USAGE
@@ -107,8 +114,11 @@ OPTIONS
   --db-host=db-host
       [mysql, postgresql] database host
 
+  --db-include=(tables-only|views-only|tables-and-views)
+      [mysql, postgresql] Should the generated GraphQL schema be based only on database views, only on tables or on both.
+
   --db-link-types
-      [mysql, postgresql] Automatically link types with @materializer whenever there is database support
+      [mysql, postgresql] Automatically link types based on foreign key relationships using @materializer
       (https://stepzen.com/docs/features/linking-types)
 
   --db-password=db-password

package/lib/commands/deploy.js

@@ -27,7 +27,7 @@ class Deploy extends zen_command_1.default {
                 ? `${flags.configurationsets},stepzen/public`
                 : 'stepzen/public';
         }
-        const response = await actions_1.deploy(args.destination, flags.configurationsets, flags.schema);
+        const response = await (0, actions_1.deploy)(args.destination, flags.configurationsets, flags.schema);
         if (response.success) {
             if (!flags.silent) {
                 this.log(response.message || 'Success');

package/lib/commands/import.d.ts

@@ -1,7 +1,10 @@
 import { flags } from '@oclif/command';
+import { Input } from '@oclif/parser';
+import type { CommonImportOptions } from '../generate';
 import ZenCommand from '../shared/zen-command';
 import { HeaderInput } from '../shared/header';
 import { Workspace } from '../shared/types';
+declare type Flags<Command> = Command extends Input<infer F> ? F : never;
 export default class Import extends ZenCommand {
     static description: string;
     static commonIntrospectionFlags: {
@@ -20,6 +23,7 @@ export default class Import extends ZenCommand {
         'db-password': flags.IOptionFlag<string | undefined>;
         'db-database': flags.IOptionFlag<string | undefined>;
         'db-link-types': import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        'db-include': flags.IOptionFlag<string>;
     };
     static postgresqlFlags: {
         'db-schema': flags.IOptionFlag<string | undefined>;
@@ -45,6 +49,7 @@ export default class Import extends ZenCommand {
             'db-password': flags.IOptionFlag<string | undefined>;
             'db-database': flags.IOptionFlag<string | undefined>;
             'db-link-types': import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+            'db-include': flags.IOptionFlag<string>;
         };
         schemas: string[];
     } | {
@@ -60,6 +65,7 @@ export default class Import extends ZenCommand {
         'db-password': flags.IOptionFlag<string | undefined>;
         'db-database': flags.IOptionFlag<string | undefined>;
         'db-link-types': import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        'db-include': flags.IOptionFlag<string>;
         'query-name': flags.IOptionFlag<string | undefined>;
         'query-type': flags.IOptionFlag<string | undefined>;
         'path-params': flags.IOptionFlag<string | undefined>;
@@ -79,6 +85,10 @@ export default class Import extends ZenCommand {
     }[];
     static strict: boolean;
     run(): Promise<void>;
+    importCurl(argv: string[], flags: Flags<typeof Import>, commonOptions: CommonImportOptions): Promise<string>;
+    importGraphQL(argv: string[], flags: Flags<typeof Import>, commonOptions: CommonImportOptions): Promise<string>;
+    importSql(schema: 'mysql' | 'postgresql', flags: Flags<typeof Import>, fixedOptions: CommonImportOptions): Promise<string>;
+    importFromGeneratorEngines(schema: string, flags: any, fixedOptions: CommonImportOptions): Promise<string>;
     ensureOnConflictBehavior(workspace: Workspace, schema: string, flags: ReturnType<Import['parseWorkaround']>['flags']): Promise<"overwrite" | "append">;
     warnAboutIgnoredFlags(schema: string, usedFlags: {
         [key: string]: any;
@@ -90,6 +100,7 @@ export default class Import extends ZenCommand {
         'db-password': string | undefined;
         'db-database': string | undefined;
         'db-link-types': boolean;
+        'db-include': string;
         'query-name': string | undefined;
         'query-type': string | undefined;
         'path-params': string | undefined;
@@ -106,4 +117,14 @@ export default class Import extends ZenCommand {
         [name: string]: any;
     }>;
     parseHeaderFlags(headerFlagValues?: string[], headerParamFlagValues?: string[]): HeaderInput[];
+    getSqlOptionsFromFlags(flags: Flags<typeof Import>): {
+        host: string | undefined;
+        user: string | undefined;
+        password: string | undefined;
+        database: string | undefined;
+        linkTypes: boolean;
+        schema: string | undefined;
+        include: "tables-only" | "views-only" | "tables-and-views" | undefined;
+    };
 }
+export {};

package/lib/commands/import.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const chalk = require("chalk");
 const fs = require("fs-extra");
+const glob = require("glob");
 const path = require("path");
 const inquirer = require("inquirer");
 const command_1 = require("@oclif/command");
@@ -16,6 +17,8 @@ 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 validate_1 = require("../commands/validate");
 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");
@@ -24,139 +27,196 @@ class Import extends zen_command_1.default {
     async run() {
         const { args, argv, flags } = this.parseWorkaround();
         // Get a list of schemas you're asking for
-        const schema = helpers_1.getSchema(args.schema);
+        const schema = (0, helpers_1.getSchema)(args.schema);
         // Get or create a StepZen workspace (possibly interactive)
         const workspace = await this.ensureStepZenWorkspace({ directory: flags.dir });
+        if (schema !== 'curl' && schema !== 'graphql') {
+            try {
+                if (glob.sync('**/*.graphql', { cwd: workspace.schema }).length > 0) {
+                    // The workspace schema has to be valid for import to work because when
+                    // importing any other schemas than `curl` and `graphql` the CLI tries
+                    // to _merge_ the imported schema into the workspace schema, and that's
+                    // going to fail if the workspace schema is invalid to start with.
+                    await validate_1.default.run([workspace.schema]);
+                }
+            }
+            catch (error) {
+                throw new errors_1.CLIError(`Could not import a ${schema} schema into the workspace.` +
+                    ` The workspace needs to have a valid GraphQL schema before` +
+                    ` ${chalk.bold(`stepzen import ${schema}`)} could start.` +
+                    `\n` +
+                    `\nThe following issues with the GraphQL schema were detected:` +
+                    `\n${error.message}`);
+            }
+        }
         // Define a sane onConflict behaviour (possibly interactive)
         const onConflict = await this.ensureOnConflictBehavior(workspace, schema, flags);
         this.warnAboutIgnoredFlags(schema, flags);
-        const headers = this.parseHeaderFlags(flags.header, flags['header-param']);
+        // Common options for all import schemas
+        const commonOptions = {
+            name: flags.name,
+            source: workspace.schema,
+            onConflict,
+        };
         // Select an import execution flow:
-        //  - v1 with `stepzen/engines` and cloud function
-        //  - v2 with the graphqlize service
-        let result;
-        if (schema === 'curl') {
-            // LATER: offload the check to the graphqlize service or fetch
-            // the list of supported data sources and compare agains it.
-            this.log(chalk.yellow(`NOTE: ${chalk.bold('stepzen import curl')} is a ${chalk.bold('new')} feature.`));
-            this.log(chalk.yellow('If you have any issues, please check if they have been addressed ' +
-                'in the latest version, or reach out to StepZen on Discord: ' +
-                constants_1.STEPZEN_DISCORD_URL));
-            let curl2sdlOptions;
-            const fixedOptions = {
-                name: flags.name,
-                source: workspace.schema,
-                onConflict,
-            };
-            const editableOptions = {
-                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 curlAnswers = await curl2sdl_1.askCurlQuestions(editableOptions);
-                curl2sdlOptions = Object.assign(Object.assign(Object.assign({}, fixedOptions), curlAnswers), { 
-                    // include boths headers passed via flags and headers entered interactively
-                    headers: headers.concat(curlAnswers.curlArgs.headers) });
-            }
-            else {
-                // run non-interative
-                const argsOrError = curl_parser_1.parseCurlArgv(argv);
-                if ('error' in argsOrError) {
-                    throw new errors_1.CLIError(argsOrError.error);
-                }
-                const parsedPathParamsOrError = path_params_parser_1.parsePathParamsPattern(argsOrError.url, flags['path-params']);
-                if ('error' in parsedPathParamsOrError) {
-                    throw new errors_1.CLIError(parsedPathParamsOrError.error);
+        //  - v1 (deprecated) through the `generator-engines` cloud function
+        //  - v2 (default) directly call the DB and REST introspection service APIs
+        const useGeneratorEngines = (0, utils_1.getFeatureFlag)(constants_1.USE_GENERATOR_ENGINES);
+        let importFn = undefined;
+        switch (schema) {
+            case 'curl':
+                importFn = () => this.importCurl(argv, flags, commonOptions);
+                break;
+            case 'graphql':
+                importFn = () => this.importGraphQL(argv, flags, commonOptions);
+                break;
+            case 'mysql':
+            case 'postgresql':
+                importFn = useGeneratorEngines
+                    ? () => this.importFromGeneratorEngines(schema, flags, commonOptions)
+                    : () => this.importSql(schema, flags, commonOptions);
+                break;
+            default:
+                if (useGeneratorEngines) {
+                    importFn = () => this.importFromGeneratorEngines(schema, flags, commonOptions);
                 }
-                const maybeDuplicateParamsMessage = curl2sdl_1.makeDuplicateParamsMessage(headers, parsedPathParamsOrError, argsOrError.url);
-                if (maybeDuplicateParamsMessage) {
-                    throw new errors_1.CLIError(maybeDuplicateParamsMessage);
+                else {
+                    throw new errors_1.CLIError(`Cannot find the schema ${schema}`);
                 }
-                curl2sdlOptions = Object.assign(Object.assign(Object.assign({}, fixedOptions), editableOptions), { pathParams: parsedPathParamsOrError, headers: headers, curlArgs: argsOrError });
-            }
-            core_1.CliUx.ux.action.start('Starting');
-            const resultOrError = await curl2sdl_1.curl2sdl(curl2sdlOptions);
-            core_1.CliUx.ux.action.stop();
-            if ('error' in resultOrError) {
-                this.log('A problem occured while processing your import. ' +
-                    'Please check that the given cURL command is valid.');
-                this.log(resultOrError.error);
-                this.exit();
-            }
-            result = resultOrError.outPath;
         }
-        else if (schema === 'graphql') {
-            const editableOptions = {
-                typePrefix: flags.prefix,
-                headers: headers,
-            };
-            let answers;
-            if (argv.length === 1) {
-                // interactive
-                answers = await graphql2sdl_1.askGraphQLQuestions(editableOptions);
+        const result = await importFn();
+        // Housekeeping
+        fs.copySync(result, workspace.schema);
+        fs.removeSync(result);
+        // Nice message
+        this.log(chalk.green(`Successfully imported schema ${chalk.bold(schema)} from StepZen`));
+    }
+    async importCurl(argv, flags, commonOptions) {
+        const headers = this.parseHeaderFlags(flags.header, flags['header-param']);
+        this.log(chalk.yellow(`NOTE: ${chalk.bold('stepzen import curl')} is a ${chalk.bold('new')} feature.`));
+        this.log(chalk.yellow('If you have any issues, please check if they have been addressed ' +
+            'in the latest version, or reach out to StepZen on Discord: ' +
+            constants_1.STEPZEN_DISCORD_URL));
+        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 = Object.assign(Object.assign(Object.assign({}, 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);
             }
-            else {
-                // non-interactive
-                answers = Object.assign(Object.assign({}, editableOptions), { endpoint: argv[1] });
+            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 fixedOptions = {
-                name: flags.name,
-                source: workspace.schema,
-                onConflict,
-            };
-            const options = Object.assign(Object.assign({}, fixedOptions), answers);
-            core_1.CliUx.ux.action.start('Starting');
-            const resultOrError = await graphql2sdl_1.graphql2sdl(options);
-            core_1.CliUx.ux.action.stop();
-            if ('error' in resultOrError) {
-                this.log('A problem occured while processing your import.');
-                this.log(resultOrError.error);
-                this.exit();
+            const maybeDuplicateParamsMessage = (0, curl2sdl_1.makeDuplicateParamsMessage)(headers, parsedPathParamsOrError, argsOrError.url);
+            if (maybeDuplicateParamsMessage) {
+                throw new errors_1.CLIError(maybeDuplicateParamsMessage);
             }
-            result = resultOrError.outPath;
+            curl2sdlOptions = Object.assign(Object.assign(Object.assign({}, commonOptions), curlFlagValues), { pathParams: parsedPathParamsOrError, headers: headers, curlArgs: argsOrError });
+        }
+        core_1.CliUx.ux.action.start('Starting');
+        const resultOrError = await (0, curl2sdl_1.curl2sdl)(curl2sdlOptions);
+        core_1.CliUx.ux.action.stop();
+        if ('error' in resultOrError) {
+            this.log('A problem occured while processing your import. ' +
+                'Please check that the given cURL command is valid.');
+            this.log(resultOrError.error);
+            this.exit();
+        }
+        return resultOrError.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 = Object.assign(Object.assign(Object.assign({}, commonOptions), interactiveOptions), { 
+                // include boths headers passed via flags and headers entered interactively
+                headers: headers.concat(interactiveOptions.headers) });
+        }
+        else {
+            // run non-interactively
+            graphql2sdlOptions = Object.assign(Object.assign(Object.assign({}, commonOptions), graphqlFlagValues), { endpoint: argv[1], headers: headers });
+        }
+        core_1.CliUx.ux.action.start('Starting');
+        const resultOrError = await (0, graphql2sdl_1.graphql2sdl)(graphql2sdlOptions);
+        core_1.CliUx.ux.action.stop();
+        if ('error' in resultOrError) {
+            this.log('A problem occured while processing your import.');
+            this.log(resultOrError.error);
+            this.exit();
+        }
+        return resultOrError.outPath;
+    }
+    async importSql(schema, flags, fixedOptions) {
+        let sql2sdlOptions;
+        const sqlFlagValues = this.getSqlOptionsFromFlags(flags);
+        if (sqlFlagValues.host !== undefined &&
+            sqlFlagValues.database !== undefined &&
+            sqlFlagValues.user !== undefined &&
+            sqlFlagValues.password !== undefined) {
+            // run non-interactively
+            sql2sdlOptions = Object.assign(Object.assign(Object.assign({}, fixedOptions), sqlFlagValues), sqlFlagValues);
         }
         else {
-            // Map flag names to the properties defined for sql engines in:
-            // https://github.com/steprz/generator-engines/blob/main/generator/src/shared/sql.ts
-            // If/when the number of property-to-answer mappings increase, create a dictionary
-            // { schema: { flag: field } } and build the below map based on this (a
-            // dictionary also enables a generic solution to the warning about ignored flags).
-            let preAnswered = {};
-            if (schema === 'mysql' || schema === 'postgresql') {
-                const asKeyValue = (key, flag) => flag === undefined ? {} : { [key]: flag };
-                preAnswered = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, asKeyValue('host', flags['db-host'])), asKeyValue('user', flags['db-user'])), asKeyValue('password', flags['db-password'])), asKeyValue('database', flags['db-database'])), asKeyValue('linkTypes', flags['db-link-types'] ? 'Yes' : 'No')), asKeyValue('schema', flags['db-schema']));
+            // one or more required parameters are missing: start an interactive prompt
+            const interactiveOptions = await (0, sql2sdl_1.askSqlQuestions)(schema, sqlFlagValues);
+            sql2sdlOptions = Object.assign(Object.assign(Object.assign({}, fixedOptions), interactiveOptions), { include: sqlFlagValues.include });
+        }
+        core_1.CliUx.ux.action.start('Starting');
+        const resultOrError = await (0, sql2sdl_1.sql2sdl)(schema, sql2sdlOptions);
+        core_1.CliUx.ux.action.stop();
+        if ('error' in resultOrError) {
+            this.log('A problem occured while processing your import. ' +
+                'Please check that the given database details are valid.');
+            this.log(resultOrError.error);
+            this.exit();
+        }
+        return resultOrError.outPath;
+    }
+    async importFromGeneratorEngines(schema, flags, fixedOptions) {
+        let preAnswered = {};
+        if (schema === 'mysql' || schema === 'postgresql') {
+            preAnswered = this.getSqlOptionsFromFlags(flags);
+            if (Object.prototype.hasOwnProperty.call(preAnswered, 'linkTypes')) {
+                preAnswered.linkTypes = preAnswered.linkTypes ? 'Yes' : 'No';
             }
-            // Let's go!
-            result = await generate_1.default({
-                schema,
-                name: flags.name,
-                onConflict,
-                source: workspace.schema,
-                preAnswered,
-            });
-            // Validate
-            await transpiler_1.validate(result, {
-                extensions: await utils_1.getStepZenExtensions(),
-            });
         }
-        // Housekeeping
-        fs.copySync(result, workspace.schema);
-        fs.removeSync(result);
-        // Nice message
-        this.log(chalk.green(`Successfully imported schema ${chalk.bold(schema)} from StepZen`));
+        // Let's go!
+        const result = await (0, generate_1.default)(Object.assign(Object.assign({}, fixedOptions), { schema,
+            preAnswered }));
+        // Validate
+        await (0, transpiler_1.validate)(result, {
+            extensions: await (0, utils_1.getStepZenExtensions)(),
+        });
+        return result;
     }
     async ensureOnConflictBehavior(workspace, schema, flags) {
-        const featureFlag = process.env.STEPZEN_DETECT_NAME_CONFLICTS;
-        if (featureFlag === undefined || featureFlag.toLowerCase() === 'false') {
+        const detectNameConflicts = (0, utils_1.getFeatureFlag)(constants_1.DETECT_NAME_CONFLICTS);
+        if (!detectNameConflicts) {
             return 'append';
         }
         const name = flags.name || schema;
@@ -258,7 +318,7 @@ class Import extends zen_command_1.default {
         const headers = [];
         if (headerFlagValues) {
             headerFlagValues.forEach(value => {
-                const headerOrError = header_1.parseHeader(value);
+                const headerOrError = (0, header_1.parseHeader)(value);
                 if (headerOrError && 'error' in headerOrError) {
                     throw new errors_1.CLIError(headerOrError.error);
                 }
@@ -270,15 +330,37 @@ class Import extends zen_command_1.default {
                 }
             });
         }
-        const headersOrError = header_params_parser_1.makeHeaders(headers, headerParamFlagValues);
+        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'],
+        };
+        if ((0, utils_1.getFeatureFlag)(constants_1.USE_GENERATOR_ENGINES)) {
+            // Explicitly delete all `undefined` properties to keep the
+            // `generator-engines` cloud function happy
+            Object.keys(options).forEach(key => {
+                const k = key;
+                if (options[k] === undefined) {
+                    delete options[k];
+                }
+            });
+        }
+        return options;
+    }
 }
 exports.default = Import;
-Import.description = 'import a schema for an external data source or a API endpoint to your GraphQL API';
+Import.description = 'import a schema for an external data source or an API endpoint to your GraphQL API';
 Import.commonIntrospectionFlags = {
     prefix: command_1.flags.string({
         description: '[curl, graphql] prefix to add every type in the generated schema.',
@@ -338,10 +420,16 @@ Import.sqlFlags = {
         description: '[mysql, postgresql] name of database to import',
     }),
     'db-link-types': command_1.flags.boolean({
-        description: `[mysql, postgresql] Automatically link types with` +
-            ` @materializer whenever there is database support` +
+        description: `[mysql, postgresql] Automatically link types based on` +
+            ` foreign key relationships using @materializer` +
             ` ${chalk.dim('(https://stepzen.com/docs/features/linking-types)')}`,
     }),
+    'db-include': command_1.flags.enum({
+        options: ['tables-only', 'views-only', 'tables-and-views'],
+        description: `[mysql, postgresql] Should the generated GraphQL schema be based` +
+            ` only on database views, only on tables or on both.`,
+        hidden: (0, utils_1.getFeatureFlag)(constants_1.USE_GENERATOR_ENGINES),
+    }),
 };
 Import.postgresqlFlags = {
     'db-schema': command_1.flags.string({

package/lib/commands/init.js

@@ -7,7 +7,7 @@ const zen_command_1 = require("../shared/zen-command");
 class Init extends zen_command_1.default {
     async run() {
         const { args, flags } = this.parse(Init);
-        const created = await workspace_1.initWorkspace({
+        const created = await (0, workspace_1.initWorkspace)({
             directory: args.directory,
             endpoint: flags.endpoint,
             yes: flags.yes,
@@ -17,7 +17,7 @@ class Init extends zen_command_1.default {
     }
 }
 exports.default = Init;
-Init.description = 'stepzen init';
+Init.description = 'Initialize a StepZen workspace in the current directory';
 Init.hidden = true;
 Init.flags = Object.assign(Object.assign({}, zen_command_1.default.flags), { endpoint: command_1.flags.string({ hidden: true }), help: command_1.flags.help({ char: 'h' }), yes: command_1.flags.boolean({ default: false, hidden: true }) });
 Init.args = [

package/lib/commands/lint.js

@@ -9,7 +9,7 @@ class Init extends zen_command_1.default {
     async run() {
         const { flags } = this.parse(Init);
         // Get the correct directory
-        const directory = utils_1.getDirectory(flags.dir);
+        const directory = (0, utils_1.getDirectory)(flags.dir);
         this.log(directory);
         // Take over console.log
         console.log = (msg) => {
@@ -18,7 +18,7 @@ class Init extends zen_command_1.default {
             this.log(formatted);
         };
         // Lint
-        await transpiler_1.lint(directory);
+        await (0, transpiler_1.lint)(directory);
     }
 }
 exports.default = Init;

package/lib/commands/list.js

@@ -14,7 +14,7 @@ class List extends zen_command_1.default {
         var _a;
         const { args } = this.parse(List);
         await this.ensureStepZenAccount();
-        const response = await actions_1.list(args.type);
+        const response = await (0, actions_1.list)(args.type);
         if (response.success) {
             if (((_a = response.results) === null || _a === void 0 ? void 0 : _a.length) === 0) {
                 // Success, but no results

package/lib/commands/login.js

@@ -15,7 +15,7 @@ class Login extends zen_command_1.default {
         const { flags } = this.parse(Login);
         let configuration;
         if (flags.public) {
-            const { uuid } = await configuration_1.readConfiguration();
+            const { uuid } = await (0, configuration_1.readConfiguration)();
             configuration = await stepzen_sdk_1.default.createAnonymousAccount(uuid);
         }
         else {
@@ -23,7 +23,7 @@ class Login extends zen_command_1.default {
             let adminkey;
             // If the --config flag is provided, try and log in using the details in the file
             if (flags.config) {
-                const config = await configuration_1.importConfiguration(flags.config);
+                const config = await (0, configuration_1.importConfiguration)(flags.config);
                 account = config.account;
                 adminkey = config.adminkey;
             }
@@ -49,7 +49,7 @@ class Login extends zen_command_1.default {
             configuration = await stepzen_sdk_1.default.login(adminkey, account);
         }
         // Change the default account.
-        configuration_1.writeCredentialsToConfigFile(configuration);
+        (0, configuration_1.writeCredentialsToConfigFile)(configuration);
         this.log(`You have successfully logged in as ${chalk.bold(configuration.account)}.`);
     }
 }

package/lib/commands/logout.js

@@ -9,7 +9,7 @@ const zen_command_1 = require("../shared/zen-command");
 class Logout extends zen_command_1.default {
     async run() {
         // Remove the configuration from the login file.
-        configuration_1.removeCredentialsFromConfigFile();
+        (0, configuration_1.removeCredentialsFromConfigFile)();
         this.log('You have been logged out.');
     }
 }