apify-cli 0.14.1 → 0.14.2-beta.1

package/src/lib/create-utils.js

@@ -0,0 +1,175 @@
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const https = require('https');
+const { validateActorName } = require('./utils');
+
+const PROGRAMMING_LANGUAGES = ['JavaScript', 'TypeScript', 'Python'];
+
+/**
+ * @param {string} url
+ * @returns {Promise<unknown>}
+ */
+exports.httpsGet = async (url) => {
+    return new Promise((resolve, reject) => {
+        https.get(url, (response) => {
+            if (response.statusCode === 301 || response.statusCode === 302) {
+                resolve(exports.httpsGet(response.headers.location));
+            } else {
+                resolve(response);
+            }
+        }).on('error', reject);
+    });
+};
+
+/**
+ * @param {string} maybeActorName
+ * @returns {Promise<string>}
+ */
+exports.ensureValidActorName = async (maybeActorName) => {
+    if (maybeActorName) {
+        validateActorName(maybeActorName);
+        return maybeActorName;
+    }
+    return promptActorName();
+};
+
+/**
+ * @param {string} maybeTemplateName
+ * @param {Promise<object>} manifestPromise
+ * @returns {Promise<object>}
+ */
+exports.getTemplateDefinition = async (maybeTemplateName, manifestPromise) => {
+    const manifest = await manifestPromise;
+    // If the fetch failed earlier, the resolve value of
+    // the promise will be the error from fetching the manifest.
+    if (manifest instanceof Error) throw manifest;
+
+    if (maybeTemplateName) {
+        const templateDefinition = manifest.templates.find((t) => t.name === maybeTemplateName);
+        if (!templateDefinition) {
+            throw new Error(`Could not find the selected template: ${maybeTemplateName} in the list of templates.`);
+        }
+        return templateDefinition;
+    }
+
+    return executePrompts(manifest);
+};
+
+/**
+ * Inquirer does not have a native way to "go back" between prompts.
+ * @param {object} manifest
+ * @returns {Promise<object>}
+ */
+async function executePrompts(manifest) {
+    const programmingLanguage = await promptProgrammingLanguage();
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const templateDefinition = await promptTemplateDefinition(manifest, programmingLanguage);
+        if (templateDefinition) {
+            const shouldInstall = await promptTemplateInstallation(templateDefinition);
+            if (shouldInstall) {
+                return templateDefinition;
+            }
+        } else {
+            return executePrompts(manifest);
+        }
+    }
+}
+
+/**
+ * @returns {Promise<string>}
+ */
+async function promptActorName() {
+    const answer = await inquirer.prompt([{
+        name: 'actorName',
+        message: 'Name of your new actor:',
+        type: 'input',
+        validate: (promptText) => {
+            try {
+                validateActorName(promptText);
+            } catch (err) {
+                return err.message;
+            }
+            return true;
+        },
+    }]);
+    return answer.actorName;
+}
+
+/**
+ * @returns {Promise<string>}
+ */
+async function promptProgrammingLanguage() {
+    const answer = await inquirer.prompt([{
+        type: 'list',
+        name: 'programmingLanguage',
+        message: 'Choose the programming language of your new actor:',
+        default: PROGRAMMING_LANGUAGES[0],
+        choices: PROGRAMMING_LANGUAGES,
+        loop: false,
+    }]);
+    return answer.programmingLanguage;
+}
+
+/**
+ * @param {object} manifest
+ * @param {string} programmingLanguage
+ * @returns {Promise<object>} template definition
+ */
+async function promptTemplateDefinition(manifest, programmingLanguage) {
+    const choices = manifest.templates
+        .filter((t) => {
+            return t.category.toLowerCase() === programmingLanguage.toLowerCase();
+        })
+        .map((t) => {
+            return {
+                name: t.label,
+                value: t,
+            };
+        });
+
+    choices.push(new inquirer.Separator());
+    choices.push({
+        name: 'Go back',
+        value: false,
+    });
+
+    const answer = await inquirer.prompt([{
+        type: 'list',
+        name: 'templateDefinition',
+        message: 'Choose a template for your new actor. Detailed information about the template will be shown in the next step.',
+        default: choices[0],
+        choices,
+        loop: false,
+        pageSize: 8,
+    }]);
+
+    return answer.templateDefinition;
+}
+
+/**
+ * @param {object} templateDefinition
+ * @returns {Promise<string>}
+ */
+async function promptTemplateInstallation(templateDefinition) {
+    const choices = [{ name: `Install template`, value: true }];
+    choices.push(new inquirer.Separator());
+    choices.push({ name: 'Go back', value: false });
+
+    const message = 'Do you want to install the following template?';
+    const label = chalk.underline(templateDefinition.label);
+    const description = chalk.dim(templateDefinition.description);
+    const suffix = `\n ${label}:\n ${description}`;
+
+    const answer = await inquirer.prompt([{
+        type: 'list',
+        name: 'shouldInstall',
+        message,
+        suffix,
+        default: choices[0],
+        choices,
+        loop: false,
+    }]);
+
+    return answer.shouldInstall;
+}

