@simplysm/orm-common 13.0.74 → 13.0.76

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

@@ -61,46 +61,6 @@ describe("DDL - Relation Builder", () => {
     });
   });
 
-  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",
-        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 - composite FK", () => {
     const Company = Table("Company")
       .database("TestDb")
@@ -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
 });

package/tests/dml/update.spec.ts

@@ -41,42 +41,6 @@ describe("UPDATE - Basic", () => {
     });
   });
 
-  describe("UPDATE multiple columns", () => {
-    const db = createTestDb();
-
-    const def = db
-      .employee()
-      .where((e) => [expr.eq(e.id, 1)])
-      .getUpdateQueryDef(() => ({
-        name: expr.val("string", "New Name"),
-        departmentId: expr.val("number", 2),
-      }));
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "update",
-        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-        as: "T1",
-        record: {
-          name: { type: "value", value: "New Name" },
-          departmentId: { type: "value", value: 2 },
-        },
-        where: [
-          {
-            type: "eq",
-            source: { type: "column", path: ["T1", "id"] },
-            target: { type: "value", value: 1 },
-          },
-        ],
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.updateMultiCol[dialect]);
-    });
-  });
-
   describe("UPDATE with literal values (without expr.val)", () => {
     const db = createTestDb();
 
@@ -153,45 +117,6 @@ describe("UPDATE - Basic", () => {
     });
   });
 
-  describe("UPDATE referencing current values (e.g., count = count + 1)", () => {
-    const db = createTestDb();
-
-    const def = db
-      .employee()
-      .where((e) => [expr.eq(e.id, 1)])
-      .getUpdateQueryDef((e) => ({
-        // managerId = managerId + 1 (example)
-        managerId: expr.raw("number")`${e.managerId} + 1`,
-      }));
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "update",
-        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-        as: "T1",
-        record: {
-          managerId: {
-            type: "raw",
-            sql: "$1 + 1",
-            params: [{ type: "column", path: ["T1", "managerId"] }],
-          },
-        },
-        where: [
-          {
-            type: "eq",
-            source: { type: "column", path: ["T1", "id"] },
-            target: { type: "value", value: 1 },
-          },
-        ],
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.updateWithRef[dialect]);
-    });
-  });
-
   describe("Specify output column", () => {
     const db = createTestDb();
 
@@ -294,25 +219,4 @@ describe("FK switch", () => {
     });
   });
 
-  describe("FK on", () => {
-    const db = createTestDb();
-
-    const def = db.getSwitchFkQueryDef(
-      { database: "TestDb", schema: "TestSchema", name: "Employee" },
-      "on",
-    );
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "switchFk",
-        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-        switch: "on",
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.fkOn[dialect]);
-    });
-  });
 });

package/tests/dml/upsert.spec.ts

@@ -146,58 +146,6 @@ describe("UPSERT - Basic", () => {
     });
   });
 
-  describe("Complex WHERE condition", () => {
-    const db = createTestDb();
-    const def = db
-      .employee()
-      .where((e) => [expr.eq(e.name, "Gildong Hong"), expr.eq(e.departmentId, 1)])
-      .getUpsertQueryDef(
-        () => ({ managerId: expr.val("number", 10) }),
-        (upd) => ({
-          name: expr.val("string", "Gildong Hong"),
-          departmentId: expr.val("number", 1),
-          managerId: upd.managerId,
-        }),
-      );
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "upsert",
-        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-        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 },
-            },
-          ],
-        },
-        updateRecord: {
-          managerId: { type: "value", value: 10 },
-        },
-        insertRecord: {
-          name: { type: "value", value: "Gildong Hong" },
-          departmentId: { type: "value", value: 1 },
-          managerId: { type: "value", value: 10 },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.upsertMultiWhere[dialect]);
-    });
-  });
-
   describe("UPSERT with literal values (without expr.val)", () => {
     const db = createTestDb();
     const def = db

package/tests/errors/queryable-errors.spec.ts

@@ -10,9 +10,6 @@ describe("Queryable error cases", () => {
       expect(() => expr.and([])).toThrow("empty arrays are not allowed");
     });
 
-    it("ArgumentError when calling or() with empty array", () => {
-      expect(() => expr.or([])).toThrow("empty arrays are not allowed");
-    });
   });
 
   describe("executable errors", () => {
@@ -97,21 +94,6 @@ describe("Queryable error cases", () => {
       }).toThrow("inQuery subquery must SELECT only a single column.");
     });
 
-    it("Error when using subquery without column specification", () => {
-      const db = createTestDb();
-
-      expect(() => {
-        db.user()
-          .where((u) => [
-            expr.inQuery(
-              u.id,
-              // @ts-expect-error - subquery without SELECT
-              db.post(),
-            ),
-          ])
-          .getSelectQueryDef();
-      }).toThrow("inQuery subquery must SELECT only a single column.");
-    });
   });
 
   describe("countAsync() errors", () => {
@@ -141,37 +123,4 @@ describe("Queryable error cases", () => {
     });
   });
 
-  describe("RecursiveQueryable.union() errors", () => {
-    it("Error when calling union with a single queryable", () => {
-      const db = createTestDb();
-
-      expect(() => {
-        db.employee()
-          .where((e) => [expr.null(e.managerId)])
-          .recursive((cte) => cte.union(db.employee()));
-      }).toThrow("union requires at least 2 queryables.");
-    });
-
-    it("Error when calling union with zero queryables", () => {
-      const db = createTestDb();
-
-      expect(() => {
-        db.employee()
-          .where((e) => [expr.null(e.managerId)])
-          .recursive((cte) => cte.union());
-      }).toThrow("union requires at least 2 queryables.");
-    });
-  });
-
-  describe("JoinQueryable.union() errors", () => {
-    it("Error when calling union with a single queryable inside join", () => {
-      const db = createTestDb();
-
-      expect(() => {
-        db.user().join("posts", (j, u) =>
-          j.union(db.post().where((p) => [expr.eq(p.userId, u.id)])),
-        );
-      }).toThrow("union requires at least 2 queryables.");
-    });
-  });
 });