@nu-art/build-and-install 0.203.117

package/core/types/package/runtime-package.d.ts

@@ -0,0 +1,11 @@
+import { PackageJson } from '../configs';
+import { Package, Package_Sourceless } from './package';
+type WithPackageJson = {
+    packageJsonTemplate: PackageJson;
+    packageJsonWorkspace?: PackageJson;
+    packageJsonOutput?: PackageJson;
+    packageJsonRuntime?: PackageJson;
+};
+export type RuntimePackage = Required<Package> & WithPackageJson;
+export type RuntimePackage_WithOutput = Required<Exclude<Package, Package_Sourceless>> & WithPackageJson;
+export {};

package/core/types/package/runtime-package.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/types/project-config.d.ts

@@ -0,0 +1,15 @@
+import { StringMap } from '@nu-art/ts-common';
+import { Package, RuntimePackage } from './package';
+export type ProjectConfig = {
+    params: StringMap;
+    packages: Package[];
+};
+export type RuntimeProjectConfig = {
+    packages: Package[];
+    params: StringMap;
+    packagesDependency?: RuntimePackage[][];
+    packageMap?: {
+        [packageName: string]: RuntimePackage;
+    };
+};
+export type Constructor<T> = new (...args: any) => T;

package/core/types/project-config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/logic/ProjectManager.d.ts

@@ -0,0 +1,38 @@
+import { ProjectConfig, RuntimePackage, RuntimePackage_WithOutput } from '../core/types';
+import { Logger } from '@nu-art/ts-common';
+export declare const PackageBuildPhaseType_Package: "package";
+export declare const PackageBuildPhaseType_PackageWithOutput: "package-with-output";
+export declare const PackageBuildPhaseType_Project: "project";
+type BuildPhase_Base = {
+    name: string;
+    terminatingPhase?: boolean;
+    mandatoryPhases?: BuildPhase[];
+};
+type BuildPhase_Package = BuildPhase_Base & {
+    type: typeof PackageBuildPhaseType_Package;
+    action: (pkg: RuntimePackage) => Promise<any>;
+    filter?: (pkg: RuntimePackage) => Promise<boolean>;
+};
+type BuildPhase_PackageWithOutput = BuildPhase_Base & {
+    type: typeof PackageBuildPhaseType_PackageWithOutput;
+    action: (pkg: RuntimePackage_WithOutput) => Promise<any>;
+    filter?: (pkg: RuntimePackage_WithOutput) => Promise<boolean>;
+};
+type BuildPhase_Project = BuildPhase_Base & {
+    type: 'project';
+    action: () => Promise<any>;
+    filter?: () => Promise<boolean>;
+};
+export type BuildPhase = BuildPhase_Package | BuildPhase_PackageWithOutput | BuildPhase_Project;
+export declare class ProjectManager extends Logger {
+    private phases;
+    private config;
+    constructor(config: ProjectConfig);
+    registerPhase(phase: BuildPhase): void;
+    execute(phasesToRun?: BuildPhase[]): Promise<void>;
+    private resolveAllMandatoryPhases;
+    runPhaseByKey(phaseKey: string): Promise<void>;
+    private getPackagesForPhaseType;
+    private runPhase;
+}
+export {};

