@fragno-dev/db 0.2.0 → 0.2.2

package/src/query/unit-of-work/unit-of-work-coordinator.test.ts

@@ -722,54 +722,54 @@ describe("UOW Coordinator - Parent-Child Execution", () => {
     // If we got here without Node.js throwing an unhandled rejection, the test passes
   });
 
-  it("should inherit nonce from parent to children for idempotent operations", () => {
+  it("should inherit idempotencyKey from parent to children for idempotent operations", () => {
     const executor = createMockExecutor();
     const parentUow = createUnitOfWork(createCompiler(), executor, createMockDecoder());
 
-    // Parent UOW should have a nonce
-    const parentNonce = parentUow.nonce;
-    expect(parentNonce).toBeDefined();
-    expect(typeof parentNonce).toBe("string");
-    expect(parentNonce.length).toBeGreaterThan(0);
+    // Parent UOW should have an idempotencyKey
+    const parentIdempotencyKey = parentUow.idempotencyKey;
+    expect(parentIdempotencyKey).toBeDefined();
+    expect(typeof parentIdempotencyKey).toBe("string");
+    expect(parentIdempotencyKey.length).toBeGreaterThan(0);
 
     // Create first child
     const child1 = parentUow.restrict();
-    expect(child1.nonce).toBe(parentNonce);
+    expect(child1.idempotencyKey).toBe(parentIdempotencyKey);
 
     // Create second child (sibling to child1)
     const child2 = parentUow.restrict();
-    expect(child2.nonce).toBe(parentNonce);
+    expect(child2.idempotencyKey).toBe(parentIdempotencyKey);
 
     // Create nested child (child of child1)
     const grandchild = child1.restrict();
-    expect(grandchild.nonce).toBe(parentNonce);
+    expect(grandchild.idempotencyKey).toBe(parentIdempotencyKey);
 
-    // All UOWs in the hierarchy should share the same nonce
-    expect(parentUow.nonce).toBe(child1.nonce);
-    expect(child1.nonce).toBe(child2.nonce);
-    expect(child2.nonce).toBe(grandchild.nonce);
+    // All UOWs in the hierarchy should share the same idempotencyKey
+    expect(parentUow.idempotencyKey).toBe(child1.idempotencyKey);
+    expect(child1.idempotencyKey).toBe(child2.idempotencyKey);
+    expect(child2.idempotencyKey).toBe(grandchild.idempotencyKey);
   });
 
-  it("should generate different nonces for separate UOW hierarchies", () => {
+  it("should generate different idempotencyKeys for separate UOW hierarchies", () => {
     const executor = createMockExecutor();
 
     // Create two separate parent UOWs
     const parentUow1 = createUnitOfWork(createCompiler(), executor, createMockDecoder());
     const parentUow2 = createUnitOfWork(createCompiler(), executor, createMockDecoder());
 
-    // They should have different nonces
-    expect(parentUow1.nonce).not.toBe(parentUow2.nonce);
+    // They should have different idempotencyKeys
+    expect(parentUow1.idempotencyKey).not.toBe(parentUow2.idempotencyKey);
 
-    // But children within each hierarchy should inherit their parent's nonce
+    // But children within each hierarchy should inherit their parent's idempotencyKey
     const child1 = parentUow1.restrict();
     const child2 = parentUow2.restrict();
 
-    expect(child1.nonce).toBe(parentUow1.nonce);
-    expect(child2.nonce).toBe(parentUow2.nonce);
-    expect(child1.nonce).not.toBe(child2.nonce);
+    expect(child1.idempotencyKey).toBe(parentUow1.idempotencyKey);
+    expect(child2.idempotencyKey).toBe(parentUow2.idempotencyKey);
+    expect(child1.idempotencyKey).not.toBe(child2.idempotencyKey);
   });
 
-  it.skip("should not cause unhandled rejection when service method awaits retrievalPhase and executeRetrieve fails", async () => {
+  it("should not cause unhandled rejection when service method awaits retrievalPhase and executeRetrieve fails", async () => {
     const testSchema = schema((s) =>
       s.addTable("settings", (t) =>
         t
@@ -828,4 +828,252 @@ describe("UOW Coordinator - Parent-Child Execution", () => {
 
     expect(await deferred.promise).toContain('relation "settings" does not exist');
   });
+
+  it("should allow child UOW to call getCreatedIds() after parent executes mutations", async () => {
+    const testSchema = schema((s) =>
+      s.addTable("products", (t) =>
+        t.addColumn("id", idColumn()).addColumn("name", "string").addColumn("price", "integer"),
+      ),
+    );
+
+    const executor = createMockExecutor();
+    const parentUow = createUnitOfWork(createCompiler(), executor, createMockDecoder());
+
+    // Service method that creates a product using a child UOW and returns the child
+    const createProduct = (name: string, price: number) => {
+      const childUow = parentUow.restrict();
+      const productId = childUow.forSchema(testSchema).create("products", { name, price });
+      // Return both the child UOW and the product ID reference
+      return { childUow, productId };
+    };
+
+    // Call service to create a product via child UOW
+    const { childUow, productId } = createProduct("Widget", 1999);
+
+    // Parent executes mutations
+    await parentUow.executeMutations();
+
+    // Child should be able to call getCreatedIds() after parent has executed
+    // This tests that child checks parent's state, not its own stale state
+    const createdIds = childUow.getCreatedIds();
+
+    expect(createdIds).toHaveLength(1);
+    expect(createdIds[0].externalId).toBe(productId.externalId);
+  });
+
+  it("should preserve internal IDs in child UOW when using two-phase pattern with mutationPhase await", async () => {
+    const testSchema = schema((s) =>
+      s.addTable("orders", (t) =>
+        t
+          .addColumn("id", idColumn())
+          .addColumn("customerId", "string")
+          .addColumn("total", "integer"),
+      ),
+    );
+
+    const executor = createMockExecutor();
+    const parentUow = createUnitOfWork(createCompiler(), executor, createMockDecoder());
+
+    // Service method that uses two-phase pattern (common with hooks/async operations)
+    // This simulates a service that creates a record and needs to return the internal ID
+    const createOrder = async (customerId: string, total: number) => {
+      const childUow = parentUow.restrict();
+      const typedUow = childUow.forSchema(testSchema);
+
+      const orderId = typedUow.create("orders", { customerId, total });
+
+      // Service awaits mutationPhase to coordinate with parent execution
+      await childUow.mutationPhase;
+
+      // After mutationPhase resolves, service should be able to get internal IDs
+      const createdIds = childUow.getCreatedIds();
+      const foundId = createdIds.find((id) => id.externalId === orderId.externalId);
+
+      return {
+        externalId: orderId.externalId,
+        internalId: foundId?.internalId,
+      };
+    };
+
+    // Handler orchestrates the service call and mutation execution
+    const handler = async () => {
+      const orderPromise = createOrder("customer-123", 9999);
+
+      // Execute mutations - this should resolve the service's mutationPhase await
+      await parentUow.executeMutations();
+
+      // Now the service can complete and return the result with internal ID
+      return await orderPromise;
+    };
+
+    const result = await handler();
+
+    // The key assertion: internal ID should be defined (not undefined)
+    // This tests that child UOW preserves shared reference to parent's createdInternalIds array
+    expect(result.internalId).toBeDefined();
+    expect(typeof result.internalId).toBe("bigint");
+    expect(result.internalId).toBeGreaterThan(0n);
+  });
+
+  it("should fail when handler executes mutations before service finishes scheduling them (anti-pattern)", async () => {
+    const testSchema = schema((s) =>
+      s.addTable("totp_secret", (t) =>
+        t
+          .addColumn("id", idColumn())
+          .addColumn("userId", "string")
+          .addColumn("secret", "string")
+          .addColumn("backupCodes", "string")
+          .createIndex("idx_totp_user", ["userId"]),
+      ),
+    );
+
+    // Create executor that returns empty results (no existing record)
+    const customExecutor: UOWExecutor<CompiledQuery, unknown> = {
+      executeRetrievalPhase: async (queries: CompiledQuery[]) => {
+        // Return empty array for each query (no existing records)
+        return queries.map(() => []);
+      },
+      executeMutationPhase: async (mutations: CompiledMutation<CompiledQuery>[]) => {
+        return {
+          success: true,
+          createdInternalIds: mutations.map(() => BigInt(Math.floor(Math.random() * 1000))),
+        };
+      },
+    };
+
+    const parentUow = createUnitOfWork(createCompiler(), customExecutor, createMockDecoder());
+
+    // Service that has async work AFTER awaiting retrievalPhase but BEFORE scheduling mutations
+    // This is a problematic pattern that can lead to race conditions
+    const enableTotp = async (userId: string) => {
+      const childUow = parentUow.restrict();
+      const typedUow = childUow
+        .forSchema(testSchema)
+        .findFirst("totp_secret", (b) =>
+          b.whereIndex("idx_totp_user", (eb) => eb("userId", "=", userId)),
+        );
+
+      // Service awaits retrieval phase
+      const [existing] = await typedUow.retrievalPhase;
+
+      if (existing) {
+        throw new Error("TOTP already enabled");
+      }
+
+      // Simulate async work (like hashing backup codes) that yields control
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      // By the time we get here, if the handler has already called executeMutate(),
+      // the UOW will be in "executed" state and this will fail
+      typedUow.create("totp_secret", {
+        userId,
+        secret: "TESTSECRET123",
+        backupCodes: "[]",
+      });
+
+      await typedUow.mutationPhase;
+
+      return { success: true };
+    };
+
+    // ANTI-PATTERN: Handler executes both phases immediately without awaiting service
+    const badHandler = async () => {
+      // Call service - returns promise immediately
+      const resultPromise = enableTotp("user-123");
+
+      // Execute retrieval phase
+      await parentUow.executeRetrieve();
+
+      // Execute mutation phase BEFORE service has finished scheduling mutations
+      // This is the bug - service is still running async work and hasn't scheduled mutations yet
+      await parentUow.executeMutations();
+
+      // Now await service promise - but it's too late, UOW is already in "executed" state
+      return await resultPromise;
+    };
+
+    // This should throw "Cannot add mutation operation in executed state"
+    await expect(badHandler()).rejects.toThrow("Cannot add mutation operation in executed state");
+  });
+
+  it("should succeed when handler awaits service promise between phases (correct pattern)", async () => {
+    const testSchema = schema((s) =>
+      s.addTable("totp_secret", (t) =>
+        t
+          .addColumn("id", idColumn())
+          .addColumn("userId", "string")
+          .addColumn("secret", "string")
+          .addColumn("backupCodes", "string")
+          .createIndex("idx_totp_user", ["userId"]),
+      ),
+    );
+
+    // Create executor that returns empty results (no existing record)
+    const customExecutor: UOWExecutor<CompiledQuery, unknown> = {
+      executeRetrievalPhase: async (queries: CompiledQuery[]) => {
+        return queries.map(() => []);
+      },
+      executeMutationPhase: async (mutations: CompiledMutation<CompiledQuery>[]) => {
+        return {
+          success: true,
+          createdInternalIds: mutations.map(() => BigInt(Math.floor(Math.random() * 1000))),
+        };
+      },
+    };
+
+    const parentUow = createUnitOfWork(createCompiler(), customExecutor, createMockDecoder());
+
+    // Same service as before - has async work between retrieval and mutation scheduling
+    const enableTotp = async (userId: string) => {
+      const childUow = parentUow.restrict();
+      const typedUow = childUow
+        .forSchema(testSchema)
+        .findFirst("totp_secret", (b) =>
+          b.whereIndex("idx_totp_user", (eb) => eb("userId", "=", userId)),
+        );
+
+      const [existing] = await typedUow.retrievalPhase;
+
+      if (existing) {
+        throw new Error("TOTP already enabled");
+      }
+
+      // Simulate async work (like hashing backup codes)
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      // Schedule mutation - this will work because handler waits for service to finish
+      typedUow.create("totp_secret", {
+        userId,
+        secret: "TESTSECRET123",
+        backupCodes: "[]",
+      });
+
+      return { success: true };
+    };
+
+    // CORRECT PATTERN: Handler awaits service promise between phase executions
+    const goodHandler = async () => {
+      // Call service first - it schedules retrieval operations synchronously
+      const resultPromise = enableTotp("user-123");
+
+      // Execute retrieval phase - service can now continue past its retrieval await
+      await parentUow.executeRetrieve();
+
+      // Wait for service to finish - it will schedule mutations
+      const result = await resultPromise;
+
+      // Execute mutations that service scheduled
+      await parentUow.executeMutations();
+
+      return result;
+    };
+
+    // This should succeed without errors
+    const result = await goodHandler();
+    expect(result.success).toBe(true);
+
+    // Verify operations were registered
+    expect(parentUow.getRetrievalOperations()).toHaveLength(1);
+    expect(parentUow.getMutationOperations()).toHaveLength(1);
+  });
 });

package/src/query/unit-of-work/unit-of-work.test.ts

@@ -838,6 +838,70 @@ describe("DeleteBuilder with string ID", () => {
   });
 });
 
+describe("generateId", () => {
+  const testSchema = schema((s) =>
+    s.addTable("users", (t) =>
+      t.addColumn("id", idColumn()).addColumn("email", "string").addColumn("name", "string"),
+    ),
+  );
+
+  it("should generate a new FragnoId without creating a record", () => {
+    const uow = createUnitOfWork(createMockCompiler(), createMockExecutor(), createMockDecoder());
+
+    const id = uow.forSchema(testSchema).generateId("users");
+
+    expect(id).toBeInstanceOf(FragnoId);
+    expect(id.externalId).toBeDefined();
+    expect(typeof id.externalId).toBe("string");
+    expect(id.externalId.length).toBeGreaterThan(0);
+    expect(id.version).toBe(0);
+
+    // No mutation operations should be added
+    expect(uow.getMutationOperations()).toHaveLength(0);
+  });
+
+  it("should generate unique IDs on each call", () => {
+    const uow = createUnitOfWork(createMockCompiler(), createMockExecutor(), createMockDecoder());
+    const typedUow = uow.forSchema(testSchema);
+
+    const id1 = typedUow.generateId("users");
+    const id2 = typedUow.generateId("users");
+
+    expect(id1.externalId).not.toBe(id2.externalId);
+  });
+
+  it("should allow using generated ID in create", async () => {
+    const executor = {
+      executeRetrievalPhase: async () => [],
+      executeMutationPhase: async () => ({
+        success: true,
+        createdInternalIds: [1n],
+      }),
+    };
+
+    const uow = createUnitOfWork(createMockCompiler(), executor, createMockDecoder());
+    const typedUow = uow.forSchema(testSchema);
+
+    const id = typedUow.generateId("users");
+    typedUow.create("users", { id, email: "test@example.com", name: "Test" });
+
+    await uow.executeMutations();
+    const createdIds = uow.getCreatedIds();
+
+    expect(createdIds).toHaveLength(1);
+    expect(createdIds[0].externalId).toBe(id.externalId);
+  });
+
+  it("should throw for non-existent table", () => {
+    const uow = createUnitOfWork(createMockCompiler(), createMockExecutor(), createMockDecoder());
+
+    expect(() => {
+      // @ts-expect-error - testing runtime error for non-existent table
+      uow.forSchema(testSchema).generateId("nonexistent");
+    }).toThrow("Table nonexistent not found in schema");
+  });
+});
+
 describe("getCreatedIds", () => {
   const testSchema = schema((s) =>
     s.addTable("users", (t) =>

package/src/query/unit-of-work/unit-of-work.ts

@@ -7,6 +7,7 @@ import type {
   Relation,
 } from "../../schema/create";
 import { FragnoId } from "../../schema/create";
+import { generateId } from "../../schema/generate-id";
 import type { Condition, ConditionBuilder } from "../condition-builder";
 import type {
   SelectClause,
@@ -262,13 +263,9 @@ export type MutationResult =
  * Executor interface for Unit of Work operations
  */
 export interface UOWExecutor<TOutput, TRawResult = unknown> {
-  /**
-   * Execute the retrieval phase - all queries run in a single transaction for snapshot isolation
-   */
   executeRetrievalPhase(retrievalBatch: TOutput[]): Promise<TRawResult[]>;
 
   /**
-   * Execute the mutation phase - all queries run in a transaction with version checks
    * Returns success status indicating if mutations completed without conflicts,
    * and internal IDs for create operations (null if database doesn't support RETURNING)
    */
@@ -903,7 +900,7 @@ export interface IUnitOfWork {
   // Getters (schema-agnostic)
   readonly state: UOWState;
   readonly name: string | undefined;
-  readonly nonce: string;
+  readonly idempotencyKey: string;
   readonly retrievalPhase: Promise<unknown[]>;
   readonly mutationPhase: Promise<void>;
 
@@ -917,7 +914,11 @@ export interface IUnitOfWork {
   getCreatedIds(): FragnoId[];
 
   // Parent-child relationships
-  restrict(): IUnitOfWork;
+  restrict(options?: { readyFor?: "mutation" | "retrieval" | "none" }): IUnitOfWork;
+
+  // Coordination for restricted UOWs
+  signalReadyForRetrieval(): void;
+  signalReadyForMutation(): void;
 
   // Reset for retry support
   reset(): void;
@@ -963,7 +964,7 @@ export function createUnitOfWork(
 export interface UnitOfWorkConfig {
   dryRun?: boolean;
   onQuery?: (query: unknown) => void;
-  nonce?: string;
+  idempotencyKey?: string;
 }
 
 /**
@@ -1195,7 +1196,7 @@ class UOWChildCoordinator<TRawInput> {
 export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
   #name?: string;
   #config?: UnitOfWorkConfig;
-  #nonce: string;
+  #idempotencyKey: string;
 
   #state: UOWState = "building-retrieval";
 
@@ -1239,7 +1240,7 @@ export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
     this.#schemaNamespaceMap = schemaNamespaceMap ?? new WeakMap();
     this.#name = name;
     this.#config = config;
-    this.#nonce = config?.nonce ?? crypto.randomUUID();
+    this.#idempotencyKey = config?.idempotencyKey ?? crypto.randomUUID();
   }
 
   /**
@@ -1275,20 +1276,25 @@ export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
    * Create a restricted child UOW that cannot execute phases.
    * The child shares the same operation storage but must signal readiness
    * before the parent can execute each phase.
+   *
+   * @param options.readyFor - Controls automatic readiness signaling:
+   *   - "mutation" (default): Signals ready for both retrieval and mutation immediately
+   *   - "retrieval": Signals ready for retrieval only
+   *   - "none": No automatic signaling, caller must signal manually
    */
-  restrict(): UnitOfWork<TRawInput> {
+  restrict(options?: { readyFor?: "mutation" | "retrieval" | "none" }): UnitOfWork<TRawInput> {
+    const readyFor = options?.readyFor ?? "mutation";
+
     const child = new UnitOfWork(
       this.#compiler,
       this.#executor,
       this.#decoder,
       this.#name,
-      { ...this.#config, nonce: this.#nonce },
+      { ...this.#config, idempotencyKey: this.#idempotencyKey },
       this.#schemaNamespaceMap,
     );
     child.#coordinator.setAsRestricted(this, this.#coordinator);
 
-    // Share state with parent
-    child.#state = this.#state;
     child.#retrievalOps = this.#retrievalOps;
     child.#mutationOps = this.#mutationOps;
     child.#retrievalResults = this.#retrievalResults;
@@ -1301,10 +1307,13 @@ export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
 
     this.#coordinator.addChild(child);
 
-    // For synchronous usage (the common case), immediately signal readiness
-    // This allows services called directly from handlers to work without explicit signaling
-    child.signalReadyForRetrieval();
-    child.signalReadyForMutation();
+    // Signal readiness based on options
+    if (readyFor === "mutation" || readyFor === "retrieval") {
+      child.signalReadyForRetrieval();
+    }
+    if (readyFor === "mutation") {
+      child.signalReadyForMutation();
+    }
 
     return child;
   }
@@ -1375,15 +1384,15 @@ export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
   }
 
   get state(): UOWState {
-    return this.#state;
+    return this.#coordinator.parent?.state ?? this.#state;
   }
 
   get name(): string | undefined {
     return this.#name;
   }
 
-  get nonce(): string {
-    return this.#nonce;
+  get idempotencyKey(): string {
+    return this.#idempotencyKey;
   }
 
   /**
@@ -1502,7 +1511,9 @@ export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
       this.#state = "executed";
 
       if (result.success) {
-        this.#createdInternalIds = result.createdInternalIds;
+        // Mutate array in-place to preserve shared references with child UOWs
+        this.#createdInternalIds.length = 0;
+        this.#createdInternalIds.push(...result.createdInternalIds);
       }
 
       // Resolve the mutation phase promise to unblock waiting service methods
@@ -1536,9 +1547,9 @@ export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
    * Add a retrieval operation (used by TypedUnitOfWork)
    */
   addRetrievalOperation(op: RetrievalOperation<AnySchema>): number {
-    if (this.#state !== "building-retrieval") {
+    if (this.state !== "building-retrieval") {
       throw new Error(
-        `Cannot add retrieval operation in state ${this.#state}. Must be in building-retrieval state.`,
+        `Cannot add retrieval operation in state ${this.state}. Must be in building-retrieval state.`,
       );
     }
     this.#retrievalOps.push(op);
@@ -1550,7 +1561,7 @@ export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
    * Add a mutation operation (used by TypedUnitOfWork)
    */
   addMutationOperation(op: MutationOperation<AnySchema>): void {
-    if (this.#state === "executed") {
+    if (this.state === "executed") {
       throw new Error(`Cannot add mutation operation in executed state.`);
     }
     this.#mutationOps.push(op);
@@ -1565,9 +1576,9 @@ export class UnitOfWork<const TRawInput = unknown> implements IUnitOfWork {
    * @returns Array of FragnoIds in the same order as create() calls
    */
   getCreatedIds(): FragnoId[] {
-    if (this.#state !== "executed") {
+    if (this.state !== "executed") {
       throw new Error(
-        `getCreatedIds() can only be called after executeMutations(). Current state: ${this.#state}`,
+        `getCreatedIds() can only be called after executeMutations(). Current state: ${this.state}`,
       );
     }
 
@@ -1660,8 +1671,8 @@ export class TypedUnitOfWork<
     return this.#uow.name;
   }
 
-  get nonce(): string {
-    return this.#uow.nonce;
+  get idempotencyKey(): string {
+    return this.#uow.idempotencyKey;
   }
 
   get state() {
@@ -1712,8 +1723,16 @@ export class TypedUnitOfWork<
     return this.#uow.executeMutations();
   }
 
-  restrict(): IUnitOfWork {
-    return this.#uow.restrict();
+  restrict(options?: { readyFor?: "mutation" | "retrieval" | "none" }): IUnitOfWork {
+    return this.#uow.restrict(options);
+  }
+
+  signalReadyForRetrieval(): void {
+    this.#uow.signalReadyForRetrieval();
+  }
+
+  signalReadyForMutation(): void {
+    this.#uow.signalReadyForMutation();
   }
 
   reset(): void {
@@ -1940,6 +1959,22 @@ export class TypedUnitOfWork<
     return this as any;
   }
 
+  /**
+   * Generate a new ID for a table without creating a record.
+   * This is useful when you need to reference an ID before actually creating the record,
+   * or when you need to pass the ID to external services.
+   *
+   * @example
+   * ```ts
+   * const userId = uow.generateId("users");
+   * // Use userId in related records or pass to external services
+   * uow.create("users", { id: userId, name: "John" });
+   * ```
+   */
+  generateId<TableName extends keyof TSchema["tables"] & string>(tableName: TableName): FragnoId {
+    return generateId(this.#schema, tableName);
+  }
+
   create<TableName extends keyof TSchema["tables"] & string>(
     tableName: TableName,
     values: TableToInsertValues<TSchema["tables"][TableName]>,

package/src/schema/create.ts

@@ -1,5 +1,6 @@
 import { createId } from "../id";
-import { inspect } from "node:util";
+
+export { generateId } from "./generate-id";
 
 export type AnySchema = Schema<Record<string, AnyTable>>;
 
@@ -548,10 +549,6 @@ export class FragnoId {
   valueOf(): string {
     return this.#externalId;
   }
-
-  [inspect.custom](): string {
-    return `FragnoId { externalId: ${this.#externalId}, internalId: ${this.#internalId?.toString()} }`;
-  }
 }
 
 /**