@simplysm/orm-common 13.0.75 → 13.0.77

package/tests/select/subquery.spec.ts

@@ -279,64 +279,6 @@ describe("SELECT - UNION", () => {
     });
   });
 
-  describe("3 or more", () => {
-    const db = createTestDb();
-    const qr1 = db.user().where((item) => [expr.eq(item.age, 20)]);
-    const qr2 = db.user().where((item) => [expr.eq(item.age, 30)]);
-    const qr3 = db.user().where((item) => [expr.eq(item.age, 40)]);
-    const def = Queryable.union(qr1, qr2, qr3).getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T4",
-        from: [
-          {
-            type: "select",
-            as: "T1",
-            from: { database: "TestDb", schema: "TestSchema", name: "User" },
-            where: [
-              {
-                type: "eq",
-                source: { type: "column", path: ["T1", "age"] },
-                target: { type: "value", value: 20 },
-              },
-            ],
-          },
-          {
-            type: "select",
-            as: "T2",
-            from: { database: "TestDb", schema: "TestSchema", name: "User" },
-            where: [
-              {
-                type: "eq",
-                source: { type: "column", path: ["T2", "age"] },
-                target: { type: "value", value: 30 },
-              },
-            ],
-          },
-          {
-            type: "select",
-            as: "T3",
-            from: { database: "TestDb", schema: "TestSchema", name: "User" },
-            where: [
-              {
-                type: "eq",
-                source: { type: "column", path: ["T3", "age"] },
-                target: { type: "value", value: 40 },
-              },
-            ],
-          },
-        ],
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.unionThree[dialect]);
-    });
-  });
-
   describe("UNION -> WHERE (apply to each query)", () => {
     const db = createTestDb();
     const qr1 = db.user();
@@ -439,44 +381,6 @@ describe("SELECT - UNION", () => {
     });
   });
 
-  describe("UNION -> SELECT", () => {
-    const db = createTestDb();
-    const qr1 = db.user().select((item) => ({ id: item.id, name: item.name }));
-    const qr2 = db.user().select((item) => ({ id: item.id, name: item.name }));
-    const def = Queryable.union(qr1, qr2).getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T3",
-        from: [
-          {
-            type: "select",
-            as: "T1",
-            from: { database: "TestDb", schema: "TestSchema", name: "User" },
-            select: {
-              id: { type: "column", path: ["T1", "id"] },
-              name: { type: "column", path: ["T1", "name"] },
-            },
-          },
-          {
-            type: "select",
-            as: "T2",
-            from: { database: "TestDb", schema: "TestSchema", name: "User" },
-            select: {
-              id: { type: "column", path: ["T2", "id"] },
-              name: { type: "column", path: ["T2", "name"] },
-            },
-          },
-        ],
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.unionThenSelect[dialect]);
-    });
-  });
 });
 
 //#region ========== SCALAR SUBQUERY ==========

package/tests/select/window.spec.ts

