@quadnix/octo 0.0.2 → 0.0.3

package/src/models/server/server.interface.ts

@@ -1,7 +0,0 @@
-import { IModelReference } from '../model.interface.js';
-import { Server } from './server.model.js';
-
-export interface IServer {
-  image: IModelReference;
-  serverKey: Server['serverKey'];
-}

package/src/models/server/server.model.ts

@@ -1,56 +0,0 @@
-import { UnknownModel } from '../../app.type.js';
-import { Model } from '../../decorators/model.decorator.js';
-import { Deployment } from '../deployment/deployment.model.js';
-import { Image } from '../image/image.model.js';
-import { AModel } from '../model.abstract.js';
-import { IServer } from './server.interface.js';
-
-@Model()
-export class Server extends AModel<IServer, Server> {
-  readonly MODEL_NAME: string = 'server';
-
-  readonly image: Image;
-
-  readonly serverKey: string;
-
-  constructor(serverKey: string, image: Image) {
-    super();
-    this.serverKey = serverKey;
-
-    this.image = image;
-    this.addRelationship('serverKey', image, 'imageId');
-  }
-
-  addDeployment(deployment: Deployment): void {
-    const childrenDependencies = this.getChildren('deployment');
-    if (!childrenDependencies['deployment']) childrenDependencies['deployment'] = [];
-
-    // Check for duplicates.
-    const deployments = childrenDependencies['deployment'].map((d) => d.to);
-    if (deployments.find((d: Deployment) => d.deploymentTag === deployment.deploymentTag)) {
-      throw new Error('Deployment already exists!');
-    }
-    this.addChild('serverKey', deployment, 'deploymentTag');
-  }
-
-  getContext(): string {
-    const parents = this.getParents();
-    const app = parents['app'][0].to;
-    return [`${this.MODEL_NAME}=${this.serverKey}`, app.getContext()].join(',');
-  }
-
-  synth(): IServer {
-    return {
-      image: { context: this.image.getContext() },
-      serverKey: this.serverKey,
-    };
-  }
-
-  static override async unSynth(
-    server: IServer,
-    deReferenceContext: (context: string) => Promise<UnknownModel>,
-  ): Promise<Server> {
-    const image = (await deReferenceContext(server.image.context)) as Image;
-    return new Server(server.serverKey, image);
-  }
-}

package/src/models/service/service.interface.ts

@@ -1,5 +0,0 @@
-import { Service } from './service.model.js';
-
-export interface IService {
-  serviceId: Service['serviceId'];
-}

package/src/models/service/service.model.ts

@@ -1,25 +0,0 @@
-import { Model } from '../../decorators/model.decorator.js';
-import { AModel } from '../model.abstract.js';
-import { IService } from './service.interface.js';
-
-@Model()
-export class Service extends AModel<IService, Service> {
-  readonly MODEL_NAME: string = 'service';
-
-  readonly serviceId: string;
-
-  constructor(serviceId: string) {
-    super();
-    this.serviceId = serviceId;
-  }
-
-  getContext(): string {
-    const parents = this.getParents();
-    const app = parents['app'][0].to;
-    return [`${this.MODEL_NAME}=${this.serviceId}`, app.getContext()].join(',');
-  }
-
-  synth(): IService {
-    throw new Error('Method not implemented! Use subclass');
-  }
-}

package/src/models/support/support.interface.ts

@@ -1,6 +0,0 @@
-import { Support } from './support.model.js';
-
-export interface ISupport {
-  applicationType: Support['applicationType'];
-  serverKey: Support['serverKey'];
-}

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

