stepzen 0.13.0-beta.2 → 0.14.0-beta.0

package/lib/shared/configuration.d.ts

@@ -1,5 +1,24 @@
-import { MachineConfiguration } from './types';
-export declare const readConfiguration: () => MachineConfiguration | null;
-export declare const importConfiguration: (filepath: string) => MachineConfiguration;
-export declare const removeConfigurationFromLoginFile: () => boolean;
-export declare const writeConfigurationToLoginFile: (configuration: MachineConfiguration) => MachineConfiguration;
+import { LoggedInMachineConfiguration, LoggedOutMachineConfiguration, MachineConfiguration, StepZenCredentials } from './types';
+/**
+ * Ensure that the `stepzen-config.yaml` file exists and has valid content.
+ * Cover 3 cases:
+ *  - file does not exist (this is the first time the CLI is run)
+ *      -> initialize the config file and add a UUID into it
+ *  - file exists but does not include a UUID (it was created by an earlier
+ *    version of the CLI)
+ *       -> add a UUID into the existing config file
+ *  - file exists, has stepzen credentials, but does not include an API key
+ *    (it was created by an earlier version of the CLI)
+ *       -> either fetch the API key from StepZen or remove logged in credentials
+ *
+ * @param {*} maybeConfiguration raw contents of the configuration file
+ */
+export declare const ensureValidConfiguration: (maybeConfiguration: Record<string, any> | null) => Promise<{
+    configuration: MachineConfiguration;
+    modified: boolean;
+}>;
+export declare const importConfiguration: (filepath: string) => Promise<Record<string, any>>;
+export declare const readConfiguration: () => Promise<MachineConfiguration>;
+export declare const writeConfiguration: (configuration: MachineConfiguration) => Promise<MachineConfiguration>;
+export declare const writeCredentialsToConfigFile: (credentials: StepZenCredentials) => Promise<LoggedInMachineConfiguration>;
+export declare const removeCredentialsFromConfigFile: () => Promise<LoggedOutMachineConfiguration>;

package/lib/shared/configuration.js

@@ -1,61 +1,106 @@
 "use strict";
 // Copyright (c) 2020,2021,2022, StepZen, Inc.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeConfigurationToLoginFile = exports.removeConfigurationFromLoginFile = exports.importConfiguration = exports.readConfiguration = void 0;
+exports.removeCredentialsFromConfigFile = exports.writeCredentialsToConfigFile = exports.writeConfiguration = exports.readConfiguration = exports.importConfiguration = exports.ensureValidConfiguration = void 0;
 // This file contains methods for managing configuration
 const errors_1 = require("@oclif/errors");
 const debug = require("debug");
 const fs = require("fs");
+const crypto = require("crypto");
 const path = require("path");
 const yaml = require("yaml");
+const stepzen_sdk_1 = require("./stepzen-sdk");
 const constants_1 = require("./constants");
