@quadnix/octo 0.0.2 → 0.0.4

package/src/decorators/overlay.decorator.ts

@@ -1,10 +0,0 @@
-import { ModelSerializationService } from '../services/serialization/model/model-serialization.service.js';
-import { Container } from './container.js';
-
-export function Overlay(): (constructor: any) => void {
-  return function (constructor: any) {
-    Container.get(ModelSerializationService).then((modelSerializationService) => {
-      modelSerializationService.registerClass(constructor.name, constructor);
-    });
-  };
-}

package/src/decorators/resource.decorator.ts

@@ -1,10 +0,0 @@
-import { ResourceSerializationService } from '../services/serialization/resource/resource-serialization.service.js';
-import { Container } from './container.js';
-
-export function Resource(): (constructor: any) => void {
-  return function (constructor: any) {
-    Container.get(ResourceSerializationService).then((resourceSerializationService) => {
-      resourceSerializationService.registerClass(constructor.name, constructor);
-    });
-  };
-}

package/src/decorators/test-container.spec.ts

@@ -1,50 +0,0 @@
-import { jest } from '@jest/globals';
-import {
-  ModelSerializationService,
-  ModelSerializationServiceFactory,
-} from '../services/serialization/model/model-serialization.service.js';
-import { ResourceSerializationService } from '../services/serialization/resource/resource-serialization.service.js';
-import { Container } from './container.js';
-import { TestContainer } from './test-container.js';
-
-describe('TestContainer UT', () => {
-  beforeAll(() => {
-    // Register a new factory with metadata for testing purposes.
-    Container.registerFactory(ModelSerializationService, ModelSerializationServiceFactory, {
-      metadata: { test: 'true' },
-    });
-
-    TestContainer.create(
-      [
-        {
-          type: ModelSerializationService,
-          value: jest.fn(),
-        },
-        {
-          metadata: { test: 'true' },
-          type: ModelSerializationService,
-          value: 'My Mock',
-        },
-      ],
-      { factoryTimeoutInMs: 500 },
-    );
-  });
-
-  it('should replace old factory with new mock', async () => {
-    const modelSerializationService = await Container.get<jest.Mock>(ModelSerializationService as any);
-    expect(modelSerializationService.getMockName()).toBe('jest.fn()');
-  });
-
-  it('should replace old factory with metadata with new mock', async () => {
-    const modelSerializationService = await Container.get<string>(ModelSerializationService as any, {
-      metadata: { test: 'true' },
-    });
-    expect(modelSerializationService).toBe('My Mock');
-  });
-
-  it('should not replace old factory when no mock given', async () => {
-    const resourceSerializationService = await Container.get(ResourceSerializationService);
-    expect(typeof resourceSerializationService['getMockName']).toBe('undefined');
-    expect(typeof resourceSerializationService.serialize).toBe('function');
-  });
-});

package/src/decorators/test-container.ts

@@ -1,56 +0,0 @@
-import { Constructable } from '../app.type.js';
-import { DiffUtility } from '../functions/diff/diff.utility.js';
-import { Container } from './container.js';
-
-type Factory<T> = { create: () => Promise<T> };
-
-type FactoryMock<T> = {
-  metadata?: { [key: string]: string };
-  type: Constructable<T> | string;
-  value: T;
-};
-
-type TestContainerOptions = { factoryTimeoutInMs?: number };
-
-export class TestContainer {
-  private static createTestFactory<T>(mock: FactoryMock<T>): Factory<T> {
-    return class {
-      static mock: FactoryMock<T> = mock;
-
-      static async create(): Promise<T> {
-        return this.mock.value;
-      }
-    };
-  }
-
-  static create(mocks: FactoryMock<unknown>[], options: TestContainerOptions): void {
-    const oldFactories = { ...Container['factories'] };
-    Container.reset();
-
-    if (options.factoryTimeoutInMs) {
-      Container.setFactoryTimeout(options.factoryTimeoutInMs);
-    }
-
-    for (const mock of mocks) {
-      const mockClassName = typeof mock.type === 'string' ? mock.type : mock.type.name;
-      const mockMetadata = mock.metadata || {};
-      const registeredFactories = oldFactories[mockClassName] || [];
-      const matchingFactoryIndex = registeredFactories.findIndex((f) =>
-        DiffUtility.isObjectDeepEquals(f.metadata, mockMetadata),
-      );
-
-      if (matchingFactoryIndex > -1) {
-        oldFactories[mockClassName][matchingFactoryIndex].factory = this.createTestFactory(mock);
-      }
-    }
-
-    for (const name in oldFactories) {
-      for (const oldFactory of oldFactories[name]) {
-        Container.registerFactory(name, oldFactory.factory as Factory<unknown>, { metadata: oldFactory.metadata });
-        if (oldFactory.default) {
-          Container.setDefault(name, oldFactory.factory as Factory<unknown>);
-        }
-      }
-    }
-  }
-}

