@superblocksteam/sdk 1.14.2 → 2.0.3-next.100

package/test/version-control.test.mts

@@ -0,0 +1,1412 @@
+import os from "node:os";
+import path from "node:path";
+import { readAppApiYamlFile, LoopType } from "@superblocksteam/util";
+import { expect } from "chai";
+import fs from "fs-extra";
+import { describe, it } from "mocha";
+import { stringify as ymlstringify } from "yaml";
+import { FeatureFlags } from "../src/flag.js";
+import {
+  addExistingFilePathsForApi,
+  validateLocalResource,
+  writeAppApi,
+  writeApplicationToDisk,
+  writeResourceToDisk,
+} from "../src/version-control.mjs";
+import type {
+  ApplicationWrapper,
+  MultiPageApplicationWrapperWithComponents,
+} from "../src/client.js";
+import type { ApiWithPb } from "../src/types/common.js";
+import type { ApiRepresentation } from "../src/version-control.mjs";
+import type {
+  SuperblocksApplicationConfig,
+  SuperblocksBackendConfig,
+  SuperblocksConfig,
+} from "@superblocksteam/util";
+import type { ApiWrapper } from "@superblocksteam/util";
+
+// set to false to use the `test-output` workspace directory for debugging
+const USE_TEMP_TEST_DIR = true;
+
+const JS_LINE = "const x = 1;\n";
+const SMALL_JS_CONTENT = JS_LINE.repeat(2);
+const LARGE_JS_CONTENT = JS_LINE.repeat(20);
+const LARGER_JS_CONTENT = JS_LINE.repeat(30);
+
+const EXTRACT_SOURCE_CODE: ApiRepresentation = {
+  extractLargeSourceFiles: true,
+  minLinesForExtraction: 0,
+};
+const NO_EXTRACT_SOURCE_CODE: ApiRepresentation = {
+  extractLargeSourceFiles: false,
+  minLinesForExtraction: 0,
+};
+
+describe("version-control", function () {
+  const testDir = USE_TEMP_TEST_DIR
+    ? // eslint-disable-next-line mocha/no-setup-in-describe
+      fs.mkdtempSync(path.join(os.tmpdir(), "test-output"))
+    : // eslint-disable-next-line mocha/no-setup-in-describe
+      new URL("../../test-output", import.meta.url).pathname;
+
+  beforeEach(async function () {
+    // Clean up the temporary directory before each test, then create it
+    await fs.rm(testDir, { recursive: true, force: true });
+    await fs.ensureDir(testDir);
+  });
+
+  afterEach(async function () {
+    // Clean up the temporary directory after each test
+    await fs.rm(testDir, { recursive: true, force: true });
+  });
+
+  describe("writeAppApi", function () {
+    it("should write app api to separate directory with correct name", async function () {
+      // Setup
+      const api: ApiWrapper = {
+        apiPb: {
+          metadata: {
+            id: "test-id",
+            name: "Test API",
+            organization: "test-org-id",
+          },
+          blocks: [],
+          trigger: {},
+        },
+      };
+      const apiPromises: Promise<void>[] = [];
+
+      // Execute
+      const existingFilePaths = new Set<string>(); // empty since not overwriting existing files
+      const apiInfo = await writeAppApi(
+        api,
+        testDir,
+        existingFilePaths,
+        apiPromises,
+        EXTRACT_SOURCE_CODE,
+      );
+      await Promise.all(apiPromises);
+
+      // Verify the ApiInfo object is correct
+      expect(apiInfo.name).to.equal("Test API");
+      expect(apiInfo.sourceFiles).to.deep.equal([]);
+
+      // Verify the files exist and match expectations: one YAML file in directory nested under `apis`
+      const apiDir = path.join(testDir, "apis");
+      await expectFileExists(apiDir, "test_api/api.yaml");
+
+      // And does not have a YAML file in the `apis` directory
+      await expectNoFileExists(apiDir, "test_api.yaml");
+
+      // and can be read back in
+      (await readApiFile(apiDir, "Test API")).to.deep.equal({
+        api: api.apiPb,
+        stepPathMap: {},
+      });
+    });
+
+    it("should write app api to separate directory and extract large code blocks to separate files", async function () {
+      // Setup
+      const api: ApiWrapper = {
+        apiPb: {
+          metadata: {
+            id: "test-id",
+            name: "Test API",
+            organization: "test-org-id",
+          },
+          blocks: [
+            {
+              name: "Large Block",
+              step: {
+                integration: "javascript",
+                javascript: {
+                  body: LARGE_JS_CONTENT,
+                },
+              },
+            },
+          ],
+          trigger: {},
+        },
+      };
+      const apiPromises: Promise<void>[] = [];
+
+      // Execute
+      const existingFilePaths = new Set<string>(); // empty since not overwriting existing files
+      const apiInfo = await writeAppApi(
+        api,
+        testDir,
+        existingFilePaths,
+        apiPromises,
+        EXTRACT_SOURCE_CODE,
+      );
+      await Promise.all(apiPromises);
+
+      // Verify the ApiInfo object is correct
+      expect(apiInfo.name).to.equal("Test API");
+      expect(apiInfo.sourceFiles).to.deep.equal(["large_block.js"]);
+
+      // Verify the files exist and match expectations
+      const apiDir = path.join(testDir, "apis");
+      (await expectFileExists(apiDir, "test_api/api.yaml")).and.contains(
+        "path: ./large_block.js",
+      );
+      (await expectFileExists(apiDir, "test_api/large_block.js")).and.includes(
+        LARGE_JS_CONTENT,
+      );
+
+      // And does not have a YAML file in the `apis` directory
+      await expectNoFileExists(apiDir, "test_api.yaml");
+
+      // and can be read back in
+      (await readApiFile(apiDir, api.apiPb.metadata.name)).to.deep.equal({
+        api: api.apiPb,
+        stepPathMap: {
+          "Large Block": "./large_block.js",
+        },
+      });
+    });
+
+    it("should write app api with similarly-named steps to separate directory and extract large code blocks to separate files", async function () {
+      const stepName1 = "Large Block";
+      const stepName2 = stepName1.toLocaleLowerCase();
+
+      // Setup
+      const api: ApiWrapper = {
+        apiPb: {
+          metadata: {
+            id: "test-id",
+            name: "Test API",
+            organization: "test-org-id",
+          },
+          blocks: [
+            {
+              name: stepName1,
+              step: {
+                integration: "javascript",
+                javascript: {
+                  body: LARGE_JS_CONTENT,
+                },
+              },
+            },
+            {
+              name: stepName2,
+              step: {
+                integration: "javascript",
+                javascript: {
+                  body: LARGER_JS_CONTENT,
+                },
+              },
+            },
+          ],
+          trigger: {},
+        },
+      };
+      const apiPromises: Promise<void>[] = [];
+
+      // Execute
+      const existingFilePaths = new Set<string>(); // empty since not overwriting existing files
+      const apiInfo = await writeAppApi(
+        api,
+        testDir,
+        existingFilePaths,
+        apiPromises,
+        EXTRACT_SOURCE_CODE,
+      );
+      await Promise.all(apiPromises);
+
+      // Verify the ApiInfo object is correct
+      expect(apiInfo.name).to.equal("Test API");
+      expect(apiInfo.sourceFiles).to.deep.equal([
+        "large_block.js",
+        "large_block_1.js",
+      ]);
+
+      // Verify the files exist and match expectations
+      const apiDir = path.join(testDir, "apis");
+      (await expectFileExists(apiDir, "test_api/api.yaml")).and.contains(
+        "path: ./large_block.js",
+      );
+      (await expectFileExists(apiDir, "test_api/large_block.js")).and.includes(
+        LARGE_JS_CONTENT,
+      );
+      (
+        await expectFileExists(apiDir, "test_api/large_block_1.js")
+      ).and.includes(LARGER_JS_CONTENT);
+
+      // And does not have a YAML file in the `apis` directory
+      await expectNoFileExists(apiDir, "test_api.yaml");
+
+      // and can be read back in
+      (await readApiFile(apiDir, api.apiPb.metadata.name)).to.deep.equal({
+        api: api.apiPb,
+        stepPathMap: {
+          "Large Block": "./large_block.js",
+          "large block": "./large_block_1.js",
+        },
+      });
+    });
+
+    it("should write app api to separate directory and extract small code blocks to separate files", async function () {
+      // Setup
+      const api: ApiWrapper = {
+        apiPb: {
+          metadata: {
+            id: "test-id",
+            name: "Test API",
+            organization: "test-org-id",
+          },
+          blocks: [
+            {
+              name: "Small Block",
+              step: {
+                integration: "javascript",
+                javascript: {
+                  body: SMALL_JS_CONTENT,
+                },
+              },
+            },
+          ],
+          trigger: {},
+        },
+      };
+      const apiPromises: Promise<void>[] = [];
+
+      // Execute
+      const existingFilePaths = new Set<string>(); // empty since not overwriting existing files
+      const apiInfo = await writeAppApi(
+        api,
+        testDir,
+        existingFilePaths,
+        apiPromises,
+        EXTRACT_SOURCE_CODE,
+      );
+      await Promise.all(apiPromises);
+
+      // Verify the ApiInfo object is correct
+      expect(apiInfo.name).to.equal("Test API");
+      expect(apiInfo.sourceFiles).to.deep.equal(["small_block.js"]);
+
+      // Verify the files exist and match expectations: one YAML file in directory nested under `apis`
+      const apisDir = path.join(testDir, "apis");
+      (await expectFileExists(apisDir, "test_api/api.yaml")).and.contains(
+        "path: ./small_block.js",
+      );
+      (await expectFileExists(apisDir, "test_api/small_block.js")).and.contains(
+        SMALL_JS_CONTENT,
+      );
+      // And no separate code file and no nested directory with the files
+      await expectNoFileExists(apisDir, "small_block.js");
+      await expectNoFileExists(apisDir, "test_api.yaml");
+      await expectNoFileExists(apisDir, "test_api/test_api.yaml");
+
+      // and can be read back in
+      (await readApiFile(apisDir, api.apiPb.metadata.name)).to.deep.equal({
+        api: api.apiPb,
+        stepPathMap: {
+          "Small Block": "./small_block.js",
+        },
+      });
+    });
+
+    it("should write app api to apis directory and not extract code blocks to separate files", async function () {
+      // Setup
+      const api: ApiWrapper = {
+        apiPb: {
+          metadata: {
+            id: "test-id",
+            name: "Test API",
+            organization: "test-org-id",
+          },
+          blocks: [
+            {
+              name: "Large Block",
+              step: {
+                integration: "javascript",
+                javascript: {
+                  body: LARGE_JS_CONTENT,
+                },
+              },
+            },
+          ],
+          trigger: {},
+        },
+      };
+      const apiPromises: Promise<void>[] = [];
+
+      // Execute
+      const existingFilePaths = new Set<string>(); // empty since not overwriting existing files
+      const apiInfo = await writeAppApi(
+        api,
+        testDir,
+        existingFilePaths,
+        apiPromises,
+        NO_EXTRACT_SOURCE_CODE,
+      );
+      await Promise.all(apiPromises);
+
+      // Verify the ApiInfo object is correct
+      expect(apiInfo.name).to.equal("Test API");
+      expect(apiInfo.sourceFiles).to.deep.equal([]);
+
+      // Compute the expected YAML file content
+      const expectedYamlContent = ymlstringify(api.apiPb, {
+        sortMapEntries: true,
+        blockQuote: "literal",
+      });
+
+      // Verify the files exist and match expectations
+      const apisDir = path.join(testDir, "apis");
+      (await expectFileExists(apisDir, "test_api.yaml")).and.equals(
+        expectedYamlContent,
+      );
+      await expectNoFileExists(apisDir, "large_block.js");
+      await expectNoFileExists(apisDir, "test_api/test_api.yaml");
+      await expectNoFileExists(apisDir, "test_api/large_block.js");
+
+      // and can be read back in
+      (await readApiFile(apisDir, api.apiPb.metadata.name)).to.deep.equal({
+        api: api.apiPb,
+        stepPathMap: {},
+      });
+    });
+
+    it("should write api with try-catch, conditional, loop, and parallel JavaScript steps", async function () {
+      const api: ApiWrapper = {
+        apiPb: {
+          metadata: {
+            id: "test-id",
+            name: "Try Catch API",
+            organization: "test-org-id",
+          },
+          blocks: [
+            {
+              name: "Try Catch Block",
+              tryCatch: {
+                catch: {
+                  blocks: [
+                    {
+                      name: "Catch Block",
+                      loop: {
+                        range: "{{[1,2,3]}}",
+                        type: LoopType.FOR_EACH,
+                        variables: {
+                          index: "indexVar",
+                          item: "itemVar",
+                        },
+                        blocks: [
+                          {
+                            name: "Loop Step",
+                            step: {
+                              integration: "javascript",
+                              javascript: {
+                                body: LARGER_JS_CONTENT,
+                              },
+                            },
+                          },
+                        ],
+                      },
+                    },
+                  ],
+                },
+                try: {
+                  blocks: [
+                    {
+                      name: "Conditional Block",
+                      conditional: {
+                        if: {
+                          condition: "{{2 > 1}}",
+                          blocks: [
+                            {
+                              name: "If Step",
+                              step: {
+                                integration: "javascript",
+                                javascript: {
+                                  body: LARGER_JS_CONTENT,
+                                },
+                              },
+                            },
+                          ],
+                        },
+                        elseIf: [
+                          {
+                            condition: "{{}}",
+                            blocks: [
+                              {
+                                name: "Else If Step",
+                                step: {
+                                  integration: "javascript",
+                                  javascript: {
+                                    body: LARGE_JS_CONTENT,
+                                  },
+                                },
+                              },
+                            ],
+                          },
+                        ],
+                        else: {
+                          blocks: [
+                            {
+                              name: "Else Step",
+                              step: {
+                                integration: "javascript",
+                                javascript: {
+                                  body: LARGE_JS_CONTENT,
+                                },
+                              },
+                            },
+                          ],
+                        },
+                      },
+                    },
+                  ],
+                },
+                variables: {
+                  indexVar: "indexVar",
+                  itemVar: "itemVar",
+                },
+              },
+            },
+            {
+              name: "Second Block",
+              step: {
+                integration: "javascript",
+                javascript: {
+                  body: LARGE_JS_CONTENT,
+                },
+              },
+            },
+            {
+              name: "Parallel Block",
+              parallel: {
+                static: {
+                  paths: {
+                    Path1: {
+                      blocks: [
+                        {
+                          name: "Path1 step",
+                          step: {
+                            integration: "javascript",
+                            javascript: {
+                              body: LARGE_JS_CONTENT,
+                            },
+                          },
+                        },
+                      ],
+                    },
+                    Path2: {
+                      blocks: [
+                        {
+                          name: "Path2 step",
+                          step: {
+                            integration: "javascript",
+                            javascript: {
+                              body: SMALL_JS_CONTENT,
+                            },
+                          },
+                        },
+                      ],
+                    },
+                  },
+                },
+              },
+            },
+          ],
+          trigger: {},
+        },
+      };
+      // Compute the expected YAML file content
+      const expectedYamlContent = ymlstringify(api.apiPb, {
+        sortMapEntries: true,
+        blockQuote: "literal",
+      });
+
+      // This test writes the API several times, so we need to keep track of the existing files
+      const existingFilePaths = new Set<string>();
+
+      {
+        // Write the API and extract code blocks
+        const apiPromises: Promise<void>[] = [];
+        const apiInfo = await writeAppApi(
+          api,
+          testDir,
+          existingFilePaths,
+          apiPromises,
+          EXTRACT_SOURCE_CODE,
+        );
+        await Promise.all(apiPromises);
+
+        // Verify the ApiInfo object is correct
+        expect(apiInfo.name).to.equal("Try Catch API");
+        expect(apiInfo.sourceFiles).to.deep.equal([
+          "else_if_step.js",
+          "else_step.js",
+          "if_step.js",
+          "loop_step.js",
+          "path1_step.js",
+          "path2_step.js",
+          "second_block.js",
+        ]);
+
+        // Verify the files exist and match expectations
+        const apiDir = path.join(testDir, "apis");
+        (await expectFileExists(apiDir, "try_catch_api/api.yaml")).and.contains(
+          "path: ./loop_step.js",
+        );
+        (
+          await expectFileExists(apiDir, "try_catch_api/loop_step.js")
+        ).and.includes(LARGER_JS_CONTENT);
+        (
+          await expectFileExists(apiDir, "try_catch_api/second_block.js")
+        ).and.includes(LARGE_JS_CONTENT);
+        (
+          await expectFileExists(apiDir, "try_catch_api/if_step.js")
+        ).and.includes(LARGER_JS_CONTENT);
+        (
+          await expectFileExists(apiDir, "try_catch_api/else_if_step.js")
+        ).and.includes(LARGE_JS_CONTENT);
+        (
+          await expectFileExists(apiDir, "try_catch_api/else_step.js")
+        ).and.includes(LARGE_JS_CONTENT);
+        (
+          await expectFileExists(apiDir, "try_catch_api/path1_step.js")
+        ).and.includes(LARGE_JS_CONTENT);
+        (
+          await expectFileExists(apiDir, "try_catch_api/path2_step.js")
+        ).and.includes(SMALL_JS_CONTENT);
+
+        // and can be read back in
+        (await readApiFile(apiDir, "Try Catch API")).to.deep.equal({
+          api: api.apiPb,
+          stepPathMap: {
+            "Else If Step": "./else_if_step.js",
+            "Else Step": "./else_step.js",
+            "If Step": "./if_step.js",
+            "Loop Step": "./loop_step.js",
+            "Path1 step": "./path1_step.js",
+            "Path2 step": "./path2_step.js",
+            "Second Block": "./second_block.js",
+          },
+        });
+
+        // Finally add the existing files to the set to be removed later
+        addExistingFilePathsForApi(apiInfo, apiDir, existingFilePaths, true);
+      }
+
+      {
+        // Write the API and do NOT extract code blocks
+        const apiPromises: Promise<void>[] = [];
+        const apiInfo = await writeAppApi(
+          api,
+          testDir,
+          existingFilePaths,
+          apiPromises,
+          NO_EXTRACT_SOURCE_CODE,
+        );
+        await Promise.all(apiPromises);
+        await removeExistingFiles(existingFilePaths);
+
+        // Verify the ApiInfo object is correct
+        expect(apiInfo.name).to.equal("Try Catch API");
+        expect(apiInfo.sourceFiles).to.deep.equal([]);
+
+        // Verify the files exist and match expectations
+        const apiDir = path.join(testDir, "apis");
+        (await expectFileExists(apiDir, "try_catch_api.yaml")).and.equals(
+          expectedYamlContent,
+        );
+
+        // And no code files are created in a nested directory
+        await expectNoFileExists(apiDir, "try_catch_api/api.yaml");
+        await expectNoFileExists(apiDir, "try_catch_api/try_catch_api.yaml");
+        await expectNoFileExists(apiDir, "try_catch_api/loop_step.js");
+        await expectNoFileExists(apiDir, "try_catch_api/second_block.js");
+        await expectNoFileExists(apiDir, "try_catch_api/if_step.js");
+        await expectNoFileExists(apiDir, "try_catch_api/else_if_step.js");
+        await expectNoFileExists(apiDir, "try_catch_api/else_step.js");
+        await expectNoFileExists(apiDir, "try_catch_api/path1_step.js");
+        await expectNoFileExists(apiDir, "try_catch_api/path2_step.js");
+        await expectNoFileExists(apiDir, "try_catch_api");
+
+        // and can be read back in
+        (await readApiFile(apiDir, "Try Catch API")).to.deep.equal({
+          api: api.apiPb,
+          stepPathMap: {},
+        });
+      }
+    });
+  });
+
+  describe("writeResourcesToDisk", function () {
+    const mockFeatureFlags = new FeatureFlags({
+      "superblocks.git.split.large.steps.enabled": true,
+      "superblocks.git.split.large.steps.new.enabled": true,
+      "superblocks.git.split.large.step.lines": 10,
+    });
+
+    it("should write single page app to separate directory and extract code blocks to separate files", async function () {
+      // Setup
+      const resourceId = "9736f700-88d6-49fc-a519-245a20af248b";
+      const testApi: ApiWithPb = {
+        id: "test-id",
+        apiPb: {
+          metadata: {
+            id: "test-id",
+            name: "Test API",
+            organization: "test-org-id",
+          },
+          blocks: [
+            {
+              name: "Large Block",
+              step: {
+                integration: "javascript",
+                javascript: {
+                  body: LARGE_JS_CONTENT,
+                },
+              },
+            },
+          ],
+          trigger: {},
+        },
+      };
+      const singlePageApp: ApplicationWrapper = {
+        application: {
+          id: resourceId,
+          name: "Test App",
+          metadata: {
+            fileVersion: "0.2.0", // this and the feature flag drive whether we split files or not
+          },
+        },
+        page: {
+          id: "test-page-id",
+          name: "Test Page",
+          apis: [],
+          applicationId: resourceId,
+          isHidden: false,
+          layouts: [],
+        },
+        apis: [testApi],
+      };
+      const apiPromises: Promise<void>[] = [];
+
+      // Execute
+      const resourceConfig = await writeResourceToDisk(
+        "APPLICATION",
+        resourceId,
+        singlePageApp,
+        testDir,
+        mockFeatureFlags,
+        undefined,
+        EXTRACT_SOURCE_CODE,
+      );
+      await Promise.all(apiPromises);
+
+      // Verify the superblocks.json file is correct for a SINGLE PAGE APP (no source files)
+      const config = (await expectSuperblocksJsonFileExists(
+        `${testDir}/apps/test_app`,
+      )) as SuperblocksApplicationConfig;
+      // Verify the apis is undefined for the new format
+      expect(config.apis).to.be.undefined;
+      // and the appApis is defined
+      expect(config.appApis?.[testApi.id].name).to.equal(
+        testApi.apiPb.metadata.name,
+      );
+
+      // Verify the files exist and match expectations
+      expect(resourceConfig.location).to.equal("apps/test_app");
+      await expectFileExists(testDir, "apps/test_app/application.yaml");
+      await expectFileExists(testDir, "apps/test_app/page.yaml");
+      (
+        await expectFileExists(testDir, "apps/test_app/apis/test_api/api.yaml")
+      ).and.contains("path: ./large_block.js");
+      (
+        await expectFileExists(
+          testDir,
+          "apps/test_app/apis/test_api/large_block.js",
+        )
+      ).and.includes(LARGE_JS_CONTENT);
+      // and can be read back in
+      (
+        await readApiFile(`${testDir}/apps/test_app/apis`, "Test API")
+      ).to.deep.equal({
+        api: testApi.apiPb,
+        stepPathMap: {
+          "Large Block": "./large_block.js",
+        },
+      });
+    });
+
+    it("should write backend to separate directory and extract code blocks to separate files", async function () {
+      // Setup
+      const resourceId = "9736f700-88d6-49fc-a519-245a20af248b";
+      const testApi: ApiWrapper = {
+        apiPb: {
+          metadata: {
+            id: "test-id",
+            name: "Test Backend",
+            organization: "test-org-id",
+          },
+          blocks: [
+            {
+              name: "Large Block",
+              step: {
+                integration: "javascript",
+                javascript: {
+                  body: LARGE_JS_CONTENT,
+                },
+              },
+            },
+          ],
+          trigger: {},
+        },
+      };
+      // Compute the expected YAML file content
+      const expectedYamlContent = ymlstringify(testApi.apiPb, {
+        sortMapEntries: true,
+        blockQuote: "literal",
+      });
+      // Write out the backend without extracting any code blocks
+      {
+        // Execute
+        const apiPromises: Promise<void>[] = [];
+        const resourceConfig = await writeResourceToDisk(
+          "BACKEND",
+          resourceId,
+          testApi,
+          testDir,
+          mockFeatureFlags,
+          undefined,
+          NO_EXTRACT_SOURCE_CODE,
+        );
+        await Promise.all(apiPromises);
+
+        // Verify the superblocks.json file is correct for a BACKEND that does not extract source files
+        const config = (await expectSuperblocksJsonFileExists(
+          `${testDir}/backends/test_backend`,
+        )) as SuperblocksBackendConfig;
+        expect(config.sourceFiles).to.be.undefined;
+
+        // Verify the files exist and match expectations
+        expect(resourceConfig.location).to.equal("backends/test_backend");
+        await expectFileExists(testDir, "backends/test_backend/api.yaml");
+        (
+          await expectFileExists(testDir, "backends/test_backend/api.yaml")
+        ).and.contains(expectedYamlContent);
+        await expectNoFileExists(
+          testDir,
+          "backends/test_backend/large_block.js",
+        );
+
+        // and can be read back in
+        (await readApiFile(`${testDir}/backends/test_backend`)).to.deep.equal({
+          api: testApi.apiPb,
+          stepPathMap: {},
+        });
+        // and a push operation would consider it valid
+        expect(await validateLocalResource(testDir, resourceConfig)).to.be
+          .undefined;
+      }
+      // Write out the backend AND extract any code blocks
+      {
+        // Execute
+        const apiPromises: Promise<void>[] = [];
+        const resourceConfig = await writeResourceToDisk(
+          "BACKEND",
+          resourceId,
+          testApi,
+          testDir,
+          mockFeatureFlags,
+          undefined,
+          EXTRACT_SOURCE_CODE,
+        );
+        await Promise.all(apiPromises);
+
+        // Verify the superblocks.json file is correct for a BACKEND that does extract source files
+        const config = (await expectSuperblocksJsonFileExists(
+          `${testDir}/backends/test_backend`,
+        )) as SuperblocksBackendConfig;
+        expect(config.sourceFiles).to.deep.equal(["large_block.js"]);
+
+        // Verify the files exist and match expectations
+        expect(resourceConfig.location).to.equal("backends/test_backend");
+        (
+          await expectFileExists(testDir, "backends/test_backend/api.yaml")
+        ).and.contains("path: ./large_block.js");
+        (
+          await expectFileExists(
+            testDir,
+            "backends/test_backend/large_block.js",
+          )
+        ).and.contains(LARGE_JS_CONTENT);
+        // and can be read back in
+        (await readApiFile(`${testDir}/backends/test_backend`)).to.deep.equal({
+          api: testApi.apiPb,
+          stepPathMap: {
+            "Large Block": "./large_block.js",
+          },
+        });
+        // and a push operation would consider it valid
+        expect(await validateLocalResource(testDir, resourceConfig)).to.be
+          .undefined;
+      }
+      // Write out the backend AGAIN without extracting any code blocks
+      {
+        // Execute
+        const apiPromises: Promise<void>[] = [];
+        const resourceConfig = await writeResourceToDisk(
+          "BACKEND",
+          resourceId,
+          testApi,
+          testDir,
+          mockFeatureFlags,
+          undefined,
+          NO_EXTRACT_SOURCE_CODE,
+        );
+        await Promise.all(apiPromises);
+
+        // Verify the superblocks.json file is correct for a BACKEND that does not extract source files
+        const config = (await expectSuperblocksJsonFileExists(
+          `${testDir}/backends/test_backend`,
+        )) as SuperblocksBackendConfig;
+        expect(config.sourceFiles).to.be.undefined;
+
+        // Verify the files exist and match expectations
+        expect(resourceConfig.location).to.equal("backends/test_backend");
+        await expectFileExists(testDir, "backends/test_backend/api.yaml");
+        (
+          await expectFileExists(testDir, "backends/test_backend/api.yaml")
+        ).and.contains(expectedYamlContent);
+        await expectNoFileExists(
+          testDir,
+          "backends/test_backend/large_block.js",
+        );
+        // and can be read back in
+        (await readApiFile(`${testDir}/backends/test_backend`)).to.deep.equal({
+          api: testApi.apiPb,
+          stepPathMap: {},
+        });
+        // and a push operation would consider it valid
+        expect(await validateLocalResource(testDir, resourceConfig)).to.be
+          .undefined;
+      }
+    });
+  });
+
+  describe("writeApplicationToDIsk", function () {
+    const mockFeatureFlags = new FeatureFlags({
+      "superblocks.git.split.large.steps.enabled": true,
+      "superblocks.git.split.large.steps.new.enabled": false,
+      "superblocks.git.split.large.step.lines": 10,
+    });
+
+    it("should write multi-pageapp to disk", async function () {
+      // Setup
+      const resourceId = "9736f700-88d6-49fc-a519-245a20af248b";
+      const testApi: ApiWithPb = {
+        id: "test-id",
+        apiPb: {
+          metadata: {
+            id: "test-id",
+            name: "Test API",
+            organization: "test-org-id",
+          },
+          blocks: [
+            {
+              name: "Large Block",
+              step: {
+                integration: "javascript",
+                javascript: {
+                  body: LARGE_JS_CONTENT,
+                },
+              },
+            },
+          ],
+          trigger: {},
+        },
+      };
+      const multiPageApp: MultiPageApplicationWrapperWithComponents = {
+        type: "multi-page",
+        application: {
+          id: resourceId,
+          name: "Test App",
+        },
+        pages: [
+          {
+            id: "test-page-id",
+            name: "Test Page",
+            apis: [testApi],
+            applicationId: resourceId,
+            isHidden: false,
+            layouts: [],
+          },
+        ],
+        apis: [],
+        componentFiles: [],
+      };
+      const apiPromises: Promise<void>[] = [];
+
+      // Execute
+      const resourceConfig = await writeApplicationToDisk({
+        sdk: {} as any,
+        resource: multiPageApp,
+        projectRootFolder: testDir,
+        featureFlags: mockFeatureFlags,
+        migrateFromSinglePage: false,
+        preferredApiRepresentation: EXTRACT_SOURCE_CODE,
+      });
+      await Promise.all(apiPromises);
+
+      // Verify the superblocks.json file is correct for a multipage app that does extract source files
+      const config = (await expectSuperblocksJsonFileExists(
+        `${testDir}/apps/test_app/`,
+      )) as SuperblocksApplicationConfig;
+      const page = config.pages?.[multiPageApp.pages[0].id];
+      expect(page?.apis).to.be.undefined;
+      expect(page?.pageApis?.[testApi.id]?.sourceFiles).to.deep.equal([
+        "large_block.js",
+      ]);
+
+      // Verify the files exist and match expectations
+      expect(resourceConfig.location).to.equal("apps/test_app");
+      await expectFileExists(testDir, "apps/test_app/application.yaml");
+      await expectFileExists(
+        testDir,
+        "apps/test_app/pages/test_page/page.yaml",
+      );
+      (
+        await expectFileExists(
+          testDir,
+          "apps/test_app/pages/test_page/apis/test_api/api.yaml",
+        )
+      ).and.includes("path: ./large_block.js");
+      (
+        await expectFileExists(
+          testDir,
+          "apps/test_app/pages/test_page/apis/test_api/large_block.js",
+        )
+      ).and.includes(LARGE_JS_CONTENT);
+
+      // and does not have the files in the old format
+      await expectNoFileExists(
+        testDir,
+        "apps/test_app/pages/test_page/apis/test_api.yaml",
+      );
+      await expectNoFileExists(
+        testDir,
+        "apps/test_app/pages/test_page/apis/test_api/test_api.yaml",
+      );
+
+      // and can be read back in
+      (
+        await readApiFile(
+          `${testDir}/apps/test_app/pages/test_page/apis`,
+          "Test API",
+        )
+      ).to.deep.equal({
+        api: testApi.apiPb,
+        stepPathMap: {
+          "Large Block": "./large_block.js",
+        },
+      });
+      // and a push operation would consider it valid
+      expect(await validateLocalResource(testDir, resourceConfig)).to.be
+        .undefined;
+    });
+
+    it("should write multi-pageapp to disk and overwrite existing files", async function () {
+      // Setup
+      const resourceId = "9736f700-88d6-49fc-a519-245a20af248b";
+      const testApi: ApiWithPb = {
+        id: "test-id",
+        apiPb: {
+          metadata: {
+            id: "test-id",
+            name: "Test API",
+            organization: "test-org-id",
+          },
+          blocks: [
+            {
+              name: "Large Block",
+              step: {
+                integration: "javascript",
+                javascript: {
+                  body: LARGE_JS_CONTENT,
+                },
+              },
+            },
+          ],
+          trigger: {},
+        },
+      };
+      const multiPageApp: MultiPageApplicationWrapperWithComponents = {
+        type: "multi-page",
+        application: {
+          id: resourceId,
+          name: "Test App",
+        },
+        pages: [
+          {
+            id: "test-page-id",
+            name: "Test Page",
+            apis: [testApi],
+            applicationId: resourceId,
+            isHidden: false,
+            layouts: [],
+          },
+        ],
+        apis: [],
+        componentFiles: [],
+      };
+      const apiPromises: Promise<void>[] = [];
+
+      // Write out the multi-page app without extracting any code blocks
+      {
+        const resourceConfig = await writeApplicationToDisk({
+          sdk: {} as any,
+          resource: multiPageApp,
+          projectRootFolder: testDir,
+          featureFlags: mockFeatureFlags,
+          migrateFromSinglePage: false,
+          preferredApiRepresentation: NO_EXTRACT_SOURCE_CODE,
+        });
+        await Promise.all(apiPromises);
+
+        // Compute the expected YAML file content with embedded source code
+        const expectedYamlContent = ymlstringify(testApi.apiPb, {
+          sortMapEntries: true,
+          blockQuote: "literal",
+        });
+
+        // Verify the superblocks.json file is correct for a multipage app that does NOT extract source files
+        const config = (await expectSuperblocksJsonFileExists(
+          `${testDir}/apps/test_app/`,
+        )) as SuperblocksApplicationConfig;
+        const page = config.pages?.[multiPageApp.pages[0].id];
+        expect(page?.pageApis).to.be.undefined;
+        expect(page?.apis).to.be.deep.equal({ "test-id": "Test API" });
+
+        // Verify the files exist and match expectations
+        expect(resourceConfig.location).to.equal("apps/test_app");
+        await expectFileExists(testDir, "apps/test_app/application.yaml");
+        await expectFileExists(
+          testDir,
+          "apps/test_app/pages/test_page/page.yaml",
+        );
+        (
+          await expectFileExists(
+            testDir,
+            "apps/test_app/pages/test_page/apis/test_api.yaml",
+          )
+        ).and.contains(expectedYamlContent);
+        // And does not have the source code extracted
+        await expectNoFileExists(
+          testDir,
+          "apps/test_app/pages/test_page/apis/test_api/large_block.js",
+        );
+        // and can be read back in
+        (
+          await readApiFile(
+            `${testDir}/apps/test_app/pages/test_page/apis`,
+            "Test API",
+          )
+        ).to.deep.equal({ api: testApi.apiPb, stepPathMap: {} });
+        // and a push operation would consider it valid
+        expect(await validateLocalResource(testDir, resourceConfig)).to.be
+          .undefined;
+      }
+
+      // Write out the same multi-page app again, but this time extract any code blocks
+      {
+        const resourceConfig = await writeApplicationToDisk({
+          sdk: {} as any,
+          resource: multiPageApp,
+          projectRootFolder: testDir,
+          featureFlags: mockFeatureFlags,
+          migrateFromSinglePage: false,
+          preferredApiRepresentation: EXTRACT_SOURCE_CODE,
+        });
+        await Promise.all(apiPromises);
+
+        // Verify the superblocks.json file is correct for a multipage app that does extract source files
+        const config = (await expectSuperblocksJsonFileExists(
+          `${testDir}/apps/test_app/`,
+        )) as SuperblocksApplicationConfig;
+        const page = config.pages?.[multiPageApp.pages[0].id];
+        expect(page?.apis).to.be.undefined;
+        expect(page?.pageApis?.[testApi.id]?.sourceFiles).to.deep.equal([
+          "large_block.js",
+        ]);
+
+        // Verify the files exist and match expectations
+        expect(resourceConfig.location).to.equal("apps/test_app");
+        await expectFileExists(testDir, "apps/test_app/application.yaml");
+        await expectFileExists(
+          testDir,
+          "apps/test_app/pages/test_page/page.yaml",
+        );
+        (
+          await expectFileExists(
+            testDir,
+            "apps/test_app/pages/test_page/apis/test_api/api.yaml",
+          )
+        ).and.contains("path: ./large_block.js");
+        (
+          await expectFileExists(
+            testDir,
+            "apps/test_app/pages/test_page/apis/test_api/large_block.js",
+          )
+        ).and.includes(LARGE_JS_CONTENT);
+        // And the old file no longer exists
+        await expectNoFileExists(
+          testDir,
+          "apps/test_app/pages/test_page/apis/test_api.yaml",
+        );
+        await expectNoFileExists(
+          testDir,
+          "apps/test_app/pages/test_page/apis/test_api/test_api.yaml",
+        );
+        // and can be read back in
+        (
+          await readApiFile(
+            `${testDir}/apps/test_app/pages/test_page/apis`,
+            "Test API",
+          )
+        ).to.deep.equal({
+          api: testApi.apiPb,
+          stepPathMap: {
+            "Large Block": "./large_block.js",
+          },
+        });
+        // and a push operation would consider it valid
+        expect(await validateLocalResource(testDir, resourceConfig)).to.be
+          .undefined;
+      }
+
+      // Write out the same multi-page app again, but this time with shorter code that should be extracted
+      {
+        // Change the JS code to be shorter
+        if (testApi.apiPb?.blocks?.[0]?.step?.javascript) {
+          testApi.apiPb.blocks[0].step.javascript.body = SMALL_JS_CONTENT;
+        }
+        const resourceConfig = await writeApplicationToDisk({
+          sdk: {} as any,
+          resource: multiPageApp,
+          projectRootFolder: testDir,
+          featureFlags: mockFeatureFlags,
+          migrateFromSinglePage: false,
+          preferredApiRepresentation: EXTRACT_SOURCE_CODE,
+        });
+        await Promise.all(apiPromises);
+
+        // Verify the superblocks.json file is correct for a multipage app that does extract source files
+        const config = (await expectSuperblocksJsonFileExists(
+          `${testDir}/apps/test_app/`,
+        )) as SuperblocksApplicationConfig;
+        const page = config.pages?.[multiPageApp.pages[0].id];
+        expect(page?.apis).to.be.undefined;
+        expect(page?.pageApis?.[testApi.id]?.sourceFiles).to.deep.equal([
+          "large_block.js",
+        ]);
+
+        // Verify the files exist and match expectations
+        expect(resourceConfig.location).to.equal("apps/test_app");
+        await expectFileExists(testDir, "apps/test_app/application.yaml");
+        await expectFileExists(
+          testDir,
+          "apps/test_app/pages/test_page/page.yaml",
+        );
+        (
+          await expectFileExists(
+            testDir,
+            "apps/test_app/pages/test_page/apis/test_api/api.yaml",
+          )
+        ).and.contains("path: ./large_block.js");
+        // And does have the source code extracted
+        (
+          await expectFileExists(
+            testDir,
+            "apps/test_app/pages/test_page/apis/test_api/large_block.js",
+          )
+        ).and.includes(SMALL_JS_CONTENT);
+        // And does not have the old file
+        await expectNoFileExists(
+          testDir,
+          "apps/test_app/pages/test_page/apis/test_api.yaml",
+        );
+        // and can be read back in
+        (
+          await readApiFile(
+            `${testDir}/apps/test_app/pages/test_page/apis`,
+            "Test API",
+          )
+        ).to.deep.equal({
+          api: testApi.apiPb,
+          stepPathMap: {
+            "Large Block": "./large_block.js",
+          },
+        });
+        // and a push operation would consider it valid
+        expect(await validateLocalResource(testDir, resourceConfig)).to.be
+          .undefined;
+      }
+
+      // Write out the same multi-page app again, again with large code so files are extracted
+      {
+        // Change the JS code to be shorter so no files are extracted
+        if (testApi.apiPb?.blocks?.[0]?.step?.javascript) {
+          testApi.apiPb.blocks[0].step.javascript.body = LARGE_JS_CONTENT;
+        }
+        const resourceConfig = await writeApplicationToDisk({
+          sdk: {} as any,
+          resource: multiPageApp,
+          projectRootFolder: testDir,
+          featureFlags: mockFeatureFlags,
+          migrateFromSinglePage: false,
+          preferredApiRepresentation: EXTRACT_SOURCE_CODE,
+        });
+        await Promise.all(apiPromises);
+
+        // Verify the superblocks.json file is correct for a multipage app that does extract source files
+        const config = (await expectSuperblocksJsonFileExists(
+          `${testDir}/apps/test_app/`,
+        )) as SuperblocksApplicationConfig;
+        const page = config.pages?.[multiPageApp.pages[0].id];
+        expect(page?.apis).to.be.undefined;
+        expect(page?.pageApis?.[testApi.id]?.sourceFiles).to.deep.equal([
+          "large_block.js",
+        ]);
+
+        // Verify the files exist and match expectations
+        expect(resourceConfig.location).to.equal("apps/test_app");
+        await expectFileExists(testDir, "apps/test_app/application.yaml");
+        await expectFileExists(
+          testDir,
+          "apps/test_app/pages/test_page/page.yaml",
+        );
+        (
+          await expectFileExists(
+            testDir,
+            "apps/test_app/pages/test_page/apis/test_api/api.yaml",
+          )
+        ).and.contains("path: ./large_block.js");
+        (
+          await expectFileExists(
+            testDir,
+            "apps/test_app/pages/test_page/apis/test_api/large_block.js",
+          )
+        ).and.includes(LARGE_JS_CONTENT);
+        // And the old file no longer exists
+        await expectNoFileExists(
+          testDir,
+          "apps/test_app/pages/test_page/apis/test_api.yaml",
+        );
+        // and the file with the wrong name does not exist
+        await expectNoFileExists(
+          testDir,
+          "apps/test_app/pages/test_page/apis/test_api/test_api.yaml",
+        );
+        // and can be read back in
+        (
+          await readApiFile(
+            `${testDir}/apps/test_app/pages/test_page/apis`,
+            "Test API",
+          )
+        ).to.deep.equal({
+          api: testApi.apiPb,
+          stepPathMap: {
+            "Large Block": "./large_block.js",
+          },
+        });
+        // and a push operation would consider it valid
+        expect(await validateLocalResource(testDir, resourceConfig)).to.be
+          .undefined;
+      }
+
+      // Write out the multi-page app again without extracting any code blocks
+      {
+        const resourceConfig = await writeApplicationToDisk({
+          sdk: {} as any,
+          resource: multiPageApp,
+          projectRootFolder: testDir,
+          featureFlags: mockFeatureFlags,
+          migrateFromSinglePage: false,
+          preferredApiRepresentation: NO_EXTRACT_SOURCE_CODE,
+        });
+        await Promise.all(apiPromises);
+
+        // Compute the expected YAML file content with embedded source code
+        const expectedYamlContent = ymlstringify(testApi.apiPb, {
+          sortMapEntries: true,
+          blockQuote: "literal",
+        });
+
+        // Verify the files exist and match expectations
+        expect(resourceConfig.location).to.equal("apps/test_app");
+        await expectFileExists(testDir, "apps/test_app/application.yaml");
+        await expectFileExists(
+          testDir,
+          "apps/test_app/pages/test_page/page.yaml",
+        );
+        (
+          await expectFileExists(
+            testDir,
+            "apps/test_app/pages/test_page/apis/test_api.yaml",
+          )
+        ).and.contains(expectedYamlContent);
+        // And does not have the source code extracted
+        await expectNoFileExists(
+          testDir,
+          "apps/test_app/pages/test_page/apis/test_api/large_block.js",
+        );
+        // and can be read back in
+        (
+          await readApiFile(
+            `${testDir}/apps/test_app/pages/test_page/apis`,
+            "Test API",
+          )
+        ).to.deep.equal({
+          api: testApi.apiPb,
+          stepPathMap: {},
+        });
+      }
+    });
+  });
+});
+
+async function expectFileExists(
+  testDir: string,
+  relativePath: string,
+): Promise<Chai.Assertion> {
+  const filePath = path.join(testDir, relativePath);
+  await expect(await fs.pathExists(filePath)).to.be.true;
+  const content = await fs.readFile(filePath, "utf8");
+  return expect(content);
+}
+
+async function expectNoFileExists(testDir: string, relativePath: string) {
+  const filePath = path.join(testDir, relativePath);
+  expect(await fs.pathExists(filePath)).to.be.false;
+}
+
+async function readApiFile(
+  testDir: string,
+  apiName?: string,
+): Promise<Chai.Assertion> {
+  const api = await readAppApiYamlFile(testDir, apiName);
+  return expect(api);
+}
+
+async function expectSuperblocksJsonFileExists(
+  testDir: string,
+): Promise<SuperblocksConfig> {
+  const filePath = path.join(testDir, ".superblocks/superblocks.json");
+  await expect(await fs.pathExists(filePath)).to.be.true;
+  const content = await fs.readFile(filePath, "utf8");
+  return JSON.parse(content) as SuperblocksConfig;
+}
+
+async function removeExistingFiles(existingFilePaths: Set<string>) {
+  for (const filePath of existingFilePaths) {
+    await fs.remove(filePath);
+  }
+}