@simplysm/orm-common 13.0.75 → 13.0.77

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

@@ -23,54 +23,6 @@ describe("DDL - Procedure Builder", () => {
     });
   });
 
-  describe("description specified", () => {
-    const proc = Procedure("TestProc").description("Test procedure");
-
-    it("should validate metadata", () => {
-      expect(proc.meta).toEqual({
-        name: "TestProc",
-        description: "Test procedure",
-        database: undefined,
-        schema: undefined,
-        params: undefined,
-        returns: undefined,
-        query: undefined,
-      });
-    });
-  });
-
-  describe("database specified", () => {
-    const proc = Procedure("TestProc").database("CustomDb");
-
-    it("should validate metadata", () => {
-      expect(proc.meta).toEqual({
-        name: "TestProc",
-        description: undefined,
-        database: "CustomDb",
-        schema: undefined,
-        params: undefined,
-        returns: undefined,
-        query: undefined,
-      });
-    });
-  });
-
-  describe("schema specified", () => {
-    const proc = Procedure("TestProc").schema("CustomSchema");
-
-    it("should validate metadata", () => {
-      expect(proc.meta).toEqual({
-        name: "TestProc",
-        description: undefined,
-        database: undefined,
-        schema: "CustomSchema",
-        params: undefined,
-        returns: undefined,
-        query: undefined,
-      });
-    });
-  });
-
   describe("params specified (single parameter)", () => {
     const proc = Procedure("TestProc").params((c) => ({ id: c.bigint() }));
 
@@ -82,23 +34,6 @@ describe("DDL - Procedure Builder", () => {
     });
   });
 
-  describe("params specified (multiple parameters)", () => {
-    const proc = Procedure("TestProc").params((c) => ({
-      id: c.bigint(),
-      name: c.varchar(100),
-      isActive: c.boolean(),
-    }));
-
-    it("should validate metadata", () => {
-      expect(proc.meta.name).toBe("TestProc");
-      expect(proc.meta.params).toBeDefined();
-      expect(Object.keys(proc.meta.params!)).toEqual(["id", "name", "isActive"]);
-      expect(proc.meta.params!.id.meta.dataType).toEqual({ type: "bigint" });
-      expect(proc.meta.params!.name.meta.dataType).toEqual({ type: "varchar", length: 100 });
-      expect(proc.meta.params!.isActive.meta.dataType).toEqual({ type: "boolean" });
-    });
-  });
-
   describe("returns specified (single return)", () => {
     const proc = Procedure("TestProc").returns((c) => ({ id: c.bigint() }));
 
@@ -110,24 +45,6 @@ describe("DDL - Procedure Builder", () => {
     });
   });
 
-  describe("returns specified (multiple returns)", () => {
-    const proc = Procedure("TestProc").returns((c) => ({
-      id: c.bigint(),
-      name: c.varchar(100),
-      email: c.varchar(200).nullable(),
-    }));
-
-    it("should validate metadata", () => {
-      expect(proc.meta.name).toBe("TestProc");
-      expect(proc.meta.returns).toBeDefined();
-      expect(Object.keys(proc.meta.returns!)).toEqual(["id", "name", "email"]);
-      expect(proc.meta.returns!.id.meta.dataType).toEqual({ type: "bigint" });
-      expect(proc.meta.returns!.name.meta.dataType).toEqual({ type: "varchar", length: 100 });
-      expect(proc.meta.returns!.email.meta.dataType).toEqual({ type: "varchar", length: 200 });
-      expect(proc.meta.returns!.email.meta.nullable).toBe(true);
-    });
-  });
-
   describe("body specified + basic DDL generation", () => {
     const proc = Procedure("TestProc")
       .database("TestDb")
@@ -208,27 +125,4 @@ describe("DDL - Procedure Builder", () => {
     });
   });
 
-  describe("method chaining order", () => {
-    // Same result even with different method chaining order
-    const proc1 = Procedure("TestProc")
-      .params((c) => ({ id: c.bigint() }))
-      .database("TestDb")
-      .schema("TestSchema")
-      .body("SELECT 1");
-
-    const proc2 = Procedure("TestProc")
-      .database("TestDb")
-      .schema("TestSchema")
-      .params((c) => ({ id: c.bigint() }))
-      .body("SELECT 1");
-
-    it("should validate metadata consistency", () => {
-      // params is an object so deep comparison is needed
-      expect(proc1.meta.name).toBe(proc2.meta.name);
-      expect(proc1.meta.database).toBe(proc2.meta.database);
-      expect(proc1.meta.schema).toBe(proc2.meta.schema);
-      expect(proc1.meta.query).toBe(proc2.meta.query);
-      expect(Object.keys(proc1.meta.params!)).toEqual(Object.keys(proc2.meta.params!));
-    });
-  });
 });

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

