@serverless-devs/s 0.0.45 → 0.1.4-18cdd23b

package/src/set/output-color/index.ts

@@ -1,49 +0,0 @@
-import * as program from 'commander';
-import { handlerProfileFile } from '../../utils/handler-set-config';
-import logger from '../../utils/logger';
-import i18n from '../../utils/i18n';
-import {CommandError} from '../../error/command-error';
-
-
-program
-  .name('s set output-color')
-  .usage('[options] [name]')
-  .helpOption('-h, --help', i18n.__('Display help for command'))
-  .description(`i18n.__('Here you can set whether the output has color.')
-  
-   ${i18n.__('Example')}:
-        # ${i18n.__('If your want output colorful')}:
-            $ s set output-color enable
-        # ${i18n.__('If your want output with default color')}:
-            $ s set output-color disable
-  `)
-  .parse(process.argv);
-
-
-(async () => {
-  let openColorStr = '';
-  if (program.args.length > 0) {
-    openColorStr = program.args[0];
-  } else {
-    return program.help();
-  }
-  let openColorFlag: boolean;
-  if (openColorStr === 'enable') {
-    logger.colorSwitch(true);
-    openColorFlag = true;
-    logger.success('Color output enable');
-  } else if (openColorStr === 'disable') {
-    logger.colorSwitch(false);
-    openColorFlag = false;
-    logger.success('Color output disable');
-  } else {
-    return program.help();
-  }
-
-  await handlerProfileFile({
-    data: openColorFlag,
-    configKey: 'output-color'
-  });
-})().catch((err) => {
-  throw new CommandError(err.message);
-});

package/src/utils/analysis.ts

@@ -1,36 +0,0 @@
-export class Analysis {
-  protected componentOrderKeyMap: { [key: string]: any } = {};
-  constructor(protected readonly parsedObj: any, protected readonly dependenciesMap: any) {
-  }
-  private getComponentOrderKeyMap(projKeys: string[]) {
-    projKeys.forEach((key: string) => {
-      this.componentOrderKeyMap[key] = 1;
-    });
-  }
-
-  private calculateOrderNumber(componentKeys: string[]) {
-    componentKeys.forEach((key: string) => {
-      const dependenciesInstance = this.dependenciesMap[key];
-      Object.keys(dependenciesInstance).forEach(_key => {
-        if (this.componentOrderKeyMap[_key]) {
-          this.componentOrderKeyMap[_key] += dependenciesInstance[_key];
-        }
-      });
-    });
-  }
-  getProjectOrder() {
-
-    const componentKeys = Object.keys(this.dependenciesMap).filter(key => key !== 'Global');
-    this.getComponentOrderKeyMap(componentKeys); //
-    this.calculateOrderNumber(componentKeys);
-    const projectArray = Object.keys(this.componentOrderKeyMap).map((key) => {
-      return { name: key, order: this.componentOrderKeyMap[key] };
-    });
-    return projectArray.sort((item1, item2) => {
-      return item2.order - item1.order;
-    }).map((item) => item.name);
-
-  }
-}
-
-

package/src/utils/check-version.ts

