@simplysm/orm-common 13.0.100 → 14.0.4

package/tests/examples/sampling.spec.ts

@@ -1,42 +0,0 @@
-/**
- * Random sampling example
- *
- * Implements random sampling using expr.random() combined with orderBy/top
- * instead of a dedicated sample() method.
- *
- * Usage: db.user().orderBy(() => expr.random()).top(5)
- */
-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";
-import * as expected from "./sampling.expected";
-
-describe("EXAMPLE - Random sampling", () => {
-  describe("Basic sampling (ORDER BY RANDOM + TOP)", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .orderBy(() => expr.random())
-      .top(5)
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "User" },
-        orderBy: [[{ type: "random" }]],
-        top: 5,
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.samplingBasic[dialect]);
-    });
-  });
-
-});

package/tests/examples/unpivot.expected.ts

@@ -1,120 +0,0 @@
-import { mysql, pgsql, tsql } from "@simplysm/core-common";
-import type { ExpectedSql } from "../setup/test-utils";
-
-//#region ========== UNPIVOT - Basic ==========
-
-export const unpivotBasic: ExpectedSql = {
-  mysql: mysql`
-SELECT \`T1\`.\`id\` AS \`id\`, \`T1\`.\`category\` AS \`category\`,
-  \`T1.unpvt\`.\`month\` AS \`month\`, \`T1.unpvt\`.\`amount\` AS \`amount\`
-FROM \`TestDb\`.\`MonthlySales\` AS \`T1\`
-LEFT OUTER JOIN LATERAL (
-  SELECT 'jan' AS \`month\`, \`T1\`.\`jan\` AS \`amount\`
-  UNION ALL
-  SELECT 'feb' AS \`month\`, \`T1\`.\`feb\` AS \`amount\`
-  UNION ALL
-  SELECT 'mar' AS \`month\`, \`T1\`.\`mar\` AS \`amount\`
-) AS \`T1.unpvt\` ON TRUE
-  `,
-  mssql: tsql`
-SELECT [T1].[id] AS [id], [T1].[category] AS [category],
-  [T1.unpvt].[month] AS [month], [T1.unpvt].[amount] AS [amount]
-FROM [TestDb].[TestSchema].[MonthlySales] AS [T1]
-OUTER APPLY (
-  SELECT N'jan' AS [month], [T1].[jan] AS [amount]
-  UNION ALL
-  SELECT N'feb' AS [month], [T1].[feb] AS [amount]
-  UNION ALL
-  SELECT N'mar' AS [month], [T1].[mar] AS [amount]
-) AS [T1.unpvt]
-  `,
-  postgresql: pgsql`
-SELECT "T1"."id" AS "id", "T1"."category" AS "category",
-  "T1.unpvt"."month" AS "month", "T1.unpvt"."amount" AS "amount"
-FROM "TestSchema"."MonthlySales" AS "T1"
-LEFT OUTER JOIN LATERAL (
-  SELECT 'jan' AS "month", "T1"."jan" AS "amount"
-  UNION ALL
-  SELECT 'feb' AS "month", "T1"."feb" AS "amount"
-  UNION ALL
-  SELECT 'mar' AS "month", "T1"."mar" AS "amount"
-) AS "T1.unpvt" ON TRUE
-  `,
-};
-
-export const unpivotTwoColumns: ExpectedSql = {
-  mysql: mysql`
-SELECT \`T1\`.\`id\` AS \`id\`, \`T1\`.\`category\` AS \`category\`, \`T1\`.\`mar\` AS \`mar\`,
-  \`T1.unpvt\`.\`period\` AS \`period\`, \`T1.unpvt\`.\`value\` AS \`value\`
-FROM \`TestDb\`.\`MonthlySales\` AS \`T1\`
-LEFT OUTER JOIN LATERAL (
-  SELECT 'jan' AS \`period\`, \`T1\`.\`jan\` AS \`value\`
-  UNION ALL
-  SELECT 'feb' AS \`period\`, \`T1\`.\`feb\` AS \`value\`
-) AS \`T1.unpvt\` ON TRUE
-  `,
-  mssql: tsql`
-SELECT [T1].[id] AS [id], [T1].[category] AS [category], [T1].[mar] AS [mar],
-  [T1.unpvt].[period] AS [period], [T1.unpvt].[value] AS [value]
-FROM [TestDb].[TestSchema].[MonthlySales] AS [T1]
-OUTER APPLY (
-  SELECT N'jan' AS [period], [T1].[jan] AS [value]
-  UNION ALL
-  SELECT N'feb' AS [period], [T1].[feb] AS [value]
-) AS [T1.unpvt]
-  `,
-  postgresql: pgsql`
-SELECT "T1"."id" AS "id", "T1"."category" AS "category", "T1"."mar" AS "mar",
-  "T1.unpvt"."period" AS "period", "T1.unpvt"."value" AS "value"
-FROM "TestSchema"."MonthlySales" AS "T1"
-LEFT OUTER JOIN LATERAL (
-  SELECT 'jan' AS "period", "T1"."jan" AS "value"
-  UNION ALL
-  SELECT 'feb' AS "period", "T1"."feb" AS "value"
-) AS "T1.unpvt" ON TRUE
-  `,
-};
-
-export const unpivotWithWhere: ExpectedSql = {
-  mysql: mysql`
-SELECT \`T1\`.\`id\` AS \`id\`, \`T1\`.\`category\` AS \`category\`,
-  \`T1.unpvt\`.\`month\` AS \`month\`, \`T1.unpvt\`.\`amount\` AS \`amount\`
-FROM \`TestDb\`.\`MonthlySales\` AS \`T1\`
-LEFT OUTER JOIN LATERAL (
-  SELECT 'jan' AS \`month\`, \`T1\`.\`jan\` AS \`amount\`
-  UNION ALL
-  SELECT 'feb' AS \`month\`, \`T1\`.\`feb\` AS \`amount\`
-  UNION ALL
-  SELECT 'mar' AS \`month\`, \`T1\`.\`mar\` AS \`amount\`
-) AS \`T1.unpvt\` ON TRUE
-WHERE \`T1\`.\`category\`<=>'A'
-  `,
-  mssql: tsql`
-SELECT [T1].[id] AS [id], [T1].[category] AS [category],
-  [T1.unpvt].[month] AS [month], [T1.unpvt].[amount] AS [amount]
-FROM [TestDb].[TestSchema].[MonthlySales] AS [T1]
-OUTER APPLY (
-  SELECT N'jan' AS [month], [T1].[jan] AS [amount]
-  UNION ALL
-  SELECT N'feb' AS [month], [T1].[feb] AS [amount]
-  UNION ALL
-  SELECT N'mar' AS [month], [T1].[mar] AS [amount]
-) AS [T1.unpvt]
-WHERE (([T1].[category] IS NULL AND N'A' IS NULL) OR [T1].[category] = N'A')
-  `,
-  postgresql: pgsql`
-SELECT "T1"."id" AS "id", "T1"."category" AS "category",
-  "T1.unpvt"."month" AS "month", "T1.unpvt"."amount" AS "amount"
-FROM "TestSchema"."MonthlySales" AS "T1"
-LEFT OUTER JOIN LATERAL (
-  SELECT 'jan' AS "month", "T1"."jan" AS "amount"
-  UNION ALL
-  SELECT 'feb' AS "month", "T1"."feb" AS "amount"
-  UNION ALL
-  SELECT 'mar' AS "month", "T1"."mar" AS "amount"
-) AS "T1.unpvt" ON TRUE
-WHERE "T1"."category" IS NOT DISTINCT FROM 'A'
-  `,
-};
-
-//#endregion