package/logic/ProjectManager.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectManager = exports.PackageBuildPhaseType_Project = exports.PackageBuildPhaseType_PackageWithOutput = exports.PackageBuildPhaseType_Package = void 0;
+const types_1 = require("../core/types");
+const ts_common_1 = require("@nu-art/ts-common");
+exports.PackageBuildPhaseType_Package = 'package';
+exports.PackageBuildPhaseType_PackageWithOutput = 'package-with-output';
+exports.PackageBuildPhaseType_Project = 'project';
+const PackageBuildPhaseTypes = [exports.PackageBuildPhaseType_Package, exports.PackageBuildPhaseType_PackageWithOutput, exports.PackageBuildPhaseType_Project];
+class ProjectManager extends ts_common_1.Logger {
+    constructor(config) {
+        super();
+        this.phases = [];
+        this.getPackagesForPhaseType = (phaseType) => {
+            var _a;
+            const allRuntimePackages = [];
+            (_a = this.config.packagesDependency) === null || _a === void 0 ? void 0 : _a.forEach(dependency => dependency.forEach(_package => allRuntimePackages.push(_package)));
+            switch (phaseType) {
+                case exports.PackageBuildPhaseType_Project:
+                    return [];
+                case exports.PackageBuildPhaseType_Package:
+                    return allRuntimePackages;
+                case exports.PackageBuildPhaseType_PackageWithOutput:
+                    return allRuntimePackages.filter(_package => {
+                        const packageType = _package.type;
+                        return types_1.PackageTypesWithOutput.includes(packageType);
+                    });
+                default:
+                    return allRuntimePackages;
+            }
+        };
+        this.config = config;
+        ts_common_1.BeLogged.addClient(ts_common_1.LogClient_Terminal);
+        this.setMinLevel(ts_common_1.LogLevel.Verbose);
+    }
+    registerPhase(phase) {
+        this.phases.push(phase);
+    }
+    async execute(phasesToRun) {
+        for (const phase of (phasesToRun !== null && phasesToRun !== void 0 ? phasesToRun : this.phases)) {
+            const didRun = await this.runPhase(phase);
+            //terminate execution if phase is terminating
+            if (didRun && phase.terminatingPhase)
+                break;
+        }
+    }
+    resolveAllMandatoryPhases(phase) {
+        let result = [phase];
+        if (phase.mandatoryPhases) {
+            for (const childPhase of phase.mandatoryPhases) {
+                result = result.concat(this.resolveAllMandatoryPhases(childPhase));
+            }
+        }
+        return (0, ts_common_1.filterDuplicates)(result, result => result.name);
+    }
+    async runPhaseByKey(phaseKey) {
+        const phase = this.phases.find(phase => phase.name === phaseKey);
+        if (!phase)
+            return;
+        const finalPhasesToRun = this.resolveAllMandatoryPhases(phase).reverse();
+        return this.execute(finalPhasesToRun);
+    }
+    async runPhase(phase) {
+        var _a;
+        if (phase.type === exports.PackageBuildPhaseType_Project) {
+            if (!phase.filter || await phase.filter()) {
+                this.logInfo(`Running project phase: ${phase.name}`);
+                await phase.action();
+                return true;
+            }
+            this.logVerbose(`Skipping project phase: ${phase.name}`);
+            return false;
+        }
+        const relevantPackages = this.getPackagesForPhaseType(phase.type);
+        if (relevantPackages.length === 0)
+            return false;
+        let didPrint = false;
+        let didRun = false;
+        for (const packages of (_a = this.config.packagesDependency) !== null && _a !== void 0 ? _a : []) {
+            const packagesToCheck = packages.filter(pkg => relevantPackages.includes(pkg));
+            const filteredPackages = (0, ts_common_1.filterInstances)(await Promise.all(packagesToCheck.map(async (pkg) => {
+                if (!phase.filter || await phase.filter(pkg))
+                    return pkg;
+            })));
+            const finalPackages = filteredPackages.filter(pkg => pkg);
+            if (finalPackages.length === 0)
+                continue;
+            if (!didPrint) {
+                this.logInfo(`Running phase: ${phase.name}`);
+                didPrint = true;
+            }
+            if (finalPackages.length === 1)
+                this.logDebug(`  Package: ${packagesToCheck.map(pkg => pkg.name)[0]}`);
+            else
+                this.logDebug(`  Packages: ${JSON.stringify(packagesToCheck.map(pkg => pkg.name))}`);
+            const errors = await Promise.all(finalPackages.map(async (pkg) => {
+                try {
+                    await phase.action(pkg);
+                    didRun = true;
+                }
+                catch (e) {
+                    return e;
+                }
+            }));
+            if ((0, ts_common_1.filterInstances)(errors).length > 0) {
+                errors.forEach((error, index) => {
+                    var _a, _b, _c, _d;
+                    if (!error)
+                        return;
+                    this.logError(`\nError in package: ${(_a = packages[index].packageJsonTemplate) === null || _a === void 0 ? void 0 : _a.name}`);
+                    if ((_b = error.stdout) === null || _b === void 0 ? void 0 : _b.length)
+                        this.logVerbose(error.stdout);
+                    if ((_c = error.stderr) === null || _c === void 0 ? void 0 : _c.length)
+                        this.logVerboseBold(error.stderr);
+                    else if ((_d = error.message) === null || _d === void 0 ? void 0 : _d.length)
+                        this.logError(error.message);
+                });
+                throw new Error(`${(0, ts_common_1.filterInstances)(errors).length} Errors in phase "${phase.name}"`);
+            }
+        }
+        return didRun;
+        // throw new Error(`Unknown phase type '${JSON.stringify(phase)}'`);
+    }
+}
+exports.ProjectManager = ProjectManager;

package/logic/map-project-packages.d.ts

@@ -0,0 +1,4 @@
+import { Package, PackageJson, ProjectConfig, RuntimePackage, RuntimeProjectConfig } from '../core/types';
+export declare function convertPackageJSONTemplateToPackJSON_Value(template: PackageJson, value: (value: string, key?: string) => string): PackageJson;
+export declare function convertToRuntimePackage(basePackage: Package, project: ProjectConfig): RuntimePackage;
+export declare function mapProjectPackages(projectConfig: ProjectConfig): RuntimeProjectConfig;

