@enspirit/emb 0.0.9 → 0.1.0

package/dist/src/docker/images/buildImage.js

@@ -1,64 +0,0 @@
-import { getContext } from '../../index.js';
-import { decodeBuildkitStatusResponse, getSentinelFile, } from '../index.js';
-import { FilePrerequisitePlugin } from '../../prerequisites/index.js';
-export const buildDockerImage = async (component, opts = {}, progress) => {
-    const cmp = await component.toDockerBuild();
-    const files = (cmp.prerequisites || []).map((f) => f.path);
-    const { docker, monorepo } = getContext();
-    /** SENTINEL LOGIC */
-    // TODO: make configurable
-    const prereqPlugin = new FilePrerequisitePlugin();
-    const preBuildMeta = await prereqPlugin.meta(component, cmp.prerequisites, 'pre');
-    const sentinelFile = getSentinelFile(component);
-    let lastValue;
-    try {
-        lastValue = (await monorepo.store.readFile(sentinelFile)).toString();
-    }
-    catch {
-        lastValue = undefined;
-    }
-    if (lastValue) {
-        const diff = await prereqPlugin.diff(component, cmp.prerequisites, lastValue, preBuildMeta);
-        if (!diff) {
-            return;
-        }
-    }
-    const stream = await docker.buildImage({
-        context: cmp.context,
-        src: [...files],
-    }, {
-        buildargs: cmp.buildArgs,
-        dockerfile: cmp.dockerfile,
-        labels: cmp.labels,
-        t: cmp.name + ':' + (cmp.tag || 'latest'),
-        target: cmp.target,
-        version: '2',
-    });
-    if (opts.output) {
-        stream.pipe(opts.output);
-    }
-    stream.on('close', async () => {
-        const sentinelValue = await prereqPlugin.meta(component, cmp.prerequisites, 'post');
-        await monorepo.store.writeFile(sentinelFile, sentinelValue);
-    });
-    return new Promise((resolve, reject) => {
-        docker.modem.followProgress(stream, (err, traces) => {
-            return err ? reject(err) : resolve({ ...cmp, traces });
-        }, async (trace) => {
-            if (trace.error) {
-                reject(new Error(trace.error));
-            }
-            else {
-                try {
-                    const { vertexes } = await decodeBuildkitStatusResponse(trace.aux);
-                    vertexes.forEach((v) => {
-                        progress?.(v);
-                    });
-                }
-                catch (error) {
-                    console.error(error);
-                }
-            }
-        });
-    });
-};

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

@@ -1,14 +0,0 @@
-import { FilePrerequisite } from '../prerequisites/index.js';
-export type EnvVariable = {
-    name: string;
-};
-export interface DockerComponentBuild {
-    buildArgs?: Record<string, string>;
-    context: string;
-    dockerfile: string;
-    labels?: Record<string, string>;
-    name: string;
-    prerequisites: Array<FilePrerequisite>;
-    tag: string;
-    target?: string;
-}

package/dist/src/monorepo/operations/components/BuildComponentsOperation.d.ts

