@simplysm/orm-common 13.0.75 → 13.0.77

package/tests/expr/utility.spec.ts

@@ -90,33 +90,6 @@ describe("Expr - Utility functions", () => {
     });
   });
 
-  describe("cast - type conversion to VARCHAR", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        id: item.id,
-        ageStr: expr.cast(item.age, { type: "varchar", length: 50 }),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        id: { type: "column", path: ["T1", "id"] },
-        ageStr: {
-          type: "cast",
-          source: { type: "column", path: ["T1", "age"] },
-          targetType: { type: "varchar", length: 50 },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.castToVarchar[dialect]);
-    });
-  });
-
   //#endregion
 
   //#region ========== RAW ==========

package/tests/select/basic.spec.ts

@@ -119,12 +119,12 @@ describe("SELECT - Basic", () => {
     });
   });
 
-  describe("ifNull (2 arguments)", () => {
+  describe("coalesce (2 arguments)", () => {
     const db = createTestDb();
     const def = db
       .user()
       .select((item) => ({
-        email: expr.ifNull(item.email, "N/A"),
+        email: expr.coalesce(item.email, "N/A"),
       }))
       .getSelectQueryDef();
 
@@ -135,7 +135,7 @@ describe("SELECT - Basic", () => {
         from: { database: "TestDb", schema: "TestSchema", name: "User" },
         select: {
           email: {
-            type: "ifNull",
+            type: "coalesce",
             args: [
               { type: "column", path: ["T1", "email"] },
               { type: "value", value: "N/A" },
@@ -151,33 +151,15 @@ describe("SELECT - Basic", () => {
     });
   });
 
-  describe("ifNull (3 arguments, COALESCE)", () => {
+  describe("coalesce (3 arguments, COALESCE)", () => {
     const db = createTestDb();
     const def = db
       .user()
       .select((item) => ({
-        contact: expr.ifNull(item.email, item.name, "N/A"),
+        contact: expr.coalesce(item.email, item.name, "N/A"),
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "User" },
-        select: {
-          contact: {
-            type: "ifNull",
-            args: [
-              { type: "column", path: ["T1", "email"] },
-              { type: "column", path: ["T1", "name"] },
-              { type: "value", value: "N/A" },
-            ],
-          },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.selectIfNull3[dialect]);
@@ -254,21 +236,6 @@ describe("SELECT - Basic", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "User" },
-        select: {
-          suffix: {
-            type: "substring",
-            source: { type: "column", path: ["T1", "name"] },
-            start: { type: "value", value: 3 },
-          },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.selectSubstringNoLength[dialect]);
@@ -346,23 +313,6 @@ describe("SELECT - Basic", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "User" },
-        select: {
-          maxAge: {
-            type: "greatest",
-            args: [
-              { type: "column", path: ["T1", "age"] },
-              { type: "value", value: 18 },
-            ],
-          },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.selectGreatest[dialect]);
@@ -394,15 +344,6 @@ describe("SELECT - Options", () => {
     const db = createTestDb();
     const def = db.user().lock().getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "User" },
-        lock: true,
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.selectLock[dialect]);
@@ -413,16 +354,6 @@ describe("SELECT - Options", () => {
     const db = createTestDb();
     const def = db.user().distinct().lock().getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "User" },
-        distinct: true,
-        lock: true,
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.selectDistinctLock[dialect]);

package/tests/select/filter.spec.ts

@@ -75,21 +75,6 @@ describe("SELECT - WHERE - comparison operations", () => {
       .where((item) => [expr.gt(item.age, 20)])
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "User" },
-        where: [
-          {
-            type: "gt",
-            source: { type: "column", path: ["T1", "age"] },
-            target: { type: "value", value: 20 },
-          },
-        ],
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.whereGt[dialect]);
@@ -103,21 +88,6 @@ describe("SELECT - WHERE - comparison operations", () => {
       .where((item) => [expr.gte(item.age, 20)])
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "User" },
-        where: [
-          {
-            type: "gte",
-            source: { type: "column", path: ["T1", "age"] },
-            target: { type: "value", value: 20 },
-          },
-        ],
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.whereGte[dialect]);
@@ -131,21 +101,6 @@ describe("SELECT - WHERE - comparison operations", () => {
       .where((item) => [expr.lt(item.age, 30)])
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "User" },
-        where: [
-          {
-            type: "lt",
-            source: { type: "column", path: ["T1", "age"] },
-            target: { type: "value", value: 30 },
-          },
-        ],
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.whereLt[dialect]);
@@ -159,21 +114,6 @@ describe("SELECT - WHERE - comparison operations", () => {
       .where((item) => [expr.lte(item.age, 30)])
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "User" },
-        where: [
-          {
-            type: "lte",
-            source: { type: "column", path: ["T1", "age"] },
-            target: { type: "value", value: 30 },
-          },
-        ],
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.whereLte[dialect]);
@@ -356,24 +296,6 @@ describe("SELECT - WHERE - LIKE", () => {
       .where((item) => [expr.not(expr.like(item.name, "%Test%"))])
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "User" },
-        where: [
-          {
-            type: "not",
-            arg: {
-              type: "like",
-              source: { type: "column", path: ["T1", "name"] },
-              pattern: { type: "value", value: "%Test%" },
-            },
-          },
-        ],
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.whereNotLike[dialect]);
@@ -601,42 +523,6 @@ describe("SELECT - WHERE - EXISTS / IN subquery", () => {
     });
   });
 
-  it("not exists - verifies QueryDef", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .where((item) => [
-        expr.not(expr.exists(db.post().where((p) => [expr.eq(p.userId, item.id)]))),
-      ])
-      .getSelectQueryDef();
-
-    expect(def).toEqual({
-      type: "select",
-      as: "T1",
-      from: { database: "TestDb", schema: "TestSchema", name: "User" },
-      where: [
-        {
-          type: "not",
-          arg: {
-            type: "exists",
-            query: {
-              type: "select",
-              as: "T2",
-              from: { database: "TestDb", schema: "TestSchema", name: "Post" },
-              where: [
-                {
-                  type: "eq",
-                  source: { type: "column", path: ["T2", "userId"] },
-                  target: { type: "column", path: ["T1", "id"] },
-                },
-              ],
-            },
-          },
-        },
-      ],
-    });
-  });
-
   describe("inQuery (IN subquery)", () => {
     const db = createTestDb();
     const def = db

package/tests/select/group.spec.ts

@@ -155,90 +155,5 @@ describe("SELECT - HAVING", () => {
     });
   });
 
-  describe("multiple conditions", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        name: item.name,
-        cnt: expr.count(item.id),
-        avgAge: expr.avg(item.age),
-      }))
-      .groupBy((item) => [item.name])
-      .having((item) => [expr.gt(item.cnt, 5), expr.gte(item.avgAge, 25)])
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "User" },
-        select: {
-          name: { type: "column", path: ["T1", "name"] },
-          cnt: { type: "count", arg: { type: "column", path: ["T1", "id"] } },
-          avgAge: { type: "avg", arg: { type: "column", path: ["T1", "age"] } },
-        },
-        groupBy: [{ type: "column", path: ["T1", "name"] }],
-        having: [
-          {
-            type: "gt",
-            source: { type: "count", arg: { type: "column", path: ["T1", "id"] } },
-            target: { type: "value", value: 5 },
-          },
-          {
-            type: "gte",
-            source: { type: "avg", arg: { type: "column", path: ["T1", "age"] } },
-            target: { type: "value", value: 25 },
-          },
-        ],
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.havingMultiple[dialect]);
-    });
-  });
-
-  describe("GROUP BY + HAVING + ORDER BY combination", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        name: item.name,
-        cnt: expr.count(item.id),
-      }))
-      .groupBy((item) => [item.name])
-      .having((item) => [expr.gt(item.cnt, 1)])
-      .orderBy((item) => item.cnt, "DESC")
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "User" },
-        select: {
-          name: { type: "column", path: ["T1", "name"] },
-          cnt: { type: "count", arg: { type: "column", path: ["T1", "id"] } },
-        },
-        groupBy: [{ type: "column", path: ["T1", "name"] }],
-        having: [
-          {
-            type: "gt",
-            source: { type: "count", arg: { type: "column", path: ["T1", "id"] } },
-            target: { type: "value", value: 1 },
-          },
-        ],
-        orderBy: [[{ type: "count", arg: { type: "column", path: ["T1", "id"] } }, "DESC"]],
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.havingOrderCombo[dialect]);
-    });
-  });
-
   //#endregion
 });

