hunk.code_window:      */
       prefixTableName(prefix: string, tableName: string): string {
           return prefix + tableName;
       }
   }
hunk.labels: keep keep keep keep add keep
hunk.after_edit:     eagerJoinRelationAlias(alias: string, propertyPath: string): string {
           return alias + "_" + propertyPath.replace(".", "_");
       }
  
hunk.file_path: src/naming-strategy/DefaultNamingStrategy.ts
hunk.type: add
file: import "reflect-metadata";
  import {closeTestingConnections, createTestingConnections, reloadTestingDatabases} from "../../utils/test-utils";
  import {Connection} from "../../../src/connection/Connection";
  import {Foo} from "./entity/Foo";
  import {FooMetadata} from "./entity/FooMetadata";
  import {FooChildMetadata} from "./entity/FooChildMetadata";
  
  describe("github issues > #762 Nullable @Embedded inside @Embedded", () => {
  
      let connections: Connection[];
      before(async () => connections = await createTestingConnections({
          entities: [__dirname + "/entity/*{.js,.ts}"],
      }));
      beforeEach(() => reloadTestingDatabases(connections));
      after(() => closeTestingConnections(connections));
  
      it("should work perfectly with all data set", () => Promise.all(connections.map(async connection => {
  
          const foo = new Foo();
          foo.name = "Apple";
          foo.metadata = new FooMetadata();
          foo.metadata.bar = 1;
          foo.metadata.child = new FooChildMetadata();
          foo.metadata.child.something = 2;
          foo.metadata.child.somethingElse = 3;
          await connection.manager.save(foo);
  
          const loadedFoo = await connection.getRepository(Foo).findOne({ name: "Apple" });
          loadedFoo!.should.be.eql({
              id: 1,
              name: "Apple",
              metadata: {
                  bar: 1,
                  child: {
                      something: 2,
                      somethingElse: 3
                  }
              }
          });
      })));
  
      it("should work perfectly with some data not set", () => Promise.all(connections.map(async connection => {
  
          const foo = new Foo();
          foo.name = "Apple";
          foo.metadata = new FooMetadata();
          foo.metadata.bar = 1;
          foo.metadata.child = new FooChildMetadata();
          foo.metadata.child.somethingElse = 3;
          await connection.manager.save(foo);
  
          const loadedFoo = await connection.getRepository(Foo).findOne({ name: "Apple" });
          loadedFoo!.should.be.eql({
              id: 1,
              name: "Apple",
              metadata: {
                  bar: 1,
                  child: {
                      something: null,
                      somethingElse: 3
                  }
              }
          });
  
          const foo2 = new Foo();
          foo2.name = "Apple2";
          foo2.metadata = new FooMetadata();
          foo2.metadata.child = new FooChildMetadata();
          foo2.metadata.child.something = 2;
          await connection.manager.save(foo2);
  
          const loadedFoo2 = await connection.getRepository(Foo).findOne({ name: "Apple2" });
          loadedFoo2!.should.be.eql({
              id: 2,
              name: "Apple2",
              metadata: {
                  bar: null,
                  child: {
                      something: 2,
                      somethingElse: null
                  }
              }
          });
  
          const foo3 = new Foo();
          foo3.name = "Apple3";
          foo3.metadata = new FooMetadata();
          await connection.manager.save(foo3);
  
          const loadedFoo3 = await connection.getRepository(Foo).findOne({ name: "Apple3" });
          loadedFoo3!.should.be.eql({
              id: 3,
              name: "Apple3",
              metadata: {
                  bar: null,
                  child: {
                      something: null,
                      somethingElse: null
                  }
              }
          });
  
      })));
  
      it("should work perfectly without any data set", () => Promise.all(connections.map(async connection => {
          const foo = new Foo();
          foo.name = "Orange";
          await connection.manager.save(foo);
  
          const loadedFoo = await connection.getRepository(Foo).findOne({ name: "Orange" });
          loadedFoo!.should.be.eql({
              id: 1,
              name: "Orange",
              metadata: {
                  bar: null,
                  child: {
                      something: null,
                      somethingElse: null
                  }
              }
          });
  
      })));
  
  });
  