cleanup

Author: YunchuWang

ENTITY_IMPLEMENTATION_PLAN.md

@@ -405,9 +405,6 @@ export class TaskHubGrpcClient {
    * @param operationName - The name of the operation to invoke.
    * @param input - Optional input data for the operation.
    * @param options - Optional signal options (e.g., scheduled time).
-   *
-   * @remarks
-   * Dotnet reference: DurableEntityClient.SignalEntityAsync
    */
   async signalEntity(
     id: EntityInstanceId,
@@ -451,9 +448,6 @@ export class TaskHubGrpcClient {
    * @param id - The ID of the entity to get.
    * @param includeState - Whether to include the entity's state in the response. Defaults to true.
    * @returns The entity metadata, or undefined if the entity does not exist.
-   *
-   * @remarks
-   * Dotnet reference: DurableEntityClient.GetEntityAsync
    */
   async getEntity<T = unknown>(
     id: EntityInstanceId,
@@ -491,7 +485,6 @@ export class TaskHubGrpcClient {
    *
    * @remarks
    * This method handles pagination automatically, fetching additional pages as needed.
-   * Dotnet reference: DurableEntityClient.GetAllEntitiesAsync
    */
   async *getEntities<T = unknown>(query?: EntityQuery): AsyncGenerator<EntityMetadata<T>, void, unknown> {
     let continuationToken: string | undefined = query?.continuationToken;
@@ -557,9 +550,6 @@ export class TaskHubGrpcClient {
    * @param request - The clean request specifying what to clean. Defaults to removing empty entities and releasing orphaned locks.
    * @param continueUntilComplete - Whether to continue until all cleaning is done, or return after one batch.
    * @returns The result of the clean operation.
-   *
-   * @remarks
-   * Dotnet reference: DurableEntityClient.CleanEntityStorageAsync
    */
   async cleanEntityStorage(
     request?: CleanEntityStorageRequest,

packages/durabletask-js/src/client/client.ts

@@ -10,8 +10,6 @@ import * as pb from "../proto/orchestrator_service_pb";
  * @remarks
  * Contains structured information about an error that occurred during
  * entity operation execution, including error type, message, and stack trace.
- *
- * Dotnet reference: src/Abstractions/TaskFailureDetails.cs
  */
 export interface TaskFailureDetails {
   /**
@@ -60,8 +58,6 @@ export function createTaskFailureDetails(proto: pb.TaskFailureDetails | undefine
  * @remarks
  * Detailed information associated with a particular operation failure, including exception details,
  * can be found in the `failureDetails` property.
- *
- * Dotnet reference: src/Abstractions/Entities/EntityOperationFailedException.cs
  */
 export class EntityOperationFailedException extends Error {
   /**

packages/durabletask-js/src/entities/entity-operation-failed-exception.ts

@@ -27,8 +27,6 @@ export interface CriticalSectionInfo {
  * @remarks
  * Use this to release locks acquired via `lockEntities`.
  * Typically used in a try/finally block to ensure locks are released.
- *
- * Dotnet reference: IAsyncDisposable returned by LockEntitiesAsync
  */
 export interface LockHandle {
   /**
@@ -45,8 +43,6 @@ export interface LockHandle {
  * - `callEntity` waits for a response from the entity.
  * - `signalEntity` is a one-way (fire-and-forget) operation that doesn't wait for a response.
  * - `lockEntities` acquires locks on multiple entities for critical sections.
- *
- * Dotnet reference: src/Abstractions/Entities/TaskOrchestrationEntityFeature.cs
  */
 export interface OrchestrationEntityFeature {
   /**
@@ -64,8 +60,6 @@ export interface OrchestrationEntityFeature {
    * Unlike `signalEntity`, this method waits for the entity to process the operation
    * and returns the result. If the entity operation throws an exception, this method
    * will throw an `EntityOperationFailedException` containing the failure details.
-   *
-   * Dotnet reference: TaskOrchestrationEntityFeature.CallEntityAsync
    */
   callEntity<TResult = void>(
     id: EntityInstanceId,
@@ -86,8 +80,6 @@ export interface OrchestrationEntityFeature {
    * This is a fire-and-forget operation. The orchestration will not wait for
    * the entity operation to complete. Use `callEntity` if you need to wait
    * for a response.
-   *
-   * Dotnet reference: TaskOrchestrationEntityFeature.SignalEntityAsync
    */
   signalEntity(
     id: EntityInstanceId,
@@ -114,8 +106,6 @@ export interface OrchestrationEntityFeature {
    * - You can call (but not signal) the locked entities
    * - You cannot call sub-orchestrations
    * - You cannot acquire additional locks (no nested critical sections)
-   *
-   * Dotnet reference: TaskOrchestrationEntityFeature.LockEntitiesAsync
    */
   lockEntities(...entityIds: EntityInstanceId[]): Task<LockHandle>;
 
@@ -124,8 +114,6 @@ export interface OrchestrationEntityFeature {
    *
    * @returns Information about the current critical section state.
    *
-   * @remarks
-   * Dotnet reference: TaskOrchestrationEntityFeature.InCriticalSection
    */
   isInCriticalSection(): CriticalSectionInfo;
 }

packages/durabletask-js/src/entities/orchestration-entity-feature.ts

@@ -7,8 +7,6 @@
  * @remarks
  * Signals are one-way (fire-and-forget) messages sent to entities.
  * The signalTime option allows scheduling a signal for future delivery.
- *
- * Dotnet reference: src/Abstractions/Entities/CallEntityOptions.cs - SignalEntityOptions
  */
 export interface SignalEntityOptions {
   /**
@@ -25,8 +23,6 @@ export interface SignalEntityOptions {
  * Currently empty, reserved for future extensibility.
  * Keeping this interface so we can ship with options in the API
  * and add properties later without breaking changes.
- *
- * Dotnet reference: src/Abstractions/Entities/CallEntityOptions.cs - CallEntityOptions
  */
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
 export interface CallEntityOptions {

packages/durabletask-js/src/entities/signal-entity-options.ts

@@ -28,8 +28,6 @@ export interface StartOrchestrationOptions {
  * @remarks
  * This context is available during entity operation execution and allows
  * the entity to interact with other entities and orchestrations.
- *
- * Dotnet reference: src/Abstractions/Entities/TaskEntityContext.cs
  */
 export interface TaskEntityContext {
   /**

packages/durabletask-js/src/entities/task-entity-context.ts

@@ -13,8 +13,6 @@ import { TaskEntityState } from "./task-entity-state";
  * - The operation input (if any)
  * - The entity context (for signaling other entities, scheduling orchestrations)
  * - The entity state (for reading/writing persistent state)
- *
- * Dotnet reference: src/Abstractions/Entities/TaskEntityOperation.cs
  */
 export interface TaskEntityOperation {
   /**

packages/durabletask-js/src/entities/task-entity-operation.ts

@@ -7,8 +7,6 @@
  * @remarks
  * This interface provides methods for getting and setting entity state during operation execution.
  * Setting state to null or undefined will delete the entity state.
- *
- * Dotnet reference: src/Abstractions/Entities/TaskEntityState.cs
  */
 export interface TaskEntityState {
   /**

packages/durabletask-js/src/entities/task-entity-state.ts

@@ -10,8 +10,6 @@ import { TaskEntityOperation } from "./task-entity-operation";
  * @remarks
  * This is the core interface that all entities must implement.
  * The state of an entity can be retrieved and updated via the operation's state property.
- *
- * Dotnet reference: src/Abstractions/Entities/TaskEntity.cs - ITaskEntity
  */
 export interface ITaskEntity {
   /**
@@ -50,8 +48,6 @@ export type EntityFactory<T extends ITaskEntity = ITaskEntity> = () => T;
  * This class supports the `delete` operation implicitly. When `delete` is called and no
  * explicit delete method exists, the entity state is set to null (deleted).
  * To override this behavior, implement a `delete()` method on your entity.
- *
- * Dotnet reference: src/Abstractions/Entities/TaskEntity.cs - TaskEntity<TState>
  */
 export abstract class TaskEntity<TState> implements ITaskEntity {
   /**

packages/durabletask-js/src/entities/task-entity.ts

@@ -46,8 +46,6 @@ export abstract class OrchestrationContext {
    * @remarks
    * Use this property to signal entities from within an orchestration.
    * Signaling is a one-way (fire-and-forget) operation.
-   *
-   * Dotnet reference: TaskOrchestrationContext.Entities
    */
   abstract get entities(): OrchestrationEntityFeature;