@@ -1,139 +0,0 @@
-import axios from 'axios';
-import logger from './logger';
-import { handlerProfileFile, getConfig } from './handler-set-config';
-import { getHistoryFile } from './storage';
-import {printn} from './common';
-import * as fs from 'fs-extra';
-import { SERVERLESS_CHECK_VERSION } from '../constants/static-variable';
-import { GetManager } from '../config/get/get-manager';
-import { providerArray } from '../config/common/common';
-const pkg = require('../../package.json');
-
-interface CheckVersionResult {
-  [key: string]: any
-}
-
-export class CheckVersion {
-  checkVersionResult: CheckVersionResult;
-  hasCheckedToday = false;
-
-  async init() {
-    await this.checkTime();
-    await this.getVersion();
-  }
-
-  async showMessage() {
-    const isSelectVersion: boolean = process.argv.includes('-v') || process.argv.includes('--version');
-    const { status, statusText, data } = this.checkVersionResult;
-    const isNewVersion: boolean = data.version === pkg.version;
-    const isRequestSucc: boolean = status === undefined || !(status === 200 && statusText === 'OK');
-    if (!isSelectVersion) {
-      // 当天还没有输出过相关信息 && 如果请求成功 || 不是最新的版本
-      if (!this.hasCheckedToday && (isRequestSucc || !isNewVersion)) {
-        const release_version = `Release: ${data.version}`;
-        const local_version = `Local  : ${pkg.version}`;
-        const release_version_line_length = 36 - release_version.length;
-        const local_version_line_length = 36 - local_version.length;
-        logger.log('\n   ╭──────────────────────────────────────────╮');
-        logger.log('   │              Serverless Tool             │');
-        logger.log('   │                                          │');
-        logger.log('   │      ' + release_version + printn(release_version_line_length, ' ') + '│');
-        logger.log('   │      ' + local_version + printn(local_version_line_length, ' ') + '│');
-        logger.log('   │                                          │');
-        logger.log('   │                                          │');
-        logger.log('   │    You can upgrade through:              │');
-        logger.log('   │      npm install @serverless-devs/s -g   │');
-        logger.log('   ╰──────────────────────────────────────────╯\n');
-      }
-    } else {
-      if (isNewVersion) {
-        logger.log(`Serverless Tool Version: ${pkg.version} `);
-        console.log('\n\n');
-      } else {
-        logger.log('Serverless Tool Version: ');
-        logger.log(`    Release: ${data.version} `);
-        logger.log(`    Local  : ${pkg.version} `);
-        logger.log('');
-        logger.log('    You can upgrade through : npm install @serverless-devs/s -g');
-        logger.log('    Update information:');
-        data.message.forEach((message: any, index: any) => {
-          logger.log(`        ${index + 1}. ${message}`);
-        });
-        console.log('\n\n');
-      }
-    }
-  }
-
-  private async getVersion() {
-
-    let SERVERLESS_CHECK_VERSION_URL;
-    try {
-      const lang = (await handlerProfileFile({ read: true, filePath: 'set-config.yml' }))['locale'] || 'en';
-      SERVERLESS_CHECK_VERSION_URL = SERVERLESS_CHECK_VERSION + '?lang=' + lang;
-    } catch (err) {
-      SERVERLESS_CHECK_VERSION_URL = SERVERLESS_CHECK_VERSION;
-    }
-    
-    
-    try {
-      let analysis = getConfig('analysis');
-      if (analysis || analysis === undefined) {
-        const historyFile = getHistoryFile();
-        const historyCmds = fs.readFileSync(historyFile, 'utf-8');
-        const getManager = new GetManager();
-        const providerMap: any = {};
-        for (let i = 0;i < providerArray.length;i++) {
-          await getManager.initAccessData({'Provider': providerArray[i]});
-          const tempData = await getManager.getUserSecretID({'Provider': providerArray[i]});
-          if (providerArray[i] === 'alibaba') {
-            providerMap[providerArray[i]] = providerMap[providerArray[i]] || [];
-            // eslint-disable-next-line guard-for-in
-            for (const item in tempData) {
-              providerMap[providerArray[i]].push(tempData[item]['AccountID']);
-            }
-          } else {
-            providerMap[providerArray[i]] = Object.keys(tempData).length;
-          }
-        }
-
-        let postData: string;
-        try {
-          postData = JSON.stringify({'Account': providerMap, 'History': historyCmds});
-        } catch (ex) {
-          postData = String({'Account': providerMap, 'History': historyCmds});
-        }
-
-        try {
-          this.checkVersionResult = await axios.post(SERVERLESS_CHECK_VERSION_URL, {state: 1, data: postData}, {
-            timeout: 2000
-          });
-          fs.removeSync(historyFile);
-        } catch (ex) {}
-      } else {
-        try {
-          this.checkVersionResult = await axios.post(SERVERLESS_CHECK_VERSION_URL, {state: 0}, {
-            timeout: 2000
-          });
-        } catch (ex) {}
-      }
-    } catch (e) {
-      this.checkVersionResult = {};
-    }
-    await handlerProfileFile({
-      data: Date.now(),
-      configKey: 'check-version-time',
-      filePath: 'cache.yml'
-    });
-  }
-
-  // 当天是否验证过
-  private async checkTime() {
-    const profile = await handlerProfileFile({ read: true, filePath: 'cache.yml' });
-    const checkVersionTime = profile['check-version-time'];
-    console.log();
-    //
-    if (checkVersionTime) {
-      this.hasCheckedToday = new Date(checkVersionTime).toDateString() === new Date().toDateString();
-    }
-  }
-}

