@enspirit/emb 0.0.9 → 0.1.1

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

@@ -1,8 +1,21 @@
-export type TaskInfo = {
-    component?: string;
-    description?: string;
+import { ComponentFlavorConfig, IResourceConfig, ProjectFlavorConfig, TaskConfig } from '../config/types.js';
+export type ComponentIdentifiable<T> = T & {
     id: string;
     name: string;
-    script?: string;
-    pre?: Array<string>;
+    component: string;
+};
+export type ResourceInfo = ComponentIdentifiable<IResourceConfig>;
+export type Resources = {
+    [k: string]: ResourceInfo;
+};
+export type ProjectFlavors = {
+    [k: string]: ProjectFlavorConfig;
+};
+export type ComponentFlavorInfo = ComponentIdentifiable<ComponentFlavorConfig>;
+export type ComponentFlavors = {
+    [k: string]: ComponentFlavorInfo;
+};
+export type TaskInfo = ComponentIdentifiable<TaskConfig>;
+export type Tasks = {
+    [k: string]: TaskInfo;
 };

package/dist/src/monorepo/utils/{findRunOrder.d.ts → EMBCollection.d.ts}

@@ -1,17 +1,17 @@
-type DepList = readonly string[] | string[] | undefined;
-type CollectionConfig<IDK extends PropertyKey, DPK extends PropertyKey> = {
+import { DepList } from './types.js';
+export type CollectionConfig<IDK extends PropertyKey, DPK extends PropertyKey> = {
     idField: IDK;
     depField: DPK;
     /** If true, throw when an item's id equals some other item's name (or vice versa). */
     forbidIdNameCollision?: boolean;
 };
-type AmbiguityPolicy = 'error' | 'runAll';
 export declare class EMBCollection<T extends Partial<Record<DPK, DepList>> & Record<IDK, string> & {
     name: string;
 }, IDK extends keyof T, DPK extends keyof T> {
     private items;
     readonly idField: IDK;
     readonly depField: DPK;
+    readonly forbidIdNameCollision: boolean;
     private byId;
     private byName;
     constructor(items: Iterable<T>, cfg: CollectionConfig<IDK, DPK>);
@@ -26,9 +26,3 @@ export declare class EMBCollection<T extends Partial<Record<DPK, DepList>> & Rec
         multiple: true;
     }): T[];
 }
-export declare function findRunOrder<T extends Partial<Record<DPK, DepList>> & Record<IDK, string> & {
-    name: string;
-}, IDK extends keyof T, DPK extends keyof T>(selection: readonly string[], collection: EMBCollection<T, IDK, DPK>, { onAmbiguous }?: {
-    onAmbiguous?: AmbiguityPolicy | undefined;
-}): T[];
-export {};

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

@@ -0,0 +1,101 @@
+import { AmbiguousReferenceError, ItemCollisionsError, UnkownReferenceError, } from '../../errors.js';
+export class EMBCollection {
+    items;
+    idField;
+    depField;
+    forbidIdNameCollision;
+    //
+    byId;
+    byName;
+    constructor(items, cfg) {
+        this.items = [];
+        this.idField = cfg.idField;
+        this.depField = cfg.depField;
+        this.forbidIdNameCollision = cfg.forbidIdNameCollision ?? true;
+        this.byId = new Map();
+        this.byName = new Map();
+        // single-pass validation state
+        const seenIds = new Set();
+        const seenNames = new Set();
+        const dupIdReports = [];
+        const collisions = [];
+        for (const t of items) {
+            const id = t[this.idField];
+            const { name } = t;
+            // duplicate id?
+            if (seenIds.has(id)) {
+                const firstOwner = this.byId.get(id); // first occurrence already stored
+                dupIdReports.push(`id \`${id}\` used by \`${firstOwner.name}\` and \`${name}\``);
+                // keep the first owner in byId; do not overwrite
+            }
+            else {
+                this.byId.set(id, t);
+                seenIds.add(id);
+            }
+            // --- Optional validation: forbid id <-> name collisions ---
+            if (this.forbidIdNameCollision) {
+                if (seenNames.has(id)) {
+                    const nameOwners = this.byName.get(id) ?? [];
+                    const ownerIds = nameOwners.map((o) => o[this.idField]).join(', ');
+                    collisions.push(`value \`${id}\` is an id of \`${name}\` and also a name of item(s) with id(s): [${ownerIds}]`);
+                }
+                if (seenIds.has(name)) {
+                    const idOwner = this.byId.get(name);
+                    collisions.push(`value \`${name}\` is a name of \`${t.name}\` and also an id of \`${idOwner.name}\``);
+                }
+            }
+            // byName index
+            const list = this.byName.get(name);
+            if (list) {
+                list.push(t);
+            }
+            else {
+                this.byName.set(name, [t]);
+            }
+            // keep item list (stable order)
+            this.items.push(t);
+            // record name after checks so current name won’t collide with itself
+            seenNames.add(name);
+        }
+        if (dupIdReports.length > 0 || collisions.length > 0) {
+            const parts = [];
+            if (dupIdReports.length > 0) {
+                parts.push(`Duplicate ${String(this.idField)} values (${dupIdReports.length}):\n` +
+                    dupIdReports.join('\n'));
+            }
+            if (collisions.length > 0) {
+                parts.push(`id↔name collisions (${collisions.length}):\n` +
+                    collisions.join('\n'));
+            }
+            throw new ItemCollisionsError('Collision between items', parts);
+        }
+    }
+    /** All items (stable array iteration) */
+    get all() {
+        return this.items;
+    }
+    idOf(t) {
+        return t[this.idField];
+    }
+    depsOf(t) {
+        return (t[this.depField] ?? []);
+    }
+    matches(ref, opts) {
+        const idHit = this.byId.get(ref);
+        if (idHit) {
+            return opts?.multiple ? [idHit] : idHit;
+        }
+        const nameHits = this.byName.get(ref) ?? [];
+        if (nameHits.length === 0) {
+            throw new UnkownReferenceError(`Unknown reference \`${ref}\``, ref);
+        }
+        if (opts?.multiple) {
+            return nameHits;
+        }
+        if (nameHits.length > 1) {
+            const names = nameHits.map((t) => this.idOf(t));
+            throw new AmbiguousReferenceError(`Ambiguous reference \`${ref}\` matches multiple names`, ref, names);
+        }
+        return nameHits[0];
+    }
+}

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

