saga-toolkit 2.0.6 → 2.1.1

package/README.md

@@ -40,7 +40,7 @@ const slice = createSlice({
       result: payload,
       loading: false,
     }),
-    [fetchThings.rejected]: (state, { payload }) => ({
+    [fetchThings.rejected]: (state, { error }) => ({
       ...state,
       error,
       loading: false,

package/example/package-lock.json

@@ -1,11 +1,11 @@
 {
   "name": "example",
-  "version": "0.1.0",
+  "version": "0.0.1",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
-      "version": "0.1.0",
+      "version": "0.0.1",
       "dependencies": {
         "@reduxjs/toolkit": "^1.6.1",
         "@testing-library/jest-dom": "^5.11.4",
@@ -17,26 +17,10 @@
         "react-scripts": "4.0.3",
         "redux": "^4.1.1",
         "redux-saga": "^1.1.3",
-        "saga-toolkit": "file:..",
+        "saga-toolkit": "^2.0.6",
         "web-vitals": "^1.0.1"
       }
     },
-    "..": {
-      "version": "2.0.4",
-      "license": "ISC",
-      "devDependencies": {
-        "@babel/cli": "^7.16.8",
-        "@babel/core": "^7.16.12",
-        "@babel/node": "^7.16.8",
-        "@babel/preset-env": "^7.16.11",
-        "@reduxjs/toolkit": "^1.7.2",
-        "babel-jest": "^27.4.6",
-        "jest": "^27.4.7",
-        "redux": "^4.1.2",
-        "redux-saga": "^1.1.3",
-        "redux-saga-test-plan": "^4.0.4"
-      }
-    },
     "node_modules/@babel/code-frame": {
       "version": "7.12.13",
       "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.12.13.tgz",
@@ -15302,8 +15286,9 @@
       "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="
     },
     "node_modules/saga-toolkit": {
-      "resolved": "..",
-      "link": true
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/saga-toolkit/-/saga-toolkit-2.0.6.tgz",
+      "integrity": "sha512-KBWuzC0PSmGFGm8/t7dhjvnyoudBqWK2VENKx0Ka+sroPZq6/inAXWSCpukHxaOYAH4afO2czZb1fgve3dyB8g=="
     },
     "node_modules/sane": {
       "version": "4.1.0",
@@ -30691,19 +30676,9 @@
       "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="
     },
     "saga-toolkit": {
-      "version": "file:..",
-      "requires": {
-        "@babel/cli": "^7.16.8",
-        "@babel/core": "^7.16.12",
-        "@babel/node": "^7.16.8",
-        "@babel/preset-env": "^7.16.11",
-        "@reduxjs/toolkit": "^1.7.2",
-        "babel-jest": "^27.4.6",
-        "jest": "^27.4.7",
-        "redux": "^4.1.2",
-        "redux-saga": "^1.1.3",
-        "redux-saga-test-plan": "^4.0.4"
-      }
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/saga-toolkit/-/saga-toolkit-2.0.6.tgz",
+      "integrity": "sha512-KBWuzC0PSmGFGm8/t7dhjvnyoudBqWK2VENKx0Ka+sroPZq6/inAXWSCpukHxaOYAH4afO2czZb1fgve3dyB8g=="
     },
     "sane": {
       "version": "4.1.0",

package/example/package.json

@@ -1,6 +1,6 @@
 {
   "name": "example",
-  "version": "0.1.0",
+  "version": "0.0.1",
   "private": true,
   "dependencies": {
     "@reduxjs/toolkit": "^1.6.1",
@@ -13,7 +13,7 @@
     "react-scripts": "4.0.3",
     "redux": "^4.1.1",
     "redux-saga": "^1.1.3",
-    "saga-toolkit": "file:..",
+    "saga-toolkit": "^2.0.6",
     "web-vitals": "^1.0.1"
   },
   "scripts": {

package/example/src/sagas.js

@@ -1,40 +1,44 @@
 import { call, cancelled, delay, put, select, takeEvery } from 'redux-saga/effects'
-import { LOCATION_CHANGE } from 'connected-react-router'
 import {
   takeEveryAsync,
   takeLatestAsync,
   takeAggregateAsync,
   putAsync,
-} from './sagaToolkit'
+} from 'saga-toolkit'
 import * as actions from './slice'
 
 const hyperSuperApi = (success = true) => {
   console.log('hyperSuperApi')
 
-  let timeoutId
-  const deferred = {}
+  // let timeoutId
+  // const deferred = {}
 
   const promise = new Promise((resolve, reject) => {
-    deferred.resolve = resolve
-    deferred.reject = reject
-    timeoutId = setTimeout(() => (success ? resolve : reject)('result'), 1000)
+    // deferred.resolve = resolve
+    // deferred.reject = reject
+    // timeoutId = setTimeout(() => (success ? resolve : reject)('result'), 1000)
+    setTimeout(() => (success ? resolve : reject)('result'), 1000)
   })
 
-  deferred.promise = promise
+  // deferred.promise = promise
 
-  promise.abort = () => {
-    clearTimeout(timeoutId)
-    deferred.reject('Aborted')
-  }
+  // promise.abort = () => {
+  //   clearTimeout(timeoutId)
+  //   deferred.reject('Aborted')
+  // }
 
   return promise
 }
 
 function* appStart() {
   try {
+    // fetch things at app start
+
+    // non blocking way
     // yield put(actions.fetchThings())
-    // yield put(actions.fetchThings(false))
-    // yield put(actions.fetchThings())
+
+    // OR wait for it to finish - a blocking way
+    // yield putAsync(actions.fetchThings())
   } catch (error) {
     console.log('appStart 1', error)
   }
@@ -50,9 +54,6 @@ function* appStart() {
   console.log('Started')
 }
 
-function* locationChange() {
-}
-
 function* fetchThings({ meta }) {
   const result = yield call(() => hyperSuperApi(meta.arg))
 
@@ -62,7 +63,7 @@ function* fetchThings({ meta }) {
 function* fetchThingsDebounce({ meta }) {
   try {
     yield delay(1000)
-    
+
     console.log('STILL RUNNING', meta.requestId)
   } finally {
     if (yield cancelled()) {
@@ -70,25 +71,21 @@ function* fetchThingsDebounce({ meta }) {
     }
   }
 
-  // const result = yield call(() => hyperSuperApi(true))
-
-  // return result
   return 'shite'
 }
 
 function* click() {
   try {
-    yield putAsync(actions.fetchThings(false))
+    yield putAsync(actions.fetchThings(false)) // wait 
   } catch (error) {
     console.log('click', { error })
   }
 }
 
 export default [
-  takeEveryAsync(actions.start.pending.toString(), appStart),
-  // takeAggregateAsync(actions.fetchThings.pending.toString(), fetchThings),
-  takeEveryAsync(actions.fetchThings.pending.toString(), fetchThings),
-  takeLatestAsync(actions.fetchThingsDebounce.pending.toString(), fetchThingsDebounce),
-  takeEvery(actions.click.type.toString(), click),
-  takeEvery(LOCATION_CHANGE, locationChange),
+  takeEveryAsync(actions.start.pending, appStart),
+  // takeAggregateAsync(actions.fetchThings.pending, fetchThings),
+  takeEveryAsync(actions.fetchThings.pending, fetchThings),
+  takeLatestAsync(actions.fetchThingsDebounce.pending, fetchThingsDebounce),
+  takeEvery(actions.click.type, click),
 ]

package/example/src/slice.js

@@ -1,5 +1,5 @@
 import { createAction, createSlice } from '@reduxjs/toolkit'
-import { createSagaAction } from './sagaToolkit'
+import { createSagaAction } from 'saga-toolkit'
 
 const name = 'root'
 

package/index.d.ts

@@ -0,0 +1,72 @@
+// generated with chatGPT
+
+import { ThunkAction } from '@reduxjs/toolkit'
+
+declare module 'saga-toolkit' {
+  import { Dispatch } from 'redux'
+  import { SagaIterator } from 'redux-saga'
+  import { AsyncThunkFulfilledActionCreator, AsyncThunkConfig } from '@reduxjs/toolkit/src/createAsyncThunk'
+
+  type AsyncSagaPayloadCreator<Returned, ThunkArg = void> = (
+    arg: ThunkArg,
+    requestId: string
+  ) => Promise<Returned>
+
+  type AsyncSagaActionCreator<
+    Returned,
+    ThunkArg,
+    ThunkApiConfig extends AsyncThunkConfig = {}
+  > = (
+    arg: ThunkArg
+  ) => ThunkAction<
+    Promise<Returned>,
+    ReturnType<Dispatch>,
+    unknown,
+    ReturnType<
+      AsyncThunkFulfilledActionCreator<Returned, ThunkArg, ThunkApiConfig>
+    >
+  >
+
+  export interface AsyncSagaThunkConfig {
+    requestId: string
+    signal: AbortSignal
+    abort: (reason?: string) => void
+  }
+
+  export function createSagaAction<Returned, ThunkArg = void>(
+    type: string
+  ): AsyncSagaActionCreator<Returned, ThunkArg> & {
+    pending: string;
+    fulfilled: string;
+    rejected: string;
+    typePrefix: string;
+    type: string;
+  }
+
+  type SagaFunction<Args extends any[]> = (...args: Args) => SagaIterator;
+
+  export function takeEveryAsync<ActionPattern>(
+    pattern: ActionPattern,
+    saga: SagaFunction<[...args: any[]]>,
+    ...args: any[]
+  ): void;
+
+  export function takeLatestAsync<ActionPattern>(
+    pattern: ActionPattern,
+    saga: SagaFunction<[...args: any[]]>,
+    ...args: any[]
+  ): void;
+
+  export function takeAggregateAsync<ActionPattern>(
+    pattern: ActionPattern,
+    saga: SagaFunction<[...args: any[]]>,
+    ...args: any[]
+  ): void;
+
+  export function putAsync<T>(action: T): T;
+
+  // export function takeEveryAsync(pattern: any, saga: any, ...args: any[]): any
+  // export function takeLatestAsync(pattern: any, saga: any, ...args: any[]): any
+  // export function takeAggregateAsync(pattern: any, saga: any, ...args: any[]): any
+  // export function putAsync(action: any): any
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "saga-toolkit",
-  "version": "2.0.6",
+  "version": "2.1.1",
   "description": "An extension for redux-toolkit that allows sagas to resolve async thunk actions.",
   "main": "index.js",
   "scripts": {

package/.babelrc

@@ -1,12 +0,0 @@
-{
-  "presets": [
-    [
-      "@babel/preset-env",
-      {
-        "targets": {
-          "node": "current"
-        }
-      }
-    ]
-  ]
-}

package/example/src/sagaToolkit.js

@@ -1,154 +0,0 @@
-import { createAsyncThunk, unwrapResult } from '@reduxjs/toolkit'
-import { put, take, fork, takeEvery, cancel } from '@redux-saga/core/effects'
-import createDeferred from '@redux-saga/deferred'
-
-const requests = {}
-
-const addRequest = requestId => {
-  const deferred = createDeferred()
-  const request = {
-    ...requests[requestId],
-    requestId,
-    deferred,
-  }
-
-  if (requests[requestId]) {
-    requests[requestId].deferred = deferred
-    requests[requestId].onAdd(request)
-  } else {
-    requests[requestId] = request
-  }
-
-  return deferred.promise
-}
-
-export const createSagaAction = type => {
-  const thunk = createAsyncThunk(type, (_, { requestId }) => addRequest(requestId))
-
-  function actionCreator(...args) {
-    const originalActionCreator = thunk(...args)
-
-    return (...args) => {
-      const promise = originalActionCreator(...args)
-      requests[promise.requestId].abort = promise.abort
-
-      return promise
-    }
-  }
-
-  actionCreator.pending = thunk.pending
-  actionCreator.rejected = thunk.rejected
-  actionCreator.fulfilled = thunk.fulfilled
-  actionCreator.typePrefix = thunk.typePrefix
-  actionCreator.type = thunk.pending
-
-  return actionCreator
-}
-
-const cleanup = requestId => {
-  delete requests[requestId]
-}
-
-function* getRequest(requestId) {
-  // const { requestId } = action.meta
-  const request = requests[requestId]
-
-  if (!request) {
-    return yield (new Promise(onAdd => {
-      requests[requestId] = { onAdd }
-    }))
-  }
-
-  return request
-}
-
-const wrap = saga => function* (action, ...rest) {
-  const { requestId } = action.meta
-  const request = yield getRequest(requestId)
-  const deferred = request.deferred
-
-  try {
-    deferred.resolve(yield saga(action, ...rest))
-  } catch (error) {
-    console.log(error)
-    deferred.reject(error)
-  } finally {
-    cleanup(requestId)
-  }
-}
-
-export function takeEveryAsync(pattern, saga, ...args) {
-  return takeEvery(pattern, wrap(saga), ...args)
-}
-
-export function takeLatestAsync(pattern, saga, ...args) {
-  let deferred
-  const tasks = {}
-
-  function* wrapper(action, ...rest) {
-    if (deferred) {
-      const lastRequestId = yield deferred.promise
-      const request = yield getRequest(lastRequestId)
-
-      request.abort()
-
-      const task = yield tasks[lastRequestId].promise
-
-      yield cancel(task)
-    }
-
-    deferred = createDeferred()
-    const { requestId } = yield getRequest(action.meta.requestId)
-
-    deferred.resolve(requestId)
-
-    yield wrap(saga)(action, ...rest)
-
-    deferred = null
-  }
-
-  const takeEvery = (patternOrChannel, saga, ...args) => fork(function* () {
-    while (true) {
-      const action = yield take(patternOrChannel)
-      const { requestId } = action.meta
-      tasks[requestId] = createDeferred()
-      tasks[requestId].resolve(yield fork(saga, ...args.concat(action)))
-    }
-  })
-
-  return takeEvery(pattern, wrapper, ...args)
-}
-
-export function takeAggregateAsync(pattern, saga, ...args) {
-  let deferred
-
-  function* wrapper(action, ...rest) {
-    const { requestId } = action.meta
-
-    if (deferred) {
-      const request = yield getRequest(requestId)
-      const { resolve, reject } = request.deferred
-      const { promise } = yield deferred.promise
-
-      promise
-        .then(resolve, reject)
-        .finally(() => cleanup(requestId))
-        .catch(() => { })
-    } else {
-      deferred = createDeferred()
-      const request = yield getRequest(requestId)
-      const { promise } = request.deferred
-
-      yield wrap(saga)(action, ...rest)
-
-      deferred.resolve({ promise })
-      deferred = null
-    }
-  }
-
-  return takeEvery(pattern, wrapper, ...args)
-}
-
-export function* putAsync(action) {
-  return unwrapResult(yield (yield put(action)))
-}

package/test/createStore.js

@@ -1,24 +0,0 @@
-import { combineReducers } from 'redux'
-import { configureStore, getDefaultMiddleware } from '@reduxjs/toolkit'
-import createSagaMiddleware from 'redux-saga'
-import { all } from 'redux-saga/effects'
-
-export default ({ initialState, reducers, sagas }) => {
-  const sagaMiddleware = createSagaMiddleware()
-  const store = configureStore({
-    reducer: combineReducers(reducers),
-    middleware: [...getDefaultMiddleware(), sagaMiddleware],
-    devTools: false,
-  })
-  // const store = createStore(
-  //   combineReducers(reducers),
-  //   initialState,
-  //   applyMiddleware(sagaMiddleware)
-  // )
-
-  sagaMiddleware.run(function* () {
-    yield all(sagas)
-  })
-
-  return store
-}

package/test/sagaToolkit.test.js

@@ -1,95 +0,0 @@
-import { put } from 'redux-saga/effects'
-import { createSlice } from '@reduxjs/toolkit'
-import { expectSaga, testSaga } from 'redux-saga-test-plan'
-import createStore from './createStore'
-import { createSagaAction, takeEveryAsync } from '../sagaToolkit'
-
-const initialState = {
-  test: null,
-  testAsync: null,
-  error: null,
-}
-
-const testAsyncAction = createSagaAction('testSlice/testAsyncAction')
-
-const slice = createSlice({
-  name: 'testSlice',
-  initialState,
-  reducers: {
-    testAction: (state, action) => ({ test: action.payload }),
-  },
-  extraReducers: {
-    [testAsyncAction.pending]: (state, action) => ({
-      ...state,
-      test: action.payload,
-    }),
-    [testAsyncAction.resolved]: (state, action) => ({
-      ...state,
-      testAsync: 'action.meta.args',
-    }),
-    [testAsyncAction.rejected]: (state, action) => ({
-      ...state,
-      test: action.payload,
-    }),
-  },
-})
-
-const { testAction } = slice.actions
-
-function* saga() {
-  yield put(testAction('testing'))
-
-  return 'resolved value'
-}
-
-test('testing sync', () => {
-  const reducers = { slice: slice.reducer }
-  const sagas = [takeEveryAsync(testAsyncAction.pending, saga)]
-  const store = createStore({ initialState, reducers, sagas })
-
-  store.dispatch(testAction('testing'))
-
-  const state = store.getState()
-
-  expect(state).toEqual({
-    slice: { test: 'testing' },
-  })
-})
-
-test('testing async', () => {
-  return expectSaga(saga)
-    .withReducer(slice.reducer)
-    .hasFinalState({
-      test: 'testing',
-      testAsync: 'testing async',
-    })
-    .run()
-})
-
-test('testing async 2', () => {
-  testSaga(function *() {
-    yield takeEveryAsync(testAsyncAction.pending, saga)
-  }, 40, 2)
-    // advance saga with `next()`
-    .next()
-
-    // assert that the saga yields `take` with `'HELLO'` as type
-    // .take('HELLO')
-
-    // pass back in a value to a saga after it yields
-    // .next(action)
-
-    // assert that the saga yields `put` with the expected action
-    .put(testAction('testing'))
-
-    .next()
-
-    // assert that the saga yields a `call` to `identity` with
-    // the `action` argument
-    // .call(identity, action)
-
-    .next()
-
-    // assert that the saga is finished
-    .isDone();
-})