rigjs 1.0.34 → 2.0.0-alpha.1

package/lib/build/index.ts

@@ -0,0 +1,21 @@
+import fsHelper from '../utils/fsHelper';
+import CICD from '@/classes/cicd/CICD';
+import CICDCmd from '@/classes/cicd/CICDCmd';
+import shell from 'shelljs';
+import path from 'path';
+
+export default async (cmd: any) => {
+	//create cicd object
+	const cicd = CICD.createByDefault(cmd);
+	//construct cmd object
+	const cicdCmd = new CICDCmd(cmd, cicd);
+	console.log(cicd)
+	//build by cicdCmd and cicdConfig
+	console.log(cicdCmd.endpoints);
+	for (let i = 0; i < cicdCmd.endpoints.length; i++) {
+		const ep = cicdCmd.endpoints[i];
+		const cmdStr = `cross-env PUBLIC_PATH=${path.join('/',ep.deployDir)} ${ep.build}`;
+		console.log(cmdStr);
+		shell.exec(cmdStr);
+	}
+}

package/lib/check/index.d.ts

@@ -0,0 +1,6 @@
+declare namespace check {
+	const name: string;
+
+	function load(): void;
+}
+export default check;

package/lib/check/index.js

@@ -4,7 +4,6 @@
  * @author Wang Bo (ralwayne@163.com)
  * @date 2020/10/14 6:59 PM
  */
-const shell = require('shelljs');
 const fs = require('fs');
 const json5 = require('json5');
 const print = require('../print');

package/lib/classes/cicd/CICD.ts

@@ -0,0 +1,112 @@
+import DirLevel from '@/classes/cicd/DirLevel';
+import Endpoint, { EndpointDict} from '@/classes/cicd/Endpoint';
+import fs from 'fs';
+
+const JSON5 = require('json5');
+import qs from 'querystring';
+export enum CloudType {
+	alicloud = 'alicloud',
+}
+
+/**
+ * Bundle source
+ */
+interface DeploySource {
+	root_path: string
+}
+
+/**
+ * Deploy target
+ */
+interface DeployTarget {
+	id: string;
+	type: CloudType;
+	bucket: string;
+	region: string;
+	access_key: string;
+	access_secret: string;
+	root_path: '/';
+	uri_rewrite: {
+		original: string;
+		final?: string;
+	};
+}
+
+/**
+ * @interface DirGroup
+ * Only dynamic Dirlevel can use DirGroup
+ */
+export interface DirGroup {
+	name: string,
+	/**
+	 * Name in DirLevel,
+	 */
+	level: string,
+	includes: string[],
+}
+export interface Define{
+	[replace: string]: String;
+}
+export interface DefineDict{
+	[group: string]: Define;
+}
+
+/**
+ * Whole CI/CD config
+ */
+export interface CICDConfig {
+	tree_schema: string;
+	source: DeploySource;
+	target: DeployTarget | DeployTarget[];
+	endpoints: EndpointDict;
+	groups: DirGroup[];
+}
+
+
+class CICD {
+	/**
+	 * schema of the directory tree
+	 * @type {string}
+	 */
+	treeSchema: string;
+	/**
+	 * DirLevel shows every level of the directory structure
+	 * @type {DirLevel[]}
+	 */
+	schema: DirLevel[];
+	/**
+	 * endpoints contains build info and deploy info.
+	 * @type {Endpoint[]}
+	 */
+	endpoints: Endpoint[];
+	source: DeploySource;
+	target: DeployTarget | DeployTarget[];
+	groups: DirGroup[];
+
+	constructor(config: CICDConfig) {
+		this.treeSchema = config.tree_schema;
+		this.schema = DirLevel.createSchema(this.treeSchema);
+		this.endpoints = Endpoint.createEndpointArr(config,this.schema);
+		this.source = config.source;
+		this.target = config.target;
+		this.groups = config.groups;
+	}
+	static createByDefault(cmd:any){
+		//replace params
+		let cicdStr = fs.readFileSync(`${process.cwd()}/cicd.rig.json5`).toString();
+		const paramsStr = cmd.params;
+		const params = qs.parse(paramsStr);
+		Object.keys(params).forEach(key => {
+			const regStr = `\\$\\{${key}\\}`;
+			const regex = new RegExp(regStr, 'g');
+			cicdStr = cicdStr.replace(regex, params[key] as string);
+		});
+		return new CICD(JSON5.parse(cicdStr));
+	}
+
+	matchEndpoints(cmdDirStrArr: string[]) {
+
+	}
+}
+
+export default CICD;

