@byaga/cdk-patterns 0.6.1 → 0.8.0

package/src/methods/build-node-source.ts

@@ -0,0 +1,97 @@
+import * as path from 'path'
+import * as fse from "fs-extra";
+import * as fs from "fs";
+import {execSync} from "child_process";
+import {generateHash, HashResult} from "./generate-hash"
+import {getBuildDirectory, getSourceDirectory} from './get-source-directory'
+import duration from "./duration";
+import emptyDirSync from './empty-directory'
+import {IIgnoreOptions} from "./walk-directory";
+
+const distributionRoot = path.resolve(process.cwd(), "../dist")
+const hashRoot = path.join(distributionRoot, "hash")
+fse.ensureDirSync(hashRoot)
+
+export const defaultIgnore: IIgnoreOptions = {
+    included: (p: fs.Dirent): boolean => {
+        return !p.name.startsWith(".") &&
+            !p.name.endsWith(".md") &&
+            !p.name.includes(".test.") &&
+            p.name !== 'package-lock.json';
+    },
+    childrenIncluded: (p: fs.Dirent): boolean => {
+        return p.name === "node_modules";
+    }
+} as IIgnoreOptions
+
+interface IBuildOptions {
+    dir?: string,
+    ignore?: IIgnoreOptions
+}
+
+export function buildNodeSource(type: string, id: string, options: IBuildOptions = {}): {
+    buildDir: string,
+    moduleChanged: boolean,
+    packageChanged: boolean,
+    sourceChanged: boolean
+} {
+    const {dir = ''} = options
+    const ignore = {
+        ...defaultIgnore, ...options.ignore
+    }
+    const srcDir = getSourceDirectory(type, id)
+    const buildDir = getBuildDirectory(type, id)
+    const hashFilePath = path.join(hashRoot, `${type}-${id}-hash.txt`)
+
+    const folderExists = fs.existsSync(buildDir)
+    const hashFileExists = folderExists && fse.existsSync(hashFilePath)
+    const prevHash: HashResult = (hashFileExists ? fse.readJsonSync(hashFilePath) : {}) as HashResult
+    const hash: string = generateHash(srcDir, {ignore});
+    const nextHash: HashResult = JSON.parse(generateHash(srcDir, {ignore})) as HashResult;
+    const moduleChanged = JSON.stringify(prevHash, null, '\t') !== hash;
+    let packageChanged = false, sourceChanged = false;
+
+    if (moduleChanged) {
+        const prevPackageHash = findPackageHash(prevHash);
+        const packageHash = findPackageHash(nextHash);
+        packageChanged = prevPackageHash !== packageHash;
+
+        sourceChanged = sourceWasUpdated(prevHash, nextHash);
+        if (sourceChanged) {
+            const rmComplete = duration()
+            if (folderExists) emptyDirSync(buildDir, {childrenExcluded: folder => folder.name === 'node_modules'})
+            console.log('Cleanup Duration (ms)', rmComplete())
+
+            const copyComplete = duration()
+            fse.copySync(srcDir, buildDir, {
+                filter: src => !~src.indexOf("node_modules") && !src.endsWith('.test.js')
+            });
+            console.log('Copy Duration (ms)', copyComplete())
+        }
+
+        if (packageChanged) {
+            const installComplete = duration()
+            execSync("npm i --omit=dev --omit=optional --omit=peer --quite", {
+                cwd: dir ? path.resolve(buildDir, dir) : buildDir
+            });
+            console.log('NPM Install Duration (ms)', installComplete())
+        }
+        fs.writeFileSync(hashFilePath, hash);
+    }
+
+    return {buildDir, packageChanged, sourceChanged, moduleChanged}
+}
+
+function findPackageHash(hash: HashResult): string | undefined {
+    return hash?.children?.find(file => file.name === 'package.json')?.hash;
+}
+
+function sourceWasUpdated(prevHash: HashResult, nextHash: HashResult): boolean {
+    const fileCountChanged = prevHash.children?.length != nextHash.children?.length
+    const updatedItem = prevHash.children?.find(prevFile => {
+        const nextFile = nextHash.children?.find(f => f.name = prevFile.name);
+        return prevFile.name !== 'package.json' && (!nextFile || nextFile.hash !== prevFile.hash)
+    });
+
+    return fileCountChanged || !!updatedItem
+}

package/src/methods/duration.ts

