@quadnix/octo 0.0.2 → 0.0.4

package/src/services/serialization/model/model-serialization.service.spec.ts

@@ -1,195 +0,0 @@
-import { ModelSerializedOutput } from '../../../app.type.js';
-import { Container } from '../../../decorators/container.js';
-import { IDependency } from '../../../functions/dependency/dependency.model.js';
-import { App } from '../../../models/app/app.model.js';
-import { Environment } from '../../../models/environment/environment.model.js';
-import { Image } from '../../../models/image/image.model.js';
-import { Region } from '../../../models/region/region.model.js';
-import { Server } from '../../../models/server/server.model.js';
-import { Service } from '../../../models/service/service.model.js';
-import { Support } from '../../../models/support/support.model.js';
-import { OverlayDataRepository, OverlayDataRepositoryFactory } from '../../../overlays/overlay-data.repository.js';
-import { ModelSerializationService } from './model-serialization.service.js';
-
-describe('Model Serialization Service UT', () => {
-  beforeEach(() => {
-    Container.registerFactory(OverlayDataRepository, OverlayDataRepositoryFactory);
-  });
-
-  afterEach(() => {
-    Container.reset();
-  });
-
-  describe('deserialize()', () => {
-    it('should throw error when de-serializing an unknown class', async () => {
-      const serializedOutput: ModelSerializedOutput = {
-        anchors: [],
-        dependencies: [
-          {
-            from: 'app=name',
-          } as IDependency,
-        ],
-        models: {
-          'app=name': { className: 'ClassNotExist', model: null },
-        } as any,
-        modules: [],
-        overlays: [],
-      };
-
-      const service = new ModelSerializationService();
-      await expect(async () => {
-        await service.deserialize(serializedOutput);
-      }).rejects.toThrowError();
-    });
-
-    it('should throw error when de-serializing a class with default unSynth', async () => {
-      const serializedOutput: ModelSerializedOutput = {
-        anchors: [],
-        dependencies: [
-          {
-            from: 'app=name',
-          } as IDependency,
-        ],
-        models: {
-          'app=name': { className: 'Service', model: null },
-        } as any,
-        modules: [],
-        overlays: [],
-      };
-
-      const service = new ModelSerializationService();
-      service.registerClass('Service', Service);
-
-      await expect(async () => {
-        await service.deserialize(serializedOutput);
-      }).rejects.toThrowErrorMatchingInlineSnapshot(`"Method not implemented! Use derived class implementation"`);
-    });
-
-    it('should deserialize unknown classes when registered', async () => {
-      const app0 = new App('test-app');
-      const region0 = new Region('region-0');
-      app0.addRegion(region0);
-
-      const service = new ModelSerializationService();
-      service.registerClass('App', App);
-      service.registerClass('Region', Region);
-
-      const output = await service.serialize(app0);
-      const app1 = (await service.deserialize(output)) as App;
-
-      expect(app1.name).toBe('test-app');
-    });
-
-    it('should deserialize known classes', async () => {
-      const app0 = new App('test-app');
-      const region0 = new Region('region-0');
-      app0.addRegion(region0);
-
-      const service = new ModelSerializationService();
-      service.registerClass('App', App);
-      service.registerClass('Region', Region);
-
-      const output = await service.serialize(app0);
-      const app1 = (await service.deserialize(output)) as App;
-
-      expect(app1.name).toBe('test-app');
-    });
-
-    it('should return the serialized root on deserialization', async () => {
-      const app0 = new App('test-app');
-      const region0 = new Region('region-0');
-      app0.addRegion(region0);
-
-      const service = new ModelSerializationService();
-      service.registerClass('App', App);
-      service.registerClass('Region', Region);
-
-      const output = await service.serialize(region0);
-      const region1 = (await service.deserialize(output)) as Region;
-
-      expect(region1.regionId).toBe('region-0');
-    });
-
-    it('should have exact same dependencies on deserialized object as original object', async () => {
-      const app = new App('test');
-      const image = new Image('test', '0.0.1', {
-        dockerfilePath: 'path/to/Dockerfile',
-      });
-      app.addImage(image);
-      const server = new Server('server-1', image);
-      app.addServer(server);
-
-      const service = new ModelSerializationService();
-      service.registerClass('App', App);
-      service.registerClass('Image', Image);
-      service.registerClass('Server', Server);
-
-      const appSerialized = await service.serialize(app);
-      const appDeserialized = (await service.deserialize(appSerialized)) as App;
-
-      const newAppDependencies = (await service.serialize(appDeserialized)).dependencies.sort((a, b) =>
-        a.from + a.to > b.from + b.to ? 1 : b.from + b.to > a.from + a.to ? -1 : 0,
-      );
-      const oldAppDependencies = appSerialized.dependencies.sort((a, b) =>
-        a.from + a.to > b.from + b.to ? 1 : b.from + b.to > a.from + a.to ? -1 : 0,
-      );
-      expect(newAppDependencies).toEqual(oldAppDependencies);
-    });
-  });
-
-  describe('serialize()', () => {
-    it('should serialize an empty app', async () => {
-      const app0 = new App('test-app');
-
-      const service = new ModelSerializationService();
-      expect(await service.serialize(app0)).toMatchSnapshot();
-    });
-
-    it('should serialize a non-empty app', async () => {
-      const app0 = new App('test-app');
-      const image0 = new Image('image', '0.0.1', {
-        dockerfilePath: '/Dockerfile',
-      });
-      const region0 = new Region('region-1');
-      const environment0 = new Environment('qa');
-      app0.addImage(image0);
-      app0.addRegion(region0);
-      app0.addServer(new Server('backend', image0));
-      app0.addSupport(new Support('nginx', 'nginx'));
-      environment0.environmentVariables.set('key', 'value');
-      region0.addEnvironment(environment0);
-
-      const service = new ModelSerializationService();
-      expect(await service.serialize(app0)).toMatchSnapshot();
-    });
-
-    it('should serialize only boundary members', async () => {
-      const app0 = new App('test-app');
-      const region0_1 = new Region('region-1');
-      const region0_2 = new Region('region-2');
-      const environment0_1 = new Environment('qa');
-      const environment0_2 = new Environment('qa');
-      app0.addRegion(region0_1);
-      app0.addRegion(region0_2);
-      region0_1.addEnvironment(environment0_1);
-      region0_2.addEnvironment(environment0_2);
-
-      const service = new ModelSerializationService();
-      expect(await service.serialize(region0_1)).toMatchSnapshot();
-    });
-
-    it('should serialize when multiple models have dependency on same model', async () => {
-      const service = new ModelSerializationService();
-
-      const app0 = new App('test-app');
-      const image0 = new Image('image', '0.0.1', { dockerfilePath: '/Dockerfile' });
-      app0.addImage(image0);
-      const server0 = new Server('server-0', image0);
-      app0.addServer(server0);
-      const server1 = new Server('server-1', image0);
-      app0.addServer(server1);
-
-      expect(await service.serialize(app0)).toMatchSnapshot();
-    });
-  });
-});

