@soft-artel/ci 1.2.15 → 1.3.15

package/libs/Shell.ts

@@ -0,0 +1,119 @@
+import shelljs from 'shelljs';
+
+import { log, resolvePath, asyncSleep } from '../libs/helpers';
+
+// ===========================================
+
+function exec(cmd: string, opt: ExecOptions = { silent: !log.debug, ignoreError: false }): Promise<string>{
+	return new Promise((resolve, reject) => {
+  
+		if(opt.silent === undefined){
+			opt.silent = true;
+		}
+  
+		if(opt.silent === false){
+			log.dbg(cmd);
+		}
+  
+		shelljs.exec(cmd, opt, (code, stdout, stderr) => {
+			if(code === 0){
+				resolve(stdout.trim());
+				return;
+			}
+  
+			if(code !== 0 && opt.ignoreError){
+				resolve('');
+				return;
+			}
+  
+			const e = new Error();
+			e.message = cmd+'\n'+ (stderr.length > 0 ? stderr : stdout);
+			e.name = String(code);
+			reject(e);
+  
+		}
+		);
+	});
+}
+  
+// -------------
+  
+async function execRepeat(cmd: string, repeats = 10, sleep = 10, opt = { silent: !log.debug, ignoreError: false }){
+  
+	let tryCount = repeats;
+	let e = new Error();
+  
+	while(tryCount > 0) {
+		tryCount -= 1;
+		try{
+  
+			return await exec(cmd, { silent: opt.silent, ignoreError: false });
+  
+		} catch(err){
+			e = err;
+			log.error(`Exec Repeats [${tryCount + 1}] FAIL: ${ cmd }`);
+			log.error(err);
+			await asyncSleep(sleep);
+		}
+	}
+  
+	if(opt.ignoreError){
+		return e.message;
+	}
+  
+	throw e;
+  
+}
+  
+// -------------
+  
+async function mkdir(dir: string, opt?: ExecOptions){
+	return exec(`mkdir -p ${ resolvePath(dir) }`, opt);
+}
+  
+async function cat(file: string, opt = { silent: true, ignoreError: false }){
+	const filePath = resolvePath(file);
+	if(shelljs.test('-e', filePath) === false && opt && opt.ignoreError === true){
+		return undefined;
+	}
+	return exec('cat '+filePath, opt);
+}
+  
+async function find(where: string, filename = '', maxdepth = 3, ignore: string[] = [], pars = '', opt = { silent: true, ignoreError: false }){
+
+	let cmd = `find ${ where } ${pars}`;
+
+	for (const path of ignore) {
+		cmd += ` -not -path '${path}'`;
+	}
+
+	cmd += ` -maxdepth ${maxdepth}`;
+	cmd += ` -name ${filename}`;
+
+	return (await exec(cmd, opt)).split('\n').filter((f)=>f.length > 2);
+}
+  
+async function ls(where: string, pars = '', opt = { silent: true, ignoreError: false }){
+	return (await exec(`ls ${ where } ${ pars }`, opt)).split('\n').filter((f)=>f.length > 2);
+}
+  
+export interface ExecOptions {
+	silent?: boolean;
+	ignoreError?: boolean;
+}
+
+export default {
+	cd: shelljs.cd,
+	chmod: shelljs.chmod,
+	grep: shelljs.grep,
+	pwd: shelljs.pwd,
+	sed: shelljs.sed,
+	test: shelljs.test,
+
+	exec,
+	execRepeat,
+	mkdir,
+	cat,
+	find,
+	ls,
+};

package/libs/helpers.ts

