fix: don't use temporary table name to create foreign key, unique, check constraint with SQLite

src/driver/sqlite-abstract/AbstractSqliteQueryRunner.ts

@@ -1690,7 +1690,11 @@ export abstract class AbstractSqliteQueryRunner
     /**
      * Builds create table sql.
      */
-    protected createTableSql(table: Table, createForeignKeys?: boolean): Query {
+    protected createTableSql(
+        table: Table,
+        createForeignKeys?: boolean,
+        temporaryTable?: boolean,
+    ): Query {
         const primaryColumns = table.columns.filter(
             (column) => column.isPrimary,
         )
@@ -1712,6 +1716,14 @@ export abstract class AbstractSqliteQueryRunner
             table.name,
         )} (${columnDefinitions}`
 
+        let [databaseNew, tableName] = this.splitTablePath(table.name)
+        const newTableName = temporaryTable
+            ? `${databaseNew ? `${databaseNew}.` : ""}${tableName.replace(
+                  /^temporary_/,
+                  "",
+              )}`
+            : table.name
+
         // need for `addColumn()` method, because it recreates table.
         table.columns
             .filter((column) => column.isUnique)
@@ -1739,7 +1751,7 @@ export abstract class AbstractSqliteQueryRunner
                     const uniqueName = unique.name
                         ? unique.name
                         : this.connection.namingStrategy.uniqueConstraintName(
-                              table,
+                              newTableName,
                               unique.columnNames,
                           )
                     const columnNames = unique.columnNames
@@ -1758,7 +1770,7 @@ export abstract class AbstractSqliteQueryRunner
                     const checkName = check.name
                         ? check.name
                         : this.connection.namingStrategy.checkConstraintName(
-                              table,
+                              newTableName,
                               check.expression!,
                           )
                     return `CONSTRAINT "${checkName}" CHECK (${check.expression})`
@@ -1788,7 +1800,7 @@ export abstract class AbstractSqliteQueryRunner
                         .join(", ")
                     if (!fk.name)
                         fk.name = this.connection.namingStrategy.foreignKeyName(
-                            table,
+                            newTableName,
                             fk.columnNames,
                             this.getTablePath(fk),
                             fk.referencedColumnNames,
@@ -1983,7 +1995,7 @@ export abstract class AbstractSqliteQueryRunner
         }temporary_${tableNameNew}`
 
         // create new table
-        upQueries.push(this.createTableSql(newTable, true))
+        upQueries.push(this.createTableSql(newTable, true, true))
         downQueries.push(this.dropTableSql(newTable))
 
         // migrate all data from the old table into new table

test/github-issues/9176/entity/Author.ts

@@ -0,0 +1,10 @@
+import { Column, Entity, PrimaryGeneratedColumn } from "../../../../src"
+
+@Entity()
+export class Author {
+    @PrimaryGeneratedColumn()
+    id: number
+
+    @Column()
+    name: string
+}

test/github-issues/9176/entity/Post.ts

@@ -0,0 +1,22 @@
+import {
+    Column,
+    Entity,
+    ManyToOne,
+    PrimaryGeneratedColumn,
+} from "../../../../src"
+import { Author } from "./Author"
+
+@Entity()
+export class Post {
+    @PrimaryGeneratedColumn()
+    id: number
+
+    @Column()
+    title: string
+
+    @Column()
+    text: string
+
+    @ManyToOne((type) => Author, { cascade: true, nullable: false })
+    author: Author
+}

test/github-issues/9176/entity/User.ts

@@ -0,0 +1,33 @@
+import {
+    Check,
+    Column,
+    Entity,
+    PrimaryGeneratedColumn,
+    Unique,
+} from "../../../../src"
+
+@Entity()
+@Unique(["firstName", "lastName", "middleName"])
+export class User {
+    @PrimaryGeneratedColumn()
+    id: number
+
+    @Column()
+    firstName: string
+
+    @Column()
+    lastName: string
+
+    @Column()
+    middleName: string
+}
+
+@Entity()
+@Check(`"age" > 18`)
+export class CheckedUser {
+    @PrimaryGeneratedColumn()
+    id: number
+
+    @Column()
+    age: number
+}

test/github-issues/9176/issue-9176.ts

@@ -0,0 +1,113 @@
+import "reflect-metadata"
+import {
+    createTestingConnections,
+    closeTestingConnections,
+} from "../../utils/test-utils"
+import { DataSource } from "../../../src/data-source/DataSource"
+import { Author } from "./entity/Author"
+import { Post } from "./entity/Post"
+import { CheckedUser, User } from "./entity/User"
+import { CreatePostTable1656926770819 } from "./migration/1656926770819-CreatePostTable"
+import { CreateAuthorTable1656939116999 } from "./migration/1656939116999-CreateAuthorTable"
+import { AddAuthorIdColumn1656939646470 } from "./migration/1656939646470-AddAuthorIdColumn"
+import { CreateUserTable1657066872930 } from "./migration/1657066872930-CreateUserTable"
+import { CreateUniqueConstraintToUser1657067039714 } from "./migration/1657067039714-CreateUniqueConstraintToUser"
+import { CreateCheckedUserTable1657067039715 } from "./migration/1657067039715-CreateCheckedUserTable"
+import { CreateCheckConstraintToUser1657067039716 } from "./migration/1657067039716-CreateCheckConstraintToUser"
+import { expect } from "chai"
+
+describe("github issues > #9176 The names of foreign keys created by queryRunner.createForeignKey and schema:sync are different with SQLite", () => {
+    describe("github issues > #9176 foreign keys", () => {
+        let dataSources: DataSource[]
+        before(
+            async () =>
+                (dataSources = await createTestingConnections({
+                    entities: [Author, Post],
+                    enabledDrivers: ["sqlite"],
+                    migrations: [
+                        CreatePostTable1656926770819,
+                        CreateAuthorTable1656939116999,
+                        AddAuthorIdColumn1656939646470,
+                    ],
+                    schemaCreate: false,
+                    dropSchema: true,
+                })),
+        )
+        after(() => closeTestingConnections(dataSources))
+
+        it("should not generate queries when created foreign key with queryRunnner.createForeignKey", () =>
+            Promise.all(
+                dataSources.map(async (dataSource) => {
+                    await dataSource.runMigrations()
+                    const sqlInMemory = await dataSource.driver
+                        .createSchemaBuilder()
+                        .log()
+
+                    expect(sqlInMemory.upQueries).to.empty
+                    expect(sqlInMemory.downQueries).to.empty
+                }),
+            ))
+    })
+
+    describe("github issues > #9176 unique constraint", () => {
+        let dataSources: DataSource[]
+        before(
+            async () =>
+                (dataSources = await createTestingConnections({
+                    entities: [User],
+                    enabledDrivers: ["sqlite"],
+                    migrations: [
+                        CreateUserTable1657066872930,
+                        CreateUniqueConstraintToUser1657067039714,
+                    ],
+                    schemaCreate: false,
+                    dropSchema: true,
+                })),
+        )
+        after(() => closeTestingConnections(dataSources))
+
+        it("should not generate queries when created unique constraint with queryRunnner.createUniqueConstraint", () =>
+            Promise.all(
+                dataSources.map(async (dataSource) => {
+                    await dataSource.runMigrations()
+                    const sqlInMemory = await dataSource.driver
+                        .createSchemaBuilder()
+                        .log()
+
+                    expect(sqlInMemory.upQueries).to.empty
+                    expect(sqlInMemory.downQueries).to.empty
+                }),
+            ))
+    })
+
+    describe("github issues > #9176 check constraint", () => {
+        let dataSources: DataSource[]
+        before(
+            async () =>
+                (dataSources = await createTestingConnections({
+                    entities: [CheckedUser],
+                    enabledDrivers: ["sqlite"],
+                    migrations: [
+                        CreateCheckedUserTable1657067039715,
+                        CreateCheckConstraintToUser1657067039716,
+                    ],
+                    schemaCreate: false,
+                    dropSchema: true,
+                })),
+        )
+        after(() => closeTestingConnections(dataSources))
+
+        it("should not generate queries when created check constraint with queryRunnner.createCheckConstraint", () =>
+            Promise.all(
+                dataSources.map(async (dataSource) => {
+                    await dataSource.runMigrations()
+                    const sqlInMemory = await dataSource.driver
+                        .createSchemaBuilder()
+                        .log()
+
+                    expect(sqlInMemory.upQueries).to.empty
+                    expect(sqlInMemory.downQueries).to.empty
+                }),
+            ))
+    })
+})

test/github-issues/9176/migration/1656926770819-CreatePostTable.ts

@@ -0,0 +1,35 @@
+import { MigrationInterface, QueryRunner, Table } from "../../../../src"
+
+export class CreatePostTable1656926770819 implements MigrationInterface {
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.createTable(
+            new Table({
+                name: "post",
+                columns: [
+                    {
+                        name: "id",
+                        type: "integer",
+                        isPrimary: true,
+                        isGenerated: true,
+                        generationStrategy: "increment",
+                    },
+                    {
+                        name: "title",
+                        type: "varchar",
+                    },
+                    {
+                        name: "text",
+                        type: "varchar",
+                    },
+                ],
+            }),
+            true,
+            true,
+            true,
+        )
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.dropTable("post")
+    }
+}

