@quadnix/octo 0.0.2 → 0.0.4

package/src/resources/resource-data.repository.spec.ts

@@ -1,133 +0,0 @@
-import { jest } from '@jest/globals';
-import { Diff } from '../functions/diff/diff.model.js';
-import { ResourceDataRepository } from './resource-data.repository.js';
-import { AResource } from './resource.abstract.js';
-import { ASharedResource } from './shared-resource.abstract.js';
-
-class TestResource extends AResource<TestResource> {
-  readonly MODEL_NAME: string = 'test-resource';
-
-  constructor(resourceId: string) {
-    super(resourceId, {}, []);
-  }
-}
-
-class TestResourceWithDiffOverride extends AResource<TestResource> {
-  readonly MODEL_NAME: string = 'test-resource';
-
-  constructor(resourceId: string) {
-    super(resourceId, {}, []);
-  }
-
-  override async diff(): Promise<Diff[]> {
-    return [];
-  }
-}
-
-class SharedTestResource extends ASharedResource<TestResource> {
-  readonly MODEL_NAME: string = 'test-resource';
-
-  constructor(resourceId: string, properties: { [key: string]: unknown }, parents: [TestResource?]) {
-    super(resourceId, properties, parents as AResource<TestResource>[]);
-  }
-}
-
-describe('ResourceDataRepository UT', () => {
-  describe('diff()', () => {
-    it('should compare resources using resource diff()', async () => {
-      const oldResource = new TestResourceWithDiffOverride('resource-1');
-      const newResource = new TestResourceWithDiffOverride('resource-1');
-
-      const resourceDataRepository = new ResourceDataRepository([], [oldResource]);
-      resourceDataRepository.add(newResource);
-
-      const diffOverrideSpy = jest.spyOn(newResource, 'diff');
-
-      const diffs = await resourceDataRepository.diff();
-
-      expect(diffOverrideSpy).toHaveBeenCalledTimes(1);
-      expect(diffs).toMatchInlineSnapshot(`[]`);
-    });
-
-    it('should compare distinct resources', async () => {
-      const oldResource = new TestResource('resource-1');
-      const newResource = new TestResourceWithDiffOverride('resource-1');
-
-      const resourceDataRepository = new ResourceDataRepository([], [oldResource]);
-      resourceDataRepository.add(newResource);
-
-      const diffs = await resourceDataRepository.diff();
-
-      expect(diffs).toMatchInlineSnapshot(`[]`);
-    });
-
-    it('should compare same resources', async () => {
-      const oldResource = new TestResource('resource-1');
-      const newResource = new TestResource('resource-1');
-
-      const resourceDataRepository = new ResourceDataRepository([], [oldResource]);
-      resourceDataRepository.add(newResource);
-
-      const diffs = await resourceDataRepository.diff();
-
-      expect(diffs).toMatchInlineSnapshot(`[]`);
-    });
-
-    it('should compare same resources with delete marker on latest', async () => {
-      const oldResource = new TestResource('resource-1');
-      const newResource = new TestResource('resource-1');
-
-      const resourceDataRepository = new ResourceDataRepository([], [oldResource]);
-      resourceDataRepository.add(newResource);
-      newResource.markDeleted();
-
-      const diffs = await resourceDataRepository.diff();
-
-      expect(diffs).toMatchInlineSnapshot(`
-        [
-          {
-            "action": "delete",
-            "field": "resourceId",
-            "value": "resource-1",
-          },
-        ]
-      `);
-    });
-
-    it('should add resource if not found in old', async () => {
-      const newResource = new TestResource('resource-1');
-
-      const resourceDataRepository = new ResourceDataRepository([], []);
-      resourceDataRepository.add(newResource);
-
-      const diffs = await resourceDataRepository.diff();
-
-      expect(diffs).toMatchInlineSnapshot(`
-        [
-          {
-            "action": "add",
-            "field": "resourceId",
-            "value": "resource-1",
-          },
-        ]
-      `);
-    });
-
-    it('should skip adding shared-resource if it already exists', async () => {
-      const resource1 = new TestResource('resource-1');
-      const resource2 = new TestResource('resource-2');
-      const sharedResource1 = new SharedTestResource('shared-test-resource', {}, [resource1]);
-      const sharedResource2 = new SharedTestResource('shared-test-resource', {}, [resource2]);
-
-      const resourceDataRepository = new ResourceDataRepository(
-        [resource1, resource2, sharedResource1],
-        [resource1, resource2, sharedResource1],
-      );
-      resourceDataRepository.add(sharedResource2);
-
-      const diffs = await resourceDataRepository.diff();
-
-      expect(diffs).toMatchInlineSnapshot(`[]`);
-    });
-  });
-});

