@enspirit/emb 0.3.1 → 0.4.0

package/dist/src/monorepo/monorepo.js

@@ -6,11 +6,13 @@ import { MonorepoConfig } from './config.js';
 import { getPlugin } from './plugins/index.js';
 import { EMBStore } from './store/index.js';
 export class Monorepo {
+    _rootDir;
     defaultFlavor;
     _config;
     _store;
     initialized = false;
-    constructor(config, defaultFlavor = 'default') {
+    constructor(config, _rootDir, defaultFlavor = 'default') {
+        this._rootDir = _rootDir;
         this.defaultFlavor = defaultFlavor;
         this._config = new MonorepoConfig(config);
     }
@@ -27,7 +29,9 @@ export class Monorepo {
         return this._config.project.name;
     }
     get rootDir() {
-        return this._config.project.rootDir;
+        return this._config.project.rootDir
+            ? join(this._rootDir, this._config.project.rootDir)
+            : this._rootDir;
     }
     get currentFlavor() {
         return this.defaultFlavor;
@@ -104,7 +108,8 @@ export class Monorepo {
     get vars() {
         return this._config.vars;
     }
-    async expand(strOrRecord, expander = new TemplateExpander()) {
+    // Helper to expand a record of strings
+    async expand(toExpand, expander = new TemplateExpander()) {
         const options = {
             default: 'vars',
             sources: {
@@ -112,10 +117,7 @@ export class Monorepo {
                 vars: this.vars,
             },
         };
-        if (typeof strOrRecord === 'string') {
-            return expander.expand(strOrRecord, options);
-        }
-        return expander.expandRecord(strOrRecord, options);
+        return expander.expandRecord(toExpand, options);
     }
     async installStore(store) {
         this._store = store || new EMBStore(this);
@@ -157,20 +159,33 @@ export class Monorepo {
     }
     // Helper to build relative path to the root dir
     join(...paths) {
-        return join(this._config.project.rootDir, ...paths);
+        return join(this.rootDir, ...paths);
     }
     async run(operation, args) {
         return operation.run(args);
     }
+    async expandPatches(patches) {
+        const expanded = Promise.all(patches.map(async (patch) => {
+            if (!('value' in patch)) {
+                return patch;
+            }
+            return {
+                ...patch,
+                value: await this.expand(patch.value),
+            };
+        }));
+        return expanded;
+    }
     async withFlavor(flavorName) {
-        const patches = this._config.flavor(flavorName).patches || [];
+        const patches = await this.expandPatches(this._config.flavor(flavorName).patches || []);
         const original = this._config.toJSON();
         const errors = jsonpatch.validate(patches || [], original);
         if (errors) {
             throw errors;
         }
-        const withComponentPatches = this.components.reduce((config, cmp) => {
-            const componentPatches = cmp.flavor(flavorName, false)?.patches || [];
+        const withComponentPatches = await this.components.reduce(async (pConfig, cmp) => {
+            const config = await pConfig;
+            const componentPatches = await this.expandPatches(cmp.flavor(flavorName, false)?.patches || []);
             const errors = jsonpatch.validate(componentPatches || [], config.components[cmp.name]);
             if (errors) {
                 throw errors;
@@ -179,12 +194,12 @@ export class Monorepo {
                 return jsonpatch.applyReducer(doc, patch, index);
             }, config.components[cmp.name]);
             return config;
-        }, original);
+        }, Promise.resolve(original));
         const withGlobalPatches = patches.reduce((doc, patch, index) => {
             return jsonpatch.applyReducer(doc, patch, index);
         }, withComponentPatches);
         const newConfig = new MonorepoConfig(withGlobalPatches);
-        const repo = new Monorepo(newConfig, flavorName);
+        const repo = new Monorepo(newConfig, this._rootDir, flavorName);
         await repo.installStore();
         await repo.installEnv();
         return repo;

package/dist/src/monorepo/operations/shell/ExecuteLocalCommandOperation.d.ts

@@ -1,4 +1,4 @@
-import { Readable } from 'node:stream';
+import { Readable, Writable } from 'node:stream';
 import * as z from 'zod';
 import { AbstractOperation } from '../../../operations/index.js';
 /**
@@ -10,7 +10,8 @@ declare const schema: z.ZodObject<{
     workingDir: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare class ExecuteLocalCommandOperation extends AbstractOperation<typeof schema, Readable> {
-    constructor();
+    protected out: Writable;
+    constructor(out: Writable);
     protected _run(input: z.input<typeof schema>): Promise<Readable>;
 }
 export {};

package/dist/src/monorepo/operations/shell/ExecuteLocalCommandOperation.js

@@ -16,8 +16,10 @@ const schema = z.object({
         .describe('The working directory for the exec process inside the container'),
 });
 export class ExecuteLocalCommandOperation extends AbstractOperation {
-    constructor() {
+    out;
+    constructor(out) {
         super(schema);
+        this.out = out;
     }
     async _run(input) {
         const process = execa(input.script, {
@@ -25,6 +27,7 @@ export class ExecuteLocalCommandOperation extends AbstractOperation {
             cwd: input.workingDir,
             shell: true,
         });
+        process.all.pipe(this.out);
         return process.all;
     }
 }

package/dist/src/monorepo/operations/tasks/RunTasksOperation.d.ts

@@ -16,5 +16,5 @@ export type TaskWithScript = TaskInfo & {
 export declare class RunTasksOperation implements IOperation<RunTasksOperationParams, Array<TaskInfo>> {
     run(params: RunTasksOperationParams): Promise<Array<TaskInfo>>;
     protected runDocker(task: TaskWithScript, out?: Writable): Promise<void>;
-    protected runLocal(task: TaskWithScript): Promise<import("stream").Readable>;
+    protected runLocal(task: TaskWithScript, out: Writable): Promise<import("stream").Readable>;
 }

package/dist/src/monorepo/operations/tasks/RunTasksOperation.js

@@ -1,4 +1,5 @@
 import { getContext } from '../../../index.js';
+import { PassThrough } from 'node:stream';
 import { ComposeExecOperation } from '../../../docker/index.js';
 import { EMBCollection, findRunOrder, taskManagerFactory, } from '../../index.js';
 import { ExecuteLocalCommandOperation } from '../index.js';
@@ -33,12 +34,16 @@ export class RunTasksOperation {
                     if (executor === ExecutorType.container && !task.component) {
                         throw new Error('Cannot use the container executor with global tasks');
                     }
+                    const tee = new PassThrough();
+                    const logFile = await monorepo.store.createWriteStream(`logs/tasks/${task.id}.logs`);
+                    tee.pipe(listrTask.stdout());
+                    tee.pipe(logFile);
                     switch (executor) {
                         case ExecutorType.container: {
-                            return this.runDocker(task, listrTask.stdout());
+                            return this.runDocker(task, tee);
                         }
                         case ExecutorType.local: {
-                            return this.runLocal(task);
+                            return this.runLocal(task, tee);
                         }
                         default: {
                             throw new Error(`Unssuported executor type: ${executor}`);
@@ -60,12 +65,12 @@ export class RunTasksOperation {
             command: task.script,
         });
     }
-    async runLocal(task) {
+    async runLocal(task, out) {
         const { monorepo } = getContext();
         const cwd = task.component
             ? monorepo.join(monorepo.component(task.component).rootDir)
             : monorepo.rootDir;
-        return monorepo.run(new ExecuteLocalCommandOperation(), {
+        return monorepo.run(new ExecuteLocalCommandOperation(out), {
             script: task.script,
             workingDir: cwd,
         });

package/dist/src/monorepo/plugins/AutoDockerPlugin.js

@@ -19,7 +19,7 @@ export class AutoDockerPlugin extends AbstractPlugin {
     async extendConfig(config) {
         const files = await glob(this.config.glob || AutoDockerPluginDefaultOptions.glob, {
             ...this.config,
-            cwd: config.project.rootDir,
+            cwd: this.monorepo.rootDir,
         });
         const overrides = files.reduce((cmps, path) => {
             const name = dirname(path);

package/dist/src/monorepo/plugins/EmbfileLoaderPlugin.js

@@ -23,13 +23,13 @@ export class EmbfileLoaderPlugin extends AbstractPlugin {
     async extendConfig(config) {
         const files = await glob(this.config.glob, {
             ...this.config,
-            cwd: config.project.rootDir,
+            cwd: this.monorepo.rootDir,
         });
         const newConfig = await files.reduce(async (pConfig, path) => {
             const config = await pConfig;
             const rootDir = dirname(path);
             const name = basename(rootDir);
-            const embfile = await join(config.project.rootDir, path);
+            const embfile = await join(this.monorepo.rootDir, path);
             const component = await validateEmbfile(embfile);
             const original = config.components[name];
             const newComponent = deepmerge()(original || {}, {

package/dist/src/utils/TemplateExpander.d.ts

@@ -7,16 +7,19 @@ export type ExpansionHistory = {
     value: unknown;
     variable: string;
 };
+export type Expandable = readonly Expandable[] | string | {
+    readonly [k: string]: Expandable;
+};
+type ExpandResult<T> = T extends string ? string : T extends readonly (infer U)[] ? ReadonlyArray<ExpandResult<U>> : T extends {
+    readonly [K in keyof T]: Expandable;
+} ? {
+    readonly [K in keyof T]: ExpandResult<T[K]>;
+} : T;
 export declare class TemplateExpander {
-    /**
-     * Keep track of the sources used for expansions
-     * (track source, name, final value)
-     */
     private expansions;
     get expansionCount(): number;
     expand(str: string, options?: ExpandOptions): Promise<string>;
-    expandRecord<R extends Record<string, unknown>>(record: R, options: ExpandOptions): Promise<R>;
-    expandRecord<R extends Array<unknown>>(record: R, options: ExpandOptions): Promise<R>;
+    expandRecord<T extends Expandable>(record: T, options: ExpandOptions): Promise<ExpandResult<T>>;
     private track;
 }
 export {};

package/dist/src/utils/TemplateExpander.js

@@ -1,19 +1,14 @@
 const TPL_REGEX = /(?<!\\)\${(?:(\w+):)?(\w+)(?::-(.*?))?}/g;
 export class TemplateExpander {
-    /**
-     * Keep track of the sources used for expansions
-     * (track source, name, final value)
-     */
     expansions = [];
     get expansionCount() {
         return this.expansions.length;
     }
     async expand(str, options = {}) {
-        return ((str || '')
+        return (str || '')
             .toString()
-            // Expand variables
             .replaceAll(TPL_REGEX, (match, source, key, fallback) => {
-            const src = source || options.default;
+            const src = source ?? options.default ?? '';
             const provider = options.sources?.[src];
             if (!provider) {
                 if (fallback !== undefined) {
@@ -22,34 +17,33 @@ export class TemplateExpander {
                 throw new Error(`Invalid expand provider '${source}' ('${match}')`);
             }
             const val = provider[key];
-            // fallback is undefined when not even the :- is present
-            // we consider a variable like ${source:key:-} like the information
-            // that the variable can be an empty string if not present
             if (!val && fallback === undefined) {
                 throw new Error(`Could not expand '${match}' and no default value provided`);
             }
             if (val !== undefined && val !== null) {
                 return this.track(src, key, val);
             }
-            return this.track(src, key, fallback || '');
+            return this.track(src, key, fallback ?? '');
         })
-            // Unescape non-variables left
-            .replaceAll('\\${', '${'));
+            .replaceAll('\\${', '${');
     }
-    async expandRecord(record, options = {}) {
+    async expandRecord(record, options) {
+        if (typeof record === 'string') {
+            const out = await this.expand(record, options);
+            return out;
+        }
         if (Array.isArray(record)) {
-            return Promise.all(record.map((v) => this.expand(v, options)));
+            const out = await Promise.all(record.map((v) => this.expandRecord(v, options)));
+            return out;
         }
-        return Object.entries(record).reduce(async (vars, [name, str]) => {
-            const previous = await vars;
-            previous[name] = await (typeof str === 'object'
-                ? this.expandRecord(str, options)
-                : this.expand(str, options));
-            return previous;
-        }, Promise.resolve({}));
+        const entries = await Promise.all(Object.entries(record).map(async ([k, v]) => {
+            const expandedValue = await this.expandRecord(v, options);
+            return [k, expandedValue];
+        }));
+        return Object.fromEntries(entries);
     }
     track(source, variable, value) {
         this.expansions.push({ source, value, variable });
-        return value;
+        return String(value);
     }
 }