package/lib/classes/cicd/CICDCmd.ts

@@ -0,0 +1,65 @@
+import Endpoint from '@/classes/cicd/Endpoint';
+import CICD, {CICDConfig} from '@/classes/cicd/CICD';
+import qs, {ParsedUrlQuery} from 'querystring';
+import path from 'path'
+import fsHelper from '@/utils/fsHelper';
+
+/**
+ * @class CICDCmd
+ * @property dir string Original specific dir in cmd.
+ * @property dirArr array Splitted dir.
+ * @property endpoints array Tageted endpoints used to build,define or deploy
+ */
+class CICDCmd {
+	/**
+	 * @property dir string Whole directory
+	 * @type {string}
+	 */
+	dir: string;
+	/**
+	 *
+	 * @type {string[]}
+	 */
+	dirInSchemaStrArr: string[];
+	dirStrArr: string[];
+	endpoints: Endpoint[] = [];
+	cicd: CICD;
+
+	constructor(cmd: any, cicd: CICD) {
+		const cmdArgs = cmd.args;
+		this.dir = cmdArgs[0];
+		//获取需要被设置的schema变量
+		const schemaKeys = this.dir.match(/(?<=\{)[a-zA-Z]+(?=\})/g) || [];
+		//解析schema变量
+		let schema: ParsedUrlQuery = qs.parse(cmd.schema);
+		for (let key of schemaKeys) {
+			const val = schema[key];
+			if (val) {
+				this.dir = this.dir.replace(`{${key}}`, val as string);
+			} else {
+				throw new Error(`${key} is not set`);
+			}
+		}
+		//whole user's target dir
+		this.dirStrArr = this.dir.split('/').filter((dirStr, index) => dirStr.length > 0);
+		//dir within the schema
+		this.dirInSchemaStrArr = this.dir.split('/').filter((dirStr, index) => dirStr.length > 0 && index < cicd.schema.length);
+		this.cicd = cicd;
+		this.createTargetEndpoints();
+	}
+
+	private createTargetEndpoints() {
+		const allEndpints = this.cicd.endpoints;
+		this.endpoints = allEndpints.filter(endpoint => endpoint.matchCmd(this.dirInSchemaStrArr, this.cicd.groups));
+		if (this.dirStrArr.length > this.dirInSchemaStrArr.length) {
+			const sufDir = this.dirStrArr.slice(this.dirInSchemaStrArr.length, this.dirStrArr.length).join('/');
+			this.endpoints = this.endpoints.map(ep => {
+				ep.deployDir = path.join(ep.deployDir, sufDir);
+				return ep;
+			});
+		}
+
+	}
+}
+
+export default CICDCmd;

package/lib/classes/cicd/Deploy/AliDeploy.ts

@@ -0,0 +1,46 @@
+import aliOSS from "ali-oss";
+import fs from "fs";
+class AliOSS {
+  ossClient: aliOSS;
+  constructor(accessKeyId: string, accessKeySecret: string, region: string, bucket: string) {
+    this.ossClient = new aliOSS({
+      region,
+      accessKeyId: accessKeyId,
+      accessKeySecret: accessKeySecret,
+      bucket,
+      timeout: 600000,
+    });
+  }
+
+  private async progress(p: number, filePath: string, ossPath: string) {
+    // 上传进度。
+    process.stdout.clearLine(-1);
+    process.stdout.cursorTo(0);
+    process.stdout.write(
+      `progress: ${p.toFixed(2)}%, Upload '${filePath}' To OSS_PATH:${ossPath}`
+    );
+  }
+
+  public async putStreamFiles(
+    filesList: string[],
+    ossBasePath: string,
+    dir: string
+  ) {
+    for (let i = 0; i < filesList.length; i++) {
+      const filePath = filesList[i].split("dist\\")[1];
+      const ossPath =
+        ossBasePath + filePath.replace(/\\/g, "/").replace(dir, "");
+      const fileResult = await this.ossClient.putStream(
+        ossPath,
+        fs.createReadStream(filesList[i])
+      );
+      if (fileResult.res.status === 200) {
+        const p = ((i + 1) * 100) / filesList.length;
+        this.progress(p, filesList[i], ossPath);
+      }
+    }
+    console.log("\n");
+  }
+}
+
+export default AliOSS;

package/lib/classes/cicd/Deploy/CDN.ts