package/src/functions/dependency/dependency.model.spec.ts

@@ -1,43 +0,0 @@
-import { App } from '../../models/app/app.model.js';
-import { Environment } from '../../models/environment/environment.model.js';
-import { Region } from '../../models/region/region.model.js';
-import { DiffAction } from '../diff/diff.model.js';
-import { Dependency } from './dependency.model.js';
-
-describe('Dependency UT', () => {
-  describe('addBehavior()', () => {
-    it('should throw error when adding behavior on the wrong field (onField)', () => {
-      expect(() => {
-        const dependency = new Dependency(new Region('region-1'), new Environment('qa'));
-        dependency.addBehavior('doesNotExist', DiffAction.ADD, 'environmentName', DiffAction.ADD);
-      }).toThrowErrorMatchingInlineSnapshot(`"Invalid field name is not a property of given model!"`);
-    });
-
-    it('should throw error when adding behavior on the wrong field (toField)', () => {
-      expect(() => {
-        const dependency = new Dependency(new Region('region-1'), new Environment('qa'));
-        dependency.addBehavior('regionId', DiffAction.ADD, 'doesNotExist', DiffAction.ADD);
-      }).toThrowErrorMatchingInlineSnapshot(`"Invalid field name is not a property of given model!"`);
-    });
-  });
-
-  describe('toJSON()', () => {
-    it('should be able to JSON summarize a dependency', () => {
-      const app = new App('app');
-      const region = new Region('region-1');
-      app.addRegion(region);
-      const environment = new Environment('qa');
-      region.addEnvironment(environment);
-
-      const dependency = new Dependency(region, environment);
-
-      expect(dependency.toJSON()).toMatchInlineSnapshot(`
-        {
-          "from": "region=region-1,app=app",
-          "relationship": undefined,
-          "to": "environment=qa,region=region-1,app=app",
-        }
-      `);
-    });
-  });
-});

package/src/functions/dependency/dependency.model.ts