@@ -0,0 +1,114 @@
+import { NodeHtmlMarkdown } from 'node-html-markdown';
+import { promises as asyncFs } from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+
+const ENV = process.env;
+
+// ------------------
+
+export function checkVarsExisting(variables: { field: any; exceptionMessage: string }[]) {
+	for (const { field, exceptionMessage } of variables) {
+		if (field === undefined) {
+			throw new Error(exceptionMessage);
+		}
+	}
+}
+
+// ------------------
+
+export function checkEnvVars(variables: string[]) {
+	for (const key of variables) {
+		if (ENV[ key ] === undefined) {
+			throw new Error(`Missed variable in ENV: ${ key }`);
+		}
+	}
+}
+
+// ------------------
+
+export function capitalizeFirstLetter(str: string) {
+	return str.replace(/^\w/, (c) => c.toUpperCase());
+}
+
+// ------------------
+
+function nlToBr(str: string) {
+	return str.replace(/\n/g, '<br>\n');
+}
+
+export function htmlToMd(html: string) {
+	return NodeHtmlMarkdown.translate(nlToBr(html));
+}
+
+// ------------------
+
+export const log = {
+	// eslint-disable-next-line no-console
+	dbg: console.log, info: console.log, error: console.error, debug: true,
+};
+
+// ------------------
+
+export function resolvePath(filepath: string) {
+	if (filepath.startsWith('~')) {
+		filepath = path.join(process.env.HOME!, filepath.slice(1));
+	}
+	return path.resolve(filepath);
+}
+
+// ------------------
+
+export function asyncSleep(sec: number, fn?: (id: NodeJS.Timeout) => void){
+	return new Promise((resolve) => {
+		const id = setTimeout(resolve, sec * 1000);
+		if (fn) {
+			fn(id);
+		}
+	});
+}
+
+// ------------------
+
+export function stripTags(html: string){
+	return nlToBr(html)
+		.replace(/<\/?([a-z][a-z0-9]*)\b[^>]*>?/gi, '').replace(/\s{2,}/g, ' ')
+		.trim()
+		.replace(/🛠/g, '')
+		.replace(/🐞/g, '');
+}
+
+// ------------------
+
+export const md5 = (contents: string) => crypto.createHash('md5').update(contents).digest('hex');
+
+// ------------------
+
+export async function objectFromIniFile(path: string): Promise<Record<string, any> | undefined>{
+	const file = await asyncFs.readFile(path, 'utf8');
+	if(!file || file === ''){
+		return undefined;
+	}
+
+	const rows = file.split('\n');
+	if(!rows || rows.length < 1){
+		return undefined;
+	}
+
+	const obj: Record<string, any> = {};
+
+	for (const row of rows) {
+		const rowParts = row.split('=');
+		if(rowParts.length !== 2){
+			continue;
+		}
+		const key = rowParts[0].trim();
+		const value = rowParts[1];
+
+		obj[ key ] = value;
+	}
+
+	return obj;
+}
+
+// ------------------

package/libs/prototype.ts