package/logic/map-project-packages.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapProjectPackages = exports.convertToRuntimePackage = exports.convertPackageJSONTemplateToPackJSON_Value = void 0;
+const consts_1 = require("../core/consts");
+const fs_1 = require("fs");
+const types_1 = require("../core/types");
+const ts_common_1 = require("@nu-art/ts-common");
+const tools_1 = require("@nu-art/commando/core/tools");
+function getRuntimePackageBaseDetails_Sourceless(basePackage) {
+    return {
+        name: basePackage.name,
+        path: (0, tools_1.convertToFullPath)(basePackage.path),
+        type: basePackage.type,
+    };
+}
+function getRuntimePackageBaseDetails_Lib(basePackage) {
+    var _a, _b;
+    const packageRoot = (0, tools_1.convertToFullPath)(basePackage.path);
+    return {
+        name: basePackage.name,
+        path: packageRoot,
+        type: basePackage.type,
+        output: (0, tools_1.convertToFullPath)(basePackage.output, packageRoot),
+        customTsConfig: (_a = basePackage.customTsConfig) !== null && _a !== void 0 ? _a : false,
+        sources: (_b = basePackage.sources) !== null && _b !== void 0 ? _b : []
+    };
+}
+function getRuntimePackageBaseDetails_Firebase(basePackage) {
+    var _a, _b, _c;
+    const packageRoot = (0, tools_1.convertToFullPath)(basePackage.path);
+    return {
+        name: basePackage.name,
+        path: packageRoot,
+        type: basePackage.type,
+        output: (0, tools_1.convertToFullPath)(basePackage.output, packageRoot),
+        customTsConfig: (_a = basePackage.customTsConfig) !== null && _a !== void 0 ? _a : false,
+        sources: (_b = basePackage.sources) !== null && _b !== void 0 ? _b : [],
+        envConfig: (_c = basePackage.envConfig) !== null && _c !== void 0 ? _c : {},
+    };
+}
+function getRuntimePackageBaseDetails(basePackage) {
+    switch (basePackage.type) {
+        case types_1.PackageType_Sourceless:
+            return getRuntimePackageBaseDetails_Sourceless(basePackage);
+        case types_1.PackageType_ProjectLib:
+        case types_1.PackageType_InfraLib:
+            return getRuntimePackageBaseDetails_Lib(basePackage);
+        case types_1.PackageType_FirebaseFunctionsApp:
+        case types_1.PackageType_FirebaseHostingApp:
+            return getRuntimePackageBaseDetails_Firebase(basePackage);
+    }
+}
+function convertPackageJSONTemplateToPackJSON_Value(template, value) {
+    let workspacePackageJsonAsString = (0, ts_common_1.__stringify)(template, true);
+    let match = null;
+    do {
+        match = workspacePackageJsonAsString.match(/"(.*?)": ?"\$([A-Z_]+?)"/);
+        if (match === null || match === void 0 ? void 0 : match[0])
+            workspacePackageJsonAsString = workspacePackageJsonAsString.replace(new RegExp(`\\$${match[2]}`), value(match[2], match[1]));
+    } while (match);
+    const packageJson = JSON.parse(workspacePackageJsonAsString);
+    return packageJson;
+}
+exports.convertPackageJSONTemplateToPackJSON_Value = convertPackageJSONTemplateToPackJSON_Value;
+function convertToRuntimePackage(basePackage, project) {
+    const runtimePackage = getRuntimePackageBaseDetails(basePackage);
+    //Get template package json
+    if (!(0, fs_1.existsSync)(runtimePackage.path))
+        throw new Error(`package: ${runtimePackage.path} is missing the ${consts_1.CONST_PackageJSONTemplate} files`);
+    const pjTemplate = JSON.parse((0, fs_1.readFileSync)(`${runtimePackage.path}/${consts_1.CONST_PackageJSONTemplate}`, 'utf-8'));
+    return Object.assign(Object.assign({}, runtimePackage), { packageJsonTemplate: pjTemplate });
+}
+exports.convertToRuntimePackage = convertToRuntimePackage;
+function mapProjectPackages(projectConfig) {
+    const packages = projectConfig.packages.map(basePackage => convertToRuntimePackage(basePackage, projectConfig));
+    const packagesDependency = groupPackagesByDependencyLevel(packages);
+    return Object.assign(Object.assign({}, projectConfig), { packages,
+        packagesDependency, packageMap: (0, ts_common_1.arrayToMap)(packages, p => p.packageJsonTemplate.name) });
+}
+exports.mapProjectPackages = mapProjectPackages;
+function groupPackagesByDependencyLevel(packages) {
+    const packageNames = packages.map(p => p.packageJsonTemplate.name);
+    const packagesConfigWithDependencies = packages
+        .map(_package => {
+        const packageDependencies = packageNames.filter(name => { var _a; return (_a = _package.packageJsonTemplate.dependencies) === null || _a === void 0 ? void 0 : _a[name]; });
+        return Object.assign({ packageDependencies }, _package);
+    });
+    // Map to keep track of each package's level
+    const levels = new Map();
+    // Function to recursively find the level of a package
+    function findLevel(pkgName, visited = new Set()) {
+        if (visited.has(pkgName)) {
+            throw new Error(`Circular dependency detected for package ${pkgName}`);
+        }
+        visited.add(pkgName);
+        const pkg = packagesConfigWithDependencies.find(p => p.packageJsonTemplate.name === pkgName);
+        if (!pkg)
+            throw new Error(`Package ${pkgName} not found`);
+        // A package with no dependencies is at level 0
+        if (pkg.packageDependencies.length === 0)
+            return 0;
+        // Find the maximum level among dependencies
+        const maxDependencyLevel = Math.max(...pkg.packageDependencies.map(dep => findLevel(dep, new Set(visited))));
+        return 1 + maxDependencyLevel;
+    }
+    // Determine the level of each package
+    packagesConfigWithDependencies.forEach(pkg => {
+        const level = findLevel(pkg.packageJsonTemplate.name);
+        levels.set(pkg.packageJsonTemplate.name, level);
+    });
+    // Group packages by their level
+    const groupedPackages = new Map();
+    levels.forEach((level, pkgName) => {
+        const pkg = packages.find(p => p.packageJsonTemplate.name === pkgName);
+        if (pkg) {
+            if (!groupedPackages.has(level)) {
+                groupedPackages.set(level, []);
+            }
+            groupedPackages.get(level).push(pkg);
+        }
+    });
+    // Sort and convert the grouped packages into a sorted array of arrays
+    const sortedLevels = Array.from(groupedPackages.keys()).sort((a, b) => a - b);
+    return sortedLevels.map(level => groupedPackages.get(level));
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@nu-art/build-and-install",
+  "version": "0.203.117",
+  "description": "",
+  "keywords": [
+    "TacB0sS",
+    "infra",
+    "nu-art",
+    "commando"
+  ],
+  "homepage": "https://github.com/nu-art-js/thunderstorm",
+  "bugs": {
+    "url": "https://github.com/nu-art-js/thunderstorm/issues"
+  },
+  "publishConfig": {
+    "directory": "dist",
+    "linkDirectory": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com:nu-art-js/thunderstorm.git"
+  },
+  "license": "Apache-2.0",
+  "author": "TacB0sS",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "**/*"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "chokidar": "^3.6.0",
+    "@nu-art/ts-common": "0.203.117",
+    "@nu-art/commando": "0.203.117"
+  },
+  "devDependencies": {
+    "@types/node": "^18.0.0"
+  }
+}

