@enspirit/emb 0.0.2 → 0.0.4

package/dist/src/cli/commands/tasks/run.js

@@ -0,0 +1,113 @@
+import { getContext } from '../../../index.js';
+import { Args, Command, Flags } from '@oclif/core';
+import { Listr } from 'listr2';
+import { PassThrough } from 'node:stream';
+import { getContainer, ListContainersOperation } from '../../../docker/index.js';
+import { dockerExecutor } from '../../../executors/docker.js';
+import { ExecutorType } from '../../../executors/index.js';
+import { shellExecutor } from '../../../executors/shell.js';
+export default class RunTask extends Command {
+    static args = {
+        task: Args.string({
+            description: 'List of tasks ids to run (eg: component:task)',
+            required: false,
+        }),
+    };
+    static description = 'Run a task.';
+    static enableJsonFlag = true;
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        executor: Flags.string({
+            char: 'x',
+            name: 'executor',
+            options: Object.keys(ExecutorType),
+        }),
+    };
+    static strict = false;
+    async run() {
+        const { argv, flags } = await this.parse(RunTask);
+        const context = await getContext();
+        const { monorepo } = context;
+        const toRun = argv.length > 0
+            ? argv.reduce((tasks, t) => {
+                const found = monorepo.tasks.filter((task) => task.id === t);
+                if (found.length === 0) {
+                    throw new Error(`Task ${t} not found`);
+                }
+                return [...tasks, ...found];
+            }, [])
+            : monorepo.tasks;
+        const runTasks = toRun.map((task) => {
+            return {
+                rendererOptions: { persistentOutput: true },
+                task: async (_ctx, listrTask) => {
+                    const type = flags.executor
+                        ? flags.executor
+                        : ExecutorType.container;
+                    const logStream = await monorepo.store.createWriteStream(`logs/tasks/run/${task.id}.log`);
+                    // Gonna log on both the logStream and stdout
+                    const tee = new PassThrough();
+                    tee.pipe(listrTask.stdout());
+                    tee.pipe(logStream);
+                    switch (type) {
+                        case ExecutorType.container: {
+                            return this.dockerExec(task, tee);
+                        }
+                        case ExecutorType.local: {
+                            return this.shellExec(task, tee);
+                        }
+                        default: {
+                            throw new Error(`Unsupported executor: ${type}`);
+                        }
+                    }
+                },
+                title: `Running ${task.id}`,
+            };
+        });
+        const runner = new Listr([
+            {
+                rendererOptions: { persistentOutput: true },
+                async task(ctx, task) {
+                    return task.newListr(runTasks, {
+                        exitOnError: true,
+                        rendererOptions: { collapseSubtasks: false },
+                    });
+                },
+                title: 'Running tasks',
+            },
+        ]);
+        await runner.run();
+    }
+    async dockerExec(task, out) {
+        const { monorepo } = getContext();
+        const matching = await monorepo.run(new ListContainersOperation(), {
+            filters: {
+                label: [
+                    `emb/project=${monorepo.name}`,
+                    `emb/component=${task.component}`,
+                ],
+            },
+        });
+        if (matching.length === 0) {
+            throw new Error(`Could not find a running container for '${task.component}'`);
+        }
+        if (matching.length > 1) {
+            throw new Error(`More than one running container found for '${task.component}'`);
+        }
+        const container = await getContainer(matching[0].Id);
+        return dockerExecutor.run(task.script, {
+            container,
+            out,
+        });
+    }
+    async shellExec(task, out) {
+        const { monorepo } = getContext();
+        const cwd = task.component
+            ? monorepo.component(task.component).rootdir
+            : monorepo.rootDir;
+        return shellExecutor.run(task.script, {
+            cwd,
+            out,
+        });
+    }
+}

package/dist/src/cli/commands/up.d.ts

