@simplysm/orm-common 13.0.75 → 13.0.76

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

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`);
-    });
   });
 });