@@ -36,7 +36,7 @@ describe("DDL - Relation Builder", () => {
     const fkBuilder = RelationFactory.foreignKey(["userId"], () => User);
 
     const db = createTestDb();
-    const def = db.getAddFkQueryDef(
+    const def = db.getAddForeignKeyQueryDef(
       { database: "TestDb", schema: "TestSchema", name: "Post" },
       "user",
       fkBuilder,
@@ -44,47 +44,7 @@ describe("DDL - Relation Builder", () => {
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "addFk",
-        table: { database: "TestDb", schema: "TestSchema", name: "Post" },
-        foreignKey: {
-          name: "FK_Post_user",
-          fkColumns: ["userId"],
-          targetTable: { database: "TestDb", schema: "TestSchema", name: "User" },
-          targetPkColumns: ["id"],
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.basicForeignKey[dialect]);
-    });
-  });
-
-  describe("ForeignKeyBuilder - description specified", () => {
-    const Post = Table("Post")
-      .database("TestDb")
-      .schema("TestSchema")
-      .columns((c) => ({
-        id: c.bigint(),
-        userId: c.bigint(),
-      }))
-      .primaryKey("id")
-      .relations(() => ({}));
-
-    const RelationFactory = createRelationFactory(() => Post);
-    const fkBuilder = RelationFactory.foreignKey(["userId"], () => User).description("User relationship");
-
-    const db = createTestDb();
-    const def = db.getAddFkQueryDef(
-      { database: "TestDb", schema: "TestSchema", name: "Post" },
-      "user",
-      fkBuilder,
-    );
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addFk",
+        type: "addForeignKey",
         table: { database: "TestDb", schema: "TestSchema", name: "Post" },
         foreignKey: {
           name: "FK_Post_user",
@@ -128,7 +88,7 @@ describe("DDL - Relation Builder", () => {
     const fkBuilder = RelationFactory.foreignKey(["companyId", "companyRegionId"], () => Company);
 
     const db = createTestDb();
-    const def = db.getAddFkQueryDef(
+    const def = db.getAddForeignKeyQueryDef(
       { database: "TestDb", schema: "TestSchema", name: "Employee" },
       "company",
       fkBuilder,
@@ -136,7 +96,7 @@ describe("DDL - Relation Builder", () => {
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "addFk",
+        type: "addForeignKey",
         table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
         foreignKey: {
           name: "FK_Employee_company",
@@ -207,166 +167,5 @@ describe("DDL - Relation Builder", () => {
     });
   });
 
-  describe("ForeignKeyTargetBuilder - description specified", () => {
-    const Post = Table("Post")
-      .database("TestDb")
-      .schema("TestSchema")
-      .columns((c) => ({
-        id: c.bigint(),
-        userId: c.bigint(),
-      }))
-      .primaryKey("id")
-      .relations(() => ({}));
-
-    const RelationFactory = createRelationFactory(() => User);
-    const targetBuilder = RelationFactory.foreignKeyTarget(() => Post, "posts").description(
-      "List of posts by user",
-    );
-
-    it("should validate metadata", () => {
-      expect(targetBuilder.meta).toEqual({
-        targetTableFn: expect.any(Function),
-        relationName: "posts",
-        description: "List of posts by user",
-        isSingle: undefined,
-      });
-    });
-  });
-
-  //#endregion
-
-  //#region ========== RelationKeyBuilder ==========
-
-  describe("RelationKeyBuilder - basic", () => {
-    const Post = Table("Post")
-      .database("TestDb")
-      .schema("TestSchema")
-      .columns((c) => ({
-        id: c.bigint(),
-        authorId: c.bigint(),
-      }))
-      .primaryKey("id")
-      .relations(() => ({}));
-
-    const RelationFactory = createRelationFactory(() => Post);
-    const rkBuilder = RelationFactory.relationKey(["authorId"], () => User);
-
-    // RelationKey does not register FK in DB so getAddFkQueryDef test is not possible
-    // Only metadata validation
-    it("should validate metadata", () => {
-      expect(rkBuilder.meta).toEqual({
-        ownerFn: expect.any(Function),
-        columns: ["authorId"],
-        targetFn: expect.any(Function),
-        description: undefined,
-      });
-    });
-  });
-
-  describe("RelationKeyBuilder - description specified", () => {
-    const Post = Table("Post")
-      .database("TestDb")
-      .schema("TestSchema")
-      .columns((c) => ({
-        id: c.bigint(),
-        authorId: c.bigint(),
-      }))
-      .primaryKey("id")
-      .relations(() => ({}));
-
-    const RelationFactory = createRelationFactory(() => Post);
-    const rkBuilder = RelationFactory.relationKey(["authorId"], () => User).description(
-      "Author relationship (logical)",
-    );
-
-    it("should validate metadata", () => {
-      expect(rkBuilder.meta).toEqual({
-        ownerFn: expect.any(Function),
-        columns: ["authorId"],
-        targetFn: expect.any(Function),
-        description: "Author relationship (logical)",
-      });
-    });
-  });
-
-  //#endregion
-
-  //#region ========== RelationKeyTargetBuilder ==========
-
-  describe("RelationKeyTargetBuilder - basic (array)", () => {
-    const Post = Table("Post")
-      .database("TestDb")
-      .schema("TestSchema")
-      .columns((c) => ({
-        id: c.bigint(),
-        authorId: c.bigint(),
-      }))
-      .primaryKey("id")
-      .relations(() => ({}));
-
-    const RelationFactory = createRelationFactory(() => User);
-    const targetBuilder = RelationFactory.relationKeyTarget(() => Post, "authoredPosts");
-
-    it("should validate metadata", () => {
-      expect(targetBuilder.meta).toEqual({
-        targetTableFn: expect.any(Function),
-        relationName: "authoredPosts",
-        description: undefined,
-        isSingle: undefined,
-      });
-    });
-  });
-
-  describe("RelationKeyTargetBuilder - single() method", () => {
-    const Post = Table("Post")
-      .database("TestDb")
-      .schema("TestSchema")
-      .columns((c) => ({
-        id: c.bigint(),
-        authorId: c.bigint(),
-      }))
-      .primaryKey("id")
-      .relations(() => ({}));
-
-    const RelationFactory = createRelationFactory(() => User);
-    const targetBuilder = RelationFactory.relationKeyTarget(() => Post, "featuredPost").single();
-
-    it("should validate metadata", () => {
-      expect(targetBuilder.meta).toEqual({
-        targetTableFn: expect.any(Function),
-        relationName: "featuredPost",
-        description: undefined,
-        isSingle: true,
-      });
-    });
-  });
-
-  describe("RelationKeyTargetBuilder - description specified", () => {
-    const Post = Table("Post")
-      .database("TestDb")
-      .schema("TestSchema")
-      .columns((c) => ({
-        id: c.bigint(),
-        authorId: c.bigint(),
-      }))
-      .primaryKey("id")
-      .relations(() => ({}));
-
-    const RelationFactory = createRelationFactory(() => User);
-    const targetBuilder = RelationFactory.relationKeyTarget(
-      () => Post,
-      "authoredPosts",
-    ).description("List of authored posts (logical)");
-
-    it("should validate metadata", () => {
-      expect(targetBuilder.meta).toEqual({
-        targetTableFn: expect.any(Function),
-        relationName: "authoredPosts",
-        description: "List of authored posts (logical)",
-        isSingle: undefined,
-      });
-    });
-  });
-
   //#endregion
 });

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

@@ -24,23 +24,6 @@ describe("DDL - Table Builder", () => {
     });
   });
 
-  describe("description specified", () => {
-    const table = Table("User").description("User table");
-
-    it("should validate metadata", () => {
-      expect(table.meta).toEqual({
-        name: "User",
-        description: "User table",
-        database: undefined,
-        schema: undefined,
-        columns: undefined,
-        primaryKey: undefined,
-        relations: undefined,
-        indexes: undefined,
-      });
-    });
-  });
-
   describe("database specified", () => {
     const table = Table("User").database("CustomDb");
 
@@ -58,23 +41,6 @@ describe("DDL - Table Builder", () => {
     });
   });
 
-  describe("schema specified", () => {
-    const table = Table("User").schema("CustomSchema");
-
-    it("should validate metadata", () => {
-      expect(table.meta).toEqual({
-        name: "User",
-        description: undefined,
-        database: undefined,
-        schema: "CustomSchema",
-        columns: undefined,
-        primaryKey: undefined,
-        relations: undefined,
-        indexes: undefined,
-      });
-    });
-  });
-
   describe("columns specified (single column)", () => {
     const table = Table("User").columns((c) => ({ id: c.bigint() }));
 

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

@@ -7,66 +7,6 @@ import "../setup/test-utils"; // toMatchSql matcher
 import * as expected from "./view-builder.expected";
 
 describe("DDL - View Builder", () => {
-  describe("basic view (name only)", () => {
-    const view = View("TestView");
-
-    it("should validate metadata", () => {
-      expect(view.meta).toEqual({
-        name: "TestView",
-        description: undefined,
-        database: undefined,
-        schema: undefined,
-        viewFn: undefined,
-        relations: undefined,
-      });
-    });
-  });
-
-  describe("description specified", () => {
-    const view = View("TestView").description("This is a test view");
-
-    it("should validate metadata", () => {
-      expect(view.meta).toEqual({
-        name: "TestView",
-        description: "This is a test view",
-        database: undefined,
-        schema: undefined,
-        viewFn: undefined,
-        relations: undefined,
-      });
-    });
-  });
-
-  describe("database specified", () => {
-    const view = View("TestView").database("CustomDb");
-
-    it("should validate metadata", () => {
-      expect(view.meta).toEqual({
-        name: "TestView",
-        description: undefined,
-        database: "CustomDb",
-        schema: undefined,
-        viewFn: undefined,
-        relations: undefined,
-      });
-    });
-  });
-
-  describe("schema specified", () => {
-    const view = View("TestView").schema("CustomSchema");
-
-    it("should validate metadata", () => {
-      expect(view.meta).toEqual({
-        name: "TestView",
-        description: undefined,
-        database: undefined,
-        schema: "CustomSchema",
-        viewFn: undefined,
-        relations: undefined,
-      });
-    });
-  });
-
   describe("query specified (basic SELECT)", () => {
     const view = View("TestView").query((db: TestDbContext) =>
       db.user().select((u) => ({

package/tests/dml/delete.spec.ts

@@ -60,39 +60,6 @@ describe("DELETE - Basic", () => {
     });
   });
 
-  describe("DELETE with multiple conditions", () => {
-    const db = createTestDb();
-
-    const def = db
-      .employee()
-      .where((e) => [expr.eq(e.departmentId, 1), expr.null(e.managerId)])
-      .getDeleteQueryDef();
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "delete",
-        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-        as: "T1",
-        where: [
-          {
-            type: "eq",
-            source: { type: "column", path: ["T1", "departmentId"] },
-            target: { type: "value", value: 1 },
-          },
-          {
-            type: "null",
-            arg: { type: "column", path: ["T1", "managerId"] },
-          },
-        ],
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.deleteMultiCond[dialect]);
-    });
-  });
-
   describe("output column specified", () => {
     const db = createTestDb();
 

package/tests/dml/insert.spec.ts

@@ -161,44 +161,6 @@ describe("INSERT IF NOT EXISTS", () => {
     });
   });
 
-  describe("Check duplicates with complex conditions", () => {
-    const db = createTestDb();
-    const def = db
-      .employee()
-      .where((e) => [expr.eq(e.name, "Gildong Hong"), expr.eq(e.departmentId, 1)])
-      .getInsertIfNotExistsQueryDef({ name: "Gildong Hong", departmentId: 1 });
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "insertIfNotExists",
-        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-        record: { name: "Gildong Hong", departmentId: 1 },
-        existsSelectQuery: {
-          type: "select",
-          as: "T1",
-          from: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-          where: [
-            {
-              type: "eq",
-              source: { type: "column", path: ["T1", "name"] },
-              target: { type: "value", value: "Gildong Hong" },
-            },
-            {
-              type: "eq",
-              source: { type: "column", path: ["T1", "departmentId"] },
-              target: { type: "value", value: 1 },
-            },
-          ],
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.insertIfNotExistsMultiple[dialect]);
-    });
-  });
-
   //#endregion
 });
 
@@ -244,45 +206,5 @@ describe("INSERT INTO ... SELECT", () => {
     });
   });
 
-  describe("INSERT INTO SELECT with WHERE condition", () => {
-    const db = createTestDb();
-    const def = db
-      .employee()
-      .where((e) => [expr.eq(e.departmentId, 1)])
-      .select((e) => ({
-        id: e.id,
-        name: e.name,
-      }))
-      .getInsertIntoQueryDef(EmployeeBackup);
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "insertInto",
-        table: { database: "TestDb", schema: "TestSchema", name: "EmployeeBackup" },
-        recordsSelectQuery: {
-          type: "select",
-          as: "T1",
-          from: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-          where: [
-            {
-              type: "eq",
-              source: { type: "column", path: ["T1", "departmentId"] },
-              target: { type: "value", value: 1 },
-            },
-          ],
-          select: {
-            id: { type: "column", path: ["T1", "id"] },
-            name: { type: "column", path: ["T1", "name"] },
-          },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.insertIntoSelectWhere[dialect]);
-    });
-  });
-
   //#endregion
 });