@@ -1,78 +0,0 @@
-import { Container } from '../../decorators/container.js';
-import { ModelSerializationService } from '../../services/serialization/model/model-serialization.service.js';
-import { App } from '../app/app.model.js';
-import { Deployment } from '../deployment/deployment.model.js';
-import { Environment } from '../environment/environment.model.js';
-import { Execution } from '../execution/execution.model.js';
-import { Image } from '../image/image.model.js';
-import { Region } from '../region/region.model.js';
-import { Support } from './support.model.js';
-
-describe('Support UT', () => {
-  let modelSerializationService: ModelSerializationService;
-
-  beforeAll(async () => {
-    modelSerializationService = await Container.get(ModelSerializationService);
-  });
-
-  describe('diff()', () => {
-    describe('when diff of object with children', () => {
-      it('should capture delete of children', async () => {
-        const app0_0 = new App('test');
-        const image0_0 = new Image('test', 'imageTag', {
-          dockerfilePath: 'path/to/Dockerfile',
-        });
-        app0_0.addImage(image0_0);
-        const region0_0 = new Region('region');
-        app0_0.addRegion(region0_0);
-        const environment0_0 = new Environment('qa');
-        region0_0.addEnvironment(environment0_0);
-        const support0_0 = new Support('nginx', 'nginx');
-        app0_0.addSupport(support0_0);
-        const deployment0_0 = new Deployment('nginx@0.0.1');
-        support0_0.addDeployment(deployment0_0);
-        new Execution(deployment0_0, environment0_0, image0_0);
-
-        const app0_1 = (await modelSerializationService.deserialize(
-          await modelSerializationService.serialize(app0_0),
-        )) as App;
-        const region0_1 = app0_1.getChild('region', [{ key: 'regionId', value: 'region' }]) as Region;
-        const environment0_1 = region0_1.getChild('environment', [
-          { key: 'environmentName', value: 'qa' },
-        ]) as Environment;
-        const execution0_1 = environment0_1.getChild('execution', [
-          { key: 'executionId', value: 'nginx@0.0.1_qa' },
-        ]) as Execution;
-        const support0_1 = app0_1.getChild('support', [{ key: 'serverKey', value: 'nginx' }]) as Support;
-        const deployment0_1 = support0_1.getChild('deployment', [
-          { key: 'deploymentTag', value: 'nginx@0.0.1' },
-        ]) as Deployment;
-
-        execution0_1.remove(true);
-        deployment0_1.remove();
-        support0_1.remove();
-        const diff = await app0_1.diff(app0_0);
-
-        expect(diff).toMatchInlineSnapshot(`
-          [
-            {
-              "action": "delete",
-              "field": "executionId",
-              "value": "nginx@0.0.1_qa",
-            },
-            {
-              "action": "delete",
-              "field": "deploymentTag",
-              "value": "nginx@0.0.1",
-            },
-            {
-              "action": "delete",
-              "field": "serverKey",
-              "value": "nginx",
-            },
-          ]
-        `);
-      });
-    });
-  });
-});

package/src/models/support/support.model.ts

@@ -1,52 +0,0 @@
-import { SupportApplicationType, UnknownModel } from '../../app.type.js';
-import { Model } from '../../decorators/model.decorator.js';
-import { Deployment } from '../deployment/deployment.model.js';
-import { AModel } from '../model.abstract.js';
-import { ISupport } from './support.interface.js';
-
-@Model()
-export class Support extends AModel<ISupport, Support> {
-  readonly MODEL_NAME: string = 'support';
-
-  readonly applicationType: SupportApplicationType;
-
-  readonly serverKey: string;
-
-  constructor(serverKey: string, applicationType: SupportApplicationType) {
-    super();
-    this.serverKey = serverKey;
-    this.applicationType = applicationType;
-  }
-
-  addDeployment(deployment: Deployment): void {
-    const childrenDependencies = this.getChildren('deployment');
-    if (!childrenDependencies['deployment']) childrenDependencies['deployment'] = [];
-
-    // Check for duplicates.
-    const deployments = childrenDependencies['deployment'].map((d) => d.to);
-    if (deployments.find((d: Deployment) => d.deploymentTag === deployment.deploymentTag)) {
-      throw new Error('Deployment already exists!');
-    }
-    this.addChild('serverKey', deployment, 'deploymentTag');
-  }
-
-  getContext(): string {
-    const parents = this.getParents();
-    const app = parents['app'][0].to;
-    return [`${this.MODEL_NAME}=${this.serverKey}`, app.getContext()].join(',');
-  }
-
-  synth(): ISupport {
-    return {
-      applicationType: this.applicationType,
-      serverKey: this.serverKey,
-    };
-  }
-
-  static override async unSynth(
-    support: ISupport,
-    deReferenceContext: (context: string) => Promise<UnknownModel>,
-  ): Promise<Support> {
-    return new Support(support.serverKey, support.applicationType);
-  }
-}

package/src/overlays/anchor.abstract.ts

