@simplysm/orm-common 13.0.75 → 13.0.77

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();
 
@@ -277,14 +202,14 @@ describe("FK switch", () => {
 
     const def = db.getSwitchFkQueryDef(
       { database: "TestDb", schema: "TestSchema", name: "Employee" },
-      "off",
+      false,
     );
 
     it("Verify QueryDef", () => {
       expect(def).toEqual({
         type: "switchFk",
         table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-        switch: "off",
+        enabled: false,
       });
     });
 
@@ -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.");
-    });
-  });
 });

package/tests/escape.spec.ts

@@ -23,45 +23,14 @@ describe("MysqlExprRenderer.escapeString", () => {
 
   //#endregion
 
-  //#region ========== Control Character Escaping ==========
-
-  it("should escape newlines", () => {
-    const result = renderer.escapeString("line1\nline2");
-    expect(result).toBe("line1\\nline2");
-  });
-
-  it("should escape carriage returns", () => {
-    const result = renderer.escapeString("line1\rline2");
-    expect(result).toBe("line1\\rline2");
-  });
-
-  it("should escape tabs", () => {
-    const result = renderer.escapeString("col1\tcol2");
-    expect(result).toBe("col1\\tcol2");
-  });
-
-  //#endregion
-
   //#region ========== Combined Attack Test ==========
 
-  it("should defend against SQL injection attempts", () => {
-    const malicious = "'; DROP TABLE users; --";
-    const result = renderer.escapeString(malicious);
-    expect(result).toBe("''; DROP TABLE users; --");
-  });
-
   it("should defend against backslash + quote combination", () => {
     const malicious = "\\'";
     const result = renderer.escapeString(malicious);
     expect(result).toBe("\\\\''");
   });
 
-  it("should defend against NULL byte + SQL comment combination", () => {
-    const malicious = "admin\0-- ";
-    const result = renderer.escapeString(malicious);
-    expect(result).toBe("admin\\0-- ");
-  });
-
   //#endregion
 });
 
@@ -73,16 +42,6 @@ describe("MysqlExprRenderer.escapeValue", () => {
     expect(result).toBe("'O''Reilly'");
   });
 
-  it("correctly escapes string containing backslashes", () => {
-    const result = renderer.escapeValue("C:\\path");
-    expect(result).toBe("'C:\\\\path'");
-  });
-
-  it("defends against SQL injection attempts", () => {
-    const result = renderer.escapeValue("'; DROP TABLE users; --");
-    expect(result).toBe("'''; DROP TABLE users; --'");
-  });
-
   it("returns 'NULL' string for null", () => {
     const result = renderer.escapeValue(null);
     expect(result).toBe("NULL");

package/tests/examples/pivot.spec.ts

@@ -68,339 +68,6 @@ describe("SELECT - PIVOT (groupBy + switch)", () => {
     });
   });
 