@@ -1,178 +0,0 @@
-import { UnknownModel } from '../../app.type.js';
-import { DiffAction } from '../diff/diff.model.js';
-
-class DependencyBehavior {
-  forAction: DiffAction;
-
-  onAction: DiffAction;
-
-  onField: string;
-
-  toField: string;
-
-  constructor(onField: string, onAction: DiffAction, toField: string, forAction: DiffAction) {
-    this.onField = onField;
-    this.onAction = onAction;
-    this.toField = toField;
-    this.forAction = forAction;
-  }
-}
-
-export enum DependencyRelationship {
-  CHILD = 'child',
-  PARENT = 'parent',
-}
-
-export interface IDependency {
-  behaviors: {
-    forAction: DependencyBehavior['forAction'];
-    onAction: DependencyBehavior['onAction'];
-    onField: DependencyBehavior['onField'];
-    toField: DependencyBehavior['toField'];
-  }[];
-
-  from: string;
-
-  relationship?: {
-    onField: DependencyBehavior['onField'];
-    toField: DependencyBehavior['toField'];
-    type: DependencyRelationship;
-  };
-
-  to: string;
-}
-
-export class Dependency {
-  private readonly behaviors: DependencyBehavior[] = [];
-
-  readonly from: UnknownModel;
-
-  private relationship: { onField: string; toField: string; type: DependencyRelationship };
-
-  readonly to: UnknownModel;
-
-  constructor(from: UnknownModel, to: UnknownModel) {
-    this.from = from;
-    this.to = to;
-  }
-
-  private getBehaviorIndex(onField: string, onAction: DiffAction, toField: string, forAction: DiffAction): number {
-    return this.behaviors.findIndex(
-      (b) => b.onField === onField && b.onAction === onAction && b.toField === toField && b.forAction === forAction,
-    );
-  }
-
-  addBehavior(onField: string, onAction: DiffAction, toField: string, forAction: DiffAction): void {
-    if (!this.from.hasOwnProperty(onField) || !this.to.hasOwnProperty(toField)) {
-      throw new Error('Invalid field name is not a property of given model!');
-    }
-
-    if (this.getBehaviorIndex(onField, onAction, toField, forAction) === -1) {
-      this.behaviors.push(new DependencyBehavior(onField, onAction, toField, forAction));
-    }
-  }
-
-  addChildRelationship(onField: string, toField: string): void {
-    if (this.relationship) {
-      throw new Error('Dependency relationship already exists!');
-    }
-    this.relationship = { onField, toField, type: DependencyRelationship.CHILD };
-  }
-
-  addParentRelationship(onField: string, toField: string): void {
-    if (this.relationship) {
-      throw new Error('Dependency relationship already exists!');
-    }
-    this.relationship = { onField, toField, type: DependencyRelationship.PARENT };
-  }
-
-  hasMatchingBehavior(onField?: string, onAction?: DiffAction, toField?: string, forAction?: DiffAction): boolean {
-    return this.behaviors.some((b) => {
-      const onFieldCondition = onField ? b.onField === onField : true;
-      const onActionCondition = onAction ? b.onAction === onAction : true;
-      const toFieldCondition = toField ? b.toField === toField : true;
-      const forActionCondition = forAction ? b.forAction === forAction : true;
-      return onFieldCondition && onActionCondition && toFieldCondition && forActionCondition;
-    });
-  }
-
-  isChildRelationship(): boolean {
-    return this.relationship && this.relationship.type === DependencyRelationship.CHILD;
-  }
-
-  isEqual(dependency: Dependency): boolean {
-    return (
-      this.from.getContext() === dependency.from.getContext() && this.to.getContext() === dependency.to.getContext()
-    );
-  }
-
-  isParentRelationship(): boolean {
-    return this.relationship && this.relationship.type === DependencyRelationship.PARENT;
-  }
-
-  getRelationship(): { onField: string; toField: string; type: DependencyRelationship } | undefined {
-    return this.relationship;
-  }
-
-  removeBehavior(onField: string, onAction: DiffAction, toField: string, forAction: DiffAction): void {
-    const index = this.getBehaviorIndex(onField, onAction, toField, forAction);
-    if (index === -1) {
-      throw new Error('Dependency behavior not found!');
-    }
-
-    this.behaviors.splice(index, 1);
-  }
-
-  synth(): IDependency {
-    const behaviors: IDependency['behaviors'] = [];
-    this.behaviors.forEach((b) => {
-      behaviors.push({
-        forAction: b.forAction,
-        onAction: b.onAction,
-        onField: b.onField,
-        toField: b.toField,
-      });
-    });
-
-    return {
-      behaviors,
-      from: this.from.getContext(),
-      relationship: this.relationship
-        ? {
-            onField: this.relationship.onField,
-            toField: this.relationship.toField,
-            type: this.relationship.type,
-          }
-        : undefined,
-      to: this.to.getContext(),
-    };
-  }
-
-  toJSON(): object {
-    return {
-      from: this.from.getContext(),
-      relationship: this.relationship
-        ? {
-            onField: this.relationship.onField,
-            toField: this.relationship.toField,
-            type: this.relationship.type,
-          }
-        : undefined,
-      to: this.to.getContext(),
-    };
-  }
-
-  static unSynth(from: UnknownModel, to: UnknownModel, dependency: IDependency): Dependency {
-    const newDependency = new Dependency(from, to);
-
-    dependency.behaviors.forEach((b) => {
-      newDependency.addBehavior(b.onField, b.onAction, b.toField, b.forAction);
-    });
-
-    if (dependency.relationship) {
-      newDependency.relationship = { ...dependency.relationship };
-    }
-
-    return newDependency;
-  }
-}

package/src/functions/diff/diff-metadata.model.ts

@@ -1,51 +0,0 @@
-import { ActionInputs, ActionOutputs, UnknownModel, UnknownResource } from '../../app.type.js';
-import { IAction } from '../../models/action.interface.js';
-import { IResourceAction } from '../../resources/resource-action.interface.js';
-import { Diff, DiffAction } from './diff.model.js';
-
-export class DiffMetadata {
-  readonly actions: IAction<ActionInputs, ActionOutputs>[] | IResourceAction[];
-  applied: boolean;
-  applyOrder: number;
-
-  readonly diff: Diff;
-  readonly action: DiffAction;
-  readonly field: string;
-  readonly model: UnknownModel | UnknownResource;
-  readonly value: unknown;
-
-  readonly inputs: ActionInputs = {};
-  readonly outputs: ActionOutputs = {};
-
-  constructor(diff: Diff, actions: IAction<ActionInputs, ActionOutputs>[] | IResourceAction[]) {
-    if (!actions?.length) {
-      throw new Error('No matching action given for diff!');
-    }
-
-    this.actions = actions;
-    this.applied = false;
-    this.applyOrder = -1;
-
-    this.diff = diff;
-    this.action = diff.action;
-    this.field = diff.field;
-    this.model = diff.model;
-    this.value = diff.value;
-  }
-
-  toJSON(): ReturnType<Diff['toJSON']> {
-    return {
-      action: this.action,
-      field: this.field,
-      value: this.value,
-    };
-  }
-
-  updateInputs(inputs: ActionInputs): void {
-    Object.assign(this.inputs, inputs);
-  }
-
-  updateOutputs(outputs: ActionOutputs): void {
-    Object.assign(this.outputs, outputs);
-  }
-}

