feat: Added new isSameOnSystem method on resource entity + tests

Author: kevinwang5658

src/entities/resource-config.test.ts

@@ -1,8 +1,9 @@
 //import { ProjectConfig } from './project.js';
 import { describe, expect, it } from 'vitest';
 import { ResourceConfig } from './resource-config';
+import { ResourceInfo } from './resource-info';
 
-describe('Parser: project entity tests', () => {
+describe('Resource config unit tests', () => {
   it('parses an empty project', () => {
     expect(new ResourceConfig({
       type: 'anything',
@@ -23,4 +24,104 @@ describe('Parser: project entity tests', () => {
 
   it('plugin versions must be semvers', () => {
   })
+
+  it ('detects if two resource configs represent the same thing on the system (different types)', () => {
+    const resource1 = new ResourceConfig({
+      type: 'type1',
+    })
+    const resource2 = new ResourceConfig({
+      type: 'type2',
+    })
+    expect(resource1.isSameOnSystem(resource2, false)).to.be.false;
+
+    const resource3 = new ResourceConfig({
+      type: 'type1',
+    })
+    const resource4 = new ResourceConfig({
+      type: 'type1',
+    })
+    expect(resource3.isSameOnSystem(resource4, false)).to.be.true;
+  })
+
+
+  it ('detects if two resource configs represent the same thing on the system (different names)', () => {
+    // Fails
+    const resource1 = new ResourceConfig({
+      type: 'type1',
+      name: 'name1',
+    })
+    const resource2 = new ResourceConfig({
+      type: 'type1',
+      name: 'name2'
+    })
+    expect(resource1.isSameOnSystem(resource2)).to.be.false;
+
+    // Passes
+    const resource3 = new ResourceConfig({
+      type: 'type1',
+      name: 'name1',
+    })
+    const resource4 = new ResourceConfig({
+      type: 'type1',
+      name: 'name1'
+    })
+    expect(resource3.isSameOnSystem(resource4, false)).to.be.true;
+  })
+
+  it ('detects if two resource configs represent the same thing on the system (different required parameters)', () => {
+    // Passes
+    const resourceInfo = ResourceInfo.fromResponseData({
+      type: 'type1',
+      schema: {
+        type: 'object',
+        required: ['param1', 'param2'],
+        properties: {
+          param1: {},
+          param2: {},
+          param3: {}
+        }
+      }
+    });
+
+    const resource1 = new ResourceConfig({
+      type: 'type1',
+      param2: 'b',
+      name: 'name1',
+      param1: 'a',
+      param3: 'c'
+    })
+    resource1.attachResourceInfo(resourceInfo)
+
+    const resource2 = new ResourceConfig({
+      param3: 'different',
+      type: 'type1',
+      name: 'name1',
+      param1: 'a',
+      param2: 'b',
+    })
+    resource2.attachResourceInfo(resourceInfo)
+
+    expect(resource1.isSameOnSystem(resource2)).to.be.true;
+
+    // Fails
+    const resource3 = new ResourceConfig({
+      type: 'type1',
+      name: 'name1',
+      param1: 'a',
+      param2: 'b',
+      param3: 'c'
+    })
+    resource3.attachResourceInfo(resourceInfo)
+
+    const resource4 = new ResourceConfig({
+      type: 'type1',
+      name: 'name1',
+      param1: 'a',
+      param2: 'different',
+      param3: 'different'
+    })
+    resource4.attachResourceInfo(resourceInfo)
+
+    expect(resource3.isSameOnSystem(resource4)).to.be.false;
+  })
 });

src/entities/resource-config.ts

@@ -1,6 +1,8 @@
 import { ResourceJson, ResourceConfig as SchemaResourceConfig } from 'codify-schemas';
 
+import { deepEqual } from '../utils/index.js';
 import { ConfigBlock, ConfigType } from './config.js';
+import { ResourceInfo } from './resource-info.js';
 
 /** Resource JSON supported format
  * {
@@ -32,6 +34,8 @@ export class ResourceConfig implements ConfigBlock {
   dependencyIds: string[] = []; // id of other nodes
   parameters: Record<string, unknown>;
 
+  resourceInfo?: ResourceInfo;
+
   constructor(config: SchemaResourceConfig, sourceMapKey?: string) {
     const { dependsOn, name, type, ...parameters } = config;
 
@@ -69,6 +73,41 @@ export class ResourceConfig implements ConfigBlock {
     return externalId === this.id;
   }
 
+  /**
+   * Useful for imports, creates and destroys. This checks if two resources represents the same installation on the system.
+   */
+  isSameOnSystem(other: ResourceConfig, checkResourceInfo = true): boolean {
+    if (other.type !== this.type) {
+      return false;
+    }
+
+    // If names are specified then that means Codify intends for the resources to be the same
+    if (other.name && this.name && other.name !== this.name) {
+      return false;
+    }
+
+    if (!checkResourceInfo) {
+      return true;
+    }
+
+    if (!this.resourceInfo || !other.resourceInfo) {
+      throw new Error(`checkResourceInfo specified but no resource info provided (${this.type}) (other: ${other.type})`)
+    }
+
+    const thisRequiredKeys = new Set(this.resourceInfo.getRequiredParameters().map((p) => p.name));
+    const otherRequiredKeys = new Set(other.resourceInfo.getRequiredParameters().map((p) => p.name));
+
+    const thisRequiredParameters = Object.fromEntries(Object.entries(this.parameters)
+      .filter(([k]) => thisRequiredKeys.has(k))
+    );
+    const otherRequiredParameters = Object.fromEntries(Object.entries(other.parameters)
+      .filter(([k]) => otherRequiredKeys.has(k))
+    );
+
+    return deepEqual(thisRequiredParameters, otherRequiredParameters);
+
+  }
+
   setName(name: string) {
     this.name = name;
     this.raw.name = name;
@@ -113,4 +152,12 @@ export class ResourceConfig implements ConfigBlock {
   addDependencies(dependencies: string[]) {
     this.dependencyIds.push(...dependencies);
   }
+
+  attachResourceInfo(resourceInfo: ResourceInfo) {
+    if (resourceInfo.type !== this.type) {
+      throw new Error(`Attempting to attach resource info (${resourceInfo.type}) on an un-related resource (${this.type})`)
+    }
+
+    this.resourceInfo = resourceInfo;
+  }
 }

src/entities/resource-info.ts

@@ -5,7 +5,7 @@ interface ParameterInfo {
   type?: string;
   description?: string;
   isRequired: boolean;
-  value: unknown;
+  value?: unknown;
 }
 
 export class ResourceInfo implements GetResourceInfoResponseData {
@@ -15,6 +15,8 @@ export class ResourceInfo implements GetResourceInfoResponseData {
   dependencies?: string[] | undefined;
   import?: { requiredParameters: null | string[]; } | undefined;
 
+  private constructor() {}
+
   get description(): string | undefined {
     return this.schema?.description as string | undefined;
   }
@@ -31,14 +33,16 @@ export class ResourceInfo implements GetResourceInfoResponseData {
       return [];
     }
 
-    const { properties } = schema;
+    const { properties, required } = schema;
     if (!properties || typeof properties !== 'object') {
       return [];
     }
 
     return Object.entries(properties)
       .map(([propertyName, info]) => {
-        const isRequired = this.import?.requiredParameters?.some((name) => name === propertyName) ?? false
+        const isRequired = this.import?.requiredParameters?.some((name) => name === propertyName)
+          ?? (required as string[] | undefined)?.includes(propertyName)
+          ?? false;
 
         return {
           name: propertyName,

src/utils/index.ts

@@ -29,3 +29,33 @@ export function sleep(ms: number): Promise<void> {
     setTimeout(resolve, ms)
   });
 }
+
+export function deepEqual(obj1: unknown, obj2: unknown): boolean {
+  // Base case: If both objects are identical, return true.
+  if (obj1 === obj2) {
+    return true;
+  }
+
+  // Check if both objects are objects and not null.
+  if (typeof obj1 !== 'object' || typeof obj2 !== 'object' || obj1 === null || obj2 === null) {
+    return false;
+  }
+
+  // Get the keys of both objects.
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  // Check if the number of keys is the same.
+  if (keys1.length !== keys2.length) {
+    return false;
+  }
+
+  // Iterate through the keys and compare their values recursively.
+  for (const key of keys1) {
+    if (!keys2.includes(key) || !deepEqual(obj1[key], obj2[key])) {
+      return false;
+    }
+  }
+
+  // If all checks pass, the objects are deep equal.
+  return true;
+}