@simplysm/orm-common 13.0.99 → 14.0.1

package/tests/expr/conditional.expected.ts

@@ -1,134 +0,0 @@
-import { mysql, pgsql, tsql } from "@simplysm/core-common";
-import type { ExpectedSql } from "../setup/test-utils";
-
-export const coalesce: ExpectedSql = {
-  mysql: mysql`
-    SELECT COALESCE(\`T1\`.\`name\`, 'Unknown') AS \`nameOrDefault\`
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-  `,
-  mssql: tsql`
-    SELECT COALESCE([T1].[name], N'Unknown') AS [nameOrDefault]
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-  `,
-  postgresql: pgsql`
-    SELECT COALESCE("T1"."name", 'Unknown') AS "nameOrDefault"
-    FROM "TestSchema"."User" AS "T1"
-  `,
-};
-
-export const nullIf: ExpectedSql = {
-  mysql: mysql`
-    SELECT NULLIF(\`T1\`.\`age\`, 0) AS \`checkedAge\`
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-  `,
-  mssql: tsql`
-    SELECT NULLIF([T1].[age], 0) AS [checkedAge]
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-  `,
-  postgresql: pgsql`
-    SELECT NULLIF("T1"."age", 0) AS "checkedAge"
-    FROM "TestSchema"."User" AS "T1"
-  `,
-};
-
-export const ifCond: ExpectedSql = {
-  mysql: mysql`
-    SELECT IF(\`T1\`.\`isActive\` <=> TRUE, 'Active', 'Inactive') AS \`status\`
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-  `,
-  mssql: tsql`
-    SELECT CASE WHEN (([T1].[isActive] IS NULL AND 1 IS NULL) OR [T1].[isActive] = 1) THEN N'Active' ELSE N'Inactive' END AS [status]
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-  `,
-  postgresql: pgsql`
-    SELECT CASE WHEN "T1"."isActive" IS NOT DISTINCT FROM TRUE THEN 'Active' ELSE 'Inactive' END AS "status"
-    FROM "TestSchema"."User" AS "T1"
-  `,
-};
-
-export const switchCase: ExpectedSql = {
-  mysql: mysql`
-    SELECT CASE
-      WHEN \`T1\`.\`age\` < 20 THEN 'Teen'
-      WHEN \`T1\`.\`age\` < 40 THEN 'Adult'
-      ELSE 'Senior'
-    END AS \`ageGroup\`
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-  `,
-  mssql: tsql`
-    SELECT CASE
-      WHEN [T1].[age] < 20 THEN N'Teen'
-      WHEN [T1].[age] < 40 THEN N'Adult'
-      ELSE N'Senior'
-    END AS [ageGroup]
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-  `,
-  postgresql: pgsql`
-    SELECT CASE
-      WHEN "T1"."age" < 20 THEN 'Teen'
-      WHEN "T1"."age" < 40 THEN 'Adult'
-      ELSE 'Senior'
-    END AS "ageGroup"
-    FROM "TestSchema"."User" AS "T1"
-  `,
-};
-
-export const isExpr: ExpectedSql = {
-  mysql: mysql`
-    SELECT (\`T1\`.\`isActive\` <=> TRUE) AS \`isActiveFlag\`
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-  `,
-  mssql: tsql`
-    SELECT CASE WHEN (([T1].[isActive] IS NULL AND 1 IS NULL) OR [T1].[isActive] = 1) THEN 1 ELSE 0 END AS [isActiveFlag]
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-  `,
-  postgresql: pgsql`
-    SELECT ("T1"."isActive" IS NOT DISTINCT FROM TRUE)::INTEGER AS "isActiveFlag"
-    FROM "TestSchema"."User" AS "T1"
-  `,
-};
-
-export const greatest: ExpectedSql = {
-  mysql: mysql`
-    SELECT GREATEST(\`T1\`.\`age\`, 18) AS \`maxVal\`
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-  `,
-  mssql: tsql`
-    SELECT (SELECT MAX(v) FROM (VALUES ([T1].[age]), (18)) AS t(v)) AS [maxVal]
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-  `,
-  postgresql: pgsql`
-    SELECT GREATEST("T1"."age", 18) AS "maxVal"
-    FROM "TestSchema"."User" AS "T1"
-  `,
-};
-
-export const least: ExpectedSql = {
-  mysql: mysql`
-    SELECT LEAST(\`T1\`.\`age\`, 100) AS \`minVal\`
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-  `,
-  mssql: tsql`
-    SELECT (SELECT MIN(v) FROM (VALUES ([T1].[age]), (100)) AS t(v)) AS [minVal]
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-  `,
-  postgresql: pgsql`
-    SELECT LEAST("T1"."age", 100) AS "minVal"
-    FROM "TestSchema"."User" AS "T1"
-  `,
-};
-
-export const coalesceMultiple: ExpectedSql = {
-  mysql: mysql`
-    SELECT COALESCE(\`T1\`.\`email\`, \`T1\`.\`name\`, 'Anonymous') AS \`firstValid\`
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-  `,
-  mssql: tsql`
-    SELECT COALESCE([T1].[email], [T1].[name], N'Anonymous') AS [firstValid]
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-  `,
-  postgresql: pgsql`
-    SELECT COALESCE("T1"."email", "T1"."name", 'Anonymous') AS "firstValid"
-    FROM "TestSchema"."User" AS "T1"
-  `,
-};

