@quadnix/octo 0.0.2 → 0.0.4

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

@@ -1,311 +0,0 @@
-import { UnknownResource } from '../../../app.type.js';
-import { Container } from '../../../decorators/container.js';
-import { ResourceDataRepository, ResourceDataRepositoryFactory } from '../../../resources/resource-data.repository.js';
-import { AResource } from '../../../resources/resource.abstract.js';
-import { ASharedResource } from '../../../resources/shared-resource.abstract.js';
-import { ResourceSerializationService } from './resource-serialization.service.js';
-
-class TestResource extends AResource<TestResource> {
-  readonly MODEL_NAME: string = 'test-resource';
-
-  constructor(resourceId: string, properties: { [k: string]: string } = {}, parents: [TestResource?] = []) {
-    super(resourceId, properties, parents as AResource<TestResource>[]);
-  }
-}
-
-class SharedTestResource extends ASharedResource<TestResource> {
-  readonly MODEL_NAME: string = 'shared-test-resource';
-
-  constructor(resourceId: string, properties: object, parents: [TestResource?]) {
-    super(resourceId, {}, parents as AResource<TestResource>[]);
-  }
-}
-
-describe('Resource Serialization Service UT', () => {
-  beforeEach(() => {
-    Container.registerFactory(ResourceDataRepository, ResourceDataRepositoryFactory);
-  });
-
-  afterEach(() => {
-    Container.reset();
-  });
-
-  describe('deserialize()', () => {
-    it('should throw error when de-serializing an unknown class', async () => {
-      const resource1 = new TestResource('resource-1');
-      resource1.properties['key1'] = 'value1';
-      resource1.response['response1'] = 'value1';
-
-      const resources = [resource1];
-      await Container.get(ResourceDataRepository, { args: [true, [...resources], [...resources]] });
-
-      const service = new ResourceSerializationService();
-
-      await expect(async () => {
-        const serializedOutput = await service.serialize();
-        await service.deserialize(serializedOutput);
-      }).rejects.toThrowErrorMatchingInlineSnapshot(`"Cannot read properties of undefined (reading 'unSynth')"`);
-    });
-
-    it('should deserialize a single resource', async () => {
-      const resource1 = new TestResource('resource-1');
-      resource1.properties['key1'] = 'value1';
-      resource1.response['response1'] = 'value1';
-
-      const resources = [resource1];
-      await Container.get(ResourceDataRepository, { args: [true, [...resources], [...resources]] });
-
-      const service = new ResourceSerializationService();
-      service.registerClass('TestResource', TestResource);
-
-      const serializedOutput = await service.serialize();
-      await service.deserialize(serializedOutput);
-
-      const resourceDataRepository = await Container.get(ResourceDataRepository);
-      const deserializedResources = resourceDataRepository.getByProperties();
-      expect(deserializedResources).toMatchSnapshot();
-    });
-
-    it('should deserialize a resource with complex properties', async () => {
-      const resource1 = new TestResource('resource-1');
-      resource1.properties['key1'] = { key2: { key3: 'value3' }, key4: 'value4' };
-      resource1.response['response1'] = 'value1';
-
-      const resources = [resource1];
-      await Container.get(ResourceDataRepository, { args: [true, [...resources], [...resources]] });
-
-      const service = new ResourceSerializationService();
-      service.registerClass('TestResource', TestResource);
-
-      const serializedOutput = await service.serialize();
-      await service.deserialize(serializedOutput);
-
-      const resourceDataRepository = await Container.get(ResourceDataRepository);
-      const deserializedResources = resourceDataRepository.getByProperties();
-      expect(deserializedResources).toMatchSnapshot();
-    });
-
-    it('should deserialize a single shared resource', async () => {
-      const resource1 = new TestResource('resource-1');
-      resource1.properties['key1'] = 'value1';
-      resource1.response['response1'] = 'value1';
-      const resource2 = new SharedTestResource('resource-2', {}, [resource1]);
-
-      const resources = [resource1, resource2];
-      await Container.get(ResourceDataRepository, { args: [true, [...resources], [...resources]] });
-
-      const service = new ResourceSerializationService();
-      service.registerClass('TestResource', TestResource);
-      service.registerClass('SharedTestResource', SharedTestResource);
-
-      const serializedOutput = await service.serialize();
-      await service.deserialize(serializedOutput);
-
-      const resourceDataRepository = await Container.get(ResourceDataRepository);
-      const deserializedResources = resourceDataRepository.getByProperties();
-      expect(deserializedResources).toMatchSnapshot();
-    });
-
-    it('should throw error trying to deserialize a shared resource without corresponding resource', async () => {
-      const resource1 = new TestResource('resource-1');
-      resource1.properties['key1'] = 'value1';
-      resource1.response['response1'] = 'value1';
-      const resource2 = new SharedTestResource('resource-2', {}, [resource1]);
-
-      const resources = [resource2];
-      await Container.get(ResourceDataRepository, { args: [true, [...resources], [...resources]] });
-
-      const service = new ResourceSerializationService();
-      service.registerClass('TestResource', TestResource);
-      service.registerClass('SharedTestResource', SharedTestResource);
-      service.setResourceDeserializationTimeout(50);
-
-      const serializedOutput = await service.serialize();
-
-      await expect(async () => {
-        await service.deserialize(serializedOutput);
-      }).rejects.toMatchInlineSnapshot(`[Error: DeReferencing resource operation timed out!]`);
-    });
-
-    it('should deserialize dependencies', async () => {
-      const resource1 = new TestResource('resource-1');
-      resource1.properties['key1'] = 'value1';
-      resource1.response['response1'] = 'value1';
-      const resource2 = new TestResource('resource-2');
-      resource2.properties['key2'] = 'value2';
-      resource2.response['response2'] = 'value2';
-      resource1.addChild('resourceId', resource2, 'resourceId');
-
-      const resources = [resource1, resource2];
-      await Container.get(ResourceDataRepository, { args: [true, [...resources], [...resources]] });
-
-      const service = new ResourceSerializationService();
-      service.registerClass('TestResource', TestResource);
-
-      const serializedOutput = await service.serialize();
-      await service.deserialize(serializedOutput);
-
-      const resourceDataRepository = await Container.get(ResourceDataRepository);
-      const deserializedResources = resourceDataRepository.getByProperties();
-
-      const resource1Deserialized = deserializedResources.find((r) => r.resourceId === 'resource-1');
-      const resource2Deserialized = resource1Deserialized!.getChildren()['test-resource'][0]
-        .to as AResource<TestResource>;
-      expect(resource2Deserialized.resourceId).toBe('resource-2');
-      expect((resource2Deserialized.getParents()['test-resource'][0].to as AResource<TestResource>).resourceId).toBe(
-        'resource-1',
-      );
-    });
-
-    it('should deserialize dependencies in reverse order', async () => {
-      const resource1 = new TestResource('resource-1');
-      resource1.properties['key1'] = 'value1';
-      resource1.response['response1'] = 'value1';
-      const resource2 = new TestResource('resource-2');
-      resource2.properties['key2'] = 'value2';
-      resource2.response['response2'] = 'value2';
-      resource1.addChild('resourceId', resource2, 'resourceId');
-
-      const resources = [resource2, resource1];
-      await Container.get(ResourceDataRepository, { args: [true, [...resources], [...resources]] });
-
-      const service = new ResourceSerializationService();
-      service.registerClass('TestResource', TestResource);
-
-      const serializedOutput = await service.serialize();
-      await service.deserialize(serializedOutput);
-
-      const resourceDataRepository = await Container.get(ResourceDataRepository);
-      const deserializedResources = resourceDataRepository.getByProperties();
-
-      const resource1Deserialized = deserializedResources.find((r) => r.resourceId === 'resource-1');
-      const resource2Deserialized = resource1Deserialized!.getChildren()['test-resource'][0]
-        .to as AResource<TestResource>;
-      expect(resource2Deserialized.resourceId).toBe('resource-2');
-      expect((resource2Deserialized.getParents()['test-resource'][0].to as AResource<TestResource>).resourceId).toBe(
-        'resource-1',
-      );
-    });
-
-    it('should have exact same dependencies on deserialized object as original object', async () => {
-      const resource1 = new TestResource('resource-1');
-      resource1.properties['key1'] = 'value1';
-      resource1.response['response1'] = 'value1';
-      const resource2 = new TestResource('resource-2');
-      resource2.properties['key2'] = 'value2';
-      resource2.response['response2'] = 'value2';
-      resource1.addChild('resourceId', resource2, 'resourceId');
-      const resource3 = new SharedTestResource('resource-3', {}, [resource1]);
-
-      const resources = [resource1, resource2, resource3];
-      await Container.get(ResourceDataRepository, { args: [true, [...resources], [...resources]] });
-
-      const service = new ResourceSerializationService();
-      service.registerClass('TestResource', TestResource);
-      service.registerClass('SharedTestResource', SharedTestResource);
-
-      const serializedOutput1 = await service.serialize();
-      const oldResourcesDependencies = serializedOutput1.dependencies.sort((a, b) =>
-        a.from + a.to > b.from + b.to ? 1 : b.from + b.to > a.from + a.to ? -1 : 0,
-      );
-
-      await service.deserialize(serializedOutput1);
-      const resourceDataRepository = await Container.get(ResourceDataRepository);
-      const deserializedResources = resourceDataRepository.getByProperties();
-
-      // An easy way to get dependencies from `deserializedResources` is to serialize it again.
-      await Container.get(ResourceDataRepository, {
-        args: [true, [...deserializedResources], [...deserializedResources]],
-      });
-      const serializedOutput2 = await service.serialize();
-      const newResourcesDependencies = serializedOutput2.dependencies.sort((a, b) =>
-        a.from + a.to > b.from + b.to ? 1 : b.from + b.to > a.from + a.to ? -1 : 0,
-      );
-
-      expect(newResourcesDependencies).toEqual(oldResourcesDependencies);
-    });
-
-    it('should initialize ResourceDataRepository with separate old and new resources', async () => {
-      const resource1 = new TestResource('resource-1');
-      resource1.properties['key1'] = 'value1';
-      resource1.response['response1'] = 'value1';
-
-      const resources = [resource1];
-      await Container.get(ResourceDataRepository, { args: [true, [...resources], [...resources]] });
-
-      const service = new ResourceSerializationService();
-      service.registerClass('TestResource', TestResource);
-
-      const serializedOutput = await service.serialize();
-      await service.deserialize(serializedOutput);
-
-      const resourceDataRepository = await Container.get(ResourceDataRepository);
-
-      // Manipulate new resources. This must not affect old resources in any way.
-      resourceDataRepository.getById('resource-1')!.properties['key1'] = 'value2';
-      expect(resourceDataRepository['newResources'][0]).not.toEqual(resourceDataRepository['oldResources'][0]);
-    });
-  });
-
-  describe('serialize()', () => {
-    it('should serialize an empty array', async () => {
-      await Container.get(ResourceDataRepository, { args: [true, [], []] });
-
-      const service = new ResourceSerializationService();
-      expect(await service.serialize()).toMatchSnapshot();
-    });
-
-    it('should serialize non-empty array', async () => {
-      const resources: UnknownResource[] = [new TestResource('resource-1')];
-      await Container.get(ResourceDataRepository, { args: [true, [...resources], [...resources]] });
-
-      const service = new ResourceSerializationService();
-      expect(await service.serialize()).toMatchSnapshot();
-    });
-
-    it('should not serialize resources marked for deletion', async () => {
-      const resource1 = new TestResource('resource-1');
-      resource1.properties['key1'] = 'value1';
-      resource1.response['response1'] = 'value1';
-      const resource2 = new TestResource('resource-2');
-      resource2.properties['key2'] = 'value2';
-      resource2.response['response2'] = 'value2';
-      resource2.markDeleted();
-
-      const resources = [resource1, resource2];
-      await Container.get(ResourceDataRepository, { args: [true, [...resources], [...resources]] });
-
-      const service = new ResourceSerializationService();
-      expect(await service.serialize()).toMatchSnapshot();
-    });
-
-    it('should serialize dependencies and properties and resources', async () => {
-      const resource1 = new TestResource('resource-1');
-      resource1.properties['key1'] = 'value1';
-      resource1.response['response1'] = 'value1';
-      const resource2 = new TestResource('resource-2');
-      resource2.properties['key2'] = 'value2';
-      resource2.response['response2'] = 'value2';
-      resource1.addChild('resourceId', resource2, 'resourceId');
-
-      const resources = [resource1, resource2];
-      await Container.get(ResourceDataRepository, { args: [true, [...resources], [...resources]] });
-
-      const service = new ResourceSerializationService();
-      expect(await service.serialize()).toMatchSnapshot();
-    });
-
-    it('should serialize shared resources', async () => {
-      const resource1 = new TestResource('resource-1');
-      const resource2 = new SharedTestResource('resource-2', {}, [resource1]);
-      resource2.properties['key2'] = 'value2';
-      resource2.response['response2'] = 'value2';
-
-      const resources = [resource1, resource2];
-      await Container.get(ResourceDataRepository, { args: [true, [...resources], [...resources]] });
-
-      const service = new ResourceSerializationService();
-      expect(await service.serialize()).toMatchSnapshot();
-    });
-  });
-});

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

