@simplysm/orm-common 13.0.74 → 13.0.76

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simplysm/orm-common",
-  "version": "13.0.74",
+  "version": "13.0.76",
   "description": "Simplysm Package - ORM Module (common)",
   "author": "simplysm",
   "license": "Apache-2.0",
@@ -19,6 +19,6 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@simplysm/core-common": "13.0.74"
+    "@simplysm/core-common": "13.0.76"
   }
 }

package/tests/db-context/create-db-context.spec.ts

@@ -50,21 +50,6 @@ describe("createDbContext", () => {
     expect(postDef.as).toBe("T2");
   });
 
-  it("DDL methods exist on instance", () => {
-    const db = createDbContext(TestDb, new MockExecutor(), {
-      database: "TestDb",
-    });
-
-    // QueryDef generators
-    expect(typeof db.getCreateTableQueryDef).toBe("function");
-    expect(typeof db.getAddColumnQueryDef).toBe("function");
-    expect(typeof db.getClearSchemaQueryDef).toBe("function");
-
-    // Execution methods
-    expect(typeof db.createTable).toBe("function");
-    expect(typeof db.addColumn).toBe("function");
-  });
-
   it("DDL QueryDef generators produce correct output", () => {
     const db = createDbContext(TestDb, new MockExecutor(), {
       database: "TestDb",
@@ -192,22 +177,6 @@ describe("createDbContext", () => {
     });
   });
 
-  it("_migration accessor exists", () => {
-    const db = createDbContext(TestDb, new MockExecutor(), {
-      database: "TestDb",
-    });
-
-    expect(typeof db._migration).toBe("function");
-  });
-
-  it("initialize method exists", () => {
-    const db = createDbContext(TestDb, new MockExecutor(), {
-      database: "TestDb",
-    });
-
-    expect(typeof db.initialize).toBe("function");
-  });
-
   it("getQueryDefObjectName resolves table with defaults", () => {
     const db = createDbContext(TestDb, new MockExecutor(), {
       database: "TestDb",

package/tests/db-context/define-db-context.spec.ts

@@ -1,40 +1,7 @@
 import { describe, expect, it } from "vitest";
-import type { DbContextBase, DbContextDef } from "../../src/types/db-context-def";
 import { defineDbContext } from "../../src/define-db-context";
 import { User } from "../setup/models/User";
 import { Post } from "../setup/models/Post";
-import { ActiveUsers } from "../setup/views/ActiveUsers";
-
-describe("DbContext Types", () => {
-  it("DbContextBase interface has required members", () => {
-    // Type-level test: verify the interface exists with correct shape
-    const base: DbContextBase = {
-      status: "ready",
-      database: "test",
-      schema: undefined,
-      getNextAlias: () => "T1",
-      resetAliasCounter: () => {},
-      executeDefs: () => Promise.resolve([[]]),
-      getQueryDefObjectName: () => ({ database: "test", name: "test" }),
-      switchFk: () => Promise.resolve(),
-    };
-    expect(base.status).toBe("ready");
-    expect(base.getNextAlias()).toBe("T1");
-  });
-
-  it("DbContextDef has meta property", () => {
-    const def: DbContextDef<{}, {}> = {
-      meta: {
-        tables: {},
-        views: {},
-        procedures: {},
-        migrations: [],
-      },
-    };
-    expect(def.meta.tables).toEqual({});
-    expect(def.meta.migrations).toEqual([]);
-  });
-});
 
 describe("defineDbContext", () => {
   it("creates a DbContextDef with tables", () => {
@@ -47,22 +14,4 @@ describe("defineDbContext", () => {
     expect(MyDb.meta.migrations).toEqual([]);
   });
 
-  it("creates a DbContextDef with views", () => {
-    const MyDb = defineDbContext({
-      tables: { user: User },
-      views: { activeUsers: ActiveUsers },
-    });
-
-    expect(MyDb.meta.views.activeUsers).toBe(ActiveUsers);
-  });
-
-  it("creates a DbContextDef with migrations", () => {
-    const migrations = [{ name: "test", up: async () => {} }];
-    const MyDb = defineDbContext({
-      tables: { user: User },
-      migrations,
-    });
-
-    expect(MyDb.meta.migrations).toBe(migrations);
-  });
 });

package/tests/ddl/basic.spec.ts

@@ -122,65 +122,6 @@ describe("DDL - Table", () => {
     });
   });
 
-  describe("getTruncateQueryDef", () => {
-    const db = createTestDb();
-    const def = db.getTruncateQueryDef({ database: "TestDb", schema: "TestSchema", name: "User" });
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "truncate",
-        table: { database: "TestDb", schema: "TestSchema", name: "User" },
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.truncate[dialect]);
-    });
-  });
-
-  describe("getSwitchFkQueryDef - on", () => {
-    const db = createTestDb();
-    const def = db.getSwitchFkQueryDef(
-      { database: "TestDb", schema: "TestSchema", name: "User" },
-      "on",
-    );
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "switchFk",
-        table: { database: "TestDb", schema: "TestSchema", name: "User" },
-        switch: "on",
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.switchFkOn[dialect]);
-    });
-  });
-
-  describe("getSwitchFkQueryDef - off", () => {
-    const db = createTestDb();
-    const def = db.getSwitchFkQueryDef(
-      { database: "TestDb", schema: "TestSchema", name: "User" },
-      "off",
-    );
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "switchFk",
-        table: { database: "TestDb", schema: "TestSchema", name: "User" },
-        switch: "off",
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.switchFkOff[dialect]);
-    });
-  });
-
   describe("getDropTableQueryDef", () => {
     const db = createTestDb();
     const def = db.getDropTableQueryDef({ database: "TestDb", schema: "TestSchema", name: "User" });
@@ -279,35 +220,6 @@ describe("DDL - Column", () => {
     });
   });
 
