@simplysm/orm-common 13.0.75 → 13.0.77

package/tests/ddl/basic.spec.ts

@@ -122,65 +122,6 @@ describe("DDL - Table", () => {
     });
   });
 
-  describe("getTruncateQueryDef", () => {
-    const db = createTestDb();
-    const def = db.getTruncateQueryDef({ database: "TestDb", schema: "TestSchema", name: "User" });
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "truncate",
-        table: { database: "TestDb", schema: "TestSchema", name: "User" },
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.truncate[dialect]);
-    });
-  });
-
-  describe("getSwitchFkQueryDef - on", () => {
-    const db = createTestDb();
-    const def = db.getSwitchFkQueryDef(
-      { database: "TestDb", schema: "TestSchema", name: "User" },
-      "on",
-    );
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "switchFk",
-        table: { database: "TestDb", schema: "TestSchema", name: "User" },
-        switch: "on",
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.switchFkOn[dialect]);
-    });
-  });
-
-  describe("getSwitchFkQueryDef - off", () => {
-    const db = createTestDb();
-    const def = db.getSwitchFkQueryDef(
-      { database: "TestDb", schema: "TestSchema", name: "User" },
-      "off",
-    );
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "switchFk",
-        table: { database: "TestDb", schema: "TestSchema", name: "User" },
-        switch: "off",
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.switchFkOff[dialect]);
-    });
-  });
-
   describe("getDropTableQueryDef", () => {
     const db = createTestDb();
     const def = db.getDropTableQueryDef({ database: "TestDb", schema: "TestSchema", name: "User" });
@@ -279,35 +220,6 @@ describe("DDL - Column", () => {
     });
   });
 
-  describe("getAddColumnQueryDef - with autoIncrement", () => {
-    const db = createTestDb();
-    const column = Column.bigint().autoIncrement();
-    const def = db.getAddColumnQueryDef(
-      { database: "TestDb", schema: "TestSchema", name: "User" },
-      "seq",
-      column,
-    );
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addColumn",
-        table: { database: "TestDb", schema: "TestSchema", name: "User" },
-        column: {
-          name: "seq",
-          dataType: { type: "bigint" },
-          autoIncrement: true,
-          nullable: undefined,
-          default: undefined,
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.addColumnWithAutoIncrement[dialect]);
-    });
-  });
-
   describe("getDropColumnQueryDef", () => {
     const db = createTestDb();
     const def = db.getDropColumnQueryDef(
@@ -358,35 +270,6 @@ describe("DDL - Column", () => {
     });
   });
 
-  describe("getModifyColumnQueryDef - change TYPE + DEFAULT simultaneously", () => {
-    const db = createTestDb();
-    const column = Column.int().default(100);
-    const def = db.getModifyColumnQueryDef(
-      { database: "TestDb", schema: "TestSchema", name: "User" },
-      "score",
-      column,
-    );
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "modifyColumn",
-        table: { database: "TestDb", schema: "TestSchema", name: "User" },
-        column: {
-          name: "score",
-          dataType: { type: "int" },
-          autoIncrement: undefined,
-          nullable: undefined,
-          default: 100,
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.modifyColumnTypeAndDefault[dialect]);
-    });
-  });
-
   describe("getRenameColumnQueryDef", () => {
     const db = createTestDb();
     const def = db.getRenameColumnQueryDef(
@@ -412,32 +295,32 @@ describe("DDL - Column", () => {
 });
 
 describe("DDL - Primary Key", () => {
-  describe("getDropPkQueryDef", () => {
+  describe("getDropPrimaryKeyQueryDef", () => {
     const db = createTestDb();
-    const def = db.getDropPkQueryDef({ database: "TestDb", schema: "TestSchema", name: "User" });
+    const def = db.getDropPrimaryKeyQueryDef({ database: "TestDb", schema: "TestSchema", name: "User" });
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "dropPk",
+        type: "dropPrimaryKey",
         table: { database: "TestDb", schema: "TestSchema", name: "User" },
       });
     });
 
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.dropPk[dialect]);
+      expect(builder.build(def)).toMatchSql(expected.dropPrimaryKey[dialect]);
     });
   });
 