@@ -0,0 +1,126 @@
+import moment from "dayjs";
+import qs from "qs";
+import crypto from "crypto";
+import axios from "axios";
+import * as uuid from "uuid";
+
+type TFlag = "break" | "enhance_break" | null;
+
+class CDN {
+  AccessKeySecret: string;
+  AccessKeyId: string;
+  constructor(AccessKeyId: string, AccessKeySecret: string) {
+    this.AccessKeySecret = AccessKeySecret;
+    this.AccessKeyId = AccessKeyId;
+  }
+  /**
+   * 访问CDN通用接口
+   * @param {接口名称} actionName
+   * @param {各接口定制化参数} paramObj
+   * @returns
+   */
+  private async getCdnData(actionName: string, paramObj: Object) {
+    let config = {
+      Action: actionName,
+      Format: "JSON",
+      Version: "2018-05-10",
+      AccessKeyId: this.AccessKeyId,
+      SignatureMethod: "HMAC-SHA1",
+      Timestamp: moment().toDate().toISOString(),
+      SignatureVersion: "1.0",
+      SignatureNonce: uuid.v1(),
+    };
+    config = Object.assign(config, paramObj);
+    let paramConfig = qs.stringify(config, {
+      sort: (a: number, b: number) => {
+        return a < b ? -1 : 1;
+      },
+      charset: "utf-8",
+    });
+
+    const strSign = `GET&%2F&${encodeURIComponent(paramConfig)}`;
+    console.log(`strSign: ${strSign}`);
+    const hmacSha1 = crypto.createHmac("sha1", this.AccessKeySecret);
+    hmacSha1.update(strSign);
+    const signature = hmacSha1.digest("base64");
+    paramConfig += `&Signature=${signature}`;
+
+    const url = `http://cdn.aliyuncs.com?${paramConfig}`;
+    console.log(url);
+
+    const res = await axios.create().get(url);
+    return res.data;
+  }
+
+  /**
+   * 改写回源URI接口
+   * @param {加速域名} domainName
+   * @param {需要重写的url 数组} sourceUrls
+   * @param {重写目标url 数组} targetUrls
+   * @param {改写操作执行规则 数组 值为null、break或enhance_break} flags
+   * @returns
+   */
+  public async setRWriteUri(
+    domainName: string,
+    sourceUrls: string[],
+    targetUrls: string[],
+    flags: TFlag[]
+  ) {
+    if (sourceUrls.length !== targetUrls.length) {
+      throw new Error(`sourceUrls's length not equal targetUrls's length`);
+    }
+    const Functions: Object[] = [];
+    sourceUrls.forEach((item, index) => {
+      Functions.push({
+        functionArgs: [
+          {
+            argName: "source_url",
+            argValue: item,
+          },
+          {
+            argName: "target_url",
+            argValue: targetUrls[index],
+          },
+          {
+            argName: "flag",
+            argValue: flags[index],
+          },
+        ],
+        functionName: "back_to_origin_url_rewrite",
+      });
+    });
+
+    const data = await this.getCdnData("BatchSetCdnDomainConfig", {
+      DomainNames: domainName,
+      Functions: JSON.stringify(Functions),
+    });
+    return data;
+  }
+
+  /**
+   * 刷新节点上的文件内容
+   * @param {刷新URL, 格式为加速域名或刷新的文件或目录。多个URL之间使用换行符(\n)或(\r\n)分隔} objectPath
+   * @param {刷新的类型 File: 文件; Directory: 目录} objectType
+   */
+  public async refreshCache(objectPath: string, objectType: string) {
+    const data = await this.getCdnData("RefreshObjectCaches", {
+      ObjectPath: objectPath,
+      ObjectType: objectType ? objectType : undefined,
+    });
+    return data;
+  }
+
+  /**
+   * 预热源站内容到缓存节点
+   * @param {预热URL,格式为加速域名或预热的文件 多个URL之间使用换行符(\n)或(\r\n)分隔 单条长度最长为1024个字符} objectPath
+   * @returns
+   */
+  async pushCache(objectPath: string) {
+    const data = await this.getCdnData("PushObjectCache", {
+      ObjectPath: objectPath,
+    });
+    return data;
+  }
+}
+
+export default CDN;

package/lib/classes/cicd/DirLevel.ts

