@quadnix/octo 0.0.2 → 0.0.4

package/src/models/image/image.model.ts

@@ -1,62 +0,0 @@
-import { resolve } from 'path';
-import { UnknownModel } from '../../app.type.js';
-import { Model } from '../../decorators/model.decorator.js';
-import { AModel } from '../model.abstract.js';
-import { IImage } from './image.interface.js';
-
-export interface IImageDockerOptions {
-  dockerfilePath: string;
-  buildArgs?: { [key: string]: string };
-  quiet?: boolean;
-}
-
-@Model()
-export class Image extends AModel<IImage, Image> {
-  readonly MODEL_NAME: string = 'image';
-
-  readonly dockerOptions: IImageDockerOptions;
-
-  readonly imageId: string;
-
-  readonly imageName: string;
-
-  readonly imageTag: string;
-
-  constructor(imageName: string, imageTag: string, options: IImageDockerOptions) {
-    super();
-    this.imageId = `${imageName}:${imageTag}`;
-    this.imageName = imageName;
-    this.imageTag = imageTag;
-
-    options.dockerfilePath = resolve(options.dockerfilePath);
-    this.dockerOptions = options;
-  }
-
-  getContext(): string {
-    const parents = this.getParents();
-    const app = parents['app'][0].to;
-    return [`${this.MODEL_NAME}=${this.imageId}`, app.getContext()].join(',');
-  }
-
-  synth(): IImage {
-    return {
-      dockerOptions: {
-        buildArgs: { ...this.dockerOptions.buildArgs },
-        dockerfilePath: this.dockerOptions.dockerfilePath,
-        quiet: this.dockerOptions.quiet,
-      },
-      imageId: this.imageTag,
-      imageName: this.imageName,
-      imageTag: this.imageTag,
-    };
-  }
-
-  static override async unSynth(
-    image: IImage,
-    deReferenceContext: (context: string) => Promise<UnknownModel>,
-  ): Promise<Image> {
-    return new Image(image.imageName, image.imageTag, {
-      ...image.dockerOptions,
-    });
-  }
-}

package/src/models/model.abstract.ts

