@enspirit/emb 0.4.0 → 0.4.2

package/README.md

@@ -14,7 +14,7 @@ $ npm install -g @enspirit/emb
 $ emb COMMAND
 running command...
 $ emb (--version)
-@enspirit/emb/0.4.0 darwin-x64 node-v22.12.0
+@enspirit/emb/0.4.2 darwin-x64 node-v22.18.0
 $ emb --help [COMMAND]
 USAGE
   $ emb COMMAND

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

@@ -20,9 +20,6 @@ export default class UpCommand extends FlavoredCommand {
         if (flags.force) {
             buildFlags.push('--force');
         }
-        if (flags.flavor) {
-            buildFlags.push('--flavor', flags.flavor);
-        }
         await this.config.runCommand('resources:build', buildFlags);
         await monorepo.run(new ComposeUpOperation(), {
             forceRecreate: flags.force,

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

@@ -13,8 +13,13 @@ export declare const BuildImageOperationInputSchema: z.ZodObject<{
     labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     target: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-export declare class BuildImageOperation extends AbstractOperation<typeof BuildImageOperationInputSchema, Array<unknown>> {
+export declare class BuildImageOperation extends AbstractOperation<typeof BuildImageOperationInputSchema, void> {
     private out?;
     constructor(out?: Writable | undefined);
-    protected _run(input: z.input<typeof BuildImageOperationInputSchema>): Promise<Array<unknown>>;
+    protected _run(input: z.input<typeof BuildImageOperationInputSchema>): Promise<void>;
+    protected _buildWithDockerCLI(input: z.input<typeof BuildImageOperationInputSchema>): Promise<void>;
+    /**
+     * Experimental with dockerode and the docker API directly
+     */
+    protected _buildWithDockerode(input: z.input<typeof BuildImageOperationInputSchema>): Promise<void>;
 }

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

@@ -1,3 +1,6 @@
+import { CommandExecError } from '../../../index.js';
+import { spawn } from 'node:child_process';
+import { join } from 'node:path';
 import { PassThrough } from 'node:stream';
 import * as z from 'zod';
 import { decodeBuildkitStatusResponse } from '../../index.js';
@@ -37,13 +40,61 @@ export class BuildImageOperation extends AbstractOperation {
         this.out = out;
     }
     async _run(input) {
-        const tee = new PassThrough();
+        return this._buildWithDockerCLI(input);
+    }
+    async _buildWithDockerCLI(input) {
+        const labels = Object.entries(input.labels || {})
+            .reduce((arr, [key, value]) => {
+            arr.push(`${key.trim()}=${value.trim()}`);
+            return arr;
+        }, [])
+            .join(',');
+        const args = [
+            'build',
+            input.context,
+            '-f',
+            join(input.context, input.dockerfile || 'Dockerfile'),
+            '--label',
+            labels,
+        ];
+        if (input.tag) {
+            args.push('--tag', input.tag);
+        }
+        if (input.target) {
+            args.push('--target', input.target);
+        }
+        Object.entries(input.buildArgs || []).forEach(([key, value]) => {
+            args.push('--build-arg', `${key.trim()}=${value.trim()}`);
+        });
         const logFile = await this.context.monorepo.store.createWriteStream(`logs/docker/build/${input.tag}.log`);
+        const tee = new PassThrough();
         tee.pipe(logFile);
         if (this.out) {
             tee.pipe(this.out);
         }
-        tee.write('Sending build context to Docker\n');
+        tee.write('Building image with opts: ' + JSON.stringify(args));
+        const child = await spawn('docker', args);
+        child.stderr.pipe(tee);
+        child.stdout.pipe(tee);
+        return new Promise((resolve, reject) => {
+            child.on('close', () => {
+                resolve();
+            });
+            child.on('exit', (code, signal) => {
+                if (code !== 0) {
+                    reject(new CommandExecError('Docker build failed', code || -1, signal));
+                }
+            });
+            child.on('error', (err) => {
+                reject(err);
+            });
+        });
+    }
+    /**
+     * Experimental with dockerode and the docker API directly
+     */
+    async _buildWithDockerode(input) {
+        const logFile = 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],
@@ -55,21 +106,22 @@ export class BuildImageOperation extends AbstractOperation {
             target: input.target,
             version: '2',
         });
-        tee.write('Starting build\n');
         return new Promise((resolve, reject) => {
-            this.context.docker.modem.followProgress(stream, (err, traces) => {
-                // logFile.close();
-                return err ? reject(err) : resolve(traces);
+            this.context.docker.modem.followProgress(stream, (err, _traces) => {
+                return err ? reject(err) : resolve();
             }, async (trace) => {
                 if (trace.error) {
-                    // logFile.close();
-                    reject(new Error(trace.error));
+                    logFile.write(trace.error + '\n');
+                    this.out?.write(trace.error + '\n');
+                    reject(trace.error);
                 }
                 else {
                     try {
                         const { vertexes } = await decodeBuildkitStatusResponse(trace.aux);
                         vertexes.forEach((v) => {
-                            tee.write(v.name + '\n');
+                            // logStream.write(JSON.stringify(v) + '\n');
+                            logFile.write(v.name + '\n');
+                            this.out?.write(v.name + '\n');
                         });
                     }
                     catch (error) {

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

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

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

@@ -0,0 +1,22 @@
+import * as z from 'zod';
+import { AbstractOperation } from '../../../operations/index.js';
+/**
+ * https://docs.docker.com/reference/api/engine/version/v1.37/#tag/Image/operation/ImagePush
+ */
+const schema = z.object({
+    images: z
+        .array(z.string())
+        .optional()
+        .describe('The names of images to push (The name should be provided without tag. Use the `tag` parameter to specify why tag to push)'),
+    tag: z
+        .string()
+        .optional()
+        .default('latest')
+        .describe('Tag of the images to push'),
+});
+export class PushImagesOperation extends AbstractOperation {
+    constructor() {
+        super(schema);
+    }
+    async _run(_input) { }
+}

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

@@ -2,15 +2,17 @@ import { fdir as Fdir } from 'fdir';
 import { stat, statfs } from 'node:fs/promises';
 import { join } from 'node:path';
 import pMap from 'p-map';
+import { SentinelFileBasedBuilder } from '../../monorepo/index.js';
 import { GitPrerequisitePlugin } from '../../prerequisites/index.js';
 import { ResourceFactory, } from '../../monorepo/resources/ResourceFactory.js';
 import { BuildImageOperation } from '../operations/index.js';
-class DockerImageResourceBuilder {
+class DockerImageResourceBuilder extends SentinelFileBasedBuilder {
     buildContext;
-    context;
+    dockerContext;
     constructor(buildContext) {
+        super(buildContext);
         this.buildContext = buildContext;
-        this.context = this.config.context
+        this.dockerContext = this.config?.context
             ? this.config.context[0] === '/'
                 ? buildContext.monorepo.join(this.config.context)
                 : buildContext.component.join(this.config.context)
@@ -20,72 +22,69 @@ class DockerImageResourceBuilder {
         return this.buildContext.monorepo;
     }
     get config() {
-        return (this.buildContext.config.params || {});
+        return this.buildContext.config.params;
     }
     get component() {
         return this.buildContext.component;
     }
-    async build(out) {
+    async _build(_resource, out) {
         // Ensure the folder exists
-        await statfs(this.context);
+        await statfs(this.dockerContext);
         const imageName = [
             this.monorepo.name,
-            this.config.tag || this.component.name,
+            this.config?.tag || this.component.name,
         ].join('/');
-        const tagName = this.config.tag || this.monorepo.defaults.docker?.tag || 'latest';
+        const tagName = this.config?.tag || this.monorepo.defaults.docker?.tag || 'latest';
         const crawler = new Fdir();
         const sources = await crawler
             .withRelativePaths()
-            .crawl(this.context)
+            .crawl(this.dockerContext)
             .withPromise();
         const buildParams = {
-            context: this.context,
-            dockerfile: this.config.dockerfile || 'Dockerfile',
+            context: this.dockerContext,
+            dockerfile: this.config?.dockerfile || 'Dockerfile',
             src: sources,
             buildArgs: await this.monorepo.expand({
                 ...this.monorepo.defaults.docker?.buildArgs,
-                ...this.config.buildArgs,
+                ...this.config?.buildArgs,
             }),
             tag: await this.monorepo.expand(`${imageName}:${tagName}`),
             labels: await this.monorepo.expand({
-                ...this.config.labels,
+                ...this.config?.labels,
                 'emb/project': this.monorepo.name,
                 'emb/component': this.component.name,
                 'emb/flavor': this.monorepo.currentFlavor,
             }),
-            target: this.config.target,
+            target: this.config?.target,
         };
         return {
             input: buildParams,
             operation: new BuildImageOperation(out),
         };
     }
-    async mustBuild(sentinel) {
+    async _mustBuild() {
         const plugin = new GitPrerequisitePlugin();
-        const sources = await plugin.collect(this.context);
+        const sources = await plugin.collect(this.dockerContext);
         const lastUpdated = await this.lastUpdatedInfo(sources);
-        if (!sentinel) {
-            return lastUpdated;
+        if (!lastUpdated) {
+            return;
         }
-        return lastUpdated && lastUpdated.time.getTime() > sentinel.mtime
-            ? lastUpdated
-            : undefined;
+        return { mtime: lastUpdated.time.getTime() };
     }
     async lastUpdatedInfo(sources) {
         const stats = await pMap(sources, async (s) => {
-            const stats = await stat(join(this.context, s.path));
+            const stats = await stat(join(this.dockerContext, s.path));
             return {
                 time: stats.mtime,
                 path: s.path,
             };
         }, { concurrency: 30 });
         if (stats.length === 0) {
-            return 0;
+            return;
         }
         return stats.reduce((last, entry) => {
             return last.time > entry.time ? last : entry;
         }, stats[0]);
     }
 }
-// Bring better abstraction and register as part of the plugin initialization
-ResourceFactory.register('docker/image', async (context) => new DockerImageResourceBuilder(context));
+ResourceFactory.register('docker/image', DockerImageResourceBuilder);

package/dist/src/errors.d.ts

@@ -72,6 +72,11 @@ export declare class MultipleContainersFoundError extends EMBError {
     component: string;
     constructor(msg: string, component: string);
 }
+export declare class CommandExecError extends EMBError {
+    exitCode: number;
+    signal?: (NodeJS.Signals | null) | undefined;
+    constructor(msg: string, exitCode: number, signal?: (NodeJS.Signals | null) | undefined);
+}
 export declare class ComposeExecError extends EMBError {
     exitCode: number;
     signal?: (NodeJS.Signals | null) | undefined;

package/dist/src/errors.js

@@ -95,6 +95,15 @@ export class MultipleContainersFoundError extends EMBError {
         this.component = component;
     }
 }
+export class CommandExecError extends EMBError {
+    exitCode;
+    signal;
+    constructor(msg, exitCode, signal) {
+        super('COMMAND_EXEC_ERR', msg);
+        this.exitCode = exitCode;
+        this.signal = signal;
+    }
+}
 export class ComposeExecError extends EMBError {
     exitCode;
     signal;

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

@@ -30,7 +30,9 @@ export declare class Monorepo {
     private installEnv;
     init(): Promise<Monorepo>;
     join(...paths: string[]): string;
-    run<I, O>(operation: IOperation<I, O>, args: I): Promise<O>;
+    run<I extends void, O>(operation: IOperation<I, O>): Promise<O>;
+    run<I extends void, O>(operation: IOperation<I, O>): Promise<O>;
+    run<I, O>(operation: IOperation<I, O>, input: I): Promise<O>;
     private expandPatches;
     withFlavor(flavorName: string): Promise<Monorepo>;
 }

package/dist/src/monorepo/monorepo.js

@@ -161,8 +161,11 @@ export class Monorepo {
     join(...paths) {
         return join(this.rootDir, ...paths);
     }
-    async run(operation, args) {
-        return operation.run(args);
+    run(operation, input = undefined) {
+        if (input === undefined) {
+            return operation.run();
+        }
+        return operation.run(input);
     }
     async expandPatches(patches) {
         const expanded = Promise.all(patches.map(async (patch) => {

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

@@ -1,3 +1,4 @@
+import { Writable } from 'node:stream';
 import * as z from 'zod';
 import { AbstractOperation } from '../../../operations/index.js';
 declare const schema: z.ZodObject<{
@@ -5,7 +6,8 @@ declare const schema: z.ZodObject<{
     force: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare class CreateFileOperation extends AbstractOperation<typeof schema, unknown> {
-    constructor();
+    protected out?: Writable | undefined;
+    constructor(out?: Writable | undefined);
     protected _run(input: z.input<typeof schema>): Promise<void>;
 }
 export {};

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

@@ -10,8 +10,10 @@ const schema = z.object({
         .describe("Update 'atime' and 'mtime' if the file already exists"),
 });
 export class CreateFileOperation extends AbstractOperation {
-    constructor() {
+    out;
+    constructor(out) {
         super(schema);
+        this.out = out;
     }
     async _run(input) {
         try {

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

@@ -1,12 +1,11 @@
 import * as z from 'zod';
-import { ResourceInfo } from '../../index.js';
-import { ResourceBuilderInfo } from '../../resources/ResourceFactory.js';
+import { IResourceBuilder, ResourceInfo } from '../../index.js';
 import { AbstractOperation } from '../../../operations/index.js';
 export type BuildResourceMeta = {
     dryRun?: boolean;
     force?: boolean;
     resource?: ResourceInfo;
-    builder?: ResourceBuilderInfo<unknown, unknown>;
+    builder?: IResourceBuilder<unknown, unknown, unknown>;
     builderInput?: unknown;
     sentinelData?: unknown;
     cacheHit?: boolean;
@@ -18,11 +17,9 @@ declare const schema: z.ZodObject<{
     force: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare class BuildResourcesOperation extends AbstractOperation<typeof schema, Record<string, BuildResourceMeta>> {
+    private built;
     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

@@ -1,7 +1,7 @@
 import { PRESET_TIMER, } from 'listr2';
 import * as z from 'zod';
 import { EMBCollection, findRunOrder, taskManagerFactory, } from '../../index.js';
-import { ResourceFactory, } from '../../resources/ResourceFactory.js';
+import { ResourceFactory } from '../../resources/ResourceFactory.js';
 import { AbstractOperation } from '../../../operations/index.js';
 const schema = z.object({
     resources: z
@@ -22,6 +22,9 @@ const schema = z.object({
         .describe('Bypass the cache and force the build'),
 });
 export class BuildResourcesOperation extends AbstractOperation {
+    // keep track of what has been built
+    // to ensure depedencies cannot ignore their turn
+    built = [];
     constructor() {
         super(schema);
     }
@@ -92,16 +95,19 @@ export class BuildResourcesOperation extends AbstractOperation {
                 /** Skip the build if the builder knows it can be skipped */
                 task: async (ctx) => {
                     if (ctx.builder?.mustBuild) {
-                        const previousSentinelData = await this.readSentinelFile(resource);
-                        ctx.sentinelData =
-                            await ctx.builder.mustBuild(previousSentinelData);
+                        ctx.sentinelData = await ctx.builder.mustBuild(ctx.resource);
                         ctx.cacheHit = !ctx.sentinelData;
+                        // If one of our dependency was built, we force the re-build
+                        // despite the cache-hit
+                        const found = ctx.resource.dependencies?.find((d) => Boolean(this.built.find((r) => r.id === d)));
+                        ctx.force = ctx.force || Boolean(found);
                     }
                 },
             },
             {
-                title: `Build image for ${resource.id}`,
-                async task(ctx, task) {
+                rendererOptions: { persistentOutput: true },
+                title: `Build ${resource.id}`,
+                task: async (ctx, task) => {
                     const skip = (prefix) => {
                         parentTask.title = `${prefix} ${resource.id}`;
                         task.skip();
@@ -110,26 +116,28 @@ export class BuildResourcesOperation extends AbstractOperation {
                     if (ctx.cacheHit && !ctx.force && !ctx.dryRun) {
                         return skip('[cache hit]');
                     }
-                    const { input, operation } = await ctx.builder.build(task.stdout());
+                    const { input, operation } = await ctx.builder.build(ctx.resource, task.stdout());
                     ctx.builderInput = input;
+                    this.built.push(ctx.resource);
                     if (ctx.dryRun) {
                         return skip('[dry run]');
                     }
-                    return operation.run(ctx.builderInput);
+                    const output = await operation.run(ctx.builderInput);
+                    if (ctx.sentinelData) {
+                        ctx.builder.commit?.(ctx.resource, output, ctx.sentinelData);
+                    }
+                    return output;
                 },
             },
             {
                 // Return build meta data and dump
                 // cache data into sentinel file
-                task: async (ctx) => {
+                async task(ctx) {
                     if (ctx.builder) {
                         delete ctx.builder;
                     }
                     //
                     parentContext[resource.id] = ctx;
-                    if (ctx.sentinelData && !ctx.dryRun) {
-                        await this.storeSentinelData(resource, ctx.sentinelData);
-                    }
                 },
             },
         ], {
@@ -142,23 +150,4 @@ export class BuildResourcesOperation extends AbstractOperation {
         });
         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 stats = await this.context.monorepo.store.stat(path, false);
-        if (!stats) {
-            return undefined;
-        }
-        const data = await this.context.monorepo.store.readFile(path, false);
-        return {
-            data,
-            mtime: stats.mtime.getTime(),
-        };
-    }
 }

package/dist/src/monorepo/operations/shell/ExecuteLocalCommandOperation.d.ts

@@ -10,8 +10,8 @@ declare const schema: z.ZodObject<{
     workingDir: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare class ExecuteLocalCommandOperation extends AbstractOperation<typeof schema, Readable> {
-    protected out: Writable;
-    constructor(out: Writable);
+    protected out?: Writable | undefined;
+    constructor(out?: Writable | undefined);
     protected _run(input: z.input<typeof schema>): Promise<Readable>;
 }
 export {};

package/dist/src/monorepo/operations/shell/ExecuteLocalCommandOperation.js

@@ -27,7 +27,9 @@ export class ExecuteLocalCommandOperation extends AbstractOperation {
             cwd: input.workingDir,
             shell: true,
         });
-        process.all.pipe(this.out);
+        if (this.out) {
+            process.all.pipe(this.out);
+        }
         return process.all;
     }
 }

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

@@ -59,8 +59,6 @@ export class RunTasksOperation {
     async runDocker(task, out) {
         const { monorepo } = getContext();
         return monorepo.run(new ComposeExecOperation(out), {
-            attachStderr: true,
-            attachStdout: true,
             service: task.component,
             command: task.script,
         });

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

@@ -0,0 +1,15 @@
+import { Writable } from 'node:stream';
+import { CreateFileOperation, IResourceBuilder, ResourceInfo } from '../index.js';
+import { OpInput, OpOutput } from '../../operations/index.js';
+import { ResourceBuildContext } from './ResourceFactory.js';
+export declare class FileResourceBuilder implements IResourceBuilder<OpInput<CreateFileOperation>, OpOutput<CreateFileOperation>, void> {
+    protected context: ResourceBuildContext<OpInput<CreateFileOperation>>;
+    constructor(context: ResourceBuildContext<OpInput<CreateFileOperation>>);
+    build(resource: ResourceInfo<OpInput<CreateFileOperation>>, out?: Writable): Promise<{
+        input: {
+            path: string;
+            force?: boolean | undefined;
+        };
+        operation: CreateFileOperation;
+    }>;
+}

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

@@ -0,0 +1,19 @@
+import { CreateFileOperation, } from '../index.js';
+import { ResourceFactory } from './ResourceFactory.js';
+export class FileResourceBuilder {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    async build(resource, out) {
+        const input = {
+            path: this.context.component.join(resource.params?.path || resource.name),
+        };
+        return {
+            input,
+            operation: new CreateFileOperation(out),
+        };
+    }
+}
+// Bring better abstraction and register as part of the plugin initialization
+ResourceFactory.register('file', FileResourceBuilder);

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

@@ -1,34 +1,12 @@
-import { Component, Monorepo, ResourceInfo } from '../../index.js';
-import { Writable } from 'node:stream';
-import { IOperation } from '../../operations/types.js';
-export type ResourceBuildContext = {
-    config: ResourceInfo;
+import { Component, IResourceBuilder, Monorepo, ResourceInfo } from '../../index.js';
+export type ResourceBuildContext<I> = {
+    config: ResourceInfo<I>;
     component: Component;
     monorepo: Monorepo;
 };
-export type SentinelData<T = void> = {
-    mtime: number;
-    data: T;
-};
-export type ResourceBuilderInfo<I, O, D = unknown> = {
-    /**
-     * Returns input and operation required to actually
-     * build the resources.
-     * This allows the dry-run mechanism to be implemented outside
-     * resource builder implementations
-     *
-     * @param out The Writable to use to write logs
-     */
-    build(out?: Writable): Promise<{
-        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 type ResourceBuilderConstructor<I, O, R> = new (context: ResourceBuildContext<I>) => IResourceBuilder<I, O, R>;
 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>;
+    protected static types: Record<string, ResourceBuilderConstructor<any, any, any>>;
+    static register<I, O, R>(type: string, constructor: ResourceBuilderConstructor<I, O, R>): void;
+    static factor<I, O, R>(type: string, context: ResourceBuildContext<I>): IResourceBuilder<I, O, R>;
 }

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

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