使用级联插入时，TypeORM M2O O2M Relationship外键为空

Question

目前，我正在尝试使用没有类型记录的Many To One和One to Many关系来创建TypeORM。

我已经设置了以下实体：

./entity/proposal

module.exports = {
    name: "Proposal",
    columns: {
        id: {
            primary: true,
            type: "int",
            generated: true
        },
        name: {
            type: "varchar",
            length: 60
        },
        description: {
            type: "varchar",
            default: "",
            length: 150
        },
        createdAt: {
            createDate: true
        },
        updatedAt: {
            updateDate: true
        }
    },
    relations: {
        sections: {
            target: "Section",
            type: "one-to-many",
            treeParent: true,
            cascade: true,
            inverseSide: 'Proposal'
        }
    }
}

./entity/section

module.exports = {
    name: "Section",
    columns: {
        id: {
            primary: true,
            type: "int",
            generated: true
        },
        name: {
            type: "varchar",
            length: 60,
            default: "New Section"
        },
        order: {
            type: "int"
        }
    },
    relations: {
      proposal: {
          target: "Proposal",
          type: "many-to-one",
          joinColumn: true,
          nullable: false
      }
  }
}

在这里，我创建了两个函数，一个用于插入建议，另一个用于创建模拟数据，该函数使用级联特性插入行(如本例所示：https://github.com/typeorm/javascript-example)

./controller/createProposal.js

const getRepository = require('typeorm').getRepository

const createProposal = async proposal => {

    let proposalRepository = getRepository("Proposal");
    let result = await proposalRepository.save(proposal)
            .then( savedProposal  => {
                return savedProposal
            })
            .catch( err => {
                return {
                    message: "There was an issue saving the proposal",
                    err: err
                }
            });

    return result

}

module.exports = createProposal

./controller/mockData.js

const createProposal = require('../proposal/createProposal')

const insertMockData = async () => {

  let section1 = {
    name: "Letter",
    order: 1
  }

  let section2 = {
    name: "Cloud",
    order: 2
  }

  let proposal = {
    name: "Cloud Proposal",
    description: "Cloud Proposal",
    sections: [
      section1, section2
    ] 
  }

  let result = await createProposal(proposal)

}

module.exports = insertMockData

将insertMockData()函数与nullable: true一起使用将产生以下结果：

=== Proposal Table ===
id  name                 description
1   "Cloud Proposal"     "Cloud Proposal"

=== Section Table ===
id  name        order     proposalid
1   "Letter"    1         null
2   "Cloud"     2         null

我需要将proposalid放在节表中，这样我就可以在proposalRepository.findOneOrFail({ id , relations: ['sections'] })中找到它了。

我做错了什么？

Answer 1

尝试将eager: true添加到Section->proposal

relations: {
    proposal: {
        target: "Proposal",
        type: "many-to-one",
        joinColumn: true,
        nullable: false,
        eager: true // This line
    }
}

Answer 2

希望这对某人有用。最近，我在使用one-to-many和many-to-one的TypeORM和NodeJS (version 0.2.18)关系时遇到了同样的问题。

这是具有工作关系的工作实体：

const { EntitySchema } = require('typeorm')

const FirstEntity = require('../model/FirstEntity')

module.exports = new EntitySchema({
  name: 'FirstEntity',
  target: FirstEntity,
  columns: {
    id: {
      primary: true,
      type: 'bigint',
      generated: true,
    },
    createdAt: {
      type: 'timestamp with time zone',
      default: () => 'NOW()',
    },
    updatedAt: {
      type: 'timestamp with time zone',
      default: () => 'NOW()',
    },
    ...........
  },
  relations: {
    secondentities: {
      target: 'SecondEntity',
      type: 'one-to-many',
      cascade: true,
      inverseSide: 'firstEntity',
      eager: true,
      nullable: false,
    },
  },
})

const { EntitySchema } = require('typeorm')

const SecondEntity = require('../model/SecondEntity')

module.exports = new EntitySchema({
  name: 'SecondEntity',
  target: SecondEntity,
  columns: {
    id: {
      primary: true,
      type: 'bigint',
      generated: true,
    },
    createdAt: {
      type: 'timestamp with time zone',
      default: () => 'NOW()',
    },
    updatedAt: {
      type: 'timestamp with time zone',
      default: () => 'NOW()',
    },
    ...........
  },
  relations: {
    firstEntity: {
      target: 'FirstEntity',
      type: 'many-to-one',
      inverseSide: 'secondentities',
      nullable: false,
    },
  },
})

我的第一个问题是，.save() of firstEntity根本没有保存嵌套的secondentities。它由cascade属性求解。

在添加cascade之后，我的第二个问题是，保存到DB的secondentities中缺少保存的firstEntity id。通过添加inverseSide属性来解决这个问题。

请注意，nullable属性根本不起作用，因此在.save()之后，我必须手动保存保存的firstEntity并检查secondentities是否存在。