@@ -1,324 +0,0 @@
-import { ModelType, UnknownModel } from '../app.type.js';
-import { Dependency } from '../functions/dependency/dependency.model.js';
-import { Diff, DiffAction } from '../functions/diff/diff.model.js';
-import { DiffUtility } from '../functions/diff/diff.utility.js';
-import { AAnchor } from '../overlays/anchor.abstract.js';
-import { IModel } from './model.interface.js';
-
-/**
- * This is the base implementation of the Model's interface,
- * and is used to define common functionality between all models.
- * All models are an extension of this class.
- */
-export abstract class AModel<I, T> implements IModel<I, T> {
-  abstract readonly MODEL_NAME: string;
-  readonly MODEL_TYPE: ModelType = ModelType.MODEL;
-
-  protected readonly anchors: AAnchor[] = [];
-
-  protected readonly dependencies: Dependency[] = [];
-
-  addChild(onField: keyof T | string, child: UnknownModel, toField: string): void {
-    // Check if child already has a dependency to self.
-    const cIndex = child.dependencies.findIndex((d) => Object.is(d.to, this));
-    if (cIndex !== -1 && child.dependencies[cIndex].isParentRelationship()) {
-      throw new Error('Found circular dependencies!');
-    }
-
-    const childToParentDependency = cIndex === -1 ? new Dependency(child, this) : child.dependencies[cIndex];
-    childToParentDependency.addBehavior(toField, DiffAction.ADD, onField as string, DiffAction.ADD);
-    childToParentDependency.addBehavior(toField, DiffAction.ADD, onField as string, DiffAction.UPDATE);
-    if (cIndex === -1) {
-      childToParentDependency.addChildRelationship(toField, onField as string);
-      child.dependencies.push(childToParentDependency);
-    }
-
-    // Check if parent already has a dependency to child.
-    const pIndex = this.dependencies.findIndex((d) => Object.is(d.to, child));
-    if (pIndex !== -1 && this.dependencies[pIndex].isChildRelationship()) {
-      throw new Error('Found circular dependencies!');
-    }
-    const parentToChildDependency = pIndex === -1 ? new Dependency(this, child) : this.dependencies[pIndex];
-    parentToChildDependency.addBehavior(onField as string, DiffAction.DELETE, toField, DiffAction.DELETE);
-    if (pIndex === -1) {
-      parentToChildDependency.addParentRelationship(onField as string, toField);
-      this.dependencies.push(parentToChildDependency);
-    }
-  }
-
-  addRelationship(onField: keyof T | string, to: UnknownModel, toField: string): void {
-    const thisToThatDependency = new Dependency(this, to);
-    thisToThatDependency.addBehavior(onField as string, DiffAction.ADD, toField, DiffAction.ADD);
-    thisToThatDependency.addBehavior(onField as string, DiffAction.ADD, toField, DiffAction.UPDATE);
-    this.dependencies.push(thisToThatDependency);
-    const thatToThisDependency = new Dependency(to, this);
-    thatToThisDependency.addBehavior(toField, DiffAction.DELETE, onField as string, DiffAction.DELETE);
-    to.dependencies.push(thatToThisDependency);
-  }
-
-  async diff(previous?: T): Promise<Diff[]> {
-    const childrenByModel = this.getChildren();
-    const childrenOfPreviousByModel = (previous as UnknownModel)?.getChildren() ?? {};
-
-    const diffs: Diff[] = [];
-    const modelsSeen: string[] = [];
-
-    for (const modelName in childrenByModel) {
-      const children = childrenByModel[modelName].map((d) => d.to);
-      const childrenOfPrevious = childrenOfPreviousByModel[modelName]?.map((d) => d.to) ?? [];
-      const field = childrenByModel[modelName][0].getRelationship()!.toField;
-      const childrenDiffs = await DiffUtility.diffModels(childrenOfPrevious, children, field as string);
-      diffs.push(...childrenDiffs);
-
-      modelsSeen.push(modelName);
-    }
-
-    for (const modelName in childrenOfPreviousByModel) {
-      if (modelsSeen.indexOf(modelName) !== -1) {
-        continue;
-      }
-
-      const children = [];
-      const childrenOfPrevious = childrenOfPreviousByModel[modelName].map((d) => d.to);
-      const field = childrenOfPreviousByModel[modelName][0].getRelationship()!.toField;
-      const childrenDiffs = await DiffUtility.diffModels(childrenOfPrevious, children, field as string);
-      diffs.push(...childrenDiffs);
-    }
-
-    return diffs;
-  }
-
-  /**
-   * Get an array of ancestors which must exist for self to exist.
-   */
-  getAncestors(): UnknownModel[] {
-    const members: UnknownModel[] = [this];
-    const membersProcessed: UnknownModel[] = [];
-
-    while (members.length > 0) {
-      const member = members.pop() as UnknownModel;
-
-      // Skip processing an already processed member.
-      if (membersProcessed.some((m) => m.getContext() === member.getContext())) {
-        continue;
-      }
-
-      for (const d of member.dependencies) {
-        // If in dependency I am not declared a parent, then d.to is either my parent or has a relationship to me.
-        // The behavior of that relationship should be that it must exist for me to exist.
-        if (
-          !d.isParentRelationship() &&
-          d.hasMatchingBehavior(undefined, DiffAction.ADD, undefined, DiffAction.ADD) &&
-          !membersProcessed.some((m) => m.getContext() === d.to.getContext())
-        ) {
-          members.push(d.to);
-        }
-      }
-
-      membersProcessed.push(member);
-    }
-
-    return membersProcessed;
-  }
-
-  getAnchor(anchorId: string): AAnchor | undefined {
-    return this.anchors.find((a) => a.anchorId === anchorId);
-  }
-
-  getAnchors(): AAnchor[] {
-    return this.anchors;
-  }
-
-  /**
-   * Get a boundary (sub graph) of a model, i.e. an array of models that must belong together.
-   * To generate a boundary, we must process all children and grand-children of self.
-   */
-  getBoundaryMembers(): UnknownModel[] {
-    if (this.MODEL_TYPE !== ModelType.MODEL) {
-      return [];
-    }
-
-    const extenders: UnknownModel[] = [this];
-    const members: UnknownModel[] = [];
-    const parentOf: { [key: string]: string[] } = {};
-
-    const pushToExtenders = (models: UnknownModel[]): void => {
-      models.forEach((model) => {
-        if (model.MODEL_TYPE !== ModelType.MODEL) {
-          return;
-        }
-        if (!members.some((m) => m.getContext() === model.getContext())) {
-          extenders.push(model);
-        }
-      });
-    };
-
-    while (extenders.length > 0) {
-      const model = extenders.pop() as UnknownModel;
-      const ancestors = model.getAncestors();
-
-      for (const ancestor of ancestors) {
-        // Skip processing an already processed ancestor.
-        if (members.some((m) => m.getContext() === ancestor.getContext())) {
-          continue;
-        }
-        // Skip processing Non-MODEL ancestors.
-        if (ancestor.MODEL_TYPE !== ModelType.MODEL) {
-          continue;
-        }
-        members.push(ancestor);
-
-        // Check for circular dependencies on ancestor.
-        for (const d of ancestor.dependencies) {
-          let childContext;
-          let parentContext;
-          if (d.isParentRelationship()) {
-            childContext = d.to.getContext();
-            parentContext = d.from.getContext();
-          } else if (d.isChildRelationship()) {
-            childContext = d.from.getContext();
-            parentContext = d.to.getContext();
-          } else {
-            // A relationship that is neither parent or child, will not be reported in circular dependency!
-            continue;
-          }
-
-          const seen: { [key: string]: boolean } = {};
-          const toProcess: string[] = [parentContext];
-          while (toProcess.length > 0) {
-            const context = toProcess.pop() as string;
-            if (seen[context]) {
-              throw new Error('Found circular dependencies!');
-            } else {
-              seen[context] = true;
-            }
-            toProcess.push(...(parentOf[context] || []));
-          }
-
-          if (!parentOf[childContext]) {
-            parentOf[childContext] = [];
-            parentOf[childContext].push(parentContext);
-          } else if (!parentOf[childContext].some((p) => p === parentContext)) {
-            parentOf[childContext].push(parentContext);
-          }
-        }
-      }
-
-      const children = model.getChildren();
-      for (const modelName in children) {
-        pushToExtenders(children[modelName].map((d) => d.to));
-      }
-
-      const dependents = model.dependencies
-        .filter((d) => !d.isParentRelationship() && !d.isChildRelationship())
-        .map((d) => d.to);
-      pushToExtenders(dependents);
-    }
-
-    return members;
-  }
-
-  getChild(modelName: string, filters: { key: string; value: any }[]): UnknownModel | undefined {
-    const dependency = this.getChildren(modelName)[modelName]?.find((d) =>
-      filters.every((c) => d.to[c.key] === c.value),
-    );
-    return dependency ? dependency.to : undefined;
-  }
-
-  getChildren(modelName?: string): { [key: string]: Dependency[] } {
-    return this.dependencies
-      .filter((d) => d.isParentRelationship() && (modelName ? d.to.MODEL_NAME === modelName : true))
-      .reduce((accumulator, currentValue) => {
-        if (!(currentValue.to.MODEL_NAME in accumulator)) {
-          accumulator[currentValue.to.MODEL_NAME] = [];
-        }
-        accumulator[currentValue.to.MODEL_NAME].push(currentValue);
-        return accumulator;
-      }, {});
-  }
-
-  abstract getContext(): string;
-
-  getParents(modelName?: string): { [key: string]: Dependency[] } {
-    return this.dependencies
-      .filter((d) => d.isChildRelationship() && (modelName ? d.to.MODEL_NAME === modelName : true))
-      .reduce((accumulator, currentValue) => {
-        if (!(currentValue.to.MODEL_NAME in accumulator)) {
-          accumulator[currentValue.to.MODEL_NAME] = [];
-        }
-        accumulator[currentValue.to.MODEL_NAME].push(currentValue);
-        return accumulator;
-      }, {});
-  }
-
-  hasAncestor(model: UnknownModel): boolean {
-    const modelParts = model
-      .getContext()
-      .split(',')
-      .map((p) => p.split('='));
-
-    const ancestors = this.getAncestors();
-    return ancestors.some((a) => {
-      const ancestorParts = a
-        .getContext()
-        .split(',')
-        .reduce((map, p) => {
-          const parts = p.split('=');
-          map[parts[0]] = parts[1];
-          return map;
-        }, {});
-
-      return modelParts.every((p) => ancestorParts[p[0]] === p[1]);
-    });
-  }
-
-  remove(ignoreDirectRelationships = false, dryRun = false): void {
-    // Verify model can be removed.
-    for (const dependency of this.dependencies) {
-      // When direct relationship is not ignored, this model can't be a parent or have direct relationships.
-      // When direct relationship is ignored, this model can't be a parent.
-      if (
-        (!ignoreDirectRelationships && !dependency.isChildRelationship()) ||
-        (ignoreDirectRelationships && dependency.isParentRelationship())
-      ) {
-        throw new Error('Cannot remove model until dependent models exist!');
-      }
-    }
-
-    if (dryRun) {
-      return;
-    }
-
-    // Removing all dependencies that points to this.
-    for (const dependency of this.dependencies) {
-      const index = dependency.to.dependencies.findIndex((d) => d.to.getContext() === this.getContext());
-      dependency.to.dependencies.splice(index, 1);
-    }
-  }
-
-  removeRelationship(model: UnknownModel): void {
-    for (let i = this.dependencies.length - 1; i >= 0; i--) {
-      const dependency = this.dependencies[i];
-      if (dependency.to.getContext() === model.getContext()) {
-        this.dependencies.splice(i, 1);
-      }
-    }
-
-    for (let i = model.dependencies.length - 1; i >= 0; i--) {
-      const dependency = model.dependencies[i];
-      if (dependency.to.getContext() === this.getContext()) {
-        model.dependencies.splice(i, 1);
-      }
-    }
-  }
-
-  abstract synth(): I;
-
-  static async unSynth(...args: unknown[]): Promise<UnknownModel> {
-    if (args.length > 4) {
-      throw new Error('Too many args in unSynth()');
-    }
-
-    throw new Error('Method not implemented! Use derived class implementation');
-  }
-}