package/phases/phases.d.ts

@@ -0,0 +1,24 @@
+import { BuildPhase } from '../logic/ProjectManager';
+export declare const projectPackages: import("../core/types").RuntimeProjectConfig;
+export declare const Phase_PrintHelp: BuildPhase;
+export declare const Phase_SetWithThunderstorm: BuildPhase;
+export declare const Phase_SetupProject: BuildPhase;
+export declare const Phase_ResolveTemplate: BuildPhase;
+export declare const Phase_ResolveEnv: BuildPhase;
+export declare const Phase_ResolvePackages: BuildPhase;
+export declare const Phase_InstallNvm: BuildPhase;
+export declare const Phase_PrintDependencyTree: BuildPhase;
+export declare const Phase_CheckCyclicImports: BuildPhase;
+export declare const Phase_PrintEnv: BuildPhase;
+export declare const Phase_PackagePurge: BuildPhase;
+export declare const Phase_InstallGlobals: BuildPhase;
+export declare const Phase_InstallPnpm: BuildPhase;
+export declare const Phase_InstallPackages: BuildPhase;
+export declare const Phase_Clean: BuildPhase;
+export declare const Phase_Lint: BuildPhase;
+export declare const Phase_Debug: BuildPhase;
+export declare const Phase_Compile: BuildPhase;
+export declare const Phase_CompileWatch: BuildPhase;
+export declare const Phase_Launch: BuildPhase;
+export declare const Phase_DeployFrontend: BuildPhase;
+export declare const Phase_DeployBackend: BuildPhase;