@simplysm/orm-common 13.0.99 → 14.0.1

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

@@ -1,148 +0,0 @@
-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.getAddIndexQueryDef(
-      { database: "TestDb", schema: "TestSchema", name: "User" },
-      indexBuilder,
-    );
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addIndex",
-        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.getAddIndexQueryDef(
-      { database: "TestDb", schema: "TestSchema", name: "User" },
-      indexBuilder,
-    );
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addIndex",
-        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.getAddIndexQueryDef(
-      { database: "TestDb", schema: "TestSchema", name: "User" },
-      indexBuilder,
-    );
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addIndex",
-        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.getAddIndexQueryDef(
-      { database: "TestDb", schema: "TestSchema", name: "User" },
-      indexBuilder,
-    );
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addIndex",
-        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.getAddIndexQueryDef(
-      { database: "TestDb", schema: "TestSchema", name: "User" },
-      indexBuilder,
-    );
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addIndex",
-        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]);
-    });
-  });
-
-});

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

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

@@ -1,128 +0,0 @@
-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("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("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("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]);
-    });
-  });
-
-});

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

@@ -1,36 +0,0 @@
-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");
-  `,
-};

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

@@ -1,171 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createTestDb } from "../setup/TestDbContext";
-import { createRelationFactory } from "../../src/schema/factory/relation-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 "./relation-builder.expected";
-import { Table } from "../../src/schema/table-builder";
-
-// Test table definition
-const User = Table("User")
-  .database("TestDb")
-  .schema("TestSchema")
-  .columns((c) => ({
-    id: c.bigint(),
-    name: c.varchar(100),
-  }))
-  .primaryKey("id")
-  .relations(() => ({}));
-
-describe("DDL - Relation Builder", () => {
-  //#region ========== ForeignKeyBuilder ==========
-
-  describe("ForeignKeyBuilder - basic FK", () => {
-    const Post = Table("Post")
-      .database("TestDb")
-      .schema("TestSchema")
-      .columns((c) => ({
-        id: c.bigint(),
-        userId: c.bigint(),
-      }))
-      .primaryKey("id")
-      .relations(() => ({}));
-
-    const RelationFactory = createRelationFactory(() => Post);
-    const fkBuilder = RelationFactory.foreignKey(["userId"], () => User);
-
-    const db = createTestDb();
-    const def = db.getAddForeignKeyQueryDef(
-      { database: "TestDb", schema: "TestSchema", name: "Post" },
-      "user",
-      fkBuilder,
-    );
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addForeignKey",
-        table: { database: "TestDb", schema: "TestSchema", name: "Post" },
-        foreignKey: {
-          name: "FK_Post_user",
-          fkColumns: ["userId"],
-          targetTable: { database: "TestDb", schema: "TestSchema", name: "User" },
-          targetPkColumns: ["id"],
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.basicForeignKey[dialect]);
-    });
-  });
-
-  describe("ForeignKeyBuilder - composite FK", () => {
-    const Company = Table("Company")
-      .database("TestDb")
-      .schema("TestSchema")
-      .columns((c) => ({
-        id: c.bigint(),
-        regionId: c.int(),
-        name: c.varchar(100),
-      }))
-      .primaryKey("id", "regionId")
-      .relations(() => ({}));
-
-    const Employee = Table("Employee")
-      .database("TestDb")
-      .schema("TestSchema")
-      .columns((c) => ({
-        id: c.bigint(),
-        companyId: c.bigint(),
-        companyRegionId: c.int(),
-      }))
-      .primaryKey("id")
-      .relations(() => ({}));
-
-    const RelationFactory = createRelationFactory(() => Employee);
-    const fkBuilder = RelationFactory.foreignKey(["companyId", "companyRegionId"], () => Company);
-
-    const db = createTestDb();
-    const def = db.getAddForeignKeyQueryDef(
-      { database: "TestDb", schema: "TestSchema", name: "Employee" },
-      "company",
-      fkBuilder,
-    );
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addForeignKey",
-        table: { database: "TestDb", schema: "TestSchema", name: "Employee" },
-        foreignKey: {
-          name: "FK_Employee_company",
-          fkColumns: ["companyId", "companyRegionId"],
-          targetTable: { database: "TestDb", schema: "TestSchema", name: "Company" },
-          targetPkColumns: ["id", "regionId"],
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.compositeForeignKey[dialect]);
-    });
-  });
-
-  //#endregion
-
-  //#region ========== ForeignKeyTargetBuilder ==========
-
-  describe("ForeignKeyTargetBuilder - basic (array)", () => {
-    const Post = Table("Post")
-      .database("TestDb")
-      .schema("TestSchema")
-      .columns((c) => ({
-        id: c.bigint(),
-        userId: c.bigint(),
-      }))
-      .primaryKey("id")
-      .relations(() => ({}));
-
-    const RelationFactory = createRelationFactory(() => User);
-    const targetBuilder = RelationFactory.foreignKeyTarget(() => Post, "posts");
-
-    // ForeignKeyTargetBuilder has no QueryDef as it is a reverse relationship
-    // Only type inference testing is performed
-    it("should validate metadata", () => {
-      expect(targetBuilder.meta).toEqual({
-        targetTableFn: expect.any(Function),
-        relationName: "posts",
-        description: undefined,
-        isSingle: undefined,
-      });
-    });
-  });
-
-  describe("ForeignKeyTargetBuilder - single() method", () => {
-    const Post = Table("Post")
-      .database("TestDb")
-      .schema("TestSchema")
-      .columns((c) => ({
-        id: c.bigint(),
-        userId: c.bigint(),
-      }))
-      .primaryKey("id")
-      .relations(() => ({}));
-
-    const RelationFactory = createRelationFactory(() => User);
-    const targetBuilder = RelationFactory.foreignKeyTarget(() => Post, "primaryPost").single();
-
-    it("should validate metadata", () => {
-      expect(targetBuilder.meta).toEqual({
-        targetTableFn: expect.any(Function),
-        relationName: "primaryPost",
-        description: undefined,
-        isSingle: true,
-      });
-    });
-  });
-
-  //#endregion
-});

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

@@ -1,113 +0,0 @@
-import { mysql, pgsql, tsql } from "@simplysm/core-common";
-import type { ExpectedSql } from "../setup/test-utils";
-
-export const singlePrimaryKey: ExpectedSql = {
-  mysql: mysql`
-    CREATE TABLE \`TestDb\`.\`User\` (
-      \`id\` BIGINT NOT NULL,
-      CONSTRAINT \`PK_User\` PRIMARY KEY (\`id\`)
-    )
-  `,
-  mssql: tsql`
-    CREATE TABLE [TestDb].[TestSchema].[User] (
-      [id] BIGINT NOT NULL,
-      CONSTRAINT [PK_User] PRIMARY KEY ([id])
-    )
-  `,
-  postgresql: pgsql`
-    CREATE TABLE "TestSchema"."User" (
-      "id" BIGINT NOT NULL,
-      CONSTRAINT "PK_User" PRIMARY KEY ("id")
-    )
-  `,
-};
-
-export const compositePrimaryKey: ExpectedSql = {
-  mysql: mysql`
-    CREATE TABLE \`TestDb\`.\`Order\` (
-      \`userId\` BIGINT NOT NULL,
-      \`productId\` BIGINT NOT NULL,
-      \`quantity\` INT NOT NULL,
-      CONSTRAINT \`PK_Order\` PRIMARY KEY (\`userId\`, \`productId\`)
-    )
-  `,
-  mssql: tsql`
-    CREATE TABLE [TestDb].[TestSchema].[Order] (
-      [userId] BIGINT NOT NULL,
-      [productId] BIGINT NOT NULL,
-      [quantity] INT NOT NULL,
-      CONSTRAINT [PK_Order] PRIMARY KEY ([userId], [productId])
-    )
-  `,
-  postgresql: pgsql`
-    CREATE TABLE "TestSchema"."Order" (
-      "userId" BIGINT NOT NULL,
-      "productId" BIGINT NOT NULL,
-      "quantity" INTEGER NOT NULL,
-      CONSTRAINT "PK_Order" PRIMARY KEY ("userId", "productId")
-    )
-  `,
-};
-
-export const complexOptions1: ExpectedSql = {
-  mysql: mysql`
-    CREATE TABLE \`TestDb\`.\`User\` (
-      \`id\` BIGINT NOT NULL,
-      \`name\` VARCHAR(100) NOT NULL,
-      CONSTRAINT \`PK_User\` PRIMARY KEY (\`id\`)
-    )
-  `,
-  mssql: tsql`
-    CREATE TABLE [TestDb].[TestSchema].[User] (
-      [id] BIGINT NOT NULL,
-      [name] NVARCHAR(100) NOT NULL,
-      CONSTRAINT [PK_User] PRIMARY KEY ([id])
-    )
-  `,
-  postgresql: pgsql`
-    CREATE TABLE "TestSchema"."User" (
-      "id" BIGINT NOT NULL,
-      "name" VARCHAR(100) NOT NULL,
-      CONSTRAINT "PK_User" PRIMARY KEY ("id")
-    )
-  `,
-};
-
-export const complexOptions3: ExpectedSql = {
-  mysql: mysql`
-    CREATE TABLE \`TestDb\`.\`Product\` (
-      \`id\` BIGINT NOT NULL AUTO_INCREMENT,
-      \`name\` VARCHAR(200) NOT NULL,
-      \`price\` DECIMAL(10, 2) NOT NULL,
-      \`stock\` INT NOT NULL DEFAULT 0,
-      \`isActive\` BOOLEAN NOT NULL DEFAULT TRUE,
-      \`description\` LONGTEXT NULL,
-      \`createdAt\` DATETIME NOT NULL,
-      CONSTRAINT \`PK_Product\` PRIMARY KEY (\`id\`)
-    )
-  `,
-  mssql: tsql`
-    CREATE TABLE [TestDb].[TestSchema].[Product] (
-      [id] BIGINT NOT NULL IDENTITY(1, 1),
-      [name] NVARCHAR(200) NOT NULL,
-      [price] DECIMAL(10, 2) NOT NULL,
-      [stock] INT NOT NULL DEFAULT 0,
-      [isActive] BIT NOT NULL DEFAULT 1,
-      [description] NVARCHAR(MAX) NULL,
-      [createdAt] DATETIME2 NOT NULL,
-      CONSTRAINT [PK_Product] PRIMARY KEY ([id])
-    )
-  `,
-  postgresql: pgsql`
-    CREATE TABLE "TestSchema"."Product" (
-      "id" BIGINT NOT NULL GENERATED BY DEFAULT AS IDENTITY,
-      "name" VARCHAR(200) NOT NULL,
-      "price" NUMERIC(10, 2) NOT NULL,
-      "stock" INTEGER NOT NULL DEFAULT 0,
-      "isActive" BOOLEAN NOT NULL DEFAULT TRUE,
-      "description" TEXT NULL,
-      "createdAt" TIMESTAMP NOT NULL,
-      CONSTRAINT "PK_Product" PRIMARY KEY ("id")
-    )
-  `,
-};