package/src/models/model.interface.ts

@@ -1,42 +0,0 @@
-import { ModelType } from '../app.type.js';
-import { Diff } from '../functions/diff/diff.model.js';
-
-/**
- * Models are the building blocks that can be combined to create any infrastructure.
- * This interface outlines the basic structure that any model must have.
- * Models have fields (class properties), and functions.
- */
-export interface IModel<I, T> {
-  /**
-   * This is the unique name of the model.
-   * It is used to identify other instances of the same model.
-   */
-  readonly MODEL_NAME: string;
-
-  readonly MODEL_TYPE: ModelType;
-
-  /**
-   * Generate a diff comparing all children of self with previous instance.
-   * If previous does not exist, diff adds all children of self.
-   *
-   * Diff captures change. So fields that do not change, e.g. ID fields, do not need to be diffed.
-   */
-  diff(previous?: T): Promise<Diff[]>;
-
-  /**
-   * Generates a string representation of self, used to identify the uniqueness of the instance.
-   */
-  getContext(): string;
-
-  /**
-   * Generate a serializable representation of self as per model's interface.
-   */
-  synth(): I;
-}
-
-/**
- * Model Reference encapsulates identification information of self.
- */
-export interface IModelReference {
-  context: string;
-}

package/src/models/pipeline/pipeline.interface.ts

