@simplysm/orm-common 13.0.68 → 13.0.70

package/tests/expr/date.spec.ts

@@ -0,0 +1,526 @@
+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("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        monthPart: {
+          type: "month",
+          arg: { type: "column", path: ["T1", "createdAt"] },
+        },
+      });
+    });
+
+    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("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        dayPart: {
+          type: "day",
+          arg: { type: "column", path: ["T1", "createdAt"] },
+        },
+      });
+    });
+
+    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("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        hourPart: {
+          type: "hour",
+          arg: { type: "column", path: ["T1", "createdAt"] },
+        },
+      });
+    });
+
+    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("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        minutePart: {
+          type: "minute",
+          arg: { type: "column", path: ["T1", "createdAt"] },
+        },
+      });
+    });
+
+    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("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        secondPart: {
+          type: "second",
+          arg: { type: "column", path: ["T1", "createdAt"] },
+        },
+      });
+    });
+
+    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",
+          separator: "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("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        yearsDiff: {
+          type: "dateDiff",
+          separator: "year",
+          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.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("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        monthsDiff: {
+          type: "dateDiff",
+          separator: "month",
+          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.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",
+          separator: "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",
+          separator: "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",
+          separator: "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",
+          separator: "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

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

@@ -0,0 +1,106 @@
+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]);
+    });
+  });
+
+  describe("ceil - ceiling", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        ceiled: expr.ceil(item.age),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        ceiled: {
+          type: "ceil",
+          arg: { type: "column", path: ["T1", "age"] },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.ceil[dialect]);
+    });
+  });
+
+  describe("floor - flooring", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        floored: expr.floor(item.age),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        floored: {
+          type: "floor",
+          arg: { type: "column", path: ["T1", "age"] },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.floor[dialect]);
+    });
+  });
+});