package/tests/examples/unpivot.spec.ts

@@ -1,161 +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";
-import * as expected from "./unpivot.expected";
-
-describe("SELECT - UNPIVOT (join + union)", () => {
-  describe("Basic", () => {
-    const db = createTestDb();
-    const def = db
-      .monthlySales()
-      .join("unpvt", (qr, c) =>
-        qr.union(
-          qr.select({ month: expr.val("string", "jan"), amount: c.jan }),
-          qr.select({ month: expr.val("string", "feb"), amount: c.feb }),
-          qr.select({ month: expr.val("string", "mar"), amount: c.mar }),
-        ),
-      )
-      .select((item) => ({
-        id: item.id,
-        category: item.category,
-        month: item.unpvt![0].month,
-        amount: item.unpvt![0].amount,
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "MonthlySales" },
-        select: {
-          id: { type: "column", path: ["T1", "id"] },
-          category: { type: "column", path: ["T1", "category"] },
-          month: { type: "column", path: ["T1.unpvt", "month"] },
-          amount: { type: "column", path: ["T1.unpvt", "amount"] },
-        },
-        joins: [
-          {
-            type: "select",
-            as: "T1.unpvt",
-            from: [
-              {
-                type: "select",
-                as: "T1.unpvt",
-                select: {
-                  month: { type: "value", value: "jan" },
-                  amount: { type: "column", path: ["T1", "jan"] },
-                },
-              },
-              {
-                type: "select",
-                as: "T1.unpvt",
-                select: {
-                  month: { type: "value", value: "feb" },
-                  amount: { type: "column", path: ["T1", "feb"] },
-                },
-              },
-              {
-                type: "select",
-                as: "T1.unpvt",
-                select: {
-                  month: { type: "value", value: "mar" },
-                  amount: { type: "column", path: ["T1", "mar"] },
-                },
-              },
-            ],
-            isSingle: false,
-          },
-        ],
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.unpivotBasic[dialect]);
-    });
-  });
-
-  describe("WHERE -> UNPIVOT", () => {
-    const db = createTestDb();
-    const def = db
-      .monthlySales()
-      .where((r) => [expr.eq(r.category, "A")])
-      .join("unpvt", (qr, c) =>
-        qr.union(
-          qr.select({ month: expr.val("string", "jan"), amount: c.jan }),
-          qr.select({ month: expr.val("string", "feb"), amount: c.feb }),
-          qr.select({ month: expr.val("string", "mar"), amount: c.mar }),
-        ),
-      )
-      .select((item) => ({
-        id: item.id,
-        category: item.category,
-        month: item.unpvt![0].month,
-        amount: item.unpvt![0].amount,
-      }))
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "MonthlySales" },
-        where: [
-          {
-            type: "eq",
-            source: { type: "column", path: ["T1", "category"] },
-            target: { type: "value", value: "A" },
-          },
-        ],
-        select: {
-          id: { type: "column", path: ["T1", "id"] },
-          category: { type: "column", path: ["T1", "category"] },
-          month: { type: "column", path: ["T1.unpvt", "month"] },
-          amount: { type: "column", path: ["T1.unpvt", "amount"] },
-        },
-        joins: [
-          {
-            type: "select",
-            as: "T1.unpvt",
-            from: [
-              {
-                type: "select",
-                as: "T1.unpvt",
-                select: {
-                  month: { type: "value", value: "jan" },
-                  amount: { type: "column", path: ["T1", "jan"] },
-                },
-              },
-              {
-                type: "select",
-                as: "T1.unpvt",
-                select: {
-                  month: { type: "value", value: "feb" },
-                  amount: { type: "column", path: ["T1", "feb"] },
-                },
-              },
-              {
-                type: "select",
-                as: "T1.unpvt",
-                select: {
-                  month: { type: "value", value: "mar" },
-                  amount: { type: "column", path: ["T1", "mar"] },
-                },
-              },
-            ],
-            isSingle: false,
-          },
-        ],
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.unpivotWithWhere[dialect]);
-    });
-  });
-});

