repos / starfx

chore: cache bust css

style: docs

feat: support multiple stores registering the same thunk (#51)

* feat(thunk): enable multiple stores to register thunks with unique identifiers

* refactor(store): remove unused getStoreId function

style: home

refactor(persist): update persist.ts (#50)

Refactor persist.ts to improve code organization and readability.
- Add support for transform functions to modify the state before storing and after retrieving from storage.
- Implement inbound and outbound transformers to handle state transformations.
- Handle errors thrown by transformers and log them to the console.
- Use the transformed state when reconciling and persisting the store.
- Update persistStoreMdw function to use the transformed state when saving to storage.
- Add tests for persist transformers

fix: unregister a thunk when the operation shuts down

chore: update esm.sh to latest

chore: update deno.lock file

chore: cleanup thunk registry fix

fix(thunk): prevent multiple calls to `.register`

docs: structured conc

docs: copy

docs: copy

docs: copy

docs: copy

docs: nav

docs: copy

docs: copy

fix: fmt

docs: copy

docs: copy

docs: fx

docs: copy

chore: doc comments

chore(react): export `useStore` hook

docs(loaders): meta code example

docs(learn): preload then refresh

docs: typo

docs: copy

docs: typo

docs: copy

docs: copy

docs: copy

docs: copy

docs: copy

docs: copy

docs: copy

docs: copy

docs: more content

fix(thunk): run thunk supervisors immediately on register

For whatever reason, dispatching actions to register all the supervisor
thunks was too slow and causing a regression with prod systems.

This reverts part of the register function to how it used to work.  To
be more specific, it calls the supervisor functions immediately in a
`parallel` call.

chore(thunk): use `console.warn` instead of `console.error`

fix(thunk): remove unnecessary error log

docs: exposition

docs: readme

refactor: enhanced thunk registry system (#44)

The current registry system for thunks works like this:

- User calls `const thunks = createThunks()`
- User creates **all** thunks `const go = thunks.create("go")`
- User registers thunks `store.run(thunks.bootup)`

However, there's a caveat with this implementation: all thunks must be
created before `store.run` is called.  Further, since thunks are created
at the module-level, if the module that exports those thunks isn't
loaded before `thunk.bootup` is called then those thunks are silently
ignored.

This change will make it so it doesn't matter when a thunk is created,
we will "lazy load" it.

We still require `store.run(thunks.bootup)` to be called -- because we
need access to the store and won't have it when creating a thunk.

We are also sending an error whenever a thunk is dispatched without it
being registered which should help ensure thunks get properly
registered.

We also changed the name of `thunks.bootup` to `thunks.register` to make
it more clear that this is a registry system.

docs(learn): headers

docs: readme

docs: learn page

docs: content

docs: logo

chore: update pgs-action

chore: update pgs-action

docs: readme

docs: effection link

docs: copy

refactor: pager partial

style: tweak settings

fix: sidebar links

chore: nav

chore: update deno.lock file

docs: update pdocs and reframe lib

fix: catch error and bubble up

chore: update deno.lock

fix(mdw): thunk loader needs `ctx.loader`

docs: copy

chore: update go

chore: upgrade pgit

refactor: remove Result.data

BREAKING CHANGE: `ctx.json` no longer has a `.data` property

docs: metadata

docs: copy

docs: soften the blow

docs: getting started

docs: getting started

fix: export ApiMdwProps

refactor: merge `starfx/store` into `starfx` (#43)

I'm looking for ways to simplify the API in order to make this lib more
ergonomic.

DEPRECATED: `configureStore` is now `createStore`
BREAKING CHANGE: removed `starfx/store`

docs: motivation

design: sidebar

docs: copy

chore: retain 1 site

docs: clearTimers

chore: make clearTimers more ergonomic (#42)

feat: clear timers (#41)

feat: use `race` from `effection`

BREAKING CHANGE: replace `race` with `raceMap`

chore: deprecate `slice.loader`

Use `slice.loaders` instead

fix: reset loader when task is cancelled (#40)

This issue happens when:
- User runs a task with a loader
- Loading is in "loading" state
- Task gets halted
- Loader does not get cleaned up
- Loader stays in "loading" state

docs: cleanup

chore: update pdocs

chore: update pdocs

docs: endpoints

docs: copy

docs: nav

docs: copy

json api example

docs: sitemap links

docs: react

docs: react

docs: copy

docs: copy

docs: typo

docs: copy

docs: api work

docs: more pages

fix: docs gha

fix: docs gha

fix: gha for docs

fix: tweak gha

docs site (#39)

Wait for loader (#37)

docs: readme

chore: dont prefix action types

BREAKING CHANGE: we removed `@@starfx:` from all action types

fix(ci): shell string

fix: lint

fix(thunk): `toString` must return `type` instead of `name`

ecosystem CI tests (#36)

* initial CI setup

* fix CI workflow name

* consistent CI workflow name with file name

* script to symlink and CI workflow update to run build

* fix folder name in example dir

* try --refresh-lockfile

* try with npm

* try with --no-lockfile

* try with npm including build

* npm run build

* run as matrix

* don't fail fast

* skip remove of ./npm/node_modules

* do file: install for parcel instead

* keep node_modules for parcel

* matrix out path chunks

* lint fix

* another lint fix

* fix CI name

* install both examples

* dynamically pull matching branch

* nested folder

* quiet script

* throw on failed reponse

* pass branch

* more error context

* bad boop

* name branch step

* lint

* build and test examples

* remove GITHUB_TOKEN

* directly append in script

* add logs

* dump output

* dump output file

* dump step

* .outputs

* lint

* really need to fix my local linter

* add a bit to the readme

* rename .scripts/ to scripts/

* update script references

refactor: remove `log` (#35)

refactor: removed wrapped spawn from take helpers

BREAKING CHANGE: take helper fn signatures are different
BREAKING CHANGE: no more log or `LogContext`

fix: parcel bundler import export destructuring

For whatever reason, parcel doesn't like that we are importing from
"thunk" and exporting at the same time.

chore: folder/file org cleanup (#33)

chore: update deno.lock

refactor: rm redux (#32)

refactor(query): better extract types from endpoints

- fix(query): pick correct `ApiError` type inside `createApi`
- `useCache` will automatically pull success type from endpoint.

refactor(store): export storeMdw as collection

fix(store): loader mdw

docs: readme

fix(loader): consistent state shape

fix(loader): dont save derived data inside slice

feat(query): generic loader mdw

chore(query): cleanup mdw.predicate

feat(query): `mdw.predicate`

fix: flatten PersistGate elements

fix(table): properly memoize `selectByIds`

chore(query): export useCache type

docs: readme

docs: readme

docs: readme

docs: readme

docs: readme

docs: readme

docs: readme

docs: readme

docs: readme

docs: readme

docs: readme

docs: readme

feat(store): add local storage adapter

fix(thunks): types

fix(store): persistor rehydrates properly now

docs: readme

docs: readme

fix(store): cache timer mdw

chore: rename files and remove old fx

chore: rm getframe

refactor(log): generalize for any logging not just errors

fix(slice): properly memoize loader selectors

fix: wrong type for slice.any

chore: remove `first` from upstream

feat(store): `reset` updater to revert store to initialState provided by
user

feat(slice.table): return empty value provided for reuse

chore: remove outdated selectors

docs: readme

docs: readme

docs: readme

docs: readme

docs: readme

fix: `slice.table` types

docs: readme

docs: readme

docs: readme

docs: readme

refactor(store): `slice.table` `empty` is now optional (#28)

feat(query): thunk and api thunks can simply accept payload (#29)

fix: export persist module

fix(thunk): add `.use` to `CreateActionWithPayload` (#27)

feat(store): redux-persist replacement (#21)

feat: `createBatchMdw` for batching store listener events (#22)

refactor: require data and loaders slices (#24)

docs: readme

docs: readme

chore: update effection@v3-beta.3

feat: thunks dynamic mdw api (#26)

docs: readme

docs: readme

docs: readme

docs: readme

docs: readme

docs: readme

docs: readme

docs: readme

docs: readme

docs: readme

docs: readme headers

docs: readme

refactor(query): middleware naming (#25)

refactor(npm): use deno arg instead of env var

doc: readme

doc: readme

refactor(fx): use `call` from `effection` (#20)

fix(gha): trailing slash rsync

chore: use pgs-action

refactor(redux): custom queue impl (#19)

chore(npm): explicit fields

fix(redux): `poll` supervisor correct call sig

chore: rm references to `saga-query`

chore: update `effection` to `beta.0`

chore: update effection v3.0.15

refactor(redux): take strat

Trying to think about performance considerations with implementation

refactor(redux): use signal for middleware

chore(redux): export `send` for debugging

refactor(redux): use signal instead of channel

fix(redux): dispatchActions needs batchActions

chore: type improvements

chore: modify supervisor types

chore: export more redux fns

chore: export supervisors

chore: update deps

chore: update `saga-query` changes

doc: update tagline

refactor(store/slice): rename `obj.patch` to `obj.update`

fix: imports for `starfx/react`

Merge pull request #13 from neurosnap/create-table


---------

Co-authored-by: Vlad <vladmarginean@softwiz.ro>

feat: schema concept

Schema is like a database schema: you specify what tables you want and their shape.  The goal of this feature is to help users build an immutable data store that resembles a database, with ways to change the data being store as well as query it.

New features:
- `createSchema` which will generate the `initialState` for `createStore`
- `table()` which will create a table slice
- `str()` which will create a string slice
- `num()` which will create a number slice
- `any()` which will create a generic slice with any type
- `obj()` which will create an object slice

```ts
import { createSchema, configureStore, slice, select } from 'starfx/store';
import { main } from 'starfx';

interface User {
  id: string;
  name: string;
}

const { db, initialState } = createSchema({
  users: slice.table<User>({ empty: { id: "", name: "" } }),
});

const store = configureStore({ initialState });
main(function*() {
  yield* schema.update(db.users.add({ "1": { id: "1", name: "bob" }  }));
  const user = yield* select(db.users.selectById, { id: "1" });
});
```

doc: readme

doc: readme

doc: readme

doc: readme

doc: readme update with references

fix(pgs): retain

Use redux (#12)

doc: refactor

doc: readme

Toolkit 2.0 (#11)

feat: added `prepareStore()`

BREAKING CHANGE: refactored `configureStore()` from `starfx/redux`

refactor: `call()` to not be safe (#9)

docs: readme

chore: add pgit

fix: bubble errors up properly

fix: `errorHandler` properly catch errors

fix: event inside takeEvery can trigger same event (#5)

This is a regression from `saga-query`.  This is an issue that came up
in `redux-saga`.

[See ref to original issue.](https://github.com/redux-saga/redux-saga/issues/277)

[Discussion in discord](https://discordapp.com/channels/700803887132704931/1108053742835736636)

fix: ensure compose mdw returns aggregate `Result` (#6)

There was a regression compared to `saga-query` for `createPipe()` where
we were swallowing errors in the mdw pipeline.  This is largely because
we are experimenting with the idea of ensuring all operations inside
`starfx` are safe-by-default and return a `Result` instead of `throw`.

This effort is a design decision to treat errors-as-data.

In order to support safe-by-default inside our `compose()` function, we
need to aggregate the `Result` of every mdw call and then attach an
aggregate `Result` onto the `ctx` provided to `compose()`.

So now we require at least one field to always exist on `ctx` which is
`ctx.result` which returns `Result<any[]>`.

If an error exists inside the aggregate results, we return it unwrapped
as an error.  If no error exists in the results then we return a single
`Result` with a list of values unwrapped.

Here is a test that demonstrates the new behavior:

```ts
it(tests, "error inside endpoint mdw", async () => {
  let called = false;
  const query = createPipe();
  query.use(function* (ctx, next) {
    yield* next();
    if (!ctx.result.ok) {
      called = true;
    }
  });

  query.use(query.routes());

  const fetchUsers = query.create(
    `/users`,
    { supervisor: takeEvery },
    function* processUsers() {
      throw new Error("some error");
    },
  );

  const store = await configureStore({
    initialState: {
      ...createQueryState(),
      users: {},
    },
  });
  store.run(query.bootup);
  store.dispatch(fetchUsers());
  asserts.assertEquals(called, true);
});
```

fix: dispatch type sig

docs: readme

chore: fix readme fmt

docs: quick readme example

refactor: switch default createPipe() supervisor to redux

feat: immutable store (#2)

fmt

fix: npm release

add enhancers to redux store (#3)

fix: double take on same event (#4)

fix(npm): generate esm-specific types

chore: use mod.ts for entry points

chore: npm build tweaks

chore: npm working!

chore: move examples

chore: more natural npm imports

chore: reorg files and types

chore: refactor redux store creator

chore: compose types

fix: publish workflow

fix: missing lock

fix: npm build

chore: fmt

doc: readme

doc: readme

doc: description

feat(query): Data synchronization using a middleware system for front-end apps (#1)

chore: update deno lock

take helpers

tweaks

feat: `compose` function for middleware

refactor: `call` returns `Result` now

chore: moved `once`

chore: fix imports

chore: remove .bak file

chore(fx): replaced `all` with `parallel`

feat: parallel fx

parallel api

fix

explicit exports

lock

docs: readme

docs: fix linter

docs: readme

chore: getting ready for initial release

init