@simplysm/orm-common 13.0.99 → 14.0.1

package/tests/select/window.spec.ts

@@ -1,433 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createTestDb } from "../setup/TestDbContext";
-import { expr } from "../../src/expr/expr";
-import { createQueryBuilder } from "../../src/query-builder/query-builder";
-import { dialects } from "../setup/test-utils";
-import "../setup/test-utils"; // toMatchSql matcher
-import * as expected from "./window.expected";
-
-describe("SELECT - Window Functions", () => {
-  describe("ROW_NUMBER: Department salary ranking", () => {
-    const db = createTestDb();
-    const def = db
-      .employee()
-      .select((e) => ({
-        id: e.id,
-        name: e.name,
-        departmentId: e.departmentId,
-        rowNum: expr.rowNumber({ partitionBy: [e.departmentId], orderBy: [[e.id, "ASC"]] }),
-      }))
-      .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"] },
-          departmentId: { type: "column", path: ["T1", "departmentId"] },
-          rowNum: {
-            type: "window",
-            fn: { type: "rowNumber" },
-            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.rowNumber[dialect]);
-    });
-  });
-
-  describe("RANK: Overall score ranking (skip on tie)", () => {
-    const db = createTestDb();
-    const def = db
-      .employee()
-      .select((e) => ({
-        id: e.id,
-        name: e.name,
-        rank: expr.rank({ orderBy: [[e.id, "DESC"]] }),
-      }))
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.rank[dialect]);
-    });
-  });
-
-  describe("DENSE_RANK: Overall score ranking (consecutive on tie)", () => {
-    const db = createTestDb();
-    const def = db
-      .employee()
-      .select((e) => ({
-        id: e.id,
-        denseRank: expr.denseRank({ orderBy: [[e.id, "DESC"]] }),
-      }))
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.denseRank[dialect]);
-    });
-  });
-
-  describe("NTILE: Divide into quartiles", () => {
-    const db = createTestDb();
-    const def = db
-      .employee()
-      .select((e) => ({
-        id: e.id,
-        quartile: expr.ntile(4, { orderBy: [[e.id, "DESC"]] }),
-      }))
-      .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"] },
-          quartile: {
-            type: "window",
-            fn: { type: "ntile", n: 4 },
-            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.ntile[dialect]);
-    });
-  });
-
-  describe("LAG: Get previous row value", () => {
-    const db = createTestDb();
-    const def = db
-      .employee()
-      .select((e) => ({
-        id: e.id,
-        name: e.name,
-        prevId: expr.lag(
-          e.id,
-          { partitionBy: [e.departmentId], orderBy: [[e.id, "ASC"]] },
-          { offset: 1 },
-        ),
-      }))
-      .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"] },
-          prevId: {
-            type: "window",
-            fn: {
-              type: "lag",
-              column: { type: "column", path: ["T1", "id"] },
-              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.lag[dialect]);
-    });
-  });
-
-  describe("LEAD: Get next row value", () => {
-    const db = createTestDb();
-    const def = db
-      .employee()
-      .select((e) => ({
-        id: e.id,
-        nextId: expr.lead(e.id, { orderBy: [[e.id, "ASC"]] }, { offset: 1 }),
-      }))
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.lead[dialect]);
-    });
-  });
-
-  describe("LAG with default: Default value when no previous row", () => {
-    const db = createTestDb();
-    const def = db
-      .employee()
-      .select((e) => ({
-        id: e.id,
-        prevId: expr.lag(e.id, { orderBy: [[e.id, "ASC"]] }, { offset: 1, default: 0 }),
-      }))
-      .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"] },
-          prevId: {
-            type: "window",
-            fn: {
-              type: "lag",
-              column: { type: "column", path: ["T1", "id"] },
-              offset: 1,
-              default: { type: "value", value: 0 },
-            },
-            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.lagWithDefault[dialect]);
-    });
-  });
-
-  describe("LEAD with default: Default value when no next row", () => {
-    const db = createTestDb();
-    const def = db
-      .employee()
-      .select((e) => ({
-        id: e.id,
-        nextId: expr.lead(e.id, { orderBy: [[e.id, "ASC"]] }, { offset: 1, default: -1 }),
-      }))
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.leadWithDefault[dialect]);
-    });
-  });
-
-  describe("SUM OVER: Cumulative sum", () => {
-    const db = createTestDb();
-    const def = db
-      .employee()
-      .select((e) => ({
-        id: e.id,
-        runningTotal: expr.sumOver(e.id, {
-          partitionBy: [e.departmentId],
-          orderBy: [[e.id, "ASC"]],
-        }),
-      }))
-      .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"] },
-          runningTotal: {
-            type: "window",
-            fn: {
-              type: "sum",
-              column: { type: "column", path: ["T1", "id"] },
-            },
-            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.sumOver[dialect]);
-    });
-  });
-
-  describe("AVG OVER: moving average", () => {
-    const db = createTestDb();
-    const def = db
-      .employee()
-      .select((e) => ({
-        id: e.id,
-        avgId: expr.avgOver(e.id, { partitionBy: [e.departmentId] }),
-      }))
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.avgOver[dialect]);
-    });
-  });
-
-  describe("COUNT OVER: count within partition", () => {
-    const db = createTestDb();
-    const def = db
-      .employee()
-      .select((e) => ({
-        id: e.id,
-        deptCount: expr.countOver({ partitionBy: [e.departmentId] }),
-      }))
-      .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"] },
-          deptCount: {
-            type: "window",
-            fn: { type: "count" },
-            spec: {
-              partitionBy: [{ type: "column", path: ["T1", "departmentId"] }],
-            },
-          },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.countOver[dialect]);
-    });
-  });
-
-  describe("FIRST_VALUE / LAST_VALUE", () => {
-    const db = createTestDb();
-    const def = db
-      .employee()
-      .select((e) => ({
-        id: e.id,
-        firstInDept: expr.firstValue(e.name, {
-          partitionBy: [e.departmentId],
-          orderBy: [[e.id, "ASC"]],
-        }),
-        lastInDept: expr.lastValue(e.name, {
-          partitionBy: [e.departmentId],
-          orderBy: [[e.id, "ASC"]],
-        }),
-      }))
-      .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"] },
-          firstInDept: {
-            type: "window",
-            fn: {
-              type: "firstValue",
-              column: { type: "column", path: ["T1", "name"] },
-            },
-            spec: {
-              partitionBy: [{ type: "column", path: ["T1", "departmentId"] }],
-              orderBy: [[{ type: "column", path: ["T1", "id"] }, "ASC"]],
-            },
-          },
-          lastInDept: {
-            type: "window",
-            fn: {
-              type: "lastValue",
-              column: { type: "column", path: ["T1", "name"] },
-            },
-            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.firstLastValue[dialect]);
-    });
-  });
-
-  describe("multiple window function combinations", () => {
-    const db = createTestDb();
-    const def = db
-      .employee()
-      .select((e) => ({
-        id: e.id,
-        name: e.name,
-        rowNum: expr.rowNumber({ partitionBy: [e.departmentId], orderBy: [[e.id, "ASC"]] }),
-        rank: expr.rank({ partitionBy: [e.departmentId], orderBy: [[e.id, "DESC"]] }),
-        prevName: expr.lag(
-          e.name,
-          { partitionBy: [e.departmentId], orderBy: [[e.id, "ASC"]] },
-          { offset: 1 },
-        ),
-      }))
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.combined[dialect]);
-    });
-  });
-
-  describe("MIN OVER: min ID per department", () => {
-    const db = createTestDb();
-    const def = db
-      .employee()
-      .select((e) => ({
-        id: e.id,
-        minId: expr.minOver(e.id, { partitionBy: [e.departmentId] }),
-      }))
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.minOver[dialect]);
-    });
-  });
-
-  describe("MAX OVER: max ID per department", () => {
-    const db = createTestDb();
-    const def = db
-      .employee()
-      .select((e) => ({
-        id: e.id,
-        maxId: expr.maxOver(e.id, { partitionBy: [e.departmentId] }),
-      }))
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.maxOver[dialect]);
-    });
-  });
-});

