@simplysm/orm-common 13.0.100 → 14.0.4

package/tests/expr/date.spec.ts

@@ -1,459 +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 "./date.expected";
-import { DateTime } from "@simplysm/core-common";
-
-describe("Expr - Date/Time functions", () => {
-  describe("year - extract year", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        yearPart: expr.year(item.createdAt),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        yearPart: {
-          type: "year",
-          arg: { type: "column", path: ["T1", "createdAt"] },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.year[dialect]);
-    });
-  });
-
-  describe("month - extract month", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        monthPart: expr.month(item.createdAt),
-      }))
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.month[dialect]);
-    });
-  });
-
-  describe("day - extract day", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        dayPart: expr.day(item.createdAt),
-      }))
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.day[dialect]);
-    });
-  });
-
-  describe("hour - extract hour", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        hourPart: expr.hour(item.createdAt),
-      }))
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.hour[dialect]);
-    });
-  });
-
-  describe("minute - extract minute", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        minutePart: expr.minute(item.createdAt),
-      }))
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.minute[dialect]);
-    });
-  });
-
-  describe("second - extract second", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        secondPart: expr.second(item.createdAt),
-      }))
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.second[dialect]);
-    });
-  });
-
-  describe("dateDiff - date difference (days)", () => {
-    const db = createTestDb();
-    const targetDate = new DateTime(2024, 1, 1);
-    const def = db
-      .user()
-      .select((item) => ({
-        daysDiff: expr.dateDiff("day", item.createdAt, targetDate),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        daysDiff: {
-          type: "dateDiff",
-          unit: "day",
-          from: { type: "column", path: ["T1", "createdAt"] },
-          to: { type: "value", value: targetDate },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.dateDiffDay[dialect]);
-    });
-  });
-
-  describe("dateDiff - date difference (years)", () => {
-    const db = createTestDb();
-    const targetDate = new DateTime(2024, 1, 1);
-    const def = db
-      .user()
-      .select((item) => ({
-        yearsDiff: expr.dateDiff("year", item.createdAt, targetDate),
-      }))
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.dateDiffYear[dialect]);
-    });
-  });
-
-  describe("dateDiff - date difference (months)", () => {
-    const db = createTestDb();
-    const targetDate = new DateTime(2024, 1, 1);
-    const def = db
-      .user()
-      .select((item) => ({
-        monthsDiff: expr.dateDiff("month", item.createdAt, targetDate),
-      }))
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.dateDiffMonth[dialect]);
-    });
-  });
-
-  describe("dateDiff - date difference (hours)", () => {
-    const db = createTestDb();
-    const targetDate = new DateTime(2024, 1, 1);
-    const def = db
-      .user()
-      .select((item) => ({
-        hoursDiff: expr.dateDiff("hour", item.createdAt, targetDate),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        hoursDiff: {
-          type: "dateDiff",
-          unit: "hour",
-          from: { type: "column", path: ["T1", "createdAt"] },
-          to: { type: "value", value: targetDate },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.dateDiffHour[dialect]);
-    });
-  });
-
-  describe("dateDiff - date difference (minutes)", () => {
-    const db = createTestDb();
-    const targetDate = new DateTime(2024, 1, 1);
-    const def = db
-      .user()
-      .select((item) => ({
-        minutesDiff: expr.dateDiff("minute", item.createdAt, targetDate),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        minutesDiff: {
-          type: "dateDiff",
-          unit: "minute",
-          from: { type: "column", path: ["T1", "createdAt"] },
-          to: { type: "value", value: targetDate },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.dateDiffMinute[dialect]);
-    });
-  });
-
-  describe("dateDiff - date difference (seconds)", () => {
-    const db = createTestDb();
-    const targetDate = new DateTime(2024, 1, 1);
-    const def = db
-      .user()
-      .select((item) => ({
-        secondsDiff: expr.dateDiff("second", item.createdAt, targetDate),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        secondsDiff: {
-          type: "dateDiff",
-          unit: "second",
-          from: { type: "column", path: ["T1", "createdAt"] },
-          to: { type: "value", value: targetDate },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.dateDiffSecond[dialect]);
-    });
-  });
-
-  describe("dateAdd - add date (months)", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        nextMonth: expr.dateAdd("month", item.createdAt, 1),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        nextMonth: {
-          type: "dateAdd",
-          unit: "month",
-          source: { type: "column", path: ["T1", "createdAt"] },
-          value: { type: "value", value: 1 },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.dateAddMonth[dialect]);
-    });
-  });
-
-  describe("dateAdd - add date (years)", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        nextYear: expr.dateAdd("year", item.createdAt, 1),
-      }))
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.dateAddYear[dialect]);
-    });
-  });
-
-  describe("dateAdd - add date (days)", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        nextWeek: expr.dateAdd("day", item.createdAt, 7),
-      }))
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.dateAddDay[dialect]);
-    });
-  });
-
-  describe("dateAdd - add date (hours)", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        twoHoursLater: expr.dateAdd("hour", item.createdAt, 2),
-      }))
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.dateAddHour[dialect]);
-    });
-  });
-
-  describe("dateAdd - add date (minutes)", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        thirtyMinLater: expr.dateAdd("minute", item.createdAt, 30),
-      }))
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.dateAddMinute[dialect]);
-    });
-  });
-
-  describe("dateAdd - add date (seconds)", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        fortyFiveSecLater: expr.dateAdd("second", item.createdAt, 45),
-      }))
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.dateAddSecond[dialect]);
-    });
-  });
-
-  describe("formatDate - date formatting", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        formatted: expr.formatDate(item.createdAt, "yyyy-MM-dd HH:mm:ss"),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        formatted: {
-          type: "formatDate",
-          source: { type: "column", path: ["T1", "createdAt"] },
-          format: "yyyy-MM-dd HH:mm:ss",
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.formatDate[dialect]);
-    });
-  });
-
-  describe("isoWeek - ISO week", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        week: expr.isoWeek(expr.cast(item.createdAt, { type: "date" })),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        week: {
-          type: "isoWeek",
-          arg: {
-            type: "cast",
-            source: { type: "column", path: ["T1", "createdAt"] },
-            targetType: { type: "date" },
-          },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.isoWeek[dialect]);
-    });
-  });
-
-  describe("isoWeekStartDate - ISO week start date", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        weekStart: expr.isoWeekStartDate(expr.cast(item.createdAt, { type: "date" })),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        weekStart: {
-          type: "isoWeekStartDate",
-          arg: {
-            type: "cast",
-            source: { type: "column", path: ["T1", "createdAt"] },
-            targetType: { type: "date" },
-          },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.isoWeekStartDate[dialect]);
-    });
-  });
-
-  describe("isoYearMonth - ISO year-month (YYYY-MM)", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        yearMonth: expr.isoYearMonth(expr.cast(item.createdAt, { type: "date" })),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        yearMonth: {
-          type: "isoYearMonth",
-          arg: {
-            type: "cast",
-            source: { type: "column", path: ["T1", "createdAt"] },
-            targetType: { type: "date" },
-          },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.isoYearMonth[dialect]);
-    });
-  });
-});

