Backend for reading and writing overrides for bundle config (#901)

## Changes
* Adds
* `BundleConfigReaderWriter`: Manages reading and writing configs
to/from the `BundleFileSet`
* `ConfigOverrideReaderWriter`: Manages reading and writing configs
to/from the `StateStorage`
* `ConfigModel`: Provides a centralised view of the configs after
applying any overrides. This is the single source of truth for all
features that require reading/writing these configs.


## Tests
<!-- How is this tested? -->

Author: kartikgupta-db

packages/databricks-vscode/.eslintrc.json

@@ -0,0 +1,6 @@
+{
+    "plugins": ["eslint-plugin-local-rules"],
+    "rules": {
+        "local-rules/mutex-synchronised-decorator": "error"
+    }
+}

packages/databricks-vscode/eslint-local-rules/index.js

@@ -0,0 +1,12 @@
+/* eslint-disable */
+require("ts-node").register({
+    transpileOnly: true,
+    compilerOptions: {
+        module: "commonjs",
+    },
+});
+
+module.exports = {
+    "mutex-synchronised-decorator":
+        require("./rules/mutexSynchronisedDecorator").default,
+};

packages/databricks-vscode/eslint-local-rules/rules/mutexSynchronisedDecorator.ts

@@ -0,0 +1,76 @@
+/* eslint-disable no-console */
+import {ESLintUtils, AST_NODE_TYPES} from "@typescript-eslint/utils";
+
+const rule = ESLintUtils.RuleCreator.withoutDocs({
+    create(context) {
+        return {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            Decorator(node) {
+                if (
+                    node.expression.type === "CallExpression" &&
+                    node.expression.callee.type ===
+                        AST_NODE_TYPES.MemberExpression &&
+                    node.expression.callee.object.type ===
+                        AST_NODE_TYPES.Identifier &&
+                    node.expression.callee.object.name === "Mutex" &&
+                    node.expression.callee.property.type ===
+                        AST_NODE_TYPES.Identifier &&
+                    node.expression.callee.property.name === "synchronise" &&
+                    node.expression.arguments.length > 0
+                ) {
+                    const mutexName =
+                        node.expression.arguments[0].type ===
+                        AST_NODE_TYPES.Literal
+                            ? (node.expression.arguments[0].value as string)
+                            : "";
+
+                    if (node.parent.parent?.type !== AST_NODE_TYPES.ClassBody) {
+                        return context.report({
+                            node,
+                            messageId: "decoratorNotInClass",
+                        });
+                    }
+
+                    const exists = node.parent.parent.body.some((element) => {
+                        return (
+                            element.type ===
+                                AST_NODE_TYPES.PropertyDefinition &&
+                            element.key.type === AST_NODE_TYPES.Identifier &&
+                            element.key.name === mutexName
+                        );
+                    });
+
+                    const className =
+                        node.parent.parent.parent?.type ===
+                        AST_NODE_TYPES.ClassDeclaration
+                            ? node.parent.parent.parent.id?.name
+                            : undefined;
+
+                    if (!exists) {
+                        return context.report({
+                            node,
+                            messageId: "synchronisedMutexNotInClass",
+                            data: {
+                                mutexName,
+                                className,
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+    meta: {
+        type: "problem",
+        schema: [],
+        messages: {
+            decoratorNotInClass:
+                "Mutex.synchronized() should be used inside a class",
+            synchronisedMutexNotInClass:
+                'Mutex "{{mutexName}}" is not defined in class "{{className}}".',
+        },
+    },
+    defaultOptions: [],
+});
+
+export default rule;

packages/databricks-vscode/eslint-local-rules/tsconfig.json

@@ -0,0 +1,6 @@
+{
+    "transpileOnly": true,
+    "compilerOptions": {
+        "module": "Node16"
+    }
+}

packages/databricks-vscode/package.json

@@ -709,6 +709,7 @@
         "@sinonjs/fake-timers": "^10.3.0",
         "@types/bcryptjs": "^2.4.2",
         "@types/chai": "^4.3.5",
+        "@types/eslint": "^8.44.6",
         "@types/fs-extra": "^11.0.1",
         "@types/mocha": "^10.0.2",
         "@types/mock-require": "^2.0.1",
@@ -720,6 +721,7 @@
         "@types/yargs": "^17.0.24",
         "@typescript-eslint/eslint-plugin": "^6.0.0",
         "@typescript-eslint/parser": "^6.0.0",
+        "@typescript-eslint/utils": "^6.9.0",
         "@vscode/test-electron": "^2.3.3",
         "@wdio/cli": "^8.12.2",
         "@wdio/local-runner": "^8.12.1",
@@ -729,6 +731,7 @@
         "chai": "^4.3.7",
         "esbuild": "^0.19.4",
         "eslint": "^8.51.0",
+        "eslint-plugin-local-rules": "^2.0.0",
         "fs-extra": "^11.1.1",
         "glob": "^10.3.10",
         "json-schema-to-typescript": "^13.1.1",

packages/databricks-vscode/src/bundle/BundleFileSet.ts

@@ -4,7 +4,7 @@ import {merge} from "lodash";
 import * as yaml from "yaml";
 import path from "path";
 import {BundleSchema} from "./BundleSchema";
-import {readFile} from "fs/promises";
+import {readFile, writeFile} from "fs/promises";
 import {CachedValue} from "../locking/CachedValue";
 import minimatch from "minimatch";
 
@@ -13,6 +13,10 @@ export async function parseBundleYaml(file: Uri) {
     return data as BundleSchema;
 }
 
+export async function writeBundleYaml(file: Uri, data: BundleSchema) {
+    await writeFile(file.fsPath, yaml.stringify(data));
+}
+
 function toGlobPath(path: string) {
     if (process.platform === "win32") {
         return path.replace(/\\/g, "/");
@@ -21,7 +25,7 @@ function toGlobPath(path: string) {
 }
 export class BundleFileSet {
     private rootFilePattern: string = "{bundle,databricks}.{yaml,yml}";
-    private _mergedBundle: CachedValue<BundleSchema> =
+    public readonly bundleDataCache: CachedValue<BundleSchema> =
         new CachedValue<BundleSchema>(async () => {
             let bundle = {};
             await this.forEach(async (data) => {
@@ -88,13 +92,15 @@ export class BundleFileSet {
         return [rootFile, ...((await this.getIncludedFiles()) ?? [])];
     }
 
-    async findFileWithPredicate(predicate: (file: Uri) => Promise<boolean>) {
-        const matchedFiles: Uri[] = [];
-        for (const file of await this.allFiles()) {
-            if (await predicate(file)) {
-                matchedFiles.push(file);
+    async findFile(
+        predicate: (data: BundleSchema, file: Uri) => Promise<boolean>
+    ) {
+        const matchedFiles: {data: BundleSchema; file: Uri}[] = [];
+        this.forEach(async (data, file) => {
+            if (await predicate(data, file)) {
+                matchedFiles.push({data, file});
             }
-        }
+        });
         return matchedFiles;
     }
 
@@ -123,12 +129,4 @@ export class BundleFileSet {
     async isBundleFile(e: Uri) {
         return this.isRootBundleFile(e) || (await this.isIncludedBundleFile(e));
     }
-
-    async invalidateMergedBundleCache() {
-        await this._mergedBundle.invalidate();
-    }
-
-    get mergedBundle() {
-        return this._mergedBundle.value;
-    }
 }

packages/databricks-vscode/src/bundle/types.ts

@@ -0,0 +1,3 @@
+import {BundleSchema} from "./BundleSchema";
+
+export type BundleTarget = Required<BundleSchema>["targets"][string];

packages/databricks-vscode/src/cli/DatabricksCliSyncParser.ts

@@ -123,6 +123,7 @@ export class DatabricksCliSyncParser {
                 return;
             }
         }
+        this.syncStateCallback("ERROR", data);
     }
 
     private matchForErrors(line: string) {