@nu-art/build-and-install 0.400.14 → 0.401.1

package/v3/RunningStatusHandler.js

@@ -1,67 +0,0 @@
-import fs, { promises as _fs } from 'fs';
-import { __stringify, Logger } from '@nu-art/ts-common';
-export class RunningStatusHandler extends Logger {
-    isolated = false;
-    outputFolder;
-    // The completed units in the phase.. when running -con, these can be skipped
-    completedUnits = [];
-    runtimeParams;
-    startIndex = 0;
-    constructor(outputFolder, runtimeParams) {
-        super();
-        this.outputFolder = outputFolder;
-        this.runtimeParams = runtimeParams;
-    }
-    async init() {
-        if (!fs.existsSync(this.outputFolder))
-            await _fs.mkdir(this.outputFolder, { recursive: true });
-        if (this.runtimeParams.continue) {
-            const currentParams = this.runtimeParams;
-            this.startIndex = await this.load();
-            this.runtimeParams = Object.assign(currentParams, this.runtimeParams);
-        }
-    }
-    isolate() {
-        this.isolated = true;
-        return this;
-    }
-    isCompleted(unitKey) {
-        return this.completedUnits.includes(unitKey);
-    }
-    async onUnitCompleted(unitKey) {
-        this.logDebug(`On unit completed: ${unitKey}`);
-        this.completedUnits.push(unitKey);
-        await this.saveStatus();
-    }
-    async onStepEnded() {
-        this.logDebug(`On step ended successfully #${this.startIndex}`);
-        this.completedUnits = [];
-    }
-    async onStepStarted(index) {
-        this.startIndex = index;
-        this.logDebug(`Setting execution index to #${this.startIndex}`);
-        if (this.isolated)
-            return;
-        await this.saveStatus();
-    }
-    async saveStatus() {
-        await _fs.writeFile(`${this.outputFolder}/running-status.json`, __stringify({
-            index: this.startIndex,
-            runtimeParams: this.runtimeParams,
-            completedUnits: this.completedUnits
-        }, true));
-    }
-    async load() {
-        try {
-            const data = JSON.parse(await _fs.readFile(`${this.outputFolder}/running-status.json`, { encoding: 'utf-8' }));
-            this.startIndex = data.index;
-            this.completedUnits = data.completedUnits ?? [];
-            this.runtimeParams = data.runtimeParams;
-            return data.index;
-        }
-        catch (e) {
-            this.logError('Failed reading running status, using initial status', e);
-            return;
-        }
-    }
-}

package/v3/UnitsMapper/UnitsMapper.d.ts

@@ -1,21 +0,0 @@
-import { BaseUnit, ProjectUnit } from '../units/index.js';
-import { Logger } from '@nu-art/ts-common';
-import { UnitMapper_Base } from './resolvers/UnitMapper_Base.js';
-import { BaiParams } from '../../core/params/params.js';
-/**
- * This class will receive a path and will map the workspace packages and libs
- *
- * A lib will have rules to infer it, mainly from the package.json but also from existing files in the context of the node lib
- */
-export declare class UnitsMapper extends Logger {
-    private rules;
-    /**
-     * @param path - will always be a directory
-     * @param projectRoot - The path to the project root
-     * @param units - The project units derived from the file system
-     */
-    resolveUnits(path: string, projectRoot?: string, units?: BaseUnit<any>[]): Promise<BaseUnit<any, import("../units/BaseUnit.js").UnitRuntimeContext>[]>;
-    addRules<T extends BaseUnit<any>>(...rules: UnitMapper_Base<T>[]): this;
-    setRuntimeParams(runtimeParams: BaiParams): this;
-    assertUniqueKeys(units: ProjectUnit[]): void;
-}

package/v3/UnitsMapper/resolvers/UnitMapper_Base.d.ts

@@ -1,23 +0,0 @@
-import { AbsolutePath, Logger, RelativePath, StringMap, TypeValidator } from '@nu-art/ts-common';
-import { BaseUnit } from '../../units/index.js';
-import { BAI_Config } from '../../../core/types/index.js';
-import { BaiParams } from '../../../core/params/params.js';
-export type BaseUnitConfig = {
-    fullPath: AbsolutePath;
-    relativePath: RelativePath;
-    label: string;
-    key: string;
-    dependencies: StringMap;
-};
-export type UnitConfigJSON_Base = {
-    type: string;
-};
-export declare abstract class UnitMapper_Base<T extends BaseUnit<any>, ConfigJSON extends UnitConfigJSON_Base = UnitConfigJSON_Base> extends Logger {
-    protected validator: TypeValidator<ConfigJSON>;
-    protected baiConfig: BAI_Config;
-    protected runtimeParams: BaiParams;
-    protected constructor(validator: TypeValidator<ConfigJSON>);
-    setRuntimeParams(runtimeParams: BaiParams): void;
-    setConfig(config: BAI_Config): void;
-    abstract resolveUnit(path: string, root: string): Promise<T | undefined>;
-}

