feat: WIP added a file modification calculator to calculate imports

Author: kevinwang5658

package-lock.json

@@ -10,11 +10,13 @@
     "@oclif/core": "^4.0.8",
     "@oclif/plugin-help": "^6.2.4",
     "@oclif/plugin-update": "^4.6.13",
+    "@types/diff": "^7.0.1",
     "ajv": "^8.12.0",
     "ajv-formats": "^3.0.1",
     "chalk": "^5.3.0",
     "codify-schemas": "^1.0.63",
     "debug": "^4.3.4",
+    "diff": "^7.0.0",
     "ink": "^5",
     "jotai": "^2.11.1",
     "js-yaml": "^4.1.0",

package.json

@@ -113,6 +113,11 @@ export class ResourceConfig implements ConfigBlock {
     this.raw.name = name;
   }
 
+  setParameter(name: string, value: unknown) {
+    this.parameters[name] = value;
+    this.raw[name] = value;
+  }
+
   addDependenciesFromDependsOn(resourceExists: (id: string) => boolean) {
     for (const id of this.dependsOn) {
       if (!resourceExists(id)) {

src/entities/resource-config.ts

@@ -0,0 +1,65 @@
+import { describe, it, vi, afterEach } from 'vitest';
+import { FileModificationCalculator, ModificationType } from './file-modification-calculator';
+import { ResourceConfig } from '../entities/resource-config';
+import { ResourceInfo } from '../entities/resource-info';
+import { FileType, InMemoryFile } from '../parser/entities';
+
+vi.mock('node:fs', async () => {
+  const { fs } = await import('memfs');
+  return fs
+})
+
+vi.mock('node:fs/promises', async () => {
+  const { fs } = await import('memfs');
+  return fs.promises;
+})
+
+
+describe('File modification calculator tests', () => {
+
+  it('Can generate a diff and a new file', async () => {
+    const existingResource = new ResourceConfig({
+      type: 'resource1'
+    });
+    existingResource.attachResourceInfo(generateResourceInfo('resource1'))
+
+    const existingFileContents =
+`[
+  {
+    "type": "project",
+    "plugins": {
+      "default": "latest",
+    }
+  },
+  { "type": "resource1" }
+]`
+    const existingFile = <InMemoryFile> { filePath: '/path/to/file.json', fileType: FileType.JSON, contents: existingFileContents };
+
+    const modifiedResource = new ResourceConfig({
+      type: 'resource1',
+      parameter1: 'abc'
+    })
+    modifiedResource.attachResourceInfo(generateResourceInfo('resource1'))
+
+    const calculator = new FileModificationCalculator([existingResource], existingFile)
+    const result = await calculator.calculate([{
+      modification: ModificationType.INSERT_OR_UPDATE,
+      resource: modifiedResource,
+    }])
+
+    console.log(result)
+    console.log(result.diff)
+  })
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  })
+})
+
+function generateResourceInfo(type: string, requiredParameters?: string[]): ResourceInfo {
+  return ResourceInfo.fromResponseData({
+    plugin: 'plugin',
+    type,
+    import: { requiredParameters }
+  })
+}

src/utils/file-modification-calculator.test.ts

@@ -0,0 +1,119 @@
+import chalk from 'chalk';
+import { ResourceConfig } from '../entities/resource-config.js';
+import * as Diff from 'diff'
+import { FileType, InMemoryFile } from '../parser/entities.js';
+
+export enum ModificationType {
+  INSERT_OR_UPDATE,
+  DELETE
+}
+
+export interface ModifiedResource {
+  resource: ResourceConfig;
+  modification: ModificationType
+}
+
+export interface FileModificationResult {
+  newFile: string;
+  diff: string;
+}
+
+export class FileModificationCalculator {
+  private existingFile?: InMemoryFile;
+  private existingResources: ResourceConfig[];
+
+  constructor(existingResources: ResourceConfig[], existingFile: InMemoryFile) {
+    this.existingFile = existingFile;
+    this.existingResources = existingResources;
+  }
+
+  async calculate(modifications: ModifiedResource[]): Promise<FileModificationResult> {
+    const resultResources = [...this.existingResources]
+
+    if (this.existingResources.length === 0 || !this.existingFile) {
+      const newFile = JSON.stringify(
+        modifications
+          .filter((r) => r.modification === ModificationType.INSERT_OR_UPDATE)
+          .map((r) => r.resource.raw),
+        null, 2)
+
+      return {
+        newFile,
+        diff: this.diff('', newFile),
+      }
+    }
+
+    this.validate(modifications);
+
+    for (const modified of modifications) {
+      const duplicateIndex = this.existingResources.findIndex((existing) => existing.isSameOnSystem(modified.resource))
+
+      if (duplicateIndex === -1) {
+        if (modified.modification === ModificationType.INSERT_OR_UPDATE) {
+          resultResources.push(modified.resource);
+        }
+
+        continue;
+      }
+
+      if (modified.modification === ModificationType.DELETE) {
+        resultResources.splice(duplicateIndex, 1);
+        continue;
+      }
+
+      const duplicate = resultResources[duplicateIndex];
+      for (const [key, newValue] of Object.entries(modified.resource.parameters)) {
+        duplicate.setParameter(key, newValue);
+      }
+    }
+
+    const newFile = JSON.stringify(
+      resultResources.map((r) => r.raw),
+      null, 2
+    );
+
+    return {
+      newFile,
+      diff: this.diff(this.existingFile.contents, newFile),
+    }
+  }
+
+  validate(modifiedResources: ModifiedResource[]): void {
+    if (!this.existingFile) {
+      return;
+    }
+
+    if (this.existingFile?.fileType !== FileType.JSON) {
+      throw new Error(`Only updating .json files are currently supported. Found ${this.existingFile?.filePath}`);
+    }
+
+    if (this.existingResources.some((r) => !r.resourceInfo)) {
+      const badResources = this.existingResources
+        .filter((r) => !r.resourceInfo)
+        .map((r) => r.id);
+
+      throw new Error(`All resources must have resource info attached to generate diff. Found bad resources: ${badResources}`);
+    }
+
+    if (modifiedResources.some((r) => !r.resource.resourceInfo)) {
+      const badResources = modifiedResources
+        .filter((r) => !r.resource.resourceInfo)
+        .map((r) => r.resource.id);
+
+      throw new Error(`All resources must have resource info attached to generate diff. Found bad resources: ${badResources}`);
+    }
+  }
+
+  diff(a: string, b: string): string {
+    const diff = Diff.diffLines(a, b);
+
+    let result = '';
+    diff.forEach((part) => {
+      result += part.added ? chalk.green(part.value) :
+        part.removed ? chalk.red(part.value) :
+          part.value;
+    });
+
+    return result;
+  }
+}