@enspirit/emb 0.0.2 → 0.0.3

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

@@ -0,0 +1 @@
+export declare const validateUserConfig: (pathOrObject: string | unknown) => Promise<import("./types.js").IMonorepoConfig>;

package/dist/src/config/validation.js

@@ -0,0 +1,27 @@
+import { Ajv } from 'ajv';
+import { readFile, stat } from 'node:fs/promises';
+import yaml from 'yaml';
+import { toProjectConfig } from './convert.js';
+export const validateUserConfig = async (pathOrObject) => {
+    const ajv = new Ajv();
+    let userConfig;
+    if (typeof pathOrObject === 'string') {
+        if (await stat(pathOrObject)) {
+            const cfgYaml = (await readFile(pathOrObject)).toString();
+            userConfig = yaml.parse(cfgYaml.toString());
+        }
+        else {
+            throw new Error(`Could not find file: ${pathOrObject}`);
+        }
+    }
+    else {
+        userConfig = pathOrObject;
+    }
+    /*
+    if (!ajv.validate(configSchema, userConfig)) {
+      ajv.errors!.forEach((err) => console.error(err));
+      throw new Error(`Your .emb.yml is incorrect`);
+    }
+    */
+    return toProjectConfig(userConfig);
+};

package/dist/src/context.d.ts

@@ -0,0 +1,3 @@
+import { EmbContext } from './types.js';
+export declare const getContext: () => EmbContext;
+export declare const setContext: (ctx: EmbContext) => void;

package/dist/src/context.js

@@ -0,0 +1,7 @@
+let context;
+export const getContext = () => {
+    return context;
+};
+export const setContext = (ctx) => {
+    context = ctx;
+};

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

@@ -0,0 +1,7 @@
+export type DockerComposeOptions = {
+    cwd?: string;
+};
+export type UpOptions = DockerComposeOptions & {};
+export declare const up: (opts?: UpOptions) => Promise<import("child_process").ChildProcessWithoutNullStreams>;
+export type DownOptions = DockerComposeOptions & {};
+export declare const down: (opts?: UpOptions) => Promise<import("child_process").ChildProcessWithoutNullStreams>;

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

@@ -0,0 +1,13 @@
+import { spawn } from 'node:child_process';
+export const up = async (opts) => {
+    return spawn('docker', ['compose', 'up', '-d'], {
+        cwd: opts?.cwd,
+        env: process.env,
+    });
+};
+export const down = async (opts) => {
+    return spawn('docker', ['compose', 'down'], {
+        cwd: opts?.cwd,
+        env: process.env,
+    });
+};

package/dist/src/docker/containers/getContainer.d.ts

@@ -0,0 +1,2 @@
+import { Container } from 'dockerode';
+export declare const getContainer: (id: string) => Promise<Container>;

package/dist/src/docker/containers/getContainer.js

@@ -0,0 +1,5 @@
+import { getContext } from '../../index.js';
+export const getContainer = async (id) => {
+    const { docker } = getContext();
+    return docker.getContainer(id);
+};

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

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

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

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

package/dist/src/docker/images/buildImage.d.ts

@@ -0,0 +1,19 @@
+import { Writable } from 'node:stream';
+import { DockerComponentBuild } from '../index.js';
+import { Component } from '../../monorepo/index.js';
+export type MobyTrace = {
+    aux: unknown;
+    error?: string;
+    id: string;
+};
+export type Progress = {
+    error?: string;
+    name?: string;
+};
+export type DockerBuildExtraOptions = {
+    output?: Writable;
+};
+export type BuildDockerImageOutput = DockerComponentBuild & {
+    traces: Array<MobyTrace>;
+};
+export declare const buildDockerImage: (component: Component, opts?: DockerBuildExtraOptions, progress?: (progress: Progress) => void) => Promise<BuildDockerImageOutput | undefined>;

package/dist/src/docker/images/buildImage.js

