Embedded entities with entity schema

[javix]

Issue type:

[x] question
[ ] bug report
[ ] feature request
[ ] documentation issue

Database system/driver:

[ ] cordova
[ ] mongodb
[ ] mssql
[ ] mysql / mariadb
[ ] oracle
[x] postgres
[ ] sqlite
[ ] sqljs
[ ] react-native
[ ] expo

TypeORM version:

[ ] latest
[ ] @next
[x] 0.2.12 (or put your version here)

Steps to reproduce or a small repository showing the problem:

In the actual project I can not use decorators, therefore I describe the entities with entity schema.
Now, I wont use embedded entities., but it does not work.

export const userSchema: EntitySchema<User> = new EntitySchema<User>( {
    name: 'user',
    target: User,
    columns: {
        username: {
            type: 'varchar',
            length: 20,
            unique: true
        },
        password: {
            type: 'varchar',
            length: 20,
            transformer: new PasswordValueTransformer()
        },
        lastLogin: {
            type: 'timestamp with time zone',
            nullable: true,
            name: 'lastlogin'
        }
    }
} );

export const metadataSchema: EntitySchema<Metadata> = new EntitySchema<Metadata>( {
    name: 'metadata',
    target: Metadata,
    columns: {
        createdBy: {
            type: 'varchar'
        },
        createdAt: {
            type: 'timestamp with time zone',
            createDate: true
        },
        modifiedBy: {
            type: 'varchar'
        },
        modifiedAt: {
            type: 'timestamp with time zone',
            updateDate: true
        }
    }
} );

export const dbUserSchema: EntitySchema<DbUser> = new EntitySchema<DbUser>( {
    name: 'dbUser',
    target: DbUser,
    columns: {
        id: {
            type: Number,
            primary: true,
            generated: true
        },
        user: {
            type: User   <--- compile failed
        },
    },
    relations: {
        user: {
            type: User   <--- compile failed
        },
        metadata: {
            type: Metadata   <--- compile failed
        }
    }
} );

[adamsar]

I also have a case that I need help with here:

export const AddressSchema = new EntitySchema<Address>({
    name: "address",
    columns: {
        zipcode: {
            name: "zipcode",
            type: "text",
            nullable: false
        },

        prefecture: {
            name: "prefecture",
            type: "text",
            enum: Prefecture,
            nullable: false
        },

        city: {
            name: "city",
            type: "text",
            nullable: false
        },

        line1: [{
            name: "line1",
            type: string,
            nullable: false
        }]
    }
})

export const UserSchema = new EntitySchema<User>(

    {
        name: "user",
        columns: {

            id: {
                name: "user_id",
                type: "uuid",
                primary: true,
                generated: true
            },

            email: {
                type: "text",
                nullable: false
            },

            address: {
                name: "address",
                type: AddressSchema // This is what I need to figure out
            },

            name: {
                name: "name",
                type: string
            },

            ...timestampColumns,
            ...passwordColumn
        }
    }
)

[adamsar]

Ideally I want to hold all of this in the same table with address_zipcode... etc as the column names.

[MaciejSikorski]

What is the status of this?

[igoraguiar]

I'm switching from decorators to EntitySchema and this feature is essential for me.
I implemented it and sent a PR.

[mtalbert]

I would also really like this feature! Without it, I either have an ugly choice of flattening in my Domain Model or separating my Domain and Data models and adding an extra transformation between them.

[toneysix]

I would also really like this feature! Without it, I either have an ugly choice of flattening in my Domain Model or separating my Domain and Data models and adding an extra transformation between them.

TS is a pretty raw stack as of me, you should take a look at c#, it ain't suffering from such things (children's issues). as I said before, this feature ought to have kept up with decorators way, IMHO

P.S.: am gonna implement it