@simplysm/orm-common 13.0.75 → 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

@@ -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",
@@ -79,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 () => {
@@ -115,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",
     });
@@ -123,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");
       });
@@ -181,33 +166,17 @@ 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.");
     });
   });
 
-  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.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"`,