-  describe("getAddPkQueryDef", () => {
+  describe("getAddPrimaryKeyQueryDef", () => {
     const db = createTestDb();
-    const def = db.getAddPkQueryDef({ database: "TestDb", schema: "TestSchema", name: "User" }, [
+    const def = db.getAddPrimaryKeyQueryDef({ database: "TestDb", schema: "TestSchema", name: "User" }, [
       "id",
     ]);
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "addPk",
+        type: "addPrimaryKey",
         table: { database: "TestDb", schema: "TestSchema", name: "User" },
         columns: ["id"],
       });
@@ -445,41 +328,21 @@ describe("DDL - Primary Key", () => {
 
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.addPk[dialect]);
+      expect(builder.build(def)).toMatchSql(expected.addPrimaryKey[dialect]);
     });
   });
 
-  describe("getAddPkQueryDef - composite key", () => {
-    const db = createTestDb();
-    const def = db.getAddPkQueryDef(
-      { database: "TestDb", schema: "TestSchema", name: "UserRole" },
-      ["userId", "roleId"],
-    );
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addPk",
-        table: { database: "TestDb", schema: "TestSchema", name: "UserRole" },
-        columns: ["userId", "roleId"],
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.addPkComposite[dialect]);
-    });
-  });
 });
 
 describe("DDL - Foreign Key / Index", () => {
-  describe("getAddFkQueryDef", () => {
+  describe("getAddForeignKeyQueryDef", () => {
     const db = createTestDb();
     const userRelation = Post.meta.relations?.["user"];
     if (!(userRelation instanceof ForeignKeyBuilder)) {
       throw new Error("user relation not found");
     }
 
-    const def = db.getAddFkQueryDef(
+    const def = db.getAddForeignKeyQueryDef(
       { database: "TestDb", schema: "TestSchema", name: "Post" },
       "user",
       userRelation,
@@ -487,7 +350,7 @@ describe("DDL - Foreign Key / Index", () => {
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "addFk",
+        type: "addForeignKey",
         table: { database: "TestDb", schema: "TestSchema", name: "Post" },
         foreignKey: {
           name: "FK_Post_user",
@@ -500,20 +363,20 @@ describe("DDL - Foreign Key / Index", () => {
 
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.addFk[dialect]);
+      expect(builder.build(def)).toMatchSql(expected.addForeignKey[dialect]);
     });
   });
 
-  describe("getDropFkQueryDef", () => {
+  describe("getDropForeignKeyQueryDef", () => {
     const db = createTestDb();
-    const def = db.getDropFkQueryDef(
+    const def = db.getDropForeignKeyQueryDef(
       { database: "TestDb", schema: "TestSchema", name: "Post" },
       "user",
     );
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "dropFk",
+        type: "dropForeignKey",
         table: { database: "TestDb", schema: "TestSchema", name: "Post" },
         foreignKey: "FK_Post_user",
       });
@@ -521,22 +384,22 @@ describe("DDL - Foreign Key / Index", () => {
 
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.dropFk[dialect]);
+      expect(builder.build(def)).toMatchSql(expected.dropForeignKey[dialect]);
     });
   });
 
-  describe("getAddIdxQueryDef", () => {
+  describe("getAddIndexQueryDef", () => {
     const db = createTestDb();
     const indexBuilder = new IndexBuilder({ columns: ["email"] as string[], unique: true });
 
-    const def = db.getAddIdxQueryDef(
+    const def = db.getAddIndexQueryDef(
       { database: "TestDb", schema: "TestSchema", name: "User" },
       indexBuilder,
     );
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "addIdx",
+        type: "addIndex",
         table: { database: "TestDb", schema: "TestSchema", name: "User" },
         index: {
           name: "IDX_User_email",
@@ -548,19 +411,19 @@ describe("DDL - Foreign Key / Index", () => {
 
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.addIdx[dialect]);
+      expect(builder.build(def)).toMatchSql(expected.addIndex[dialect]);
     });
   });
 
-  describe("getDropIdxQueryDef", () => {
+  describe("getDropIndexQueryDef", () => {
     const db = createTestDb();
-    const def = db.getDropIdxQueryDef({ database: "TestDb", schema: "TestSchema", name: "User" }, [
+    const def = db.getDropIndexQueryDef({ database: "TestDb", schema: "TestSchema", name: "User" }, [
       "email",
     ]);
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "dropIdx",
+        type: "dropIndex",
         table: { database: "TestDb", schema: "TestSchema", name: "User" },
         index: "IDX_User_email",
       });
@@ -568,30 +431,10 @@ describe("DDL - Foreign Key / Index", () => {
 
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.dropIdx[dialect]);
+      expect(builder.build(def)).toMatchSql(expected.dropIndex[dialect]);
     });
   });
 
-  describe("getDropIdxQueryDef - composite", () => {
-    const db = createTestDb();
-    const def = db.getDropIdxQueryDef({ database: "TestDb", schema: "TestSchema", name: "User" }, [
-      "name",
-      "email",
-    ]);
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "dropIdx",
-        table: { database: "TestDb", schema: "TestSchema", name: "User" },
-        index: "IDX_User_name_email",
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.dropIdxComposite[dialect]);
-    });
-  });
 });
 
 describe("DDL - View", () => {

package/tests/ddl/column-builder.spec.ts

@@ -51,20 +51,6 @@ describe("DDL - Column Builder", () => {
       column,
     );
 
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addColumn",
-        table: { database: "TestDb", schema: "TestSchema", name: "User" },
-        column: {
-          name: "id",
-          dataType: { type: "bigint" },
-          autoIncrement: undefined,
-          nullable: undefined,
-          default: undefined,
-        },
-      });
-    });
-
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.bigintType[dialect]);
@@ -82,20 +68,6 @@ describe("DDL - Column Builder", () => {
       column,
     );
 
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addColumn",
-        table: { database: "TestDb", schema: "TestSchema", name: "Product" },
-        column: {
-          name: "weight",
-          dataType: { type: "float" },
-          autoIncrement: undefined,
-          nullable: undefined,
-          default: undefined,
-        },
-      });
-    });
-
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.floatType[dialect]);
@@ -113,20 +85,6 @@ describe("DDL - Column Builder", () => {
       column,
     );
 
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addColumn",
-        table: { database: "TestDb", schema: "TestSchema", name: "Product" },
-        column: {
-          name: "price",
-          dataType: { type: "double" },
-          autoIncrement: undefined,
-          nullable: undefined,
-          default: undefined,
-        },
-      });
-    });
-
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.doubleType[dialect]);
@@ -175,20 +133,6 @@ describe("DDL - Column Builder", () => {
       column,
     );
 
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addColumn",
-        table: { database: "TestDb", schema: "TestSchema", name: "User" },
-        column: {
-          name: "name",
-          dataType: { type: "varchar", length: 100 },
-          autoIncrement: undefined,
-          nullable: undefined,
-          default: undefined,
-        },
-      });
-    });
-
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.varcharType[dialect]);
@@ -237,20 +181,6 @@ describe("DDL - Column Builder", () => {
       column,
     );
 
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addColumn",
-        table: { database: "TestDb", schema: "TestSchema", name: "Post" },
-        column: {
-          name: "content",
-          dataType: { type: "text" },
-          autoIncrement: undefined,
-          nullable: undefined,
-          default: undefined,
-        },
-      });
-    });
-
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.textType[dialect]);
@@ -268,20 +198,6 @@ describe("DDL - Column Builder", () => {
       column,
     );
 
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addColumn",
-        table: { database: "TestDb", schema: "TestSchema", name: "File" },
-        column: {
-          name: "data",
-          dataType: { type: "binary" },
-          autoIncrement: undefined,
-          nullable: undefined,
-          default: undefined,
-        },
-      });
-    });
-
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.binaryType[dialect]);
@@ -299,20 +215,6 @@ describe("DDL - Column Builder", () => {
       column,
     );
 
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addColumn",
-        table: { database: "TestDb", schema: "TestSchema", name: "User" },
-        column: {
-          name: "isActive",
-          dataType: { type: "boolean" },
-          autoIncrement: undefined,
-          nullable: undefined,
-          default: undefined,
-        },
-      });
-    });
-
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.booleanType[dialect]);
@@ -330,20 +232,6 @@ describe("DDL - Column Builder", () => {
       column,
     );
 
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addColumn",
-        table: { database: "TestDb", schema: "TestSchema", name: "User" },
-        column: {
-          name: "createdAt",
-          dataType: { type: "datetime" },
-          autoIncrement: undefined,
-          nullable: undefined,
-          default: undefined,
-        },
-      });
-    });
-
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.datetimeType[dialect]);

