@simplysm/orm-common 13.0.100 → 14.0.4

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

@@ -1,399 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createTestDb } from "../setup/TestDbContext";
-import { Table } from "../../src/schema/table-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 "./table-builder.expected";
-
-describe("DDL - Table Builder", () => {
-  describe("basic table (name only)", () => {
-    const table = Table("User");
-
-    it("should validate metadata", () => {
-      expect(table.meta).toEqual({
-        name: "User",
-        description: undefined,
-        database: undefined,
-        schema: undefined,
-        columns: undefined,
-        primaryKey: undefined,
-        relations: undefined,
-        indexes: undefined,
-      });
-    });
-  });
-
-  describe("database specified", () => {
-    const table = Table("User").database("CustomDb");
-
-    it("should validate metadata", () => {
-      expect(table.meta).toEqual({
-        name: "User",
-        description: undefined,
-        database: "CustomDb",
-        schema: undefined,
-        columns: undefined,
-        primaryKey: undefined,
-        relations: undefined,
-        indexes: undefined,
-      });
-    });
-  });
-
-  describe("columns specified (single column)", () => {
-    const table = Table("User").columns((c) => ({ id: c.bigint() }));
-
-    it("should validate metadata", () => {
-      expect(table.meta.name).toBe("User");
-      expect(table.meta.columns).toBeDefined();
-      expect(Object.keys(table.meta.columns!)).toEqual(["id"]);
-      expect(table.meta.columns!.id.meta.dataType).toEqual({ type: "bigint" });
-    });
-  });
-
-  describe("columns specified (multiple columns)", () => {
-    const table = Table("User").columns((c) => ({
-      id: c.bigint(),
-      name: c.varchar(100),
-      email: c.varchar(200),
-    }));
-
-    it("should validate metadata", () => {
-      expect(table.meta.name).toBe("User");
-      expect(table.meta.columns).toBeDefined();
-      expect(Object.keys(table.meta.columns!)).toEqual(["id", "name", "email"]);
-      expect(table.meta.columns!.id.meta.dataType).toEqual({ type: "bigint" });
-      expect(table.meta.columns!.name.meta.dataType).toEqual({ type: "varchar", length: 100 });
-      expect(table.meta.columns!.email.meta.dataType).toEqual({ type: "varchar", length: 200 });
-    });
-  });
-
-  describe("primaryKey specified (single key)", () => {
-    const User = Table("User")
-      .database("TestDb")
-      .schema("TestSchema")
-      .columns((c) => ({ id: c.bigint() }))
-      .primaryKey("id");
-
-    const db = createTestDb();
-    const def = db.getCreateTableQueryDef(User);
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "createTable",
-        table: { database: "TestDb", schema: "TestSchema", name: "User" },
-        columns: [
-          {
-            name: "id",
-            dataType: { type: "bigint" },
-            autoIncrement: undefined,
-            nullable: undefined,
-            default: undefined,
-          },
-        ],
-        primaryKey: ["id"],
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.singlePrimaryKey[dialect]);
-    });
-  });
-
-  describe("primaryKey specified (composite key)", () => {
-    const Order = Table("Order")
-      .database("TestDb")
-      .schema("TestSchema")
-      .columns((c) => ({
-        userId: c.bigint(),
-        productId: c.bigint(),
-        quantity: c.int(),
-      }))
-      .primaryKey("userId", "productId");
-
-    const db = createTestDb();
-    const def = db.getCreateTableQueryDef(Order);
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "createTable",
-        table: { database: "TestDb", schema: "TestSchema", name: "Order" },
-        columns: [
-          {
-            name: "userId",
-            dataType: { type: "bigint" },
-            autoIncrement: undefined,
-            nullable: undefined,
-            default: undefined,
-          },
-          {
-            name: "productId",
-            dataType: { type: "bigint" },
-            autoIncrement: undefined,
-            nullable: undefined,
-            default: undefined,
-          },
-          {
-            name: "quantity",
-            dataType: { type: "int" },
-            autoIncrement: undefined,
-            nullable: undefined,
-            default: undefined,
-          },
-        ],
-        primaryKey: ["userId", "productId"],
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.compositePrimaryKey[dialect]);
-    });
-  });
-
-  describe("indexes specified (single index)", () => {
-    const User = Table("User")
-      .columns((c) => ({
-        id: c.bigint(),
-        email: c.varchar(200),
-      }))
-      .primaryKey("id")
-      .indexes((i) => [i.index("email")]);
-
-    it("should validate metadata", () => {
-      expect(User.meta.indexes).toBeDefined();
-      expect(User.meta.indexes!.length).toBe(1);
-      expect(User.meta.indexes![0].meta.columns).toEqual(["email"]);
-    });
-  });
-
-  describe("indexes specified (multiple indexes)", () => {
-    const User = Table("User")
-      .columns((c) => ({
-        id: c.bigint(),
-        email: c.varchar(200),
-        name: c.varchar(100),
-        age: c.int(),
-      }))
-      .primaryKey("id")
-      .indexes((i) => [i.index("email"), i.index("name", "age")]);
-
-    it("should validate metadata", () => {
-      expect(User.meta.indexes).toBeDefined();
-      expect(User.meta.indexes!.length).toBe(2);
-      expect(User.meta.indexes![0].meta.columns).toEqual(["email"]);
-      expect(User.meta.indexes![1].meta.columns).toEqual(["name", "age"]);
-    });
-  });
-
-  describe("indexes specified (unique index)", () => {
-    const User = Table("User")
-      .columns((c) => ({
-        id: c.bigint(),
-        email: c.varchar(200),
-      }))
-      .primaryKey("id")
-      .indexes((i) => [i.index("email").unique()]);
-
-    it("should validate metadata", () => {
-      expect(User.meta.indexes).toBeDefined();
-      expect(User.meta.indexes!.length).toBe(1);
-      expect(User.meta.indexes![0].meta.columns).toEqual(["email"]);
-      expect(User.meta.indexes![0].meta.unique).toBe(true);
-    });
-  });
-
-  describe("relations specified (foreignKey)", () => {
-    const Company = Table("Company")
-      .columns((c) => ({ id: c.bigint() }))
-      .primaryKey("id");
-
-    const User = Table("User")
-      .columns((c) => ({
-        id: c.bigint(),
-        companyId: c.bigint(),
-      }))
-      .primaryKey("id")
-      .relations((r) => ({
-        company: r.foreignKey(["companyId"], () => Company),
-      }));
-
-    it("should validate metadata", () => {
-      expect(User.meta.relations).toBeDefined();
-      expect(Object.keys(User.meta.relations!)).toEqual(["company"]);
-      expect(User.meta.relations!.company.meta.columns).toEqual(["companyId"]);
-      expect(User.meta.relations!.company.meta.targetFn).toBeDefined();
-    });
-  });
-
-  describe("combined options 1 (database + schema + description)", () => {
-    const User = Table("User")
-      .database("TestDb")
-      .schema("TestSchema")
-      .description("User table")
-      .columns((c) => ({
-        id: c.bigint(),
-        name: c.varchar(100),
-      }))
-      .primaryKey("id");
-
-    const db = createTestDb();
-    const def = db.getCreateTableQueryDef(User);
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "createTable",
-        table: { database: "TestDb", schema: "TestSchema", name: "User" },
-        columns: [
-          {
-            name: "id",
-            dataType: { type: "bigint" },
-            autoIncrement: undefined,
-            nullable: undefined,
-            default: undefined,
-          },
-          {
-            name: "name",
-            dataType: { type: "varchar", length: 100 },
-            autoIncrement: undefined,
-            nullable: undefined,
-            default: undefined,
-          },
-        ],
-        primaryKey: ["id"],
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.complexOptions1[dialect]);
-    });
-  });
-
-  describe("combined options 2 (columns + PK + indexes)", () => {
-    const User = Table("User")
-      .database("TestDb")
-      .schema("TestSchema")
-      .columns((c) => ({
-        id: c.bigint(),
-        email: c.varchar(200),
-        name: c.varchar(100),
-      }))
-      .primaryKey("id")
-      .indexes((i) => [i.index("email").unique()]);
-
-    it("should validate metadata", () => {
-      expect(User.meta.database).toBe("TestDb");
-      expect(User.meta.schema).toBe("TestSchema");
-      expect(Object.keys(User.meta.columns!)).toEqual(["id", "email", "name"]);
-      expect(User.meta.primaryKey).toEqual(["id"]);
-      expect(User.meta.indexes!.length).toBe(1);
-      expect(User.meta.indexes![0].meta.unique).toBe(true);
-    });
-  });
-
-  describe("combined options 3 (various column types)", () => {
-    const Product = Table("Product")
-      .database("TestDb")
-      .schema("TestSchema")
-      .description("Product table")
-      .columns((c) => ({
-        id: c.bigint().autoIncrement(),
-        name: c.varchar(200),
-        price: c.decimal(10, 2),
-        stock: c.int().default(0),
-        isActive: c.boolean().default(true),
-        description: c.text().nullable(),
-        createdAt: c.datetime(),
-      }))
-      .primaryKey("id");
-
-    const db = createTestDb();
-    const def = db.getCreateTableQueryDef(Product);
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "createTable",
-        table: { database: "TestDb", schema: "TestSchema", name: "Product" },
-        columns: [
-          {
-            name: "id",
-            dataType: { type: "bigint" },
-            autoIncrement: true,
-            nullable: undefined,
-            default: undefined,
-          },
-          {
-            name: "name",
-            dataType: { type: "varchar", length: 200 },
-            autoIncrement: undefined,
-            nullable: undefined,
-            default: undefined,
-          },
-          {
-            name: "price",
-            dataType: { type: "decimal", precision: 10, scale: 2 },
-            autoIncrement: undefined,
-            nullable: undefined,
-            default: undefined,
-          },
-          {
-            name: "stock",
-            dataType: { type: "int" },
-            autoIncrement: undefined,
-            nullable: undefined,
-            default: 0,
-          },
-          {
-            name: "isActive",
-            dataType: { type: "boolean" },
-            autoIncrement: undefined,
-            nullable: undefined,
-            default: true,
-          },
-          {
-            name: "description",
-            dataType: { type: "text" },
-            autoIncrement: undefined,
-            nullable: true,
-            default: undefined,
-          },
-          {
-            name: "createdAt",
-            dataType: { type: "datetime" },
-            autoIncrement: undefined,
-            nullable: undefined,
-            default: undefined,
-          },
-        ],
-        primaryKey: ["id"],
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.complexOptions3[dialect]);
-    });
-  });
-
-  describe("method chaining order", () => {
-    // Same result even with different method chaining order
-    const table1 = Table("User")
-      .columns((c) => ({ id: c.bigint() }))
-      .database("TestDb")
-      .schema("TestSchema")
-      .primaryKey("id");
-
-    const table2 = Table("User")
-      .database("TestDb")
-      .schema("TestSchema")
-      .columns((c) => ({ id: c.bigint() }))
-      .primaryKey("id");
-
-    it("should validate metadata consistency", () => {
-      expect(table1.meta).toEqual(table2.meta);
-    });
-  });
-});

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