package/v3/UnitsMapper/resolvers/UnitMapper_Base.js

@@ -1,16 +0,0 @@
-import { Logger } from '@nu-art/ts-common';
-export class UnitMapper_Base extends Logger {
-    validator;
-    baiConfig;
-    runtimeParams;
-    constructor(validator) {
-        super();
-        this.validator = validator;
-    }
-    setRuntimeParams(runtimeParams) {
-        this.runtimeParams = runtimeParams;
-    }
-    setConfig(config) {
-        this.baiConfig = config;
-    }
-}

package/v3/UnitsMapper/resolvers/UnitMapper_FirebaseFunction.js

@@ -1,66 +0,0 @@
-import { tsValidate_OptionalArray, tsValidateAnyString, tsValidateBoolean, tsValidateDynamicObject, tsValidateOptionalAnyNumber, tsValidateOptionalAnyString, tsValidateValue } from '@nu-art/ts-common';
-import { UnitMapper_Node } from './UnitMapper_Node.js';
-import { Unit_FirebaseFunctionsApp } from '../../units/firebase/Unit_FirebaseFunctionsApp.js';
-import { resolve } from 'path';
-import { BaiParam_SetEnv } from '../../../core/params/params.js';
-const valuesValidator = {
-    defaultConfig: tsValidateOptionalAnyString,
-    envConfig: tsValidateOptionalAnyString,
-    identityAccount: tsValidateOptionalAnyString,
-    projectId: tsValidateAnyString,
-    isLocal: tsValidateBoolean(false),
-};
-export class UnitMapper_FirebaseFunction_Class extends UnitMapper_Node {
-    static tsValidator_FirebaseFunction = {
-        type: tsValidateValue(['firebase-function']),
-        ignore: tsValidate_OptionalArray(tsValidateOptionalAnyString),
-        envs: tsValidateDynamicObject(valuesValidator, tsValidateAnyString),
-        debugPort: tsValidateOptionalAnyNumber,
-        basePort: tsValidateOptionalAnyNumber,
-        sslKey: tsValidateOptionalAnyString,
-        sslCert: tsValidateOptionalAnyString,
-        ...UnitMapper_Node.tsValidator_Node,
-    };
-    constructor() {
-        super(UnitMapper_FirebaseFunction_Class.tsValidator_FirebaseFunction);
-    }
-    async resolveNodeUnit(context) {
-        const outputDir = context.packageJson.publishConfig?.directory;
-        const env = this.runtimeParams[BaiParam_SetEnv.keyName];
-        let envUnitConfig = context.packageJson.unitConfig.envs[env];
-        if (!envUnitConfig) {
-            this.logWarning(`Missing EnvConfig in unit ${context.baseConfig.key}`);
-            envUnitConfig = {
-                identityAccount: '',
-                defaultConfig: '',
-                envConfig: '',
-                projectId: '',
-                isLocal: true
-            };
-            // throw new ImplementationMissingException(`Missing configuration for env: ${env}`);
-        }
-        const envConfig = {
-            identityAccount: envUnitConfig.identityAccount,
-            defaultConfig: envUnitConfig.defaultConfig,
-            envConfig: envUnitConfig.envConfig,
-            projectId: envUnitConfig.projectId,
-            isLocal: envUnitConfig.isLocal ?? env === 'local'
-        };
-        const { type, ...unitConfig } = context.packageJson.unitConfig;
-        return new Unit_FirebaseFunctionsApp({
-            ...context.baseConfig,
-            ...Unit_FirebaseFunctionsApp.DefaultConfig_FirebaseFunction,
-            ...unitConfig,
-            envConfig,
-            isTopLevelApp: true,
-            hasSelfHotReload: unitConfig.hasSelfHotReload ?? false,
-            packageJson: context.packageJson,
-            customESLintConfig: context.customESLintConfig,
-            customTSConfig: context.customTSConfig,
-            output: resolve(context.baseConfig.fullPath, outputDir ?? Unit_FirebaseFunctionsApp.DefaultConfig_FirebaseFunction.output),
-            sslCert: resolve(context.baseConfig.fullPath, unitConfig.sslCert ?? Unit_FirebaseFunctionsApp.DefaultConfig_FirebaseFunction.sslCert),
-            sslKey: resolve(context.baseConfig.fullPath, unitConfig.sslKey ?? Unit_FirebaseFunctionsApp.DefaultConfig_FirebaseFunction.sslKey),
-        });
-    }
-}
-export const UnitMapper_FirebaseFunction = new UnitMapper_FirebaseFunction_Class();