package/src/functions/diff/diff.model.ts

@@ -1,33 +0,0 @@
-import { UnknownModel } from '../../app.type.js';
-
-export enum DiffAction {
-  ADD = 'add',
-  DELETE = 'delete',
-  REPLACE = 'replace',
-  UPDATE = 'update',
-}
-
-export class Diff {
-  readonly action: DiffAction;
-
-  readonly field: string;
-
-  readonly model: UnknownModel;
-
-  readonly value: unknown;
-
-  constructor(model: Diff['model'], action: Diff['action'], field: Diff['field'], value: Diff['value']) {
-    this.model = model;
-    this.action = action;
-    this.field = field;
-    this.value = value;
-  }
-
-  toJSON(): Omit<Diff, 'model' | 'toJSON'> {
-    return {
-      action: this.action,
-      field: this.field,
-      value: this.value,
-    };
-  }
-}

package/src/functions/diff/diff.utility.ts

@@ -1,163 +0,0 @@
-import { UnknownModel } from '../../app.type.js';
-import { Diff, DiffAction } from './diff.model.js';
-
-export class DiffUtility {
-  private static generateDeleteDiff(model: UnknownModel, field: string): Diff[] {
-    const diff: Diff[] = [];
-
-    const children = model.getChildren();
-    for (const modelName of Object.keys(children)) {
-      for (const dependency of children[modelName]) {
-        const child = dependency.to;
-        const childField = dependency.getRelationship()!.toField;
-        diff.push(...DiffUtility.generateDeleteDiff(child, childField));
-      }
-    }
-
-    diff.push(new Diff(model, DiffAction.DELETE, field, model[field]));
-    return diff;
-  }
-
-  // Source: https://stackoverflow.com/a/32922084/1834562
-  static isObjectDeepEquals(x: object, y: object): boolean {
-    const ok = Object.keys,
-      tx = typeof x,
-      ty = typeof y;
-    return x && y && tx === 'object' && tx === ty
-      ? ok(x).length === ok(y).length && ok(x).every((key) => this.isObjectDeepEquals(x[key], y[key]))
-      : x === y;
-  }
-
-  /**
-   * Generate a deep diff of an array of basic types from the previous model vs the latest model.
-   * @param a previous model.
-   * @param b latest model.
-   * @param field string representing the field parent uses to reference the array.
-   */
-  static diffArray(a: UnknownModel, b: UnknownModel, field: string): Diff[] {
-    const diff: Diff[] = [];
-    const aSet = new Set(a[field]);
-    const bSet = new Set(b[field]);
-
-    // Iterate elements of previous (a). If found in latest (b), consider it an UPDATE.
-    // If not found in latest (b), consider it a DELETE.
-    for (const element of aSet) {
-      if (bSet.has(element)) {
-        diff.push(new Diff(b, DiffAction.UPDATE, field, element));
-      } else {
-        diff.push(new Diff(a, DiffAction.DELETE, field, element));
-      }
-    }
-
-    // Iterate elements of latest (b). If not found in previous (a), consider it an ADD.
-    for (const element of bSet) {
-      if (!aSet.has(element)) {
-        diff.push(new Diff(b, DiffAction.ADD, field, element));
-      }
-    }
-
-    return diff;
-  }
-
-  /**
-   * Generate a deep diff of an array of objects from the previous model vs the latest model.
-   * @param a previous model.
-   * @param b latest model.
-   * @param field string representing the field parent uses to reference the array.
-   * @param compare function to check if two objects are equal.
-   */
-  static diffArrayOfObjects(
-    a: UnknownModel,
-    b: UnknownModel,
-    field: string,
-    compare: (object1, object2) => boolean,
-  ): Diff[] {
-    const diff: Diff[] = [];
-
-    // Iterate elements of previous (a). If found in latest (b), consider it an UPDATE.
-    // If not found in latest (b), consider it a DELETE.
-    for (const aObject of a[field]) {
-      if (b[field].some((bObject) => compare(aObject, bObject))) {
-        diff.push(new Diff(b, DiffAction.UPDATE, field, aObject));
-      } else {
-        diff.push(...DiffUtility.generateDeleteDiff(a, field));
-      }
-    }
-
-    // Iterate elements of latest (b). If not found in previous (a), consider it an ADD.
-    for (const bObject of b[field]) {
-      if (!a[field].some((aObject) => compare(aObject, bObject))) {
-        diff.push(new Diff(b, DiffAction.ADD, field, bObject));
-      }
-    }
-
-    return diff;
-  }
-
-  /**
-   * Generate a deep diff of a map of basic types from the previous model vs the latest model.
-   * @param a previous model.
-   * @param b latest model.
-   * @param field string representing the field parent uses to reference the map.
-   */
-  static diffMap(a: UnknownModel, b: UnknownModel, field: string): Diff[] {
-    const diff: Diff[] = [];
-
-    // Iterate fields of previous (a). If found in latest (b), consider it an UPDATE.
-    // If not found in latest (b), consider it a DELETE.
-    for (const [key, value] of a[field]) {
-      if (b[field].has(key)) {
-        if (b[field].get(key) !== value) {
-          diff.push(new Diff(b, DiffAction.UPDATE, field, { key, value: b[field].get(key) }));
-        }
-      } else {
-        diff.push(new Diff(a, DiffAction.DELETE, field, { key, value }));
-      }
-    }
-
-    // Iterate fields of latest (b). If not found in previous (a), consider it an ADD.
-    for (const [key, value] of b[field]) {
-      if (!a[field].has(key)) {
-        diff.push(new Diff(b, DiffAction.ADD, field, { key, value }));
-      }
-    }
-
-    return diff;
-  }
-
-  /**
-   * Generate a deep diff of an array of previous models vs latest models.
-   * The diff is generated recursively, i.e. all children of the model are included in the diff.
-   * @param a array of previous models.
-   * @param b array of latest models.
-   * @param field string representing the unique identifier of the model.
-   */
-  static async diffModels(a: UnknownModel[], b: UnknownModel[], field: string): Promise<Diff[]> {
-    const diff: Diff[] = [];
-
-    // Iterate fields of previous (a). If found in latest (b), get recursive diff of children of b vs a.
-    // If not found in latest (b), consider it a DELETE.
-    for (const x of a) {
-      const y = b.find((i) => i[field] === x[field]);
-      if (y) {
-        const pDiff = await y.diff(x);
-        diff.push(...pDiff);
-      } else {
-        diff.push(...DiffUtility.generateDeleteDiff(x, field));
-      }
-    }
-
-    // Iterate fields of latest (b). If not found in previous (a), consider it an ADD.
-    // Recursively add all children of b.
-    for (const y of b) {
-      if (!a.find((i) => i[field] === y[field])) {
-        diff.push(new Diff(y, DiffAction.ADD, field, y[field]));
-
-        const pDiff = await y.diff();
-        diff.push(...pDiff);
-      }
-    }
-
-    return diff;
-  }
-}