@@ -1,38 +0,0 @@
-import { mysql, pgsql, tsql } from "@simplysm/core-common";
-import type { ExpectedSql } from "../setup/test-utils";
-
-export const queryBasic: ExpectedSql = {
-  mysql: mysql`
-    CREATE OR REPLACE VIEW \`TestDb\`.\`TestView\` AS
-    SELECT \`T1\`.\`id\` AS \`id\`, \`T1\`.\`name\` AS \`name\`
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-  `,
-  mssql: tsql`
-    CREATE OR ALTER VIEW [TestDb].[TestSchema].[TestView] AS
-    SELECT [T1].[id] AS [id], [T1].[name] AS [name]
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-  `,
-  postgresql: pgsql`
-    CREATE OR REPLACE VIEW "TestSchema"."TestView" AS
-    SELECT "T1"."id" AS "id", "T1"."name" AS "name"
-    FROM "TestSchema"."User" AS "T1"
-  `,
-};
-
-export const combined: ExpectedSql = {
-  mysql: mysql`
-    CREATE OR REPLACE VIEW \`CustomDb\`.\`TestView\` AS
-    SELECT \`T1\`.\`id\` AS \`id\`, \`T1\`.\`email\` AS \`email\`
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-  `,
-  mssql: tsql`
-    CREATE OR ALTER VIEW [CustomDb].[CustomSchema].[TestView] AS
-    SELECT [T1].[id] AS [id], [T1].[email] AS [email]
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-  `,
-  postgresql: pgsql`
-    CREATE OR REPLACE VIEW "CustomSchema"."TestView" AS
-    SELECT "T1"."id" AS "id", "T1"."email" AS "email"
-    FROM "TestSchema"."User" AS "T1"
-  `,
-};

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