package/src/services/serialization/model/model-serialization.service.ts

@@ -1,172 +0,0 @@
-import { IUnknownModel, ModelSerializedOutput, UnknownModel, UnknownOverlay } from '../../../app.type.js';
-import { Container } from '../../../decorators/container.js';
-import { Factory } from '../../../decorators/factory.decorator.js';
-import { AModule } from '../../../functions/module/module.abstract.js';
-import { IModule } from '../../../functions/module/module.interface.js';
-import { IAnchor } from '../../../overlays/anchor.interface.js';
-import { Dependency, IDependency } from '../../../functions/dependency/dependency.model.js';
-import { IOverlay } from '../../../overlays/overlay.interface.js';
-import { OverlayDataRepository } from '../../../overlays/overlay-data.repository.js';
-
-export class ModelSerializationService {
-  private MODEL_DESERIALIZATION_TIMEOUT_IN_MS = 5000;
-
-  private readonly classMapping: { [key: string]: any } = {};
-
-  private readonly modules: AModule[] = [];
-
-  async deserialize(serializedOutput: ModelSerializedOutput): Promise<UnknownModel> {
-    const deReferencePromises: {
-      [p: string]: [Promise<boolean>, (value: boolean) => void, (error: Error) => void, NodeJS.Timeout];
-    } = {};
-    const seen: { [p: string]: UnknownModel } = {};
-
-    const deReferenceContext = async (context: string): Promise<UnknownModel> => {
-      if (!seen[context]) {
-        if (deReferencePromises[context]) {
-          await deReferencePromises[context][0];
-        } else {
-          deReferencePromises[context] = [] as any;
-          const promise = new Promise<boolean>((resolve, reject) => {
-            deReferencePromises[context][1] = resolve;
-            deReferencePromises[context][2] = reject;
-          });
-          deReferencePromises[context][0] = promise;
-
-          deReferencePromises[context][3] = setTimeout(() => {
-            deReferencePromises[context][2](new Error('DeReferencing model operation timed out!'));
-          }, this.MODEL_DESERIALIZATION_TIMEOUT_IN_MS);
-          await promise;
-        }
-      }
-
-      return seen[context];
-    };
-
-    const deserializeModel = async (context: string): Promise<UnknownModel> => {
-      const { className, model } = serializedOutput.models[context];
-      const deserializationClass = this.classMapping[className];
-
-      seen[context] = await deserializationClass.unSynth(model, deReferenceContext);
-      if (deReferencePromises[context] !== undefined) {
-        deReferencePromises[context][1](true);
-        clearTimeout(deReferencePromises[context][3]);
-      }
-
-      return seen[context];
-    };
-
-    // Deserialize all serialized models.
-    const promiseToDeserializeModels: Promise<UnknownModel>[] = [];
-    for (const context in serializedOutput.models) {
-      promiseToDeserializeModels.push(deserializeModel(context));
-    }
-    await Promise.all(promiseToDeserializeModels);
-
-    for (const a of serializedOutput.anchors) {
-      const { className, parent } = a;
-      const deserializationClass = this.classMapping[className];
-
-      const anchor = await deserializationClass.unSynth(deserializationClass, a, deReferenceContext);
-      seen[parent.context]['anchors'].push(anchor);
-    }
-
-    for (const d of serializedOutput.dependencies) {
-      const dependency = Dependency.unSynth(seen[d.from], seen[d.to], d);
-      if (!seen[d.from]['dependencies'].some((d) => d.from === dependency.from && d.to === dependency.to)) {
-        seen[d.from]['dependencies'].push(dependency);
-      }
-    }
-
-    // Deserialize all modules.
-    this.modules.splice(0, this.modules.length); // Empty modules array.
-    for (const { className, module } of serializedOutput.modules) {
-      const deserializationClass = this.classMapping[className];
-
-      const newModule = await deserializationClass.unSynth(deserializationClass, module, deReferenceContext);
-      this.modules.push(newModule);
-    }
-
-    // Deserialize all overlays.
-    const newOverlays: UnknownOverlay[] = [];
-    const oldOverlays: UnknownOverlay[] = [];
-    for (const { className, overlay } of serializedOutput.overlays) {
-      const deserializationClass = this.classMapping[className];
-      const newOverlay = await deserializationClass.unSynth(deserializationClass, overlay, deReferenceContext);
-      newOverlays.push(newOverlay);
-      const oldOverlay = await deserializationClass.unSynth(deserializationClass, overlay, deReferenceContext);
-      oldOverlays.push(oldOverlay);
-    }
-    // Initialize a new instance of OverlayDataRepository, overwriting the previous one.
-    await Container.get(OverlayDataRepository, { args: [true, newOverlays, oldOverlays] });
-
-    // If no dependencies to serialize, return the first seen model.
-    return serializedOutput.dependencies.length > 0 ? seen[serializedOutput.dependencies[0].from] : seen[0];
-  }
-
-  registerClass(className: string, deserializationClass: any): void {
-    this.classMapping[className] = deserializationClass;
-  }
-
-  registerModule(module: AModule): void {
-    this.modules.push(module);
-  }
-
-  async serialize(root: UnknownModel): Promise<ModelSerializedOutput> {
-    const boundary = root.getBoundaryMembers();
-    const anchors: (IAnchor & { className: string })[] = [];
-    const dependencies: IDependency[] = [];
-    const models: { [key: string]: { className: string; model: IUnknownModel } } = {};
-    const modules: { className: string; module: IModule }[] = [];
-    const overlays: { className: string; overlay: IOverlay }[] = [];
-
-    for (const model of boundary) {
-      for (const a of model['anchors']) {
-        anchors.push({ ...a.synth(), className: a.constructor.name });
-      }
-
-      for (const d of model['dependencies']) {
-        // Skip dependencies that are not part of boundary.
-        if (
-          !boundary.some((m) => m.getContext() === d.from.getContext()) ||
-          !boundary.some((m) => m.getContext() === d.to.getContext())
-        ) {
-          continue;
-        }
-
-        dependencies.push(d.synth());
-      }
-
-      const context = model.getContext();
-      if (!models[context]) {
-        models[context] = {
-          className: model.constructor.name,
-          model: model.synth() as IUnknownModel,
-        };
-      }
-    }
-
-    for (const module of this.modules) {
-      modules.push({ className: module.constructor.name, module: module.synth() });
-    }
-
-    const overlayDataRepository = await Container.get(OverlayDataRepository);
-    for (const overlay of overlayDataRepository.getByProperties()) {
-      overlays.push({ className: overlay.constructor.name, overlay: overlay.synth() });
-    }
-
-    return { anchors, dependencies, models, modules, overlays };
-  }
-}
-
-@Factory<ModelSerializationService>(ModelSerializationService)
-export class ModelSerializationServiceFactory {
-  private static instance: ModelSerializationService;
-
-  static async create(): Promise<ModelSerializationService> {
-    if (!this.instance) {
-      this.instance = new ModelSerializationService();
-    }
-    return this.instance;
-  }
-}