-  describe("getAddColumnQueryDef - with autoIncrement", () => {
-    const db = createTestDb();
-    const column = Column.bigint().autoIncrement();
-    const def = db.getAddColumnQueryDef(
-      { database: "TestDb", schema: "TestSchema", name: "User" },
-      "seq",
-      column,
-    );
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addColumn",
-        table: { database: "TestDb", schema: "TestSchema", name: "User" },
-        column: {
-          name: "seq",
-          dataType: { type: "bigint" },
-          autoIncrement: true,
-          nullable: undefined,
-          default: undefined,
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.addColumnWithAutoIncrement[dialect]);
-    });
-  });
-
   describe("getDropColumnQueryDef", () => {
     const db = createTestDb();
     const def = db.getDropColumnQueryDef(
@@ -358,35 +270,6 @@ describe("DDL - Column", () => {
     });
   });
 
-  describe("getModifyColumnQueryDef - change TYPE + DEFAULT simultaneously", () => {
-    const db = createTestDb();
-    const column = Column.int().default(100);
-    const def = db.getModifyColumnQueryDef(
-      { database: "TestDb", schema: "TestSchema", name: "User" },
-      "score",
-      column,
-    );
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "modifyColumn",
-        table: { database: "TestDb", schema: "TestSchema", name: "User" },
-        column: {
-          name: "score",
-          dataType: { type: "int" },
-          autoIncrement: undefined,
-          nullable: undefined,
-          default: 100,
-        },
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.modifyColumnTypeAndDefault[dialect]);
-    });
-  });
-
   describe("getRenameColumnQueryDef", () => {
     const db = createTestDb();
     const def = db.getRenameColumnQueryDef(
@@ -449,26 +332,6 @@ describe("DDL - Primary Key", () => {
     });
   });
 
-  describe("getAddPkQueryDef - composite key", () => {
-    const db = createTestDb();
-    const def = db.getAddPkQueryDef(
-      { database: "TestDb", schema: "TestSchema", name: "UserRole" },
-      ["userId", "roleId"],
-    );
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addPk",
-        table: { database: "TestDb", schema: "TestSchema", name: "UserRole" },
-        columns: ["userId", "roleId"],
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.addPkComposite[dialect]);
-    });
-  });
 });
 
 describe("DDL - Foreign Key / Index", () => {
@@ -572,26 +435,6 @@ describe("DDL - Foreign Key / Index", () => {
     });
   });
 
