chore: remove retryable

Author: edvincandon

ARCHITECTURE.md

@@ -168,22 +168,6 @@ Implement `StateHandler` for any shape. The contract:
 - **Fail:** stashes the transition (reverts to the trailing fallback)
 - **Use case:** user deletes an entity, server rejects — undo the deletion, restore the entity
 
-### Retry
-
-Retry is always a consumer concern — timing, backoff, and reconnect logic belong in your app. The library provides:
-
-```typescript
-import { retryTransition, selectFailedTransition, selectRetryCount } from '@lostsolution/optimistron';
-
-const failed = selectFailedTransition(id)(state.todos);
-if (failed) {
-  const retries = selectRetryCount(id)(state.todos);
-  if (retries < 3) dispatch(retryTransition(failed)); // strips failure flags, re-stages
-}
-```
-
-When `processTransition` overwrites a failed transition (re-stage or amend after fail), it increments `retryCount` and sets `lastRetry` (timestamp).
-
 ---
 
 ## Async Patterns
@@ -356,10 +340,6 @@ const crud = crudPrepare<ProjectTodo>()(['projectId', 'id']);
 // transitionId: "projectId-value/id-value"
 ```
 
-### `retryTransition(action)`
-
-Strips `failed` and `conflict` flags from a `StagedAction`, returning a clean action for re-dispatch.
-
 ### Selectors
 
 All transition selectors are curried: `selector(id)(transitionState)`.
@@ -371,7 +351,6 @@ All transition selectors are curried: `selector(id)(transitionState)`.
 | `selectIsConflicting(id)` | `boolean` — transition conflicts with committed state |
 | `selectFailedTransition(id)` | `StagedAction \| undefined` |
 | `selectConflictingTransition(id)` | `StagedAction \| undefined` |
-| `selectRetryCount(id)` | `number` — times re-staged after failure |
 | `selectFailedTransitions` | `(state) => StagedAction[]` — all failed in one slice |
 | `selectAllFailedTransitions` | `(...states) => StagedAction[]` — across slices |
 

README.md

@@ -242,17 +242,6 @@ selectIsFailed(id)(state.todos); // failed?
 selectIsConflicting(id)(state.todos); // stale conflict?
 ```
 