test/github-issues/9176/migration/1656939116999-CreateAuthorTable.ts

@@ -0,0 +1,31 @@
+import { MigrationInterface, QueryRunner, Table } from "../../../../src"
+
+export class CreateAuthorTable1656939116999 implements MigrationInterface {
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.createTable(
+            new Table({
+                name: "author",
+                columns: [
+                    {
+                        name: "id",
+                        type: "integer",
+                        isPrimary: true,
+                        isGenerated: true,
+                        generationStrategy: "increment",
+                    },
+                    {
+                        name: "name",
+                        type: "varchar",
+                    },
+                ],
+            }),
+            true,
+            true,
+            true,
+        )
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.dropTable("author")
+    }
+}

test/github-issues/9176/migration/1656939646470-AddAuthorIdColumn.ts

@@ -0,0 +1,38 @@
+import {
+    MigrationInterface,
+    QueryRunner,
+    TableColumn,
+    TableForeignKey,
+} from "../../../../src"
+
+export class AddAuthorIdColumn1656939646470 implements MigrationInterface {
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.addColumn(
+            "post",
+            new TableColumn({
+                name: "authorId",
+                type: "integer",
+            }),
+        )
+        await queryRunner.createForeignKey(
+            "post",
+            new TableForeignKey({
+                columnNames: ["authorId"],
+                referencedTableName: "author",
+                referencedColumnNames: ["id"],
+            }),
+        )
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.dropForeignKey(
+            "post",
+            new TableForeignKey({
+                columnNames: ["authorId"],
+                referencedTableName: "author",
+                referencedColumnNames: ["id"],
+            }),
+        )
+        await queryRunner.dropColumn("post", "authorId")
+    }
+}

test/github-issues/9176/migration/1657066872930-CreateUserTable.ts

@@ -0,0 +1,39 @@
+import { MigrationInterface, QueryRunner, Table } from "../../../../src"
+
+export class CreateUserTable1657066872930 implements MigrationInterface {
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.createTable(
+            new Table({
+                name: "user",
+                columns: [
+                    {
+                        name: "id",
+                        type: "integer",
+                        isPrimary: true,
+                        isGenerated: true,
+                        generationStrategy: "increment",
+                    },
+                    {
+                        name: "firstName",
+                        type: "varchar",
+                    },
+                    {
+                        name: "lastName",
+                        type: "varchar",
+                    },
+                    {
+                        name: "middleName",
+                        type: "varchar",
+                    },
+                ],
+            }),
+            true,
+            true,
+            true,
+        )
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.dropTable("user")
+    }
+}