package/tests/setup/MockExecutor.ts

@@ -1,18 +0,0 @@
-import type { DbContextExecutor, ResultMeta } from "../../src/types/db";
-import type { QueryDef } from "../../src/types/query-def";
-
-export class MockExecutor implements DbContextExecutor {
-  // connection management (Mock - no-op)
-  async connect(): Promise<void> {}
-  async close(): Promise<void> {}
-
-  // transactions (Mock - no-op)
-  async beginTransaction(): Promise<void> {}
-  async commitTransaction(): Promise<void> {}
-  async rollbackTransaction(): Promise<void> {}
-
-  // query execution
-  executeDefs(_defs: QueryDef[], _resultMetas?: (ResultMeta | undefined)[]): Promise<any[][]> {
-    return Promise.resolve([[]]);
-  }
-}

package/tests/setup/TestDbContext.ts

@@ -1,59 +0,0 @@
-import "@simplysm/core-common";
-import type { DbContextInstance } from "../../src/types/db-context-def";
-import { defineDbContext } from "../../src/define-db-context";
-import { createDbContext } from "../../src/create-db-context";
-import { Post } from "./models/Post";
-import { Company } from "./models/Company";
-import { Sales } from "./models/Sales";
-import { MonthlySales } from "./models/MonthlySales";
-import { Employee } from "./models/Employee";
-import { ActiveUsers } from "./views/ActiveUsers";
-import { UserSummary } from "./views/UserSummary";
-import { MockExecutor } from "./MockExecutor";
-import { User } from "./models/User";
-import { GetUserById } from "./procedure/GetUserById";
-import { GetAllUsers } from "./procedure/GetAllUsers";
-
-// Tables-only definition (used by view definitions to break circular reference)
-// eslint-disable-next-line unused-imports/no-unused-vars -- used in typeof for TestDbTablesContext type
-const TestDbTablesDef = defineDbContext({
-  tables: {
-    company: Company,
-    user: User,
-    post: Post,
-    sales: Sales,
-    monthlySales: MonthlySales,
-    employee: Employee,
-  },
-});
-
-/** Type for view definitions — references tables only, avoids circular dependency */
-export type TestDbTablesContext = DbContextInstance<typeof TestDbTablesDef>;
-
-export const TestDbDef = defineDbContext({
-  tables: {
-    company: Company,
-    user: User,
-    post: Post,
-    sales: Sales,
-    monthlySales: MonthlySales,
-    employee: Employee,
-  },
-  views: {
-    activeUsers: ActiveUsers,
-    userSummary: UserSummary,
-  },
-  procedures: {
-    getUserById: GetUserById,
-    getAllUsers: GetAllUsers,
-  },
-});
-
-export function createTestDb() {
-  return createDbContext(TestDbDef, new MockExecutor(), {
-    database: "TestDb",
-    schema: "TestSchema",
-  });
-}
-
-export type TestDbContext = ReturnType<typeof createTestDb>;

package/tests/setup/models/Company.ts

@@ -1,13 +0,0 @@
-import { Table } from "../../../src/schema/table-builder";
-import { User } from "./User";
-
-export const Company = Table("Company")
-  .columns((c) => ({
-    id: c.bigint().autoIncrement(),
-    name: c.varchar(200),
-    foundedAt: c.date().nullable(),
-  }))
-  .primaryKey("id")
-  .relations((r) => ({
-    users: r.foreignKeyTarget(() => User, "company"),
-  }));

package/tests/setup/models/Employee.ts

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

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

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

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

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

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

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

@@ -1,72 +0,0 @@
-/**
- * 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;
-  }
-}