Research
Security News
Quasar RAT Disguised as an npm Package for Detecting Vulnerabilities in Ethereum Smart Contracts
Socket researchers uncover a malicious npm package posing as a tool for detecting vulnerabilities in Etherium smart contracts.
@erboladaiorg/earum-ipsum
Advanced tools
Reactive state and effect management with RxJS.
The library provides a way to describe business and application logic using MVC-like architecture. Core elements include actions and effects, states and stores. All of them are optionated and can be used separately. The core package is framework-agnostic and can be used in different cases: libraries, server apps, web, SPA and micro-frontends apps.
The library is inspired by MVC, RxJS, Akita, JetState and Effector.
It is recommended to use RxEffects together with Ditox.js – a dependency injection container.
Version 1.0 contains breaking changes due stabilizing API from the early stage. The previous API is available in 0.7.2 version.
Documentation is coming soon.
Package | Description | Links |
---|---|---|
@erboladaiorg/earum-ipsum | Core elements, state and effect management | Docs, API |
@erboladaiorg/earum-ipsum-react | Tooling for React.js | Docs, API |
npm install @erboladaiorg/earum-ipsum @erboladaiorg/earum-ipsum-react --save
The main idea is to use the classic MVC pattern with event-based models (state stores) and reactive controllers (actions and effects). The view subscribes to model changes (state queries) of the controller and requests the controller to do some actions.
Core elements:
State
– a data model.Query
– a getter and subscriber for data of the state.StateMutation
– a pure function which changes the state.Store
– a state storage, it provides methods to update and subscribe the state.Action
– an event emitter.Effect
– a business logic which handles the action and makes state changes and side effects.Controller
– a controller type for effects and business logicScope
– a controller-like boundary for effects and business logicBelow is an implementation of the pizza shop, which allows order pizza from the menu and to submit the cart. The controller orchestrate the state store and side effects. The component renders the state and reacts on user events.
// pizzaShop.ts
import {
Controller,
createAction,
createScope,
declareStateUpdates,
EffectState,
Query,
withStoreUpdates,
} from '@erboladaiorg/earum-ipsum';
import { delay, filter, map, mapTo, of } from 'rxjs';
// The state
type CartState = Readonly<{ orders: Array<string> }>;
// Declare the initial state.
const CART_STATE: CartState = { orders: [] };
// Declare updates of the state.
const CART_STATE_UPDATES = declareStateUpdates<CartState>({
addPizzaToCart: (name: string) => (state) => ({
...state,
orders: [...state.orders, name],
}),
removePizzaFromCart: (name: string) => (state) => ({
...state,
orders: state.orders.filter((order) => order !== name),
}),
});
// Declaring the controller.
// It should provide methods for triggering the actions,
// and queries or observables for subscribing to data.
export type PizzaShopController = Controller<{
ordersQuery: Query<Array<string>>;
addPizza: (name: string) => void;
removePizza: (name: string) => void;
submitCart: () => void;
submitState: EffectState<Array<string>>;
}>;
export function createPizzaShopController(): PizzaShopController {
// Creates the scope to track subscriptions
const scope = createScope();
// Creates the state store
const store = withStoreUpdates(
scope.createStore(CART_STATE),
CART_STATE_UPDATES,
);
// Creates queries for the state data
const ordersQuery = store.query((state) => state.orders);
// Introduces actions
const addPizza = createAction<string>();
const removePizza = createAction<string>();
const submitCart = createAction();
// Handle simple actions
scope.handle(addPizza, (order) => store.updates.addPizzaToCart(order));
scope.handle(removePizza, (name) => store.updates.removePizzaFromCart(name));
// Create a effect in a general way
const submitEffect = scope.createEffect<Array<string>>((orders) => {
// Sending an async request to a server
return of(orders).pipe(delay(1000), mapTo(undefined));
});
// Effect can handle `Observable` and `Action`. It allows to filter action events
// and transform data which is passed to effect's handler.
submitEffect.handle(
submitCart.event$.pipe(
map(() => ordersQuery.get()),
filter((orders) => !submitEffect.pending.get() && orders.length > 0),
),
);
// Effect's results can be used as actions
scope.handle(submitEffect.done$, () => store.set(CART_STATE));
return {
ordersQuery,
addPizza,
removePizza,
submitCart,
submitState: submitEffect,
destroy: () => scope.destroy(),
};
}
// pizzaShopComponent.tsx
import React, { FC, useEffect } from 'react';
import { useConst, useObservable, useQuery } from '@erboladaiorg/earum-ipsum-react';
import { createPizzaShopController } from './pizzaShop';
export const PizzaShopComponent: FC = () => {
// Creates the controller and destroy it on unmounting the component
const controller = useConst(() => createPizzaShopController());
useEffect(() => controller.destroy, [controller]);
// The same creation can be achieved by using `useController()` helper:
// const controller = useController(createPizzaShopController);
// Using the controller
const { ordersQuery, addPizza, removePizza, submitCart, submitState } =
controller;
// Subscribing to state data and the effect stata
const orders = useQuery(ordersQuery);
const isPending = useQuery(submitState.pending);
const submitError = useObservable(submitState.error$, undefined);
return (
<>
<h1>Pizza Shop</h1>
<h2>Menu</h2>
<ul>
<li>
Pepperoni
<button disabled={isPending} onClick={() => addPizza('Pepperoni')}>
Add
</button>
</li>
<li>
Margherita
<button disabled={isPending} onClick={() => addPizza('Margherita')}>
Add
</button>
</li>
</ul>
<h2>Cart</h2>
<ul>
{orders.map((name) => (
<li>
{name}
<button disabled={isPending} onClick={() => removePizza(name)}>
Remove
</button>
</li>
))}
</ul>
<button disabled={isPending || orders.length === 0} onClick={submitCart}>
Submit
</button>
{submitError && <div>Failed to submit the cart</div>}
</>
);
};
© 2021 Mikhail Nasyrov, MIT license
FAQs
Unknown package
The npm package @erboladaiorg/earum-ipsum receives a total of 0 weekly downloads. As such, @erboladaiorg/earum-ipsum popularity was classified as not popular.
We found that @erboladaiorg/earum-ipsum demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 0 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Research
Security News
Socket researchers uncover a malicious npm package posing as a tool for detecting vulnerabilities in Etherium smart contracts.
Security News
Research
A supply chain attack on Rspack's npm packages injected cryptomining malware, potentially impacting thousands of developers.
Research
Security News
Socket researchers discovered a malware campaign on npm delivering the Skuld infostealer via typosquatted packages, exposing sensitive data.