package/tests/ddl/index-builder.spec.ts

@@ -12,14 +12,14 @@ describe("DDL - Index Builder", () => {
   describe("IndexBuilder - single column index", () => {
     const db = createTestDb();
     const indexBuilder = IndexFactory.index("email");
-    const def = db.getAddIdxQueryDef(
+    const def = db.getAddIndexQueryDef(
       { database: "TestDb", schema: "TestSchema", name: "User" },
       indexBuilder,
     );
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "addIdx",
+        type: "addIndex",
         table: { database: "TestDb", schema: "TestSchema", name: "User" },
         index: {
           name: "IDX_User_email",
@@ -38,14 +38,14 @@ describe("DDL - Index Builder", () => {
   describe("IndexBuilder - unique index", () => {
     const db = createTestDb();
     const indexBuilder = IndexFactory.index("email").unique();
-    const def = db.getAddIdxQueryDef(
+    const def = db.getAddIndexQueryDef(
       { database: "TestDb", schema: "TestSchema", name: "User" },
       indexBuilder,
     );
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "addIdx",
+        type: "addIndex",
         table: { database: "TestDb", schema: "TestSchema", name: "User" },
         index: {
           name: "IDX_User_email",
@@ -64,14 +64,14 @@ describe("DDL - Index Builder", () => {
   describe("IndexBuilder - composite index", () => {
     const db = createTestDb();
     const indexBuilder = IndexFactory.index("name", "email");
-    const def = db.getAddIdxQueryDef(
+    const def = db.getAddIndexQueryDef(
       { database: "TestDb", schema: "TestSchema", name: "User" },
       indexBuilder,
     );
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "addIdx",
+        type: "addIndex",
         table: { database: "TestDb", schema: "TestSchema", name: "User" },
         index: {
           name: "IDX_User_name_email",
@@ -93,14 +93,14 @@ describe("DDL - Index Builder", () => {
   describe("IndexBuilder - orderBy specified", () => {
     const db = createTestDb();
     const indexBuilder = IndexFactory.index("name", "email").orderBy("DESC", "ASC");
-    const def = db.getAddIdxQueryDef(
+    const def = db.getAddIndexQueryDef(
       { database: "TestDb", schema: "TestSchema", name: "User" },
       indexBuilder,
     );
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "addIdx",
+        type: "addIndex",
         table: { database: "TestDb", schema: "TestSchema", name: "User" },
         index: {
           name: "IDX_User_name_email",
@@ -122,14 +122,14 @@ describe("DDL - Index Builder", () => {
   describe("IndexBuilder - name specified", () => {
     const db = createTestDb();
     const indexBuilder = IndexFactory.index("email").name("UQ_User_email");
-    const def = db.getAddIdxQueryDef(
+    const def = db.getAddIndexQueryDef(
       { database: "TestDb", schema: "TestSchema", name: "User" },
       indexBuilder,
     );
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "addIdx",
+        type: "addIndex",
         table: { database: "TestDb", schema: "TestSchema", name: "User" },
         index: {
           name: "UQ_User_email",
@@ -145,58 +145,4 @@ describe("DDL - Index Builder", () => {
     });
   });
 
-  describe("IndexBuilder - description specified", () => {
-    const db = createTestDb();
-    const indexBuilder = IndexFactory.index("email").description("이메일 검색용 인덱스");
-    const def = db.getAddIdxQueryDef(
-      { database: "TestDb", schema: "TestSchema", name: "User" },
-      indexBuilder,
-    );
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addIdx",
-        table: { database: "TestDb", schema: "TestSchema", name: "User" },
-        index: {
-          name: "IDX_User_email",
-          columns: [{ name: "email", orderBy: "ASC" }],
-          unique: undefined,
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.singleColumnIndex[dialect]);
-    });
-  });
-
-  describe("IndexBuilder - combined options (unique + orderBy)", () => {
-    const db = createTestDb();
-    const indexBuilder = IndexFactory.index("name", "email").unique().orderBy("DESC", "ASC");
-    const def = db.getAddIdxQueryDef(
-      { database: "TestDb", schema: "TestSchema", name: "User" },
-      indexBuilder,
-    );
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addIdx",
-        table: { database: "TestDb", schema: "TestSchema", name: "User" },
-        index: {
-          name: "IDX_User_name_email",
-          columns: [
-            { name: "name", orderBy: "DESC" },
-            { name: "email", orderBy: "ASC" },
-          ],
-          unique: true,
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.uniqueOrderByIndex[dialect]);
-    });
-  });
 });