@simplysm/orm-common 13.0.100 → 14.0.4

package/tests/setup/views/ActiveUsers.ts

@@ -1,8 +0,0 @@
-import { View } from "../../../src/schema/view-builder";
-import { expr } from "../../../src/expr/expr";
-import type { TestDbTablesContext } from "../TestDbContext";
-
-// view showing only active users
-export const ActiveUsers = View("ActiveUsers").query((db: TestDbTablesContext) =>
-  db.user().where((u) => [expr.eq(u.isActive, true)]),
-);

package/tests/setup/views/UserSummary.ts

@@ -1,11 +0,0 @@
-import { View } from "../../../src/schema/view-builder";
-import type { TestDbTablesContext } from "../TestDbContext";
-
-// view for user summary info (includes select)
-export const UserSummary = View("UserSummary").query((db: TestDbTablesContext) =>
-  db.user().select((u) => ({
-    id: u.id,
-    name: u.name,
-    email: u.email,
-  })),
-);

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

@@ -1,97 +0,0 @@
-import { describe, expect, expectTypeOf, it } from "vitest";
-import { createTestDb } from "../setup/TestDbContext";
-import { expr } from "../../src/expr/expr";
-import { User } from "../setup/models/User";
-import type {
-  NullableQueryableRecord,
-  QueryableRecord,
-  UnwrapQueryableRecord,
-} from "../../src/exec/queryable";
-
-describe("NullableQueryableRecord type inference", () => {
-  it("optional relation (joinSingle) fields should be ExprUnit<T | undefined>", () => {
-    const db = createTestDb();
-    const q = db
-      .post()
-      .joinSingle("user", (qr, c) => qr.from(User).where((u) => [expr.eq(u.id, c.userId)]))
-      .select((item) => ({
-        title: item.title,
-        userName: item.user!.name,
-      }));
-
-    // title is from the main table — should remain non-nullable
-    type Result = typeof q extends { meta: { columns: infer C } } ? C : never;
-    type TitleType = Result extends { title: { $infer: infer T } } ? T : never;
-    type UserNameType = Result extends { userName: { $infer: infer T } } ? T : never;
-
-    expectTypeOf<TitleType>().toEqualTypeOf<string>();
-    expectTypeOf<UserNameType>().toEqualTypeOf<string | undefined>();
-
-    // Runtime: query builds without error
-    expect(q).toBeDefined();
-  });
-
-  it("QueryableRecord preserves optional modifier (for select output)", () => {
-    type OptionalData = { id?: number; name: string };
-    type Result = QueryableRecord<OptionalData>;
-
-    // Key is optional — Required<> needed to access id
-    expectTypeOf<Required<Result>["id"]>().toMatchTypeOf<{ $infer: number | undefined }>();
-    expectTypeOf<Result["name"]>().toMatchTypeOf<{ $infer: string }>();
-
-    expect(true).toBe(true);
-  });
-
-  it("select auto-infers result type from callback return", () => {
-    const db = createTestDb();
-
-    const q = db
-      .user()
-      .where((u) => [expr.eq(u.isActive, true)])
-      .select((c) => ({
-        id: c.id,
-        name: c.name,
-        email: c.email,
-        isActive: c.isActive,
-      }));
-
-    // UnwrapQueryableRecord extracts primitive types from ExprUnit
-    type Result = typeof q extends { meta: { columns: infer C } } ? C : never;
-    type IdType = Result extends { id: { $infer: infer T } } ? T : never;
-    type EmailType = Result extends { email: { $infer: infer T } } ? T : never;
-
-    expectTypeOf<IdType>().toEqualTypeOf<number>();
-    expectTypeOf<EmailType>().toEqualTypeOf<string | undefined>();
-
-    expect(q).toBeDefined();
-  });
-
-  it("UnwrapQueryableRecord unwraps ExprUnit to primitive", () => {
-    type Input = {
-      id: import("../../src/expr/expr-unit").ExprUnit<number>;
-      name: import("../../src/expr/expr-unit").ExprUnit<string>;
-      email: import("../../src/expr/expr-unit").ExprUnit<string | undefined>;
-    };
-    type Result = UnwrapQueryableRecord<Input>;
-
-    expectTypeOf<Result>().toEqualTypeOf<{
-      id: number;
-      name: string;
-      email: string | undefined;
-    }>();
-
-    expect(true).toBe(true);
-  });
-
-  it("NullableQueryableRecord wraps primitives with | undefined", () => {
-    // Type-only test — verified by pnpm typecheck
-    type TestData = { name: string; age: number | undefined };
-    type Result = NullableQueryableRecord<TestData>;
-
-    // All primitives get | undefined in NullableQueryableRecord
-    expectTypeOf<Result["name"]>().toMatchTypeOf<{ $infer: string | undefined }>();
-    expectTypeOf<Result["age"]>().toMatchTypeOf<{ $infer: number | undefined }>();
-
-    expect(true).toBe(true);
-  });
-});

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