package/src/utils/command.ts

@@ -1,123 +0,0 @@
-import {Command} from 'commander';
-import axios from 'axios';
-import logger from './logger';
-import * as storage from './storage';
-import {CheckVersion} from './check-version';
-import {Parse} from './parse';
-import * as fs from 'fs-extra';
-import * as os from 'os';
-import createUniversalCommand from '../command';
-
-const BASE_API_URL = 'https://tool.serverlessfans.com';
-const COMMAND_DESC_URL = '/api/package/command';
-export async function getCommandDetail(name: any, provider: any, version:any): Promise<Array<any>> {
-  const url: any = `${BASE_API_URL}${COMMAND_DESC_URL}`;
-  let command_list: any = [];
-  try {
-    const result: any = await axios.get(url, {
-      params: {
-        name, provider, version
-      }
-    });
-    if (result.data && result.data.Response) {
-      const command = result.data.Response.Command || {};
-      command_list = Object.keys(command).map((key) => {
-        return {
-          name: key,
-          desc: command[key]
-        };
-      });
-    }
-  } catch (e) {
-    logger.error(e.message);
-  }
-  return command_list;
-}
-export async function getParsedTemplateObj(templateFile: any) {
-  const parse = new Parse(templateFile);
-  const parsedObj = parse.getOriginalParsedObj();
-  return await parse.getRealVariables(parsedObj);
-}
-
-export function getCustomerCommandInfo(parsedTemplateObj: any): Array<string> {
-
-  return Object.keys(parsedTemplateObj).filter(key => key !== 'Global');
-}
-
-export async function createCustomerCommand(templateFile: string): Promise<Array<any>> {
-  const customerCommands : any = [];
-  const doc = await getParsedTemplateObj(templateFile);
-  const commandListPromise = getCustomerCommandInfo(doc).map(async (projectName) => {
-    const projectDocDetail = doc[projectName];
-    const { Provider, Component } = projectDocDetail;
-    const commandList = await getCommandDetail(Component, Provider, '');
-    return { projectName, commandList, projectDocDetail };
-  });
-  const commondListDetail = await Promise.all(commandListPromise);
-  commondListDetail.forEach(({ projectName, commandList, projectDocDetail }) => {
-    const customerCommand = new Command(projectName);
-    commandList.forEach(async (command) => {
-      const { name: commandName, desc } = command;
-      const universialCommandInstance = await createUniversalCommand(commandName, projectName, desc);
-      customerCommand.addCommand(universialCommandInstance);
-    });
-    customerCommands.push(customerCommand);
-  });
-  return customerCommands;
-}
-
-export function registerCommandChecker(program: any) {
-  program.on('command:*', (cmds: any) => {
-    const commands = program.commands.map((command: any) => command.name());
-
-    if (!commands.includes(cmds[0])) {
-      logger.error(`  error: unknown command ${cmds[0]}`);
-      logger.error();
-      program.help();
-    }
-  });
-}
-
-export async function registerExitOverride(program: any) {
-  const checkVersion = new CheckVersion();
-  await checkVersion.init();
-  program.exitOverride(async () => {
-    checkVersion.showMessage();
-  });
-}
-
-export async function registerCustomerCommand(system_command: any, templateFile: string) {
-  if (templateFile) {
-    const customerCommands = await createCustomerCommand(templateFile);
-    customerCommands.forEach((command) => {
-      system_command.addCommand(command);
-    });
-  }
-}
-export async function regiserUniversalCommand(system_command: any, templateFile: string) {
-  if (templateFile) {
-    const parsedTemplateObj = await getParsedTemplateObj(templateFile);
-    const customerCommands = getCustomerCommandInfo(parsedTemplateObj);
-    if ( process.argv[2] && !customerCommands.includes( process.argv[2])) {
-      system_command.addCommand(createUniversalCommand( process.argv[2]));
-    } else if ( process.argv[2] && customerCommands.includes( process.argv[2]) && process.argv[3] && !customerCommands.includes( process.argv[3])) {
-      system_command.addCommand(createUniversalCommand( process.argv[3]));
-    }
-  }
-
-}
-export function registerVerbose(program: any) {
-  if (process.argv.includes('--verbose')) {
-    process.env.VERBOSE = program.verbose;
-  }
-}
-
-export function recordCommandHistory(argv: string[]) {
-  const file = storage.getHistoryFile();
-  fs.appendFileSync(file, argv.join(',') + os.EOL);
-}
-
-
-
-
-export default registerCommandChecker;

