stepzen 0.19.0-beta.0 → 0.19.0-beta.1

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.19.0-beta.0 darwin-x64 node-v14.19.3
+stepzen/0.19.0-beta.1 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,8 +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: {
@@ -21,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>;
@@ -46,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[];
     } | {
@@ -61,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>;
@@ -80,10 +85,10 @@ export default class Import extends ZenCommand {
     }[];
     static strict: boolean;
     run(): Promise<void>;
-    importCurl(argv: string[], flags: any, fixedOptions: CommonImportOptions): Promise<string>;
-    importGraphQL(argv: string[], flags: any, fixedOptions: CommonImportOptions): Promise<string>;
-    importSql(schema: string, argv: string[], flags: any, fixedOptions: CommonImportOptions): Promise<string>;
-    importFromGeneratorEngines(schema: string, argv: string[], flags: any, fixedOptions: CommonImportOptions): Promise<string>;
+    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;
@@ -95,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;
@@ -111,7 +117,14 @@ export default class Import extends ZenCommand {
         [name: string]: any;
     }>;
     parseHeaderFlags(headerFlagValues?: string[], headerParamFlagValues?: string[]): HeaderInput[];
-    getSqlOptionsFromFlags(flags: any): {
-        [x: string]: any;
+    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");
@@ -17,6 +18,7 @@ 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");
@@ -25,51 +27,78 @@ 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);
         // Common options for all import schemas
-        const fixedOptions = {
+        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') {
-            result = await this.importCurl(argv, flags, fixedOptions);
-        }
-        else if (schema === 'graphql') {
-            result = await this.importGraphQL(argv, flags, fixedOptions);
-        }
-        else if (process.env.STEPZEN_BYPASS_GENERATOR_ENGINES) {
-            result = await this.importSql(schema, argv, flags, fixedOptions);
-        }
-        else {
-            // Delegate the schema to generator-engines function
-            result = await this.importFromGeneratorEngines(schema, argv, flags, fixedOptions);
+        //  - 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);
+                }
+                else {
+                    throw new errors_1.CLIError(`Cannot find the schema ${schema}`);
+                }
         }
