@enspirit/emb 0.0.9 → 0.1.0

package/dist/src/monorepo/monorepo.js

@@ -1,3 +1,4 @@
+import jsonpatch from 'fast-json-patch';
 import { join } from 'node:path';
 import { TemplateExpander } from '../utils/index.js';
 import { Component } from './component.js';
@@ -5,16 +6,15 @@ import { MonorepoConfig } from './config.js';
 import { getPlugin } from './plugins/index.js';
 import { EMBStore } from './store/index.js';
 export class Monorepo {
+    defaultFlavor;
     _config;
     _store;
     initialized = false;
-    constructor(config) {
+    constructor(config, defaultFlavor = 'default') {
+        this.defaultFlavor = defaultFlavor;
+        console.log('WEIRD BECAUSE, adnsod', defaultFlavor);
         this._config = new MonorepoConfig(config);
     }
-    // TODO: cache/improve
-    get components() {
-        return this._config.components.map((c) => new Component(c, this));
-    }
     get config() {
         return this._config.toJSON();
     }
@@ -22,7 +22,7 @@ export class Monorepo {
         return this._config.defaults;
     }
     get flavors() {
-        return this._config.flavors.map((f) => f.name);
+        return this._config.flavors;
     }
     get name() {
         return this._config.project.name;
@@ -31,28 +31,37 @@ export class Monorepo {
         return this._config.project.rootDir;
     }
     get currentFlavor() {
-        return this._config.currentFlavor;
+        return this.defaultFlavor;
     }
     get store() {
         return this._store;
     }
+    get components() {
+        return Object.entries(this._config.components).map(([name, c]) => new Component(name, c, this));
+    }
+    component(name) {
+        return new Component(name, this._config.component(name), this);
+    }
     get tasks() {
-        const globalTasks = (this._config.tasks || [])?.map((t) => {
+        const globalTasks = Object.entries(this._config.tasks || {}).map(([name, task]) => {
             return {
-                ...t,
-                id: `global:${t.name}`,
+                ...task,
+                name,
+                id: `global:${name}`,
             };
         });
         return this.components.reduce((tasks, cmp) => {
-            return [...tasks, ...cmp.tasks];
+            const cmpTasks = Object.entries(cmp.tasks || {}).map(([name, task]) => {
+                return {
+                    ...task,
+                    name,
+                    component: cmp.name,
+                    id: `${cmp.name}:${name}`,
+                };
+            });
+            return [...tasks, ...cmpTasks];
         }, globalTasks);
     }
-    get vars() {
-        return this._config.vars;
-    }
-    component(name) {
-        return new Component(this._config.component(name), this);
-    }
     task(nameOrId) {
         const byId = this.tasks.find((t) => t.id === nameOrId);
         if (byId) {
@@ -67,6 +76,35 @@ export class Monorepo {
         }
         return found[0];
     }
+    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];
+        }, []);
+    }
+    resource(nameOrId) {
+        const byId = this.resources.find((t) => t.id === nameOrId);
+        if (byId) {
+            return byId;
+        }
+        const found = this.resources.filter((t) => t.name === nameOrId);
+        if (found.length > 1) {
+            throw new Error(`Resource name ambigous, found multiple matches: ${nameOrId}`);
+        }
+        if (found.length === 0) {
+            throw new Error(`Resource not found: ${nameOrId}`);
+        }
+        return found[0];
+    }
+    get vars() {
+        return this._config.vars;
+    }
     async expand(strOrRecord, expander = new TemplateExpander()) {
         const options = {
             default: 'vars',
@@ -125,8 +163,29 @@ export class Monorepo {
     async run(operation, args) {
         return operation.run(args);
     }
-    async withFlavor(name) {
-        const repo = new Monorepo(this._config.withFlavor(name));
+    async withFlavor(flavorName) {
+        const patches = this._config.flavor(flavorName).patches || [];
+        const original = this._config.toJSON();
+        const errors = jsonpatch.validate(patches || [], original);
+        if (errors) {
+            throw new Error('Invalid patch(es) detected');
+        }
+        const withComponentPatches = this.components.reduce((config, cmp) => {
+            const componentPatches = cmp.flavor(flavorName, false)?.patches || [];
+            const errors = jsonpatch.validate(componentPatches || [], config.components[cmp.name]);
+            if (errors) {
+                throw new Error('Invalid patch(es) detected');
+            }
+            config.components[cmp.name] = componentPatches.reduce((doc, patch, index) => {
+                return jsonpatch.applyReducer(doc, patch, index);
+            }, config.components[cmp.name]);
+            return config;
+        }, 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);
         await repo.installStore();
         await repo.installEnv();
         return repo;

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

@@ -1,2 +1 @@
-export * from './BuildComponentsOperation.js';
 export * from './GetComponentContainerOperation.js';

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

@@ -1,2 +1 @@
-export * from './BuildComponentsOperation.js';
 export * from './GetComponentContainerOperation.js';

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

@@ -0,0 +1,11 @@
+import * as z from 'zod';
+import { AbstractOperation } from '../../../operations/index.js';
+declare const schema: z.ZodObject<{
+    path: z.ZodString;
+    force: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare class CreateFileOperation extends AbstractOperation<typeof schema, unknown> {
+    constructor();
+    protected _run(input: z.input<typeof schema>): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,31 @@
+import { open, statfs, utimes } from 'node:fs/promises';
+import * as z from 'zod';
+import { AbstractOperation } from '../../../operations/index.js';
+const schema = z.object({
+    //
+    path: z.string().describe('Path to the file to create'),
+    force: z
+        .boolean()
+        .optional()
+        .describe("Update 'atime' and 'mtime' if the file already exists"),
+});
+export class CreateFileOperation extends AbstractOperation {
+    constructor() {
+        super(schema);
+    }
+    async _run(input) {
+        try {
+            await statfs(input.path);
+            if (input.force) {
+                await utimes(input.path, Date.now(), Date.now());
+            }
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT') {
+                const fn = await open(input.path, 'a');
+                return fn.close();
+            }
+            throw error;
+        }
+    }
+}

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

@@ -0,0 +1 @@
+export * from './CreateFileOperation.js';

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

@@ -0,0 +1 @@
+export * from './CreateFileOperation.js';

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

@@ -1,3 +1,4 @@
 export * from './components/index.js';
+export * from './fs/index.js';
 export * from './shell/index.js';
 export * from './tasks/index.js';

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

@@ -1,3 +1,4 @@
 export * from './components/index.js';
+export * from './fs/index.js';
 export * from './shell/index.js';
 export * from './tasks/index.js';

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

@@ -0,0 +1,27 @@
+import * as z from 'zod';
+import { ResourceInfo } from '../../index.js';
+import { ResourceBuilderInfo } from '../../resources/ResourceFactory.js';
+import { AbstractOperation } from '../../../operations/index.js';
+export type BuildResourceMeta = {
+    dryRun?: boolean;
+    force?: boolean;
+    resource?: ResourceInfo;
+    builder?: ResourceBuilderInfo<unknown, unknown>;
+    sentinelData?: unknown;
+    cacheHit?: boolean;
+};
+declare const schema: z.ZodObject<{
+    resources: 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 BuildResourcesOperation extends AbstractOperation<typeof schema, Record<string, BuildResourceMeta>> {
+    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

@@ -0,0 +1,146 @@
+import * as z from 'zod';
+import { EMBCollection, findRunOrder, taskManagerFactory, } from '../../index.js';
+import { ResourceFactory, } from '../../resources/ResourceFactory.js';
+import { AbstractOperation } from '../../../operations/index.js';
+const schema = z.object({
+    resources: z
+        .array(z.string())
+        .describe('The list of resources to build')
+        .optional(),
+    dryRun: z
+        .boolean()
+        .optional()
+        .describe('Do not build but return the config that would be used to build the resources'),
+    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 BuildResourcesOperation extends AbstractOperation {
+    constructor() {
+        super(schema);
+    }
+    async _run(input) {
+        const { monorepo } = this.context;
+        const manager = taskManagerFactory();
+        const collection = new EMBCollection(monorepo.resources, {
+            idField: 'id',
+            depField: 'dependencies',
+            forbidIdNameCollision: true,
+        });
+        const ordered = findRunOrder(input.resources || [], collection);
+        const tasks = ordered.map((resource) => {
+            return {
+                task: async (context, task) => {
+                    return this.buildResource(resource, task, context, {
+                        dryRun: input.dryRun,
+                        force: input.force,
+                    });
+                },
+                title: `Building ${resource.id}`,
+            };
+        });
+        return manager.run([
+            {
+                title: 'Build resources',
+                async task(ctx, task) {
+                    return task.newListr(tasks, {
+                        rendererOptions: {
+                            collapseSubtasks: false,
+                            collapseSkips: true,
+                        },
+                    });
+                },
+            },
+        ], {
+            silentRendererCondition() {
+                return Boolean(input.silent);
+            },
+            rendererOptions: {
+                collapseSkips: true,
+                collapseSubtasks: true,
+            },
+            ctx: {},
+        });
+    }
+    async buildResource(resource, parentTask, parentContext, options) {
+        const list = parentTask.newListr([
+            {
+                title: 'Prepare build context',
+                task: async (ctx) => {
+                    // Extend the context for this specific resource build chain
+                    Object.assign(ctx, options, { resource });
+                    const { monorepo } = this.context;
+                    ctx.builder = await ResourceFactory.factor(resource.type, {
+                        monorepo,
+                        config: resource,
+                        component: monorepo.component(resource.component),
+                    });
+                },
+            },
+            // Actual build
+            {
+                title: `Build ${resource.id}`,
+                /** Skip the build if the builder knows it can be skipped */
+                task: async (ctx, task) => {
+                    if (ctx.builder?.mustBuild) {
+                        const previousSentinelData = await this.readSentinelFile(resource);
+                        ctx.sentinelData =
+                            await ctx.builder.mustBuild(previousSentinelData);
+                        ctx.cacheHit = !ctx.sentinelData;
+                    }
+                    if (!ctx.force && (ctx.dryRun || ctx.cacheHit)) {
+                        const prefix = ctx.dryRun ? '[dry run]' : '[cache hit]';
+                        parentTask.title = `${prefix} ${resource.id}`;
+                        task.skip();
+                        return parentTask.skip();
+                    }
+                    return ctx.builder.operation.run(ctx.builder?.input);
+                },
+            },
+            {
+                // Return build meta data and dump
+                // cache data into sentinel file
+                task: async (ctx) => {
+                    // TODO: clean this
+                    if (ctx.builder?.mustBuild) {
+                        delete ctx.builder.mustBuild;
+                    }
+                    if (ctx.builder?.operation) {
+                        // @ts-expect-error duynno
+                        delete ctx.builder.operation;
+                    }
+                    //
+                    parentContext[resource.id] = ctx;
+                    if (ctx.sentinelData && !ctx.dryRun) {
+                        await this.storeSentinelData(resource, ctx.sentinelData);
+                    }
+                },
+            },
+        ], {
+            ctx: {
+                ...options,
+            },
+            rendererOptions: {
+                collapseSubtasks: true,
+            },
+        });
+        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 data = await this.context.monorepo.store.readFile(path, false);
+        return data ? JSON.parse(data) : undefined;
+    }
+}

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

@@ -64,7 +64,7 @@ export class RunTasksOperation {
     async runLocal(task) {
         const { monorepo } = getContext();
         const cwd = task.component
-            ? monorepo.component(task.component).rootdir
+            ? monorepo.component(task.component).rootDir
             : monorepo.rootDir;
         return monorepo.run(new ExecuteLocalCommandOperation(), {
             script: task.script,

package/dist/src/monorepo/plugins/{ComponentDiscoverPlugin.d.ts → AutoDockerPlugin.d.ts}

@@ -1,15 +1,15 @@
 import { Monorepo, MonorepoConfig } from '../index.js';
 import { AbstractPlugin } from './plugin.js';
-export type ComponentDiscoverPluginOptions = {
+export type AutoDockerPluginOptions = {
     glob?: string;
     ignore?: string | string[];
 };
-export declare const ComponentDiscoverPluginDefaultOptions: {
+export declare const AutoDockerPluginDefaultOptions: {
     glob: string;
 };
-export declare class ComponentDiscoverPlugin extends AbstractPlugin<ComponentDiscoverPluginOptions> {
+export declare class AutoDockerPlugin extends AbstractPlugin<AutoDockerPluginOptions> {
     protected monorepo: Monorepo;
     static name: string;
-    constructor(config: Partial<ComponentDiscoverPluginOptions>, monorepo: Monorepo);
+    constructor(config: Partial<AutoDockerPluginOptions>, monorepo: Monorepo);
     extendConfig(config: MonorepoConfig): Promise<MonorepoConfig>;
 }

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

@@ -0,0 +1,46 @@
+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 AutoDockerPluginDefaultOptions = {
+    glob: '*/Dockerfile',
+};
+export class AutoDockerPlugin extends AbstractPlugin {
+    monorepo;
+    static name = 'autodocker';
+    constructor(config, monorepo) {
+        super({
+            ...AutoDockerPluginDefaultOptions,
+            ...config,
+        }, monorepo);
+        this.monorepo = monorepo;
+    }
+    async extendConfig(config) {
+        const files = await glob(this.config.glob || AutoDockerPluginDefaultOptions.glob, {
+            ...this.config,
+            cwd: config.project.rootDir,
+        });
+        const overrides = files.reduce((cmps, path) => {
+            const name = dirname(path);
+            const component = config.components[name];
+            const cfg = {
+                resources: {
+                    image: {
+                        type: 'docker/image',
+                        params: {},
+                    },
+                },
+            };
+            cmps[name] = component ? deepmerge()(component, cfg) : cfg;
+            return cmps;
+        }, {});
+        return new MonorepoConfig({
+            ...config,
+            components: {
+                ...config.components,
+                ...overrides,
+            },
+        });
+    }
+}

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

@@ -1,5 +1,6 @@
+import deepmerge from '@fastify/deepmerge';
 import { glob } from 'glob';
-import { join } from 'node:path';
+import { basename, dirname, join } from 'node:path';
 import { validateEmbfile } from '../../config/index.js';
 import { AbstractPlugin } from './plugin.js';
 export const EmbfileLoaderPluginDefaultOptions = {
@@ -26,10 +27,16 @@ export class EmbfileLoaderPlugin extends AbstractPlugin {
         });
         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 component = await validateEmbfile(embfile);
+            const original = config.components[name];
+            const newComponent = deepmerge()(original || {}, component);
             return config.with({
-                components: [component],
+                components: {
+                    [name]: newComponent,
+                },
             });
         }, Promise.resolve(config));
         return newConfig;

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

@@ -1,5 +1,5 @@
 import { AbstractPlugin } from './plugin.js';
-export * from './ComponentDiscoverPlugin.js';
+export * from './AutoDockerPlugin.js';
 export * from './DotEnvPlugin.js';
 export * from './EmbfileLoaderPlugin.js';
 import { Monorepo } from '../index.js';

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

@@ -1,7 +1,7 @@
-export * from './ComponentDiscoverPlugin.js';
+export * from './AutoDockerPlugin.js';
 export * from './DotEnvPlugin.js';
 export * from './EmbfileLoaderPlugin.js';
-import { ComponentDiscoverPlugin } from './ComponentDiscoverPlugin.js';
+import { AutoDockerPlugin } from './AutoDockerPlugin.js';
 import { DotEnvPlugin } from './DotEnvPlugin.js';
 import { EmbfileLoaderPlugin } from './EmbfileLoaderPlugin.js';
 const PluginRegistry = new Map();
@@ -18,6 +18,6 @@ export const getPlugin = (name) => {
     return PluginRegistry.get(name);
 };
 /** Not sure why we need casting */
-registerPlugin(ComponentDiscoverPlugin);
+registerPlugin(AutoDockerPlugin);
 registerPlugin(DotEnvPlugin);
 registerPlugin(EmbfileLoaderPlugin);

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,13 @@
+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 }) => {
+    const fromConfig = (config.params || {});
+    const input = {
+        path: component.join(fromConfig?.path || config.name),
+    };
+    return {
+        input,
+        operation: new CreateFileOperation(),
+    };
+});

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

@@ -0,0 +1,23 @@
+import { Component, Monorepo, ResourceInfo } from '../../index.js';
+import { IOperation } from '../../operations/types.js';
+export type ResourceBuildContext = {
+    config: ResourceInfo;
+    component: Component;
+    monorepo: Monorepo;
+};
+export type SentinelData<T = void> = {
+    mtime: number;
+    data: T;
+};
+export type ResourceBuilderInfo<I, O, D = unknown> = {
+    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 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>;
+}

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

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

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

@@ -0,0 +1 @@
+import './FileResource.js';

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

@@ -0,0 +1 @@
+import './FileResource.js';

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

@@ -14,7 +14,7 @@ export declare class EMBStore {
     init(): Promise<void>;
     join(path: string): string;
     mkdirp(path: string): Promise<void>;
-    readFile(path: string): Promise<Buffer<ArrayBufferLike>>;
+    readFile(path: string, mustExist?: boolean): Promise<string | undefined>;
     trash(): Promise<void>;
     writeFile(path: string, data: string): Promise<void>;
 }

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

@@ -54,8 +54,16 @@ export class EMBStore {
         const normalized = normalize(join('/', path));
         await mkdir(this.join(normalized), { recursive: true });
     }
-    async readFile(path) {
-        return readFile(this.join(path));
+    async readFile(path, mustExist = true) {
+        try {
+            return (await readFile(this.join(path))).toString();
+        }
+        catch (error) {
+            if (error.code === 'ENOENT' && !mustExist) {
+                return;
+            }
+            throw error;
+        }
     }
     async trash() {
         return rm(this.path, { force: true, recursive: true });

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

@@ -1,3 +1,3 @@
 import { Manager } from '@listr2/manager';
-import { ListrBaseClassOptions } from 'listr2';
-export declare function taskManagerFactory<T extends Record<PropertyKey, unknown>>(override?: ListrBaseClassOptions): Manager<T>;
+import { ListrContext, ListrRendererValue, ListrSecondaryRendererValue } from 'listr2';
+export declare function taskManagerFactory<Ctx = ListrContext, FallbackRenderer extends ListrRendererValue = ListrSecondaryRendererValue>(): Manager<Ctx, ListrRendererValue, FallbackRenderer>;

package/dist/src/monorepo/taskManagerFactory.js

@@ -1,6 +1,6 @@
 import { Manager } from '@listr2/manager';
 import { ListrDefaultRendererLogLevels, PRESET_TIMER, } from 'listr2';
-export function taskManagerFactory(override) {
+export function taskManagerFactory() {
     return new Manager({
         collectErrors: 'minimal',
         concurrent: false,
@@ -16,6 +16,5 @@ export function taskManagerFactory(override) {
                 ...PRESET_TIMER,
             },
         },
-        ...override,
     });
 }