package/src/services/serialization/resource/__snapshots__/resource-serialization.service.spec.ts.snap

@@ -1,284 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`Resource Serialization Service UT deserialize() should deserialize a resource with complex properties 1`] = `
-[
-  TestResource {
-    "MODEL_NAME": "test-resource",
-    "MODEL_TYPE": "resource",
-    "_deleteMarker": false,
-    "anchors": [],
-    "dependencies": [],
-    "properties": {
-      "key1": {
-        "key2": {
-          "key3": "value3",
-        },
-        "key4": "value4",
-      },
-    },
-    "resourceId": "resource-1",
-    "response": {
-      "response1": "value1",
-    },
-  },
-]
-`;
-
-exports[`Resource Serialization Service UT deserialize() should deserialize a single resource 1`] = `
-[
-  TestResource {
-    "MODEL_NAME": "test-resource",
-    "MODEL_TYPE": "resource",
-    "_deleteMarker": false,
-    "anchors": [],
-    "dependencies": [],
-    "properties": {
-      "key1": "value1",
-    },
-    "resourceId": "resource-1",
-    "response": {
-      "response1": "value1",
-    },
-  },
-]
-`;
-
-exports[`Resource Serialization Service UT deserialize() should deserialize a single shared resource 1`] = `
-[
-  TestResource {
-    "MODEL_NAME": "test-resource",
-    "MODEL_TYPE": "resource",
-    "_deleteMarker": false,
-    "anchors": [],
-    "dependencies": [
-      {
-        "from": "test-resource=resource-1",
-        "relationship": {
-          "onField": "resourceId",
-          "toField": "resourceId",
-          "type": "parent",
-        },
-        "to": "shared-test-resource=resource-2",
-      },
-    ],
-    "properties": {
-      "key1": "value1",
-    },
-    "resourceId": "resource-1",
-    "response": {
-      "response1": "value1",
-    },
-  },
-  SharedTestResource {
-    "MODEL_NAME": "shared-test-resource",
-    "MODEL_TYPE": "shared-resource",
-    "_deleteMarker": false,
-    "anchors": [],
-    "dependencies": [
-      {
-        "from": "shared-test-resource=resource-2",
-        "relationship": {
-          "onField": "resourceId",
-          "toField": "resourceId",
-          "type": "child",
-        },
-        "to": "test-resource=resource-1",
-      },
-    ],
-    "properties": {},
-    "resourceId": "resource-2",
-    "response": {},
-  },
-]
-`;
-
-exports[`Resource Serialization Service UT serialize() should not serialize resources marked for deletion 1`] = `
-{
-  "dependencies": [],
-  "resources": {
-    "resource-1": {
-      "className": "TestResource",
-      "resource": {
-        "properties": {
-          "key1": "value1",
-        },
-        "resourceId": "resource-1",
-        "response": {
-          "response1": "value1",
-        },
-      },
-    },
-  },
-  "sharedResources": {},
-}
-`;
-
-exports[`Resource Serialization Service UT serialize() should serialize an empty array 1`] = `
-{
-  "dependencies": [],
-  "resources": {},
-  "sharedResources": {},
-}
-`;
-
-exports[`Resource Serialization Service UT serialize() should serialize dependencies and properties and resources 1`] = `
-{
-  "dependencies": [
-    {
-      "behaviors": [
-        {
-          "forAction": "delete",
-          "onAction": "delete",
-          "onField": "resourceId",
-          "toField": "resourceId",
-        },
-      ],
-      "from": "test-resource=resource-1",
-      "relationship": {
-        "onField": "resourceId",
-        "toField": "resourceId",
-        "type": "parent",
-      },
-      "to": "test-resource=resource-2",
-    },
-    {
-      "behaviors": [
-        {
-          "forAction": "add",
-          "onAction": "add",
-          "onField": "resourceId",
-          "toField": "resourceId",
-        },
-        {
-          "forAction": "update",
-          "onAction": "add",
-          "onField": "resourceId",
-          "toField": "resourceId",
-        },
-      ],
-      "from": "test-resource=resource-2",
-      "relationship": {
-        "onField": "resourceId",
-        "toField": "resourceId",
-        "type": "child",
-      },
-      "to": "test-resource=resource-1",
-    },
-  ],
-  "resources": {
-    "resource-1": {
-      "className": "TestResource",
-      "resource": {
-        "properties": {
-          "key1": "value1",
-        },
-        "resourceId": "resource-1",
-        "response": {
-          "response1": "value1",
-        },
-      },
-    },
-    "resource-2": {
-      "className": "TestResource",
-      "resource": {
-        "properties": {
-          "key2": "value2",
-        },
-        "resourceId": "resource-2",
-        "response": {
-          "response2": "value2",
-        },
-      },
-    },
-  },
-  "sharedResources": {},
-}
-`;
-
-exports[`Resource Serialization Service UT serialize() should serialize non-empty array 1`] = `
-{
-  "dependencies": [],
-  "resources": {
-    "resource-1": {
-      "className": "TestResource",
-      "resource": {
-        "properties": {},
-        "resourceId": "resource-1",
-        "response": {},
-      },
-    },
-  },
-  "sharedResources": {},
-}
-`;
-
-exports[`Resource Serialization Service UT serialize() should serialize shared resources 1`] = `
-{
-  "dependencies": [
-    {
-      "behaviors": [
-        {
-          "forAction": "delete",
-          "onAction": "delete",
-          "onField": "resourceId",
-          "toField": "resourceId",
-        },
-      ],
-      "from": "test-resource=resource-1",
-      "relationship": {
-        "onField": "resourceId",
-        "toField": "resourceId",
-        "type": "parent",
-      },
-      "to": "shared-test-resource=resource-2",
-    },
-    {
-      "behaviors": [
-        {
-          "forAction": "add",
-          "onAction": "add",
-          "onField": "resourceId",
-          "toField": "resourceId",
-        },
-        {
-          "forAction": "update",
-          "onAction": "add",
-          "onField": "resourceId",
-          "toField": "resourceId",
-        },
-      ],
-      "from": "shared-test-resource=resource-2",
-      "relationship": {
-        "onField": "resourceId",
-        "toField": "resourceId",
-        "type": "child",
-      },
-      "to": "test-resource=resource-1",
-    },
-  ],
-  "resources": {
-    "resource-1": {
-      "className": "TestResource",
-      "resource": {
-        "properties": {},
-        "resourceId": "resource-1",
-        "response": {},
-      },
-    },
-  },
-  "sharedResources": {
-    "resource-2": {
-      "className": "SharedTestResource",
-      "resource": {
-        "properties": {
-          "key2": "value2",
-        },
-        "resourceId": "resource-2",
-        "response": {
-          "response2": "value2",
-        },
-      },
-    },
-  },
-}
-`;