@simplysm/orm-common 13.0.74 → 13.0.76

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

package/tests/examples/sampling.spec.ts

@@ -39,67 +39,4 @@ describe("EXAMPLE - Random sampling", () => {
     });
   });
 
-  describe("Conditional sampling (WHERE + ORDER BY RANDOM + TOP)", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .where((item) => [expr.gte(item.age, 20)])
-      .orderBy(() => expr.random())
-      .top(3)
-      .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 },
-          },
-        ],
-        orderBy: [[{ type: "random" }]],
-        top: 3,
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.samplingWithWhere[dialect]);
-    });
-  });
-
-  describe("Column selection with sampling", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        id: item.id,
-        name: item.name,
-      }))
-      .orderBy(() => expr.random())
-      .top(10)
-      .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: "random" }]],
-        top: 10,
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.samplingWithSelect[dialect]);
-    });
-  });
 });

package/tests/examples/unpivot.spec.ts

@@ -79,71 +79,6 @@ describe("SELECT - UNPIVOT (join + union)", () => {
     });
   });
 
-  describe("2-column unpivot", () => {
-    const db = createTestDb();
-    const def = db
-      .monthlySales()
-      .join("unpvt", (qr, c) =>
-        qr.union(
-          qr.select({ period: expr.val("string", "jan"), value: c.jan }),
-          qr.select({ period: expr.val("string", "feb"), value: c.feb }),
-        ),
-      )
-      .select((item) => ({
-        id: item.id,
-        category: item.category,
-        mar: item.mar,
-        period: item.unpvt![0].period,
-        value: item.unpvt![0].value,
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "MonthlySales" },
-        select: {
-          id: { type: "column", path: ["T1", "id"] },
-          category: { type: "column", path: ["T1", "category"] },
-          mar: { type: "column", path: ["T1", "mar"] },
-          period: { type: "column", path: ["T1.unpvt", "period"] },
-          value: { type: "column", path: ["T1.unpvt", "value"] },
-        },
-        joins: [
-          {
-            type: "select",
-            as: "T1.unpvt",
-            from: [
-              {
-                type: "select",
-                as: "T1.unpvt",
-                select: {
-                  period: { type: "value", value: "jan" },
-                  value: { type: "column", path: ["T1", "jan"] },
-                },
-              },
-              {
-                type: "select",
-                as: "T1.unpvt",
-                select: {
-                  period: { type: "value", value: "feb" },
-                  value: { type: "column", path: ["T1", "feb"] },
-                },
-              },
-            ],
-            isSingle: false,
-          },
-        ],
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.unpivotTwoColumns[dialect]);
-    });
-  });
-
   describe("WHERE -> UNPIVOT", () => {
     const db = createTestDb();
     const def = db

package/tests/exec/search-parser.spec.ts

@@ -56,14 +56,6 @@ describe("parseSearchQuery", () => {
       });
     });
 
-    it("Multiple identical prefixes", () => {
-      expect(parseSearchQuery("+사과 +바나나")).toEqual({
-        or: [],
-        must: ["%사과%", "%바나나%"],
-        not: [],
-      });
-    });
-
     it("Ignore when only prefixes present", () => {
       expect(parseSearchQuery("+ - ")).toEqual({ or: [], must: [], not: [] });
       expect(parseSearchQuery("+ 사과")).toEqual({ or: ["%사과%"], must: [], not: [] });
@@ -148,14 +140,6 @@ describe("parseSearchQuery", () => {
       });
     });
 
-    it("* on both sides → contains search (explicit)", () => {
-      expect(parseSearchQuery("*사과*")).toEqual({
-        or: ["%사과%"],
-        must: [],
-        not: [],
-      });
-    });
-
     it("* in middle → middle wildcard", () => {
       expect(parseSearchQuery("사*과")).toEqual({
         or: ["사%과"],

package/tests/expr/comparison.spec.ts

@@ -69,19 +69,6 @@ describe("Expr - Comparison operators (null-safe)", () => {
       .where((item) => [expr.gt(item.age, 20)])
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toMatchObject({
-        type: "select",
-        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.gt[dialect]);
@@ -95,19 +82,6 @@ describe("Expr - Comparison operators (null-safe)", () => {
       .where((item) => [expr.lt(item.age, 30)])
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toMatchObject({
-        type: "select",
-        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.lt[dialect]);
@@ -121,19 +95,6 @@ describe("Expr - Comparison operators (null-safe)", () => {
       .where((item) => [expr.gte(item.age, 18)])
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toMatchObject({
-        type: "select",
-        where: [
-          {
-            type: "gte",
-            source: { type: "column", path: ["T1", "age"] },
-            target: { type: "value", value: 18 },
-          },
-        ],
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.gte[dialect]);
@@ -147,19 +108,6 @@ describe("Expr - Comparison operators (null-safe)", () => {
       .where((item) => [expr.lte(item.age, 65)])
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toMatchObject({
-        type: "select",
-        where: [
-          {
-            type: "lte",
-            source: { type: "column", path: ["T1", "age"] },
-            target: { type: "value", value: 65 },
-          },
-        ],
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.lte[dialect]);
@@ -227,20 +175,6 @@ describe("Expr - Comparison operators (null-safe)", () => {
       .where((item) => [expr.between(item.age, undefined, 30)])
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toMatchObject({
-        type: "select",
-        where: [
-          {
-            type: "between",
-            source: { type: "column", path: ["T1", "age"] },
-            from: undefined,
-            to: { type: "value", value: 30 },
-          },
-        ],
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.betweenToOnly[dialect]);