@@ -0,0 +1,64 @@
+import { getContext } from '../../index.js';
+import { decodeBuildkitStatusResponse, getSentinelFile, } from '../index.js';
+import { FilePrerequisitePlugin } from '../../prerequisites/index.js';
+export const buildDockerImage = async (component, opts = {}, progress) => {
+    const cmp = await component.toDockerBuild();
+    const files = (cmp.prerequisites || []).map((f) => f.path);
+    const { docker, monorepo } = getContext();
+    /** SENTINEL LOGIC */
+    // TODO: make configurable
+    const prereqPlugin = new FilePrerequisitePlugin();
+    const preBuildMeta = await prereqPlugin.meta(component, cmp.prerequisites, 'pre');
+    const sentinelFile = getSentinelFile(component);
+    let lastValue;
+    try {
+        lastValue = (await monorepo.store.readFile(sentinelFile)).toString();
+    }
+    catch {
+        lastValue = undefined;
+    }
+    if (lastValue) {
+        const diff = await prereqPlugin.diff(component, cmp.prerequisites, lastValue, preBuildMeta);
+        if (!diff) {
+            return;
+        }
+    }
+    const stream = await docker.buildImage({
+        context: cmp.context,
+        src: [...files],
+    }, {
+        buildargs: cmp.buildArgs,
+        dockerfile: cmp.dockerfile,
+        labels: cmp.labels,
+        t: cmp.name + ':' + (cmp.tag || 'latest'),
+        target: cmp.target,
+        version: '2',
+    });
+    if (opts.output) {
+        stream.pipe(opts.output);
+    }
+    stream.on('close', async () => {
+        const sentinelValue = await prereqPlugin.meta(component, cmp.prerequisites, 'post');
+        await monorepo.store.writeFile(sentinelFile, sentinelValue);
+    });
+    return new Promise((resolve, reject) => {
+        docker.modem.followProgress(stream, (err, traces) => {
+            return err ? reject(err) : resolve({ ...cmp, traces });
+        }, async (trace) => {
+            if (trace.error) {
+                reject(new Error(trace.error));
+            }
+            else {
+                try {
+                    const { vertexes } = await decodeBuildkitStatusResponse(trace.aux);
+                    vertexes.forEach((v) => {
+                        progress?.(v);
+                    });
+                }
+                catch (error) {
+                    console.error(error);
+                }
+            }
+        });
+    });
+};

package/dist/src/docker/images/deleteImage.d.ts

@@ -0,0 +1,5 @@
+export type ImageRemoveOptions = {
+    force?: boolean;
+    removeAnonymousVolumes?: boolean;
+};
+export declare const deleteImage: (name: string, opts?: ImageRemoveOptions) => Promise<unknown>;

package/dist/src/docker/images/deleteImage.js

@@ -0,0 +1,6 @@
+import { getContext } from '../../index.js';
+export const deleteImage = async (name, opts) => {
+    const { docker } = getContext();
+    const image = await docker.getImage(name);
+    return image.remove(opts);
+};

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

@@ -0,0 +1,4 @@
+export * from './buildImage.js';
+export * from './deleteImage.js';
+export * from './listImages.js';
+export * from './pruneImages.js';

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

@@ -0,0 +1,4 @@
+export * from './buildImage.js';
+export * from './deleteImage.js';
+export * from './listImages.js';
+export * from './pruneImages.js';

package/dist/src/docker/images/listImages.d.ts

@@ -0,0 +1,2 @@
+import { ImageInfo, ListImagesOptions } from 'dockerode';
+export declare const listImages: (opts?: ListImagesOptions) => Promise<Array<ImageInfo>>;

package/dist/src/docker/images/listImages.js

@@ -0,0 +1,8 @@
+import { getContext } from '../../index.js';
+export const listImages = async (opts) => {
+    const { docker } = getContext();
+    const images = await docker.listImages({
+        ...opts,
+    });
+    return images;
+};

package/dist/src/docker/images/pruneImages.d.ts

@@ -0,0 +1,6 @@
+import { PruneImagesInfo } from 'dockerode';
+export type PruneImagesOptions = {
+    dangling?: boolean;
+    label?: Array<string>;
+};
+export declare const pruneImages: (opts?: PruneImagesOptions) => Promise<PruneImagesInfo>;

package/dist/src/docker/images/pruneImages.js

@@ -0,0 +1,8 @@
+import { getContext } from '../../index.js';
+export const pruneImages = async (opts) => {
+    const { docker } = getContext();
+    const info = await docker.pruneImages({
+        ...opts,
+    });
+    return info;
+};

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