@@ -1,166 +0,0 @@
-import { ActionOutputs, ResourceSerializedOutput, UnknownResource } from '../../../app.type.js';
-import { Container } from '../../../decorators/container.js';
-import { Factory } from '../../../decorators/factory.decorator.js';
-import { IDependency } from '../../../functions/dependency/dependency.model.js';
-import { ResourceDataRepository } from '../../../resources/resource-data.repository.js';
-
-export class ResourceSerializationService {
-  private RESOURCE_DESERIALIZATION_TIMEOUT_IN_MS = 5000;
-
-  private readonly classMapping: { [key: string]: any } = {};
-
-  private async _deserialize(serializedOutput: ResourceSerializedOutput): Promise<ActionOutputs> {
-    const deReferencePromises: {
-      [p: string]: [Promise<boolean>, (value: boolean) => void, (error: Error) => void, NodeJS.Timeout];
-    } = {};
-    const parents: { [p: string]: string[] } = {};
-    const seen: ActionOutputs = {};
-
-    const deReferenceResource = async (resourceId: string): Promise<UnknownResource> => {
-      if (!seen[resourceId]) {
-        if (deReferencePromises[resourceId]) {
-          await deReferencePromises[resourceId][0];
-        } else {
-          deReferencePromises[resourceId] = [] as any;
-          const promise = new Promise<boolean>((resolve, reject) => {
-            deReferencePromises[resourceId][1] = resolve;
-            deReferencePromises[resourceId][2] = reject;
-          });
-          deReferencePromises[resourceId][0] = promise;
-
-          deReferencePromises[resourceId][3] = setTimeout(() => {
-            deReferencePromises[resourceId][2](new Error('DeReferencing resource operation timed out!'));
-          }, this.RESOURCE_DESERIALIZATION_TIMEOUT_IN_MS);
-          await promise;
-        }
-      }
-
-      return seen[resourceId];
-    };
-
-    const deserializeResource = async (
-      resourceId: string,
-      parents: string[],
-      isSharedResource: boolean,
-    ): Promise<UnknownResource> => {
-      const { className, resource } = isSharedResource
-        ? serializedOutput.sharedResources[resourceId]
-        : serializedOutput.resources[resourceId];
-      const deserializationClass = this.classMapping[className];
-
-      const deserializedResource = await deserializationClass.unSynth(
-        deserializationClass,
-        resource,
-        parents || [],
-        deReferenceResource,
-      );
-
-      seen[resourceId] = deserializedResource;
-      if (deReferencePromises[resourceId]) {
-        deReferencePromises[resourceId][1](true);
-        clearTimeout(deReferencePromises[resourceId][3]);
-      }
-
-      return deserializedResource;
-    };
-
-    // Re-generate resource parents from dependencies.
-    for (const d of serializedOutput.dependencies) {
-      const fromResourceId = d.from.split('=')[1];
-      const toResourceId = d.to.split('=')[1];
-
-      if (!parents[fromResourceId]) {
-        parents[fromResourceId] = [];
-      }
-      if (!parents[toResourceId]) {
-        parents[toResourceId] = [];
-      }
-
-      // Resources don't have other relationships than parent-child relations.
-      if (d.relationship?.type === 'child' && !parents[fromResourceId].includes(toResourceId)) {
-        parents[fromResourceId].push(toResourceId);
-      } else if (d.relationship?.type === 'parent' && !parents[toResourceId].includes(fromResourceId)) {
-        parents[toResourceId].push(fromResourceId);
-      }
-    }
-
-    // Deserialize all serialized resources.
-    const promiseToDeserializeResources: Promise<UnknownResource>[] = [];
-    for (const resourceId in serializedOutput.resources) {
-      promiseToDeserializeResources.push(deserializeResource(resourceId, parents[resourceId], false));
-    }
-    await Promise.all(promiseToDeserializeResources);
-
-    // Deserialize all serialized shared-resources.
-    const promiseToDeserializeSharedResources: Promise<UnknownResource>[] = [];
-    for (const resourceId in serializedOutput.sharedResources) {
-      promiseToDeserializeSharedResources.push(deserializeResource(resourceId, parents[resourceId], true));
-    }
-    await Promise.all(promiseToDeserializeSharedResources);
-
-    return seen;
-  }
-
-  async deserialize(serializedOutput: ResourceSerializedOutput): Promise<void> {
-    const deserializedOutput = await this._deserialize(serializedOutput);
-    const deserializedOutputCopy = await this._deserialize(serializedOutput);
-
-    // Initialize a new instance of ResourceDataRepository, overwriting the previous one.
-    await Container.get(ResourceDataRepository, {
-      args: [true, Object.values(deserializedOutput), Object.values(deserializedOutputCopy)],
-    });
-  }
-
-  registerClass(className: string, deserializationClass: any): void {
-    this.classMapping[className] = deserializationClass;
-  }
-
-  async serialize(): Promise<ResourceSerializedOutput> {
-    const resourceDataRepository = await Container.get(ResourceDataRepository);
-    const resources = resourceDataRepository.getByProperties();
-
-    const dependencies: IDependency[] = [];
-    const serializedResources: ResourceSerializedOutput['resources'] = {};
-    const sharedSerializedResources: ResourceSerializedOutput['sharedResources'] = {};
-
-    for (const resource of resources) {
-      // Skip serializing resources marked as deleted.
-      if (resource.isMarkedDeleted()) {
-        continue;
-      }
-
-      const resourceDependencies = resource['dependencies'].map((d) => d.synth());
-      dependencies.push(...resourceDependencies);
-
-      if (resource.MODEL_TYPE === 'shared-resource') {
-        sharedSerializedResources[resource.resourceId] = {
-          className: resource.constructor.name,
-          resource: resource.synth(),
-        };
-      } else {
-        serializedResources[resource.resourceId] = {
-          className: resource.constructor.name,
-          resource: resource.synth(),
-        };
-      }
-    }
-
-    return { dependencies, resources: serializedResources, sharedResources: sharedSerializedResources };
-  }
-
-  setResourceDeserializationTimeout(timeoutInMs: number): void {
-    this.RESOURCE_DESERIALIZATION_TIMEOUT_IN_MS = timeoutInMs;
-  }
-}
-
-@Factory<ResourceSerializationService>(ResourceSerializationService)
-export class ResourceSerializationServiceFactory {
-  private static instance: ResourceSerializationService;
-
-  static async create(): Promise<ResourceSerializationService> {
-    if (!this.instance) {
-      this.instance = new ResourceSerializationService();
-    }
-    return this.instance;
-  }
-}