@@ -1,116 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createTestDb, type TestDbContext } from "../setup/TestDbContext";
-import { View } from "../../src/schema/view-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 "./view-builder.expected";
-
-describe("DDL - View Builder", () => {
-  describe("query specified (basic SELECT)", () => {
-    const view = View("TestView").query((db: TestDbContext) =>
-      db.user().select((u) => ({
-        id: u.id,
-        name: u.name,
-      })),
-    );
-
-    it("should validate metadata", () => {
-      expect(view.meta.name).toBe("TestView");
-      expect(view.meta.viewFn).toBeTypeOf("function");
-    });
-
-    const db = createTestDb();
-    const def = db.getCreateViewQueryDef(view);
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "createView",
-        view: { database: "TestDb", schema: "TestSchema", name: "TestView" },
-        queryDef: {
-          type: "select",
-          from: { database: "TestDb", schema: "TestSchema", name: "User" },
-          as: "T1",
-          select: {
-            id: { type: "column", path: ["T1", "id"] },
-            name: { type: "column", path: ["T1", "name"] },
-          },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.queryBasic[dialect]);
-    });
-  });
-
-  describe("combined options (database + schema + description + query)", () => {
-    const view = View("TestView")
-      .database("CustomDb")
-      .schema("CustomSchema")
-      .description("Combined options view")
-      .query((db: TestDbContext) =>
-        db.user().select((u) => ({
-          id: u.id,
-          email: u.email,
-        })),
-      );
-
-    it("should validate metadata", () => {
-      expect(view.meta.name).toBe("TestView");
-      expect(view.meta.database).toBe("CustomDb");
-      expect(view.meta.schema).toBe("CustomSchema");
-      expect(view.meta.description).toBe("Combined options view");
-      expect(view.meta.viewFn).toBeTypeOf("function");
-    });
-
-    const db = createTestDb();
-    const def = db.getCreateViewQueryDef(view);
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "createView",
-        view: { database: "CustomDb", schema: "CustomSchema", name: "TestView" },
-        queryDef: {
-          type: "select",
-          from: { database: "TestDb", schema: "TestSchema", name: "User" },
-          as: "T1",
-          select: {
-            id: { type: "column", path: ["T1", "id"] },
-            email: { type: "column", path: ["T1", "email"] },
-          },
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.combined[dialect]);
-    });
-  });
-
-  describe("relations specified", () => {
-    const Company = View("Company").query((db: TestDbContext) =>
-      db.company().select((c) => ({ id: c.id })),
-    );
-
-    const view = View("TestView")
-      .query((db: TestDbContext) =>
-        db.user().select((u) => ({
-          id: u.id,
-          name: u.name,
-          companyId: u.companyId,
-        })),
-      )
-      .relations((r) => ({
-        company: r.relationKey(["companyId"], () => Company),
-      }));
-
-    it("should validate metadata", () => {
-      expect(view.meta.name).toBe("TestView");
-      expect(view.meta.relations).toBeDefined();
-      expect(view.meta.relations?.["company"]).toBeDefined();
-    });
-  });
-});