@@ -1,143 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { parseQueryResult } from "../../src/utils/result-parser";
-import type { ResultMeta } from "../../src/types/db";
-
-/**
- * Performance benchmark tests
- *
- * Purpose: measure optimization effect of removing objClone
- * Metrics:
- * - processing time for large simple records
- * - processing time for large JOIN records
- * - processing time for nested JOIN records
- */
-describe("result-parser performance", () => {
-  // test data generation helpers
-  function generateSimpleRecords(count: number): Record<string, unknown>[] {
-    return Array.from({ length: count }, (_, i) => ({
-      id: String(i + 1),
-      name: `User${i + 1}`,
-      email: `user${i + 1}@example.com`,
-      age: String(20 + (i % 50)),
-      active: i % 2,
-    }));
-  }
-
-  function generateJoinRecords(userCount: number, postsPerUser: number): Record<string, unknown>[] {
-    const records: Record<string, unknown>[] = [];
-    for (let u = 0; u < userCount; u++) {
-      for (let p = 0; p < postsPerUser; p++) {
-        records.push({
-          "id": String(u + 1),
-          "name": `User${u + 1}`,
-          "posts.id": String(u * postsPerUser + p + 1),
-          "posts.title": `Post${p + 1} by User${u + 1}`,
-          "posts.content": `Content of post ${p + 1}`,
-        });
-      }
-    }
-    return records;
-  }
-
-  function generateNestedJoinRecords(
-    userCount: number,
-    postsPerUser: number,
-    commentsPerPost: number,
-  ): Record<string, unknown>[] {
-    const records: Record<string, unknown>[] = [];
-    for (let u = 0; u < userCount; u++) {
-      for (let p = 0; p < postsPerUser; p++) {
-        for (let c = 0; c < commentsPerPost; c++) {
-          records.push({
-            "id": String(u + 1),
-            "name": `User${u + 1}`,
-            "posts.id": String(u * postsPerUser + p + 1),
-            "posts.title": `Post${p + 1}`,
-            "posts.comments.id": String((u * postsPerUser + p) * commentsPerPost + c + 1),
-            "posts.comments.text": `Comment${c + 1}`,
-          });
-        }
-      }
-    }
-    return records;
-  }
-
-  describe("simple record processing", () => {
-    it("10,000 records processing - within 500ms", async () => {
-      const raw = generateSimpleRecords(10_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(10_000);
-      expect(elapsed).toBeLessThan(500);
-      console.log(`  simple 10,000: ${elapsed.toFixed(2)}ms`);
-    });
-
-  });
-
-  describe("1-level JOIN processing", () => {
-    it("1,000 users × 10 posts = 10,000 records - within 600ms", async () => {
-      const raw = generateJoinRecords(1_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(1_000);
-      expect(elapsed).toBeLessThan(600);
-      console.log(`  JOIN 10,000 (1000×10): ${elapsed.toFixed(2)}ms`);
-    });
-
-  });
-
-  describe("2-level nested JOIN processing", () => {
-    it("100 users × 10 posts × 5 comments = 5,000 records - within 500ms", async () => {
-      const raw = generateNestedJoinRecords(100, 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(100);
-      expect(elapsed).toBeLessThan(500);
-      console.log(`  nested JOIN 5,000 (100×10×5): ${elapsed.toFixed(2)}ms`);
-    });
-
-  });
-});