package/src/resources/resource-data.repository.ts

@@ -1,92 +0,0 @@
-import { ActionOutputs, ModelType, UnknownResource } from '../app.type.js';
-import { Factory } from '../decorators/factory.decorator.js';
-import { Diff, DiffAction } from '../functions/diff/diff.model.js';
-import { IResource } from './resource.interface.js';
-
-export class ResourceDataRepository {
-  constructor(
-    private readonly newResources: UnknownResource[] = [],
-    private readonly oldResources: UnknownResource[] = [],
-  ) {
-    Object.freeze(this.oldResources);
-  }
-
-  private async _diffResources(newResources: ActionOutputs, oldResources: ActionOutputs): Promise<Diff[]> {
-    const diffs: Diff[] = [];
-
-    for (const oldResourceId in oldResources) {
-      if (!newResources[oldResourceId]) {
-        diffs.push(new Diff(oldResources[oldResourceId], DiffAction.DELETE, 'resourceId', oldResourceId));
-      } else {
-        const rDiff = await newResources[oldResourceId].diff(oldResources[oldResourceId]);
-        diffs.push(...rDiff);
-      }
-    }
-
-    for (const newResourceId in newResources) {
-      if (!oldResources[newResourceId]) {
-        const newResource = newResources[newResourceId];
-
-        if (newResource.MODEL_TYPE === 'shared-resource' || newResource.getSharedResource() !== undefined) {
-          const rDiff = await newResource.diff();
-          diffs.push(...rDiff);
-        } else {
-          diffs.push(new Diff(newResource, DiffAction.ADD, 'resourceId', newResource.resourceId));
-        }
-      }
-    }
-
-    return diffs;
-  }
-
-  add(resource: UnknownResource): void {
-    if (resource.MODEL_TYPE !== ModelType.RESOURCE && resource.MODEL_TYPE !== ModelType.SHARED_RESOURCE) {
-      throw new Error('Adding non-resource model!');
-    }
-
-    // Insert or replace resources.
-    const rIndex = this.newResources.findIndex((r) => r.resourceId === resource.resourceId);
-    if (rIndex === -1) {
-      this.newResources.push(resource);
-    } else {
-      this.newResources[rIndex] = resource;
-    }
-  }
-
-  async diff(): Promise<Diff[]> {
-    const newResources: ActionOutputs = this.newResources.reduce(
-      (accumulator, current) => ({ ...accumulator, [current.resourceId]: current }),
-      {},
-    );
-    const oldResources: ActionOutputs = this.oldResources.reduce(
-      (accumulator, current) => ({ ...accumulator, [current.resourceId]: current }),
-      {},
-    );
-
-    return this._diffResources(newResources, oldResources);
-  }
-
-  getById(resourceId: IResource['resourceId']): UnknownResource | undefined {
-    return this.newResources.find((r) => r.resourceId === resourceId);
-  }
-
-  getByProperties(filters: { key: string; value: any }[] = []): UnknownResource[] {
-    return this.newResources.filter((r) => filters.every((c) => r.properties[c.key] === c.value));
-  }
-}
-
-@Factory<ResourceDataRepository>(ResourceDataRepository)
-export class ResourceDataRepositoryFactory {
-  private static instance: ResourceDataRepository;
-
-  static async create(
-    forceNew: boolean,
-    newResources: UnknownResource[],
-    oldResources: UnknownResource[],
-  ): Promise<ResourceDataRepository> {
-    if (forceNew || !this.instance) {
-      this.instance = new ResourceDataRepository(newResources, oldResources);
-    }
-    return this.instance;
-  }
-}

package/src/resources/resource.abstract.ts