package/tests/expr/conditional.spec.ts

@@ -1,249 +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 "./conditional.expected";
-
-describe("Expr - Conditional functions", () => {
-  describe("coalesce - null replacement", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        nameOrDefault: expr.coalesce(item.name, "Unknown"),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        nameOrDefault: {
-          type: "coalesce",
-          args: [
-            { type: "column", path: ["T1", "name"] },
-            { type: "value", value: "Unknown" },
-          ],
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.coalesce[dialect]);
-    });
-  });
-
-  describe("nullIf - null if value equals", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        checkedAge: expr.nullIf(item.age, 0),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        checkedAge: {
-          type: "nullIf",
-          source: { type: "column", path: ["T1", "age"] },
-          value: { type: "value", value: 0 },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.nullIf[dialect]);
-    });
-  });
-
-  describe("if - conditional branching", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        status: expr.if(expr.eq(item.isActive, true), "Active", "Inactive"),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        status: {
-          type: "if",
-          condition: {
-            type: "eq",
-            source: { type: "column", path: ["T1", "isActive"] },
-            target: { type: "value", value: true },
-          },
-          then: { type: "value", value: "Active" },
-          else: { type: "value", value: "Inactive" },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.ifCond[dialect]);
-    });
-  });
-
-  describe("switch - CASE WHEN", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        ageGroup: expr
-          .switch()
-          .case(expr.lt(item.age, 20), "Teen")
-          .case(expr.lt(item.age, 40), "Adult")
-          .default("Senior"),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        ageGroup: {
-          type: "switch",
-          cases: expect.arrayContaining([
-            {
-              when: {
-                type: "lt",
-                source: { type: "column", path: ["T1", "age"] },
-                target: { type: "value", value: 20 },
-              },
-              then: { type: "value", value: "Teen" },
-            },
-            {
-              when: {
-                type: "lt",
-                source: { type: "column", path: ["T1", "age"] },
-                target: { type: "value", value: 40 },
-              },
-              then: { type: "value", value: "Adult" },
-            },
-          ]),
-          else: { type: "value", value: "Senior" },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.switchCase[dialect]);
-    });
-  });
-
-  describe("is - convert condition to boolean", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        isActiveFlag: expr.is(expr.eq(item.isActive, true)),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        isActiveFlag: {
-          type: "is",
-          condition: {
-            type: "eq",
-            source: { type: "column", path: ["T1", "isActive"] },
-            target: { type: "value", value: true },
-          },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.isExpr[dialect]);
-    });
-  });
-
-  describe("greatest - maximum value", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        maxVal: expr.greatest(item.age, 18),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        maxVal: {
-          type: "greatest",
-          args: expect.arrayContaining([
-            { type: "column", path: ["T1", "age"] },
-            { type: "value", value: 18 },
-          ]),
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.greatest[dialect]);
-    });
-  });
-
-  describe("switch - all case/default are undefined", () => {
-    it("throws an error", () => {
-      const db = createTestDb();
-      expect(() => {
-        db.user()
-          .select((item) => ({
-            result: expr
-              .switch<string | undefined>()
-              .case(expr.gt(item.age, 20), undefined)
-              .default(undefined),
-          }))
-          .getSelectQueryDef();
-      }).toThrow("At least one of switch's case/default must be non-null.");
-    });
-  });
-
-  describe("if - both then and else are undefined", () => {
-    it("throws an error", () => {
-      const db = createTestDb();
-      expect(() => {
-        db.user()
-          .select((item) => ({
-            result: expr.if<string | undefined>(expr.gt(item.age, 20), undefined, undefined),
-          }))
-          .getSelectQueryDef();
-      }).toThrow("At least one of if's then/else must be non-null.");
-    });
-  });
-
-  describe("coalesce - create COALESCE with 3+ arguments", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .select((item) => ({
-        firstValid: expr.coalesce(item.email, item.name, "Anonymous"),
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def.select).toMatchObject({
-        firstValid: {
-          type: "coalesce",
-          args: [
-            { type: "column", path: ["T1", "email"] },
-            { type: "column", path: ["T1", "name"] },
-            { type: "value", value: "Anonymous" },
-          ],
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.coalesceMultiple[dialect]);
-    });
-  });
-});