@@ -57,25 +57,6 @@ describe("SELECT - Window Functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-        select: {
-          id: { type: "column", path: ["T1", "id"] },
-          name: { type: "column", path: ["T1", "name"] },
-          rank: {
-            type: "window",
-            fn: { type: "rank" },
-            spec: {
-              orderBy: [[{ type: "column", path: ["T1", "id"] }, "DESC"]],
-            },
-          },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.rank[dialect]);
@@ -92,24 +73,6 @@ describe("SELECT - Window Functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-        select: {
-          id: { type: "column", path: ["T1", "id"] },
-          denseRank: {
-            type: "window",
-            fn: { type: "denseRank" },
-            spec: {
-              orderBy: [[{ type: "column", path: ["T1", "id"] }, "DESC"]],
-            },
-          },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.denseRank[dialect]);
@@ -205,28 +168,6 @@ describe("SELECT - Window Functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-        select: {
-          id: { type: "column", path: ["T1", "id"] },
-          nextId: {
-            type: "window",
-            fn: {
-              type: "lead",
-              column: { type: "column", path: ["T1", "id"] },
-              offset: 1,
-            },
-            spec: {
-              orderBy: [[{ type: "column", path: ["T1", "id"] }, "ASC"]],
-            },
-          },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.lead[dialect]);
@@ -282,29 +223,6 @@ describe("SELECT - Window Functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-        select: {
-          id: { type: "column", path: ["T1", "id"] },
-          nextId: {
-            type: "window",
-            fn: {
-              type: "lead",
-              column: { type: "column", path: ["T1", "id"] },
-              offset: 1,
-              default: { type: "value", value: -1 },
-            },
-            spec: {
-              orderBy: [[{ type: "column", path: ["T1", "id"] }, "ASC"]],
-            },
-          },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.leadWithDefault[dialect]);
@@ -362,27 +280,6 @@ describe("SELECT - Window Functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-        select: {
-          id: { type: "column", path: ["T1", "id"] },
-          avgId: {
-            type: "window",
-            fn: {
-              type: "avg",
-              column: { type: "column", path: ["T1", "id"] },
-            },
-            spec: {
-              partitionBy: [{ type: "column", path: ["T1", "departmentId"] }],
-            },
-          },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.avgOver[dialect]);
@@ -496,46 +393,6 @@ describe("SELECT - Window Functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-        select: {
-          id: { type: "column", path: ["T1", "id"] },
-          name: { type: "column", path: ["T1", "name"] },
-          rowNum: {
-            type: "window",
-            fn: { type: "rowNumber" },
-            spec: {
-              partitionBy: [{ type: "column", path: ["T1", "departmentId"] }],
-              orderBy: [[{ type: "column", path: ["T1", "id"] }, "ASC"]],
-            },
-          },
-          rank: {
-            type: "window",
-            fn: { type: "rank" },
-            spec: {
-              partitionBy: [{ type: "column", path: ["T1", "departmentId"] }],
-              orderBy: [[{ type: "column", path: ["T1", "id"] }, "DESC"]],
-            },
-          },
-          prevName: {
-            type: "window",
-            fn: {
-              type: "lag",
-              column: { type: "column", path: ["T1", "name"] },
-              offset: 1,
-            },
-            spec: {
-              partitionBy: [{ type: "column", path: ["T1", "departmentId"] }],
-              orderBy: [[{ type: "column", path: ["T1", "id"] }, "ASC"]],
-            },
-          },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.combined[dialect]);
@@ -552,27 +409,6 @@ describe("SELECT - Window Functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-        select: {
-          id: { type: "column", path: ["T1", "id"] },
-          minId: {
-            type: "window",
-            fn: {
-              type: "min",
-              column: { type: "column", path: ["T1", "id"] },
-            },
-            spec: {
-              partitionBy: [{ type: "column", path: ["T1", "departmentId"] }],
-            },
-          },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.minOver[dialect]);
@@ -589,27 +425,6 @@ describe("SELECT - Window Functions", () => {
       }))
       .getSelectQueryDef();
 
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-        select: {
-          id: { type: "column", path: ["T1", "id"] },
-          maxId: {
-            type: "window",
-            fn: {
-              type: "max",
-              column: { type: "column", path: ["T1", "id"] },
-            },
-            spec: {
-              partitionBy: [{ type: "column", path: ["T1", "departmentId"] }],
-            },
-          },
-        },
-      });
-    });
-
     it.each(dialects)("[%s] Verify SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.maxOver[dialect]);

package/tests/types/nullable-queryable-record.spec.ts

@@ -31,21 +31,6 @@ describe("NullableQueryableRecord type inference", () => {
     expect(q).toBeDefined();
   });
 
-  it("non-optional relation (required object) fields should remain ExprUnit<T>", () => {
-    const db = createTestDb();
-    const q = db.post().select((item) => ({
-      title: item.title,
-      viewCount: item.viewCount,
-    }));
-
-    type Result = typeof q extends { meta: { columns: infer C } } ? C : never;
-    type TitleType = Result extends { title: { $infer: infer T } } ? T : never;
-
-    expectTypeOf<TitleType>().toEqualTypeOf<string>();
-
-    expect(q).toBeDefined();
-  });
-
   it("QueryableRecord preserves optional modifier (for select output)", () => {
     type OptionalData = { id?: number; name: string };
     type Result = QueryableRecord<OptionalData>;
@@ -57,17 +42,6 @@ describe("NullableQueryableRecord type inference", () => {
     expect(true).toBe(true);
   });
 
-  it("QueryableRecord preserves optional modifier for write operations", () => {
-    type OptionalData = { id?: number; name: string };
-    type WriteResult = QueryableRecord<OptionalData>;
-
-    // QueryableRecord preserves optional keys (for update/insert operations)
-    expectTypeOf<Required<WriteResult>["id"]>().toMatchTypeOf<{ $infer: number | undefined }>();
-    expectTypeOf<WriteResult["name"]>().toMatchTypeOf<{ $infer: string }>();
-
-    expect(true).toBe(true);
-  });
-
   it("select auto-infers result type from callback return", () => {
     const db = createTestDb();
 
@@ -109,28 +83,6 @@ describe("NullableQueryableRecord type inference", () => {
     expect(true).toBe(true);
   });
 
-  it("select with optional properties then orderBy should compile", () => {
-    const db = createTestDb();
-
-    /*type IUserItem = {
-      id?: number;
-      name?: string;
-      isActive: boolean;
-    };*/
-
-    const q = db
-      .user()
-      .where((u) => [expr.eq(u.isActive, true)])
-      .select((c) => ({
-        id: c.id,
-        name: c.name,
-        isActive: c.isActive,
-      }))
-      .orderBy((c) => c.id, "DESC");
-
-    expect(q).toBeDefined();
-  });
-
   it("NullableQueryableRecord wraps primitives with | undefined", () => {
     // Type-only test — verified by pnpm typecheck
     type TestData = { name: string; age: number | undefined };

package/tests/utils/result-parser-perf.spec.ts

@@ -85,27 +85,6 @@ describe("result-parser performance", () => {
       console.log(`  simple 10,000: ${elapsed.toFixed(2)}ms`);
     });
 
-    it("50,000 records processing - within 3000ms", async () => {
-      const raw = generateSimpleRecords(50_000);
-      const meta: ResultMeta = {
-        columns: {
-          id: "number",
-          name: "string",
-          email: "string",
-          age: "number",
-          active: "boolean",
-        },
-        joins: {},
-      };
-
-      const start = performance.now();
-      const result = await parseQueryResult(raw, meta);
-      const elapsed = performance.now() - start;
-
-      expect(result).toHaveLength(50_000);
-      expect(elapsed).toBeLessThan(3000);
-      console.log(`  simple 50,000: ${elapsed.toFixed(2)}ms`);
-    });
   });
 
   describe("1-level JOIN processing", () => {
@@ -131,27 +110,6 @@ describe("result-parser performance", () => {
       console.log(`  JOIN 10,000 (1000×10): ${elapsed.toFixed(2)}ms`);
     });
 
-    it("5,000 users × 10 posts = 50,000 records - within 3000ms", async () => {
-      const raw = generateJoinRecords(5_000, 10);
-      const meta: ResultMeta = {
-        columns: {
-          "id": "number",
-          "name": "string",
-          "posts.id": "number",
-          "posts.title": "string",
-          "posts.content": "string",
-        },
-        joins: { posts: { isSingle: false } },
-      };
-
-      const start = performance.now();
-      const result = await parseQueryResult(raw, meta);
-      const elapsed = performance.now() - start;
-
-      expect(result).toHaveLength(5_000);
-      expect(elapsed).toBeLessThan(3000);
-      console.log(`  JOIN 50,000 (5000×10): ${elapsed.toFixed(2)}ms`);
-    });
   });
 
   describe("2-level nested JOIN processing", () => {
@@ -181,30 +139,5 @@ describe("result-parser performance", () => {
       console.log(`  nested JOIN 5,000 (100×10×5): ${elapsed.toFixed(2)}ms`);
     });
 
-    it("500 users × 10 posts × 5 comments = 25,000 records - within 2000ms", async () => {
-      const raw = generateNestedJoinRecords(500, 10, 5);
-      const meta: ResultMeta = {
-        columns: {
-          "id": "number",
-          "name": "string",
-          "posts.id": "number",
-          "posts.title": "string",
-          "posts.comments.id": "number",
-          "posts.comments.text": "string",
-        },
-        joins: {
-          "posts": { isSingle: false },
-          "posts.comments": { isSingle: false },
-        },
-      };
-
-      const start = performance.now();
-      const result = await parseQueryResult(raw, meta);
-      const elapsed = performance.now() - start;
-
-      expect(result).toHaveLength(500);
-      expect(elapsed).toBeLessThan(2000);
-      console.log(`  nested JOIN 25,000 (500×10×5): ${elapsed.toFixed(2)}ms`);
-    });
   });
 });

package/tests/utils/result-parser.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { bytesFromHex, DateOnly, DateTime, Time, Uuid } from "@simplysm/core-common";
+import { bytes, DateOnly, DateTime, Time, Uuid } from "@simplysm/core-common";
 import { parseQueryResult } from "../../src/utils/result-parser";
 import type { ResultMeta } from "../../src/types/db";
 
@@ -40,17 +40,6 @@ describe("result-parser", () => {
       expect(result).toEqual([{ active: true, deleted: false }]);
     });
 
-    it("boolean conversion - true/false", async () => {
-      const raw = [{ active: true, deleted: false }];
-      const meta: ResultMeta = {
-        columns: { active: "boolean", deleted: "boolean" },
-        joins: {},
-      };
-
-      const result = await parseQueryResult(raw, meta);
-      expect(result).toEqual([{ active: true, deleted: false }]);
-    });
-
     it('boolean conversion - "0"/"1" strings', async () => {
       const raw = [{ active: "1", deleted: "0" }];
       const meta: ResultMeta = {
@@ -123,7 +112,7 @@ describe("result-parser", () => {
 
     it("Uuid conversion - Uint8Array", async () => {
       const uuidStr = "550e8400-e29b-41d4-a716-446655440000";
-      const uuidBytes = bytesFromHex(uuidStr.replace(/-/g, ""));
+      const uuidBytes = bytes.fromHex(uuidStr.replace(/-/g, ""));
       const raw = [{ id: uuidBytes }];
       const meta: ResultMeta = {
         columns: { id: "Uuid" },
@@ -137,8 +126,8 @@ describe("result-parser", () => {
     });
 
     it("Bytes conversion - Uint8Array passthrough", async () => {
-      const bytes = new Uint8Array([0x01, 0x02, 0x03]);
-      const raw = [{ data: bytes }];
+      const rawBytes = new Uint8Array([0x01, 0x02, 0x03]);
+      const raw = [{ data: rawBytes }];
       const meta: ResultMeta = {
         columns: { data: "Bytes" },
         joins: {},
@@ -183,18 +172,6 @@ describe("result-parser", () => {
       expect(result![0]).not.toHaveProperty("name");
     });
 
-    it("undefined value removes the key", async () => {
-      const raw = [{ id: 1, name: undefined }];
-      const meta: ResultMeta = {
-        columns: { id: "number", name: "string" },
-        joins: {},
-      };
-
-      const result = await parseQueryResult(raw, meta);
-      expect(result).toEqual([{ id: 1 }]);
-      expect(result![0]).not.toHaveProperty("name");
-    });
-
     it("record with all null values is excluded", async () => {
       const raw = [{ id: null, name: null }];
       const meta: ResultMeta = {
@@ -618,17 +595,6 @@ describe("result-parser", () => {
   //#region ========== edge cases ==========
 
   describe("edge cases", () => {
-    it("joins is an empty object", async () => {
-      const raw = [{ id: 1, name: "User1" }];
-      const meta: ResultMeta = {
-        columns: { id: "number", name: "string" },
-        joins: {},
-      };
-
-      const result = await parseQueryResult(raw, meta);
-      expect(result).toEqual([{ id: 1, name: "User1" }]);
-    });
-
     it("deduplicates duplicate data", async () => {
       const raw = [
         { "id": 1, "name": "User1", "posts.id": 10, "posts.title": "Post1" },