@@ -1,23 +0,0 @@
-import * as z from 'zod';
-import { DockerComponentBuild } from '../../../docker/index.js';
-import { AbstractOperation } from '../../../operations/index.js';
-export type BuildComponentMeta = {
-    dryRun?: boolean;
-    cacheHit?: boolean;
-    force?: boolean;
-    build: DockerComponentBuild;
-    preBuildMeta?: string;
-    sentinelFile: string;
-};
-declare const schema: z.ZodObject<{
-    components: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    dryRun: z.ZodOptional<z.ZodBoolean>;
-    silent: z.ZodOptional<z.ZodBoolean>;
-    force: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare class BuildComponentsOperation extends AbstractOperation<typeof schema, Record<string, BuildComponentMeta>> {
-    constructor();
-    protected _run(input: z.input<typeof schema>): Promise<Record<string, BuildComponentMeta>>;
-    private buildComponent;
-}
-export {};

package/dist/src/monorepo/operations/components/BuildComponentsOperation.js

@@ -1,157 +0,0 @@
-import { getContext } from '../../../index.js';
-import * as z from 'zod';
-import { BuildImageOperation, getSentinelFile, } from '../../../docker/index.js';
-import { EMBCollection, findRunOrder, taskManagerFactory, } from '../../index.js';
-import { AbstractOperation } from '../../../operations/index.js';
-import { FilePrerequisitePlugin, PrerequisiteType } from '../../../prerequisites/index.js';
-const schema = z.object({
-    components: z
-        .array(z.string())
-        .describe('The list of components to build')
-        .optional(),
-    dryRun: z
-        .boolean()
-        .optional()
-        .describe('Do not build but return the config that would be used to build the images'),
-    silent: z
-        .boolean()
-        .optional()
-        .describe('Do not produce any output on the terminal'),
-    force: z
-        .boolean()
-        .optional()
-        .describe('Bypass the cache and force the build'),
-});
-export class BuildComponentsOperation extends AbstractOperation {
-    constructor() {
-        super(schema);
-    }
-    async _run(input) {
-        const { monorepo } = getContext();
-        const manager = taskManagerFactory();
-        const selection = (input.components || []).map((t) => monorepo.component(t));
-        const collection = new EMBCollection(this.context.monorepo.components, {
-            idField: 'name',
-            depField: 'dependencies',
-            forbidIdNameCollision: true,
-        });
-        const ordered = findRunOrder(selection.map((s) => s.name), collection);
-        const tasks = ordered.map((cmp) => {
-            return {
-                task: async (context, task) => {
-                    return this.buildComponent(cmp, task, context, {
-                        dryRun: input.dryRun,
-                        force: input.force,
-                    });
-                },
-                title: `Building ${cmp.name}`,
-            };
-        });
-        manager.add([
-            {
-                title: 'Build images',
-                async task(ctx, task) {
-                    return task.newListr([...tasks], {
-                        rendererOptions: {
-                            collapseSubtasks: true,
-                        },
-                    });
-                },
-            },
-        ], {
-            rendererOptions: {
-                collapseSkips: false,
-                collapseSubtasks: false,
-            },
-            ctx: {},
-        });
-        const results = await manager.runAll();
-        return results;
-    }
-    async buildComponent(cmp, parentTask, parentContext, options) {
-        const prereqPlugin = new FilePrerequisitePlugin();
-        const list = parentTask.newListr([
-            // Collect all the prerequisites and other build infos
-            // (This is when variables are expanded etc)
-            {
-                async task(ctx) {
-                    // Install the context for this specific component build chain
-                    ctx.cacheHit = false;
-                    ctx.force = options?.force;
-                    ctx.sentinelFile = getSentinelFile(cmp);
-                    ctx.build = await cmp.toDockerBuild();
-                },
-                title: 'Prepare build context',
-            },
-            // Check for sentinal information to see if the build can be skipped
-            {
-                skip(ctx) {
-                    return Boolean(ctx.force);
-                },
-                task: async (ctx) => {
-                    ctx.preBuildMeta = await prereqPlugin.meta(cmp, ctx.build.prerequisites, 'pre');
-                    let lastValue;
-                    try {
-                        lastValue = (await this.context.monorepo.store.readFile(ctx.sentinelFile)).toString();
-                    }
-                    catch {
-                        lastValue = undefined;
-                    }
-                    if (lastValue) {
-                        const diff = await prereqPlugin.diff(cmp, ctx.build.prerequisites, lastValue, ctx.preBuildMeta);
-                        if (!ctx.force && !diff) {
-                            ctx.cacheHit = true;
-                            parentTask.skip(`${parentTask.title} (cache hit)`);
-                        }
-                    }
-                },
-                title: 'Checking prerequisites',
-            },
-            {
-                skip: (ctx) => !ctx.force && (Boolean(ctx.cacheHit) || Boolean(ctx.dryRun)),
-                task: async (ctx, task) => {
-                    const title = `Building image ${ctx.build.name}:${ctx.build.tag}`;
-                    task.title = title;
-                    const op = new BuildImageOperation((progress) => {
-                        task.title = progress;
-                    });
-                    await this.context.monorepo.run(op, {
-                        ...ctx.build,
-                        src: ctx.build.prerequisites
-                            .filter((p) => {
-                            return p.type === PrerequisiteType.file;
-                        })
-                            .map((p) => p.path),
-                        tag: ctx.build.name + ':' + ctx.build.tag,
-                    });
-                    // Restore title
-                    task.title = title;
-                },
-                title: 'Building image',
-            },
-            // Update sentinel file
-            {
-                skip: (ctx) => !ctx.force && (Boolean(ctx.cacheHit) || Boolean(ctx.dryRun)),
-                task: async (ctx) => {
-                    const sentinelValue = await prereqPlugin.meta(cmp, ctx.build.prerequisites, 'post');
-                    await this.context.monorepo.store.writeFile(ctx.sentinelFile, sentinelValue);
-                },
-                title: 'Dumping cache info',
-            },
-            {
-                // Return build meta data
-                async task(ctx) {
-                    parentContext[cmp.name] = ctx;
-                    if (!ctx.force && ctx.dryRun) {
-                        parentTask.skip(`${parentTask.title} (dry run)`);
-                    }
-                },
-            },
-        ], {
-            ctx: {
-                ...options,
-            },
-        });
-        return list;
-    }
-}

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

@@ -1,44 +0,0 @@
-import deepmerge from '@fastify/deepmerge';
-import { glob } from 'glob';
-import { dirname } from 'node:path';
-import { MonorepoConfig } from '../index.js';
-import { AbstractPlugin } from './plugin.js';
-export const ComponentDiscoverPluginDefaultOptions = {
-    glob: '*/Dockerfile',
-};
-export class ComponentDiscoverPlugin extends AbstractPlugin {
-    monorepo;
-    static name = 'autodiscover';
-    constructor(config, monorepo) {
-        super({
-            ...ComponentDiscoverPluginDefaultOptions,
-            ...config,
-        }, monorepo);
-        this.monorepo = monorepo;
-    }
-    async extendConfig(config) {
-        const files = await glob(this.config.glob || ComponentDiscoverPluginDefaultOptions.glob, {
-            ...this.config,
-            cwd: config.project.rootDir,
-        });
-        const overrides = files.map((path) => {
-            const name = dirname(path);
-            const component = config.components.find((cmp) => cmp.name === name);
-            const cfg = {
-                name,
-                docker: {
-                    context: name,
-                },
-            };
-            return component ? deepmerge()(component, cfg) : cfg;
-        });
-        const untouched = config.components.filter((c) => !overrides.find((o) => {
-            return o.name === c.name;
-        }));
-        const components = [...overrides, ...untouched];
-        return new MonorepoConfig({
-            ...config,
-            components,
-        });
-    }
-}

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

@@ -1,6 +0,0 @@
-import { IProjectConfig } from '../config/index.js';
-export declare class ProjectConfig implements IProjectConfig {
-    name: string;
-    rootDir: string;
-    constructor(config: IProjectConfig);
-}

package/dist/src/monorepo/project.js

@@ -1,8 +0,0 @@
-export class ProjectConfig {
-    name;
-    rootDir;
-    constructor(config) {
-        this.name = config.name;
-        this.rootDir = config.rootDir;
-    }
-}

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

@@ -1,165 +0,0 @@
-import graphlib from 'graphlib';
-import { AmbiguousTaskError, CircularDependencyError, TaskNameCollisionError, UnkownReferenceError, } from '../../errors.js';
-export class EMBCollection {
-    items;
-    idField;
-    depField;
-    byId;
-    byName;
-    constructor(items, cfg) {
-        this.items = [];
-        this.idField = cfg.idField;
-        this.depField = cfg.depField;
-        this.byId = new Map();
-        this.byName = new Map();
-        // single-pass validation state
-        const seenIds = new Set();
-        const seenNames = new Set();
-        const dupIdReports = [];
-        const collisions = [];
-        for (const t of items) {
-            const id = t[this.idField];
-            const { name } = t;
-            // duplicate id?
-            if (seenIds.has(id)) {
-                const firstOwner = this.byId.get(id); // first occurrence already stored
-                dupIdReports.push(`id "${id}" used by "${firstOwner.name}" and "${name}"`);
-                // keep the first owner in byId; do not overwrite
-            }
-            else {
-                this.byId.set(id, t);
-                seenIds.add(id);
-            }
-            // --- Optional validation: forbid id <-> name collisions ---
-            const checkCollisions = cfg.forbidIdNameCollision && this.idField !== 'name';
-            if (checkCollisions) {
-                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)
-                list.push(t);
-            else
-                this.byName.set(name, [t]);
-            // keep item list (stable order)
-            this.items.push(t);
-            // record name after checks so current name won’t collide with itself
-            seenNames.add(name);
-        }
-        if (dupIdReports.length > 0 || collisions.length > 0) {
-            const parts = [];
-            if (dupIdReports.length > 0) {
-                parts.push(`Duplicate ${String(this.idField)} values (${dupIdReports.length}):\n` +
-                    dupIdReports.join('\n'));
-            }
-            if (collisions.length > 0) {
-                parts.push(`id↔name collisions (${collisions.length}):\n` +
-                    collisions.join('\n'));
-            }
-            throw new TaskNameCollisionError('Collision between task names and ids', parts);
-        }
-    }
-    /** All items (stable array iteration) */
-    get all() {
-        return this.items;
-    }
-    idOf(t) {
-        return t[this.idField];
-    }
-    depsOf(t) {
-        return (t[this.depField] ?? []);
-    }
-    matches(ref, opts) {
-        const idHit = this.byId.get(ref);
-        if (idHit)
-            return opts?.multiple ? [idHit] : idHit;
-        const nameHits = this.byName.get(ref) ?? [];
-        if (nameHits.length === 0) {
-            throw new UnkownReferenceError(`Unknown reference "${ref}"`);
-        }
-        if (opts?.multiple)
-            return nameHits;
-        if (nameHits.length > 1) {
-            const ids = nameHits.map((t) => this.idOf(t));
-            throw new AmbiguousTaskError(`Ambiguous reference "${ref}" matches multiple id/name`, ids);
-        }
-        return nameHits[0];
-    }
-}
-/* ----------------- run-order helpers unchanged (for completeness) ---------------- */
-function resolveRefSet(col, ref, policy) {
-    if (policy === 'runAll')
-        return col.matches(ref, { multiple: true }).map((t) => col.idOf(t));
-    return [col.idOf(col.matches(ref))];
-}
-function collectPredecessorClosure(g, seeds) {
-    const seen = new Set();
-    const q = [];
-    for (const s of seeds) {
-        if (!seen.has(s)) {
-            seen.add(s);
-            q.push(s);
-        }
-    }
-    while (q.length > 0) {
-        const cur = q.shift();
-        for (const p of g.predecessors(cur) ?? [])
-            if (!seen.has(p)) {
-                seen.add(p);
-                q.push(p);
-            }
-    }
-    return seen;
-}
-function buildGraph(col, policy) {
-    const g = new graphlib.Graph({ directed: true });
-    for (const t of col.all)
-        g.setNode(col.idOf(t));
-    for (const t of col.all) {
-        const toId = col.idOf(t);
-        for (const ref of col.depsOf(t)) {
-            for (const fromId of resolveRefSet(col, ref, policy))
-                g.setEdge(fromId, toId);
-        }
-    }
-    return g;
-}
-export function findRunOrder(selection, collection, { onAmbiguous = 'error' } = {}) {
-    const g = buildGraph(collection, onAmbiguous);
-    const cycles = graphlib.alg.findCycles(g);
-    if (cycles.length > 0) {
-        throw new CircularDependencyError(`Circular dependencies detected: ${JSON.stringify(cycles)}`);
-    }
-    const selectedIds = new Set();
-    for (const ref of selection)
-        for (const id of resolveRefSet(collection, ref, onAmbiguous))
-            selectedIds.add(id);
-    if (selectedIds.size === 0)
-        throw new Error('Selection resolved to no items.');
-    const include = collectPredecessorClosure(g, selectedIds.values());
-    const sub = new graphlib.Graph({ directed: true });
-    for (const id of include)
-        sub.setNode(id);
-    for (const id of include)
-        for (const p of g.predecessors(id) ?? [])
-            if (include.has(p))
-                sub.setEdge(p, id);
-    const ids = graphlib.alg.topsort(sub);
-    const byId = new Map();
-    for (const t of collection.all)
-        byId.set(collection.idOf(t), t);
-    return ids.map((id) => {
-        const t = byId.get(id);
-        if (!t)
-            throw new Error(`Internal error: missing item for id "${id}"`);
-        return t;
-    });
-}