package/src/functions/module/module.abstract.ts

@@ -1,59 +0,0 @@
-import { UnknownModel } from '../../app.type.js';
-import { IModule } from './module.interface.js';
-
-export abstract class AModule {
-  private readonly members: UnknownModel[] = [];
-
-  protected addMember(member: UnknownModel): void {
-    const index = this.members.findIndex((m) => m.getContext() === member.getContext());
-
-    if (index === -1) {
-      this.members.push(member);
-    }
-  }
-
-  abstract apply(...args: UnknownModel[]): void;
-
-  abstract remove(...args: UnknownModel[]): void;
-
-  removeAll(): void {
-    for (const member of this.members) {
-      member.remove(false, true);
-    }
-
-    for (const member of this.members) {
-      member.remove(false, false);
-    }
-  }
-
-  protected removeMember(member: UnknownModel): void {
-    const index = this.members.findIndex((m) => m.getContext() === member.getContext());
-
-    if (index !== -1) {
-      this.members.splice(index, 1);
-    }
-  }
-
-  synth(): IModule {
-    return {
-      members: this.members.map((m) => ({
-        context: m.getContext(),
-      })),
-    };
-  }
-
-  static async unSynth(
-    deserializationClass: any,
-    module: IModule,
-    deReferenceContext: (context: string) => Promise<UnknownModel>,
-  ): Promise<AModule> {
-    const newModule = new deserializationClass();
-
-    for (const member of module.members) {
-      const model = await deReferenceContext(member.context);
-      newModule.addMember(model);
-    }
-
-    return newModule;
-  }
-}

package/src/functions/module/module.interface.ts

@@ -1,5 +0,0 @@
-import { IModelReference } from '../../models/model.interface.js';
-
-export interface IModule {
-  members: IModelReference[];
-}