@@ -0,0 +1,24 @@
+const hrDuration = () => {
+    const startTime: [number, number] = process.hrtime();
+    const onEnd = function duration(): number {
+        const hrTime:[number, number] = process.hrtime(startTime);
+        return hrTime[0] * 1000 + hrTime[1] / 1000000;
+    };
+    onEnd.time = startTime;
+
+    return onEnd;
+};
+const msDuration = () => {
+    const startTime: number = Date.now();
+    const onEnd = function duration(): number {
+        return Date.now() - startTime;
+    };
+    onEnd.time = startTime;
+
+    return onEnd;
+};
+
+// @ts-ignore
+const duration= process.hrtime ? hrDuration : msDuration
+
+export default duration

package/src/methods/empty-directory.ts

@@ -0,0 +1,19 @@
+import * as fse from "fs-extra";
+import duration from "./duration";
+import walkDirectory, {DirentExtended, IIgnoreOptions} from "./walk-directory";
+
+export default function emptyDirSync(parentFolder: string, options: IIgnoreOptions) {
+    const rmComplete = duration()
+    const files = walkDirectory(parentFolder, options);
+
+    files
+        .forEach((file:DirentExtended) => {
+            try {
+                fse.removeSync(file.fullpath());
+                console.log('Deleted file:', file.fullpath());
+            } catch (err) {
+                console.error('Error deleting file:', err);
+            }
+        });
+    console.log('Empty Directory Complete (ms)', parentFolder, rmComplete())
+}

package/src/methods/generate-hash.ts

@@ -0,0 +1,49 @@
+import * as crypto from 'crypto'
+import * as path from 'path'
+import * as fs from 'fs'
+import walk, {IIgnoreOptions} from './walk-directory'
+
+const ALGO = 'sha1';
+const ENCODING = 'base64';
+
+interface HashOptions {
+    ignore: IIgnoreOptions
+}
+
+export interface HashResult {
+    hash?: string
+    children?: HashItem[]
+}
+export interface HashItem {
+    hash: string,
+    path: string,
+    name: string
+}
+
+export function generateHash(folder: string, opt: HashOptions): string {
+    const files = walk(folder, opt.ignore);
+
+    const hash = crypto.createHash(ALGO);
+    const children = files
+        .sort((a, b) => a.fullpath().localeCompare(b.fullpath()))
+        .map((child) => {
+            const relPath = path.relative(process.cwd(), child.fullpath())
+            const fileHash = crypto.createHash(ALGO);
+            fileHash.update(relPath);
+            fileHash.update(fs.readFileSync(child.fullpath()));
+
+            const file = {
+                name: child.name,
+                path: relPath,
+                hash: fileHash.digest(ENCODING)
+            };
+            hash.update(file.hash);
+
+            return file;
+        });
+
+    return JSON.stringify({
+        hash: hash.digest(ENCODING),
+        children
+    }, null, '\t')
+}

package/src/methods/get-source-directory.ts

@@ -0,0 +1,11 @@
+import * as path from 'path'
+
+export const sourceRoot = path.resolve(process.cwd(), "../src");
+export const distributionRoot = path.resolve(process.cwd(), "../dist");
+
+export function getSourceDirectory(type: string, id: string): string {
+    return path.join(sourceRoot, type, id)
+}
+export function getBuildDirectory(type: string, id: string): string {
+    return path.join(distributionRoot, type, id)
+}

package/src/methods/walk-directory.ts

@@ -0,0 +1,30 @@
+import * as path from 'path'
+import * as fs from 'fs'
+
+export interface IIgnoreOptions {
+    excluded?: (stat: fs.Dirent) => boolean,
+    included?: (stat: fs.Dirent) => boolean,
+    childrenExcluded?: (stat: fs.Dirent) => boolean,
+    childrenIncluded?: (stat: fs.Dirent) => boolean
+}
+export const yes = () => true
+export const no = () => false
+
+export default function walkDirectory(directory: string, options: IIgnoreOptions, filepaths: DirentExtended[] = []): DirentExtended[] {
+    const { excluded = no, included = yes, childrenExcluded = no, childrenIncluded = yes} = options;
+    const files = fs.readdirSync(directory, {withFileTypes: true}) as unknown[] as DirentExtended[];
+    for (let stats of files) {
+        const filepath = path.join(directory, stats.name)
+        stats.fullpath = () => filepath
+        if (stats.isDirectory() && !childrenExcluded(stats) && childrenIncluded(stats)) {
+            walkDirectory(filepath, options, filepaths)
+        } else if (stats.isFile() && !excluded(stats) && included(stats)) {
+            filepaths.push(stats)
+        }
+    }
+    return filepaths;
+}
+
+export interface DirentExtended extends fs.Dirent {
+    fullpath: () => string
+}