hunk.code_window:             await dataSource.queryResultCache.clear()
               console.log(chalk.green("Cache was successfully cleared"))
               await dataSource.destroy()
           } catch (err) {
               if (dataSource) await (dataSource as DataSource).destroy()
               PlatformTools.logCmdErr("Error during cache clear.", err)
  
hunk.labels: keep keep keep keep keep replace replace keep keep
hunk.file_path: src/commands/CacheClearCommand.ts
hunk.type: replace
file: import "reflect-metadata"
  import {
      closeTestingConnections,
      createTestingConnections,
      reloadTestingDatabases,
  } from "../../utils/test-utils"
  import { DataSource, EntityManager } from "../../../src"
  import { Parent } from "./entity/Parent"
  import { Child } from "./entity/Child"
  import { xfail } from "../../utils/xfail"
  import { expect } from "chai"
  
  describe("github issues > #3105 Error with cascading saves using EntityManager in a transaction", () => {
      let connections: DataSource[]
  
      before(
          async () =>
              (connections = await createTestingConnections({
                  entities: [__dirname + "/entity/*{.js,.ts}"],
                  enabledDrivers: ["postgres"],
              })),
      )
  
      beforeEach(() => reloadTestingDatabases(connections))
      after(() => closeTestingConnections(connections))
  
      xfail
          .unless(() => connections.length > 0)
          .it(
              "error with cascading saves using EntityManager in a transaction",
              () =>
                  Promise.all(
                      connections.map(async function (connection) {
                          let findChildOne
                          let findChildTwo
  
                          await expect(
                              connection.manager.transaction(
                                  async (
                                      transactionalEntityManager: EntityManager,
                                  ) => {
                                      const parent = new Parent()
                                      parent.children = [
                                          new Child(1),
                                          new Child(2),
                                      ]
  
                                      let newParent =
                                          await transactionalEntityManager.save(
                                              parent,
                                          )
  
                                      newParent.children = [
                                          new Child(4),
                                          new Child(5),
                                      ]
                                      newParent =
                                          await transactionalEntityManager.save(
                                              parent,
                                          )
  
                                      // Check that the correct children are persisted with the parent.
                                      findChildOne = newParent.children.find(
                                          (child) => {
                                              return child.data === 4
                                          },
                                      )
  
                                      findChildTwo = newParent.children.find(
                                          (child) => {
                                              return child.data === 5
                                          },
                                      )
                                  },
                              ),
                          ).not.to.be.rejected
  
                          expect(findChildOne).to.not.be.undefined
                          expect(findChildTwo).to.not.be.undefined
                      }),
                  ),
          )
  })
  