+        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, fixedOptions) {
+    async importCurl(argv, flags, commonOptions) {
         const headers = this.parseHeaderFlags(flags.header, flags['header-param']);
-        // 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 editableOptions = {
+        const curlFlagValues = {
             queryName: flags['query-name'],
             rootType: flags['query-type'],
             typePrefix: flags.prefix,
@@ -83,29 +112,29 @@ class Import extends zen_command_1.default {
                 '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), { 
+            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(curlAnswers.curlArgs.headers) });
+                headers: headers.concat(interactiveOptions.curlArgs.headers) });
         }
         else {
-            // run non-interative
-            const argsOrError = curl_parser_1.parseCurlArgv(argv);
+            // run non-interactively
+            const argsOrError = (0, 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']);
+            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 = curl2sdl_1.makeDuplicateParamsMessage(headers, parsedPathParamsOrError, argsOrError.url);
+            const maybeDuplicateParamsMessage = (0, curl2sdl_1.makeDuplicateParamsMessage)(headers, parsedPathParamsOrError, argsOrError.url);
             if (maybeDuplicateParamsMessage) {
                 throw new errors_1.CLIError(maybeDuplicateParamsMessage);
             }
-            curl2sdlOptions = Object.assign(Object.assign(Object.assign({}, fixedOptions), editableOptions), { pathParams: parsedPathParamsOrError, headers: headers, curlArgs: argsOrError });
+            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 curl2sdl_1.curl2sdl(curl2sdlOptions);
+        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. ' +
@@ -115,24 +144,25 @@ class Import extends zen_command_1.default {
         }
         return resultOrError.outPath;
     }
-    async importGraphQL(argv, flags, fixedOptions) {
+    async importGraphQL(argv, flags, commonOptions) {
         const headers = this.parseHeaderFlags(flags.header, flags['header-param']);
-        const editableOptions = {
+        let graphql2sdlOptions;
+        const graphqlFlagValues = {
             typePrefix: flags.prefix,
-            headers: headers,
         };
-        let answers;
         if (argv.length === 1) {
-            // interactive
-            answers = await graphql2sdl_1.askGraphQLQuestions(editableOptions);
+            // 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 {
-            // non-interactive
-            answers = Object.assign(Object.assign({}, editableOptions), { endpoint: argv[1] });
+            // run non-interactively
+            graphql2sdlOptions = Object.assign(Object.assign(Object.assign({}, commonOptions), graphqlFlagValues), { endpoint: argv[1], headers: headers });
         }
-        const options = Object.assign(Object.assign({}, fixedOptions), answers);
         core_1.CliUx.ux.action.start('Starting');
-        const resultOrError = await graphql2sdl_1.graphql2sdl(options);
+        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.');
@@ -141,27 +171,23 @@ class Import extends zen_command_1.default {
         }
         return resultOrError.outPath;
     }
-    async importSql(schema, argv, flags, fixedOptions) {
-        if (!(schema === 'mysql' || schema === 'postgresql')) {
-            throw new errors_1.CLIError(`Schema "${schema}" not supported when the STEPZEN_BYPASS_GENERATOR_ENGINES feature flag is enabled; ` +
-                `if this is a legacy import schema, please run the command without the feature flag`);
-        }
-        const editableOptions = this.getSqlOptionsFromFlags(flags);
-        let answers;
-        if (editableOptions.host !== undefined &&
-            editableOptions.database !== undefined &&
-            editableOptions.user !== undefined &&
-            editableOptions.password !== undefined) {
-            // non-interactive
-            answers = editableOptions;
+    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 {
-            // interactive
-            answers = await sql2sdl_1.askSqlQuestions(schema, editableOptions);
+            // 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 });
         }
-        const options = Object.assign(Object.assign({}, fixedOptions), answers);
         core_1.CliUx.ux.action.start('Starting');
-        const resultOrError = await sql2sdl_1.sql2sdl(schema, options);
+        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. ' +
@@ -171,26 +197,26 @@ class Import extends zen_command_1.default {
         }
         return resultOrError.outPath;
     }
-    async importFromGeneratorEngines(schema, argv, flags, fixedOptions) {
-        const preAnswered = {};
+    async importFromGeneratorEngines(schema, flags, fixedOptions) {
+        let preAnswered = {};
         if (schema === 'mysql' || schema === 'postgresql') {
-            const sqlPreAnswered = this.getSqlOptionsFromFlags(flags);
-            if (Object.prototype.hasOwnProperty.call(sqlPreAnswered, 'linkTypes')) {
-                sqlPreAnswered.linkTypes = sqlPreAnswered.linkTypes ? 'Yes' : 'No';
+            preAnswered = this.getSqlOptionsFromFlags(flags);
+            if (Object.prototype.hasOwnProperty.call(preAnswered, 'linkTypes')) {
+                preAnswered.linkTypes = preAnswered.linkTypes ? 'Yes' : 'No';
             }
         }
         // Let's go!
-        const result = await generate_1.default(Object.assign(Object.assign({}, fixedOptions), { schema,
+        const result = await (0, generate_1.default)(Object.assign(Object.assign({}, fixedOptions), { schema,
             preAnswered }));
         // Validate
-        await transpiler_1.validate(result, {
-            extensions: await utils_1.getStepZenExtensions(),
+        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;
@@ -292,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);
                 }
@@ -304,19 +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 asKeyValue = (key, flag) => flag === undefined ? {} : { [key]: flag };
-        return 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'])), asKeyValue('schema', flags['db-schema']));
+        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.',
@@ -376,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.');
     }
 }

package/lib/commands/start.js

@@ -27,25 +27,27 @@ class Start extends zen_command_1.default {
         if (flags.endpoint) {
             workspace.endpoint = flags.endpoint;
         }
-        // Check the port is available
-        const port = await detect(flags.port);
-        if (flags.port !== port) {
-            throw new errors_1.CLIError(`Could not start - port ${flags.port} is already in use`);
+        if (!flags['no-dashboard']) {
+            // Check the port is available
+            const port = await detect(flags.port);
+            if (flags.port !== port) {
+                throw new errors_1.CLIError(`Could not start - port ${flags.port} is already in use`);
+            }
         }
-        const printEndpointDetailsOnce = lodash_1.once(() => {
-            start_1.success({
+        const printEndpointDetailsOnce = (0, lodash_1.once)(() => {
+            (0, start_1.success)({
                 workspace,
                 account: configuration.account,
-                port: flags.port,
+                port: flags['no-dashboard'] ? undefined : flags.port,
             });
             this.log();
         });
         // This is the file watcher
         if (!flags['no-watcher']) {
-            const redeploy = throttle_debounce_1.debounce(500, (path) => {
+            const redeploy = (0, throttle_debounce_1.debounce)(500, (path) => {
                 debug('stepzen:start')(`chokidar decected change to ${path}`);
-                start_1.changed({ workspace, file: path });
-                start_1.deploy({ workspace, flags }).then(didDeploy => {
+                (0, start_1.changed)({ workspace, file: path });
+                (0, start_1.deploy)({ workspace, flags }).then(didDeploy => {
                     didDeploy && printEndpointDetailsOnce();
                 });
             });
@@ -65,7 +67,7 @@ class Start extends zen_command_1.default {
         let didDeploy = false;
         // Unless explicitly disabled, auto-init
         if (!flags['no-init']) {
-            didDeploy = await start_1.deploy({ workspace, flags });
+            didDeploy = await (0, start_1.deploy)({ workspace, flags });
         }
         // Create the dashboard
         if (!flags['no-dashboard']) {
@@ -96,7 +98,7 @@ class Start extends zen_command_1.default {
                 printEndpointDetailsOnce();
             }
             if (!flags['no-watcher']) {
-                start_1.watching(workspace);
+                (0, start_1.watching)(workspace);
             }
         }
     }

package/lib/commands/transpile.js

@@ -12,10 +12,10 @@ const zen_command_1 = require("../shared/zen-command");
 class Transpile extends zen_command_1.default {
     async run() {
         const { args, flags } = this.parse(Transpile);
-        const folder = utils_1.getDirectory(args.folder);
+        const folder = (0, utils_1.getDirectory)(args.folder);
         // CONFIG
         if (flags['output-configuration']) {
-            const config = await transpiler_1.configure(folder, flags.silent);
+            const config = await (0, transpiler_1.configure)(folder, flags.silent);
             if (flags['hide-output']) {
                 return config;
             }
@@ -24,9 +24,9 @@ class Transpile extends zen_command_1.default {
         }
         // SCHEMA
         try {
-            const schema = transpiler_1.stitch(folder);
-            transpiler_1.validate(schema, {
-                extensions: await utils_1.getStepZenExtensions(),
+            const schema = (0, transpiler_1.stitch)(folder);
+            (0, transpiler_1.validate)(schema, {
+                extensions: await (0, utils_1.getStepZenExtensions)(),
             });
             const file = path.join(schema, 'index.graphql');
             const stitched = fs.readFileSync(file, 'utf8');