open-index/open-npm huggingface dataset:
npm package: @moxalibudbud/redis
Description: Simple wrapper of @azure/storage-blob
Latest version: 0.0.3-alpha

# `@moxalibudbud/redis` – Redis Wrapper Utility

A simple and reusable Redis client wrapper using [`ioredis`](https://github.com/luin/ioredis), designed for Node.js applications.

---

## 🔧 Environment Variables

Configure the Redis connection using the following environment variables:

| Variable             | Description                  | Default     |
| -------------------- | ---------------------------- | ----------- |
| `APP_REDIS_HOST`     | Redis server hostname        | `127.0.0.1` |
| `APP_REDIS_PORT`     | Redis server port            | `6379`      |
| `APP_REDIS_USERNAME` | Redis username (if required) | _(none)_    |
| `APP_REDIS_PASSWORD` | Redis password (if required) | _(none)_    |

---

## 🚀 Installation

```bash
pnpm add @moxalibudbud/redis
# or
npm install @moxalibudbud/redis
```

## 🚀 Usage

# `TODO`
npm package: @moxb/fiber-wrappers
Description: Wrap async functions with sync functions using (fiber) Futures
Author: moxb
Latest version: 0.4.6

# Synchronous wrappers around Promises, using fiber Futures

You can use this library to wrap your Promise-returning functions with (seemingly) fully synchronous functions,
which can then be called without any extra precaution, without using async/await.

The magic is powered by [fibers](https://www.npmjs.com/package/fibers).

Before using it for new project, **please consider the node of obsolesce at fiber's side**.
npm package: @moxb/meteor-react
Description: MobX meteor React binding
Author: moxb
Latest version: 0.4.7

# Meteor react hooks

This package contains various small utilities I find useful when building React applications,
using React hooks, on top of Meteor.

## Provided React hooks:
* `useMeteorUserId()` for obvious reasons
* `useMeteorUser()` for obvious reasons
 * `useMeteorPublication()` for using the live results of a subscription to a Meteor publication, with flow control, error handling, etc
 * `useMethodResults()` for using the results of a Meteor method, with various flow control functions, manual triggers, polling, error handling, etc
npm package: @moxb/shards-account-ui-antd
Description: Shards: basic user account handling UI with ant design
Author: moxb
Latest version: 0.3.50
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# Shards - Accounts UI for Ant Design

This package provides _very basic_ UI elements for common user account workflows, built using Ant Design.

**This is considered to be W.I.P.**

### Assumptions:

- You are building a React application
- You want to use Ant Design for the UI

## Quick start

This package only provides the UI elements, but doesn't provide any real functionality.
[@moxb/shards-accounts-flow](https://www.npmjs.com/package/@moxb/shards-accounts-flow) provides
a full login work-flow with automatic redirection.
npm package: @moxb/shards-accounts-flow-antd
Description: Shards: basic user login flow with ant design UI
Author: moxb
Latest version: 0.4.8

# Shards - User Login workflow with Ant Design

This package provides a _very basic_ solution for common user account workflows.

**This is considered to be W.I.P.**

### Assumptions:

- You are building a React application
- Client-side routing is provided by Stellar Router
- You want to use Ant Design for the UI

## Features

* If the user is trying to access a restricted part of the application,
  and is not logged in, he will be automatically redirected to the login form.
* User login, registration, password reset request and password reset are supported.
* After successful login, the user is redirected to the original location he tried to visit.

## Quick start

### Client side:

Basic app integration:

```typescript jsx
// This is for routing, not for accounts
import {SimpleLoginApp} from './WithLoginFlow';

const routingStore = createRoutingStore();

// you need to bring your Auth Backend
const authBackedn = new RandomAuthBackend();

// We will use this on the login form
const Splash = () => <h1>Welcome to my app!</h1>;

export const App = () => (
    <StellarRouterProvider store={routingStore}>
        <SingleLoginApp splash={<Splash/> backend={authBackend}}>
            <MainAppLayout/>
        </SingleLoginApp>
    </StellarRouterProvider>
);
```

- It's also possible to arrange it so that some part of the app is available
  without login, but a restricted part is not.
  In that case, wrap the root of the app with `<WithLoginFlow>`,
  and the restricted part with `<OnlyUsers>`.
- There is also `<LogoutButton />` that you can use for logging out.

## See also

- The UI used by this package is shipped in
  [@moxb/shards-accounts-ui-antd](https://www.npmjs.com/package/@moxb/shards-accounts-ui-antd).
- An example auth backend if provided by
  [@moxb/shards-accounts-meteor](https://www.npmjs.com/package/@moxb/shards-account-meteor).
npm package: @moxb/shards-accounts-meteor
Description: Shards: basic meteor user account handling with ant design
Author: moxb
Latest version: 0.4.8

# Shards - User accounts by Meteor

This package provides a Meteor-based authentication backend for
[@moxb/shards-accounts-flow-antd](https://www.npmjs.com/package/@moxb/shards-accounts-flow-antd).

**This is considered to be W.I.P.**

## Quick start

### Client side:

```typescript
import {MeteorAuthBackend} from '@moxb/shards-accounts-meteor';

const authBackend = new MeteorAuthBackend();
```

... and then pass this backend to `<WithLoginFlow>`.

### Server side:

```typescript
import {setupUserAccounts} from '@moxb/shards-accounts-meteor/dist/server';

setupUserAccounts()
```

This is required to set up the paths that will go into the various account-related emails
so that it matches with the client-side routing.
npm package: @moxb/shards-accounts-ui-antd
Description: Shards: basic user account handling UI with ant design
Author: moxb
Latest version: 0.4.7

# Shards - Accounts UI for Ant Design

This package provides _very basic_ UI elements for common user account workflows, built using Ant Design.

**This is considered to be W.I.P.**

### Assumptions:

- You are building a React application
- You want to use Ant Design for the UI

## Quick start

This package only provides the UI elements, but doesn't provide any real functionality.
[@moxb/shards-accounts-flow](https://www.npmjs.com/package/@moxb/shards-accounts-flow) provides
a full login work-flow with automatic redirection.
npm package: @moxb/shards-meteor-account-antd
Description: Shards: basic meteor user account handling with ant design
Author: moxb
Latest version: 0.3.45

# Shards - Meteor User Accounts with Ant Design

This package provides a _very basic_ solution for common user account workflows for Meteor applications.

**This is considered to be W.I.P.**

### Assumptions:
 - You are building a Meteor application, with a React UI
 - Client-side routing is provided by Stellar Router
 - You want to use Ant Design for the UI

## Features

* This is based on normal Meteor accounts.
* If the user is not logged in, he will be automatically redirected to the login form.
* User login, registration, password reset request and password reset are supported.
* After successful login, the user is redirected to the original location he tried to visit.

## Quick start

### Client side:

App integration:

```typescript jsx
// This is for routing, not for accounts
const routingStore = createRoutingStore();

// We will use this on the login form
const Splash = () => <h1>Welcome to my app!</h1>;

export const App = () => (
    <StellarRouterProvider store={routingStore}>
        <LoginRequired splash={<Splash />}>
            <MainAppLayout />
        </LoginRequired>
    </StellarRouterProvider>
);
```

Other:
 - For logging out, you can use `userLogout()` function or the `<LogoutButton>`
 - To check the currently active user, you can use the `useMeteorUserId()` and `useMeteorUser()` React hooks
   from the `@moxb/meteor-react` package.

### Server side:

```typescript
setupUserAccounts()
```

This is required to set up the paths that will go into the various account-related emails
so that it matches with the client-side routing.

## See also

The UI used by this package is shipped in
[@moxb/shards-accounts-ui-antd](https://www.npmjs.com/package/@moxb/shards-account-ui-antd).
npm package: @moxb/shards-meteor-process-manager-antd
Description: Shards: Meteor process manager - antd UI
Author: moxb
Latest version: 0.4.7

# Shards - Meteor Process Manager: AntD UI

This family of packages provides a framework for Meteor projects that allows running tasks in the background.

## Overview

* See [@moxb/shards-meteor-process-manager-core](https://www.npmjs.com/package/@moxb/shards-meteor-process-manager-core)
for a description of some basic terms.
* See [@moxb/shards-meteor-process-manager-server](https://www.npmjs.com/package/@moxb/shards-meteor-process-manager-server)
about the server integration.
* This packages provides a UI for managing the processes.

## Usage

Just use the React component.

```typescript jsx
const ProcessPage = () => (
    <div>
        <h2>Process Maanger</h2>
        <ProcessManagerUI scopeId="basic" />
    </div>
);
```
npm package: @moxb/shards-meteor-process-manager-core
Description: Shards: Meteor process manager core
Author: moxb
Latest version: 0.4.7

# Shards - Meteor Process Manager: core

This family of packages provides a framework for Meteor projects that allows running tasks in the background.

## Overview

### Task Definition

Tasks are described using a specific interface. Basic example:

```typescript
const processCountSheep: ProcessDefinition = {
  processId: 'count-sheep',
  name: "Count sheep",
  detailLevel: 1,
  execute: () => {
      // 1
      sleep(1);
      // 2
      sleep(2);
      // 3
  }
};
```

See [ProcessDefinition](https://github.com/moxb/moxb/tree/master/packages/shards-meteor-process-manager-core/src/types/ProcessDefinition.ts) for more.

### Process Context

When a process is executed, it gets `ProcessContext` instance, which provides some APIs for communicating
with the process manager.

```typescript
function someProcess(context: ProcessContext<any>) {
    sleep(1);
    context.reportProgress("One", 0.1);
    sleep(1);
    context.reportProgress("Two", 0.2);
    sleep(1);
}
```

See [ProcessContext](https://github.com/moxb/moxb/tree/master/packages/shards-meteor-process-manager-core/src/types/ProcessContext.ts) for more.

### Recursive launching of processes

A process can also request the launching of another process. Multiple modes of interactions are supported.

TODO

### Process Controller

The process controller is a singleton object, living on the server side.
It's responsible for controlling what happens around the processes.

The application code running on the server side can talk to this controller:

```typescript
getProcessController().launchProcess("basic", "count-sheep");
getProcessController().stopProcess("basic", "count-sheep");
```

See [ProcessController](https://github.com/moxb/moxb/tree/master/packages/shards-meteor-process-manager-core/src/types/ProcessController.ts) for more.

The application code on the client side can talk to the process controller
using a set of Meteor methods:

```typescript
launchProcessMethod.call({ scopeId: "basic", processId: "count-sheep" });
stopProcessMethod.call({ scopeId: "basic", processId: "count-sheep" });
```

### Examining process status

We store the status of each of the defined processes.

```typescript
console.log(getProcessController().getProcess("basic", "count-sheep");
```

See [ProcessStatus](https://github.com/moxb/moxb/tree/master/packages/shards-meteor-process-manager-core/src/types/ProcessStatus.ts) for the exact details.

As far as the client is concerned, `publicationBackgroundProcesses` is a Meteor publication
carries all process status info from the server to the client.

## See also

* [@moxb/shards-meteor-process-manager-server](https://www.npmjs.com/package/@moxb/shards-meteor-process-manager-server)
  for integrating the process manager into your application server
* [@moxb/shards-meteor-process-manager-antd](https://www.npmjs.com/package/@moxb/shards-meteor-process-manager-atnd)
  for an out-of-the-box GUI for controlling the processes
npm package: @moxb/shards-meteor-process-manager-server
Description: Shards: Meteor process manager - server component
Author: moxb
Latest version: 0.4.7

# Shards - Meteor Process Manager: server features

This family of packages provides a framework for Meteor projects that allows running tasks in the background.

## Overview

See [@moxb/shards-meteor-process-manager-core](https://www.npmjs.com/package/@moxb/shards-meteor-process-manager-core)
for a description of some basic terms.

### Roles

Your app can run in one of two different roles:
 * Controller: There can be only one. Controls the execution of the tasks. Sends requests to the workers.
 * Worker: There can be more than one. Takes requests from the controller and executes processes.

The idea is that the same Meteor application can be executed on multiple nodes simultaneously, in different roles.

### Running a worker node

```typescript
// Define our processes
const processBreedSheep = { ... };
const processCountSheep = { ... };
const processButcherSheep = { ... };

// Launch a worker node
initProcessManagerWorker({
    getScopeData: () => {},
    getProcessList: () => [ // enumerate our processes
        processBreedSheep,
        processCountSheep,
        processButcherSheep,
    ],
});
```

See [ProcessManagerWorkerProps](https://github.com/moxb/moxb/tree/master/packages/shards-meteor-process-manager-server/src/worker.ts) for more details.

### Running a controller node

```typescript
initProcessManagerController();
```

See [ProcessManagerControllerProps](https://github.com/moxb/moxb/tree/master/packages/shards-meteor-process-manager-server/src/controller.ts) for more details.

### Communication between the nodes

All nodes should have access to the same MongoDB instance. For best (fastest) result, the OpLog support should be enabled, and it should be part of the MongoURL provided to the meteor nodes.

### Meteor users, ScopeId, Scope, ScopeData, authorization

TODO

## See also

* [@moxb/shards-meteor-process-manager-core](https://www.npmjs.com/package/@moxb/shards-meteor-process-manager-core)
  for the core concepts
* [@moxb/shards-meteor-process-manager-antd](https://www.npmjs.com/package/@moxb/shards-meteor-process-manager-atnd)
  for an out-of-the-box GUI for controlling the processes
npm package: @moxb/stellar-router-antd
Description: stellar-router: ant design bindings
Author: moxb
Latest version: 0.4.8

# Stellar Router - Ant design widgets

Stellar Router is a router for web applications. This package provides Ant Design widgets for React applications.
For more info about the design goals and features of this routing system,
see the [@moxb/stellar-router-core](https://www.npmjs.com/package/@moxb/stellar-router-core) package.

## Usage

TODO