-### Retry
-
-```typescript
-import { retryTransition, selectFailedTransition, selectRetryCount } from '@lostsolution/optimistron';
-
-const failed = selectFailedTransition(id)(state.todos);
-if (failed && selectRetryCount(id)(state.todos) < 3) {
-    dispatch(retryTransition(failed));
-}
-```
-
 ### Aggregate failures
 
 ```typescript

src/index.ts

@@ -8,12 +8,11 @@ export {
     selectIsConflicting,
     selectIsFailed,
     selectIsOptimistic,
-    selectRetryCount,
 } from './selectors/selectors';
 export { listState } from './state/list';
 export { nestedRecordState, recordState } from './state/record';
 export { singularState } from './state/singular';
-export { isTransition, Operation, OptimisticMergeResult, retryTransition, TransitionMode } from './transitions';
+export { isTransition, Operation, OptimisticMergeResult, TransitionMode } from './transitions';
 
 export type { HandlerReducer, ReducerConfig } from './reducer';
 export type { ActionMatcher, BoundStateHandler, CrudActionMap, StateHandler, TransitionState, VersioningOptions, WiredStateHandler } from './state/types';

src/selectors/selectors.ts

@@ -52,11 +52,3 @@ export const selectIsConflicting =
 
 /** Returns all failed transitions across multiple transition states */
 export const selectAllFailedTransitions = (...states: TransitionState<any>[]): StagedAction[] => states.flatMap(selectFailedTransitions);
-
-/** Returns the retry count for a transition, or 0 if not found */
-export const selectRetryCount =
-    (transitionId: string) =>
-    <State>({ transitions }: TransitionState<State>): number => {
-        const action = transitions.find((a) => getTransitionMeta(a).id === transitionId);
-        return action ? (getTransitionMeta(action).retryCount ?? 0) : 0;
-    };

src/transitions.ts

@@ -42,8 +42,6 @@ export type Transition<T = Operation> = {
     conflict?: boolean;
     failed?: boolean;
     trailing?: StagedAction;
-    retryCount?: number;
-    lastRetry?: number;
 };
 
 /** Extracts the transition meta definitions on an action */
@@ -84,9 +82,6 @@ export const toStaged = <P>(action: TransitionAction<Operation, P>, update: Part
 export const toCommit = <P>(action: TransitionAction<Operation, P>, update: Partial<Transition> = {}): CommittedAction<P> =>
     updateTransition({ ...action, type: toType(action.type, Operation.COMMIT) }, { ...update, operation: Operation.COMMIT });
 
-/** Strips failure/conflict flags from a staged action, making it ready for re-dispatch */
-export const retryTransition = <P>(action: StagedAction<P>): StagedAction<P> => updateTransition(action, { failed: undefined, conflict: undefined });
-
 export const processTransition = (transition: TransitionAction, transitions: StagedAction[]): StagedAction[] => {
     const { operation, id, mode } = getTransitionMeta(transition);
     const matchIdx = transitions.findIndex((entry) => id === getTransitionID(entry));
@@ -110,14 +105,11 @@ export const processTransition = (transition: TransitionAction, transitions: Sta
             const existingMeta = getTransitionMeta(existing);
             const trailing = existing.type === transition.type ? existingMeta.trailing : existing;
 
-            /** When overwriting a failed transition, track retry metadata */
-            const retryMeta: Partial<Transition> = existingMeta.failed ? { retryCount: (existingMeta.retryCount ?? 0) + 1, lastRetry: Date.now() } : {};
-
             /* REVERTIBLE mode stores the previous transition as a trailing transition.
              * This enables reversion to the previous state when stashing. */
             if (mode === TransitionMode.REVERTIBLE) {
-                nextTransitions[matchIdx] = updateTransition(stage, { ...retryMeta, trailing });
-            } else nextTransitions[matchIdx] = updateTransition(stage, retryMeta);
+                nextTransitions[matchIdx] = updateTransition(stage, { trailing });
+            } else nextTransitions[matchIdx] = stage;
 
             return nextTransitions;
         }

test/integration/record.spec.ts

@@ -97,8 +97,6 @@ describe('optimistron', () => {
 
                         expect(nextAfterRestage.state).toStrictEqual(initial.state);
                         expect(nextAfterRestage.transitions.length).toBe(1);
-                        expect(getTransitionMeta(nextAfterRestage.transitions[0]).retryCount).toBe(1);
-                        expect(getTransitionMeta(nextAfterRestage.transitions[0]).lastRetry).toBeNumber();
                         expect(selectOptimistic(selectState)(nextAfterRestage)).toStrictEqual({ [item.id]: item });
                         expect(selectIsOptimistic(item.id)(nextAfterRestage)).toBe(true);
                         expect(selectIsFailed(item.id)(nextAfterRestage)).toBe(false);
@@ -111,8 +109,6 @@ describe('optimistron', () => {
                         expect(nextAfterAmend.state).toStrictEqual(initial.state);
                         expect(nextAfterAmend.transitions.length).toBe(1);
                         expect(getTransitionMeta(nextAfterAmend.transitions[0]).failed).toBe(true);
-                        expect(getTransitionMeta(nextAfterAmend.transitions[0]).retryCount).toBe(1);
-                        expect(getTransitionMeta(nextAfterAmend.transitions[0]).lastRetry).toBeNumber();
                         expect(selectOptimistic(selectState)(nextAfterAmend)).toStrictEqual({ [item.id]: amendedItem });
                         expect(selectIsOptimistic(item.id)(nextAfterAmend)).toBe(true);
                         expect(selectIsFailed(item.id)(nextAfterAmend)).toBe(true);

test/unit/selectors.spec.ts

@@ -8,7 +8,6 @@ import {
     selectIsConflicting,
     selectIsFailed,
     selectIsOptimistic,
-    selectRetryCount,
 } from '~selectors/selectors';
 import { create, createIndexedState, createItem, indexedState, reducer, selectState } from '~test/utils';
 import { updateTransition } from '~transitions';
@@ -131,21 +130,4 @@ describe('selectors', () => {
             expect(selectAllFailedTransitions()).toEqual([]);
         });
     });
-
-    describe('selectRetryCount', () => {
-        test('should return 0 for non-existent transition', () => {
-            expect(selectRetryCount('unknown')(createIndexedState())).toBe(0);
-        });
-
-        test('should return 0 for transition without retryCount', () => {
-            const state = createIndexedState([stage]);
-            expect(selectRetryCount(item.id)(state)).toBe(0);
-        });
-
-        test('should return retryCount from transition meta', () => {
-            const retried = updateTransition(stage, { retryCount: 3 });
-            const state = createIndexedState([retried]);
-            expect(selectRetryCount(item.id)(state)).toBe(3);
-        });
-    });
 });

test/unit/transitions.spec.ts

@@ -4,16 +4,7 @@ import { bindReducer } from '~reducer';
 import { bindStateFactory } from '~state/factory';
 import { create, createIndexedState, createItem, edit, indexedState, reducer } from '~test/utils';
 import type { StagedAction, TransitionAction } from '~transitions';
-import {
-    TransitionMode,
-    OptimisticMergeResult,
-    getTransitionMeta,
-    processTransition,
-    retryTransition,
-    sanitizeTransitions,
-    toCommit,
-    updateTransition,
-} from '~transitions';
+import { TransitionMode, OptimisticMergeResult, getTransitionMeta, processTransition, sanitizeTransitions, toCommit, updateTransition } from '~transitions';
 
 const TestTransitionID = `${Math.random()}`;
 
@@ -168,61 +159,6 @@ describe('processTransition', () => {
     });
 });
 
-describe('retryTransition', () => {
-    test('should strip failed and conflict flags', () => {
-        const stage = transition.stage(TestTransitionID, 1);
-        const failed = updateTransition(stage, { failed: true, conflict: true });
-        const retried = retryTransition(failed);
-
-        expect(getTransitionMeta(retried).failed).toBeUndefined();
-        expect(getTransitionMeta(retried).conflict).toBeUndefined();
-        expect(getTransitionMeta(retried).id).toBe(TestTransitionID);
-        expect(retried.payload).toEqual(stage.payload);
-    });
-
-    test('should preserve other meta fields', () => {
-        const stage = transition.stage(TestTransitionID, 1);
-        const withRetry = updateTransition(stage, { failed: true, retryCount: 3, lastRetry: 12345 });
-        const retried = retryTransition(withRetry);
-
-        expect(getTransitionMeta(retried).retryCount).toBe(3);
-        expect(getTransitionMeta(retried).lastRetry).toBe(12345);
-    });
-});
-
-describe('processTransition retry metadata', () => {
-    test('should increment retryCount when overwriting a failed transition', () => {
-        const stage = transition.stage(TestTransitionID, 1);
-        const fail = transition.fail(TestTransitionID, new Error());
-        const restage = transition.stage(TestTransitionID, 2);
-
-        const afterFail = applyTransitions(stage, fail);
-        const afterRestage = processTransition(restage, afterFail);
-
-        expect(getTransitionMeta(afterRestage[0]).retryCount).toBe(1);
-        expect(getTransitionMeta(afterRestage[0]).lastRetry).toBeNumber();
-    });
-
-    test('should accumulate retryCount across multiple retries', () => {
-        const stage = transition.stage(TestTransitionID, 1);
-        const fail1 = transition.fail(TestTransitionID, new Error());
-        const restage1 = transition.stage(TestTransitionID, 2);
-        const fail2 = transition.fail(TestTransitionID, new Error());
-        const restage2 = transition.stage(TestTransitionID, 3);
-
-        const result = applyTransitions(stage, fail1, restage1, fail2, restage2);
-        expect(getTransitionMeta(result[0]).retryCount).toBe(2);
-    });
-
-    test('should not add retryCount when overwriting a non-failed transition', () => {
-        const stage1 = transition.stage(TestTransitionID, 1);
-        const stage2 = transition.stage(TestTransitionID, 2);
-
-        const result = applyTransitions(stage1, stage2);
-        expect(getTransitionMeta(result[0]).retryCount).toBeUndefined();
-    });
-});
-
 describe('sanitizeTransition', () => {
     const item = createItem();