@@ -0,0 +1,49 @@
+import regex from '../../utils/regex';
+
+/**
+ * contain attributes of every level in the directory schema
+ */
+class DirLevel {
+	/**
+	 * Means that is this level's name can be set dynamically.
+	 * @type {boolean}
+	 */
+	dynamic: boolean;
+	/**
+	 * The meaning of this level.Can be changed when [this.dynamic] is true.
+	 * % matches all dir name.
+	 * @type {string}
+	 */
+	name: string | '%';
+	/**
+	 * The level in the directory schema
+	 * @type {number}
+	 */
+	level: number;
+
+	constructor(dirName: string, level: number) {
+		this.dynamic = regex.dynamicDir.test(dirName);
+		this.name = dirName;
+		this.level = level;
+	}
+
+	static createSchema(treeSchema: string) {
+		let dirStrArr = treeSchema.split('/');
+		dirStrArr = dirStrArr.filter(dirStr => dirStr.length > 0);
+		return dirStrArr.map((dirStr, index) => {
+			return new DirLevel(dirStr, index);
+		});
+	}
+
+	static createDirArr(dir: string, schema: DirLevel[]) {
+		let dirStrArr = dir.split('/');
+		dirStrArr = dirStrArr.filter(dirStr => dirStr.length > 0);
+		return dirStrArr.map((dirStr, index) => {
+			const level = new DirLevel(dirStr, index);
+			level.dynamic = schema[index].dynamic;
+			return level;
+		});
+	}
+}
+
+export default DirLevel;

package/lib/classes/cicd/Endpoint.ts

@@ -0,0 +1,87 @@
+import {CICDConfig, DefineDict, DirGroup} from './CICD';
+import {mkdirSync} from 'fs';
+import DirLevel from '@/classes/cicd/DirLevel';
+
+interface EndpointInfo {
+	build: string;
+	target: string;
+	domain: string;
+	define: DefineDict;
+}
+
+export interface EndpointDict {
+	[dir: string]: EndpointInfo;
+}
+
+class Endpoint {
+	dir: string;
+	dirStrArr: string[];
+	dirArr: DirLevel[];
+	target: string;
+	build: string;
+	domain: string;
+	deployDir: string;
+	define: DefineDict;
+
+
+	constructor(dir: string, info: EndpointInfo, schema: DirLevel[]) {
+		this.dir = dir;
+		this.deployDir = dir;
+		this.dirStrArr = dir.split('/').filter(d => d.length > 0);
+		this.dirArr = DirLevel.createDirArr(dir, schema);
+		this.target = info.target;
+		this.build = info.build;
+		this.domain = info.domain;
+		this.define = info.define;
+	}
+
+	static createEndpointArr(cicdConfig: CICDConfig, schema: DirLevel[]) {
+		const endpointDict = cicdConfig.endpoints;
+		return Object.keys(endpointDict).map(dir => {
+			const info = endpointDict[dir];
+			return new Endpoint(dir, info, schema);
+		});
+	}
+
+	matchCmd(dirSchemaStrArr: string[], groups: DirGroup[]) {
+		if (this.dirStrArr.length < dirSchemaStrArr.length) {
+			return false;
+		}
+		for (let i = 0; i < dirSchemaStrArr.length; i++) {
+			const cmdDir = dirSchemaStrArr[i];
+			const dir = this.dirStrArr[i];
+			const dirLevel = this.dirArr[i];
+			//check if dir is wildcard
+			if (cmdDir !== '%') {
+				//not wildcard
+				//check if dir is group alias
+				if (cmdDir.indexOf('%') === 0) {
+					//dir is group
+					//find group
+					const group = groups.find(g => g.name === cmdDir);
+					if (group) {
+						//group found
+						//check if group includes this dir
+						if (group.includes.indexOf(dir) < 0) {
+							//not include
+							return false;
+						}
+					} else {
+						return false;
+					}
+
+				} else {
+					//cmdDir is not group
+					if (cmdDir !== dir) {
+						return false;
+					}
+				}
+			} else {
+				if (!dirLevel.dynamic) return false;
+			}
+		}
+		return true;
+	}
+}
+
+export default Endpoint;

package/lib/define/index.ts