@@ -1,6 +0,0 @@
-import { Pipeline } from './pipeline.model.js';
-
-export interface IPipeline {
-  instructionSet: Pipeline['instructionSet'];
-  pipelineName: Pipeline['pipelineName'];
-}

package/src/models/pipeline/pipeline.model.ts

@@ -1,47 +0,0 @@
-import { UnknownModel } from '../../app.type.js';
-import { Model } from '../../decorators/model.decorator.js';
-import { DiffUtility } from '../../functions/diff/diff.utility.js';
-import { AModel } from '../model.abstract.js';
-import { Diff } from '../../functions/diff/diff.model.js';
-import { IPipeline } from './pipeline.interface.js';
-
-@Model()
-export class Pipeline extends AModel<IPipeline, Pipeline> {
-  readonly MODEL_NAME: string = 'pipeline';
-
-  readonly instructionSet: string[] = [];
-
-  readonly pipelineName: string;
-
-  constructor(pipelineName: string) {
-    super();
-    this.pipelineName = pipelineName;
-  }
-
-  override async diff(previous?: Pipeline): Promise<Diff[]> {
-    // Generate diff of instructionSet.
-    return DiffUtility.diffArray(previous || ({ instructionSet: [] } as unknown as Pipeline), this, 'instructionSet');
-  }
-
-  getContext(): string {
-    const parents = this.getParents();
-    const app = parents['app'][0].to;
-    return [`${this.MODEL_NAME}=${this.pipelineName}`, app.getContext()].join(',');
-  }
-
-  synth(): IPipeline {
-    return {
-      instructionSet: [...this.instructionSet],
-      pipelineName: this.pipelineName,
-    };
-  }
-
-  static override async unSynth(
-    pipeline: IPipeline,
-    deReferenceContext: (context: string) => Promise<UnknownModel>,
-  ): Promise<Pipeline> {
-    const newPipeline = new Pipeline(pipeline.pipelineName);
-    newPipeline.instructionSet.push(...pipeline.instructionSet);
-    return newPipeline;
-  }
-}