package/tests/exec/search-parser.spec.ts

@@ -1,267 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { parseSearchQuery } from "../../src/exec/search-parser";
-
-describe("parseSearchQuery", () => {
-  //#region ========== Basic behavior ==========
-
-  describe("Basic behavior", () => {
-    it("Empty string → empty result", () => {
-      expect(parseSearchQuery("")).toEqual({ or: [], must: [], not: [] });
-      expect(parseSearchQuery("   ")).toEqual({ or: [], must: [], not: [] });
-    });
-
-    it("Single word → add LIKE pattern to or array", () => {
-      expect(parseSearchQuery("Apple")).toEqual({
-        or: ["%Apple%"],
-        must: [],
-        not: [],
-      });
-    });
-
-    it("Multiple words (space separated) → OR condition", () => {
-      expect(parseSearchQuery("사과 바나나")).toEqual({
-        or: ["%사과%", "%바나나%"],
-        must: [],
-        not: [],
-      });
-    });
-  });
-
-  //#endregion
-
-  //#region ========== Prefixes ==========
-
-  describe("Prefixes", () => {
-    it("+ prefix → must (AND condition)", () => {
-      expect(parseSearchQuery("+사과")).toEqual({
-        or: [],
-        must: ["%사과%"],
-        not: [],
-      });
-    });
-
-    it("- prefix → not (NOT condition)", () => {
-      expect(parseSearchQuery("-바나나")).toEqual({
-        or: [],
-        must: [],
-        not: ["%바나나%"],
-      });
-    });
-
-    it("Mixed prefixes", () => {
-      expect(parseSearchQuery("사과 +딸기 -바나나")).toEqual({
-        or: ["%사과%"],
-        must: ["%딸기%"],
-        not: ["%바나나%"],
-      });
-    });
-
-    it("Ignore when only prefixes present", () => {
-      expect(parseSearchQuery("+ - ")).toEqual({ or: [], must: [], not: [] });
-      expect(parseSearchQuery("+ 사과")).toEqual({ or: ["%사과%"], must: [], not: [] });
-    });
-
-    it("Consecutive prefixes", () => {
-      // First prefix is processed, remaining are included as literal
-      expect(parseSearchQuery("++term")).toEqual({
-        or: [],
-        must: ["%+term%"], // + prefix processed, "+term" remains as literal including +
-        not: [],
-      });
-      expect(parseSearchQuery("--word")).toEqual({
-        or: [],
-        must: [],
-        not: ["%-word%"], // - prefix processed, "-word" remains as literal including -
-      });
-    });
-  });
-
-  //#endregion
-
-  //#region ========== Quotes ==========
-
-  describe("Quotes", () => {
-    it("Quoted phrase → must (exact match)", () => {
-      expect(parseSearchQuery('"Delicious Fruit"')).toEqual({
-        or: [],
-        must: ["%Delicious Fruit%"],
-        not: [],
-      });
-    });
-
-    it("+quote → must", () => {
-      expect(parseSearchQuery('+"Delicious Fruit"')).toEqual({
-        or: [],
-        must: ["%Delicious Fruit%"],
-        not: [],
-      });
-    });
-
-    it("-quote → not", () => {
-      expect(parseSearchQuery('-"Delicious Fruit"')).toEqual({
-        or: [],
-        must: [],
-        not: ["%Delicious Fruit%"],
-      });
-    });
-
-    it("Ignore empty quotes", () => {
-      expect(parseSearchQuery('""')).toEqual({ or: [], must: [], not: [] });
-      expect(parseSearchQuery('"  "')).toEqual({ or: [], must: [], not: [] });
-    });
-
-    it("Mix quotes and regular words", () => {
-      expect(parseSearchQuery('사과 "Delicious Fruit" 바나나')).toEqual({
-        or: ["%사과%", "%바나나%"],
-        must: ["%Delicious Fruit%"],
-        not: [],
-      });
-    });
-  });
-
-  //#endregion
-
-  //#region ========== Wildcards ==========
-
-  describe("Wildcards", () => {
-    it("* at start → search by suffix", () => {
-      expect(parseSearchQuery("*사과")).toEqual({
-        or: ["%사과"],
-        must: [],
-        not: [],
-      });
-    });
-
-    it("* at end → search by prefix", () => {
-      expect(parseSearchQuery("사과*")).toEqual({
-        or: ["사과%"],
-        must: [],
-        not: [],
-      });
-    });
-
-    it("* in middle → middle wildcard", () => {
-      expect(parseSearchQuery("사*과")).toEqual({
-        or: ["사%과"],
-        must: [],
-        not: [],
-      });
-    });
-  });
-
-  //#endregion
-
-  //#region ========== Escaping ==========
-
-  describe("Escaping", () => {
-    it("\\* → literal *", () => {
-      expect(parseSearchQuery("app\\*test")).toEqual({
-        or: ["%app*test%"],
-        must: [],
-        not: [],
-      });
-    });
-
-    it("\\% → SQL LIKE \\%", () => {
-      expect(parseSearchQuery("100\\%")).toEqual({
-        or: ["%100\\%%"],
-        must: [],
-        not: [],
-      });
-    });
-
-    it('\\" → literal "', () => {
-      expect(parseSearchQuery('\\"test\\"')).toEqual({
-        or: ['%"test"%'],
-        must: [],
-        not: [],
-      });
-    });
-
-    it("\\+ → literal + (not prefix)", () => {
-      expect(parseSearchQuery("\\+positive")).toEqual({
-        or: ["%+positive%"],
-        must: [],
-        not: [],
-      });
-    });
-
-    it("\\- → literal - (not prefix)", () => {
-      expect(parseSearchQuery("\\-negative")).toEqual({
-        or: ["%-negative%"],
-        must: [],
-        not: [],
-      });
-    });
-
-    it("\\\\ → literal \\", () => {
-      expect(parseSearchQuery("path\\\\to\\\\file")).toEqual({
-        or: ["%path\\\\to\\\\file%"],
-        must: [],
-        not: [],
-      });
-    });
-  });
-
-  //#endregion
-
-  //#region ========== SQL special characters ==========
-
-  describe("SQL special character escaping", () => {
-    it("_ → \\_ (SQL LIKE escape)", () => {
-      expect(parseSearchQuery("file_name")).toEqual({
-        or: ["%file\\_name%"],
-        must: [],
-        not: [],
-      });
-    });
-
-    it("% → \\% (SQL LIKE escape)", () => {
-      expect(parseSearchQuery("100%")).toEqual({
-        or: ["%100\\%%"],
-        must: [],
-        not: [],
-      });
-    });
-
-    it("[ → \\[ (SQL LIKE escape)", () => {
-      expect(parseSearchQuery("array[0]")).toEqual({
-        or: ["%array\\[0]%"],
-        must: [],
-        not: [],
-      });
-    });
-  });
-
-  //#endregion
-
-  //#region ========== Complex search ==========
-
-  describe("Complex search", () => {
-    it("TSDoc example: normal + quote + exclude + required", () => {
-      expect(parseSearchQuery('사과 "Delicious Fruit" -바나나 +딸기')).toEqual({
-        or: ["%사과%"],
-        must: ["%Delicious Fruit%", "%딸기%"],
-        not: ["%바나나%"],
-      });
-    });
-
-    it("Mix wildcards and regular words", () => {
-      expect(parseSearchQuery("app* test")).toEqual({
-        or: ["app%", "%test%"],
-        must: [],
-        not: [],
-      });
-    });
-
-    it("Mix all elements", () => {
-      expect(parseSearchQuery('*start end* +must -not "exact phrase"')).toEqual({
-        or: ["%start", "end%"],
-        must: ["%exact phrase%", "%must%"],
-        not: ["%not%"],
-      });
-    });
-  });
-
-  //#endregion
-});

