@simplysm/orm-common 13.0.69 → 13.0.70

package/tests/ddl/index-builder.spec.ts

@@ -0,0 +1,202 @@
+import { describe, expect, it } from "vitest";
+import { createTestDb } from "../setup/TestDbContext";
+import { createIndexFactory } from "../../src/schema/factory/index-builder";
+import { createQueryBuilder } from "../../src/query-builder/query-builder";
+import { dialects } from "../setup/test-utils";
+import "../setup/test-utils"; // toMatchSql matcher
+import * as expected from "./index-builder.expected";
+
+const IndexFactory = createIndexFactory<"name" | "email" | "age">();
+
+describe("DDL - Index Builder", () => {
+  describe("IndexBuilder - single column index", () => {
+    const db = createTestDb();
+    const indexBuilder = IndexFactory.index("email");
+    const def = db.getAddIdxQueryDef(
+      { database: "TestDb", schema: "TestSchema", name: "User" },
+      indexBuilder,
+    );
+
+    it("should validate QueryDef", () => {
+      expect(def).toEqual({
+        type: "addIdx",
+        table: { database: "TestDb", schema: "TestSchema", name: "User" },
+        index: {
+          name: "IDX_User_email",
+          columns: [{ name: "email", orderBy: "ASC" }],
+          unique: undefined,
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] should validate SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.singleColumnIndex[dialect]);
+    });
+  });
+
+  describe("IndexBuilder - unique index", () => {
+    const db = createTestDb();
+    const indexBuilder = IndexFactory.index("email").unique();
+    const def = db.getAddIdxQueryDef(
+      { database: "TestDb", schema: "TestSchema", name: "User" },
+      indexBuilder,
+    );
+
+    it("should validate QueryDef", () => {
+      expect(def).toEqual({
+        type: "addIdx",
+        table: { database: "TestDb", schema: "TestSchema", name: "User" },
+        index: {
+          name: "IDX_User_email",
+          columns: [{ name: "email", orderBy: "ASC" }],
+          unique: true,
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] should validate SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.uniqueIndex[dialect]);
+    });
+  });
+
+  describe("IndexBuilder - composite index", () => {
+    const db = createTestDb();
+    const indexBuilder = IndexFactory.index("name", "email");
+    const def = db.getAddIdxQueryDef(
+      { database: "TestDb", schema: "TestSchema", name: "User" },
+      indexBuilder,
+    );
+
+    it("should validate QueryDef", () => {
+      expect(def).toEqual({
+        type: "addIdx",
+        table: { database: "TestDb", schema: "TestSchema", name: "User" },
+        index: {
+          name: "IDX_User_name_email",
+          columns: [
+            { name: "name", orderBy: "ASC" },
+            { name: "email", orderBy: "ASC" },
+          ],
+          unique: undefined,
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] should validate SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.compositeIndex[dialect]);
+    });
+  });
+
+  describe("IndexBuilder - orderBy specified", () => {
+    const db = createTestDb();
+    const indexBuilder = IndexFactory.index("name", "email").orderBy("DESC", "ASC");
+    const def = db.getAddIdxQueryDef(
+      { database: "TestDb", schema: "TestSchema", name: "User" },
+      indexBuilder,
+    );
+
+    it("should validate QueryDef", () => {
+      expect(def).toEqual({
+        type: "addIdx",
+        table: { database: "TestDb", schema: "TestSchema", name: "User" },
+        index: {
+          name: "IDX_User_name_email",
+          columns: [
+            { name: "name", orderBy: "DESC" },
+            { name: "email", orderBy: "ASC" },
+          ],
+          unique: undefined,
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] should validate SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.orderByIndex[dialect]);
+    });
+  });
+
+  describe("IndexBuilder - name specified", () => {
+    const db = createTestDb();
+    const indexBuilder = IndexFactory.index("email").name("UQ_User_email");
+    const def = db.getAddIdxQueryDef(
+      { database: "TestDb", schema: "TestSchema", name: "User" },
+      indexBuilder,
+    );
+
+    it("should validate QueryDef", () => {
+      expect(def).toEqual({
+        type: "addIdx",
+        table: { database: "TestDb", schema: "TestSchema", name: "User" },
+        index: {
+          name: "UQ_User_email",
+          columns: [{ name: "email", orderBy: "ASC" }],
+          unique: undefined,
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] should validate SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.customNameIndex[dialect]);
+    });
+  });
+
+  describe("IndexBuilder - description specified", () => {
+    const db = createTestDb();
+    const indexBuilder = IndexFactory.index("email").description("이메일 검색용 인덱스");
+    const def = db.getAddIdxQueryDef(
+      { database: "TestDb", schema: "TestSchema", name: "User" },
+      indexBuilder,
+    );
+
+    it("should validate QueryDef", () => {
+      expect(def).toEqual({
+        type: "addIdx",
+        table: { database: "TestDb", schema: "TestSchema", name: "User" },
+        index: {
+          name: "IDX_User_email",
+          columns: [{ name: "email", orderBy: "ASC" }],
+          unique: undefined,
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] should validate SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.singleColumnIndex[dialect]);
+    });
+  });
+
+  describe("IndexBuilder - combined options (unique + orderBy)", () => {
+    const db = createTestDb();
+    const indexBuilder = IndexFactory.index("name", "email").unique().orderBy("DESC", "ASC");
+    const def = db.getAddIdxQueryDef(
+      { database: "TestDb", schema: "TestSchema", name: "User" },
+      indexBuilder,
+    );
+
+    it("should validate QueryDef", () => {
+      expect(def).toEqual({
+        type: "addIdx",
+        table: { database: "TestDb", schema: "TestSchema", name: "User" },
+        index: {
+          name: "IDX_User_name_email",
+          columns: [
+            { name: "name", orderBy: "DESC" },
+            { name: "email", orderBy: "ASC" },
+          ],
+          unique: true,
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] should validate SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.uniqueOrderByIndex[dialect]);
+    });
+  });
+});

package/tests/ddl/procedure-builder.expected.ts

@@ -0,0 +1,52 @@
+import { mysql, pgsql, tsql } from "@simplysm/core-common";
+import type { ExpectedSql } from "../setup/test-utils";
+
+export const basicProc: ExpectedSql = {
+  mysql: mysql`
+    CREATE PROCEDURE \`TestDb\`.\`TestProc\`()
+    BEGIN
+    SELECT 1 AS result;
+    END
+  `,
+  mssql: tsql`
+    CREATE OR ALTER PROCEDURE [TestDb].[TestSchema].[TestProc]
+    AS
+    BEGIN
+    SET NOCOUNT ON;
+    SELECT 1 AS result
+    END
+  `,
+  postgresql: pgsql`
+    CREATE OR REPLACE FUNCTION "TestSchema"."TestProc"()
+    RETURNS VOID AS $$
+    BEGIN
+    SELECT 1 AS result;
+    END;
+    $$ LANGUAGE plpgsql
+  `,
+};
+
+export const complexProc: ExpectedSql = {
+  mysql: mysql`
+    CREATE PROCEDURE \`TestDb\`.\`GetUserById\`(IN \`userId\` BIGINT)
+    BEGIN
+    -- Write the correct query for each DBMS --;
+    END
+  `,
+  mssql: tsql`
+    CREATE OR ALTER PROCEDURE [TestDb].[TestSchema].[GetUserById] @userId BIGINT
+    AS
+    BEGIN
+    SET NOCOUNT ON;
+    -- Write the correct query for each DBMS --
+    END
+  `,
+  postgresql: pgsql`
+    CREATE OR REPLACE FUNCTION "TestSchema"."GetUserById"("userId" BIGINT)
+    RETURNS TABLE("id" BIGINT, "name" VARCHAR(100), "email" VARCHAR(200)) AS $$
+    BEGIN
+    -- Write the correct query for each DBMS --;
+    END;
+    $$ LANGUAGE plpgsql
+  `,
+};

package/tests/ddl/procedure-builder.spec.ts

@@ -0,0 +1,234 @@
+import { describe, expect, it } from "vitest";
+import { createTestDb } from "../setup/TestDbContext";
+import { Procedure } from "../../src/schema/procedure-builder";
+import { createQueryBuilder } from "../../src/query-builder/query-builder";
+import { dialects } from "../setup/test-utils";
+import "../setup/test-utils"; // toMatchSql matcher
+import * as expected from "./procedure-builder.expected";
+
+describe("DDL - Procedure Builder", () => {
+  describe("basic procedure (name only)", () => {
+    const proc = Procedure("TestProc");
+
+    it("should validate metadata", () => {
+      expect(proc.meta).toEqual({
+        name: "TestProc",
+        description: undefined,
+        database: undefined,
+        schema: undefined,
+        params: undefined,
+        returns: undefined,
+        query: undefined,
+      });
+    });
+  });
+
+  describe("description specified", () => {
+    const proc = Procedure("TestProc").description("Test procedure");
+
+    it("should validate metadata", () => {
+      expect(proc.meta).toEqual({
+        name: "TestProc",
+        description: "Test procedure",
+        database: undefined,
+        schema: undefined,
+        params: undefined,
+        returns: undefined,
+        query: undefined,
+      });
+    });
+  });
+
+  describe("database specified", () => {
+    const proc = Procedure("TestProc").database("CustomDb");
+
+    it("should validate metadata", () => {
+      expect(proc.meta).toEqual({
+        name: "TestProc",
+        description: undefined,
+        database: "CustomDb",
+        schema: undefined,
+        params: undefined,
+        returns: undefined,
+        query: undefined,
+      });
+    });
+  });
+
+  describe("schema specified", () => {
+    const proc = Procedure("TestProc").schema("CustomSchema");
+
+    it("should validate metadata", () => {
+      expect(proc.meta).toEqual({
+        name: "TestProc",
+        description: undefined,
+        database: undefined,
+        schema: "CustomSchema",
+        params: undefined,
+        returns: undefined,
+        query: undefined,
+      });
+    });
+  });
+
+  describe("params specified (single parameter)", () => {
+    const proc = Procedure("TestProc").params((c) => ({ id: c.bigint() }));
+
+    it("should validate metadata", () => {
+      expect(proc.meta.name).toBe("TestProc");
+      expect(proc.meta.params).toBeDefined();
+      expect(Object.keys(proc.meta.params!)).toEqual(["id"]);
+      expect(proc.meta.params!.id.meta.dataType).toEqual({ type: "bigint" });
+    });
+  });
+
+  describe("params specified (multiple parameters)", () => {
+    const proc = Procedure("TestProc").params((c) => ({
+      id: c.bigint(),
+      name: c.varchar(100),
+      isActive: c.boolean(),
+    }));
+
+    it("should validate metadata", () => {
+      expect(proc.meta.name).toBe("TestProc");
+      expect(proc.meta.params).toBeDefined();
+      expect(Object.keys(proc.meta.params!)).toEqual(["id", "name", "isActive"]);
+      expect(proc.meta.params!.id.meta.dataType).toEqual({ type: "bigint" });
+      expect(proc.meta.params!.name.meta.dataType).toEqual({ type: "varchar", length: 100 });
+      expect(proc.meta.params!.isActive.meta.dataType).toEqual({ type: "boolean" });
+    });
+  });
+
+  describe("returns specified (single return)", () => {
+    const proc = Procedure("TestProc").returns((c) => ({ id: c.bigint() }));
+
+    it("should validate metadata", () => {
+      expect(proc.meta.name).toBe("TestProc");
+      expect(proc.meta.returns).toBeDefined();
+      expect(Object.keys(proc.meta.returns!)).toEqual(["id"]);
+      expect(proc.meta.returns!.id.meta.dataType).toEqual({ type: "bigint" });
+    });
+  });
+
+  describe("returns specified (multiple returns)", () => {
+    const proc = Procedure("TestProc").returns((c) => ({
+      id: c.bigint(),
+      name: c.varchar(100),
+      email: c.varchar(200).nullable(),
+    }));
+
+    it("should validate metadata", () => {
+      expect(proc.meta.name).toBe("TestProc");
+      expect(proc.meta.returns).toBeDefined();
+      expect(Object.keys(proc.meta.returns!)).toEqual(["id", "name", "email"]);
+      expect(proc.meta.returns!.id.meta.dataType).toEqual({ type: "bigint" });
+      expect(proc.meta.returns!.name.meta.dataType).toEqual({ type: "varchar", length: 100 });
+      expect(proc.meta.returns!.email.meta.dataType).toEqual({ type: "varchar", length: 200 });
+      expect(proc.meta.returns!.email.meta.nullable).toBe(true);
+    });
+  });
+
+  describe("body specified + basic DDL generation", () => {
+    const proc = Procedure("TestProc")
+      .database("TestDb")
+      .schema("TestSchema")
+      .body("SELECT 1 AS result");
+
+    const db = createTestDb();
+    const def = db.getCreateProcQueryDef(proc);
+
+    it("should validate QueryDef", () => {
+      expect(def).toEqual({
+        type: "createProc",
+        procedure: { database: "TestDb", schema: "TestSchema", name: "TestProc" },
+        params: undefined,
+        returns: undefined,
+        query: "SELECT 1 AS result",
+      });
+    });
+
+    it.each(dialects)("[%s] should validate SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.basicProc[dialect]);
+    });
+  });
+
+  describe("combined options (params + returns + body)", () => {
+    const GetUserById = Procedure("GetUserById")
+      .database("TestDb")
+      .schema("TestSchema")
+      .description("Get user by ID")
+      .params((c) => ({ userId: c.bigint() }))
+      .returns((c) => ({
+        id: c.bigint(),
+        name: c.varchar(100),
+        email: c.varchar(200).nullable(),
+      }))
+      .body("-- Write the correct query for each DBMS --");
+
+    const db = createTestDb();
+    const def = db.getCreateProcQueryDef(GetUserById);
+
+    it("should validate QueryDef", () => {
+      expect(def).toEqual({
+        type: "createProc",
+        procedure: { database: "TestDb", schema: "TestSchema", name: "GetUserById" },
+        params: [
+          {
+            name: "userId",
+            dataType: { type: "bigint" },
+            nullable: undefined,
+            default: undefined,
+          },
+        ],
+        returns: [
+          {
+            name: "id",
+            dataType: { type: "bigint" },
+            nullable: undefined,
+          },
+          {
+            name: "name",
+            dataType: { type: "varchar", length: 100 },
+            nullable: undefined,
+          },
+          {
+            name: "email",
+            dataType: { type: "varchar", length: 200 },
+            nullable: true,
+          },
+        ],
+        query: "-- Write the correct query for each DBMS --",
+      });
+    });
+
+    it.each(dialects)("[%s] should validate SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.complexProc[dialect]);
+    });
+  });
+
+  describe("method chaining order", () => {
+    // Same result even with different method chaining order
+    const proc1 = Procedure("TestProc")
+      .params((c) => ({ id: c.bigint() }))
+      .database("TestDb")
+      .schema("TestSchema")
+      .body("SELECT 1");
+
+    const proc2 = Procedure("TestProc")
+      .database("TestDb")
+      .schema("TestSchema")
+      .params((c) => ({ id: c.bigint() }))
+      .body("SELECT 1");
+
+    it("should validate metadata consistency", () => {
+      // params is an object so deep comparison is needed
+      expect(proc1.meta.name).toBe(proc2.meta.name);
+      expect(proc1.meta.database).toBe(proc2.meta.database);
+      expect(proc1.meta.schema).toBe(proc2.meta.schema);
+      expect(proc1.meta.query).toBe(proc2.meta.query);
+      expect(Object.keys(proc1.meta.params!)).toEqual(Object.keys(proc2.meta.params!));
+    });
+  });
+});

package/tests/ddl/relation-builder.expected.ts

@@ -0,0 +1,36 @@
+import { mysql, pgsql, tsql } from "@simplysm/core-common";
+import type { ExpectedSql } from "../setup/test-utils";
+
+export const basicForeignKey: ExpectedSql = {
+  mysql: mysql`
+ALTER TABLE \`TestDb\`.\`Post\` ADD CONSTRAINT \`FK_Post_user\`
+FOREIGN KEY (\`userId\`) REFERENCES \`TestDb\`.\`User\` (\`id\`)
+  `,
+  mssql: tsql`
+ALTER TABLE [TestDb].[TestSchema].[Post] ADD CONSTRAINT [FK_Post_user]
+FOREIGN KEY ([userId]) REFERENCES [TestDb].[TestSchema].[User] ([id]);
+CREATE INDEX [IDX_Post_Post_user] ON [TestDb].[TestSchema].[Post] ([userId]);
+  `,
+  postgresql: pgsql`
+ALTER TABLE "TestSchema"."Post" ADD CONSTRAINT "FK_Post_user"
+FOREIGN KEY ("userId") REFERENCES "TestSchema"."User" ("id");
+CREATE INDEX "IDX_Post_Post_user" ON "TestSchema"."Post" ("userId");
+  `,
+};
+
+export const compositeForeignKey: ExpectedSql = {
+  mysql: mysql`
+ALTER TABLE \`TestDb\`.\`Employee\` ADD CONSTRAINT \`FK_Employee_company\`
+FOREIGN KEY (\`companyId\`, \`companyRegionId\`) REFERENCES \`TestDb\`.\`Company\` (\`id\`, \`regionId\`)
+  `,
+  mssql: tsql`
+ALTER TABLE [TestDb].[TestSchema].[Employee] ADD CONSTRAINT [FK_Employee_company]
+FOREIGN KEY ([companyId], [companyRegionId]) REFERENCES [TestDb].[TestSchema].[Company] ([id], [regionId]);
+CREATE INDEX [IDX_Employee_Employee_company] ON [TestDb].[TestSchema].[Employee] ([companyId], [companyRegionId]);
+  `,
+  postgresql: pgsql`
+ALTER TABLE "TestSchema"."Employee" ADD CONSTRAINT "FK_Employee_company"
+FOREIGN KEY ("companyId", "companyRegionId") REFERENCES "TestSchema"."Company" ("id", "regionId");
+CREATE INDEX "IDX_Employee_Employee_company" ON "TestSchema"."Employee" ("companyId", "companyRegionId");
+  `,
+};