@@ -0,0 +1,10 @@
+import { FlavoredCommand } from '../index.js';
+export default class UpCommand extends FlavoredCommand<typeof UpCommand> {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {
+        'force-recreate': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,49 @@
+import { Flags } from '@oclif/core';
+import { Listr } from 'listr2';
+import { FlavoredCommand, getContext } from '../index.js';
+import { up } from '../../docker/index.js';
+export default class UpCommand extends FlavoredCommand {
+    static description = 'Start the whole project.';
+    static enableJsonFlag = true;
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        'force-recreate': Flags.boolean({
+            char: 'f',
+            default: false,
+            description: "Recreate containers even if their configuration and image haven't changed",
+            name: 'force-recreate',
+        }),
+    };
+    async run() {
+        const { monorepo } = getContext();
+        const runner = new Listr([
+            {
+                rendererOptions: { persistentOutput: true },
+                async task(ctx, task) {
+                    const process = await up({ cwd: monorepo.rootDir });
+                    const handleOutput = (chunk) => {
+                        const line = chunk.toString();
+                        task.output = line.trimEnd(); // This updates the live output in Listr
+                    };
+                    process.stdout?.on('data', handleOutput);
+                    process.stderr?.on('data', handleOutput);
+                    return new Promise((resolve, reject) => {
+                        process.on('exit', (code) => {
+                            if (code === 0) {
+                                resolve(null);
+                            }
+                            else {
+                                reject(new Error(`Command failed with code ${code}`));
+                            }
+                        });
+                        process.on('error', (err) => {
+                            reject(err);
+                        });
+                    });
+                },
+                title: 'Starting project',
+            },
+        ]);
+        await runner.run();
+    }
+}

package/dist/src/cli/constants.d.ts

@@ -0,0 +1,2 @@
+import { TableOptions } from '@oclif/table';
+export declare const TABLE_DEFAULTS: Partial<TableOptions<Record<string, unknown>>>;

package/dist/src/cli/constants.js

@@ -0,0 +1,6 @@
+export const TABLE_DEFAULTS = {
+    borderStyle: 'none',
+    headerOptions: {
+        formatter: 'constantCase',
+    },
+};

package/dist/src/cli/hooks/init.d.ts

@@ -0,0 +1,3 @@
+import { Hook } from '@oclif/core';
+declare const hook: Hook.Init;
+export default hook;

package/dist/src/cli/hooks/init.js

@@ -0,0 +1,27 @@
+import { setContext } from '../../index.js';
+import { Performance } from '@oclif/core';
+import Dockerode from 'dockerode';
+import { loadConfig } from '../../config/index.js';
+import { Monorepo } from '../../monorepo/index.js';
+const withMarker = async (owner, name, cb) => {
+    const marker = Performance.mark(owner, name);
+    const res = await cb();
+    marker?.stop();
+    return res;
+};
+const hook = async function (options) {
+    try {
+        const config = await withMarker('emb:config', 'load', () => loadConfig());
+        const monorepo = await withMarker('emb:monorepo', 'init', () => {
+            return new Monorepo(config).init();
+        });
+        setContext({
+            docker: new Dockerode(),
+            monorepo,
+        });
+    }
+    catch (error) {
+        options.context.error(error);
+    }
+};
+export default hook;

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

@@ -0,0 +1,3 @@
+export * from '../context.js';
+export * from './abstract/index.js';
+export * from './constants.js';

package/dist/src/cli/index.js

@@ -0,0 +1,3 @@
+export * from '../context.js';
+export * from './abstract/index.js';
+export * from './constants.js';

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

@@ -0,0 +1,5 @@
+import { Component, Flavor } from './schema.js';
+import { ComponentConfig, FlavorConfig, IMonorepoConfig, UserConfig } from './types.js';
+export declare const toFlavor: (flavor: Flavor) => FlavorConfig;
+export declare const toComponent: (cmp: Component) => ComponentConfig;
+export declare const toProjectConfig: (config: UserConfig, rootDir?: string) => IMonorepoConfig;

package/dist/src/config/convert.js

@@ -0,0 +1,48 @@
+import { resolve } from 'node:path';
+import { cwd } from 'node:process';
+export const toFlavor = (flavor) => {
+    return {
+        ...flavor,
+        components: flavor.components?.map(toComponent),
+    };
+};
+export const toComponent = (cmp) => {
+    return typeof cmp === 'string'
+        ? { context: cmp, name: cmp }
+        : cmp;
+};
+export const toProjectConfig = (config, rootDir) => {
+    const project = typeof config.project === 'string'
+        ? { name: config.project }
+        : config.project;
+    if (project.rootDir) {
+        project.rootDir = rootDir
+            ? resolve(rootDir, project.rootDir)
+            : project.rootDir;
+    }
+    else {
+        project.rootDir = rootDir || cwd();
+    }
+    const components = (config.components || []).map((cmp) => toComponent(cmp));
+    const { defaults, env, flavors, plugins, vars } = config;
+    return {
+        components,
+        defaults: {
+            ...defaults,
+            docker: {
+                ...defaults?.docker,
+                labels: {
+                    ...defaults?.docker?.labels,
+                    'emb/project': project.name,
+                },
+            },
+        },
+        env,
+        flavors: flavors?.map(toFlavor),
+        plugins,
+        project: {
+            ...project,
+        },
+        vars,
+    };
+};

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

@@ -0,0 +1,6 @@
+import { IMonorepoConfig } from './types.js';
+export * from './convert.js';
+export * from './types.js';
+export * from './validation.js';
+export declare const loadConfig: (force?: boolean) => Promise<IMonorepoConfig>;
+export declare const getConfig: () => IMonorepoConfig;

package/dist/src/config/index.js

@@ -0,0 +1,25 @@
+import { findUp } from 'find-up';
+import { dirname } from 'node:path';
+import { toProjectConfig } from './convert.js';
+import { validateUserConfig } from './validation.js';
+export * from './convert.js';
+export * from './types.js';
+export * from './validation.js';
+let config;
+export const loadConfig = async (force = false) => {
+    if (config && !force) {
+        return config;
+    }
+    const path = await findUp('.emb.yml');
+    if (!path) {
+        throw new Error('Could not find EMB config anywhere');
+    }
+    config = toProjectConfig(await validateUserConfig(path), dirname(path));
+    return config;
+};
+export const getConfig = () => {
+    if (!config) {
+        throw new Error(`Config not loaded, please use 'loadConfig' first`);
+    }
+    return config;
+};

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

@@ -0,0 +1,102 @@
+/**
+ * This file was automatically generated by json-schema-to-typescript.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run json-schema-to-typescript to regenerate this file.
+ */
+export type Component = string | {
+    /**
+     * The name of the component.
+     */
+    name: string;
+    /**
+     * The directory of the component.
+     */
+    context?: string;
+    /**
+     * A description of the component.
+     */
+    description?: string;
+    buildArgs?: {
+        [k: string]: unknown;
+    };
+    dependencies?: string[];
+    /**
+     * The stage to target for the build
+     */
+    target?: string;
+    /**
+     * The Dockerfile to use
+     */
+    dockerfile?: string;
+    tasks?: Task[];
+};
+export interface EMBConfigSchema {
+    project: string | {
+        /**
+         * The name of the project.
+         */
+        name: string;
+        /**
+         * The root directory of the project.
+         */
+        rootDir?: string;
+    };
+    plugins?: {
+        name: string;
+        config?: unknown;
+    }[];
+    /**
+     * Variables to install on the environment
+     */
+    env?: {
+        [k: string]: string;
+    };
+    /**
+     * Variables that will be accessible for string expansion
+     */
+    vars?: {
+        [k: string]: unknown;
+    };
+    defaults?: Defaults;
+    components?: Component[];
+    flavors?: Flavor[];
+}
+/**
+ * Default settings for build aspects
+ */
+export interface Defaults {
+    /**
+     * Default docker build settings
+     */
+    docker?: {
+        tag?: string;
+        target?: string;
+        buildArgs?: {
+            [k: string]: unknown;
+        };
+        labels?: {
+            [k: string]: string;
+        };
+        [k: string]: unknown;
+    };
+}
+export interface Task {
+    name: string;
+    description?: string;
+    script: string;
+    executor?: string;
+    options?: {
+        [k: string]: unknown;
+    };
+}
+export interface Flavor {
+    name: string;
+    /**
+     * Variables to install on the environment
+     */
+    env?: {
+        [k: string]: string;
+    };
+    components?: Component[];
+    defaults?: Defaults;
+}

package/dist/src/config/schema.js

@@ -0,0 +1,7 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated by json-schema-to-typescript.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run json-schema-to-typescript to regenerate this file.
+ */
+export {};

package/dist/src/config/schema.json

@@ -0,0 +1,209 @@
+{
+    "$id": "/schemas/config",
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "title": "EMB Config Schema",
+    "type": "object",
+    "properties": {
+        "project": {
+            "oneOf": [
+                {
+                    "type": "string",
+                    "minLength": 3,
+                    "description": "Shortcut for specifying the project name."
+                },
+                {
+                    "type": "object",
+                    "required": ["name"],
+                    "properties": {
+                        "name": {
+                            "type": "string",
+                            "minLength": 3,
+                            "description": "The name of the project."
+                        },
+                        "rootDir": {
+                            "type": "string",
+                            "minLength": 1,
+                            "description": "The root directory of the project."
+                        }
+                    },
+                    "additionalProperties": false
+                }
+            ]
+        },
+        "plugins": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "required": ["name"],
+                "properties": {
+                    "name": {
+                        "type": "string"
+                    },
+                    "config": {}
+                },
+                "additionalProperties": false
+            }
+        },
+        "env": {
+            "type": "object",
+            "description": "Variables to install on the environment",
+            "additionalProperties": {
+                "type": "string"
+            }
+        },
+        "vars": {
+            "type": "object",
+            "description": "Variables that will be accessible for string expansion",
+            "additionalProperties": true
+        },
+        "defaults": {
+            "$ref": "#/$defs/defaults"
+        },
+        "components": {
+            "type": "array",
+            "items": {
+                "$ref": "#/$defs/component"
+            }
+        },
+        "flavors": {
+            "type": "array",
+            "items": {
+                "$ref": "#/$defs/flavor"
+            }
+        }
+    },
+    "required": ["project"],
+    "additionalProperties": false,
+    "$defs": {
+        "defaults": {
+            "type": "object",
+            "description": "Default settings for build aspects",
+            "additionalProperties": false,
+            "properties": {
+                "docker": {
+                    "type": "object",
+                    "description": "Default docker build settings",
+                    "properties": {
+                        "tag": { "type": "string" },
+                        "target": { "type": "string" },
+                        "buildArgs": {
+                            "type": "object",
+                            "additionalProperties": true
+                        },
+                        "labels": {
+                            "type": "object",
+                            "additionalProperties": {
+                                "type": "string"
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "task": {
+            "type": "object",
+            "required": ["name", "script"],
+            "properties": {
+                "name": {
+                    "type": "string"
+                },
+                "description": {
+                    "type": "string"
+                },
+                "script": {
+                    "type": "string"
+                },
+                "executor": {
+                    "type": "string"
+                },
+                "options": {
+                    "type": "object",
+                    "additionalProperties": true
+                }
+            },
+            "additionalProperties": false
+        },
+        "component": {
+            "oneOf": [
+                {
+                    "type": "string",
+                    "minLength": 3,
+                    "description": "Shortcut for specifying the component name."
+                },
+                {
+                    "type": "object",
+                    "required": ["name"],
+                    "properties": {
+                        "name": {
+                            "type": "string",
+                            "minLength": 3,
+                            "description": "The name of the component."
+                        },
+                        "context": {
+                            "type": "string",
+                            "minLength": 1,
+                            "description": "The directory of the component."
+                        },
+                        "description": {
+                            "type": "string",
+                            "minLength": 1,
+                            "description": "A description of the component."
+                        },
+                        "buildArgs": {
+                            "type": "object",
+                            "properties": {},
+                            "additionalProperties": true
+                        },
+                        "dependencies": {
+                            "type": "array",
+                            "items": {
+                                "type": "string"
+                            }
+                        },
+                        "target": {
+                            "type": "string",
+                            "description": "The stage to target for the build"
+                        },
+                        "dockerfile": {
+                            "type": "string",
+                            "description": "The Dockerfile to use"
+                        },
+                        "tasks": {
+                            "type": "array",
+                            "items": {
+                                "$ref": "#/$defs/task"
+                            }
+                        }
+                    },
+                    "additionalProperties": false
+                }
+            ]
+        },
+        "flavor": {
+            "type": "object",
+            "required": ["name"],
+            "properties": {
+                "name": {
+                    "type": "string"
+                },
+                "env": {
+                    "type": "object",
+                    "description": "Variables to install on the environment",
+                    "additionalProperties": {
+                        "type": "string"
+                    }
+                },
+                "components": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/$defs/component"
+                    }
+                },
+                "defaults": {
+                    "$ref": "#/$defs/defaults"
+                }
+            },
+            "additionalProperties": false
+        }
+    }
+}

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

@@ -0,0 +1,43 @@
+import { EMBConfigSchema, Task } from './schema.js';
+export type UserConfig = EMBConfigSchema;
+export type IProjectConfig = {
+    name: string;
+    rootDir: string;
+};
+export type ComponentConfig = {
+    buildArgs?: Record<PropertyKey, string>;
+    context?: string;
+    dependencies?: Array<string>;
+    dockerfile?: string;
+    labels?: Record<string, string>;
+    name: string;
+    target?: string;
+    tasks?: Array<Task>;
+};
+export type DefaultSettings = {
+    docker?: {
+        buildArgs?: Record<string, unknown>;
+        labels?: Record<string, string>;
+        tag?: string;
+        target?: string;
+    };
+};
+export type FlavorConfig = {
+    components?: Array<ComponentConfig>;
+    defaults?: DefaultSettings;
+    env?: Record<string, string>;
+    name: string;
+};
+export type PluginConfig = {
+    config?: unknown;
+    name: string;
+};
+export type IMonorepoConfig = {
+    components: Array<ComponentConfig>;
+    defaults?: DefaultSettings;
+    env?: Record<string, string>;
+    flavors?: Array<FlavorConfig>;
+    plugins?: Array<PluginConfig>;
+    project: IProjectConfig;
+    vars?: Record<string, unknown>;
+};

package/dist/src/config/types.js

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