@@ -1,41 +0,0 @@
-import { UnknownModel } from '../app.type.js';
-import { IAnchor } from './anchor.interface.js';
-
-export abstract class AAnchor {
-  protected constructor(readonly anchorId: string, private readonly parent: UnknownModel) {
-    if (parent.getAnchor(this.anchorId)) {
-      throw new Error('Anchor already exists!');
-    }
-  }
-
-  getParent(): UnknownModel {
-    return this.parent;
-  }
-
-  synth(): IAnchor {
-    return {
-      anchorId: this.anchorId,
-      parent: { context: this.parent.getContext() },
-    };
-  }
-
-  toJSON(): object {
-    return {
-      anchorId: this.anchorId,
-      parent: this.parent.getContext(),
-    };
-  }
-
-  static async unSynth(
-    deserializationClass: any,
-    anchor: IAnchor,
-    deReferenceContext: (context: string) => Promise<UnknownModel>,
-  ): Promise<AAnchor> {
-    const parent = await deReferenceContext(anchor.parent.context);
-    const newAnchor = parent.getAnchor(anchor.anchorId);
-    if (!newAnchor) {
-      return new deserializationClass(anchor.anchorId, parent);
-    }
-    return newAnchor;
-  }
-}

package/src/overlays/anchor.interface.ts

@@ -1,7 +0,0 @@
-import { IModelReference } from '../models/model.interface.js';
-import { AAnchor } from './anchor.abstract.js';
-
-export interface IAnchor {
-  anchorId: AAnchor['anchorId'];
-  parent: IModelReference;
-}

package/src/overlays/anchor.spec.ts

@@ -1,41 +0,0 @@
-import { UnknownModel } from '../app.type.js';
-import { App } from '../models/app/app.model.js';
-import { AAnchor } from './anchor.abstract.js';
-
-class TestAnchor extends AAnchor {
-  constructor(anchorId: string, parent: UnknownModel) {
-    super(anchorId, parent);
-  }
-}
-
-describe('Anchor UT', () => {
-  describe('synth()', () => {
-    it('should be able to synth an anchor', () => {
-      const app = new App('test');
-      const anchor = new TestAnchor('anchor-1', app);
-
-      expect(anchor.synth()).toMatchInlineSnapshot(`
-        {
-          "anchorId": "anchor-1",
-          "parent": {
-            "context": "app=test",
-          },
-        }
-      `);
-    });
-  });
-
-  describe('toJSON()', () => {
-    it('should be able to JSON summarize an anchor', () => {
-      const app = new App('test');
-      const anchor = new TestAnchor('anchor-1', app);
-
-      expect(anchor.toJSON()).toMatchInlineSnapshot(`
-        {
-          "anchorId": "anchor-1",
-          "parent": "app=test",
-        }
-      `);
-    });
-  });
-});

package/src/overlays/overlay-data.repository.ts

@@ -1,76 +0,0 @@
-import { ModelType, UnknownOverlay } from '../app.type.js';
-import { Factory } from '../decorators/factory.decorator.js';
-import { Diff, DiffAction } from '../functions/diff/diff.model.js';
-import { IOverlay } from './overlay.interface.js';
-
-export class OverlayDataRepository {
-  constructor(
-    private readonly oldOverlays: UnknownOverlay[] = [],
-    private readonly newOverlays: UnknownOverlay[] = [],
-  ) {
-    Object.freeze(this.oldOverlays);
-  }
-
-  add(overlay: UnknownOverlay): void {
-    if (overlay.MODEL_TYPE !== ModelType.OVERLAY) {
-      throw new Error('Adding non-overlay model!');
-    }
-
-    if (!this.getById(overlay.overlayId)) {
-      this.newOverlays.push(overlay);
-    }
-  }
-
-  diff(): Diff[] {
-    const diffs: Diff[] = [];
-
-    for (const overlay of this.oldOverlays) {
-      if (!this.newOverlays.find((o) => o.overlayId === overlay.overlayId)) {
-        diffs.push(new Diff(overlay, DiffAction.DELETE, 'overlayId', overlay.overlayId));
-      }
-    }
-
-    for (const overlay of this.newOverlays) {
-      if (!this.oldOverlays.find((o) => o.overlayId === overlay.overlayId)) {
-        diffs.push(new Diff(overlay, DiffAction.ADD, 'overlayId', overlay.overlayId));
-      }
-    }
-
-    return diffs;
-  }
-
-  getById(overlayId: IOverlay['overlayId']): UnknownOverlay | undefined {
-    return this.newOverlays.find((o) => o.overlayId === overlayId);
-  }
-
-  getByProperties(filters: { key: string; value: any }[] = []): UnknownOverlay[] {
-    return this.newOverlays.filter((o) => filters.every((c) => o.properties[c.key] === c.value));
-  }
-
-  remove(overlay: UnknownOverlay): void {
-    if (overlay.MODEL_TYPE !== ModelType.OVERLAY) {
-      throw new Error('Adding non-overlay model!');
-    }
-
-    const overlayIndex = this.newOverlays.findIndex((o) => o.overlayId === overlay.overlayId);
-    if (overlayIndex > -1) {
-      this.newOverlays.splice(overlayIndex, 1);
-    }
-  }
-}
-
-@Factory<OverlayDataRepository>(OverlayDataRepository)
-export class OverlayDataRepositoryFactory {
-  private static instance: OverlayDataRepository;
-
-  static async create(
-    forceNew: boolean,
-    newOverlays: UnknownOverlay[],
-    oldOverlays: UnknownOverlay[],
-  ): Promise<OverlayDataRepository> {
-    if (forceNew || !this.instance) {
-      this.instance = new OverlayDataRepository(newOverlays, oldOverlays);
-    }
-    return this.instance;
-  }
-}