package/src/utils/common.ts

@@ -1,47 +0,0 @@
-const path = require('path');
-const fs = require('fs');
-
-
-
-export function checkAndReturnTemplateFile() {
-  const currentDir = process.cwd();
-  const index = process.argv.indexOf('-t') || process.argv.indexOf('--template');
-  if (index !== -1) {
-    const tempFileIndex = index + 1;
-    const tempFileName = process.argv[tempFileIndex];
-    if (tempFileName) {
-      if (tempFileName.endsWith('.yaml') || tempFileName.endsWith('.yml')) {
-        if (fs.existsSync(path.join(currentDir, tempFileName))) {
-          process.argv.splice(index, 2);
-          return path.join(currentDir, tempFileName);
-        } else if (fs.existsSync(tempFileName)) {
-          process.argv.splice(index, 2);
-          return tempFileName;
-        }
-      }
-    }
-  }
-  if (fs.existsSync(path.join(currentDir, 'template.yaml'))) {
-    return path.join(currentDir, 'template.yaml');
-  }
-  if (fs.existsSync(path.join(currentDir, 'template.yml'))) {
-    return path.join(currentDir, 'template.yml');
-  }
-  return null;
-}
-
-export function checkTemplateFile(templateFile: string) {
-  if (fs.existsSync(templateFile)) {
-    return templateFile;
-  }
-  return null;
-}
-
-
-export function printn(n: number, str = ' ') {
-  let temp_str = '';
-  for (let i = 0;i < n;i++) {
-    temp_str = temp_str + str;
-  }
-  return temp_str;
-}

package/src/utils/download-manager.ts