package/src/services/state-management/local.state-provider.spec.ts

@@ -1,42 +0,0 @@
-import { unlink } from 'fs';
-import { dirname, join } from 'path';
-import { fileURLToPath } from 'url';
-import { promisify } from 'util';
-import { LocalStateProvider } from './local.state-provider.js';
-import { StateManagementService } from './state-management.service.js';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const unlinkAsync = promisify(unlink);
-
-describe('LocalStateProvider UT', () => {
-  let filePath;
-
-  afterEach(async () => {
-    if (filePath) {
-      await unlinkAsync(filePath);
-    }
-  });
-
-  it('should be able to save state', async () => {
-    filePath = join(__dirname, 'manifest.json');
-
-    const localStateProvider = new LocalStateProvider(__dirname);
-    const stateManagementService = new StateManagementService(localStateProvider);
-
-    const data = Buffer.from(
-      JSON.stringify({
-        key1: 'value1',
-        key2: 'value2',
-      }),
-    );
-    await stateManagementService.saveState('manifest.json', data);
-
-    const manifestData = await stateManagementService.getState('manifest.json');
-    expect(JSON.parse(manifestData.toString())).toMatchInlineSnapshot(`
-      {
-        "key1": "value1",
-        "key2": "value2",
-      }
-    `);
-  });
-});