-  describe("getDropIdxQueryDef - composite", () => {
-    const db = createTestDb();
-    const def = db.getDropIdxQueryDef({ database: "TestDb", schema: "TestSchema", name: "User" }, [
-      "name",
-      "email",
-    ]);
-
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "dropIdx",
-        table: { database: "TestDb", schema: "TestSchema", name: "User" },
-        index: "IDX_User_name_email",
-      });
-    });
-
-    it.each(dialects)("[%s] should validate SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.dropIdxComposite[dialect]);
-    });
-  });
 });
 
 describe("DDL - View", () => {

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

@@ -51,20 +51,6 @@ describe("DDL - Column Builder", () => {
       column,
     );
 
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addColumn",
-        table: { database: "TestDb", schema: "TestSchema", name: "User" },
-        column: {
-          name: "id",
-          dataType: { type: "bigint" },
-          autoIncrement: undefined,
-          nullable: undefined,
-          default: undefined,
-        },
-      });
-    });
-
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.bigintType[dialect]);
@@ -82,20 +68,6 @@ describe("DDL - Column Builder", () => {
       column,
     );
 
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addColumn",
-        table: { database: "TestDb", schema: "TestSchema", name: "Product" },
-        column: {
-          name: "weight",
-          dataType: { type: "float" },
-          autoIncrement: undefined,
-          nullable: undefined,
-          default: undefined,
-        },
-      });
-    });
-
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.floatType[dialect]);
@@ -113,20 +85,6 @@ describe("DDL - Column Builder", () => {
       column,
     );
 
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addColumn",
-        table: { database: "TestDb", schema: "TestSchema", name: "Product" },
-        column: {
-          name: "price",
-          dataType: { type: "double" },
-          autoIncrement: undefined,
-          nullable: undefined,
-          default: undefined,
-        },
-      });
-    });
-
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.doubleType[dialect]);
@@ -175,20 +133,6 @@ describe("DDL - Column Builder", () => {
       column,
     );
 
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addColumn",
-        table: { database: "TestDb", schema: "TestSchema", name: "User" },
-        column: {
-          name: "name",
-          dataType: { type: "varchar", length: 100 },
-          autoIncrement: undefined,
-          nullable: undefined,
-          default: undefined,
-        },
-      });
-    });
-
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.varcharType[dialect]);
@@ -237,20 +181,6 @@ describe("DDL - Column Builder", () => {
       column,
     );
 
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addColumn",
-        table: { database: "TestDb", schema: "TestSchema", name: "Post" },
-        column: {
-          name: "content",
-          dataType: { type: "text" },
-          autoIncrement: undefined,
-          nullable: undefined,
-          default: undefined,
-        },
-      });
-    });
-
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.textType[dialect]);
@@ -268,20 +198,6 @@ describe("DDL - Column Builder", () => {
       column,
     );
 
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addColumn",
-        table: { database: "TestDb", schema: "TestSchema", name: "File" },
-        column: {
-          name: "data",
-          dataType: { type: "binary" },
-          autoIncrement: undefined,
-          nullable: undefined,
-          default: undefined,
-        },
-      });
-    });
-
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.binaryType[dialect]);
@@ -299,20 +215,6 @@ describe("DDL - Column Builder", () => {
       column,
     );
 
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addColumn",
-        table: { database: "TestDb", schema: "TestSchema", name: "User" },
-        column: {
-          name: "isActive",
-          dataType: { type: "boolean" },
-          autoIncrement: undefined,
-          nullable: undefined,
-          default: undefined,
-        },
-      });
-    });
-
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.booleanType[dialect]);
@@ -330,20 +232,6 @@ describe("DDL - Column Builder", () => {
       column,
     );
 
-    it("should validate QueryDef", () => {
-      expect(def).toEqual({
-        type: "addColumn",
-        table: { database: "TestDb", schema: "TestSchema", name: "User" },
-        column: {
-          name: "createdAt",
-          dataType: { type: "datetime" },
-          autoIncrement: undefined,
-          nullable: undefined,
-          default: undefined,
-        },
-      });
-    });
-
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
       expect(builder.build(def)).toMatchSql(expected.datetimeType[dialect]);

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

@@ -145,58 +145,4 @@ describe("DDL - Index Builder", () => {
     });
   });
 
-  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.spec.ts

@@ -23,54 +23,6 @@ describe("DDL - Procedure Builder", () => {
     });
   });
 
-  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() }));
 
@@ -82,23 +34,6 @@ describe("DDL - Procedure Builder", () => {
     });
   });
 
-  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() }));
 
@@ -110,24 +45,6 @@ describe("DDL - Procedure Builder", () => {
     });
   });
 
-  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")
@@ -208,27 +125,4 @@ describe("DDL - Procedure Builder", () => {
     });
   });
 
-  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!));
-    });
-  });
 });