package/src/overlays/overlay.abstract.ts

@@ -1,64 +0,0 @@
-import { ModelType, UnknownModel, UnknownOverlay } from '../app.type.js';
-import { AModel } from '../models/model.abstract.js';
-import { Diff } from '../functions/diff/diff.model.js';
-import { AAnchor } from './anchor.abstract.js';
-import { IOverlay } from './overlay.interface.js';
-
-export abstract class AOverlay<T> extends AModel<IOverlay, T> {
-  abstract override readonly MODEL_NAME: string;
-  override readonly MODEL_TYPE: ModelType = ModelType.OVERLAY;
-
-  readonly overlayId: IOverlay['overlayId'];
-
-  readonly properties: IOverlay['properties'] = {};
-
-  protected constructor(overlayId: IOverlay['overlayId'], properties: IOverlay['properties'], anchors: AAnchor[]) {
-    super();
-
-    this.overlayId = overlayId;
-
-    for (const key in properties) {
-      this.properties[key] = properties[key];
-    }
-
-    for (const anchor of anchors) {
-      this.addRelationship('overlayId', anchor.getParent(), 'MODEL_NAME');
-      this.anchors.push(anchor);
-    }
-  }
-
-  async diff(): Promise<Diff[]> {
-    return [];
-  }
-
-  getContext(): string {
-    return `${this.MODEL_NAME}=${this.overlayId}`;
-  }
-
-  synth(): IOverlay {
-    return {
-      anchors: this.anchors.map((a) => a.synth()),
-      overlayId: this.overlayId,
-      properties: { ...this.properties },
-    };
-  }
-
-  static async unSynth(
-    deserializationClass: any,
-    overlay: IOverlay,
-    deReferenceContext: (context: string) => Promise<UnknownModel>,
-  ): Promise<UnknownOverlay> {
-    const anchors = await Promise.all(
-      overlay.anchors.map(async (a) => {
-        const parent = await deReferenceContext(a.parent.context);
-        const anchor = parent.getAnchor(a.anchorId);
-        if (!anchor) {
-          throw new Error('Cannot find anchor while deserializing overlay!');
-        }
-        return anchor;
-      }),
-    );
-
-    return new deserializationClass(overlay.overlayId, overlay.properties, anchors);
-  }
-}

package/src/overlays/overlay.interface.ts

@@ -1,9 +0,0 @@
-import { IAnchor } from './anchor.interface.js';
-
-export interface IOverlay {
-  anchors: IAnchor[];
-
-  overlayId: string;
-
-  properties: { [key: string]: unknown };
-}

package/src/overlays/overlay.service.ts

