@simplysm/orm-common 13.0.75 → 13.0.76

package/tests/expr/conditional.spec.ts

@@ -190,33 +190,6 @@ describe("Expr - Conditional functions", () => {
     });
   });
 
-  describe("least - minimum value", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        minVal: expr.least(item.age, 100),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        minVal: {
-          type: "least",
-          args: expect.arrayContaining([
-            { type: "column", path: ["T1", "age"] },
-            { type: "value", value: 100 },
-          ]),
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.least[dialect]);
-    });
-  });
-
   describe("switch - all case/default are undefined", () => {
     it("throws an error", () => {
       const db = createTestDb();

package/tests/expr/date.spec.ts

@@ -41,15 +41,6 @@ describe("Expr - Date/Time functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        monthPart: {
-          type: "month",
-          arg: { type: "column", path: ["T1", "createdAt"] },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.month[dialect]);
@@ -65,15 +56,6 @@ describe("Expr - Date/Time functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        dayPart: {
-          type: "day",
-          arg: { type: "column", path: ["T1", "createdAt"] },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.day[dialect]);
@@ -89,15 +71,6 @@ describe("Expr - Date/Time functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        hourPart: {
-          type: "hour",
-          arg: { type: "column", path: ["T1", "createdAt"] },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.hour[dialect]);
@@ -113,15 +86,6 @@ describe("Expr - Date/Time functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        minutePart: {
-          type: "minute",
-          arg: { type: "column", path: ["T1", "createdAt"] },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.minute[dialect]);
@@ -137,15 +101,6 @@ describe("Expr - Date/Time functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        secondPart: {
-          type: "second",
-          arg: { type: "column", path: ["T1", "createdAt"] },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.second[dialect]);
@@ -189,17 +144,6 @@ describe("Expr - Date/Time functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        yearsDiff: {
-          type: "dateDiff",
-          separator: "year",
-          from: { type: "column", path: ["T1", "createdAt"] },
-          to: { type: "value", value: targetDate },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.dateDiffYear[dialect]);
@@ -216,17 +160,6 @@ describe("Expr - Date/Time functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        monthsDiff: {
-          type: "dateDiff",
-          separator: "month",
-          from: { type: "column", path: ["T1", "createdAt"] },
-          to: { type: "value", value: targetDate },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.dateDiffMonth[dialect]);

package/tests/expr/math.spec.ts

@@ -56,51 +56,4 @@ describe("Expr - Math functions", () => {
     });
   });
 
-  describe("ceil - ceiling", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        ceiled: expr.ceil(item.age),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        ceiled: {
-          type: "ceil",
-          arg: { type: "column", path: ["T1", "age"] },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.ceil[dialect]);
-    });
-  });
-
-  describe("floor - flooring", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        floored: expr.floor(item.age),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        floored: {
-          type: "floor",
-          arg: { type: "column", path: ["T1", "age"] },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.floor[dialect]);
-    });
-  });
 });

package/tests/expr/string.spec.ts

@@ -68,15 +68,6 @@ describe("Expr - String functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        byteLen: {
-          type: "byteLength",
-          arg: { type: "column", path: ["T1", "name"] },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.byteLength[dialect]);
@@ -117,16 +108,6 @@ describe("Expr - String functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        suffix: {
-          type: "right",
-          source: { type: "column", path: ["T1", "name"] },
-          length: { type: "value", value: 3 },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.right[dialect]);
@@ -142,15 +123,6 @@ describe("Expr - String functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        trimmed: {
-          type: "trim",
-          arg: { type: "column", path: ["T1", "name"] },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.trim[dialect]);
@@ -218,15 +190,6 @@ describe("Expr - String functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        upper: {
-          type: "upper",
-          arg: { type: "column", path: ["T1", "name"] },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.upper[dialect]);
@@ -242,15 +205,6 @@ describe("Expr - String functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        lower: {
-          type: "lower",
-          arg: { type: "column", path: ["T1", "name"] },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.lower[dialect]);
@@ -338,16 +292,6 @@ describe("Expr - String functions", () => {
       .where((item) => [expr.like(item.name, "%\\%%")])
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def.where).toEqual([
-        {
-          type: "like",
-          source: { type: "column", path: ["T1", "name"] },
-          pattern: { type: "value", value: "%\\%%" },
-        },
-      ]);
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.likeEscape[dialect]);

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

@@ -160,24 +160,6 @@ describe("SELECT - Basic", () => {
       }))
       .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
 });