@@ -0,0 +1,15 @@
+import graphlib from 'graphlib';
+import { EMBCollection } from './EMBCollection.js';
+import { AmbiguityPolicy, DepList } from './types.js';
+export declare function resolveRefSet<T extends Partial<Record<DPK, DepList>> & Record<IDK, string> & {
+    name: string;
+}, IDK extends keyof T, DPK extends keyof T>(col: EMBCollection<T, IDK, DPK>, ref: string, policy: AmbiguityPolicy): string[];
+export declare function collectPredecessorClosure(g: graphlib.Graph, seeds: Iterable<string>): Set<string>;
+export declare function buildGraph<T extends Partial<Record<DPK, DepList>> & Record<IDK, string> & {
+    name: string;
+}, IDK extends keyof T, DPK extends keyof T>(col: EMBCollection<T, IDK, DPK>, policy: AmbiguityPolicy): graphlib.Graph;
+export declare function findRunOrder<T extends Partial<Record<DPK, DepList>> & Record<IDK, string> & {
+    name: string;
+}, IDK extends keyof T, DPK extends keyof T>(selection: readonly string[], collection: EMBCollection<T, IDK, DPK>, { onAmbiguous }?: {
+    onAmbiguous?: AmbiguityPolicy | undefined;
+}): T[];

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

@@ -0,0 +1,84 @@
+import graphlib from 'graphlib';
+import { CircularDependencyError } from '../../errors.js';
+/* ----------------- run-order helpers unchanged (for completeness) ---------------- */
+export function resolveRefSet(col, ref, policy) {
+    if (policy === 'runAll') {
+        return col.matches(ref, { multiple: true }).map((t) => col.idOf(t));
+    }
+    return [col.idOf(col.matches(ref))];
+}
+export function collectPredecessorClosure(g, seeds) {
+    const seen = new Set();
+    const q = [];
+    for (const s of seeds) {
+        if (!seen.has(s)) {
+            seen.add(s);
+            q.push(s);
+        }
+    }
+    while (q.length > 0) {
+        const cur = q.shift();
+        for (const p of g.predecessors(cur) ?? []) {
+            if (!seen.has(p)) {
+                seen.add(p);
+                q.push(p);
+            }
+        }
+    }
+    return seen;
+}
+export function buildGraph(col, policy) {
+    const g = new graphlib.Graph({ directed: true });
+    for (const t of col.all) {
+        g.setNode(col.idOf(t));
+    }
+    for (const t of col.all) {
+        const toId = col.idOf(t);
+        for (const ref of col.depsOf(t)) {
+            for (const fromId of resolveRefSet(col, ref, policy)) {
+                g.setEdge(fromId, toId);
+            }
+        }
+    }
+    return g;
+}
+export function findRunOrder(selection, collection, { onAmbiguous = 'error' } = {}) {
+    const g = buildGraph(collection, onAmbiguous);
+    const cycles = graphlib.alg.findCycles(g);
+    if (cycles.length > 0) {
+        throw new CircularDependencyError(`Circular dependencies detected: ${JSON.stringify(cycles)}`, cycles);
+    }
+    const selectedIds = new Set();
+    for (const ref of selection) {
+        for (const id of resolveRefSet(collection, ref, onAmbiguous)) {
+            selectedIds.add(id);
+        }
+    }
+    if (selectedIds.size === 0) {
+        throw new Error('Selection resolved to no items.');
+    }
+    const include = collectPredecessorClosure(g, selectedIds.values());
+    const sub = new graphlib.Graph({ directed: true });
+    for (const id of include) {
+        sub.setNode(id);
+    }
+    for (const id of include) {
+        for (const p of g.predecessors(id) ?? []) {
+            if (include.has(p)) {
+                sub.setEdge(p, id);
+            }
+        }
+    }
+    const ids = graphlib.alg.topsort(sub);
+    const byId = new Map();
+    for (const t of collection.all) {
+        byId.set(collection.idOf(t), t);
+    }
+    return ids.map((id) => {
+        const t = byId.get(id);
+        if (!t) {
+            throw new Error(`Internal error: missing item for id "${id}"`);
+        }
+        return t;
+    });
+}

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