package/v3/core/FilesCache.d.ts

@@ -1,7 +0,0 @@
-export declare const FilesCache: {
-    clear: () => {};
-    load: {
-        json: <T>(pathToFile: string) => Promise<T>;
-        text: (pathToFile: string) => Promise<string>;
-    };
-};

package/v3/core/FilesCache.js

@@ -1,33 +0,0 @@
-import { ImplementationMissingException } from '@nu-art/ts-common';
-import { promises as fs } from 'fs';
-let cachedFiles = {};
-const readFile = async (path) => {
-    try {
-        const fileStat = await fs.stat(path);
-        if (fileStat.isFile())
-            return await fs.readFile(path, 'utf-8');
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            throw new ImplementationMissingException(`file does not exist: ${path}`);
-        throw error; // rethrow other errors
-    }
-    throw new ImplementationMissingException(`expected a file at: ${path}`);
-};
-export const FilesCache = {
-    clear: () => cachedFiles = {},
-    load: {
-        json: async (pathToFile) => {
-            const json = cachedFiles[pathToFile];
-            if (!json)
-                cachedFiles[pathToFile] = Object.freeze(JSON.parse(await readFile(pathToFile)));
-            return cachedFiles[pathToFile];
-        },
-        text: async (pathToFile) => {
-            const fileContent = cachedFiles[pathToFile];
-            if (!fileContent)
-                cachedFiles[pathToFile] = await readFile(pathToFile);
-            return cachedFiles[pathToFile];
-        }
-    }
-};

package/v3/phase/types.d.ts

@@ -1,9 +0,0 @@
-import { BaiParams } from '../../core/params/params.js';
-export type Phase<PhaseMethod extends string> = {
-    key: string;
-    name: string;
-    method: PhaseMethod;
-    filter?: (params: BaiParams) => boolean;
-    terminateAfterPhase?: boolean;
-    dependencyPhase?: Phase<string>[];
-};

package/v3/units/ProjectUnit.d.ts

@@ -1,18 +0,0 @@
-import { StringMap } from '@nu-art/ts-common';
-import { BaseUnit, BaseUnit_Config, UnitRuntimeContext } from './BaseUnit.js';
-export type Config_ProjectUnit = BaseUnit_Config & {
-    relativePath: string;
-    fullPath: string;
-    dependencies: StringMap;
-};
-export type ProjectUnit_RuntimeContext = UnitRuntimeContext & {
-    parentUnit: ProjectUnit<any>;
-    childUnits: ProjectUnit[];
-};
-/**
- * Abstract class representing a Unit within a Project.
- * Extends the BaseUnit to provide additional project-specific preparation logic.
- */
-export declare abstract class ProjectUnit<C extends Config_ProjectUnit = Config_ProjectUnit> extends BaseUnit<C, ProjectUnit_RuntimeContext> {
-    constructor(config: C);
-}

package/v3/units/ProjectUnit.js

@@ -1,11 +0,0 @@
-import { BaseUnit } from './BaseUnit.js';
-/**
- * Abstract class representing a Unit within a Project.
- * Extends the BaseUnit to provide additional project-specific preparation logic.
- */
-export class ProjectUnit extends BaseUnit {
-    constructor(config) {
-        super(config);
-        this.addToClassStack(ProjectUnit);
-    }
-}

package/v3/units/Unit_NodeProject.d.ts

@@ -1,30 +0,0 @@
-import { UnitPhaseImplementor } from '../core/types.js';
-import { StringMap } from '@nu-art/ts-common/utils/types';
-import { Unit_PackageJson, Unit_PackageJson_Config } from './Unit_PackageJson.js';
-import { ProjectUnit } from './ProjectUnit.js';
-import { Phase_Install, Phase_PostPublish, Phase_Watch } from '../phase/index.js';
-type Unit_TypescriptProject_Config = Unit_PackageJson_Config & {
-    globalPackages?: StringMap;
-    isRoot: true;
-};
-export declare class Unit_NodeProject<C extends Unit_TypescriptProject_Config = Unit_TypescriptProject_Config> extends Unit_PackageJson<C> implements UnitPhaseImplementor<[Phase_Install, Phase_Watch, Phase_PostPublish]> {
-    private watcher?;
-    readonly innerUnits: Unit_PackageJson[];
-    private readonly suffixesToWatch;
-    constructor(config: Unit_NodeProject<C>['config']);
-    protected deriveDistDependencies(): StringMap;
-    assignUnit(units: ProjectUnit[]): void;
-    /**
-     * Resolve all paths to watch in all project libs
-     * @private
-     * @returns string[]
-     */
-    private prepareWatchPaths;
-    stopWatch(): Promise<void | undefined>;
-    private findUnit;
-    install(): Promise<void>;
-    watch(timeout?: number, maxTimeout?: number): Promise<void>;
-    purge(): Promise<void>;
-    postPublish(): Promise<void>;
-}
-export {};

