repos / starfx

docs: `stale-while-revalidate` messaging

fix: examples and have them install starfx locally (#65)

react-redux as optional peerDep (#63)

chore: v0.14.6

Refactor matcher for correct predicate and action handling (#62)

- Brand action creators using a cheap, non-enumerable _starfx property for precise detection.
- Refactor matcher logic to clearly separate branded action creators from custom predicates and all other cases.
- This ensures only the intended actions are matched, fixes the failing test, and makes the matcher safe for userland/test usage and advanced patterns.
- Additionally added matcher.test.ts to outline matcher behavior and edge cases, ensuring future changes remain safe.
- Also added index signature to ActionWithPayload to ensure that is compatible with react-redux UnknownAction type [type.ts]

chore: release

fix: gha

fix: gha

chore: release gha

fix(react): exports entry (#61)

deno to node (#60)

This changes the language runtime from deno to node. The reason for this change is because the target of this library is the browser and node has the best compatibility with it. Further we were running into a bunch of issues with the deno tooling for creating npm packages (e.g. dnt).

deno is also pretty good at loading npm packages into its runtime so starting in deno doesn't help us that much.

Ultimately there's just a few too many layers in between us and the npm release and at this point deno is not really serving us.

---------

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

docs: preload copy

Merge pull request #58 from neurosnap/preview-package-workflow

preview package creation on PR

preview package creation on PR

fix(make): change test cmd

confirm tests assert when run within an generator function (#55)

---------

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

refactor: deno v2 and imports

chore: rm static workflow

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