@@ -0,0 +1,313 @@
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+
+// ===========================================
+// String
+
+export interface String {
+	replaceAll(search: string, replacement: string): string;
+}
+
+Object.defineProperties(String.prototype, {
+
+	replaceAll: {
+		value(search: string, replacement: string): any {
+			const escapedSearch = search.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+			return this.replace(new RegExp(escapedSearch, 'g'), replacement);
+		},
+		enumerable : false,
+		writable : true,
+	},
+
+}
+);
+
+// ===========================================
+// Array
+
+export interface Array<T> {
+	randomElement: T;
+	delete(elm: T): T[];
+	match(str: string): boolean;
+}
+
+Object.defineProperties(Array.prototype, {
+
+	randomElement: {
+		value(): any {
+			return this[ Math.round(Math.random() * (this.length - 1)) ];
+		},
+		enumerable : false,
+		writable : true,
+	},
+
+	// ----------------------------
+
+	delete: {
+		value(elm: any): any {
+			const index = this.indexOf(elm);
+			if(index === -1){
+				return this;
+			}
+		
+			this.splice(index, 1);
+		
+			return this;
+		},
+		enumerable : false,
+		writable : true,
+	},
+
+	// ----------------------------
+
+	match: {
+		value(str: string): boolean {
+			for (const item of this) {
+				if(typeof item === 'string' && (RegExp(item).exec(str))){
+					return true;
+				}
+			}
+			return false;
+		},
+		enumerable : false,
+		writable : true,
+	},
+
+});
+
+
+// ===========================================
+// Object
+
+function isObjectDefined(obj: any): boolean {
+	return obj !== undefined && typeof(obj) === 'object' && obj !== null && (obj instanceof Date) === false && Array.isArray(obj) === false;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+interface Object {
+	copy(maxDepth?: number, excludeKeysStart?: string[]): any;
+	diff(toObj: any, excludeKeysStart?: string[]): {from?: any; to?: any} | undefined;
+	pickKeys<O>(keys: keyof O[]): Partial<O>;
+	mergeFrom(fromObj: Record<string, any>, addFromObjKeys: boolean): void;
+	isEqual(toObj: Record<string, any>): boolean;
+}
+
+Object.defineProperties(Object.prototype, {
+
+	copy: {
+		value(maxDepth?: number, excludeKeysStart?: string[]): any {
+			const maxDeep = maxDepth === undefined ? 5 : maxDepth - 1;
+			const excludeKeys = excludeKeysStart === undefined ? ['_', '$'] : excludeKeysStart;
+		
+			const objCopy: Record<any, any> = {};
+			for(const key of Object.keys(this)){
+				if(excludeKeys.includes(key[0])){
+					continue;
+				}
+				
+				const value = (this)[key];
+		
+				if (isObjectDefined(value)) {
+					objCopy[key] = (maxDeep >= 0) ? value.copy(maxDeep, excludeKeys) : {};
+				} else {
+					objCopy[key] = value;
+				}
+			}
+			return objCopy;
+		},
+		enumerable : false,
+		writable : true,
+	},
+
+
+	// ----------------------------
+
+
+	diff: {
+		value(toObj: any, excludeKeysStart?: string[]): {from?: any; to?: any} | undefined{
+			if(isObjectDefined(toObj) === false){
+				return { from: this.copy(), to: toObj};
+			}
+		
+			const excludeKeys = excludeKeysStart === undefined ? ['_', '$'] : excludeKeysStart;
+		
+			const result: Record<any, any> = {};
+		
+			const fromKeys  = Object.keys(this);
+			const toKeys    = Object.keys(toObj);
+		
+			if(fromKeys.length === toKeys.length && toKeys.length === 0){
+				return undefined;
+			}
+		
+			for (const key of toKeys) {
+			
+				const i = fromKeys.indexOf(key);
+				if(i !== -1){
+					fromKeys.splice(i, 1);
+				}
+						
+				if(excludeKeys.includes(key[0])){
+					continue;
+				}
+
+				const oldVal = (this)[ key ];
+				const newVal = toObj[ key ];
+
+
+				if(oldVal === newVal
+					|| (isObjectDefined(oldVal) && isObjectDefined(newVal) && Object.keys(oldVal).length === 0 && Object.keys(newVal).length === 0)
+					|| (oldVal instanceof Date && newVal instanceof Date && oldVal.getTime() === newVal.getTime())
+				){
+					continue;
+				}
+
+				if(oldVal === undefined || oldVal === null || oldVal === '' || isObjectDefined(oldVal) && Object.keys(oldVal).length === 0){
+					result[ key ] = { to : newVal };
+					continue;
+				}
+
+
+				if(isObjectDefined(oldVal) && isObjectDefined(newVal)){
+					const nestedResult = oldVal.diff(newVal);
+
+					if(nestedResult && Object.keys(nestedResult).length > 0){
+						result[ key ] = nestedResult;
+					}
+					continue;
+				}
+
+				result[ key ] = {
+					from : oldVal,
+					to   : newVal,
+				};
+
+			}
+		
+		
+			for (const key of fromKeys) {
+		
+				if(excludeKeys.includes(key[0])){
+					continue;
+				}
+		
+				const oldVal = (this)[ key ];
+		
+				if(oldVal !== undefined || oldVal !== null){
+					result[ key ] = {
+						from   : oldVal,
+					};
+				}
+		
+			}
+
+			return result;
+		},
+		enumerable : false,
+		writable : true,
+	},
+
+	// ----------------------------
+
+	pickKeys: {
+		value<O>(keys: keyof O[]): Partial<O> {
+			if(!Array.isArray(keys) || keys.length === 0) return {};
+
+			const obj: Partial<O> = {};
+		
+			for (const key of keys) {
+				obj[ key as keyof O ] = (this)[ key ];
+			}
+		
+			return obj;
+		},
+		enumerable : false,
+		writable : true,
+	},
+
+	// // ----------------------------
+
+	// applayObject: {
+	// 	value(fromObj: { [x: string]: any }, exeptKeys: string | string[]) {
+	// 		if(!fromObj || typeof fromObj !== 'object') return this;
+
+	// 		Object.keys(fromObj).forEach(key => {
+
+	// 			if(!exeptKeys || !Array.isArray(exeptKeys) || !exeptKeys.includes(key)){
+	// 				this[ key ] = fromObj[ key ];
+	// 			}
+
+	// 		});
+
+	// 		return this;
+
+	// 	},
+	// 	enumerable : false,
+	// 	writable : true,
+	// },
+
+	// ----------------------------
+
+	mergeFrom: {
+		value(fromObj: { [x: string]: any }, addFromObjKeys = true) {
+	
+			if(!fromObj || typeof fromObj !== 'object') return this;
+	
+			const keys = Object.keys(this);
+	
+			const fromKeys = Object.keys(fromObj);
+	
+			// Обходим те кулючи что у нас уже есть!
+			keys.forEach(key => {
+	
+				const i = fromKeys.indexOf(key);
+				if(i !== -1){
+					fromKeys.splice(i, 1);
+				}
+	
+				const fromValue = fromObj[ key ];
+				if(fromValue === undefined || fromValue === null){
+					return;
+				}
+	
+				if(typeof this[ key ] !== 'object' ||
+					typeof this[ key ] !== typeof fromValue ||
+					Array.isArray(this[ key ])){
+					this[ key ] = fromValue;
+					return;
+				}
+	
+				this[ key ].mergeFrom(fromValue);
+	
+			});
+	
+			// Добавляем те что есть только у fromObj
+			if(addFromObjKeys && fromKeys.length >0){
+	
+				fromKeys.forEach(key => {
+					this[ key ] = fromObj[ key ];
+				});
+	
+			}
+	
+			return this;
+	
+		},
+		enumerable : false,
+		writable : true,
+	},
+
+	// ----------------------------
+
+	isEqual: {
+		value(toObj: Record<string, any>): boolean{
+			const diff = this.diff(toObj);
+
+			return diff ? Object.keys(diff).length === 0 : true;
+		},
+		enumerable : false,
+		writable : true,
+	},
+
+
+});

package/package.json

@@ -7,7 +7,7 @@
       "url": "http://gitlab.soft-artel.com/sp/cluster.git"
    },
    "name": "@soft-artel/ci",
