@simplysm/orm-common 13.0.76 → 13.0.77

package/src/types/query-def.ts

@@ -174,7 +174,7 @@ export interface UpsertQueryDef {
 export interface SwitchFkQueryDef {
   type: "switchFk";
   table: QueryDefObjectName;
-  switch: "on" | "off";
+  enabled: boolean;
 }
 
 //#endregion
@@ -275,21 +275,21 @@ export interface RenameColumnQueryDef {
 //#region ========== DDL - PK/FK/Index ==========
 
 /** DROP PRIMARY KEY */
-export interface DropPkQueryDef {
-  type: "dropPk";
+export interface DropPrimaryKeyQueryDef {
+  type: "dropPrimaryKey";
   table: QueryDefObjectName;
 }
 
 /** ADD PRIMARY KEY */
-export interface AddPkQueryDef {
-  type: "addPk";
+export interface AddPrimaryKeyQueryDef {
+  type: "addPrimaryKey";
   table: QueryDefObjectName;
   columns: string[];
 }
 
 /** ADD FOREIGN KEY */
-export interface AddFkQueryDef {
-  type: "addFk";
+export interface AddForeignKeyQueryDef {
+  type: "addForeignKey";
   table: QueryDefObjectName;
   foreignKey: {
     name: string;
@@ -300,15 +300,15 @@ export interface AddFkQueryDef {
 }
 
 /** DROP FOREIGN KEY */
-export interface DropFkQueryDef {
-  type: "dropFk";
+export interface DropForeignKeyQueryDef {
+  type: "dropForeignKey";
   table: QueryDefObjectName;
   foreignKey: string;
 }
 
 /** CREATE INDEX */
-export interface AddIdxQueryDef {
-  type: "addIdx";
+export interface AddIndexQueryDef {
+  type: "addIndex";
   table: QueryDefObjectName;
   index: {
     name: string;
@@ -318,8 +318,8 @@ export interface AddIdxQueryDef {
 }
 
 /** DROP INDEX */
-export interface DropIdxQueryDef {
-  type: "dropIdx";
+export interface DropIndexQueryDef {
+  type: "dropIndex";
   table: QueryDefObjectName;
   index: string;
 }
@@ -403,12 +403,12 @@ type DdlQueryDef =
   | DropColumnQueryDef
   | ModifyColumnQueryDef
   | RenameColumnQueryDef
-  | DropPkQueryDef
-  | AddPkQueryDef
-  | AddFkQueryDef
-  | DropFkQueryDef
-  | AddIdxQueryDef
-  | DropIdxQueryDef
+  | DropPrimaryKeyQueryDef
+  | AddPrimaryKeyQueryDef
+  | AddForeignKeyQueryDef
+  | DropForeignKeyQueryDef
+  | AddIndexQueryDef
+  | DropIndexQueryDef
   | CreateViewQueryDef
   | DropViewQueryDef
   | CreateProcQueryDef
@@ -433,12 +433,12 @@ export const DDL_TYPES = [
   "dropColumn",
   "modifyColumn",
   "renameColumn",
-  "dropPk",
-  "addPk",
-  "addFk",
-  "dropFk",
-  "addIdx",
-  "dropIdx",
+  "dropPrimaryKey",
+  "addPrimaryKey",
+  "addForeignKey",
+  "dropForeignKey",
+  "addIndex",
+  "dropIndex",
   "createView",
   "dropView",
   "createProc",
@@ -490,12 +490,12 @@ export type QueryDef =
   | RenameColumnQueryDef
 
   // DDL - PK/FK/Index
-  | DropPkQueryDef
-  | AddPkQueryDef
-  | AddFkQueryDef
-  | DropFkQueryDef
-  | AddIdxQueryDef
-  | DropIdxQueryDef
+  | DropPrimaryKeyQueryDef
+  | AddPrimaryKeyQueryDef
+  | AddForeignKeyQueryDef
+  | DropForeignKeyQueryDef
+  | AddIndexQueryDef
+  | DropIndexQueryDef
 
   // DDL - View/Procedure
   | CreateViewQueryDef

package/src/utils/result-parser.ts

@@ -1,4 +1,4 @@
-import { bytesFromHex, DateOnly, DateTime, objEqual, Time, Uuid } from "@simplysm/core-common";
+import { bytes, obj, DateOnly, DateTime, Time, Uuid } from "@simplysm/core-common";
 import type { ColumnPrimitiveStr } from "../types/column";
 import type { ResultMeta } from "../types/db";
 
@@ -55,7 +55,7 @@ function parseValue(value: unknown, type: ColumnPrimitiveStr): unknown {
 
     case "Bytes":
       if (value instanceof Uint8Array) return value;
-      if (typeof value === "string") return bytesFromHex(value);
+      if (typeof value === "string") return bytes.fromHex(value);
       throw new Error(`Failed to parse Bytes: ${typeof value}`);
   }
 }
@@ -64,6 +64,22 @@ function parseValue(value: unknown, type: ColumnPrimitiveStr): unknown {
 // Grouping Utilities
 // ============================================
 
+/** Precomputed column metadata for flatToNested */
+interface ColumnInfo {
+  key: string;
+  type: ColumnPrimitiveStr;
+  parts: string[] | undefined; // undefined for simple keys, string[] for nested keys
+}
+
+/** Precompute column info once per unique columns object */
+function buildColumnInfos(columns: Record<string, ColumnPrimitiveStr>): ColumnInfo[] {
+  return Object.entries(columns).map(([key, type]) => ({
+    key,
+    type,
+    parts: key.includes(".") ? key.split(".") : undefined,
+  }));
+}
+
 /**
  * Transform flat record to nested object
  *
@@ -72,20 +88,19 @@ function parseValue(value: unknown, type: ColumnPrimitiveStr): unknown {
  */
 function flatToNested(
   record: Record<string, unknown>,
-  columns: Record<string, ColumnPrimitiveStr>,
+  columnInfos: ColumnInfo[],
 ): Record<string, unknown> {
   const result: Record<string, unknown> = {};
 
-  for (const [key, type] of Object.entries(columns)) {
+  for (const { key, type, parts } of columnInfos) {
     const rawValue = record[key];
     const parsedValue = parseValue(rawValue, type);
 
     // undefined values are not added as keys
     if (parsedValue === undefined) continue;
 
-    if (key.includes(".")) {
+    if (parts != null) {
       // Nested key: "posts.id" → { posts: { id: ... } }
-      const parts = key.split(".");
       let current = result;
       for (let i = 0; i < parts.length - 1; i++) {
         const part = parts[i];
@@ -107,8 +122,8 @@ function flatToNested(
 /**
  * Check if object is empty (all values are undefined)
  */
-function isEmptyObject(obj: Record<string, unknown>): boolean {
-  return Object.keys(obj).length === 0;
+function isEmptyObject(record: Record<string, unknown>): boolean {
+  return Object.keys(record).length === 0;
 }
 
 // ============================================
@@ -186,6 +201,7 @@ async function parseSimpleRecords<TRecord>(
   rawResults: Record<string, unknown>[],
   columns: Record<string, ColumnPrimitiveStr>,
 ): Promise<TRecord[] | undefined> {
+  const columnInfos = buildColumnInfos(columns);
   const results: Record<string, unknown>[] = [];
 
   for (let i = 0; i < rawResults.length; i++) {
@@ -194,7 +210,7 @@ async function parseSimpleRecords<TRecord>(
       await yieldToEventLoop();
     }
 
-    const parsed = flatToNested(rawResults[i], columns);
+    const parsed = flatToNested(rawResults[i], columnInfos);
 
     // Exclude empty objects
     if (!isEmptyObject(parsed)) {
@@ -226,12 +242,13 @@ async function parseJoinedRecords<TRecord>(
   meta: ResultMeta,
 ): Promise<TRecord[] | undefined> {
   // 1. Transform all records to nested structure
+  const columnInfos = buildColumnInfos(meta.columns);
   const nestedRecords: Record<string, unknown>[] = [];
   for (let i = 0; i < rawResults.length; i++) {
     if (i > 0 && i % YIELD_INTERVAL === 0) {
       await yieldToEventLoop();
     }
-    nestedRecords.push(flatToNested(rawResults[i], meta.columns));
+    nestedRecords.push(flatToNested(rawResults[i], columnInfos));
   }
 
   // 2. Sort JOIN keys by depth (shallower ones first)
@@ -253,7 +270,15 @@ async function parseJoinedRecords<TRecord>(
  */
 function serializeGroupKey(groupKey: Record<string, unknown>, cachedKeyOrder?: string[]): string {
   const keys = cachedKeyOrder ?? Object.keys(groupKey).sort((a, b) => a.localeCompare(b));
-  return keys.map((k) => `${k}:${groupKey[k] === null ? "null" : String(groupKey[k])}`).join("|");
+  let result = "";
+  for (let i = 0; i < keys.length; i++) {
+    if (i > 0) result += "|";
+    const v = groupKey[keys[i]];
+    result += keys[i];
+    result += ":";
+    result += v === null ? "null" : String(v);
+  }
+  return result;
 }
 
 /**
@@ -295,12 +320,15 @@ function groupRecordsRecursively(
   // Map-based grouping (O(n) complexity)
   const groupMap = new Map<string, Record<string, unknown>>();
 
+  // Precompute join key exclusion set for O(1) lookup
+  const joinKeyExclusions = buildJoinKeyExclusionSet(childJoinKeys);
+
   // Key order caching (determined from first record and reused)
   let groupKeyOrder: string[] | undefined;
 
   for (const record of records) {
     // Extract and serialize group key (excluding JOIN keys)
-    const groupKey = extractGroupKey(record, childJoinKeys);
+    const groupKey = extractGroupKey(record, joinKeyExclusions);
     if (groupKeyOrder == null) {
       groupKeyOrder = Object.keys(groupKey).sort((a, b) => a.localeCompare(b));
     }
@@ -382,17 +410,33 @@ function groupRecordsRecursively(
   return grouped;
 }
 
+/**
+ * Build a Set of keys that should be excluded from group key (join keys and their prefixes)
+ */
+function buildJoinKeyExclusionSet(joinKeys: string[]): Set<string> {
+  const exclusions = new Set<string>();
+  for (const jk of joinKeys) {
+    exclusions.add(jk);
+    // Also exclude parent paths (e.g., "posts" for join key "posts.comments")
+    const parts = jk.split(".");
+    for (let i = 1; i < parts.length; i++) {
+      exclusions.add(parts.slice(0, i).join("."));
+    }
+  }
+  return exclusions;
+}
+
 /**
  * Extract group key from record excluding JOIN keys
  */
 function extractGroupKey(
   record: Record<string, unknown>,
-  joinKeys: string[],
+  joinKeyExclusions: Set<string>,
 ): Record<string, unknown> {
   const result: Record<string, unknown> = {};
   for (const [key, value] of Object.entries(record)) {
     // Only include non-JOIN keys
-    if (!joinKeys.some((jk) => jk === key || jk.startsWith(key + "."))) {
+    if (!joinKeyExclusions.has(key)) {
       // Only use primitive values (not object/array) as group key
       if (value == null || typeof value !== "object") {
         result[key] = value;
@@ -422,7 +466,7 @@ function mergeJoinData(
   if (isSingle) {
     // isSingle: true - error if data exists and values differ
     if (existingJoinData != null) {
-      if (!objEqual(existingJoinData as Record<string, unknown>, newJoinData)) {
+      if (!obj.equal(existingJoinData as Record<string, unknown>, newJoinData)) {
         throw new Error(`isSingle relationship '${localKey}' has multiple different results.`);
       }
     } else {
@@ -447,7 +491,7 @@ function mergeJoinData(
       } else {
         // Fallback without hashSet (legacy approach)
         const isDuplicate = existingJoinData.some((item) =>
-          objEqual(item as Record<string, unknown>, newJoinData),
+          obj.equal(item as Record<string, unknown>, newJoinData),
         );
         if (!isDuplicate) {
           existingJoinData.push(newJoinData);

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

@@ -64,14 +64,14 @@ describe("createDbContext", () => {
     });
   });
 
-  it("connect/trans methods exist", () => {
+  it("connect/transaction methods exist", () => {
     const db = createDbContext(TestDb, new MockExecutor(), {
       database: "TestDb",
     });
 
     expect(typeof db.connect).toBe("function");
     expect(typeof db.connectWithoutTransaction).toBe("function");
-    expect(typeof db.trans).toBe("function");
+    expect(typeof db.transaction).toBe("function");
   });
 
   it("connect manages status lifecycle", async () => {
@@ -100,7 +100,7 @@ describe("createDbContext", () => {
     expect(db.status).toBe("ready");
   });
 
-  it("trans manages status lifecycle within connectWithoutTransaction", async () => {
+  it("transaction manages status lifecycle within connectWithoutTransaction", async () => {
     const db = createDbContext(TestDb, new MockExecutor(), {
       database: "TestDb",
     });
@@ -108,7 +108,7 @@ describe("createDbContext", () => {
     await db.connectWithoutTransaction(async () => {
       await Promise.resolve();
       expect(db.status).toBe("connect");
-      await db.trans(async () => {
+      await db.transaction(async () => {
         await Promise.resolve();
         expect(db.status).toBe("transact");
       });
@@ -166,14 +166,14 @@ describe("createDbContext", () => {
     expect(db.status).toBe("ready");
   });
 
-  it("trans throws when already in transaction state", async () => {
+  it("transaction throws when already in transaction state", async () => {
     const db = createDbContext(TestDb, new MockExecutor(), {
       database: "TestDb",
     });
 
     await db.connect(async () => {
       // Already in transact state via connect
-      await expect(db.trans(async () => {})).rejects.toThrow("Already in TRANSACTION state.");
+      await expect(db.transaction(async () => {})).rejects.toThrow("Already in TRANSACTION state.");
     });
   });
 

package/tests/ddl/basic.expected.ts

@@ -212,19 +212,19 @@ export const renameColumn: ExpectedSql = {
 
 //#region ========== Primary Key ==========
 
-export const dropPk: ExpectedSql = {
+export const dropPrimaryKey: ExpectedSql = {
   mysql: mysql`ALTER TABLE \`TestDb\`.\`User\` DROP PRIMARY KEY`,
   mssql: tsql`ALTER TABLE [TestDb].[TestSchema].[User] DROP CONSTRAINT [PK_User]`,
   postgresql: pgsql`ALTER TABLE "TestSchema"."User" DROP CONSTRAINT "PK_User"`,
 };
 
-export const addPk: ExpectedSql = {
+export const addPrimaryKey: ExpectedSql = {
   mysql: mysql`ALTER TABLE \`TestDb\`.\`User\` ADD PRIMARY KEY (\`id\`)`,
   mssql: tsql`ALTER TABLE [TestDb].[TestSchema].[User] ADD CONSTRAINT [PK_User] PRIMARY KEY ([id])`,
   postgresql: pgsql`ALTER TABLE "TestSchema"."User" ADD CONSTRAINT "PK_User" PRIMARY KEY ("id")`,
 };
 
-export const addPkComposite: ExpectedSql = {
+export const addPrimaryKeyComposite: ExpectedSql = {
   mysql: mysql`ALTER TABLE \`TestDb\`.\`UserRole\` ADD PRIMARY KEY (\`userId\`, \`roleId\`)`,
   mssql: tsql`ALTER TABLE [TestDb].[TestSchema].[UserRole] ADD CONSTRAINT [PK_UserRole] PRIMARY KEY ([userId], [roleId])`,
   postgresql: pgsql`ALTER TABLE "TestSchema"."UserRole" ADD CONSTRAINT "PK_UserRole" PRIMARY KEY ("userId", "roleId")`,
@@ -234,7 +234,7 @@ export const addPkComposite: ExpectedSql = {
 
 //#region ========== Foreign Key / Index ==========
 
-export const addFk: ExpectedSql = {
+export const addForeignKey: ExpectedSql = {
   mysql: mysql`
 ALTER TABLE \`TestDb\`.\`Post\` ADD CONSTRAINT \`FK_Post_user\`
 FOREIGN KEY (\`userId\`) REFERENCES \`TestDb\`.\`User\` (\`id\`)
@@ -251,25 +251,25 @@ CREATE INDEX "IDX_Post_Post_user" ON "TestSchema"."Post" ("userId");
   `,
 };
 
-export const dropFk: ExpectedSql = {
+export const dropForeignKey: ExpectedSql = {
   mysql: mysql`ALTER TABLE \`TestDb\`.\`Post\` DROP FOREIGN KEY \`FK_Post_user\``,
   mssql: tsql`ALTER TABLE [TestDb].[TestSchema].[Post] DROP CONSTRAINT [FK_Post_user]`,
   postgresql: pgsql`ALTER TABLE "TestSchema"."Post" DROP CONSTRAINT "FK_Post_user"`,
 };
 
-export const addIdx: ExpectedSql = {
+export const addIndex: ExpectedSql = {
   mysql: mysql`CREATE UNIQUE INDEX \`IDX_User_email\` ON \`TestDb\`.\`User\` (\`email\` ASC)`,
   mssql: tsql`CREATE UNIQUE INDEX [IDX_User_email] ON [TestDb].[TestSchema].[User] ([email] ASC)`,
   postgresql: pgsql`CREATE UNIQUE INDEX "IDX_User_email" ON "TestSchema"."User" ("email" ASC)`,
 };
 
-export const dropIdx: ExpectedSql = {
+export const dropIndex: ExpectedSql = {
   mysql: mysql`DROP INDEX \`IDX_User_email\` ON \`TestDb\`.\`User\``,
   mssql: tsql`DROP INDEX [IDX_User_email] ON [TestDb].[TestSchema].[User]`,
   postgresql: pgsql`DROP INDEX "TestSchema"."IDX_User_email"`,
 };
 
-export const dropIdxComposite: ExpectedSql = {
+export const dropIndexComposite: ExpectedSql = {
   mysql: mysql`DROP INDEX \`IDX_User_name_email\` ON \`TestDb\`.\`User\``,
   mssql: tsql`DROP INDEX [IDX_User_name_email] ON [TestDb].[TestSchema].[User]`,
   postgresql: pgsql`DROP INDEX "TestSchema"."IDX_User_name_email"`,

package/tests/ddl/basic.spec.ts

@@ -295,32 +295,32 @@ describe("DDL - Column", () => {
 });
 
 describe("DDL - Primary Key", () => {
-  describe("getDropPkQueryDef", () => {
+  describe("getDropPrimaryKeyQueryDef", () => {
     const db = createTestDb();
-    const def = db.getDropPkQueryDef({ database: "TestDb", schema: "TestSchema", name: "User" });
+    const def = db.getDropPrimaryKeyQueryDef({ database: "TestDb", schema: "TestSchema", name: "User" });
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "dropPk",
+        type: "dropPrimaryKey",
         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.dropPk[dialect]);
+      expect(builder.build(def)).toMatchSql(expected.dropPrimaryKey[dialect]);
     });
   });
 
-  describe("getAddPkQueryDef", () => {
+  describe("getAddPrimaryKeyQueryDef", () => {
     const db = createTestDb();
-    const def = db.getAddPkQueryDef({ database: "TestDb", schema: "TestSchema", name: "User" }, [
+    const def = db.getAddPrimaryKeyQueryDef({ database: "TestDb", schema: "TestSchema", name: "User" }, [
       "id",
     ]);
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "addPk",
+        type: "addPrimaryKey",
         table: { database: "TestDb", schema: "TestSchema", name: "User" },
         columns: ["id"],
       });
@@ -328,21 +328,21 @@ describe("DDL - Primary Key", () => {
 
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.addPk[dialect]);
+      expect(builder.build(def)).toMatchSql(expected.addPrimaryKey[dialect]);
     });
   });
 
 });
 
 describe("DDL - Foreign Key / Index", () => {
-  describe("getAddFkQueryDef", () => {
+  describe("getAddForeignKeyQueryDef", () => {
     const db = createTestDb();
     const userRelation = Post.meta.relations?.["user"];
     if (!(userRelation instanceof ForeignKeyBuilder)) {
       throw new Error("user relation not found");
     }
 
-    const def = db.getAddFkQueryDef(
+    const def = db.getAddForeignKeyQueryDef(
       { database: "TestDb", schema: "TestSchema", name: "Post" },
       "user",
       userRelation,
@@ -350,7 +350,7 @@ describe("DDL - Foreign Key / Index", () => {
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "addFk",
+        type: "addForeignKey",
         table: { database: "TestDb", schema: "TestSchema", name: "Post" },
         foreignKey: {
           name: "FK_Post_user",
@@ -363,20 +363,20 @@ describe("DDL - Foreign Key / Index", () => {
 
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.addFk[dialect]);
+      expect(builder.build(def)).toMatchSql(expected.addForeignKey[dialect]);
     });
   });
 
-  describe("getDropFkQueryDef", () => {
+  describe("getDropForeignKeyQueryDef", () => {
     const db = createTestDb();
-    const def = db.getDropFkQueryDef(
+    const def = db.getDropForeignKeyQueryDef(
       { database: "TestDb", schema: "TestSchema", name: "Post" },
       "user",
     );
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "dropFk",
+        type: "dropForeignKey",
         table: { database: "TestDb", schema: "TestSchema", name: "Post" },
         foreignKey: "FK_Post_user",
       });
@@ -384,22 +384,22 @@ describe("DDL - Foreign Key / Index", () => {
 
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.dropFk[dialect]);
+      expect(builder.build(def)).toMatchSql(expected.dropForeignKey[dialect]);
     });
   });
 
-  describe("getAddIdxQueryDef", () => {
+  describe("getAddIndexQueryDef", () => {
     const db = createTestDb();
     const indexBuilder = new IndexBuilder({ columns: ["email"] as string[], unique: true });
 
-    const def = db.getAddIdxQueryDef(
+    const def = db.getAddIndexQueryDef(
       { database: "TestDb", schema: "TestSchema", name: "User" },
       indexBuilder,
     );
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "addIdx",
+        type: "addIndex",
         table: { database: "TestDb", schema: "TestSchema", name: "User" },
         index: {
           name: "IDX_User_email",
@@ -411,19 +411,19 @@ describe("DDL - Foreign Key / Index", () => {
 
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.addIdx[dialect]);
+      expect(builder.build(def)).toMatchSql(expected.addIndex[dialect]);
     });
   });
 
-  describe("getDropIdxQueryDef", () => {
+  describe("getDropIndexQueryDef", () => {
     const db = createTestDb();
-    const def = db.getDropIdxQueryDef({ database: "TestDb", schema: "TestSchema", name: "User" }, [
+    const def = db.getDropIndexQueryDef({ database: "TestDb", schema: "TestSchema", name: "User" }, [
       "email",
     ]);
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "dropIdx",
+        type: "dropIndex",
         table: { database: "TestDb", schema: "TestSchema", name: "User" },
         index: "IDX_User_email",
       });
@@ -431,7 +431,7 @@ describe("DDL - Foreign Key / Index", () => {
 
     it.each(dialects)("[%s] should validate SQL", (dialect) => {
       const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.dropIdx[dialect]);
+      expect(builder.build(def)).toMatchSql(expected.dropIndex[dialect]);
     });
   });
 

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

@@ -12,14 +12,14 @@ describe("DDL - Index Builder", () => {
   describe("IndexBuilder - single column index", () => {
     const db = createTestDb();
     const indexBuilder = IndexFactory.index("email");
-    const def = db.getAddIdxQueryDef(
+    const def = db.getAddIndexQueryDef(
       { database: "TestDb", schema: "TestSchema", name: "User" },
       indexBuilder,
     );
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "addIdx",
+        type: "addIndex",
         table: { database: "TestDb", schema: "TestSchema", name: "User" },
         index: {
           name: "IDX_User_email",
@@ -38,14 +38,14 @@ describe("DDL - Index Builder", () => {
   describe("IndexBuilder - unique index", () => {
     const db = createTestDb();
     const indexBuilder = IndexFactory.index("email").unique();
-    const def = db.getAddIdxQueryDef(
+    const def = db.getAddIndexQueryDef(
       { database: "TestDb", schema: "TestSchema", name: "User" },
       indexBuilder,
     );
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "addIdx",
+        type: "addIndex",
         table: { database: "TestDb", schema: "TestSchema", name: "User" },
         index: {
           name: "IDX_User_email",
@@ -64,14 +64,14 @@ describe("DDL - Index Builder", () => {
   describe("IndexBuilder - composite index", () => {
     const db = createTestDb();
     const indexBuilder = IndexFactory.index("name", "email");
-    const def = db.getAddIdxQueryDef(
+    const def = db.getAddIndexQueryDef(
       { database: "TestDb", schema: "TestSchema", name: "User" },
       indexBuilder,
     );
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "addIdx",
+        type: "addIndex",
         table: { database: "TestDb", schema: "TestSchema", name: "User" },
         index: {
           name: "IDX_User_name_email",
@@ -93,14 +93,14 @@ describe("DDL - Index Builder", () => {
   describe("IndexBuilder - orderBy specified", () => {
     const db = createTestDb();
     const indexBuilder = IndexFactory.index("name", "email").orderBy("DESC", "ASC");
-    const def = db.getAddIdxQueryDef(
+    const def = db.getAddIndexQueryDef(
       { database: "TestDb", schema: "TestSchema", name: "User" },
       indexBuilder,
     );
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "addIdx",
+        type: "addIndex",
         table: { database: "TestDb", schema: "TestSchema", name: "User" },
         index: {
           name: "IDX_User_name_email",
@@ -122,14 +122,14 @@ describe("DDL - Index Builder", () => {
   describe("IndexBuilder - name specified", () => {
     const db = createTestDb();
     const indexBuilder = IndexFactory.index("email").name("UQ_User_email");
-    const def = db.getAddIdxQueryDef(
+    const def = db.getAddIndexQueryDef(
       { database: "TestDb", schema: "TestSchema", name: "User" },
       indexBuilder,
     );
 
     it("should validate QueryDef", () => {
       expect(def).toEqual({
-        type: "addIdx",
+        type: "addIndex",
         table: { database: "TestDb", schema: "TestSchema", name: "User" },
         index: {
           name: "UQ_User_email",