package/v3/units/Unit_PackageJson.d.ts

@@ -1,17 +0,0 @@
-import { StringMap } from '@nu-art/ts-common';
-import { UnitPhaseImplementor } from '../core/types.js';
-import { Config_ProjectUnit, ProjectUnit } from './ProjectUnit.js';
-import { TS_PackageJSON } from '../UnitsMapper/types.js';
-import { Phase_Prepare, Phase_Purge } from '../phase/index.js';
-export type Unit_PackageJson_Config = Config_ProjectUnit & {
-    packageJson: TS_PackageJSON;
-};
-export declare class Unit_PackageJson<C extends Unit_PackageJson_Config = Unit_PackageJson_Config> extends ProjectUnit<C> implements UnitPhaseImplementor<[Phase_Purge, Phase_Prepare]> {
-    constructor(config: C);
-    protected npmCommand(command: string): string;
-    protected deriveDistDependencies(): StringMap;
-    protected deriveLibDependencies(): StringMap;
-    prepare(): Promise<void>;
-    purge(): Promise<void>;
-    protected releasePorts(allPorts: string[]): Promise<void>;
-}

package/v3/units/firebase/Unit_FirebaseFunctionsApp.d.ts

@@ -1,64 +0,0 @@
-import { UnitPhaseImplementor } from '../../core/types.js';
-import { FirebasePackageConfig } from '../../../core/types/index.js';
-import { StringMap } from '@nu-art/ts-common';
-import { Phase_Deploy, Phase_Launch } from '../../phase/index.js';
-import { Unit_TypescriptLib, Unit_TypescriptLib_Config } from '../Unit_TypescriptLib.js';
-export declare const firebaseFunctionEmulator_ErrorStrings: string[];
-export declare const firebaseFunctionEmulator_WarningStrings: string[];
-type EnvConfig = {
-    defaultConfig?: string;
-    envConfig?: string;
-    projectId: string;
-    isLocal?: boolean;
-    identityAccount?: string;
-};
-export type Unit_FirebaseFunctionsApp_Config = Unit_TypescriptLib_Config & {
-    firebaseConfig?: FirebasePackageConfig;
-    pathToFirebaseConfig: string;
-    envConfig: EnvConfig;
-    ignore?: string[];
-    debugPort: number;
-    basePort: number;
-    sslKey: string;
-    sslCert: string;
-    pathToEmulatorData: string;
-    sources?: string[];
-};
-export declare class Unit_FirebaseFunctionsApp<C extends Unit_FirebaseFunctionsApp_Config = Unit_FirebaseFunctionsApp_Config> extends Unit_TypescriptLib<C> implements UnitPhaseImplementor<[Phase_Launch, Phase_Deploy]> {
-    functions: StringMap;
-    static staggerCount: number;
-    static DefaultConfig_FirebaseFunction: {
-        pathToFirebaseConfig: string;
-        debugPort: number;
-        basePort: number;
-        sslKey: string;
-        sslCert: string;
-        output: string;
-        pathToEmulatorData: string;
-    };
-    readonly emulatorLogStrings: {
-        error: string[];
-        warning: string[];
-    };
-    constructor(config: Unit_FirebaseFunctionsApp<C>['config']);
-    protected copyPackageJSONToOutput(): Promise<void>;
-    prepare(): Promise<void>;
-    resolveConfigs(): Promise<void>;
-    compile(): Promise<void>;
-    postCompile(): Promise<void>;
-    launch(): Promise<void>;
-    releaseEmulatorPorts(): Promise<void>;
-    deploy(): Promise<void>;
-    private resolveFunctionsRC;
-    private resolveProxyFile;
-    private pathToProxy;
-    private resolveConfigDir;
-    private resolveFunctionsJSON;
-    private resolveFunctionsRuntimeConfig;
-    private createAppVersionFile;
-    protected deriveDistDependencies(): StringMap;
-    private createDependenciesDir;
-    private runProxy;
-    private runEmulator;
-}
-export {};