package/src/services/state-management/local.state-provider.ts

@@ -1,23 +0,0 @@
-import { readFile, writeFile } from 'fs';
-import { join, resolve } from 'path';
-import { promisify } from 'util';
-import { IStateProvider } from './state-provider.interface.js';
-
-const readFileAsync = promisify(readFile);
-const writeFileAsync = promisify(writeFile);
-
-export class LocalStateProvider implements IStateProvider {
-  private readonly localStateDirectoryPath: string;
-
-  constructor(localStateDirectoryPath: string) {
-    this.localStateDirectoryPath = resolve(localStateDirectoryPath);
-  }
-
-  async getState(stateFileName: string): Promise<Buffer> {
-    return readFileAsync(join(this.localStateDirectoryPath, stateFileName));
-  }
-
-  async saveState(stateFileName: string, data: Buffer): Promise<void> {
-    await writeFileAsync(join(this.localStateDirectoryPath, stateFileName), data);
-  }
-}

package/src/services/state-management/state-management.service.ts

@@ -1,43 +0,0 @@
-import { Factory } from '../../decorators/factory.decorator.js';
-import { IStateProvider } from './state-provider.interface.js';
-
-export class StateManagementService {
-  private readonly stateProvider: IStateProvider;
-
-  constructor(stateProvider: IStateProvider) {
-    this.stateProvider = stateProvider;
-  }
-
-  async getState(stateFileName: string, defaultValue?: any): Promise<Buffer> {
-    try {
-      return await this.stateProvider.getState(stateFileName);
-    } catch (error) {
-      if (error.code === 'ENOENT' && defaultValue) {
-        return defaultValue;
-      } else {
-        throw error;
-      }
-    }
-  }
-
-  async saveState(stateFileName: string, data: Buffer): Promise<void> {
-    return this.stateProvider.saveState(stateFileName, data);
-  }
-}
-
-@Factory<StateManagementService>(StateManagementService)
-export class StateManagementServiceFactory {
-  private static instance: StateManagementService;
-
-  static async create(stateProvider: IStateProvider): Promise<StateManagementService> {
-    if (this.instance) {
-      return this.instance;
-    }
-
-    if (!stateProvider) {
-      throw new Error(`Failed to create instance of ${StateManagementService.name} due to insufficient arguments!`);
-    }
-    this.instance = new StateManagementService(stateProvider);
-    return this.instance;
-  }
-}

package/src/services/state-management/state-provider.interface.ts

@@ -1,5 +0,0 @@
-export interface IStateProvider {
-  getState(stateFileName: string): Promise<Buffer>;
-
-  saveState(stateFileName: string, data: Buffer): Promise<void>;
-}