@@ -0,0 +1,7 @@
+export * from './compose/index.js';
+export * from './containers/index.js';
+export * from './images/index.js';
+export * from './operations/index.js';
+export * from './protobuf/index.js';
+export * from './types.js';
+export * from './utils.js';

package/dist/src/docker/index.js

@@ -0,0 +1,7 @@
+export * from './compose/index.js';
+export * from './containers/index.js';
+export * from './images/index.js';
+export * from './operations/index.js';
+export * from './protobuf/index.js';
+export * from './types.js';
+export * from './utils.js';

package/dist/src/docker/operations/containers/ListContainersOperation.d.ts

@@ -0,0 +1,18 @@
+import { ContainerInfo } from 'dockerode';
+import * as z from 'zod';
+import { AbstractOperation } from '../../../operations/index.js';
+/**
+ * https://docs.docker.com/reference/api/engine/version/v1.37/#tag/Container/operation/ContainerList
+ */
+declare const schema: z.ZodOptional<z.ZodObject<{
+    all: z.ZodOptional<z.ZodBoolean>;
+    filters: z.ZodOptional<z.ZodObject<{
+        label: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    limit: z.ZodOptional<z.ZodInt>;
+}, z.core.$strip>>;
+export declare class ListContainersOperation extends AbstractOperation<typeof schema, Array<ContainerInfo>> {
+    constructor();
+    protected _run(input: z.input<typeof schema>): Promise<Array<ContainerInfo>>;
+}
+export {};

package/dist/src/docker/operations/containers/ListContainersOperation.js

@@ -0,0 +1,44 @@
+import * as z from 'zod';
+import { AbstractOperation } from '../../../operations/index.js';
+/**
+ * https://docs.docker.com/reference/api/engine/version/v1.37/#tag/Container/operation/ContainerList
+ */
+const schema = z
+    .object({
+    all: z
+        .boolean()
+        .optional()
+        .describe('Return all containers. By default, only running containers are shown'),
+    filters: z
+        .object({
+        label: z.array(z.string()).describe('Labels on the container'),
+    })
+        .optional()
+        .describe('Filters to process on the container list,'),
+    limit: z
+        .int()
+        .positive()
+        .optional()
+        .describe('Return this number of most recently created containers, including non-running ones.'),
+})
+    .optional();
+export class ListContainersOperation extends AbstractOperation {
+    constructor() {
+        super(schema);
+    }
+    async _run(input) {
+        let filters = {};
+        if (input?.filters?.label) {
+            filters.label = input.filters.label;
+        }
+        // Let's not even pass empty filters
+        if (Object.keys(filters).length === 0) {
+            filters = undefined;
+        }
+        return this.context.docker.listContainers({
+            all: input?.all,
+            filters,
+            limit: input?.limit,
+        });
+    }
+}

package/dist/src/docker/operations/containers/PruneContainersOperation.d.ts

@@ -0,0 +1,16 @@
+import { PruneContainersInfo } from 'dockerode';
+import * as z from 'zod';
+import { AbstractOperation } from '../../../operations/index.js';
+/**
+ * https://docs.docker.com/reference/api/engine/version/v1.37/#tag/Container/operation/ContainerPrune
+ */
+declare const schema: z.ZodOptional<z.ZodObject<{
+    filters: z.ZodOptional<z.ZodObject<{
+        label: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+export declare class PruneContainersOperation extends AbstractOperation<typeof schema, PruneContainersInfo> {
+    constructor();
+    protected _run(input: z.input<typeof schema>): Promise<PruneContainersInfo>;
+}
+export {};

package/dist/src/docker/operations/containers/PruneContainersOperation.js

@@ -0,0 +1,33 @@
+import * as z from 'zod';
+import { AbstractOperation } from '../../../operations/index.js';
+/**
+ * https://docs.docker.com/reference/api/engine/version/v1.37/#tag/Container/operation/ContainerPrune
+ */
+const schema = z
+    .object({
+    filters: z
+        .object({
+        label: z.array(z.string()).describe('Labels on the container'),
+    })
+        .optional()
+        .describe('Filters to process on the container list,'),
+})
+    .optional();
+export class PruneContainersOperation extends AbstractOperation {
+    constructor() {
+        super(schema);
+    }
+    async _run(input) {
+        let filters = {};
+        if (input?.filters?.label) {
+            filters.label = input.filters.label;
+        }
+        // Let's not even pass empty filters
+        if (Object.keys(filters).length === 0) {
+            filters = undefined;
+        }
+        return this.context.docker.pruneContainers({
+            filters,
+        });
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from './ListContainersOperation.js';
+export * from './PruneContainersOperation.js';

package/dist/src/docker/operations/containers/index.js

@@ -0,0 +1,2 @@
+export * from './ListContainersOperation.js';
+export * from './PruneContainersOperation.js';

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

@@ -0,0 +1,20 @@
+import * as z from 'zod';
+import { AbstractOperation } from '../../../operations/index.js';
+/**
+ * https://docs.docker.com/reference/api/engine/version/v1.37/#tag/Image/operation/ImageBuild
+ */
+declare const schema: z.ZodObject<{
+    buildArgs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    context: z.ZodString;
+    dockerfile: z.ZodString;
+    labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    src: z.ZodArray<z.ZodString>;
+    tag: z.ZodString;
+    target: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare class BuildImageOperation extends AbstractOperation<typeof schema, Array<unknown>> {
+    private observer?;
+    constructor(observer?: ((progress: string) => void) | undefined);
+    protected _run(input: z.input<typeof schema>): Promise<Array<unknown>>;
+}
+export {};

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

@@ -0,0 +1,69 @@
+import * as z from 'zod';
+import { decodeBuildkitStatusResponse } from '../../index.js';
+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'),
+    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.'),
+    src: z.array(z.string()),
+    tag: z.z
+        .string()
+        .describe('A name and optional tag to apply to the image in the name:tag'),
+    target: z.string().optional().describe('Target build stage'),
+});
+export class BuildImageOperation extends AbstractOperation {
+    observer;
+    constructor(observer) {
+        super(schema);
+        this.observer = observer;
+    }
+    async _run(input) {
+        const logStream = await this.context.monorepo.store.createWriteStream(`logs/docker/build/${input.tag}.log`);
+        const stream = await this.context.docker.buildImage({
+            context: input.context,
+            src: [...input.src],
+        }, {
+            buildargs: input.buildArgs,
+            dockerfile: input.dockerfile,
+            labels: input.labels,
+            t: input.tag,
+            target: input.target,
+            version: '2',
+        });
+        return new Promise((resolve, reject) => {
+            this.context.docker.modem.followProgress(stream, (err, traces) => {
+                logStream.close();
+                return err ? reject(err) : resolve(traces);
+            }, async (trace) => {
+                if (trace.error) {
+                    logStream.close();
+                    reject(new Error(trace.error));
+                }
+                else {
+                    try {
+                        const { vertexes } = await decodeBuildkitStatusResponse(trace.aux);
+                        vertexes.forEach((v) => {
+                            logStream.write(JSON.stringify(v) + '\n');
+                            this.observer?.(v.name);
+                        });
+                    }
+                    catch (error) {
+                        console.error(error);
+                    }
+                }
+            });
+        });
+    }
+}

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

@@ -0,0 +1,17 @@
+import { ImageInfo } from 'dockerode';
+import * as z from 'zod';
+import { AbstractOperation } from '../../../operations/index.js';
+/**
+ * https://docs.docker.com/reference/api/engine/version/v1.37/#tag/Image/operation/ImageList
+ */
+declare const schema: z.ZodOptional<z.ZodObject<{
+    all: z.ZodOptional<z.ZodBoolean>;
+    filters: z.ZodOptional<z.ZodObject<{
+        label: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+export declare class ListImagesOperation extends AbstractOperation<typeof schema, Array<ImageInfo>> {
+    constructor();
+    protected _run(input: z.input<typeof schema>): Promise<Array<ImageInfo>>;
+}
+export {};

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

@@ -0,0 +1,38 @@
+import * as z from 'zod';
+import { AbstractOperation } from '../../../operations/index.js';
+/**
+ * https://docs.docker.com/reference/api/engine/version/v1.37/#tag/Image/operation/ImageList
+ */
+const schema = z
+    .object({
+    all: z
+        .boolean()
+        .optional()
+        .describe('Show all images. Only images from a final layer (no children) are shown by default.'),
+    filters: z
+        .object({
+        label: z.array(z.string()).describe('Labels on the images'),
+    })
+        .optional()
+        .describe('Filters to process on the images list,'),
+})
+    .optional();
+export class ListImagesOperation extends AbstractOperation {
+    constructor() {
+        super(schema);
+    }
+    async _run(input) {
+        let filters = {};
+        if (input?.filters?.label) {
+            filters.label = input.filters.label;
+        }
+        // Let's not even pass empty filters
+        if (Object.keys(filters).length === 0) {
+            filters = undefined;
+        }
+        return this.context.docker.listImages({
+            all: input?.all,
+            filters,
+        });
+    }
+}

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

@@ -0,0 +1,16 @@
+import { PruneImagesInfo } from 'dockerode';
+import * as z from 'zod';
+import { AbstractOperation } from '../../../operations/index.js';
+/**
+ * https://docs.docker.com/reference/api/engine/version/v1.37/#tag/Image/operation/ImagePrune
+ */
+declare const schema: z.ZodOptional<z.ZodObject<{
+    filters: z.ZodOptional<z.ZodObject<{
+        label: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+export declare class PruneImagesOperation extends AbstractOperation<typeof schema, PruneImagesInfo> {
+    constructor();
+    protected _run(input: z.input<typeof schema>): Promise<PruneImagesInfo>;
+}
+export {};

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

@@ -0,0 +1,33 @@
+import * as z from 'zod';
+import { AbstractOperation } from '../../../operations/index.js';
+/**
+ * https://docs.docker.com/reference/api/engine/version/v1.37/#tag/Image/operation/ImagePrune
+ */
+const schema = z
+    .object({
+    filters: z
+        .object({
+        label: z.array(z.string()).describe('Labels on the images'),
+    })
+        .optional()
+        .describe('Filters to process on the images list,'),
+})
+    .optional();
+export class PruneImagesOperation extends AbstractOperation {
+    constructor() {
+        super(schema);
+    }
+    async _run(input) {
+        let filters = {};
+        if (input?.filters?.label) {
+            filters.label = input.filters.label;
+        }
+        // Let's not even pass empty filters
+        if (Object.keys(filters).length === 0) {
+            filters = undefined;
+        }
+        return this.context.docker.pruneImages({
+            filters,
+        });
+    }
+}

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

@@ -0,0 +1,3 @@
+export * from './BuildImageOperation.js';
+export * from './ListImagesOperation.js';
+export * from './PruneImagesOperation.js';

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

@@ -0,0 +1,3 @@
+export * from './BuildImageOperation.js';
+export * from './ListImagesOperation.js';
+export * from './PruneImagesOperation.js';

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

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

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

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

package/dist/src/docker/protobuf/control.proto

@@ -0,0 +1,48 @@
+syntax = "proto3";
+
+package moby.buildkit.v1;
+
+import "google/protobuf/timestamp.proto";
+
+message StatusResponse {
+	repeated Vertex vertexes = 1;
+	repeated VertexStatus statuses = 2;
+	repeated VertexLog logs = 3;
+	repeated VertexWarning warnings = 4;
+}
+
+message Vertex {
+	string digest = 1;
+	repeated string inputs = 2;
+	string name = 3;
+	bool cached = 4;
+	google.protobuf.Timestamp started = 5;
+	google.protobuf.Timestamp completed = 6;
+	string error = 7; // typed errors?
+}
+
+message VertexStatus {
+	string ID = 1;
+	string vertex = 2;
+	string name = 3;
+	int64 current = 4;
+	int64 total = 5;
+	google.protobuf.Timestamp timestamp = 6;
+	google.protobuf.Timestamp started = 7;
+	google.protobuf.Timestamp completed = 8;
+}
+
+message VertexLog {
+	string vertex = 1;
+	google.protobuf.Timestamp timestamp = 2;
+	int64 stream = 3;
+	bytes msg = 4;
+}
+
+message VertexWarning {
+	string vertex = 1;
+	int64 level = 2;
+	bytes short = 3;
+	repeated bytes detail = 4;
+	string url = 5;
+}

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

@@ -0,0 +1,5 @@
+import protobuf from 'protobufjs';
+export declare const loadControl: () => Promise<protobuf.Root>;
+export declare const decodeBuildkitStatusResponse: (str: Buffer | string) => Promise<{
+    [k: string]: any;
+}>;