package/tests/select/join.spec.ts

@@ -353,57 +353,6 @@ describe("SELECT - JOIN", () => {
     });
   });
 
-  it("Combination of join + where", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .join("post", (q, c) => q.from(Post).where((item) => [expr.eq(item.userId, c.id)]))
-      .where((item) => [expr.eq(item.isActive, true)])
-      .getSelectQueryDef();
-
-    expect(def).toEqual({
-      type: "select",
-      as: "T1",
-      from: { database: "TestDb", schema: "TestSchema", name: "User" },
-      select: {
-        "id": { type: "column", path: ["T1", "id"] },
-        "name": { type: "column", path: ["T1", "name"] },
-        "email": { type: "column", path: ["T1", "email"] },
-        "age": { type: "column", path: ["T1", "age"] },
-        "isActive": { type: "column", path: ["T1", "isActive"] },
-        "companyId": { type: "column", path: ["T1", "companyId"] },
-        "createdAt": { type: "column", path: ["T1", "createdAt"] },
-        "post.id": { type: "column", path: ["T1.post", "id"] },
-        "post.userId": { type: "column", path: ["T1.post", "userId"] },
-        "post.title": { type: "column", path: ["T1.post", "title"] },
-        "post.content": { type: "column", path: ["T1.post", "content"] },
-        "post.viewCount": { type: "column", path: ["T1.post", "viewCount"] },
-        "post.publishedAt": { type: "column", path: ["T1.post", "publishedAt"] },
-      },
-      where: [
-        {
-          type: "eq",
-          source: { type: "column", path: ["T1", "isActive"] },
-          target: { type: "value", value: true },
-        },
-      ],
-      joins: [
-        {
-          type: "select",
-          as: "T1.post",
-          from: { database: "TestDb", schema: "TestSchema", name: "Post" },
-          isSingle: false,
-          where: [
-            {
-              type: "eq",
-              source: { type: "column", path: ["T1.post", "userId"] },
-              target: { type: "column", path: ["T1", "id"] },
-            },
-          ],
-        },
-      ],
-    });
-  });
 });
 
 describe("SELECT - INCLUDE", () => {
@@ -555,68 +504,6 @@ describe("SELECT - INCLUDE", () => {
     });
   });
 