@@ -1,197 +0,0 @@
-import * as URL from 'url';
-import * as path from 'path';
-import * as download from 'download';
-import * as os from 'os';
-import * as fs from 'fs-extra';
-import axios from 'axios';
-import * as inquirer from 'inquirer';
-import { InitError } from '../error/init-error';
-import * as ChildProcess from 'child_process';
-import * as util from 'util';
-import logger from '../utils/logger';
-import { PackageType } from '../utils/package-type';
-import { RepoTemplate } from './repo-template-entity';
-import i18n from './i18n';
-import { SERVERLESS_GET_PACKAGE_PROVIDER, SERVERLESS_GET_APP_INFO_URL } from '../constants/static-variable';
-// eslint-disable-next-line no-unused-vars
-import {ProgressService, ProgressType, ProgressBarOptions} from '@serverless-devs/s-progress-bar';
-const got = require('got');
-import {green} from 'colors';
-
-
-export class DownloadManager {
-  constructor() {
-
-  }
-
-  /**
-     * Download template from app center
-     * @param packageType: package type, such as application, component or plugin
-     * @param packageName: package name
-     * @param outputDir: outputDir
-     * @param provider: package provider, will promopt if not given
-     */
-  async downloadTemplateFromAppCenter(packageType: PackageType, packageName: string, outputDir: string, provider?: string) {
-    if (packageType !== PackageType.plugin && !provider) {
-      try {
-        provider = await this.getPackageProvider(packageType, packageName);
-        logger.info('  Init Information:');
-        logger.info(i18n.__(`    Package: {{package}}    Provider: {{provider}}`, {'package': packageName, 'provider': provider}));
-      } catch (err) {
-        throw new InitError(err.message);
-      }
-    }
-
-    try {
-      const url = await this.getPackageDownloadUrl(packageType, packageName, provider);
-      await this.downloadTemplateByUrl({
-        zipFile: url,
-        hasSubPath: false
-      }, outputDir);
-      // logger.success('Download Success......');
-    } catch (err) {
-      throw err;
-    }
-  }
-
-  async downloadTemplateByUrl(template: RepoTemplate, outputDir: string) {
-    const uuid = this.generateUUID();
-    const srcDirName = path.join(os.tmpdir(), `${uuid}`);
-    try {
-      await this.proxyDownload(template.zipFile, srcDirName, { extract: true, strip: 1 });
-    } catch (err) {
-      throw new InitError('Download template by url failed, error: {{msg}}', { msg: err.message });
-    }
-
-    if (!template.hasSubPath) {
-      fs.copySync(srcDirName, outputDir, { dereference: true });
-    } else {
-      const srcSubDirName = path.join(srcDirName, template.subPath || '');
-      const destSubDirName = path.join(outputDir, template.subPath || '');
-      fs.copySync(srcSubDirName, destSubDirName, { dereference: true });
-    }
-  }
-
-  async downloadTemplateByGitClone(url: URL.Url, outputDir: string) {
-    let cmd = `git clone ${url.href} ${outputDir}`;
-    const exec = util.promisify(ChildProcess.exec);
-    try {
-      await exec(cmd);
-    } catch (err) {
-      throw err;
-    }
-  }
-
-  private async getPackageProvider(packageType: PackageType, project: string): Promise<string> {
-    const options = {
-      url: SERVERLESS_GET_PACKAGE_PROVIDER,
-      type: 'get',
-      timeout: 5000,
-      headers: {},
-      params: {
-        name: project,
-        type: PackageType[packageType]
-      }
-    };
-
-    let result;
-    try {
-      result = await axios.request(options);
-    } catch (err) {
-      throw new InitError('Failed to get package provider, error: {{msg}}', {msg: err.message});
-    }
-    if (result.status !== 200) {
-      throw new InitError('Failed to get package provider, http code: {{code}}', {code: result.status});
-    }
-    if (result.data.Error) {
-      throw new InitError('Failed to get package provider, error message: {{msg}}', {msg: result.data.Error});
-    }
-
-    const providers: string[] = result.data.Response.Providers;
-    if (!providers || providers.length === 0) {
-      throw new InitError('No available provider for {{project}}', {project: project});
-    }
-
-    if (providers.length === 0) {
-      throw new InitError('Could not get package.');
-    } else if (providers.length === 1) {
-      return providers[0];
-    } else {
-      let {provider} = await inquirer.prompt([
-        {
-          type: 'list',
-          name: 'provider',
-          message: i18n.__('Please choose a provider'),
-          choices: providers
-        }
-      ]);
-      return new Promise((resolve, reject) => {
-        resolve(provider);
-      });
-    }
-  }
-
-  private async getPackageDownloadUrl(
-    packageType: PackageType, packageName: any, provider: any): Promise<string> {
-    const options = {
-      url: SERVERLESS_GET_APP_INFO_URL,
-      type: 'get',
-      timeout: 5000,
-      headers: {
-        'User-Agent': 's'
-      },
-      params: {
-        name: packageName,
-        provider: provider,
-        type: PackageType[packageType]
-      }
-    };
-    const result = await axios.request(options);
-    if (result.status !== 200) {
-      throw new InitError('Failed to get package information, http code: {{code}}', { code: result.status });
-    }
-    if (!result.data.Response) {
-      throw new InitError('Failed to get package information, error: {{msg}}', { msg: result.data.Response || i18n.__('Please try again later') });
-    }
-    return new Promise((resolve, reject) => {
-      resolve(result.data.Response.Url);
-    });
-  }
-
-  private generateUUID(): string {
-    return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
-  }
-
-  async proxyDownload(url: string, dest: string, options: download.DownloadOptions) {
-    let len;
-    try {
-      const {headers} = await got(url, {method: 'HEAD'});
-      len = parseInt(headers['content-length'], 10);
-    } catch (err) {
-      // ignore error
-    }
-
-    let bar :ProgressService;
-    if (len) {
-      let pbo :ProgressBarOptions = {
-        total: len
-      };
-      bar = new ProgressService(ProgressType.Bar, pbo);
-    } else {
-      let pbo :ProgressBarOptions = {
-        total: 100,
-        width: 0
-      };
-      let format = `${green(':loading')} ${green(i18n.__('Downloading ...'))} `;
-      bar = new ProgressService(ProgressType.Loading, pbo, format);
-    }
-
-    await download(url, dest, options).on(
-      'downloadProgress', progress => {
-        bar.update(progress.transferred);
-      }
-    );
-    bar.terminate();
-  }
-}
-