package/src/lib/utils.js

@@ -98,14 +98,14 @@ const getLoggedClientOrThrow = async () => {
  * @param {String|null|undefined} token
  * @returns {Object}
  */
-const getApifyClientOptions = (token) => {
+const getApifyClientOptions = (token, apiBaseUrl) => {
     if (!token && fs.existsSync(GLOBAL_CONFIGS_FOLDER) && fs.existsSync(AUTH_FILE_PATH)) {
         ({ token } = loadJson.sync(AUTH_FILE_PATH));
     }
 
     return {
         token,
-        baseUrl: process.env.APIFY_CLIENT_BASE_URL,
+        baseUrl: apiBaseUrl || process.env.APIFY_CLIENT_BASE_URL,
         requestInterceptors: [(config) => {
             config.headers = { ...APIFY_CLIENT_DEFAULT_HEADERS, ...config.headers };
             return config;
@@ -119,8 +119,12 @@ const getApifyClientOptions = (token) => {
  * @param [token]
  * @return {Promise<*>}
  */
-const getLoggedClient = async (token) => {
-    const apifyClient = new ApifyClient(getApifyClientOptions(token));
+const getLoggedClient = async (token, apiBaseUrl) => {
+    if (!token && fs.existsSync(GLOBAL_CONFIGS_FOLDER) && fs.existsSync(AUTH_FILE_PATH)) {
+        ({ token } = loadJson.sync(AUTH_FILE_PATH));
+    }
+
+    const apifyClient = new ApifyClient(getApifyClientOptions(token, apiBaseUrl));
     let userInfo;
     try {
         userInfo = await apifyClient.user('me').get();

package/src/lib/version_check.js

@@ -1,5 +1,5 @@
+const axios = require('axios');
 const chalk = require('chalk');
-const { spawn } = require('cross-spawn');
 const semver = require('semver');
 const {
     CHECK_VERSION_EVERY_MILLIS,
@@ -13,16 +13,28 @@ const {
     extendLocalState,
 } = require('./local_state');
 
-const getLatestNpmVersion = () => spawn.sync('npm', ['view', 'apify-cli', 'version']).stdout.toString().trim();
+const getLatestNpmVersion = async () => {
+    const response = await axios({
+        url: 'https://registry.npmjs.org/apify-cli/',
+        headers: {
+            // This is necessary so that NPM returns the abbreviated version of the metadata
+            // See https://github.com/npm/registry/blob/master/docs/responses/package-metadata.md
+            accept: 'application/vnd.npm.install-v1+json',
+        },
+    });
+    const packageMetadata = response.data;
+    const latestVersion = packageMetadata['dist-tags'].latest;
+    return latestVersion;
+};
 
 /**
  * Fetches the latest NPM version of Apify CLI and caches it locally.
  */
-const getAndCacheLatestNpmVersion = () => {
+const getAndCacheLatestNpmVersion = async () => {
     try {
         info('Making sure that Apify CLI is up to date...');
 
-        const latestNpmVersion = getLatestNpmVersion();
+        const latestNpmVersion = await getLatestNpmVersion();
 
         extendLocalState({
             latestNpmVersion,
@@ -54,7 +66,7 @@ const checkLatestVersion = async (enforeUpdate = false) => {
     // If check is outdated and we are online then update the current NPM version.
     const shouldGetCurrentVersion = enforeUpdate || (isCheckOutdated && await isOnline.default({ timeout: 500 }));
     const latestNpmVersion = shouldGetCurrentVersion
-        ? getAndCacheLatestNpmVersion()
+        ? await getAndCacheLatestNpmVersion()
         : cachedLatestNpmVersion;
 
     const currentNpmVersion = require('../../package.json').version; //  eslint-disable-line