@@ -1,108 +0,0 @@
-import { ModelType, UnknownResource } from '../app.type.js';
-import { Diff, DiffAction } from '../functions/diff/diff.model.js';
-import { DiffUtility } from '../functions/diff/diff.utility.js';
-import { AModel } from '../models/model.abstract.js';
-import { IResource } from './resource.interface.js';
-import { ASharedResource } from './shared-resource.abstract.js';
-
-export abstract class AResource<T> extends AModel<IResource, T> {
-  abstract override readonly MODEL_NAME: string;
-  override readonly MODEL_TYPE: ModelType = ModelType.RESOURCE;
-
-  /*
-   * While model graph are well connected, resource graph can contain nodes that are completely disassociated.
-   * For this reason, we traverse the resource graph using an array. Thus, even after calling remove()
-   * on a resource node, it will be traversed, and there needs to be a marker to identify that it has been deleted.
-   * */
-  private _deleteMarker = false;
-
-  readonly properties: IResource['properties'] = {};
-
-  readonly resourceId: IResource['resourceId'];
-
-  readonly response: IResource['response'] = {};
-
-  protected constructor(
-    resourceId: IResource['resourceId'],
-    properties: IResource['properties'],
-    parents: UnknownResource[],
-  ) {
-    super();
-
-    this.resourceId = resourceId;
-
-    for (const key in properties) {
-      this.properties[key] = properties[key];
-    }
-
-    for (const parent of parents) {
-      parent.addChild('resourceId', this, 'resourceId');
-    }
-  }
-
-  async diff(previous?: T): Promise<Diff[]> {
-    const diffs: Diff[] = [];
-
-    if (this.isMarkedDeleted()) {
-      diffs.push(
-        new Diff((previous || this) as AModel<IResource, T>, DiffAction.DELETE, 'resourceId', this.resourceId),
-      );
-      return diffs;
-    }
-
-    if (previous) {
-      if (!DiffUtility.isObjectDeepEquals(this.properties, (previous as unknown as AResource<T>).properties)) {
-        diffs.push(new Diff(this, DiffAction.UPDATE, 'resourceId', this.resourceId));
-      }
-    } else {
-      diffs.push(new Diff(this, DiffAction.ADD, 'resourceId', this.resourceId));
-    }
-
-    return diffs;
-  }
-
-  getContext(): string {
-    return `${this.MODEL_NAME}=${this.resourceId}`;
-  }
-
-  getSharedResource(): ASharedResource<T> | undefined {
-    const sameModelDependencies = this.getChildren(this.MODEL_NAME)[this.MODEL_NAME];
-    const sharedResourceDependency = sameModelDependencies?.find((d) => d.to.MODEL_TYPE === ModelType.SHARED_RESOURCE);
-    return sharedResourceDependency?.to as ASharedResource<T>;
-  }
-
-  isMarkedDeleted(): boolean {
-    return this._deleteMarker;
-  }
-
-  markDeleted(): void {
-    super.remove();
-    this._deleteMarker = true;
-  }
-
-  override remove(): void {
-    throw new Error('Cannot use remove() on resources! Use a delete marker instead.');
-  }
-
-  synth(): IResource {
-    return {
-      properties: { ...this.properties },
-      resourceId: this.resourceId,
-      response: { ...this.response },
-    };
-  }
-
-  static override async unSynth(
-    deserializationClass: any,
-    resource: IResource,
-    parentResourceIds: string[],
-    deReferenceResource: (resourceId: string) => Promise<UnknownResource>,
-  ): Promise<UnknownResource> {
-    const parents = await Promise.all(parentResourceIds.map((p) => deReferenceResource(p)));
-    const deReferencedResource = new deserializationClass(resource.resourceId, resource.properties, parents);
-    for (const key in resource.response) {
-      deReferencedResource.response[key] = resource.response[key];
-    }
-    return deReferencedResource;
-  }
-}

package/src/resources/resource.interface.ts

@@ -1,7 +0,0 @@
-export interface IResource {
-  properties: { [key: string]: unknown };
-
-  resourceId: string;
-
-  response: { [key: string]: unknown };
-}

package/src/resources/resource.spec.ts