package/src/models/region/region.interface.ts

@@ -1,5 +0,0 @@
-import { Region } from './region.model.js';
-
-export interface IRegion {
-  regionId: Region['regionId'];
-}

package/src/models/region/region.model.spec.ts

@@ -1,162 +0,0 @@
-import { Environment } from '../environment/environment.model.js';
-import { Region } from './region.model.js';
-
-describe('Region UT', () => {
-  describe('addEnvironment()', () => {
-    it('should throw error if duplicate environments exist', () => {
-      const t = (): void => {
-        const region = new Region('region-1');
-        region.addEnvironment(new Environment('qa'));
-        region.addEnvironment(new Environment('qa'));
-      };
-      expect(t).toThrowError('Environment already exists!');
-    });
-  });
-
-  describe('diff()', () => {
-    describe('when diff of environment', () => {
-      it('should capture addition', async () => {
-        const region0 = new Region('region-1');
-
-        const region1 = new Region('region-1');
-        const environment1 = new Environment('qa');
-        environment1.environmentVariables.set('key1', 'value 1');
-        environment1.environmentVariables.set('key2', 'value 2');
-        region1.addEnvironment(environment1);
-
-        const diff = await region1.diff(region0);
-
-        expect(diff).toMatchInlineSnapshot(`
-        [
-          {
-            "action": "add",
-            "field": "environmentName",
-            "value": "qa",
-          },
-          {
-            "action": "add",
-            "field": "environmentVariables",
-            "value": {
-              "key": "key1",
-              "value": "value 1",
-            },
-          },
-          {
-            "action": "add",
-            "field": "environmentVariables",
-            "value": {
-              "key": "key2",
-              "value": "value 2",
-            },
-          },
-        ]
-      `);
-      });
-
-      it('should capture update', async () => {
-        const region0 = new Region('region-1');
-        region0.addEnvironment(new Environment('qa'));
-
-        const region1 = new Region('region-1');
-        const environment1 = new Environment('qa');
-        environment1.environmentVariables.set('key', 'value');
-        region1.addEnvironment(environment1);
-
-        const diff = await region1.diff(region0);
-
-        expect(diff).toMatchInlineSnapshot(`
-        [
-          {
-            "action": "add",
-            "field": "environmentVariables",
-            "value": {
-              "key": "key",
-              "value": "value",
-            },
-          },
-        ]
-      `);
-      });
-
-      it('should capture replace', async () => {
-        const region0 = new Region('region-1');
-        region0.addEnvironment(new Environment('qa'));
-
-        const region1 = new Region('aws-ap-south-1');
-        region1.addEnvironment(new Environment('staging'));
-
-        const diff = await region1.diff(region0);
-
-        expect(diff).toMatchInlineSnapshot(`
-        [
-          {
-            "action": "delete",
-            "field": "environmentName",
-            "value": "qa",
-          },
-          {
-            "action": "add",
-            "field": "environmentName",
-            "value": "staging",
-          },
-        ]
-      `);
-      });
-
-      it('should capture deletion', async () => {
-        const region0 = new Region('region-1');
-        region0.addEnvironment(new Environment('qa'));
-
-        const region1 = new Region('region-1');
-
-        const diff = await region1.diff(region0);
-
-        expect(diff).toMatchInlineSnapshot(`
-        [
-          {
-            "action": "delete",
-            "field": "environmentName",
-            "value": "qa",
-          },
-        ]
-      `);
-      });
-
-      it('should capture diff without a previous instance', async () => {
-        const region = new Region('region-1');
-        const environment = new Environment('qa');
-        environment.environmentVariables.set('key1', 'value 1');
-        environment.environmentVariables.set('key2', 'value 2');
-        region.addEnvironment(environment);
-
-        const diff = await region.diff();
-
-        expect(diff).toMatchInlineSnapshot(`
-        [
-          {
-            "action": "add",
-            "field": "environmentName",
-            "value": "qa",
-          },
-          {
-            "action": "add",
-            "field": "environmentVariables",
-            "value": {
-              "key": "key1",
-              "value": "value 1",
-            },
-          },
-          {
-            "action": "add",
-            "field": "environmentVariables",
-            "value": {
-              "key": "key2",
-              "value": "value 2",
-            },
-          },
-        ]
-      `);
-      });
-    });
-  });
-});

