@simplysm/orm-common 13.0.69 → 13.0.71

package/tests/setup/models/Employee.ts

@@ -0,0 +1,10 @@
+import { Table } from "../../../src/schema/table-builder";
+
+export const Employee = Table("Employee")
+  .columns((c) => ({
+    id: c.bigint().autoIncrement(),
+    name: c.varchar(100),
+    managerId: c.bigint().nullable(), // self-referencing (parent manager)
+    departmentId: c.bigint().nullable(),
+  }))
+  .primaryKey("id");

package/tests/setup/models/MonthlySales.ts

@@ -0,0 +1,11 @@
+import { Table } from "../../../src/schema/table-builder";
+
+export const MonthlySales = Table("MonthlySales")
+  .columns((c) => ({
+    id: c.bigint().autoIncrement(),
+    category: c.varchar(50),
+    jan: c.int(),
+    feb: c.int(),
+    mar: c.int(),
+  }))
+  .primaryKey("id");

package/tests/setup/models/Post.ts

@@ -0,0 +1,16 @@
+import { Table } from "../../../src/schema/table-builder";
+import { User } from "./User";
+
+export const Post = Table("Post")
+  .columns((c) => ({
+    id: c.bigint().autoIncrement(),
+    userId: c.bigint(),
+    title: c.varchar(300),
+    content: c.text().nullable(),
+    viewCount: c.int().default(0),
+    publishedAt: c.datetime().nullable(),
+  }))
+  .primaryKey("id")
+  .relations((r) => ({
+    user: r.foreignKey(["userId"], () => User),
+  }));

package/tests/setup/models/Sales.ts

@@ -0,0 +1,10 @@
+import { Table } from "../../../src/schema/table-builder";
+
+export const Sales = Table("Sales")
+  .columns((c) => ({
+    id: c.bigint().autoIncrement(),
+    category: c.varchar(50),
+    year: c.int(),
+    amount: c.int(),
+  }))
+  .primaryKey("id");

package/tests/setup/models/User.ts

@@ -0,0 +1,19 @@
+import { Table } from "../../../src/schema/table-builder";
+import { Post } from "./Post";
+import { Company } from "./Company";
+
+export const User = Table("User")
+  .columns((c) => ({
+    id: c.bigint().autoIncrement(),
+    name: c.varchar(100),
+    email: c.varchar(200).nullable(),
+    age: c.int().nullable(),
+    isActive: c.boolean().default(true),
+    companyId: c.bigint().nullable(),
+    createdAt: c.datetime(),
+  }))
+  .primaryKey("id")
+  .relations((r) => ({
+    company: r.foreignKey(["companyId"], () => Company),
+    posts: r.foreignKeyTarget(() => Post, "user"),
+  }));

package/tests/setup/procedure/GetAllUsers.ts

@@ -0,0 +1,9 @@
+import { Procedure } from "../../../src/schema/procedure-builder";
+
+export const GetAllUsers = Procedure("GetAllUsers")
+  .returns((c) => ({
+    id: c.bigint(),
+    name: c.varchar(100),
+    email: c.varchar(200).nullable(),
+  }))
+  .body("-- DBMSwrite matching query --");

package/tests/setup/procedure/GetUserById.ts

@@ -0,0 +1,12 @@
+import { Procedure } from "../../../src/schema/procedure-builder";
+
+export const GetUserById = Procedure("GetUserById")
+  .params((c) => ({
+    userId: c.bigint(),
+  }))
+  .returns((c) => ({
+    id: c.bigint(),
+    name: c.varchar(100),
+    email: c.varchar(200).nullable(),
+  }))
+  .body("-- DBMSwrite matching query --");

package/tests/setup/test-utils.ts

@@ -0,0 +1,72 @@
+/**
+ * Test utilities
+ * - toMatchSql matcher
+ * - dialects constant
+ * - ExpectedSql type
+ */
+import { expect } from "vitest";
+import type { Dialect, QueryBuildResult } from "../../src/types/db";
+
+// ============================================
+// Dialect list
+// ============================================
+
+export const dialects: Dialect[] = ["mysql", "mssql", "postgresql"];
+
+// ============================================
+// Expected SQL type
+// ============================================
+
+export type ExpectedSql = Record<Dialect, string>;
+
+// ============================================
+// SQL normalization (ignore whitespace/empty lines, normalize dynamic names)
+// ============================================
+
+function normalizeSql(sql: string): string {
+  return (
+    sql
+      // Completely remove all whitespace (spaces, tabs, newlines)
+      .replace(/\s+/g, "")
+      // Procedure name normalization (SD + 32-char hex) <-- now using multistatement instead of PROC
+      // .replace(/`SD[a-f0-9]{32}`/g, "`SD_PROC`")
+      // .replace(/\[#SD[a-f0-9]{32}]/g, "[#SD_PROC]")
+      // .replace(/\[SD[a-f0-9]{32}]/g, "[SD_PROC]")
+      // .replace(/"SD[a-f0-9]{32}"/g, '"SD_PROC"')
+      // Temporary table name normalization (SD_TEMP_ + 32-char hex)
+      .replace(/`SD_TEMP_[a-f0-9]{32}`/g, "`SD_TEMP`")
+      .replace(/\[SD_TEMP_[a-f0-9]{32}]/g, "[SD_TEMP]")
+      .replace(/"SD_TEMP_[a-f0-9]{32}"/g, '"SD_TEMP"')
+  );
+}
+
+// ============================================
+// Custom matcher
+// ============================================
+
+expect.extend({
+  toMatchSql(received: string | QueryBuildResult, expected: string) {
+    const sql = typeof received === "string" ? received : received.sql;
+    const normalizedReceived = normalizeSql(sql);
+    const normalizedExpected = normalizeSql(expected);
+
+    const pass = normalizedReceived === normalizedExpected;
+
+    return {
+      pass,
+      actual: normalizedReceived,
+      expected: normalizedExpected,
+      message: () => (pass ? "SQL matches" : "SQL does not match"),
+    };
+  },
+});
+
+// Type declaration
+declare module "vitest" {
+  interface Assertion<T> {
+    toMatchSql(expected: string): T;
+  }
+  interface AsymmetricMatchersContaining {
+    toMatchSql(expected: string): unknown;
+  }
+}

package/tests/setup/views/ActiveUsers.ts

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,145 @@
+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("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>;
+
+    // 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("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();
+
+    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("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 };
+    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

@@ -0,0 +1,210 @@
+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`);
+    });
+
+    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", () => {
+    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`);
+    });
+
+    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", () => {
+    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`);
+    });
+
+    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`);
+    });
+  });
+});