package/tests/executable/basic.expected.ts

@@ -1,18 +0,0 @@
-import { mysql, pgsql, tsql } from "@simplysm/core-common";
-import type { ExpectedSql } from "../setup/test-utils";
-
-//#region ========== Procedure Execution ==========
-
-export const execProcNoParams: ExpectedSql = {
-  mysql: mysql`CALL \`TestDb\`.\`GetUserById\`()`,
-  mssql: tsql`EXEC [TestDb].[TestSchema].[GetUserById]`,
-  postgresql: pgsql`SELECT "TestSchema"."GetUserById"()`,
-};
-
-export const execProcWithParams: ExpectedSql = {
-  mysql: mysql`CALL \`TestDb\`.\`GetUserById\`(123)`,
-  mssql: tsql`EXEC [TestDb].[TestSchema].[GetUserById] 123`,
-  postgresql: pgsql`SELECT "TestSchema"."GetUserById"(123)`,
-};
-
-//#endregion

package/tests/executable/basic.spec.ts

@@ -1,54 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createTestDb } from "../setup/TestDbContext";
-import { createQueryBuilder } from "../../src/query-builder/query-builder";
-import { dialects } from "../setup/test-utils";
-import "../setup/test-utils";
-import * as expected from "./basic.expected";
-
-describe("Executable - Basic", () => {
-  describe("getExecProcQueryDef - without parameters", () => {
-    const db = createTestDb();
-    const def = db.getUserById().getExecProcQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "execProc",
-        procedure: {
-          database: "TestDb",
-          schema: "TestSchema",
-          name: "GetUserById",
-        },
-        params: undefined,
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.execProcNoParams[dialect]);
-    });
-  });
-
-  describe("getExecProcQueryDef - with parameters", () => {
-    const db = createTestDb();
-    const def = db.getUserById().getExecProcQueryDef({ userId: 123 });
-
-    it("Verify QueryDef", () => {
-      expect(def).toEqual({
-        type: "execProc",
-        procedure: {
-          database: "TestDb",
-          schema: "TestSchema",
-          name: "GetUserById",
-        },
-        params: {
-          userId: { type: "value", value: 123 },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.execProcWithParams[dialect]);
-    });
-  });
-});