package/src/models/region/region.model.ts

@@ -1,48 +0,0 @@
-import { UnknownModel } from '../../app.type.js';
-import { Model } from '../../decorators/model.decorator.js';
-import { Environment } from '../environment/environment.model.js';
-import { AModel } from '../model.abstract.js';
-import { IRegion } from './region.interface.js';
-
-@Model()
-export class Region extends AModel<IRegion, Region> {
-  readonly MODEL_NAME: string = 'region';
-
-  readonly regionId: string;
-
-  constructor(regionId: string) {
-    super();
-    this.regionId = regionId;
-  }
-
-  addEnvironment(environment: Environment): void {
-    const childrenDependencies = this.getChildren('environment');
-    if (!childrenDependencies['environment']) childrenDependencies['environment'] = [];
-
-    // Check for duplicates.
-    const environments = childrenDependencies['environment'].map((d) => d.to);
-    if (environments.find((e: Environment) => e.environmentName === environment.environmentName)) {
-      throw new Error('Environment already exists!');
-    }
-    this.addChild('regionId', environment, 'environmentName');
-  }
-
-  getContext(): string {
-    const parents = this.getParents();
-    const app = parents['app'][0].to;
-    return [`${this.MODEL_NAME}=${this.regionId}`, app.getContext()].join(',');
-  }
-
-  synth(): IRegion {
-    return {
-      regionId: this.regionId,
-    };
-  }
-
-  static override async unSynth(
-    region: IRegion,
-    deReferenceContext: (context: string) => Promise<UnknownModel>,
-  ): Promise<Region> {
-    return new Region(region.regionId);
-  }
-}