@enspirit/emb 0.5.2 → 0.6.0

package/dist/src/docker/operations/containers/ContainerExecOperation.js

@@ -4,21 +4,6 @@ import { AbstractOperation } from '../../../operations/index.js';
  * https://docs.docker.com/reference/api/engine/version/v1.37/#tag/Exec/operation/ContainerExec
  */
 const schema = z.object({
-    attachStderr: z
-        .boolean()
-        .default(false)
-        .optional()
-        .describe('Attach to `stderr` of the exec command.'),
-    attachStdin: z
-        .boolean()
-        .default(false)
-        .optional()
-        .describe('Attach to `stdin` of the exec command.'),
-    attachStdout: z
-        .boolean()
-        .default(false)
-        .optional()
-        .describe('Attach to `stdout` of the exec command.'),
     container: z.string().describe('ID or name of the container'),
     env: z
         .record(z.string(), z.string())
@@ -43,9 +28,8 @@ export class ContainerExecOperation extends AbstractOperation {
             return [...arr, `${key}=${value}`];
         }, []);
         const options = {
-            AttachStderr: input.attachStderr,
-            AttachStdin: input.attachStdin,
-            AttachStdout: input.attachStdout,
+            AttachStderr: true,
+            AttachStdout: true,
             Cmd: ['bash', '-eu', '-o', 'pipefail', '-c', input.script],
             Env: envVars,
             Tty: input.tty,
@@ -53,7 +37,7 @@ export class ContainerExecOperation extends AbstractOperation {
         };
         const exec = await container.exec(options);
         const stream = await exec.start({});
-        container.modem.demuxStream(stream, this.out || process.stdout, this.out || process.stderr);
+        exec.modem.demuxStream(stream, this.out || process.stdout, this.out || process.stderr);
         await new Promise((resolve, reject) => {
             const onError = (err) => reject(err);
             const onEnd = async () => {

package/dist/src/docker/operations/images/PushImagesOperation.d.ts

@@ -1,3 +1,4 @@
+import { Writable } from 'node:stream';
 import * as z from 'zod';
 import { AbstractOperation } from '../../../operations/index.js';
 /**
@@ -5,10 +6,15 @@ import { AbstractOperation } from '../../../operations/index.js';
  */
 declare const schema: z.ZodObject<{
     images: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    tag: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    tag: z.ZodOptional<z.ZodString>;
+    registry: z.ZodOptional<z.ZodString>;
+    retag: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare class PushImagesOperation extends AbstractOperation<typeof schema, void> {
-    constructor();
-    protected _run(_input: z.input<typeof schema>): Promise<void>;
+    protected out?: Writable | undefined;
+    constructor(out?: Writable | undefined);
+    protected _run(input: z.input<typeof schema>): Promise<void>;
+    private retagIfNecessary;
+    private pushImage;
 }
 export {};

package/dist/src/docker/operations/images/PushImagesOperation.js

@@ -1,4 +1,8 @@
+import { taskManagerFactory } from '../../../index.js';
+import { join } from 'node:path/posix';
+import { Transform } from 'node:stream';
 import * as z from 'zod';
+import { ResourceFactory } from '../../../monorepo/resources/ResourceFactory.js';
 import { AbstractOperation } from '../../../operations/index.js';
 /**
  * https://docs.docker.com/reference/api/engine/version/v1.37/#tag/Image/operation/ImagePush
@@ -7,16 +11,110 @@ const schema = z.object({
     images: z
         .array(z.string())
         .optional()
-        .describe('The names of images to push (The name should be provided without tag. Use the `tag` parameter to specify why tag to push)'),
-    tag: z
+        .describe('The names of images to push (The name should be provided without tag. Use the `tag` parameter to specify which tag to push)'),
+    tag: z.string().optional().describe('Tag of the images to push'),
+    registry: z.string().optional().describe('Override the registry to push to'),
+    retag: z
         .string()
         .optional()
-        .default('latest')
-        .describe('Tag of the images to push'),
+        .describe('Override the original tag to push as a new tag'),
 });
 export class PushImagesOperation extends AbstractOperation {
-    constructor() {
+    out;
+    constructor(out) {
         super(schema);
+        this.out = out;
+    }
+    async _run(input) {
+        const { monorepo } = this.context;
+        const references = await Promise.all(monorepo.resources
+            .filter((r) => r.type === 'docker/image')
+            .map(async (config) => {
+            const component = monorepo.component(config.component);
+            const builder = ResourceFactory.factor(config.type, {
+                config,
+                monorepo,
+                component,
+            });
+            return builder.getReference();
+        }));
+        const manager = taskManagerFactory();
+        const tasks = references.map((fullName) => {
+            return {
+                title: `Push ${fullName}`,
+                task: async (ctx, task) => {
+                    const { imgName, tag } = await this.retagIfNecessary(fullName, input.retag, input.registry);
+                    task.title = `Pushing ${imgName}:${tag}`;
+                    return this.pushImage(imgName, tag, task.stdout());
+                },
+            };
+        });
+        return manager.run([
+            {
+                title: 'Push imags',
+                async task(ctx, task) {
+                    return task.newListr(tasks, {
+                        rendererOptions: {
+                            collapseSubtasks: false,
+                            collapseSkips: true,
+                        },
+                    });
+                },
+            },
+        ]);
+    }
+    async retagIfNecessary(fullName, retag, registry) {
+        let [imgName, tag] = fullName.split(':');
+        // Retag if necessary
+        if (retag || registry) {
+            const dockerImage = await this.context.docker.getImage(fullName);
+            tag = retag || tag;
+            imgName = registry ? join(registry, imgName) : imgName;
+            await dockerImage.tag({
+                tag,
+                repo: imgName,
+            });
+        }
+        return { imgName, tag };
+    }
+    async pushImage(repo, tag, out) {
+        const dockerImage = await this.context.docker.getImage(`${repo}:${tag}`);
+        const stream = await dockerImage.push({
+            authconfig: {
+                username: process.env.DOCKER_USERNAME,
+                password: process.env.DOCKER_PASSWORD,
+            },
+        });
+        const transform = new Transform({
+            transform(chunk, encoding, callback) {
+                const lines = chunk.toString().split('\n');
+                lines.forEach((line) => {
+                    if (!line.trim()) {
+                        return;
+                    }
+                    try {
+                        const { status } = JSON.parse(line.trim());
+                        out?.write(status + '\n');
+                    }
+                    catch (error) {
+                        out?.write(error + '\n');
+                    }
+                });
+                callback();
+            },
+        });
+        stream.pipe(transform).pipe(process.stdout);
+        await new Promise((resolve, reject) => {
+            this.context.docker.modem.followProgress(stream, (err, data) => {
+                if (err) {
+                    return reject(err);
+                }
+                const hasError = data.find((d) => Boolean(d.error));
+                if (hasError) {
+                    return reject(new Error(hasError.error));
+                }
+                resolve(null);
+            });
+        });
     }
-    async _run(_input) { }
 }

package/dist/src/docker/resources/DockerImageResource.js

@@ -18,6 +18,14 @@ class DockerImageResourceBuilder extends SentinelFileBasedBuilder {
                 : buildContext.component.join(this.config.context)
             : buildContext.monorepo.join(buildContext.component.rootDir);
     }
+    async getReference() {
+        const imageName = [
+            this.monorepo.name,
+            this.config?.tag || this.component.name,
+        ].join('/');
+        const tagName = this.config?.tag || this.monorepo.defaults.docker?.tag || 'latest';
+        return this.monorepo.expand(`${imageName}:${tagName}`);
+    }
     get monorepo() {
         return this.buildContext.monorepo;
     }
@@ -30,11 +38,6 @@ class DockerImageResourceBuilder extends SentinelFileBasedBuilder {
     async _build(_resource, out) {
         // Ensure the folder exists
         await statfs(this.dockerContext);
-        const imageName = [
-            this.monorepo.name,
-            this.config?.tag || this.component.name,
-        ].join('/');
-        const tagName = this.config?.tag || this.monorepo.defaults.docker?.tag || 'latest';
         const crawler = new Fdir();
         const sources = await crawler
             .withRelativePaths()
@@ -48,7 +51,7 @@ class DockerImageResourceBuilder extends SentinelFileBasedBuilder {
                 ...this.monorepo.defaults.docker?.buildArgs,
                 ...this.config?.buildArgs,
             }),
-            tag: await this.monorepo.expand(`${imageName}:${tagName}`),
+            tag: await this.getReference(),
             labels: await this.monorepo.expand({
                 ...this.config?.labels,
                 'emb/project': this.monorepo.name,

package/dist/src/monorepo/component.d.ts

@@ -15,4 +15,5 @@ export declare class Component implements ComponentConfig {
     toJSON(): ComponentConfig;
     withFlavor(name: string): Component;
     join(path: string): string;
+    relative(path: string): string;
 }

package/dist/src/monorepo/component.js

@@ -54,4 +54,7 @@ export class Component {
     join(path) {
         return this.monorepo.join(join(this.rootDir, path));
     }
+    relative(path) {
+        return join(this.rootDir, path);
+    }
 }

package/dist/src/monorepo/config.js

@@ -16,7 +16,7 @@ export class MonorepoConfig {
         this.flavors = config.flavors || {};
         this.env = config.env || {};
         this.plugins = config.plugins || [];
-        this.tasks = toIdentifedHash(config.tasks || {}, 'global');
+        this.tasks = toIdentifedHash(config.tasks || {});
         this.components = config.components || {};
     }
     component(id) {

package/dist/src/monorepo/monorepo.js

@@ -75,14 +75,7 @@ export class Monorepo {
     }
     get resources() {
         return this.components.reduce((resources, cmp) => {
-            const cmpResources = Object.entries(cmp.resources || {}).map(([name, task]) => {
-                return {
-                    ...task,
-                    name,
-                    id: `${cmp.name}:${name}`,
-                };
-            });
-            return [...resources, ...cmpResources];
+            return [...resources, ...Object.values(cmp.resources)];
         }, []);
     }
     resource(nameOrId) {

package/dist/src/monorepo/operations/resources/BuildResourcesOperation.js

@@ -34,7 +34,6 @@ export class BuildResourcesOperation extends AbstractOperation {
         const collection = new EMBCollection(monorepo.resources, {
             idField: 'id',
             depField: 'dependencies',
-            forbidIdNameCollision: true,
         });
         const ordered = findRunOrder(input.resources || [], collection);
         const tasks = ordered.map((resource) => {

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

@@ -26,6 +26,7 @@ export class ExecuteLocalCommandOperation extends AbstractOperation {
             all: true,
             cwd: input.workingDir,
             shell: true,
+            env: input.env,
         });
         if (this.out) {
             process.all.pipe(this.out);

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

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

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

@@ -1,6 +1,6 @@
 import { getContext } from '../../../index.js';
 import { PassThrough } from 'node:stream';
-import { ComposeExecOperation } from '../../../docker/index.js';
+import { ContainerExecOperation } from '../../../docker/index.js';
 import { EMBCollection, findRunOrder, taskManagerFactory, } from '../../index.js';
 import { ExecuteLocalCommandOperation } from '../index.js';
 export var ExecutorType;
@@ -57,10 +57,12 @@ export class RunTasksOperation {
         return ordered;
     }
     async runDocker(task, out) {
-        const { monorepo } = getContext();
-        return monorepo.run(new ComposeExecOperation(out), {
-            service: task.component,
-            command: task.script,
+        const { monorepo, compose } = getContext();
+        const containerID = await compose.getContainer(task.component);
+        return monorepo.run(new ContainerExecOperation(out), {
+            container: containerID,
+            script: task.script,
+            env: await monorepo.expand(task.vars || {}),
         });
     }
     async runLocal(task, out) {
@@ -71,6 +73,7 @@ export class RunTasksOperation {
         return monorepo.run(new ExecuteLocalCommandOperation(out), {
             script: task.script,
             workingDir: cwd,
+            env: await monorepo.expand(task.vars || {}),
         });
     }
 }

package/dist/src/monorepo/resources/FileResourceBuilder.d.ts

@@ -5,6 +5,7 @@ import { ResourceBuildContext } from './ResourceFactory.js';
 export declare class FileResourceBuilder implements IResourceBuilder<OpInput<CreateFileOperation>, OpOutput<CreateFileOperation>, void> {
     protected context: ResourceBuildContext<OpInput<CreateFileOperation>>;
     constructor(context: ResourceBuildContext<OpInput<CreateFileOperation>>);
+    getReference(): Promise<string>;
     build(resource: ResourceInfo<OpInput<CreateFileOperation>>, out?: Writable): Promise<{
         input: {
             path: string;

package/dist/src/monorepo/resources/FileResourceBuilder.js

@@ -5,9 +5,12 @@ export class FileResourceBuilder {
     constructor(context) {
         this.context = context;
     }
+    async getReference() {
+        return this.context.component.relative(this.context.config.params?.path || this.context.config.name);
+    }
     async build(resource, out) {
         const input = {
-            path: this.context.component.join(resource.params?.path || resource.name),
+            path: await this.context.component.join(this.context.config.params?.path || this.context.config.name),
         };
         return {
             input,

package/dist/src/monorepo/resources/ResourceFactory.js

@@ -9,7 +9,7 @@ export class ResourceFactory {
     static factor(type, context) {
         const BuilderClass = this.types[type];
         if (!BuilderClass) {
-            throw new Error(`Unknown resource type \`${type}\``);
+            throw new Error(`Unknown resource type \`${type}\` (${context.config.id})`);
         }
         return new BuilderClass(context);
     }

package/dist/src/monorepo/resources/abstract/AbstractResourceBuilder.d.ts

@@ -20,4 +20,5 @@ export declare abstract class AbstractResourceBuilder<I, O, R> implements IResou
     publish?(resource: ResourceInfo<I>, out?: Writable): Promise<void>;
     abstract _commit(resource: ResourceInfo<I>, output: O, reason: R): Promise<void>;
     commit(resource: ResourceInfo<I>, output: O, reason: R): Promise<void>;
+    abstract getReference(): Promise<string>;
 }

package/dist/src/monorepo/resources/types.d.ts

@@ -2,6 +2,12 @@ import { ResourceInfo } from '../../index.js';
 import { Writable } from 'node:stream';
 import { IOperation } from '../../operations/types.js';
 export type IResourceBuilder<Input, Output, Reason> = {
+    /**
+     * Returns a string representing the resource to build
+     * Eg. the full name of a docker image (repo/imgname:tag)
+     * Eg. a file path
+     */
+    getReference(): Promise<string>;
     /**
      * Returns input and operation required to actually
      * build the resources.

package/dist/src/monorepo/types.d.ts

@@ -1,4 +1,9 @@
 import { ComponentFlavorConfig, IResourceConfig, ProjectFlavorConfig, TaskConfig } from '../config/types.js';
+export type MaybeComponentIdentifiable<T> = T & {
+    id: string;
+    name: string;
+    component?: string;
+};
 export type ComponentIdentifiable<T> = T & {
     id: string;
     name: string;
@@ -17,7 +22,7 @@ export type ComponentFlavorInfo = ComponentIdentifiable<ComponentFlavorConfig>;
 export type ComponentFlavors = {
     [k: string]: ComponentFlavorInfo;
 };
-export type TaskInfo = ComponentIdentifiable<TaskConfig>;
+export type TaskInfo = MaybeComponentIdentifiable<TaskConfig>;
 export type Tasks = {
     [k: string]: TaskInfo;
 };

package/dist/src/monorepo/utils/EMBCollection.d.ts

@@ -2,8 +2,6 @@ import { DepList } from './types.js';
 export type CollectionConfig<IDK extends PropertyKey, DPK extends PropertyKey> = {
     idField: IDK;
     depField: DPK;
-    /** If true, throw when an item's id equals some other item's name (or vice versa). */
-    forbidIdNameCollision?: boolean;
 };
 export declare class EMBCollection<T extends Partial<Record<DPK, DepList>> & Record<IDK, string> & {
     name: string;
@@ -11,7 +9,6 @@ export declare class EMBCollection<T extends Partial<Record<DPK, DepList>> & Rec
     private items;
     readonly idField: IDK;
     readonly depField: DPK;
-    readonly forbidIdNameCollision: boolean;
     private byId;
     private byName;
     constructor(items: Iterable<T>, cfg: CollectionConfig<IDK, DPK>);

package/dist/src/monorepo/utils/EMBCollection.js

@@ -3,7 +3,6 @@ export class EMBCollection {
     items;
     idField;
     depField;
-    forbidIdNameCollision;
     //
     byId;
     byName;
@@ -11,7 +10,6 @@ export class EMBCollection {
         this.items = [];
         this.idField = cfg.idField;
         this.depField = cfg.depField;
-        this.forbidIdNameCollision = cfg.forbidIdNameCollision ?? true;
         this.byId = new Map();
         this.byName = new Map();
         // single-pass validation state
@@ -32,18 +30,6 @@ export class EMBCollection {
                 this.byId.set(id, t);
                 seenIds.add(id);
             }
-            // --- Optional validation: forbid id <-> name collisions ---
-            if (this.forbidIdNameCollision) {
-                if (seenNames.has(id)) {
-                    const nameOwners = this.byName.get(id) ?? [];
-                    const ownerIds = nameOwners.map((o) => o[this.idField]).join(', ');
-                    collisions.push(`value \`${id}\` is an id of \`${name}\` and also a name of item(s) with id(s): [${ownerIds}]`);
-                }
-                if (seenIds.has(name)) {
-                    const idOwner = this.byId.get(name);
-                    collisions.push(`value \`${name}\` is a name of \`${t.name}\` and also an id of \`${idOwner.name}\``);
-                }
-            }
             // byName index
             const list = this.byName.get(name);
             if (list) {

package/dist/src/monorepo/utils/index.d.ts

@@ -1,7 +1,10 @@
-import { ComponentIdentifiable } from '../../index.js';
+import { ComponentIdentifiable, MaybeComponentIdentifiable } from '../../index.js';
 export * from './EMBCollection.js';
 export * from './graph.js';
 export * from './types.js';
-export declare const toIdentifedHash: <V, T extends {
-    [k: string]: V;
-}>(hash: T, parentName: string) => Record<string, ComponentIdentifiable<V>>;
+export declare function toIdentifedHash<V, T extends Record<string, V>>(hash: T, parentName: string): {
+    [K in keyof T]: ComponentIdentifiable<T[K]>;
+};
+export declare function toIdentifedHash<V, T extends Record<string, V>>(hash: T, parentName?: undefined): {
+    [K in keyof T]: MaybeComponentIdentifiable<T[K]>;
+};

package/dist/src/monorepo/utils/index.js

@@ -1,14 +1,20 @@
 export * from './EMBCollection.js';
 export * from './graph.js';
 export * from './types.js';
-export const toIdentifedHash = (hash, parentName) => {
-    return Object.entries(hash).reduce((hash, [key, value]) => {
-        hash[key] = {
+// implementation
+export function toIdentifedHash(hash, parentName) {
+    const out = {};
+    for (const key in hash) {
+        if (!Object.hasOwn(hash, key)) {
+            continue;
+        }
+        const value = hash[key];
+        out[key] = {
             ...value,
-            id: `${parentName}:${key}`,
+            id: parentName ? `${parentName}:${key}` : key,
             name: key,
-            component: parentName,
+            ...(parentName ? { component: parentName } : {}),
         };
-        return hash;
-    }, {});
-};
+    }
+    return out;
+}

package/dist/src/types.d.ts

@@ -1,5 +1,6 @@
 import type Docker from 'dockerode';
 import { Monorepo } from './monorepo/index.js';
+import { DockerComposeClient } from './docker/index.js';
 /**
  * The context is meant to be what all plugins can decorate
  * to install their own things
@@ -8,6 +9,7 @@ import { Monorepo } from './monorepo/index.js';
  * and install here things that to be accessible by operations during a CLI run
  */
 export interface EmbContext {
+    compose: DockerComposeClient;
     docker: Docker;
     monorepo: Monorepo;
 }