@augmentcode/ag-redux-toolkit
Version:
Redux + Saga state management for Svelte apps — designed for AI agents. Includes runtime TypeScript source, AI skills, and reference documentation for robust, observable, high-performance state management.
177 lines (176 loc) • 5.88 kB
JavaScript
import { addCrash, startSaga, stopSaga } from "../saga-manager-slice.js";
import { selectUpdatesLocked } from "../../store-utility/store-utility-selectors.js";
import { unlockUpdates } from "../../store-utility/store-utility-slice.js";
import { call, delay, fork, put, setContext, takeEvery } from "typed-redux-saga";
//#region src/slices/saga-manager/sagas/manager.ts
var DECREASE_RESTARTS_COUNT_DELAY = 60 * 1e3;
var RESTART_DELAY = 1e3;
var MAX_RESTART_DELAY = 600 * 1e3;
var getBackOffDelay = (restarts) => {
return Math.min(RESTART_DELAY * Math.pow(2, restarts), MAX_RESTART_DELAY);
};
var createSagaStatusRecord = () => ({
isRunning: false,
launchedAtTs: null,
crashes: []
});
var cloneSagaStatusRecord = (status) => ({
...status,
crashes: status.crashes.map((crash) => ({ ...crash }))
});
var toError = (error) => {
return error instanceof Error ? error : new Error(String(error));
};
var serializeSagaError = (error) => {
if (error instanceof Error) {
const serializedError = {
name: error.name || "Error",
message: error.message
};
if (typeof error.stack === "string") serializedError.stack = error.stack;
return serializedError;
}
return {
name: "Error",
message: String(error)
};
};
var serializeSagaCrashReport = (error, crashedAtTs) => ({
crashedAtTs,
error: serializeSagaError(error)
});
var autoRestart = (sagaName, sagaFn, onCrash, initialCrashes = []) => {
return function* autoRestarting(...args) {
let restarts = 0;
let restartsCount = 0;
let lastTimeStarted = +/* @__PURE__ */ new Date();
const crashes = initialCrashes.map((crash) => ({ ...crash }));
while (true) try {
yield* call(sagaFn, ...args);
break;
} catch (e) {
const crashedAtTs = Date.now();
const error = toError(e);
const crashReport = serializeSagaCrashReport(e, crashedAtTs);
crashes.push({
crashedAt: new Date(crashedAtTs),
error
});
onCrash?.([...crashes]);
yield* put(addCrash(sagaName, crashReport));
if (yield* selectUpdatesLocked.effect()) yield* put(unlockUpdates());
const backoffDelay = getBackOffDelay(restarts);
restartsCount++;
restarts = Math.max(0, restarts - Math.floor((+/* @__PURE__ */ new Date() - lastTimeStarted) / DECREASE_RESTARTS_COUNT_DELAY)) + 1;
lastTimeStarted = +/* @__PURE__ */ new Date();
const errorMessage = `Saga "${sagaName}" crashed ${restartsCount === 1 ? "first time" : restartsCount + " times"}. Restarting... (restart in ${backoffDelay / 1e3}s)\n`;
console.error(errorMessage, e);
yield* delay(backoffDelay);
}
};
};
/**
* The saga manager orchestrates lifecycle of started sagas.
* Store.runSaga sends both the saga name and function so sagas registered after
* Store.init() can be started and retained for restart handling.
*
* @param reduxStore - The actual Redux store exposed to selector-channel effects
* @param exposeContext - Callback to expose saga status for monitoring/debugging
*/
function* sagaManager(reduxStore, exposeContext) {
yield* setContext({ reduxStore });
const startedSagas = /* @__PURE__ */ new Map();
const runningTasks = /* @__PURE__ */ new Map();
const sagaStatuses = /* @__PURE__ */ new Map();
const getSagaStatus = (sagaName) => {
const existingStatus = sagaStatuses.get(sagaName);
if (existingStatus) return existingStatus;
const newStatus = createSagaStatusRecord();
sagaStatuses.set(sagaName, newStatus);
return newStatus;
};
const setSagaStatus = (sagaName, updater) => {
sagaStatuses.set(sagaName, updater(getSagaStatus(sagaName)));
};
const updateContext = () => {
exposeContext(Object.fromEntries(Array.from(sagaStatuses.keys()).map((name) => {
return [name, cloneSagaStatusRecord(getSagaStatus(name))];
})));
};
yield* takeEvery(startSaga, function* (action) {
const [sagaName, saga] = action.payload;
const runningTask = runningTasks.get(sagaName);
if (runningTask) if (!runningTask.task.isRunning()) {
runningTasks.delete(sagaName);
setSagaStatus(sagaName, (status) => ({
...status,
isRunning: false
}));
} else {
const storedSaga = startedSagas.get(sagaName);
if (storedSaga && storedSaga !== saga) throw new Error(`Saga "${sagaName}" is already running with a different saga function.`);
const updatedRecord = {
...runningTask,
counter: runningTask.counter + 1
};
runningTasks.set(sagaName, updatedRecord);
updateContext();
return;
}
startedSagas.set(sagaName, saga);
const startedSaga = startedSagas.get(sagaName);
if (!startedSaga) {
console.error(`Saga "${sagaName}" not found in registry`);
return;
}
const task = yield* fork(autoRestart(sagaName, startedSaga, (crashes) => {
setSagaStatus(sagaName, (status) => ({
...status,
crashes: [...crashes]
}));
updateContext();
}, getSagaStatus(sagaName).crashes));
const isRunning = task.isRunning();
if (isRunning) {
const newTaskRecord = {
task,
name: sagaName,
counter: 1
};
runningTasks.set(sagaName, newTaskRecord);
}
setSagaStatus(sagaName, (status) => ({
...status,
isRunning,
launchedAtTs: Date.now()
}));
updateContext();
});
yield* takeEvery(stopSaga, function(action) {
const [sagaName] = action.payload;
const runningTask = runningTasks.get(sagaName);
if (!runningTask) return;
const updatedRecord = {
...runningTask,
counter: runningTask.counter - 1
};
if (updatedRecord.counter <= 0) updatedRecord.task.cancel();
if (updatedRecord.task.isCancelled()) {
runningTasks.delete(sagaName);
setSagaStatus(sagaName, (status) => ({
...status,
isRunning: false
}));
} else {
runningTasks.set(sagaName, updatedRecord);
setSagaStatus(sagaName, (status) => ({
...status,
isRunning: updatedRecord.task.isRunning()
}));
}
updateContext();
});
}
//#endregion
export { getBackOffDelay, sagaManager };
//# sourceMappingURL=manager.js.map