@@ -1 +1,7 @@
-export * from './findRunOrder.js';
+import { ComponentIdentifiable } from '../../index.js';
+export * from './EMBCollection.js';
+export * from './graph.js';
+export * from './types.js';
+export declare const toIdentifedHash: <V, T extends {
+    [k: string]: V;
+}>(hash: T, parentName: string) => Record<string, ComponentIdentifiable<V>>;

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

@@ -1 +1,14 @@
-export * from './findRunOrder.js';
+export * from './EMBCollection.js';
+export * from './graph.js';
+export * from './types.js';
+export const toIdentifedHash = (hash, parentName) => {
+    return Object.entries(hash).reduce((hash, [key, value]) => {
+        hash[key] = {
+            ...value,
+            id: `${parentName}:${key}`,
+            name: key,
+            component: parentName,
+        };
+        return hash;
+    }, {});
+};

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

@@ -0,0 +1,2 @@
+export type DepList = readonly string[] | string[] | undefined;
+export type AmbiguityPolicy = 'error' | 'runAll';

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

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

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

@@ -1,10 +1,12 @@
 import { EmbContext } from '../../index.js';
 import * as z from 'zod';
 import { IOperation } from '../index.js';
+export type OpInput<A extends AbstractOperation<z.Schema, unknown>> = A extends AbstractOperation<infer I, unknown> ? z.infer<I> : never;
+export type OpOutput<A extends AbstractOperation<z.Schema, unknown>> = A extends AbstractOperation<z.Schema, infer O> ? O : never;
 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>;
+    run(input: unknown | z.infer<S>): Promise<O>;
 }

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

@@ -4,6 +4,9 @@ export class AbstractOperation {
     context;
     constructor(inputSchema) {
         this.inputSchema = inputSchema;
+        if (!inputSchema) {
+            throw new Error(`${this.constructor.name} does not call super() with validation schema`);
+        }
         this.context = getContext();
     }
     async run(input) {

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

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

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

@@ -1,5 +1,4 @@
-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>>;
+    collect(path: string): Promise<Array<FilePrerequisite>>;
 }

package/dist/src/prerequisites/GitPrerequisitePlugin.js

@@ -1,9 +1,9 @@
 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))
+    async collect(path) {
+        const repo = simpleGit(path);
+        return (await repo.raw('ls-files', path))
             .split('\n')
             .map((s) => s.trim())
             .filter(Boolean)

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

@@ -18,9 +18,9 @@ export interface FilePrerequisite extends Prerequisite<PrerequisiteType.file> {
 }
 export interface PrerequisitePlugin<T extends PrerequisiteType, P extends Prerequisite<T>, Output = unknown, Changes = unknown> {
     /**
-     * Collect/discover prerequisistes for a specific component
+     * Collect/discover prerequisistes for a path (relative to the monorepo root)
      */
-    collect?(component: Component): Promise<Array<P>>;
+    collect?(path: string): Promise<Array<P>>;
     /**
      * Returns the list of changes between the last collection and the new
      * collection.

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

@@ -15,7 +15,8 @@ export declare class TemplateExpander {
     private expansions;
     get expansionCount(): number;
     expand(str: string, options?: ExpandOptions): Promise<string>;
-    expandRecord<R extends Record<string, unknown>>(record: R, options?: ExpandOptions): Promise<R>;
+    expandRecord<R extends Record<string, unknown>>(record: R, options: ExpandOptions): Promise<R>;
+    expandRecord<R extends Array<unknown>>(record: R, options: ExpandOptions): Promise<R>;
     private track;
 }
 export {};

package/dist/src/utils/TemplateExpander.js

@@ -37,9 +37,11 @@ export class TemplateExpander {
             .replaceAll('\\${', '${'));
     }
     async expandRecord(record, options = {}) {
+        if (Array.isArray(record)) {
+            return Promise.all(record.map((v) => this.expand(v, 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));