@enspirit/emb 0.3.2 → 0.4.1

package/README.md

@@ -14,7 +14,7 @@ $ npm install -g @enspirit/emb
 $ emb COMMAND
 running command...
 $ emb (--version)
-@enspirit/emb/0.3.2 darwin-x64 node-v22.12.0
+@enspirit/emb/0.4.1 darwin-x64 node-v22.18.0
 $ emb --help [COMMAND]
 USAGE
   $ emb COMMAND

package/dist/src/cli/commands/down.js

@@ -11,8 +11,8 @@ export default class DownCommand extends FlavoredCommand {
         const runner = new Listr([
             {
                 rendererOptions: { persistentOutput: true },
-                async task() {
-                    return monorepo.run(new ComposeDownOperation(), {});
+                async task(ctx, task) {
+                    return monorepo.run(new ComposeDownOperation(task.stdout()), {});
                 },
                 title: 'Stopping project',
             },

package/dist/src/docker/compose/operations/ComposeDownOperation.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';
 /**
@@ -6,7 +6,8 @@ import { AbstractOperation } from '../../../operations/index.js';
  */
 declare const schema: z.ZodOptional<z.ZodObject<{}, z.core.$strip>>;
 export declare class ComposeDownOperation 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/docker/compose/operations/ComposeDownOperation.js

@@ -7,13 +7,15 @@ import { AbstractOperation } from '../../../operations/index.js';
  */
 const schema = z.object({}).optional();
 export class ComposeDownOperation extends AbstractOperation {
-    constructor() {
+    out;
+    constructor(out) {
         super(schema);
+        this.out = out;
     }
     async _run(_input) {
         const { monorepo } = getContext();
         const command = ['docker', 'compose', 'down'];
-        return monorepo.run(new ExecuteLocalCommandOperation(), {
+        return monorepo.run(new ExecuteLocalCommandOperation(this.out), {
             script: command.join(' '),
             workingDir: monorepo.rootDir,
         });

package/dist/src/docker/compose/operations/ComposeUpOperation.js

@@ -26,8 +26,8 @@ export class ComposeUpOperation extends AbstractOperation {
         }
         manager.add([
             {
-                async task() {
-                    return monorepo.run(new ExecuteLocalCommandOperation(), {
+                async task(ctx, task) {
+                    return monorepo.run(new ExecuteLocalCommandOperation(task.stdout()), {
                         script: command.join(' '),
                         workingDir: monorepo.rootDir,
                     });

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

@@ -13,8 +13,8 @@ export declare const BuildImageOperationInputSchema: z.ZodObject<{
     labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     target: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-export declare class BuildImageOperation extends AbstractOperation<typeof BuildImageOperationInputSchema, Array<unknown>> {
+export declare class BuildImageOperation extends AbstractOperation<typeof BuildImageOperationInputSchema, void> {
     private out?;
     constructor(out?: Writable | undefined);
-    protected _run(input: z.input<typeof BuildImageOperationInputSchema>): Promise<Array<unknown>>;
+    protected _run(input: z.input<typeof BuildImageOperationInputSchema>): Promise<void>;
 }

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

@@ -1,3 +1,4 @@
+import { Transform } from 'node:stream';
 import * as z from 'zod';
 import { decodeBuildkitStatusResponse } from '../../index.js';
 import { AbstractOperation } from '../../../operations/index.js';
@@ -36,8 +37,28 @@ export class BuildImageOperation extends AbstractOperation {
         this.out = out;
     }
     async _run(input) {
-        const logStream = await this.context.monorepo.store.createWriteStream(`logs/docker/build/${input.tag}.log`);
-        this.out?.write('Sending build context to Docker\n');
+        const logFile = await this.context.monorepo.store.createWriteStream(`logs/docker/build/${input.tag}.log`);
+        const decodeBuildkit = new Transform({
+            transform: async (chunk, encoding, callback) => {
+                try {
+                    try {
+                        const { aux } = JSON.parse(chunk);
+                        const { vertexes } = await decodeBuildkitStatusResponse(aux);
+                        vertexes.forEach((v) => {
+                            logFile.write(`${JSON.stringify(v)}\n`);
+                            this.out?.write(`${v.name}\n`);
+                        });
+                    }
+                    catch {
+                        //
+                    }
+                    callback();
+                }
+                catch (error) {
+                    console.error('__OOPS', error);
+                }
+            },
+        });
         const stream = await this.context.docker.buildImage({
             context: input.context,
             src: [...input.src],
@@ -49,29 +70,10 @@ export class BuildImageOperation extends AbstractOperation {
             target: input.target,
             version: '2',
         });
-        this.out?.write('Starting build\n');
         return new Promise((resolve, reject) => {
-            this.context.docker.modem.followProgress(stream, (err, traces) => {
-                logStream.close();
-                return err ? reject(err) : resolve(traces);
-            }, async (trace) => {
-                if (trace.error) {
-                    logStream.close();
-                    reject(new Error(trace.error));
-                }
-                else {
-                    try {
-                        const { vertexes } = await decodeBuildkitStatusResponse(trace.aux);
-                        vertexes.forEach((v) => {
-                            // logStream.write(JSON.stringify(v) + '\n');
-                            this.out?.write(v.name + '\n');
-                        });
-                    }
-                    catch (error) {
-                        console.error(error);
-                    }
-                }
-            });
+            stream.pipe(decodeBuildkit);
+            stream.on('close', () => resolve());
+            stream.on('error', (error) => reject(error));
         });
     }
 }

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

@@ -0,0 +1,14 @@
+import * as z from 'zod';
+import { AbstractOperation } from '../../../operations/index.js';
+/**
+ * https://docs.docker.com/reference/api/engine/version/v1.37/#tag/Image/operation/ImagePush
+ */
+declare const schema: z.ZodObject<{
+    images: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tag: z.ZodDefault<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>;
+}
+export {};

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

@@ -0,0 +1,22 @@
+import * as z from 'zod';
+import { AbstractOperation } from '../../../operations/index.js';
+/**
+ * https://docs.docker.com/reference/api/engine/version/v1.37/#tag/Image/operation/ImagePush
+ */
+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
+        .string()
+        .optional()
+        .default('latest')
+        .describe('Tag of the images to push'),
+});
+export class PushImagesOperation extends AbstractOperation {
+    constructor() {
+        super(schema);
+    }
+    async _run(_input) { }
+}

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

@@ -2,15 +2,17 @@ import { fdir as Fdir } from 'fdir';
 import { stat, statfs } from 'node:fs/promises';
 import { join } from 'node:path';
 import pMap from 'p-map';
+import { SentinelFileBasedBuilder } from '../../monorepo/index.js';
 import { GitPrerequisitePlugin } from '../../prerequisites/index.js';
 import { ResourceFactory, } from '../../monorepo/resources/ResourceFactory.js';
 import { BuildImageOperation } from '../operations/index.js';
-class DockerImageResourceBuilder {
+class DockerImageResourceBuilder extends SentinelFileBasedBuilder {
     buildContext;
-    context;
+    dockerContext;
     constructor(buildContext) {
+        super(buildContext);
         this.buildContext = buildContext;
-        this.context = this.config.context
+        this.dockerContext = this.config?.context
             ? this.config.context[0] === '/'
                 ? buildContext.monorepo.join(this.config.context)
                 : buildContext.component.join(this.config.context)
@@ -20,72 +22,69 @@ class DockerImageResourceBuilder {
         return this.buildContext.monorepo;
     }
     get config() {
-        return (this.buildContext.config.params || {});
+        return this.buildContext.config.params;
     }
     get component() {
         return this.buildContext.component;
     }
-    async build(out) {
+    async _build(_resource, out) {
         // Ensure the folder exists
-        await statfs(this.context);
+        await statfs(this.dockerContext);
         const imageName = [
             this.monorepo.name,
-            this.config.tag || this.component.name,
+            this.config?.tag || this.component.name,
         ].join('/');
-        const tagName = this.config.tag || this.monorepo.defaults.docker?.tag || 'latest';
+        const tagName = this.config?.tag || this.monorepo.defaults.docker?.tag || 'latest';
         const crawler = new Fdir();
         const sources = await crawler
             .withRelativePaths()
-            .crawl(this.context)
+            .crawl(this.dockerContext)
             .withPromise();
         const buildParams = {
-            context: this.context,
-            dockerfile: this.config.dockerfile || 'Dockerfile',
+            context: this.dockerContext,
+            dockerfile: this.config?.dockerfile || 'Dockerfile',
             src: sources,
             buildArgs: await this.monorepo.expand({
                 ...this.monorepo.defaults.docker?.buildArgs,
-                ...this.config.buildArgs,
+                ...this.config?.buildArgs,
             }),
             tag: await this.monorepo.expand(`${imageName}:${tagName}`),
             labels: await this.monorepo.expand({
-                ...this.config.labels,
+                ...this.config?.labels,
                 'emb/project': this.monorepo.name,
                 'emb/component': this.component.name,
                 'emb/flavor': this.monorepo.currentFlavor,
             }),
-            target: this.config.target,
+            target: this.config?.target,
         };
         return {
             input: buildParams,
             operation: new BuildImageOperation(out),
         };
     }
-    async mustBuild(sentinel) {
+    async _mustBuild() {
         const plugin = new GitPrerequisitePlugin();
-        const sources = await plugin.collect(this.context);
+        const sources = await plugin.collect(this.dockerContext);
         const lastUpdated = await this.lastUpdatedInfo(sources);
-        if (!sentinel) {
-            return lastUpdated;
+        if (!lastUpdated) {
+            return;
         }
-        return lastUpdated && lastUpdated.time.getTime() > sentinel.mtime
-            ? lastUpdated
-            : undefined;
+        return { mtime: lastUpdated.time.getTime() };
     }
     async lastUpdatedInfo(sources) {
         const stats = await pMap(sources, async (s) => {
-            const stats = await stat(join(this.context, s.path));
+            const stats = await stat(join(this.dockerContext, s.path));
             return {
                 time: stats.mtime,
                 path: s.path,
             };
         }, { concurrency: 30 });
         if (stats.length === 0) {
-            return 0;
+            return;
         }
         return stats.reduce((last, entry) => {
             return last.time > entry.time ? last : entry;
         }, stats[0]);
     }
 }
-// Bring better abstraction and register as part of the plugin initialization
-ResourceFactory.register('docker/image', async (context) => new DockerImageResourceBuilder(context));
+ResourceFactory.register('docker/image', DockerImageResourceBuilder);

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

@@ -30,7 +30,9 @@ export declare class Monorepo {
     private installEnv;
     init(): Promise<Monorepo>;
     join(...paths: string[]): string;
-    run<I, O>(operation: IOperation<I, O>, args: I): Promise<O>;
+    run<I extends void, O>(operation: IOperation<I, O>): Promise<O>;
+    run<I extends void, O>(operation: IOperation<I, O>): Promise<O>;
+    run<I, O>(operation: IOperation<I, O>, input: I): Promise<O>;
     private expandPatches;
     withFlavor(flavorName: string): Promise<Monorepo>;
 }

package/dist/src/monorepo/monorepo.js

@@ -161,11 +161,13 @@ export class Monorepo {
     join(...paths) {
         return join(this.rootDir, ...paths);
     }
-    async run(operation, args) {
-        return operation.run(args);
+    run(operation, input = undefined) {
+        if (input === undefined) {
+            return operation.run();
+        }
+        return operation.run(input);
     }
     async expandPatches(patches) {
-        console.log('PATCHES', patches);
         const expanded = Promise.all(patches.map(async (patch) => {
             if (!('value' in patch)) {
                 return patch;
@@ -175,7 +177,6 @@ export class Monorepo {
                 value: await this.expand(patch.value),
             };
         }));
-        console.log('EXPANDED', patches);
         return expanded;
     }
     async withFlavor(flavorName) {

package/dist/src/monorepo/operations/fs/CreateFileOperation.d.ts

@@ -1,3 +1,4 @@
+import { Writable } from 'node:stream';
 import * as z from 'zod';
 import { AbstractOperation } from '../../../operations/index.js';
 declare const schema: z.ZodObject<{
@@ -5,7 +6,8 @@ declare const schema: z.ZodObject<{
     force: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare class CreateFileOperation extends AbstractOperation<typeof schema, unknown> {
-    constructor();
+    protected out?: Writable | undefined;
+    constructor(out?: Writable | undefined);
     protected _run(input: z.input<typeof schema>): Promise<void>;
 }
 export {};

package/dist/src/monorepo/operations/fs/CreateFileOperation.js

@@ -10,8 +10,10 @@ const schema = z.object({
         .describe("Update 'atime' and 'mtime' if the file already exists"),
 });
 export class CreateFileOperation extends AbstractOperation {
-    constructor() {
+    out;
+    constructor(out) {
         super(schema);
+        this.out = out;
     }
     async _run(input) {
         try {

package/dist/src/monorepo/operations/resources/BuildResourcesOperation.d.ts

@@ -1,12 +1,11 @@
 import * as z from 'zod';
-import { ResourceInfo } from '../../index.js';
-import { ResourceBuilderInfo } from '../../resources/ResourceFactory.js';
+import { IResourceBuilder, ResourceInfo } from '../../index.js';
 import { AbstractOperation } from '../../../operations/index.js';
 export type BuildResourceMeta = {
     dryRun?: boolean;
     force?: boolean;
     resource?: ResourceInfo;
-    builder?: ResourceBuilderInfo<unknown, unknown>;
+    builder?: IResourceBuilder<unknown, unknown, unknown>;
     builderInput?: unknown;
     sentinelData?: unknown;
     cacheHit?: boolean;
@@ -18,11 +17,9 @@ declare const schema: z.ZodObject<{
     force: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare class BuildResourcesOperation extends AbstractOperation<typeof schema, Record<string, BuildResourceMeta>> {
+    private built;
     constructor();
     protected _run(input: z.input<typeof schema>): Promise<Record<string, BuildResourceMeta>>;
     private buildResource;
-    private sentinelFilePath;
-    private storeSentinelData;
-    private readSentinelFile;
 }
 export {};

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

@@ -1,7 +1,7 @@
 import { PRESET_TIMER, } from 'listr2';
 import * as z from 'zod';
 import { EMBCollection, findRunOrder, taskManagerFactory, } from '../../index.js';
-import { ResourceFactory, } from '../../resources/ResourceFactory.js';
+import { ResourceFactory } from '../../resources/ResourceFactory.js';
 import { AbstractOperation } from '../../../operations/index.js';
 const schema = z.object({
     resources: z
@@ -22,6 +22,9 @@ const schema = z.object({
         .describe('Bypass the cache and force the build'),
 });
 export class BuildResourcesOperation extends AbstractOperation {
+    // keep track of what has been built
+    // to ensure depedencies cannot ignore their turn
+    built = [];
     constructor() {
         super(schema);
     }
@@ -92,16 +95,18 @@ export class BuildResourcesOperation extends AbstractOperation {
                 /** Skip the build if the builder knows it can be skipped */
                 task: async (ctx) => {
                     if (ctx.builder?.mustBuild) {
-                        const previousSentinelData = await this.readSentinelFile(resource);
-                        ctx.sentinelData =
-                            await ctx.builder.mustBuild(previousSentinelData);
+                        ctx.sentinelData = await ctx.builder.mustBuild(ctx.resource);
                         ctx.cacheHit = !ctx.sentinelData;
+                        // If one of our dependency was built, we force the re-build
+                        // despite the cache-hit
+                        const found = ctx.resource.dependencies?.find((d) => Boolean(this.built.find((r) => r.id === d)));
+                        ctx.force = ctx.force || Boolean(found);
                     }
                 },
             },
             {
-                title: `Build image for ${resource.id}`,
-                async task(ctx, task) {
+                title: `Build ${resource.id}`,
+                task: async (ctx, task) => {
                     const skip = (prefix) => {
                         parentTask.title = `${prefix} ${resource.id}`;
                         task.skip();
@@ -110,26 +115,28 @@ export class BuildResourcesOperation extends AbstractOperation {
                     if (ctx.cacheHit && !ctx.force && !ctx.dryRun) {
                         return skip('[cache hit]');
                     }
-                    const { input, operation } = await ctx.builder.build(task.stdout());
+                    const { input, operation } = await ctx.builder.build(ctx.resource, task.stdout());
                     ctx.builderInput = input;
+                    this.built.push(ctx.resource);
                     if (ctx.dryRun) {
                         return skip('[dry run]');
                     }
-                    return operation.run(ctx.builderInput);
+                    const output = await operation.run(ctx.builderInput);
+                    if (ctx.sentinelData) {
+                        ctx.builder.commit?.(ctx.resource, output, ctx.sentinelData);
+                    }
+                    return output;
                 },
             },
             {
                 // Return build meta data and dump
                 // cache data into sentinel file
-                task: async (ctx) => {
+                async task(ctx) {
                     if (ctx.builder) {
                         delete ctx.builder;
                     }
                     //
                     parentContext[resource.id] = ctx;
-                    if (ctx.sentinelData && !ctx.dryRun) {
-                        await this.storeSentinelData(resource, ctx.sentinelData);
-                    }
                 },
             },
         ], {
@@ -142,23 +149,4 @@ export class BuildResourcesOperation extends AbstractOperation {
         });
         return list;
     }
-    sentinelFilePath(resource) {
-        const { monorepo } = this.context;
-        return `sentinels/flavors/${monorepo.currentFlavor}/${resource.component}/${resource.name}.built`;
-    }
-    async storeSentinelData(resource, data) {
-        await this.context.monorepo.store.writeFile(this.sentinelFilePath(resource), JSON.stringify(data));
-    }
-    async readSentinelFile(resource) {
-        const path = this.sentinelFilePath(resource);
-        const stats = await this.context.monorepo.store.stat(path, false);
-        if (!stats) {
-            return undefined;
-        }
-        const data = await this.context.monorepo.store.readFile(path, false);
-        return {
-            data,
-            mtime: stats.mtime.getTime(),
-        };
-    }
 }

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';
@@ -28,17 +29,22 @@ export class RunTasksOperation {
                     if (!task.script) {
                         return;
                     }
+                    console.log('YES WE DO', task.component);
                     const executor = params.executor ??
                         (task.component ? ExecutorType.container : ExecutorType.local);
                     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}`);
@@ -54,18 +60,16 @@ export class RunTasksOperation {
     async runDocker(task, out) {
         const { monorepo } = getContext();
         return monorepo.run(new ComposeExecOperation(out), {
-            attachStderr: true,
-            attachStdout: true,
             service: task.component,
             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/resources/FileResourceBuilder.d.ts

@@ -0,0 +1,15 @@
+import { Writable } from 'node:stream';
+import { CreateFileOperation, IResourceBuilder, ResourceInfo } from '../index.js';
+import { OpInput, OpOutput } from '../../operations/index.js';
+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>>);
+    build(resource: ResourceInfo<OpInput<CreateFileOperation>>, out?: Writable): Promise<{
+        input: {
+            path: string;
+            force?: boolean | undefined;
+        };
+        operation: CreateFileOperation;
+    }>;
+}

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

@@ -0,0 +1,19 @@
+import { CreateFileOperation, } from '../index.js';
+import { ResourceFactory } from './ResourceFactory.js';
+export class FileResourceBuilder {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    async build(resource, out) {
+        const input = {
+            path: this.context.component.join(resource.params?.path || resource.name),
+        };
+        return {
+            input,
+            operation: new CreateFileOperation(out),
+        };
+    }
+}
+// Bring better abstraction and register as part of the plugin initialization
+ResourceFactory.register('file', FileResourceBuilder);

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

@@ -1,34 +1,12 @@
-import { Component, Monorepo, ResourceInfo } from '../../index.js';
-import { Writable } from 'node:stream';
-import { IOperation } from '../../operations/types.js';
-export type ResourceBuildContext = {
-    config: ResourceInfo;
+import { Component, IResourceBuilder, Monorepo, ResourceInfo } from '../../index.js';
+export type ResourceBuildContext<I> = {
+    config: ResourceInfo<I>;
     component: Component;
     monorepo: Monorepo;
 };
-export type SentinelData<T = void> = {
-    mtime: number;
-    data: T;
-};
-export type ResourceBuilderInfo<I, O, D = unknown> = {
-    /**
-     * Returns input and operation required to actually
-     * build the resources.
-     * This allows the dry-run mechanism to be implemented outside
-     * resource builder implementations
-     *
-     * @param out The Writable to use to write logs
-     */
-    build(out?: Writable): Promise<{
-        input: I;
-        operation: IOperation<I, O>;
-    }>;
-    mustBuild?: (previousSentinelData: SentinelData<D> | undefined) => Promise<undefined | unknown>;
-};
-export type ResourceFactoryOutput<I, O> = Promise<ResourceBuilderInfo<I, O>>;
-export type ResourceOperationFactory<I, O> = (context: ResourceBuildContext) => ResourceFactoryOutput<I, O>;
+export type ResourceBuilderConstructor<I, O, R> = new (context: ResourceBuildContext<I>) => IResourceBuilder<I, O, R>;
 export declare class ResourceFactory {
-    protected static types: Record<string, ResourceOperationFactory<unknown, unknown>>;
-    static register<I, O>(type: string, opFactory: ResourceOperationFactory<I, O>): void;
-    static factor<I, O>(type: string, context: ResourceBuildContext): ResourceFactoryOutput<I, O>;
+    protected static types: Record<string, ResourceBuilderConstructor<any, any, any>>;
+    static register<I, O, R>(type: string, constructor: ResourceBuilderConstructor<I, O, R>): void;
+    static factor<I, O, R>(type: string, context: ResourceBuildContext<I>): IResourceBuilder<I, O, R>;
 }

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

@@ -1,16 +1,16 @@
 export class ResourceFactory {
     static types = {};
-    static register(type, opFactory) {
+    static register(type, constructor) {
         if (this.types[type]) {
             throw new Error(`Resource type \`${type}\` already registered`);
         }
-        this.types[type] = opFactory;
+        this.types[type] = constructor;
     }
     static factor(type, context) {
-        const opFactory = this.types[type];
-        if (!opFactory) {
+        const BuilderClass = this.types[type];
+        if (!BuilderClass) {
             throw new Error(`Unknown resource type \`${type}\``);
         }
-        return opFactory(context);
+        return new BuilderClass(context);
     }
 }

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

@@ -0,0 +1,23 @@
+import { ResourceInfo } from '../../../index.js';
+import { Writable } from 'node:stream';
+import { IOperation } from '../../../operations/types.js';
+import { ResourceBuildContext } from '../ResourceFactory.js';
+import { IResourceBuilder } from '../types.js';
+export declare abstract class AbstractResourceBuilder<I, O, R> implements IResourceBuilder<I, O, R> {
+    protected context: ResourceBuildContext<I>;
+    constructor(context: ResourceBuildContext<I>);
+    abstract _build(resource: ResourceInfo<I>, out?: Writable): Promise<{
+        input: I;
+        operation: IOperation<I, O>;
+    }>;
+    build(resource: ResourceInfo<I>, out?: Writable): Promise<{
+        input: I;
+        operation: IOperation<I, O>;
+    }>;
+    abstract _mustBuild?(resource: ResourceInfo<I>): Promise<R | undefined> | undefined;
+    mustBuild(resource: ResourceInfo<I>): Promise<R | undefined>;
+    _publish?(resource: ResourceInfo<I>, out?: Writable): Promise<void>;
+    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>;
+}

package/dist/src/monorepo/resources/abstract/AbstractResourceBuilder.js

@@ -0,0 +1,18 @@
+export class AbstractResourceBuilder {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    build(resource, out) {
+        return this._build(resource, out);
+    }
+    async mustBuild(resource) {
+        return this._mustBuild?.(resource);
+    }
+    async publish(resource, out) {
+        return this._publish?.(resource, out);
+    }
+    async commit(resource, output, reason) {
+        return this._commit?.(resource, output, reason);
+    }
+}

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

@@ -0,0 +1,27 @@
+import { ResourceInfo } from '../../../index.js';
+import { Writable } from 'node:stream';
+import { IOperation } from '../../../operations/types.js';
+import { AbstractResourceBuilder } from './AbstractResourceBuilder.js';
+export type SentinelFile<T> = {
+    mtime: number;
+    data?: T;
+};
+export declare abstract class SentinelFileBasedBuilder<I, O, SentinelData extends {
+    mtime: number;
+}> extends AbstractResourceBuilder<I, O, SentinelData> {
+    private lastSentinelFile?;
+    private newSentinelData?;
+    /**
+     * Checks wether or not the sentinel file is more recent
+     * that the output of the builder's sentinel data
+     */
+    mustBuild(resource: ResourceInfo<I>): Promise<SentinelData | undefined>;
+    build(resource: ResourceInfo<I>, out?: Writable): Promise<{
+        input: I;
+        operation: IOperation<I, O>;
+    }>;
+    private get sentinelFileName();
+    private storeSentinelData;
+    private readSentinel;
+    _commit(_resource: ResourceInfo<I>, _output: O, reason: SentinelData): Promise<void>;
+}

package/dist/src/monorepo/resources/abstract/SentinelFileBasedBuilder.js

@@ -0,0 +1,46 @@
+import { AbstractResourceBuilder } from './AbstractResourceBuilder.js';
+export class SentinelFileBasedBuilder extends AbstractResourceBuilder {
+    lastSentinelFile;
+    newSentinelData;
+    /**
+     * Checks wether or not the sentinel file is more recent
+     * that the output of the builder's sentinel data
+     */
+    async mustBuild(resource) {
+        if (!this._mustBuild) {
+            return;
+        }
+        this.lastSentinelFile = await this.readSentinel();
+        this.newSentinelData = await this._mustBuild(resource);
+        if (!(this.lastSentinelFile && this.newSentinelData)) {
+            return this.newSentinelData;
+        }
+        if (this.lastSentinelFile.mtime < this.newSentinelData.mtime) {
+            return this.newSentinelData;
+        }
+    }
+    async build(resource, out) {
+        return this._build(resource, out);
+    }
+    get sentinelFileName() {
+        const { monorepo, config } = this.context;
+        return `sentinels/flavors/${monorepo.currentFlavor}/${config.component}/${config.name}.built`;
+    }
+    async storeSentinelData(data) {
+        await this.context.monorepo.store.writeFile(this.sentinelFileName, JSON.stringify(data));
+    }
+    async readSentinel() {
+        const stats = await this.context.monorepo.store.stat(this.sentinelFileName, false);
+        if (!stats) {
+            return undefined;
+        }
+        const data = await this.context.monorepo.store.readFile(this.sentinelFileName, false);
+        return {
+            data: data ? JSON.parse(data) : data,
+            mtime: stats.mtime.getTime(),
+        };
+    }
+    async _commit(_resource, _output, reason) {
+        this.storeSentinelData(reason);
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from './AbstractResourceBuilder.js';
+export * from './SentinelFileBasedBuilder.js';

package/dist/src/monorepo/resources/abstract/index.js

@@ -0,0 +1,2 @@
+export * from './AbstractResourceBuilder.js';
+export * from './SentinelFileBasedBuilder.js';

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

@@ -1 +1,3 @@
-import './FileResource.js';
+import './FileResourceBuilder.js';
+export * from './abstract/index.js';
+export * from './types.js';

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

@@ -1 +1,3 @@
-import './FileResource.js';
+import './FileResourceBuilder.js';
+export * from './abstract/index.js';
+export * from './types.js';

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

@@ -0,0 +1,36 @@
+import { ResourceInfo } from '../../index.js';
+import { Writable } from 'node:stream';
+import { IOperation } from '../../operations/types.js';
+export type IResourceBuilder<Input, Output, Reason> = {
+    /**
+     * Returns input and operation required to actually
+     * build the resources.
+     * This allows the dry-run mechanism to be implemented outside
+     * resource implementations
+     *
+     * @param resource The resource config
+     * @param out The Writable to use to write logs
+     */
+    build(resource: ResourceInfo<Input>, out?: Writable): Promise<{
+        input: Input;
+        operation: IOperation<Input, Output>;
+    }>;
+    mustBuild?: (resource: ResourceInfo<Input>) => Promise<Reason | undefined>;
+    /**
+     * Resource builders will be informed when a successful build of resource
+     * has been produced through them
+     *
+     * This allows them to store metadata to improve their caching algorithm
+     */
+    commit?: (resource: ResourceInfo<Input>, output: Output, reason: Reason) => Promise<void>;
+    /**
+     * Similar to .build(), must return input and operation required to actually
+     * publish the resources.
+     * This allows the dry-run mechanism to be implemented outside
+     * resource implementations
+     *
+     * @param resource The resource config
+     * @param out The Writable to use to write logs
+     */
+    publish?(resource: ResourceInfo<Input>, out?: Writable): Promise<void>;
+};

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

@@ -4,7 +4,9 @@ export type ComponentIdentifiable<T> = T & {
     name: string;
     component: string;
 };
-export type ResourceInfo = ComponentIdentifiable<IResourceConfig>;
+export type ResourceInfo<T = unknown> = ComponentIdentifiable<IResourceConfig> & {
+    params?: T;
+};
 export type Resources = {
     [k: string]: ResourceInfo;
 };

package/dist/src/operations/abstract/AbstractOperation.d.ts

@@ -3,10 +3,10 @@ import * as z from 'zod';
 import { IOperation } from '../index.js';
 export type OpInput<A extends AbstractOperation<z.Schema, unknown>> = A extends AbstractOperation<infer I, unknown> ? z.infer<I> : never;
 export type OpOutput<A extends AbstractOperation<z.Schema, unknown>> = A extends AbstractOperation<z.Schema, infer O> ? O : never;
-export declare abstract class AbstractOperation<S extends z.Schema, O = unknown> implements IOperation<z.infer<S>, O> {
-    protected inputSchema: S;
+export declare abstract class AbstractOperation<I extends z.Schema, O> implements IOperation<z.infer<I>, O> {
+    protected inputSchema: I;
     protected context: EmbContext;
-    constructor(inputSchema: S);
-    protected abstract _run(input: z.infer<S>): Promise<O>;
-    run(input: unknown | z.infer<S>): Promise<O>;
+    constructor(inputSchema: I);
+    protected abstract _run(input: z.infer<I>): Promise<O>;
+    run(input: z.infer<I>): Promise<O>;
 }

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

@@ -1,3 +1,3 @@
-export interface IOperation<I, O> {
+export interface IOperation<I = void, O = unknown> {
     run(input: I): Promise<O>;
 }

package/oclif.manifest.json

@@ -718,5 +718,5 @@
       ]
     }
   },
-  "version": "0.3.2"
+  "version": "0.4.1"
 }

package/package.json

@@ -1,8 +1,16 @@
 {
   "name": "@enspirit/emb",
   "type": "module",
-  "version": "0.3.2",
-  "keywords": ["monorepo", "docker", "taskrunner", "ci", "docker compose", "sentinel", "makefile"],
+  "version": "0.4.1",
+  "keywords": [
+    "monorepo",
+    "docker",
+    "taskrunner",
+    "ci",
+    "docker compose",
+    "sentinel",
+    "makefile"
+  ],
   "author": "Louis Lambeau <louis.lambeau@enspirit.be>",
   "license": "ISC",
   "description": "A replacement for our Makefile-for-monorepos",
@@ -114,12 +122,25 @@
     ],
     "topicSeparator": " ",
     "topics": {
-      "images": {"description": "List, delete, prune docker containers" },
-      "containers": {"description": "List, delete, prune docker images" },
-      "resources": {"description": "List, clean, build resources" },
-      "components": {"description": "List & build components resources" },
-      "config": {"description": "It's all about config" },
-      "tasks": {"description": "List and run tasks" }
+      "images": {
+        "description": "List, delete, prune docker containers"
+      },
+      "containers": {
+        "description": "List, delete, prune docker images"
+      },
+      "resources": {
+        "description": "List, clean, build resources"
+      },
+      "components": {
+        "description": "List & build components resources"
+      },
+      "config": {
+        "description": "It's all about config"
+      },
+      "tasks": {
+        "description": "List and run tasks"
+      }
     }
-  }
+  },
+  "packageManager": "pnpm@9.11.0+sha512.0a203ffaed5a3f63242cd064c8fb5892366c103e328079318f78062f24ea8c9d50bc6a47aa3567cabefd824d170e78fa2745ed1f16b132e16436146b7688f19b"
 }

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

@@ -1,17 +0,0 @@
-import { CreateFileOperation } from '../index.js';
-import { ResourceFactory } from './ResourceFactory.js';
-// Bring better abstraction and register as part of the plugin initialization
-ResourceFactory.register('file', async ({ config, component }) => {
-    return {
-        async build() {
-            const fromConfig = (config.params || {});
-            const input = {
-                path: component.join(fromConfig?.path || config.name),
-            };
-            return {
-                input,
-                operation: new CreateFileOperation(),
-            };
-        },
-    };
-});