package/tests/expr/math.expected.ts

@@ -1,62 +0,0 @@
-import { mysql, pgsql, tsql } from "@simplysm/core-common";
-import type { ExpectedSql } from "../setup/test-utils";
-
-export const abs: ExpectedSql = {
-  mysql: mysql`
-    SELECT ABS(\`T1\`.\`age\`) AS \`absAge\`
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-  `,
-  mssql: tsql`
-    SELECT ABS([T1].[age]) AS [absAge]
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-  `,
-  postgresql: pgsql`
-    SELECT ABS("T1"."age") AS "absAge"
-    FROM "TestSchema"."User" AS "T1"
-  `,
-};
-
-export const round: ExpectedSql = {
-  mysql: mysql`
-    SELECT ROUND(\`T1\`.\`age\`, 2) AS \`rounded\`
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-  `,
-  mssql: tsql`
-    SELECT ROUND([T1].[age], 2) AS [rounded]
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-  `,
-  postgresql: pgsql`
-    SELECT ROUND("T1"."age", 2) AS "rounded"
-    FROM "TestSchema"."User" AS "T1"
-  `,
-};
-
-export const ceil: ExpectedSql = {
-  mysql: mysql`
-    SELECT CEIL(\`T1\`.\`age\`) AS \`ceiled\`
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-  `,
-  mssql: tsql`
-    SELECT CEILING([T1].[age]) AS [ceiled]
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-  `,
-  postgresql: pgsql`
-    SELECT CEIL("T1"."age") AS "ceiled"
-    FROM "TestSchema"."User" AS "T1"
-  `,
-};
-
-export const floor: ExpectedSql = {
-  mysql: mysql`
-    SELECT FLOOR(\`T1\`.\`age\`) AS \`floored\`
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-  `,
-  mssql: tsql`
-    SELECT FLOOR([T1].[age]) AS [floored]
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-  `,
-  postgresql: pgsql`
-    SELECT FLOOR("T1"."age") AS "floored"
-    FROM "TestSchema"."User" AS "T1"
-  `,
-};

package/tests/expr/math.spec.ts

@@ -1,59 +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 "./math.expected";
-
-describe("Expr - Math functions", () => {
-  describe("abs - absolute value", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        absAge: expr.abs(item.age),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        absAge: {
-          type: "abs",
-          arg: { type: "column", path: ["T1", "age"] },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.abs[dialect]);
-    });
-  });
-
-  describe("round - rounding", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        rounded: expr.round(item.age, 2),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        rounded: {
-          type: "round",
-          arg: { type: "column", path: ["T1", "age"] },
-          digits: 2,
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.round[dialect]);
-    });
-  });
-
-});