@@ -0,0 +1,47 @@
+import fsHelper from '../utils/fsHelper';
+import CICD, {Define} from '@/classes/cicd/CICD';
+import CICDCmd from '@/classes/cicd/CICDCmd';
+import fs from 'fs';
+import path from 'path';
+const replaceDefine = (target:string,define?:Define)=>{
+	const dirs = fs.readdirSync(target);
+	for (let dir of dirs){
+		const stat = fs.statSync(path.join(target, dir));
+		if (stat.isDirectory()){
+			replaceDefine(path.join(target, dir),define);
+		}else{
+			if (define){
+				const namePieces = dir.split('.');
+				const fileType = namePieces[namePieces.length - 1];
+				if (['js','ts'].indexOf(fileType)>=0){
+					let file = fs.readFileSync(path.join(target, dir)).toString();
+					const replaceArr = Object.keys(define);
+					for (let replace of replaceArr){
+						file = file.replace(new RegExp(replace,'g'),define[replace] as string);
+					}
+					fs.writeFileSync(path.join(target, dir),file);
+				}
+			}
+		}
+	}
+}
+export default async (cmd: any) => {
+	// let phase = 'start define';
+	// try{
+	// 	const cicdConfigJson = fsHelper.readCICDConfig();
+	// 	const cicdConfig = new CICD(cicdConfigJson);
+	// 	const args: string[] = cmd.args;
+	// 	const define = cicdConfig.defines[args[1]];
+	// 	//construct cmd object
+	// 	const cicdCmd = new CICDCmd(cmd, cicdConfig);
+	// 	console.log(cicdCmd);
+	// 	//define by cicdCmd and cicdConfig
+	// 	phase = 'start replacement';
+	// 	for (let i = 0; i < cicdCmd.endpoints.length; i++) {
+	// 		const ep = cicdCmd.endpoints[i];
+	// 		replaceDefine(path.join(cicdConfig.source.root_path, ep.dir),define);
+	// 	}
+	// }catch (e) {
+	// 	throw new Error(`${phase}:${e.message}`)
+	// }
+}

package/lib/deploy/index.ts

@@ -0,0 +1,60 @@
+import fs from "fs";
+import path from "path";
+import CICD from "@/classes/cicd/CICD";
+import CICDCmd from "@/classes/cicd/CICDCmd";
+import AliOSS from "@/classes/cicd/Deploy/AliDeploy";
+import CDN from "@/classes/cicd/Deploy/CDN";
+
+let filesList: string[] = [];
+const traverseFolder = (url: string) => {
+  if (fs.existsSync(url)) {
+    const files = fs.readdirSync(url);
+    files.forEach((file) => {
+      const curPath = path.join(url, file);
+      if (fs.statSync(curPath).isDirectory()) {
+        traverseFolder(curPath);
+      } else {
+        filesList.push(curPath);
+      }
+    });
+  }
+};
+
+export default async (cmd: any) => {
+  try {
+    //create cicd object
+    const cicd = CICD.createByDefault(cmd);
+    //construct cmd object
+    const cicdCmd = new CICDCmd(cmd, cicd);
+
+    const target = Array.isArray(cicdCmd.cicd.target)
+      ? cicdCmd.cicd.target[0]
+      : cicdCmd.cicd.target;
+
+    const aliOss = new AliOSS(target.access_key, target.access_secret, target.region, target.bucket);
+    const cdn = new CDN(target.access_key, target.access_secret);
+    for (let i = 0; i < cicdCmd.endpoints.length; i++) {
+      const distPath = path.join(
+        process.cwd(),
+        cicd.source.root_path,
+        cicdCmd.endpoints[i].dir
+      );
+      traverseFolder(distPath);
+      await aliOss.putStreamFiles(
+        filesList,
+        cicdCmd.endpoints[i].deployDir.replace(/\\/g, "/"),
+        cicdCmd.endpoints[i].dir
+      );
+
+    //   await cdn.setRWriteUri(
+    //     cicdCmd.endpoints[i].domain,
+    //     [""],
+    //     [""],
+    //     ["break"]
+    //   );
+      filesList = [];
+    }
+  } catch (e) {
+    throw e;
+  }
+};

package/lib/deps/index.d.ts

@@ -0,0 +1,6 @@
+declare namespace deps {
+	const name: string;
+
+	function load(): void;
+}
+export default deps;

package/lib/env/index.d.ts

@@ -0,0 +1,4 @@
+declare namespace env {
+	function load(): void;
+}
+export default env;

package/lib/info/index.d.ts

@@ -0,0 +1,6 @@
+declare namespace info {
+	function load(): void;
+	function info(): void;
+
+}
+export default info;

package/lib/init/cicd.rig.json5

@@ -0,0 +1,9 @@
+{
+  tree_schema: '{app}/{env}/{oem}',
+  source: {
+    root_path: 'dist',
+  },
+  target: {},
+  endpoints: {},
+  groups: [],
+}

package/lib/init/index.d.ts

@@ -0,0 +1,6 @@
+declare namespace init {
+	const name: string;
+
+	function load(): void;
+}
+export default init;