-   "version": "1.2.15",
+   "version": "1.3.15",
    "main": "sa-ci-k8s.js",
    "bin": {
       "sa-ci-k8s-build": "./k8s-build.js",

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+	"compilerOptions": {
+		"target": "es6",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019' or 'ESNEXT'. */
+		"module": "commonjs",                     /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
+		"lib": ["esnext", "DOM"],                        /* Specify library files to be included in the compilation. */
+		"allowJs": true,                          /* Allow javascript files to be compiled. */
+		"declaration": true,                      /* Generates corresponding '.d.ts' file. */
+		"declarationMap": true,                   /* Generates a sourcemap for each corresponding '.d.ts' file. */
+		"sourceMap": true,                        /* Generates corresponding '.map' file. */
+		"outDir": "_publish",                         /* Redirect output structure to the directory. */
+		"removeComments": true,                   /* Do not emit comments to output. */
+		"preserveConstEnums": true,
+		"noEmitOnError": true,                    /* Do not emit outputs if any errors were reported. */
+		"strict": true,                           /* Enable all strict type-checking options. */
+		"resolveJsonModule": true,
+		"esModuleInterop": true,                  /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+		"typeRoots": ["node_modules/@types", "../node_modules/@types"],                       /* List of folders to include type definitions from. */
+		"experimentalDecorators": true,           /* Enables experimental support for ES7 decorators. */
+		"emitDecoratorMetadata": true,            /* Enables experimental support for emitting type metadata for decorators. */
+		"forceConsistentCasingInFileNames": true,  /* Disallow inconsistently-cased references to the same file. */
+		"useUnknownInCatchVariables": false
+	},
+	"exclude": ["node_modules.", "_publish", "*.sh"]
+}

package/upd_pkg.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env ts-node
+import { promises as asyncFs } from 'fs';
+
+main();
+
+async function main() {
+
+	const pkg = JSON.parse(await asyncFs.readFile('./package.json', 'utf-8'));
+
+	let v = pkg.version;
+	const comp: string[] = v.split('.');
+	comp[ comp.length - 1 ] = `${ Number(comp[ comp.length - 1 ]) + 1 }`;
+	v = comp.join('.');
+	pkg.version = v;
+
+	await asyncFs.writeFile('./package.json',  JSON.stringify(pkg, null, 3));
+	await asyncFs.writeFile('../package.json',  JSON.stringify(pkg, null, 3)); // ts pkg
+
+	process.env.PUBLISH_VERSION = pkg.version;
+    
+}