-  it("Multiple include", () => {
-    const db = createTestDb();
-    const def = db
-      .post()
-      .include((item) => item.user)
-      .include((item) => item.user.company)
-      .getSelectQueryDef();
-
-    // duplicate includes are automatically deduplicated (user once, company once)
-    expect(def).toEqual({
-      type: "select",
-      as: "T1",
-      from: { database: "TestDb", schema: "TestSchema", name: "Post" },
-      select: {
-        "id": { type: "column", path: ["T1", "id"] },
-        "userId": { type: "column", path: ["T1", "userId"] },
-        "title": { type: "column", path: ["T1", "title"] },
-        "content": { type: "column", path: ["T1", "content"] },
-        "viewCount": { type: "column", path: ["T1", "viewCount"] },
-        "publishedAt": { type: "column", path: ["T1", "publishedAt"] },
-        "user.id": { type: "column", path: ["T1.user", "id"] },
-        "user.name": { type: "column", path: ["T1.user", "name"] },
-        "user.email": { type: "column", path: ["T1.user", "email"] },
-        "user.age": { type: "column", path: ["T1.user", "age"] },
-        "user.isActive": { type: "column", path: ["T1.user", "isActive"] },
-        "user.companyId": { type: "column", path: ["T1.user", "companyId"] },
-        "user.createdAt": { type: "column", path: ["T1.user", "createdAt"] },
-        "user.company.id": { type: "column", path: ["T1.user.company", "id"] },
-        "user.company.name": { type: "column", path: ["T1.user.company", "name"] },
-        "user.company.foundedAt": { type: "column", path: ["T1.user.company", "foundedAt"] },
-      },
-      joins: [
-        {
-          type: "select",
-          as: "T1.user",
-          from: { database: "TestDb", schema: "TestSchema", name: "User" },
-          isSingle: true,
-          where: [
-            {
-              type: "eq",
-              source: { type: "column", path: ["T1.user", "id"] },
-              target: { type: "column", path: ["T1", "userId"] },
-            },
-          ],
-        },
-        {
-          type: "select",
-          as: "T1.user.company",
-          from: { database: "TestDb", schema: "TestSchema", name: "Company" },
-          isSingle: true,
-          where: [
-            {
-              type: "eq",
-              source: { type: "column", path: ["T1.user.company", "id"] },
-              target: { type: "column", path: ["T1.user", "companyId"] },
-            },
-          ],
-        },
-      ],
-    });
-  });
-
   it("Combination of include + select", () => {
     const db = createTestDb();
     const def = db

package/tests/select/order.spec.ts

@@ -30,28 +30,6 @@ describe("SELECT - ORDER BY", () => {
     });
   });
 
-  describe("ASC (explicit)", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .orderBy((item) => item.id, "ASC")
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "User" },
-        orderBy: [[{ type: "column", path: ["T1", "id"] }, "ASC"]],
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.orderAscExplicit[dialect]);
-    });
-  });
-
   describe("DESC", () => {
     const db = createTestDb();
     const def = db
@@ -134,33 +112,6 @@ describe("SELECT - ORDER BY", () => {
 
   //#region ========== combinations ==========
 
-  describe("SELECT + ORDER BY combination", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({ id: item.id, name: item.name }))
-      .orderBy((item) => item.name, "ASC")
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "User" },
-        select: {
-          id: { type: "column", path: ["T1", "id"] },
-          name: { type: "column", path: ["T1", "name"] },
-        },
-        orderBy: [[{ type: "column", path: ["T1", "name"] }, "ASC"]],
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.orderSelectCombo[dialect]);
-    });
-  });
-
   describe("ORDER BY + LIMIT combination", () => {
     const db = createTestDb();
     const def = db