package/tests/dml/delete.expected.ts

@@ -1,96 +0,0 @@
-/**
- * DELETE test expected SQL
- */
-import { mysql, pgsql, tsql } from "@simplysm/core-common";
-import type { ExpectedSql } from "../setup/test-utils";
-
-//#region ========== TRUNCATE ==========
-
-export const truncate: ExpectedSql = {
-  mysql: mysql`
-    TRUNCATE TABLE \`TestDb\`.\`Employee\`
-  `,
-  mssql: tsql`
-    TRUNCATE TABLE [TestDb].[TestSchema].[Employee]
-  `,
-  postgresql: pgsql`
-    TRUNCATE TABLE "TestSchema"."Employee" RESTART IDENTITY
-  `,
-};
-
-//#endregion
-
-//#region ========== DELETE - Basic ==========
-
-export const deleteSimple: ExpectedSql = {
-  mysql: mysql`
-    DELETE \`T1\` FROM \`TestDb\`.\`Employee\` AS \`T1\`
-    WHERE \`T1\`.\`id\` <=> 1
-  `,
-  mssql: tsql`
-    DELETE [T1]
-    FROM [TestDb].[TestSchema].[Employee] AS [T1]
-    WHERE (([T1].[id] IS NULL AND 1 IS NULL) OR [T1].[id] = 1)
-  `,
-  postgresql: pgsql`
-    DELETE FROM "TestSchema"."Employee" AS "T1"
-    WHERE "T1"."id" IS NOT DISTINCT FROM 1
-  `,
-};
-
-export const deleteMultiCond: ExpectedSql = {
-  mysql: mysql`
-    DELETE \`T1\` FROM \`TestDb\`.\`Employee\` AS \`T1\`
-    WHERE \`T1\`.\`departmentId\` <=> 1 AND \`T1\`.\`managerId\` IS NULL
-  `,
-  mssql: tsql`
-    DELETE [T1]
-    FROM [TestDb].[TestSchema].[Employee] AS [T1]
-    WHERE (([T1].[departmentId] IS NULL AND 1 IS NULL) OR [T1].[departmentId] = 1)
-      AND [T1].[managerId] IS NULL
-  `,
-  postgresql: pgsql`
-    DELETE FROM "TestSchema"."Employee" AS "T1"
-    WHERE "T1"."departmentId" IS NOT DISTINCT FROM 1
-      AND "T1"."managerId" IS NULL
-  `,
-};
-
-export const deleteWithOutput: ExpectedSql = {
-  mysql: mysql`
-    CREATE TEMPORARY TABLE \`SD_TEMP\` AS SELECT \`T1\`.\`id\`, \`T1\`.\`name\` FROM \`TestDb\`.\`Employee\` AS \`T1\` WHERE \`T1\`.\`id\` <=> 1;
-    DELETE \`T1\` FROM \`TestDb\`.\`Employee\` AS \`T1\` WHERE \`T1\`.\`id\` <=> 1;
-    SELECT * FROM \`SD_TEMP\`;
-    DROP TEMPORARY TABLE \`SD_TEMP\`
-  `,
-  mssql: tsql`
-    DELETE [T1]
-    OUTPUT DELETED.[id], DELETED.[name]
-    FROM [TestDb].[TestSchema].[Employee] AS [T1]
-    WHERE (([T1].[id] IS NULL AND 1 IS NULL) OR [T1].[id] = 1)
-  `,
-  postgresql: pgsql`
-    DELETE FROM "TestSchema"."Employee" AS "T1"
-    WHERE "T1"."id" IS NOT DISTINCT FROM 1
-    RETURNING "id", "name"
-  `,
-};
-
-export const deleteWithTop: ExpectedSql = {
-  mysql: mysql`
-    DELETE \`T1\` FROM \`TestDb\`.\`Employee\` AS \`T1\`
-    WHERE \`T1\`.\`departmentId\` <=> 1
-    LIMIT 100
-  `,
-  mssql: tsql`
-    DELETE TOP 100 [T1]
-    FROM [TestDb].[TestSchema].[Employee] AS [T1]
-    WHERE (([T1].[departmentId] IS NULL AND 1 IS NULL) OR [T1].[departmentId] = 1)
-  `,
-  postgresql: pgsql`
-    DELETE FROM "TestSchema"."Employee" AS "T1"
-    WHERE "T1"."departmentId" IS NOT DISTINCT FROM 1
-  `,
-};
-
-//#endregion