@@ -1,60 +0,0 @@
-import { AResource } from './resource.abstract.js';
-
-class TestResource extends AResource<TestResource> {
-  readonly MODEL_NAME: string = 'test-resource';
-
-  constructor(resourceId: string) {
-    super(resourceId, {}, []);
-  }
-}
-
-describe('Resource UT', () => {
-  it('should be able to associate with another resource as its child', () => {
-    const resource1 = new TestResource('resource-1');
-    const resource2 = new TestResource('resource-2');
-
-    resource2.addChild('resourceId', resource1, 'resourceId');
-
-    expect((resource2.getChildren()['test-resource'][0].to as AResource<TestResource>).resourceId).toBe('resource-1');
-  });
-
-  it('should be able to associate with another resource multiple times', () => {
-    const resource1 = new TestResource('resource-1');
-    const resource2 = new TestResource('resource-2');
-
-    resource2.addChild('resourceId', resource1, 'resourceId');
-    resource2.addChild('resourceId', resource1, 'resourceId');
-    expect(resource2.getChildren()['test-resource'].length).toBe(1);
-  });
-
-  describe('markDeleted()', () => {
-    it('should not be able to mark a resource deleted with dependencies', () => {
-      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');
-
-      expect(() => {
-        resource1.markDeleted();
-      }).toThrowErrorMatchingInlineSnapshot(`"Cannot remove model until dependent models exist!"`);
-    });
-
-    it('should be able to mark leaf resources deleted', () => {
-      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');
-
-      resource2.markDeleted();
-
-      expect(resource1.getChildren()).toMatchInlineSnapshot(`{}`);
-      expect(resource2.isMarkedDeleted()).toBe(true);
-    });
-  });
-});

package/src/resources/shared-resource.abstract.ts

@@ -1,53 +0,0 @@
-import { ModelType } from '../app.type.js';
-import { Diff } from '../functions/diff/diff.model.js';
-import { AResource } from './resource.abstract.js';
-
-export abstract class ASharedResource<T> extends AResource<T> {
-  override readonly MODEL_TYPE: ModelType = ModelType.SHARED_RESOURCE;
-
-  async diff(): Promise<Diff[]> {
-    return [];
-  }
-
-  findParentsByProperty(filters: { key: keyof AResource<T>['properties']; value: any }[]): AResource<T>[] {
-    const parents: AResource<T>[] = [];
-    const dependencies = Object.values(this.getParents()).flat();
-    for (const d of dependencies) {
-      const resource = d.to as AResource<T>;
-      if (filters.every((c) => resource.properties[c.key] === c.value)) {
-        parents.push(resource);
-      }
-    }
-    return parents;
-  }
-
-  override getSharedResource(): ASharedResource<T> | undefined {
-    return undefined;
-  }
-
-  merge(previousSharedResource: ASharedResource<T>): ASharedResource<T> {
-    const currentDependencies = Object.values(this.getParents()).flat();
-    const previousDependencies = Object.values(previousSharedResource.getParents()).flat();
-
-    for (const key in previousSharedResource.properties) {
-      if (previousSharedResource.properties.hasOwnProperty(key) && !(key in this.properties)) {
-        this.properties[key] = previousSharedResource.properties[key];
-      }
-    }
-
-    for (const key in previousSharedResource.response) {
-      if (previousSharedResource.response.hasOwnProperty(key) && !(key in this.response)) {
-        this.response[key] = previousSharedResource.response[key];
-      }
-    }
-
-    const previousParentsNotInCurrentSharedResource = previousDependencies
-      .filter((pd) => !currentDependencies.find((cd) => cd.isEqual(pd)))
-      .map((pd) => pd.to);
-    for (const parent of previousParentsNotInCurrentSharedResource) {
-      parent.addChild('resourceId', this, 'resourceId');
-    }
-
-    return this;
-  }
-}

package/src/resources/shared-resource.spec.ts