@@ -1,38 +0,0 @@
-import { UnknownOverlay } from '../app.type.js';
-import { Container } from '../decorators/container.js';
-import { Factory } from '../decorators/factory.decorator.js';
-import { OverlayDataRepository } from './overlay-data.repository.js';
-
-export class OverlayService {
-  async addOverlay(overlay: UnknownOverlay): Promise<void> {
-    const overlayDataRepository = await Container.get(OverlayDataRepository);
-    overlayDataRepository.add(overlay);
-  }
-
-  async getOverlayById(overlayId: string): Promise<UnknownOverlay | undefined> {
-    const overlayDataRepository = await Container.get(OverlayDataRepository);
-    return overlayDataRepository.getById(overlayId);
-  }
-
-  async getOverlayByProperties(filters: { key: string; value: any }[] = []): Promise<UnknownOverlay[]> {
-    const overlayDataRepository = await Container.get(OverlayDataRepository);
-    return overlayDataRepository.getByProperties(filters);
-  }
-
-  async removeOverlay(overlay: UnknownOverlay): Promise<void> {
-    const overlayDataRepository = await Container.get(OverlayDataRepository);
-    overlayDataRepository.remove(overlay);
-  }
-}
-
-@Factory<OverlayService>(OverlayService)
-export class OverlayServiceFactory {
-  private static instance: OverlayService;
-
-  static async create(): Promise<OverlayService> {
-    if (!this.instance) {
-      this.instance = new OverlayService();
-    }
-    return this.instance;
-  }
-}

package/src/overlays/overlay.spec.ts

@@ -1,86 +0,0 @@
-import { TestAnchor, TestOverlay } from '../../test/helpers/test-classes.js';
-import { App } from '../models/app/app.model.js';
-import { AOverlay } from './overlay.abstract.js';
-
-describe('Overlay UT', () => {
-  describe('synth()', () => {
-    it('should be able to synth an empty overlay', () => {
-      const overlay = new TestOverlay('overlay-1', {}, []);
-
-      expect(overlay.synth()).toMatchInlineSnapshot(`
-        {
-          "anchors": [],
-          "overlayId": "overlay-1",
-          "properties": {},
-        }
-      `);
-    });
-
-    it('should be able to synth with anchors', () => {
-      const app = new App('test');
-      const anchor1 = new TestAnchor('anchor-1', app);
-      const anchor2 = new TestAnchor('anchor-2', app);
-      const overlay = new TestOverlay('overlay-1', { key1: 'value1' }, [anchor1, anchor2]);
-
-      expect(overlay.synth()).toMatchInlineSnapshot(`
-        {
-          "anchors": [
-            {
-              "anchorId": "anchor-1",
-              "parent": {
-                "context": "app=test",
-              },
-            },
-            {
-              "anchorId": "anchor-2",
-              "parent": {
-                "context": "app=test",
-              },
-            },
-          ],
-          "overlayId": "overlay-1",
-          "properties": {
-            "key1": "value1",
-          },
-        }
-      `);
-    });
-  });
-
-  describe('unSynth', () => {
-    it('should throw error while unSynth if anchor not found', async () => {
-      const app = new App('test');
-      const anchor1 = new TestAnchor('anchor-1', app);
-      const anchor2 = new TestAnchor('anchor-2', app);
-      const overlay = new TestOverlay('overlay-1', { key1: 'value1' }, [anchor1, anchor2]);
-      const overlaySynth = overlay.synth();
-
-      const deReferenceContext = async (): Promise<App> => {
-        const app = new App('test');
-        app['anchors'].push(anchor1);
-        return app;
-      };
-
-      await expect(async () => {
-        await AOverlay.unSynth(TestOverlay, overlaySynth, deReferenceContext);
-      }).rejects.toThrowErrorMatchingInlineSnapshot(`"Cannot find anchor while deserializing overlay!"`);
-    });
-
-    it('should be able to unSynth with anchors', async () => {
-      const app = new App('test');
-      const anchor1 = new TestAnchor('anchor-1', app);
-      const anchor2 = new TestAnchor('anchor-2', app);
-      const overlay = new TestOverlay('overlay-1', { key1: 'value1' }, [anchor1, anchor2]);
-      const overlaySynth = overlay.synth();
-
-      const deReferenceContext = async (): Promise<App> => {
-        const app = new App('test');
-        app['anchors'].push(anchor1, anchor2);
-        return app;
-      };
-      const overlayUnSynth = await AOverlay.unSynth(TestOverlay, overlaySynth, deReferenceContext);
-
-      expect(overlayUnSynth.synth()).toEqual(overlaySynth);
-    });
-  });
-});

package/src/resources/resource-action.interface.ts

@@ -1,9 +0,0 @@
-import { Diff } from '../functions/diff/diff.model.js';
-
-export interface IResourceAction {
-  readonly ACTION_NAME: string;
-
-  filter(diff: Diff): boolean;
-
-  handle(diff: Diff): Promise<void>;
-}