@enspirit/emb 0.0.8 → 0.1.0

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

@@ -4,29 +4,35 @@ import { AbstractOperation } from '../../../operations/index.js';
 /**
  * https://docs.docker.com/reference/api/engine/version/v1.37/#tag/Image/operation/ImageBuild
  */
-const schema = z.object({
-    buildArgs: z
-        .record(z.string(), z.string())
-        .optional()
-        .describe('Map of string pairs for build-time variables'),
+export const BuildImageOperationInputSchema = z.object({
+    //
     context: z.string().describe('Path to the build context'),
     dockerfile: z
         .string()
-        .describe('Path within the build context to the Dockerfile.'),
-    labels: z
-        .record(z.string(), z.string())
         .optional()
-        .describe('Arbitrary key/value labels to set on the image, as a JSON map of string pairs.'),
+        .default('Dockerfile')
+        .describe('Path within the build context to the Dockerfile.'),
     src: z.array(z.string()),
     tag: z.z
         .string()
+        .optional()
+        .describe('latest')
         .describe('A name and optional tag to apply to the image in the name:tag'),
+    //
+    buildArgs: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe('Map of string pairs for build-time variables'),
+    labels: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe('Arbitrary key/value labels to set on the image, as a JSON map of string pairs.'),
     target: z.string().optional().describe('Target build stage'),
 });
 export class BuildImageOperation extends AbstractOperation {
     observer;
     constructor(observer) {
-        super(schema);
+        super(BuildImageOperationInputSchema);
         this.observer = observer;
     }
     async _run(input) {
@@ -55,7 +61,7 @@ export class BuildImageOperation extends AbstractOperation {
                     try {
                         const { vertexes } = await decodeBuildkitStatusResponse(trace.aux);
                         vertexes.forEach((v) => {
-                            logStream.write(JSON.stringify(v) + '\n');
+                            // logStream.write(JSON.stringify(v) + '\n');
                             this.observer?.(v.name);
                         });
                     }

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

@@ -0,0 +1,56 @@
+import { stat } from 'node:fs/promises';
+import { GitPrerequisitePlugin } from '../../prerequisites/index.js';
+import { ResourceFactory, } from '../../monorepo/resources/ResourceFactory.js';
+import { BuildImageOperation } from '../operations/index.js';
+const DockerImageOpFactory = async ({ config, component, monorepo }) => {
+    const fromConfig = (config.params || {});
+    const plugin = new GitPrerequisitePlugin();
+    const sources = await plugin.collect(component);
+    const context = fromConfig.context
+        ? component.join(fromConfig.context)
+        : component.rootDir;
+    const buildParams = {
+        context,
+        dockerfile: fromConfig.dockerfile || 'Dockerfile',
+        src: sources.map((s) => s.path),
+        buildArgs: fromConfig.buildArgs || {},
+        tag: [monorepo.name, fromConfig.tag || component.name].join('/'),
+        labels: {
+            ...fromConfig.labels,
+            'emb/project': monorepo.name,
+            'emb/component': component.name,
+            'emb/flavor': monorepo.currentFlavor,
+        },
+        target: fromConfig.target,
+    };
+    const lastUpdatedInfo = async (sources) => {
+        const stats = await Promise.all(sources.map(async (s) => {
+            const stats = await stat(component.join(s.path));
+            return {
+                time: stats.mtime,
+                path: s.path,
+            };
+        }));
+        if (stats.length === 0) {
+            return 0;
+        }
+        return stats.reduce((last, entry) => {
+            return last.time > entry.time ? last : entry;
+        }, stats[0]);
+    };
+    return {
+        async mustBuild(sentinel) {
+            const lastUpdated = await lastUpdatedInfo(sources);
+            if (!sentinel) {
+                return lastUpdated;
+            }
+            return lastUpdated && lastUpdated.time.getTime() > sentinel.mtime
+                ? lastUpdated
+                : undefined;
+        },
+        input: await monorepo.expand(buildParams),
+        operation: new BuildImageOperation(),
+    };
+};
+// Bring better abstraction and register as part of the plugin initialization
+ResourceFactory.register('docker/image', DockerImageOpFactory);

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

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

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

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

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

@@ -1,7 +1 @@
-import { Component } from '../monorepo/index.js';
-export declare const shortId: (id: string) => string;
-/**
- * This is too naive and will need better logic to ensure
- * we take care of flavors etc
- */
-export declare const getSentinelFile: (component: Component) => string;
+export declare const shortId: (id?: string) => string;

package/dist/src/docker/utils.js

@@ -1,10 +1,6 @@
 export const shortId = (id) => {
+    if (!id) {
+        return '';
+    }
     return id.slice(0, 12);
 };
-/**
- * This is too naive and will need better logic to ensure
- * we take care of flavors etc
- */
-export const getSentinelFile = (component) => {
-    return `sentinels/docker/build/${component.name}.built`;
-};

package/dist/src/errors.d.ts

@@ -41,17 +41,20 @@ export declare class CliError extends EMBError {
      */
     ref?: string | undefined);
 }
-export declare class AmbiguousTaskError extends EMBError {
-    options: string[];
-    constructor(msg: string, options: string[]);
+export declare class AmbiguousReferenceError extends EMBError {
+    ref: string;
+    matches: string[];
+    constructor(msg: string, ref: string, matches: string[]);
 }
 export declare class UnkownReferenceError extends EMBError {
-    constructor(msg: string);
+    ref: string;
+    constructor(msg: string, ref: string);
 }
-export declare class TaskNameCollisionError extends EMBError {
+export declare class ItemCollisionsError extends EMBError {
     collisions: Array<string>;
     constructor(msg: string, collisions: Array<string>);
 }
 export declare class CircularDependencyError extends EMBError {
-    constructor(msg: string);
+    readonly deps: Array<Array<string>>;
+    constructor(msg: string, deps: Array<Array<string>>);
 }

package/dist/src/errors.js

@@ -40,27 +40,33 @@ export class CliError extends EMBError {
         this.ref = ref;
     }
 }
-export class AmbiguousTaskError extends EMBError {
-    options;
-    constructor(msg, options) {
-        super('AMBIG_TASK', msg);
-        this.options = options;
+export class AmbiguousReferenceError extends EMBError {
+    ref;
+    matches;
+    constructor(msg, ref, matches) {
+        super('AMBIGUOUS_TASK', msg);
+        this.ref = ref;
+        this.matches = matches;
     }
 }
 export class UnkownReferenceError extends EMBError {
-    constructor(msg) {
+    ref;
+    constructor(msg, ref) {
         super('UNKNOWN_REF', msg);
+        this.ref = ref;
     }
 }
-export class TaskNameCollisionError extends EMBError {
+export class ItemCollisionsError extends EMBError {
     collisions;
     constructor(msg, collisions) {
-        super('UNKNOWN_REF', msg);
+        super('ITEM_COLLISIONS', msg);
         this.collisions = collisions;
     }
 }
 export class CircularDependencyError extends EMBError {
-    constructor(msg) {
+    deps;
+    constructor(msg, deps) {
         super('CIRCULAR_DEPS', msg);
+        this.deps = deps;
     }
 }

package/dist/src/index.d.ts

@@ -1,4 +1,6 @@
 export * from './context.js';
+export * from './docker/index.js';
 export * from './errors.js';
+export * from './monorepo/index.js';
 export * from './types.js';
 export { run } from '@oclif/core';

package/dist/src/index.js

@@ -1,4 +1,6 @@
 export * from './context.js';
+export * from './docker/index.js';
 export * from './errors.js';
+export * from './monorepo/index.js';
 export * from './types.js';
 export { run } from '@oclif/core';

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

@@ -1,24 +1,19 @@
-import { ComponentConfig } from '../config/index.js';
-import { DockerComponentBuild } from '../docker/index.js';
-import { Monorepo, TaskInfo } from './index.js';
+import { ComponentConfig, ComponentFlavorConfig } from '../config/schema.js';
+import { ComponentFlavors, Monorepo, Resources, Tasks } from './index.js';
 import { FilePrerequisite } from '../prerequisites/index.js';
-export declare class Component {
-    protected _config: ComponentConfig;
+export declare class Component implements ComponentConfig {
+    readonly name: string;
+    readonly config: ComponentConfig;
     protected monorepo: Monorepo;
-    constructor(_config: ComponentConfig, monorepo: Monorepo);
-    get config(): ComponentConfig;
-    get context(): string;
-    get dependencies(): string[];
-    get imageName(): string;
-    get imageTag(): string;
-    get labels(): {
-        'emb/component': string;
-    };
-    get name(): string;
-    get rootdir(): string;
-    get tasks(): Array<TaskInfo>;
-    cloneWith(config: Partial<ComponentConfig>): Component;
+    readonly tasks: Tasks;
+    readonly resources: Resources;
+    readonly flavors: ComponentFlavors;
+    constructor(name: string, config: ComponentConfig, monorepo: Monorepo);
+    get rootDir(): string;
+    flavor(name: string, mustExist?: boolean): ComponentFlavorConfig;
+    cloneWith(config: Partial<ComponentConfig>): ComponentConfig;
+    toJSON(): ComponentConfig;
+    withFlavor(name: string): Component;
     getPrerequisites(): Promise<Array<FilePrerequisite>>;
     join(path: string): string;
-    toDockerBuild(): Promise<DockerComponentBuild>;
 }

package/dist/src/monorepo/component.js

@@ -1,77 +1,61 @@
-import deepmerge from '@fastify/deepmerge';
+import jsonpatch from 'fast-json-patch';
 import { join } from 'node:path';
+import { toIdentifedHash, } from './index.js';
 import { GitPrerequisitePlugin } from '../prerequisites/index.js';
 export class Component {
-    _config;
+    name;
+    config;
     monorepo;
-    constructor(_config, monorepo) {
-        this._config = _config;
+    tasks;
+    resources;
+    flavors;
+    constructor(name, config, monorepo) {
+        this.name = name;
+        this.config = config;
         this.monorepo = monorepo;
-    }
-    get config() {
-        return structuredClone(this._config);
-    }
-    get context() {
-        return this.config.docker?.context || this.name;
-    }
-    get dependencies() {
-        return this.config.docker?.dependencies || [];
-    }
-    get imageName() {
-        return join(this.monorepo.name, this.name);
-    }
-    get imageTag() {
-        return this.monorepo.defaults.docker?.tag || 'latest';
-    }
-    get labels() {
-        return {
-            'emb/component': this.name,
-            ...this._config.docker?.labels,
-        };
-    }
-    get name() {
-        return this.config.name;
-    }
-    get rootdir() {
-        return this.monorepo.join(this.context || this.name);
-    }
-    get tasks() {
-        return (this.config.tasks || [])?.map((t) => {
-            return {
-                ...t,
-                component: this.name,
-                id: `${this.name}:${t.name}`,
-            };
-        });
+        this.tasks = toIdentifedHash(config.tasks || {}, this.name);
+        this.resources = toIdentifedHash(
+        // Due to the schema.json -> typescript conversion weirdness
+        config.resources || {}, this.name);
+        this.flavors = toIdentifedHash(config.flavors || {}, this.name);
+    }
+    get rootDir() {
+        return this.monorepo.join(this.name);
+    }
+    flavor(name, mustExist = true) {
+        const flavor = this.flavors[name];
+        if (!flavor && mustExist) {
+            throw new Error(`Unknown flavor: ${name}`);
+        }
+        return flavor;
     }
     cloneWith(config) {
-        return new Component({
+        return new Component(this.name, {
             ...this.config,
             ...config,
         }, this.monorepo);
     }
+    toJSON() {
+        return structuredClone(this.config);
+    }
+    withFlavor(name) {
+        const original = this.toJSON();
+        const patches = this.flavor(name).patches || [];
+        const errors = jsonpatch.validate(patches, original);
+        if (errors) {
+            throw new Error('Invalid patch(es) detected');
+        }
+        const patched = patches.reduce((doc, patch, index) => {
+            return jsonpatch.applyReducer(doc, patch, index);
+        }, original);
+        return new Component(this.name, patched, this.monorepo);
+    }
     async getPrerequisites() {
         // TODO: move this to config with potential overridzs
         const plugin = new GitPrerequisitePlugin();
         return plugin.collect(this);
     }
     join(path) {
-        return this.monorepo.join(this.context || this.name, path);
-    }
-    async toDockerBuild() {
-        return {
-            buildArgs: await this.monorepo.expand(deepmerge()(this.monorepo.defaults.docker?.buildArgs || {}, this.config.docker?.buildArgs || {})),
-            context: this.rootdir,
-            dockerfile: this.config.docker?.dockerfile || 'Dockerfile',
-            labels: deepmerge()({
-                ...this.monorepo.defaults.docker?.labels,
-            }, this.labels),
-            name: this.imageName,
-            prerequisites: await this.getPrerequisites(),
-            tag: this.imageTag
-                ? await this.monorepo.expand(this.imageTag)
-                : 'latest',
-            target: this.config.docker?.target || this.monorepo.defaults?.docker?.target,
-        };
+        return join(this.rootDir, path);
     }
 }

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

@@ -1,19 +1,17 @@
-import { ComponentConfig, DefaultSettings, FlavorConfig, IMonorepoConfig, IProjectConfig, PluginConfig, Task } from '../config/index.js';
-export declare class MonorepoConfig implements IMonorepoConfig {
-    currentFlavor: string;
-    defaults: DefaultSettings;
+import { ProjectFlavors, Tasks } from '../index.js';
+import { ComponentConfig, DefaultsConfig, PluginConfig, ProjectConfig, ProjectFlavorConfig, UserConfig } from '../config/index.js';
+export declare class MonorepoConfig implements UserConfig {
+    project: ProjectConfig;
+    defaults: DefaultsConfig;
     env: Record<string, string>;
-    flavors: Array<FlavorConfig>;
+    flavors: ProjectFlavors;
     plugins: Array<PluginConfig>;
-    project: IProjectConfig;
     vars: Record<string, unknown>;
-    tasks: Array<Task>;
-    private _components;
-    constructor(config: IMonorepoConfig);
-    get components(): ComponentConfig[];
-    component(name: string): ComponentConfig;
-    flavor(name: string): FlavorConfig;
-    toJSON(): IMonorepoConfig;
-    with(overrides: Partial<IMonorepoConfig>): MonorepoConfig;
-    withFlavor(name: string): MonorepoConfig;
+    tasks: Tasks;
+    components: Record<string, ComponentConfig>;
+    constructor(config: UserConfig);
+    component(id: string): ComponentConfig;
+    flavor(name: string): ProjectFlavorConfig;
+    toJSON(): Required<UserConfig>;
+    with(overrides: Partial<UserConfig>): MonorepoConfig;
 }

package/dist/src/monorepo/config.js

@@ -1,84 +1,53 @@
+import { toIdentifedHash } from '../index.js';
 import deepMerge from '@fastify/deepmerge';
-import { deepMergeArray } from '../utils/index.js';
 export class MonorepoConfig {
-    // the flavor we come from
-    currentFlavor;
-    //
+    project;
     defaults;
     env;
     flavors;
     plugins;
-    project;
     vars;
     tasks;
-    _components;
+    components;
     constructor(config) {
-        this._components = config.components.reduce((map, cmp) => {
-            map.set(cmp.name, cmp);
-            return map;
-        }, new Map());
         this.defaults = config.defaults || {};
         this.project = config.project;
         this.vars = config.vars || {};
-        this.flavors = config.flavors || [];
+        this.flavors = config.flavors || {};
         this.env = config.env || {};
         this.plugins = config.plugins || [];
-        this.tasks = config.tasks || [];
-        this.currentFlavor = config.currentFlavor || 'default';
+        this.tasks = toIdentifedHash(config.tasks || {}, 'global');
+        this.components = config.components || {};
     }
-    get components() {
-        return [...this._components.values()];
-    }
-    component(name) {
-        const config = this.components.find((c) => c.name === name);
+    component(id) {
+        const config = this.components[id];
         if (!config) {
-            throw new Error(`Unknown component ${name}`);
+            throw new Error(`Unknown component ${id}`);
         }
         return config;
     }
     flavor(name) {
-        const flavor = this.flavors.find((f) => f.name === name);
+        const flavor = this.flavors[name];
         if (!flavor) {
             throw new Error(`Unknown flavor: ${name}`);
         }
         return flavor;
     }
     toJSON() {
-        return {
-            currentFlavor: this.currentFlavor,
+        return structuredClone({
             components: this.components,
             defaults: this.defaults,
             env: this.env,
             flavors: this.flavors,
             plugins: this.plugins,
             project: this.project,
-            vars: this.vars,
             tasks: this.tasks,
-        };
+            vars: this.vars,
+        });
     }
     with(overrides) {
-        const newConfig = {
-            ...this.toJSON(),
-            ...overrides,
-            components: deepMerge({
-                mergeArray() {
-                    // Merge components by identifying them by name
-                    return (target, source) => deepMergeArray(target, source, (item) => {
-                        return item.name;
-                    });
-                },
-            })(this.components, overrides?.components || []),
-            defaults: deepMerge()(this.defaults || {}, overrides.defaults || {}),
-            env: deepMerge()(this.env, overrides?.env || {}),
-            project: deepMerge()(this.project, overrides?.project || {}),
-            vars: deepMerge()(this.vars, overrides?.vars || {}),
-        };
+        const oldConfig = this.toJSON();
+        const newConfig = deepMerge()(oldConfig, overrides);
         return new MonorepoConfig(newConfig);
     }
-    withFlavor(name) {
-        return this.with({
-            ...this.flavor(name),
-            currentFlavor: name,
-        });
-    }
 }

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

@@ -3,6 +3,7 @@ export * from './config.js';
 export * from './monorepo.js';
 export * from './operations/index.js';
 export * from './plugins/index.js';
+export * from './resources/index.js';
 export * from './store/index.js';
 export * from './taskManagerFactory.js';
 export * from './types.js';

package/dist/src/monorepo/index.js

@@ -3,6 +3,7 @@ export * from './config.js';
 export * from './monorepo.js';
 export * from './operations/index.js';
 export * from './plugins/index.js';
+export * from './resources/index.js';
 export * from './store/index.js';
 export * from './taskManagerFactory.js';
 export * from './types.js';

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

@@ -1,26 +1,29 @@
-import { IMonorepoConfig } from '../config/index.js';
+import { UserConfig } from '../config/types.js';
 import { IOperation } from '../operations/index.js';
 import { TemplateExpander } from '../utils/index.js';
 import { Component } from './component.js';
 import { EMBStore } from './store/index.js';
-import { TaskInfo } from './types.js';
+import { ResourceInfo, TaskInfo } from './types.js';
 export declare class Monorepo {
+    private defaultFlavor;
     private _config;
     private _store;
     private initialized;
-    constructor(config: IMonorepoConfig);
-    get components(): Component[];
-    get config(): IMonorepoConfig;
-    get defaults(): import("../config/index.js").DefaultSettings;
-    get flavors(): string[];
+    constructor(config: UserConfig, defaultFlavor?: string);
+    get config(): UserConfig;
+    get defaults(): import("../config/types.js").DefaultsConfig;
+    get flavors(): import("./types.js").ProjectFlavors;
     get name(): string;
     get rootDir(): string;
     get currentFlavor(): string;
     get store(): EMBStore;
-    get tasks(): TaskInfo[];
-    get vars(): Record<string, unknown>;
+    get components(): Component[];
     component(name: string): Component;
+    get tasks(): TaskInfo[];
     task(nameOrId: string): TaskInfo;
+    get resources(): Array<ResourceInfo>;
+    resource(nameOrId: string): ResourceInfo;
+    get vars(): Record<string, unknown>;
     expand(str: string, expander?: TemplateExpander): Promise<string>;
     expand<R extends Record<string, unknown>>(record: R, expander?: TemplateExpander): Promise<R>;
     private installStore;
@@ -28,5 +31,5 @@ export declare class Monorepo {
     init(): Promise<Monorepo>;
     join(...paths: string[]): string;
     run<I, O>(operation: IOperation<I, O>, args: I): Promise<O>;
-    withFlavor(name: string): Promise<Monorepo>;
+    withFlavor(flavorName: string): Promise<Monorepo>;
 }