@@ -1,133 +0,0 @@
-import { Container } from '../decorators/container.js';
-import { ResourceSerializationService } from '../services/serialization/resource/resource-serialization.service.js';
-import { ResourceDataRepository } from './resource-data.repository.js';
-import { AResource } from './resource.abstract.js';
-import { ASharedResource } from './shared-resource.abstract.js';
-
-class ParentResource extends AResource<ParentResource> {
-  readonly MODEL_NAME: string = 'parent-resource';
-
-  constructor(resourceId: string) {
-    super(resourceId, {}, []);
-  }
-}
-
-class TestResource extends AResource<TestResource> {
-  readonly MODEL_NAME: string = 'test-resource';
-
-  constructor(resourceId: string, properties: { [key: string]: string }, parents: [ParentResource]) {
-    super(resourceId, properties, parents);
-  }
-}
-
-class SharedTestResource extends ASharedResource<TestResource> {
-  readonly MODEL_NAME: string = 'shared-test-resource';
-
-  constructor(resourceId: string, properties: object, parents: [TestResource?, TestResource?]) {
-    super(resourceId, {}, parents as AResource<TestResource>[]);
-  }
-}
-
-describe('SharedResource UT', () => {
-  let resourceSerializationService: ResourceSerializationService;
-
-  beforeAll(async () => {
-    resourceSerializationService = await Container.get(ResourceSerializationService);
-    resourceSerializationService.registerClass(ParentResource.name, ParentResource);
-    resourceSerializationService.registerClass(TestResource.name, TestResource);
-    resourceSerializationService.registerClass(SharedTestResource.name, SharedTestResource);
-  });
-
-  afterAll(() => {
-    Container.reset();
-  });
-
-  it('should serialize and deserialize empty shared-resources', async () => {
-    await Container.get(ResourceDataRepository, { args: [true, [], []] });
-
-    const serializedOutput = await resourceSerializationService.serialize();
-    expect(serializedOutput).toMatchInlineSnapshot(`
-      {
-        "dependencies": [],
-        "resources": {},
-        "sharedResources": {},
-      }
-    `);
-  });
-
-  it('should serialize and deserialize shared-resources with parent', async () => {
-    const parentResource = new ParentResource('parent-1');
-    const testResource = new TestResource('resource-1', { property1: 'property-value-1' }, [parentResource]);
-    testResource.response['response1'] = 'response-value-1';
-    const sharedTestResource = new SharedTestResource('shared-test-resource', {}, [testResource]);
-
-    const resources = [parentResource, testResource, sharedTestResource];
-    await Container.get(ResourceDataRepository, { args: [true, [...resources], [...resources]] });
-
-    const serializedOutput = await resourceSerializationService.serialize();
-    await resourceSerializationService.deserialize(serializedOutput);
-
-    const resourceDataRepository = await Container.get(ResourceDataRepository);
-    const deserializedResources = resourceDataRepository.getByProperties();
-
-    // Validate shared resources are same pre/post serialization.
-    expect(deserializedResources.sort((a, b) => a.resourceId.localeCompare(b.resourceId))).toEqual(
-      resources.sort((a, b) => a.resourceId.localeCompare(b.resourceId)),
-    );
-  });
-
-  it('should serialize and deserialize shared-resources with different parents', async () => {
-    // "resource-1" is a shared-resource(S1) parented by "parent-1".
-    const parentResource1 = new ParentResource('parent-1');
-    const testResource1 = new TestResource('resource-1', { property1: 'property-value-1' }, [parentResource1]);
-    // "resource-2" is also a shared-resource(S1), but parented by "parent-2".
-    const parentResource2 = new ParentResource('parent-2');
-    const testResource2 = new TestResource('resource-2', { property2: 'property-value-2' }, [parentResource2]);
-    const sharedTestResource = new SharedTestResource('shared-test-resource', {}, [testResource1, testResource2]);
-
-    const resources = [parentResource1, testResource1, parentResource2, testResource2, sharedTestResource];
-    await Container.get(ResourceDataRepository, { args: [true, [...resources], [...resources]] });
-
-    const serializedOutput = await resourceSerializationService.serialize();
-    await resourceSerializationService.deserialize(serializedOutput);
-
-    const resourceDataRepository = await Container.get(ResourceDataRepository);
-    const deserializedResources = resourceDataRepository.getByProperties();
-
-    // Validate shared resources are same pre/post serialization.
-    expect(deserializedResources.sort((a, b) => a.resourceId.localeCompare(b.resourceId))).toEqual(
-      resources.sort((a, b) => a.resourceId.localeCompare(b.resourceId)),
-    );
-  });
-
-  describe('merge()', () => {
-    it('should merge old shared resource with self and return new shared resource', () => {
-      const resource1 = new ParentResource('resource-1');
-      const resource2 = new ParentResource('resource-2');
-
-      const sharedResource1 = new SharedTestResource('shared-resource', {}, [resource1]);
-      sharedResource1.properties['property-1'] = 'property-value-1';
-      sharedResource1.response['response-1'] = 'response-value-1';
-
-      const sharedResource2 = new SharedTestResource('shared-resource', {}, [resource2]);
-      sharedResource2.properties['property-2'] = 'property-value-2';
-      sharedResource2.response['response-2'] = 'response-value-2';
-
-      const mergedSharedResource = sharedResource2.merge(sharedResource1);
-
-      expect(mergedSharedResource['dependencies'].length).toBe(2);
-      expect(mergedSharedResource.properties).toMatchInlineSnapshot(`
-        {
-          "property-1": "property-value-1",
-          "property-2": "property-value-2",
-        }
-      `);
-      expect(mergedSharedResource.response).toMatchInlineSnapshot(`
-        {
-          "response-1": "response-value-1",
-          "response-2": "response-value-2",
-        }
-      `);
-    });
-  });
-});