package/src/utils/handler-set-config.ts

@@ -1,83 +0,0 @@
-const os = require('os');
-const fs = require('fs');
-const path = require('path');
-const yaml = require('js-yaml');
-
-interface ProfileParame {
-  data?: any;
-  configKey?: string;
-  read?: boolean;
-  filePath?: string;
-}
-
-interface Profile {
-  [key: string]: any;
-}
-
-export function setConfig(key: string, value: any) {
-  const profile = getProfileFile();
-  profile[key] = value;
-  setProfileFile(profile);
-}
-
-export function getConfig(key: string): any {
-  const profile = getProfileFile();
-  return profile[key];
-}
-
-export async function handlerProfileFile(parame: ProfileParame) {
-  const filePath = parame.filePath || 'set-config.yml';
-  const profPath = path.join(os.homedir(), `.s/${filePath}`);
-  const isExists = fs.existsSync(profPath);
-
-  let profile: Profile = {};
-
-  // 如果文件和目录不存在则创建，存在则读取
-  if (!isExists) {
-    const configDir = path.join(os.homedir(), '.s');
-    try {
-      fs.statSync(configDir);
-    } catch (e) {
-      await fs.mkdirSync(configDir);
-    }
-  } else {
-    try {
-      profile = yaml.safeLoad(fs.readFileSync(profPath, 'utf8')) || {};
-    } catch (e) {
-      throw e;
-    }
-  }
-
-  // 如果仅是读取，则拿到配置信息直接退出
-  if (parame.read) {
-    return profile;
-  }
-
-  // 修改配置
-  const configKey = parame.configKey || '';
-  profile[configKey] = parame.data;
-  await fs.writeFileSync(profPath, yaml.dump(profile));
-  return profile;
-}
-
-
-function setProfileFile(profile: Profile) {
-  const profileFilePath = getDefaultProfilePath();
-  fs.writeFileSync(profileFilePath, yaml.dump(profile));
-}
-
-function getProfileFile() : Profile {
-  const profileFilePath = getDefaultProfilePath();
-  if (!fs.existsSync(profileFilePath)) {
-    return {};
-  }
-  try {
-    return yaml.safeLoad(fs.readFileSync(profileFilePath, 'utf8')) || {};
-  } catch (e) {
-    throw e;
-  }
-}
-
-function getDefaultProfilePath(): string {
-  return path.join(os.homedir(), '.s', 'set-config.yml');
-}

package/src/utils/i18n.ts

@@ -1,21 +0,0 @@
-import * as config from './handler-set-config';
-const i18n = require('i18n');
-
-i18n.configure({
-  logDebugFn: function (msg?:any) {},
-  logWarnFn: function (msg?:any) {},
-  logErrorFn: function (msg?:any) {},
-  locales: ['en', 'zh'],
-  directory: __dirname + '/locales',
-  register: global
-});
-
-const locale = config.getConfig('locale');
-if (locale) {
-  i18n.setLocale(locale);
-} else {
-  i18n.setLocale('en');
-}
-
-
-export default i18n;