-exports.readConfiguration = () => {
-    try {
-        let configuration;
-        // If the configuration comes from an env var, use it
-        if (process.env.STEPZEN_CONFIG_CONTENT) {
-            configuration = process.env.STEPZEN_CONFIG_CONTENT;
+const configFilePath = path.join(constants_1.STEPZEN_CONFIG_DIRECTORY, constants_1.STEPZEN_CONFIG_FILE);
+/**
+ * Ensure that the `stepzen-config.yaml` file exists and has valid content.
+ * Cover 3 cases:
+ *  - file does not exist (this is the first time the CLI is run)
+ *      -> initialize the config file and add a UUID into it
+ *  - file exists but does not include a UUID (it was created by an earlier
+ *    version of the CLI)
+ *       -> add a UUID into the existing config file
+ *  - file exists, has stepzen credentials, but does not include an API key
+ *    (it was created by an earlier version of the CLI)
+ *       -> either fetch the API key from StepZen or remove logged in credentials
+ *
+ * @param {*} maybeConfiguration raw contents of the configuration file
+ */
+exports.ensureValidConfiguration = async (maybeConfiguration) => {
+    let modified = false;
+    const configuration = Object.assign({}, maybeConfiguration);
+    // ensure configuration exists
+    if (!maybeConfiguration) {
+        modified = true;
+    }
+    // ensure configuration has a UUID
+    if (!configuration.uuid) {
+        configuration.uuid = crypto.randomUUID();
+        debug('stepzen:configuration')(`Generated a new machine UUID: ${configuration.uuid}`);
+        modified = true;
+    }
+    // ensure a logged-in configuration includes an API key
+    if (configuration.account && !configuration.apikey) {
+        try {
+            debug('stepzen:configuration')(`Fetching an API key for account ${configuration.account}`);
+            const credentials = await stepzen_sdk_1.default.login(configuration.adminkey, configuration.account);
+            configuration.apikey = credentials.apikey;
         }
-        else {
-            // Read the stored configuration, if it exists.
-            const file = path.join(constants_1.STEPZEN_CONFIG_DIRECTORY, constants_1.STEPZEN_CONFIG_FILE);
-            configuration = fs.readFileSync(file, 'utf8');
+        catch (error) {
+            if (error instanceof Error &&
+                error.message.includes('Your credentials are invalid')) {
+                debug('stepzen:configuration')(`Removing the stored account credentials because logging in failed. ${error}`);
+                delete configuration.account;
+                delete configuration.adminkey;
+                delete configuration.apikey;
+            }
+            else {
+                // ignore other errors
+            }
         }
-        // Parse the yaml into an Object.
-        const parsed = yaml.parse(configuration);
-        debug('stepzen:configuration')(parsed);
-        return parsed;
-    }
-    catch (_a) {
-        return null;
+        modified = true;
     }
+    return {
+        configuration: configuration,
+        modified,
+    };
 };
-exports.importConfiguration = (filepath) => {
+exports.importConfiguration = async (filepath) => {
     if (!fs.existsSync(filepath)) {
         throw new errors_1.CLIError('Configuration file does not exist');
     }
-    const configuration = fs.readFileSync(filepath, 'utf8');
+    const content = fs.readFileSync(filepath, 'utf8');
     try {
-        const parsed = yaml.parse(configuration);
-        debug('stepzen:configuration')(parsed);
-        return parsed;
+        return yaml.parse(content);
     }
     catch (_a) {
         throw new errors_1.CLIError('Configuration file is not valid yaml');
     }
 };
-exports.removeConfigurationFromLoginFile = () => {
-    try {
-        // Remove the configuration file
-        const file = path.join(constants_1.STEPZEN_CONFIG_DIRECTORY, constants_1.STEPZEN_CONFIG_FILE);
-        fs.unlinkSync(file);
-        return true;
+exports.readConfiguration = async () => {
+    let maybeConfiguration = null;
+    // If the configuration comes from an env var, use it
+    if (process.env.STEPZEN_CONFIG_CONTENT) {
+        try {
+            maybeConfiguration = yaml.parse(process.env.STEPZEN_CONFIG_CONTENT);
+        }
+        catch (error) {
+            debug('stepzen:configuration')(`Could not parse the STEPZEN_CONFIG_CONTENT env var as YAML: ${error}`);
+        }
     }
-    catch (_a) {
-        return false;
+    else {
+        try {
+            maybeConfiguration = await exports.importConfiguration(configFilePath);
+        }
+        catch (error) {
+            debug('stepzen:configuration')(`Could not read the config file at ${configFilePath}: ${error}`);
+        }
     }
+    const { configuration } = await exports.ensureValidConfiguration(maybeConfiguration);
+    debug('stepzen:configuration')(configuration);
+    return configuration;
 };
-exports.writeConfigurationToLoginFile = (configuration) => {
+exports.writeConfiguration = async (configuration) => {
     // Generate YAML from the configuration
     const content = yaml.stringify(configuration);
     // Check that the configuration directory exists. If not, create it.
@@ -63,7 +108,20 @@ exports.writeConfigurationToLoginFile = (configuration) => {
         fs.mkdirSync(constants_1.STEPZEN_CONFIG_DIRECTORY);
     }
     // Write the configuration file. Overwrites if it already exists.
-    const file = path.join(constants_1.STEPZEN_CONFIG_DIRECTORY, constants_1.STEPZEN_CONFIG_FILE);
-    fs.writeFileSync(file, content, { mode: '600' });
+    fs.writeFileSync(configFilePath, content, { mode: '600' });
+    return exports.readConfiguration();
+};
+exports.writeCredentialsToConfigFile = async (credentials) => {
+    const oldConfig = await exports.readConfiguration();
+    const newConfig = Object.assign(Object.assign({}, oldConfig), credentials);
+    const writtenConfig = await exports.writeConfiguration(newConfig);
+    return Object.assign(Object.assign({}, newConfig), writtenConfig);
+};
+exports.removeCredentialsFromConfigFile = async () => {
+    const configuration = await exports.readConfiguration();
+    delete configuration.account;
+    delete configuration.apikey;
+    delete configuration.adminkey;
+    await exports.writeConfiguration(configuration);
     return configuration;
 };

package/lib/shared/constants.d.ts

@@ -5,11 +5,11 @@ export declare const STEPZEN_DOMAIN: string;
 export declare const STEPZEN_SERVER_URL: string;
 export declare const STEPZEN_GENERATOR_ENGINES_SCHEMA: string;
 export declare const STEPZEN_GENERATOR_ENGINES_ENDPOINT = "stepzen-generator/engines";
-export declare const STEPZEN_DIRECT_GENERATOR_ENGINES_URL: string | undefined;
+export declare const STEPZEN_DIRECT_GENERATOR_ENGINES_URL: string;
 export declare const STEPZEN_API_TEMPLATES_REPOSITORY = "https://github.com/steprz/stepzen-schemas";
 export declare const ADMIN_DEPLOY_URL = "/cli/admin/deploy";
 export declare const ADMIN_LIST_URL = "/cli/admin/list";
 export declare const ADMIN_UPLOAD_URL = "/cli/admin/upload";
-export declare const ADMIN_VERIFY_URL = "/cli/admin/verify";
+export declare const ADMIN_ACCOUNT_URL = "/cli/admin/account";
 export declare const STEPZEN_JSON2SDL_SERVER_URL: string;
 export declare const STEPZEN_DISCORD_URL = "https://discord.gg/9k2VdPn2FR";

package/lib/shared/constants.js

@@ -1,7 +1,7 @@
 "use strict";
 // Copyright (c) 2020,2021,2022, StepZen, Inc.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.STEPZEN_DISCORD_URL = exports.STEPZEN_JSON2SDL_SERVER_URL = exports.ADMIN_VERIFY_URL = exports.ADMIN_UPLOAD_URL = exports.ADMIN_LIST_URL = exports.ADMIN_DEPLOY_URL = exports.STEPZEN_API_TEMPLATES_REPOSITORY = exports.STEPZEN_DIRECT_GENERATOR_ENGINES_URL = exports.STEPZEN_GENERATOR_ENGINES_ENDPOINT = exports.STEPZEN_GENERATOR_ENGINES_SCHEMA = exports.STEPZEN_SERVER_URL = exports.STEPZEN_DOMAIN = exports.STEPZEN_CONFIG_FILE = exports.STEPZEN_LAST_UPDATE_CHECK_TIMESTAMP = exports.STEPZEN_CONFIG_DIRECTORY = void 0;
+exports.STEPZEN_DISCORD_URL = exports.STEPZEN_JSON2SDL_SERVER_URL = exports.ADMIN_ACCOUNT_URL = exports.ADMIN_UPLOAD_URL = exports.ADMIN_LIST_URL = exports.ADMIN_DEPLOY_URL = exports.STEPZEN_API_TEMPLATES_REPOSITORY = exports.STEPZEN_DIRECT_GENERATOR_ENGINES_URL = exports.STEPZEN_GENERATOR_ENGINES_ENDPOINT = exports.STEPZEN_GENERATOR_ENGINES_SCHEMA = exports.STEPZEN_SERVER_URL = exports.STEPZEN_DOMAIN = exports.STEPZEN_CONFIG_FILE = exports.STEPZEN_LAST_UPDATE_CHECK_TIMESTAMP = exports.STEPZEN_CONFIG_DIRECTORY = void 0;
 // This file contains constants and all magic strings
 const dotenv = require("dotenv");
 const os = require("os");
@@ -24,14 +24,15 @@ exports.STEPZEN_GENERATOR_ENGINES_SCHEMA = ENV_VAR_STEPZEN_GENERATOR_ENGINES_SCH
 // Generator Engines schema: target API endpoint
 exports.STEPZEN_GENERATOR_ENGINES_ENDPOINT = 'stepzen-generator/engines';
 // If defined, call the generator engines cloud function directly, skipping zenctl
-exports.STEPZEN_DIRECT_GENERATOR_ENGINES_URL = ENV_VAR_STEPZEN_DIRECT_GENERATOR_ENGINES_URL;
+exports.STEPZEN_DIRECT_GENERATOR_ENGINES_URL = ENV_VAR_STEPZEN_DIRECT_GENERATOR_ENGINES_URL ||
+    'https://us-central1-stepzen-functions.cloudfunctions.net/generator-engine';
 // API Templates repository
 exports.STEPZEN_API_TEMPLATES_REPOSITORY = 'https://github.com/steprz/stepzen-schemas';
 // Paths to the endpoints used (only for tests)
 exports.ADMIN_DEPLOY_URL = '/cli/admin/deploy';
 exports.ADMIN_LIST_URL = '/cli/admin/list';
 exports.ADMIN_UPLOAD_URL = '/cli/admin/upload';
-exports.ADMIN_VERIFY_URL = '/cli/admin/verify';
+exports.ADMIN_ACCOUNT_URL = '/cli/admin/account';
 exports.STEPZEN_JSON2SDL_SERVER_URL = ENV_VAR_STEPZEN_JSON2SDL_SERVER_URL ||
     'https://jsonintrospection-ng-prod-xynkgeaaaa-uc.a.run.app';
 exports.STEPZEN_DISCORD_URL = 'https://discord.gg/9k2VdPn2FR';

package/lib/shared/curl-parser.js

@@ -87,6 +87,17 @@ const parseMethodFlag = (value, partialCurlArgs) => {
         result: Object.assign(Object.assign({}, partialCurlArgs), { method }),
     };
 };
+const parseURLFlag = (value, partialCurlArgs) => {
+    if (partialCurlArgs.url) {
+        return {
+            error: `Multiple URLs are not currently supported by StepZen CLI (${value}).` +
+                ` If this is a blocker for you, please let us know on Discord (${constants_1.STEPZEN_DISCORD_URL})`,
+        };
+    }
+    return {
+        result: Object.assign(Object.assign({}, partialCurlArgs), { url: value }),
+    };
+};
 const flags = [
     {
         matches: ['-H', '--header'],
@@ -100,6 +111,10 @@ const flags = [
         matches: ['-X', '--request'],
         parse: parseMethodFlag,
     },
+    {
+        matches: ['--url'],
+        parse: parseURLFlag,
+    },
 ];
 const tryMatchCurlFlag = (matches, argv, i) => {
     for (const match of matches) {
@@ -155,7 +170,7 @@ exports.parseCurlArgv = (argv) => {
                     continue;
                 }
                 if ('error' in matcherResult) {
-                    // flag matched but it requies a value which is missing
+                    // flag matched but it requires a value which is missing
                     return matcherResult;
                 }
                 const parserResult = flag.parse(matcherResult.value, result, matcherResult.match);
@@ -174,14 +189,13 @@ exports.parseCurlArgv = (argv) => {
                 };
             }
         }
-        else if (result.url) {
-            return {
-                error: `Multiple URLs are not currently supported by StepZen CLI (${argv[i]}).` +
-                    ` If this is a blocker for you, please let us know on Discord (${constants_1.STEPZEN_DISCORD_URL})`,
-            };
-        }
         else {
-            result.url = argv[i];
+            // The only curl argument that's not a flag is the URL
+            const resultOrError = parseURLFlag(argv[i], result, '');
+            if ('error' in resultOrError) {
+                return resultOrError;
+            }
+            result = resultOrError.result;
         }
     }
     if (!result.url) {

package/lib/shared/path-params-parser.js

@@ -4,6 +4,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parsePathParamsPattern = exports.formatPatternDiffWithPath = void 0;
 const chalk = require("chalk");
 const pathParamRegex = /^\$[_A-Za-z]\w*$/;
+// in a literal segment, $ should be escaped as $$
+const pathSegmentRegex = /^([^$]|\$\$)+$/;
 exports.formatPatternDiffWithPath = (patternSegments, pathSegments) => {
     let hasErrors = false;
     const diff = [];
@@ -13,12 +15,9 @@ exports.formatPatternDiffWithPath = (patternSegments, pathSegments) => {
             diff.push(chalk.red(`< ${patternSegment} >`));
             hasErrors = true;
         }
-        else if (patternSegment.charAt(0) === '$') {
-            diff.push(patternSegment);
-        }
-        else {
+        else if (pathSegmentRegex.test(patternSegment)) {
             const pathSegment = pathSegments[i];
-            if (pathSegment === patternSegment) {
+            if (pathSegment === patternSegment.replace('$$', '$')) {
                 diff.push(pathSegment);
             }
             else {
@@ -26,6 +25,13 @@ exports.formatPatternDiffWithPath = (patternSegments, pathSegments) => {
                 hasErrors = true;
             }
         }
+        else {
+            // If the path segment contains some unescaped (single) $ chars,
+            // interpret it as a pattern for now. An error will be reported
+            // later (in parsePathParamsPattern) if it doesn't match
+            // pathParamRegex (starts with $)
+            diff.push(patternSegment);
+        }
     }
     for (let i = patternSegments.length; i < pathSegments.length; i++) {
         diff.push(chalk.magenta(`< ${pathSegments[i]} >`));
@@ -52,22 +58,24 @@ exports.parsePathParamsPattern = (url, pathParamsPattern) => {
             error: `Path parameters do not align with the URL path: /${maybeDiff}`,
         };
     }
-    const invalidParameterSegments = patternSegments.filter(segment => segment.charAt(0) === '$' && !pathParamRegex.test(segment));
+    const invalidParameterSegments = patternSegments.filter(segment => !pathSegmentRegex.test(segment) && !pathParamRegex.test(segment));
     if (invalidParameterSegments.length > 0) {
         return {
             error: `The path parameter name '${invalidParameterSegments[0]}' is not` +
                 ` allowed. Path parameter names should be valid GraphQL identifiers` +
-                ` prefixed with $ (dollar sign).`,
+                ` prefixed with $ (dollar sign). $ in literal path segments must be` +
+                ` escaped as $$.`,
         };
     }
-    return patternSegments
+    const retval = patternSegments
         .map((segment, index) => ({
         index,
         name: segment,
     }))
-        .filter(({ name }) => name.charAt(0) === '$')
+        .filter(({ name }) => pathParamRegex.test(name))
         .map(({ index, name }) => ({
         index,
         name: name.slice(1),
     }));
+    return retval;
 };

package/lib/shared/stepzen-sdk.d.ts

@@ -1,14 +1,14 @@
+import { StepZenCredentials } from './types';
 declare const stepzen: {
-    login: (adminkey: string, account?: string) => Promise<{
-        account: string;
-        adminkey: string;
-    }>;
-    createAnonymousAccount: () => {
-        account: string;
-        adminkey: string;
-    };
+    login: (adminkey: string, account?: string) => Promise<StepZenCredentials>;
+    createAnonymousAccount: (uuid: string) => Promise<StepZenCredentials>;
     verify: (account: string, adminkey: string) => Promise<boolean>;
-    client: (options: Pick<import("@stepzen/sdk").StepZenAccount, "account" | "adminkey"> & Partial<import("@stepzen/sdk").StepZenAccount>) => Promise<{
+    client: (options: import("@stepzen/sdk/lib/client").AnonymousClientOptions | import("@stepzen/sdk/lib/client").UserCredentialsClientOptions) => Promise<{
+        readonly credentials: {
+            account: string;
+            adminkey: string;
+            apikey: string;
+        };
         account: () => Promise<{
             account: string;
             apikey: string;
@@ -19,14 +19,14 @@ declare const stepzen: {
         deploy: (destination: string, properties: {
             configurationsets?: string[] | undefined;
             schema: string;
-        }) => Promise<import("@stepzen/sdk").ZenCtlResponse>;
+        }) => Promise<import("@stepzen/sdk/lib/client").ZenCtlResponse>;
         list: {
-            configurationsets: () => Promise<import("@stepzen/sdk").ZenCtlResponse>;
-            schemas: () => Promise<import("@stepzen/sdk").ZenCtlResponse>;
+            configurationsets: () => Promise<import("@stepzen/sdk/lib/client").ZenCtlResponse>;
+            schemas: () => Promise<import("@stepzen/sdk/lib/client").ZenCtlResponse>;
         };
         upload: {
-            configurationset: (destination: string, file: string) => Promise<import("@stepzen/sdk").ZenCtlResponse>;
-            schema: (destination: string, directory: string) => Promise<import("@stepzen/sdk").ZenCtlResponse>;
+            configurationset: (destination: string, file: string) => Promise<import("@stepzen/sdk/lib/client").ZenCtlResponse>;
+            schema: (destination: string, directory: string) => Promise<import("@stepzen/sdk/lib/client").ZenCtlResponse>;
         };
     }>;
 };

package/lib/shared/stepzen-sdk.js

@@ -3,26 +3,34 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const errors_1 = require("@oclif/errors");
 const sdk_1 = require("@stepzen/sdk");
+const constants_1 = require("./constants");
 const { version } = require('../../package.json');
 const stepzen = Object.assign(Object.assign({}, sdk_1.init({ appName: `stepzen-cli/${version}` })), { login: async (adminkey, account = adminkey.split(':')[0]) => {
-        // Check whether the account and admin key exist and are correct by calling
-        // the stepzen admin api.
-        const isValidConfiguration = await stepzen.verify(account, adminkey);
-        if (!isValidConfiguration) {
+        try {
+            const client = await stepzen.client({
+                account,
+                adminkey,
+                domain: constants_1.STEPZEN_DOMAIN,
+                server: constants_1.STEPZEN_SERVER_URL,
+            });
+            return client.credentials;
+        }
+        catch (error) {
             // Exit, with error
-            throw new errors_1.CLIError('We are unable to verify your account details. Could you please check them?');
+            throw new errors_1.CLIError('We are unable to verify your account details. Could you please check them?' +
+                ` (${error})`);
+        }
+    }, createAnonymousAccount: async (uuid) => {
+        try {
+            const client = await stepzen.client({
+                publicAccountToken: uuid,
+                domain: constants_1.STEPZEN_DOMAIN,
+                server: constants_1.STEPZEN_SERVER_URL,
+            });
+            return client.credentials;
+        }
+        catch (error) {
+            throw new errors_1.CLIError(`Could not create a public account (${error})`);
         }
-        return {
-            account,
-            adminkey,
-        };
-    }, createAnonymousAccount: () => {
-        const anonAdminKey = process.env.STEPZEN_ANONYMOUS_ADMINKEY ||
-            // LATER: call the actual API (pending https://github.com/steprz/zen/issues/5545)
-            'test::steprz.io+666::test';
-        return {
-            account: anonAdminKey.split(':')[0],
-            adminkey: anonAdminKey,
-        };
     } });
 exports.default = stepzen;

package/lib/shared/types.d.ts

@@ -1,8 +1,20 @@
-export interface MachineConfiguration {
+export interface StepZenCredentials {
     account: string;
     adminkey: string;
-    apikey?: string;
+    apikey: string;
 }
+export interface LoggedOutMachineConfiguration {
+    uuid: string;
+}
+export declare type LoggedInMachineConfiguration = LoggedOutMachineConfiguration & StepZenCredentials;
+/**
+ * In-memory representation of the `~/.stepzen/stepzen-config.yaml`
+ * configuration file.
+ *
+ * If the user is not logged in, it has only a UUID of the CLI installation.
+ * If the user is logged in, it has also has the StepZen account credentials.
+ */
+export declare type MachineConfiguration = LoggedInMachineConfiguration | LoggedOutMachineConfiguration;
 /**
  * On-disk representation of a workspace config file, `stepzen.config.json`
  */

package/lib/shared/utils.d.ts

@@ -1,6 +1,4 @@
-export declare const checkAuth: () => Promise<void>;
 export declare const clearConsole: () => void;
-export declare const ensureApiKey: () => Promise<void>;
 export declare const getDirectory: (d?: string | undefined) => string;
 export declare const getStepZenExtensions: () => Promise<string>;
 export declare const validateEndpoint: (endpoint: string) => any;

package/lib/shared/utils.js

@@ -1,9 +1,8 @@
 "use strict";
 // Copyright (c) 2020,2021,2022, StepZen, Inc.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.maskStepZenKey = exports.validateEndpoint = exports.getStepZenExtensions = exports.getDirectory = exports.ensureApiKey = exports.clearConsole = exports.checkAuth = void 0;
+exports.maskStepZenKey = exports.validateEndpoint = exports.getStepZenExtensions = exports.getDirectory = exports.clearConsole = void 0;
 const errors_1 = require("@oclif/errors");
-const chalk = require("chalk");
 const debug = require("debug");
 const node_fetch_1 = require("node-fetch");
 const fs = require("fs");
@@ -11,60 +10,12 @@ const os = require("os");
 const path = require("path");
 const prettier = require("prettier");
 const constants_1 = require("./constants");
-const configuration_1 = require("./configuration");
-const stepzen_sdk_1 = require("./stepzen-sdk");
-exports.checkAuth = async () => {
-    var _a;
-    const configuration = configuration_1.readConfiguration();
-    // If there is no configuration, you're not logged in
-    if (!configuration) {
-        return;
-    }
-    const details = configuration;
-    // If the account is called 'test', return. It's a test.
-    if (details.account === 'test') {
-        return;
-    }
-    const isValidAccount = await stepzen_sdk_1.default.verify(details.account, details.adminkey);
-    if (!isValidAccount) {
-        if ((_a = details.account) === null || _a === void 0 ? void 0 : _a.endsWith('Playground')) {
-            console.log(chalk.yellow(`
-╔════════════════════════════════════════╗
-║  Your playground account has expired!  ║
-║       Sign up for a full account:      ║
-║            www.stepzen.com             ║
-╚════════════════════════════════════════╝
-      `));
-        }
-        else {
-            console.log('Could not complete the request. Please check your authentication details are correct.');
-        }
-        // eslint-disable-next-line no-process-exit,unicorn/no-process-exit
-        process.exit(1);
-    }
-};
 exports.clearConsole = () => {
     process.stdout.write(
     // Taken from create-react-app
     // eslint-disable-next-line unicorn/no-hex-escape
     process.platform === 'win32' ? '\x1B[2J\x1B[0f' : '\x1B[2J\x1B[3J\x1B[H');
 };
-exports.ensureApiKey = async () => {
-    const configuration = configuration_1.readConfiguration();
-    const details = configuration;
-    if (details && !details.apikey) {
-        debug('stepzen:account')(`Fetching API key for account ${details.account}`);
-        try {
-            const client = await stepzen_sdk_1.default.client(details);
-            const response = await client.account();
-            if ('apikey' in response) {
-                details.apikey = response.apikey;
-                await configuration_1.writeConfigurationToLoginFile(details);
-            }
-        }
-        catch (_a) { }
-    }
-};
 exports.getDirectory = (d = process.cwd()) => {
     let directory = d;
     // If it starts with `~`, expand this

package/lib/shared/zen-command.d.ts

@@ -1,14 +1,15 @@
-import { Command } from '@oclif/command';
-import { MachineConfiguration } from './types';
+import { Command, flags } from '@oclif/command';
+import { MachineConfiguration, StepZenCredentials } from './types';
 export declare abstract class ZenCommand extends Command {
     static flags: {
         'non-interactive': import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        'enable-login-prompt': flags.IOptionFlag<boolean | undefined>;
     };
     ensureStepZenAccount(): Promise<{
-        configuration: MachineConfiguration;
+        configuration: import("./types").LoggedInMachineConfiguration;
     }>;
-    promptUserToLogIn(): Promise<{
-        configuration: MachineConfiguration;
+    promptUserToLogIn(uuid: string): Promise<{
+        configuration: MachineConfiguration & StepZenCredentials;
     }>;
 }
 export default ZenCommand;

package/lib/shared/zen-command.js

@@ -3,21 +3,28 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZenCommand = void 0;
 const command_1 = require("@oclif/command");
+const errors_1 = require("@oclif/errors");
 const inquirer = require("inquirer");
 const chalk = require("chalk");
 const configuration_1 = require("./configuration");
 const stepzen_sdk_1 = require("./stepzen-sdk");
 class ZenCommand extends command_1.Command {
     async ensureStepZenAccount() {
-        const configuration = configuration_1.readConfiguration();
-        if (configuration && configuration.account) {
+        const configuration = await configuration_1.readConfiguration();
+        if ('account' in configuration) {
             return {
                 configuration,
             };
         }
-        return this.promptUserToLogIn();
+        const TheCommand = this.constructor;
+        const { flags } = this.parse(TheCommand);
+        if (flags['enable-login-prompt']) {
+            return this.promptUserToLogIn(configuration.uuid);
+        }
+        throw new errors_1.CLIError('Could not find StepZen account credentials.' +
+            ' Please run `stepzen login` first.');
     }
-    async promptUserToLogIn() {
+    async promptUserToLogIn(uuid) {
         this.log(chalk.bold(chalk.cyan('Welcome to StepZen CLI!')));
         this.log('');
         this.log(`Please log in with your StepZen account to make your GraphQL API private.` +
@@ -53,14 +60,14 @@ class ZenCommand extends command_1.Command {
                     suffix: chalk.blue(` (available at ${chalk.bold('https://stepzen.com/account')})`),
                 },
             ]);
-            configuration = await stepzen_sdk_1.default.login(answers.adminkey);
-            configuration_1.writeConfigurationToLoginFile(configuration);
+            const credentials = await stepzen_sdk_1.default.login(answers.adminkey);
+            configuration = await configuration_1.writeCredentialsToConfigFile(credentials);
             this.log('You have successfully logged in.');
             this.log('');
         }
         else {
-            configuration = await stepzen_sdk_1.default.createAnonymousAccount();
-            configuration_1.writeConfigurationToLoginFile(configuration);
+            const credentials = await stepzen_sdk_1.default.createAnonymousAccount(uuid);
+            configuration = await configuration_1.writeCredentialsToConfigFile(credentials);
             this.log(`We've created a temporary public account for you.\nAll endpoints` +
                 ` deployed to this account will be automatically deleted after 24` +
                 ` hours. You can log in with your regular StepZen account at any` +
@@ -76,5 +83,18 @@ ZenCommand.flags = {
         description: 'disable all interactive prompts',
         hidden: true,
     }),
+    // The flag type has to be `option` (not `boolean`) for `env` to take effect
+    'enable-login-prompt': command_1.flags.option({
+        description: 'An (internal) feature flag to enable the "prompt user to log in"' +
+            ' feature for the users who run the CLI without being logged in. It' +
+            ' is intentially hidden and not documented because in the future' +
+            ' this feature will be enabled for all users and the flag will be' +
+            ' removed.',
+        hidden: true,
+        options: ['true', 'false'],
+        parse: value => Boolean(value),
+        default: false,
+        env: 'STEPZEN_ENABLE_LOGIN_PROMPT',
+    }),
 };
 exports.default = ZenCommand;