-  describe("COUNT", () => {
-    const db = createTestDb();
-    const def = db
-      .sales()
-      .groupBy((item) => [item.id, item.category])
-      .select((item) => ({
-        id: item.id,
-        category: item.category,
-        y2020: expr.count(expr.if(expr.eq(item.year, 2020), item.amount, undefined)),
-        y2021: expr.count(expr.if(expr.eq(item.year, 2021), item.amount, undefined)),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "Sales" },
-        groupBy: [
-          { type: "column", path: ["T1", "id"] },
-          { type: "column", path: ["T1", "category"] },
-        ],
-        select: {
-          id: { type: "column", path: ["T1", "id"] },
-          category: { type: "column", path: ["T1", "category"] },
-          y2020: {
-            type: "count",
-            arg: {
-              type: "if",
-              condition: {
-                type: "eq",
-                source: { type: "column", path: ["T1", "year"] },
-                target: { type: "value", value: 2020 },
-              },
-              then: { type: "column", path: ["T1", "amount"] },
-              else: { type: "value", value: undefined },
-            },
-          },
-          y2021: {
-            type: "count",
-            arg: {
-              type: "if",
-              condition: {
-                type: "eq",
-                source: { type: "column", path: ["T1", "year"] },
-                target: { type: "value", value: 2021 },
-              },
-              then: { type: "column", path: ["T1", "amount"] },
-              else: { type: "value", value: undefined },
-            },
-          },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.pivotCount[dialect]);
-    });
-  });
-
-  describe("AVG", () => {
-    const db = createTestDb();
-    const def = db
-      .sales()
-      .groupBy((item) => [item.id, item.category])
-      .select((item) => ({
-        id: item.id,
-        category: item.category,
-        y2020: expr.avg(expr.if(expr.eq(item.year, 2020), item.amount, undefined)),
-        y2021: expr.avg(expr.if(expr.eq(item.year, 2021), item.amount, undefined)),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "Sales" },
-        groupBy: [
-          { type: "column", path: ["T1", "id"] },
-          { type: "column", path: ["T1", "category"] },
-        ],
-        select: {
-          id: { type: "column", path: ["T1", "id"] },
-          category: { type: "column", path: ["T1", "category"] },
-          y2020: {
-            type: "avg",
-            arg: {
-              type: "if",
-              condition: {
-                type: "eq",
-                source: { type: "column", path: ["T1", "year"] },
-                target: { type: "value", value: 2020 },
-              },
-              then: { type: "column", path: ["T1", "amount"] },
-              else: { type: "value", value: undefined },
-            },
-          },
-          y2021: {
-            type: "avg",
-            arg: {
-              type: "if",
-              condition: {
-                type: "eq",
-                source: { type: "column", path: ["T1", "year"] },
-                target: { type: "value", value: 2021 },
-              },
-              then: { type: "column", path: ["T1", "amount"] },
-              else: { type: "value", value: undefined },
-            },
-          },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.pivotAvg[dialect]);
-    });
-  });
-
-  describe("MAX", () => {
-    const db = createTestDb();
-    const def = db
-      .sales()
-      .groupBy((item) => [item.id, item.category])
-      .select((item) => ({
-        id: item.id,
-        category: item.category,
-        y2020: expr.max(expr.if(expr.eq(item.year, 2020), item.amount, undefined)),
-        y2021: expr.max(expr.if(expr.eq(item.year, 2021), item.amount, undefined)),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "Sales" },
-        groupBy: [
-          { type: "column", path: ["T1", "id"] },
-          { type: "column", path: ["T1", "category"] },
-        ],
-        select: {
-          id: { type: "column", path: ["T1", "id"] },
-          category: { type: "column", path: ["T1", "category"] },
-          y2020: {
-            type: "max",
-            arg: {
-              type: "if",
-              condition: {
-                type: "eq",
-                source: { type: "column", path: ["T1", "year"] },
-                target: { type: "value", value: 2020 },
-              },
-              then: { type: "column", path: ["T1", "amount"] },
-              else: { type: "value", value: undefined },
-            },
-          },
-          y2021: {
-            type: "max",
-            arg: {
-              type: "if",
-              condition: {
-                type: "eq",
-                source: { type: "column", path: ["T1", "year"] },
-                target: { type: "value", value: 2021 },
-              },
-              then: { type: "column", path: ["T1", "amount"] },
-              else: { type: "value", value: undefined },
-            },
-          },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.pivotMax[dialect]);
-    });
-  });
-
-  describe("MIN", () => {
-    const db = createTestDb();
-    const def = db
-      .sales()
-      .groupBy((item) => [item.id, item.category])
-      .select((item) => ({
-        id: item.id,
-        category: item.category,
-        y2020: expr.min(expr.if(expr.eq(item.year, 2020), item.amount, undefined)),
-        y2021: expr.min(expr.if(expr.eq(item.year, 2021), item.amount, undefined)),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "Sales" },
-        groupBy: [
-          { type: "column", path: ["T1", "id"] },
-          { type: "column", path: ["T1", "category"] },
-        ],
-        select: {
-          id: { type: "column", path: ["T1", "id"] },
-          category: { type: "column", path: ["T1", "category"] },
-          y2020: {
-            type: "min",
-            arg: {
-              type: "if",
-              condition: {
-                type: "eq",
-                source: { type: "column", path: ["T1", "year"] },
-                target: { type: "value", value: 2020 },
-              },
-              then: { type: "column", path: ["T1", "amount"] },
-              else: { type: "value", value: undefined },
-            },
-          },
-          y2021: {
-            type: "min",
-            arg: {
-              type: "if",
-              condition: {
-                type: "eq",
-                source: { type: "column", path: ["T1", "year"] },
-                target: { type: "value", value: 2021 },
-              },
-              then: { type: "column", path: ["T1", "amount"] },
-              else: { type: "value", value: undefined },
-            },
-          },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.pivotMin[dialect]);
-    });
-  });
-
-  describe("3 or more pivot values", () => {
-    const db = createTestDb();
-    const def = db
-      .sales()
-      .groupBy((item) => [item.id, item.category])
-      .select((item) => ({
-        id: item.id,
-        category: item.category,
-        y2019: expr.sum(expr.if(expr.eq(item.year, 2019), item.amount, undefined)),
-        y2020: expr.sum(expr.if(expr.eq(item.year, 2020), item.amount, undefined)),
-        y2021: expr.sum(expr.if(expr.eq(item.year, 2021), item.amount, undefined)),
-        y2022: expr.sum(expr.if(expr.eq(item.year, 2022), item.amount, undefined)),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "Sales" },
-        groupBy: [
-          { type: "column", path: ["T1", "id"] },
-          { type: "column", path: ["T1", "category"] },
-        ],
-        select: {
-          id: { type: "column", path: ["T1", "id"] },
-          category: { type: "column", path: ["T1", "category"] },
-          y2019: {
-            type: "sum",
-            arg: {
-              type: "if",
-              condition: {
-                type: "eq",
-                source: { type: "column", path: ["T1", "year"] },
-                target: { type: "value", value: 2019 },
-              },
-              then: { type: "column", path: ["T1", "amount"] },
-              else: { type: "value", value: undefined },
-            },
-          },
-          y2020: {
-            type: "sum",
-            arg: {
-              type: "if",
-              condition: {
-                type: "eq",
-                source: { type: "column", path: ["T1", "year"] },
-                target: { type: "value", value: 2020 },
-              },
-              then: { type: "column", path: ["T1", "amount"] },
-              else: { type: "value", value: undefined },
-            },
-          },
-          y2021: {
-            type: "sum",
-            arg: {
-              type: "if",
-              condition: {
-                type: "eq",
-                source: { type: "column", path: ["T1", "year"] },
-                target: { type: "value", value: 2021 },
-              },
-              then: { type: "column", path: ["T1", "amount"] },
-              else: { type: "value", value: undefined },
-            },
-          },
-          y2022: {
-            type: "sum",
-            arg: {
-              type: "if",
-              condition: {
-                type: "eq",
-                source: { type: "column", path: ["T1", "year"] },
-                target: { type: "value", value: 2022 },
-              },
-              then: { type: "column", path: ["T1", "amount"] },
-              else: { type: "value", value: undefined },
-            },
-          },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.pivotMultipleYears[dialect]);
-    });
-  });
-
   describe("String pivot column", () => {
     const db = createTestDb();
     const def = db