@enspirit/emb 0.0.1 → 0.0.3

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

@@ -0,0 +1,30 @@
+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 class ComponentDiscoverPlugin extends AbstractPlugin {
+    static name = 'autodiscover';
+    async extendConfig(config) {
+        const files = await glob('*/Dockerfile', {
+            cwd: config.project.rootDir,
+        });
+        const overrides = files.map((path) => {
+            const name = dirname(path);
+            const component = config.components.find((cmp) => cmp.name === name);
+            const cfg = {
+                context: name,
+                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/plugins/DotEnvPlugin.d.ts

@@ -0,0 +1,5 @@
+import { AbstractPlugin } from './plugin.js';
+export declare class DotEnvPlugin extends AbstractPlugin<Array<string>> {
+    static name: string;
+    init(): Promise<void>;
+}

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

@@ -0,0 +1,11 @@
+import { configDotenv } from 'dotenv';
+import { AbstractPlugin } from './plugin.js';
+export class DotEnvPlugin extends AbstractPlugin {
+    static name = 'dotenv';
+    async init() {
+        configDotenv({
+            path: this.config.map((p) => this.monorepo.join(p)),
+            quiet: true,
+        });
+    }
+}

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

@@ -0,0 +1,7 @@
+import { AbstractPlugin } from './plugin.js';
+export * from './ComponentsDiscover.js';
+export * from './DotEnvPlugin.js';
+import { Monorepo } from '../monorepo.js';
+export type AbstractPluginConstructor = new <C, P extends AbstractPlugin<C>>(config: C, monorepo: Monorepo) => P;
+export declare const registerPlugin: (plugin: AbstractPluginConstructor) => void;
+export declare const getPlugin: (name: string) => AbstractPluginConstructor;

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

@@ -0,0 +1,20 @@
+export * from './ComponentsDiscover.js';
+export * from './DotEnvPlugin.js';
+import { ComponentDiscoverPlugin } from './ComponentsDiscover.js';
+import { DotEnvPlugin } from './DotEnvPlugin.js';
+const PluginRegistry = new Map();
+export const registerPlugin = (plugin) => {
+    if (PluginRegistry.has(plugin.name)) {
+        throw new Error(`Plugin name confict: '${plugin.name}' already registered`);
+    }
+    PluginRegistry.set(plugin.name, plugin);
+};
+export const getPlugin = (name) => {
+    if (!PluginRegistry.has(name)) {
+        throw new Error(`Unknown plugin: ${name}`);
+    }
+    return PluginRegistry.get(name);
+};
+/** Not sure why we need casting */
+registerPlugin(ComponentDiscoverPlugin);
+registerPlugin(DotEnvPlugin);

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

@@ -0,0 +1,15 @@
+import { Monorepo, MonorepoConfig } from '../index.js';
+export declare abstract class AbstractPlugin<C = unknown> {
+    protected config: C;
+    protected monorepo: Monorepo;
+    /**
+     * The name of the plugin (must be unique)
+     */
+    static name: string;
+    constructor(config: C, monorepo: Monorepo);
+    extendConfig?(config: MonorepoConfig): Promise<MonorepoConfig>;
+    /**
+     * Initialization of a plugin.
+     */
+    init?(): Promise<void>;
+}

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

@@ -0,0 +1,12 @@
+export class AbstractPlugin {
+    config;
+    monorepo;
+    /**
+     * The name of the plugin (must be unique)
+     */
+    static name;
+    constructor(config, monorepo) {
+        this.config = config;
+        this.monorepo = monorepo;
+    }
+}

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

@@ -0,0 +1,6 @@
+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

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

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

@@ -0,0 +1,20 @@
+import { Monorepo } from '../index.js';
+/**
+ * A first implementation of a "store" where
+ * everyone can create things (logs, sentinel files, ...)
+ *
+ * For now it's a hidden folder on the root of the monorepo
+ */
+export declare class EMBStore {
+    private monorepo;
+    private path;
+    constructor(monorepo: Monorepo, dirname?: string);
+    createReadStream(path: string): Promise<import("fs").ReadStream>;
+    createWriteStream(path: string, flags?: string | undefined): Promise<import("fs").WriteStream>;
+    init(): Promise<void>;
+    join(path: string): string;
+    mkdirp(path: string): Promise<void>;
+    readFile(path: string): Promise<Buffer<ArrayBufferLike>>;
+    trash(): Promise<void>;
+    writeFile(path: string, data: string): Promise<void>;
+}

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

@@ -0,0 +1,65 @@
+import { constants, createReadStream, createWriteStream } from 'node:fs';
+import { access, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { dirname, join, normalize } from 'node:path';
+/**
+ * A first implementation of a "store" where
+ * everyone can create things (logs, sentinel files, ...)
+ *
+ * For now it's a hidden folder on the root of the monorepo
+ */
+export class EMBStore {
+    monorepo;
+    path;
+    constructor(monorepo, dirname = '.emb') {
+        this.monorepo = monorepo;
+        this.path = this.monorepo.join(dirname);
+    }
+    async createReadStream(path) {
+        await this.mkdirp(dirname(path));
+        return createReadStream(this.join(path));
+    }
+    async createWriteStream(path, flags = 'w') {
+        await this.mkdirp(dirname(path));
+        return createWriteStream(this.join(path), {
+            flags: flags ?? 'w',
+        });
+    }
+    async init() {
+        let exists;
+        try {
+            await access(this.path, constants.F_OK);
+            exists = true;
+        }
+        catch {
+            exists = false;
+        }
+        if (exists) {
+            return;
+        }
+        try {
+            await mkdir(this.path, { recursive: true });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : error;
+            throw new Error(`Unable to create the emb store: ${msg}`);
+        }
+    }
+    join(path) {
+        return join(this.path, path);
+    }
+    async mkdirp(path) {
+        // Avoid getting out of the store by ensuring nothing goes past ../
+        const normalized = normalize(join('/', path));
+        await mkdir(this.join(normalized), { recursive: true });
+    }
+    async readFile(path) {
+        return readFile(this.join(path));
+    }
+    async trash() {
+        return rm(this.path, { force: true, recursive: true });
+    }
+    async writeFile(path, data) {
+        await this.mkdirp(dirname(path));
+        return writeFile(this.join(path), data);
+    }
+}

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

@@ -0,0 +1,7 @@
+export type TaskInfo = {
+    component?: string;
+    description?: string;
+    id: string;
+    name: string;
+    script: string;
+};

package/dist/src/monorepo/types.js

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

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

@@ -0,0 +1,2 @@
+import { Component } from '../index.js';
+export declare const findBuildOrder: (components: Array<Component>, selection?: Array<string>) => Array<Component>;

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

@@ -0,0 +1,41 @@
+import graphlib from 'graphlib';
+const toGraph = (components) => {
+    const graph = new graphlib.Graph();
+    // Add all components as nodes
+    for (const comp of components) {
+        graph.setNode(comp.name);
+    }
+    // Add edges
+    for (const comp of components) {
+        for (const dep of comp.dependencies ?? []) {
+            graph.setEdge(dep.name, comp.name);
+        }
+    }
+    return graph;
+};
+export const findBuildOrder = (components, selection) => {
+    const hash = components.reduce((cmps, cmp) => {
+        cmps[cmp.name] = cmp;
+        return cmps;
+    }, {});
+    const graph = toGraph(components);
+    // Detect cycles
+    const cycles = graphlib.alg.findCycles(graph);
+    if (cycles.length > 0) {
+        throw new Error('Circular dependencies detected: ' + JSON.stringify(cycles));
+    }
+    // Pick nodes that we want to build and rebuild a graph only with these
+    const toBuild = selection || components.map((c) => c.name);
+    const includingDeps = toBuild
+        .reduce((set, name) => {
+        graph.predecessors(name)?.forEach((name) => {
+            set.add(name);
+        });
+        return set;
+    }, new Set(toBuild))
+        .values();
+    const newGraph = toGraph([...includingDeps].map((name) => hash[name]));
+    // Get build order
+    const order = graphlib.alg.topsort(newGraph);
+    return order.map((name) => hash[name]);
+};

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

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

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

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

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

@@ -0,0 +1,10 @@
+import { EmbContext } from '../../index.js';
+import * as z from 'zod';
+import { IOperation } from '../types.js';
+export declare abstract class AbstractOperation<S extends z.Schema, O = unknown> implements IOperation<z.infer<S>, O> {
+    protected inputSchema: S;
+    protected context: EmbContext;
+    constructor(inputSchema: S);
+    protected abstract _run(input: z.infer<S>): Promise<O>;
+    run(input: z.infer<S>): Promise<O>;
+}

package/dist/src/operations/abstract/AbstractOperation.js

@@ -0,0 +1,13 @@
+import { getContext } from '../../index.js';
+export class AbstractOperation {
+    inputSchema;
+    context;
+    constructor(inputSchema) {
+        this.inputSchema = inputSchema;
+        this.context = getContext();
+    }
+    async run(input) {
+        const dressed = this.inputSchema.parse(input);
+        return this._run(dressed);
+    }
+}

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

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

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

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

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

@@ -0,0 +1,2 @@
+export * from './abstract/index.js';
+export * from './types.js';

package/dist/src/operations/index.js

@@ -0,0 +1,2 @@
+export * from './abstract/index.js';
+export * from './types.js';

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

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

package/dist/src/operations/types.js

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

package/dist/src/prerequisites/FilePrerequisitePlugin.d.ts

@@ -0,0 +1,7 @@
+import { Component } from '../monorepo/index.js';
+import { FilePrerequisite, PrerequisitePlugin, PrerequisiteType } from './types.js';
+export declare class FilePrerequisitePlugin implements PrerequisitePlugin<PrerequisiteType.file, FilePrerequisite, string> {
+    diff(component: Component, prerequisites: Array<FilePrerequisite>, previous: string, _actual: string): Promise<Array<FilePrerequisite> | null>;
+    meta(component: Component, prerequisites: FilePrerequisite[], mode: 'post' | 'pre'): Promise<string>;
+    private getStats;
+}

package/dist/src/prerequisites/FilePrerequisitePlugin.js

@@ -0,0 +1,41 @@
+import { stat } from 'node:fs/promises';
+import pMap from 'p-map';
+export class FilePrerequisitePlugin {
+    async diff(component, prerequisites, previous, _actual) {
+        const stats = await this.getStats(component, prerequisites);
+        const changes = stats
+            .filter((s) => {
+            return s.mtimeMs > Number.parseInt(previous, 10);
+        })
+            .map((s) => ({
+            path: s.path,
+            type: s.type,
+        }));
+        return changes.length > 0 ? changes : null;
+    }
+    async meta(component, prerequisites, mode) {
+        switch (mode) {
+            case 'post': {
+                return Date.now().toString();
+            }
+            case 'pre': {
+                const stats = await this.getStats(component, prerequisites);
+                const max = stats.reduce((minimum, stat) => {
+                    return Math.max(minimum, stat.mtimeMs);
+                }, 0);
+                return max.toFixed(0).toString();
+            }
+            default: {
+                throw new Error(`Invalid mode passed to 'meta()': ${mode}`);
+            }
+        }
+    }
+    async getStats(component, prerequisites) {
+        return pMap(prerequisites, async (file) => {
+            return {
+                ...file,
+                ...(await stat(component.join(file.path))),
+            };
+        }, { concurrency: 30 });
+    }
+}

package/dist/src/prerequisites/GitPrerequisitePlugin.d.ts

@@ -0,0 +1,5 @@
+import { Component } from '../monorepo/index.js';
+import { FilePrerequisite, PrerequisitePlugin, PrerequisiteType } from './types.js';
+export declare class GitPrerequisitePlugin implements PrerequisitePlugin<PrerequisiteType.file, FilePrerequisite> {
+    collect(component: Component): Promise<Array<FilePrerequisite>>;
+}

package/dist/src/prerequisites/GitPrerequisitePlugin.js

@@ -0,0 +1,17 @@
+import { simpleGit } from 'simple-git';
+import { PrerequisiteType, } from './types.js';
+export class GitPrerequisitePlugin {
+    async collect(component) {
+        const repo = simpleGit(component.rootdir);
+        return (await repo.raw('ls-files', component.rootdir))
+            .split('\n')
+            .map((s) => s.trim())
+            .filter(Boolean)
+            .map((path) => {
+            return {
+                path,
+                type: PrerequisiteType.file,
+            };
+        });
+    }
+}

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

@@ -0,0 +1,3 @@
+export * from './FilePrerequisitePlugin.js';
+export * from './GitPrerequisitePlugin.js';
+export * from './types.js';

package/dist/src/prerequisites/index.js

@@ -0,0 +1,3 @@
+export * from './FilePrerequisitePlugin.js';
+export * from './GitPrerequisitePlugin.js';
+export * from './types.js';

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

@@ -0,0 +1,46 @@
+import { Component } from '../monorepo/index.js';
+export declare enum PrerequisiteType {
+    file = "file",
+    variable = "variable"
+}
+/**
+ * A prerequisite must at least include its type name
+ */
+export interface Prerequisite<T extends PrerequisiteType | string> {
+    type: T;
+}
+/**
+ * A file-like prerequisite includes at least its path
+ */
+export interface FilePrerequisite extends Prerequisite<PrerequisiteType.file> {
+    path: string;
+    type: PrerequisiteType.file;
+}
+export interface PrerequisitePlugin<T extends PrerequisiteType, P extends Prerequisite<T>, Output = unknown, Changes = unknown> {
+    /**
+     * Collect/discover prerequisistes for a specific component
+     */
+    collect?(component: Component): Promise<Array<P>>;
+    /**
+     * Returns the list of changes between the last collection and the new
+     * collection.
+     * Eg:
+     *   list of files that have changed since the last build
+     *   list of variables/value that have changed since the last build
+     *
+     * In case nothing has changed, the plugin must resolve to null
+     */
+    diff?(component: Component, prerequisistes: Array<P>, previous: Output, actual: Output): Promise<Changes | null>;
+    /**
+     * Computes the meta-information for a list of prerequisites
+     * this meta information will be saved and used later to decide whether
+     *
+     * The mode specifies if the computation is made before a build is triggered
+     * (and before deciding if the build should be triggered)
+     * or after a new build has been made
+     *
+     * or not a component needs to rebuild
+     * (eg: some prerequisite files have changed, some vars have changed, etc)
+     */
+    meta?(component: Component, prerequisites: Array<P>, mode: 'post' | 'pre'): Promise<Output>;
+}

package/dist/src/prerequisites/types.js

@@ -0,0 +1,24 @@
+// Prerequisites
+export var PrerequisiteType;
+(function (PrerequisiteType) {
+    PrerequisiteType["file"] = "file";
+    PrerequisiteType["variable"] = "variable";
+})(PrerequisiteType || (PrerequisiteType = {}));
+// Checker for files:
+//
+// Collect all files a component depends on
+// and compute their last updated time
+//
+// No previous build available for this checker?
+//   -> build and then return now() as output
+// Previous build? receive the last output (now())
+// and compare it with most recent prerequisite.
+// Checker for variables:
+//
+// Collect all variables a component depends on
+// and compute a hash key=>value
+//
+// No previous build available for this checker?
+//   -> build and then return the hash as output
+// Previous build? receive the last output (hash)
+// and compare it with current hash -> different ? true : false

package/dist/src/types.d.ts

@@ -0,0 +1,13 @@
+import type Docker from 'dockerode';
+import { Monorepo } from './monorepo/index.js';
+/**
+ * The context is meant to be what all plugins can decorate
+ * to install their own things
+ *
+ * Similar to Request in Expressjs projects, feel free to extend the type
+ * and install here things that to be accessible by operations during a CLI run
+ */
+export interface EmbContext {
+    docker: Docker;
+    monorepo: Monorepo;
+}

package/dist/src/types.js

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

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

@@ -0,0 +1,21 @@
+type ExpandOptions = {
+    default?: string;
+    sources?: Record<string, Record<string, unknown>>;
+};
+export type ExpansionHistory = {
+    source: string;
+    value: unknown;
+    variable: string;
+};
+export declare class TemplateExpander {
+    /**
+     * Keep track of the sources used for expansions
+     * (track source, name, final value)
+     */
+    private expansions;
+    get expansionCount(): number;
+    expand(str: string, options?: ExpandOptions): Promise<string>;
+    expandRecord<R extends Record<string, unknown>>(record: R, options?: ExpandOptions): Promise<R>;
+    private track;
+}
+export {};

package/dist/src/utils/TemplateExpander.js

@@ -0,0 +1,53 @@
+const TPL_REGEX = /(?<!\\)\${(?:(\w+):)?(\w+)(?::-(.*?))?}/g;
+export class TemplateExpander {
+    /**
+     * Keep track of the sources used for expansions
+     * (track source, name, final value)
+     */
+    expansions = [];
+    get expansionCount() {
+        return this.expansions.length;
+    }
+    async expand(str, options = {}) {
+        return ((str || '')
+            .toString()
+            // Expand variables
+            .replaceAll(TPL_REGEX, (match, source, key, fallback) => {
+            const src = source || options.default;
+            const provider = options.sources?.[src];
+            if (!provider) {
+                if (fallback !== undefined) {
+                    return this.track(src, key, fallback);
+                }
+                throw new Error(`Invalid expand provider '${source}' ('${match}')`);
+            }
+            const val = provider[key];
+            // fallback is undefined when not even the :- is present
+            // we consider a variable like ${source:key:-} like the information
+            // that the variable can be an empty string if not present
+            if (!val && fallback === undefined) {
+                throw new Error(`Could not expand '${match}' and no default value provided`);
+            }
+            if (val !== undefined && val !== null) {
+                return this.track(src, key, val);
+            }
+            return this.track(src, key, fallback || '');
+        })
+            // Unescape non-variables left
+            .replaceAll('\\${', '${'));
+    }
+    async expandRecord(record, options = {}) {
+        return Object.entries(record).reduce(async (vars, [name, str]) => {
+            const previous = await vars;
+            // @ts-expect-error dunno
+            previous[name] = await (typeof str === 'object'
+                ? this.expandRecord(str, options)
+                : this.expand(str, options));
+            return previous;
+        }, Promise.resolve({}));
+    }
+    track(source, variable, value) {
+        this.expansions.push({ source, value, variable });
+        return value;
+    }
+}

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

@@ -0,0 +1 @@
+export declare const deepMergeArray: <T>(target: Array<T>, source: Array<T>, identifierFn?: (item: T) => unknown) => Array<T>;

package/dist/src/utils/deepMergeArray.js

@@ -0,0 +1,19 @@
+import deepmerge from '@fastify/deepmerge';
+export const deepMergeArray = (target, source, identifierFn) => {
+    if (!identifierFn) {
+        return deepmerge()(target, source);
+    }
+    const overridden = target.map((item) => {
+        const id = identifierFn(item);
+        const override = source.find((item) => identifierFn(item) === id);
+        if (override) {
+            return deepmerge()(item, override);
+        }
+        return item;
+    });
+    const additional = source.filter((item) => {
+        const id = identifierFn(item);
+        return !target.find((item) => identifierFn(item) === id);
+    });
+    return [...overridden, ...additional];
+};

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

@@ -0,0 +1,3 @@
+export * from './deepMergeArray.js';
+export * from './TemplateExpander.js';
+export * from './time.js';

package/dist/src/utils/index.js

@@ -0,0 +1,3 @@
+export * from './deepMergeArray.js';
+export * from './TemplateExpander.js';
+export * from './time.js';

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

@@ -0,0 +1,2 @@
+import { DateTime } from 'luxon';
+export declare const timeAgo: (date: Date | DateTime) => string;

package/dist/src/utils/time.js

@@ -0,0 +1,19 @@
+import { DateTime } from 'luxon';
+const units = [
+    'year',
+    'month',
+    'week',
+    'day',
+    'hour',
+    'minute',
+    'second',
+];
+export const timeAgo = (date) => {
+    const dateTime = date instanceof Date ? DateTime.fromJSDate(date) : date;
+    const diff = dateTime.diffNow().shiftTo(...units);
+    const unit = units.find((unit) => diff.get(unit) !== 0) || 'second';
+    const relativeFormatter = new Intl.RelativeTimeFormat('en', {
+        numeric: 'auto',
+    });
+    return relativeFormatter.format(Math.trunc(diff.as(unit)), unit);
+};