open-index/open-npm huggingface dataset:
npm package: @node-ts-autumn/server
Description: under construction
Author: mafh
Latest version: 0.3.4

# @node-ts-autumn/server

* [Install](#install)
---
## server-module

server module for [@node-ts-autumn/core](https://www.npmjs.com/package/@node-ts-autumn/core)

## server-module

...for typescript node mvc framework @node-ts-autumn/core

### development state

alpha version

>Features
* link more than one @node-ts-autumn/core application to one server with different contexts

## Install

### npm

`npm install @node-ts-autumn/server

### tsconfig
```json
    {
        "compilerOptions": {
            "typeRoots": ["node_modules/@types", "node_modules/@node-ts-autumn"],
            "types": ["node","server"],
        },
    }
```
---
## Example Server

>Server

Configure the main _server_ by setting up an `Server` class that extends the `AbstractServer` class from `@node-ts-autumn/server`.

This is an example `Server` class for the server.

```typescript
global['basepath'] = __dirname;
import { AbstractServer, ServerConfig  } from '@node-ts-autumn/server';
import { Application } from '@node-ts-autumn/server';

import { MyServerConfig } from './lib/config/server/server_config';
import { MyApplication } from './lib/application';
import { FileApplication } from './lib/file_application';

export class MyServer extends AbstractServer {

    constructor () {
        super();
    }

    public getServerConfig (): ServerConfig {
        let serverConfig: ServerConfig = new MyServerConfig();
        return serverConfig;
    }

    public getApplications (): Array<Application> {
        let applications: Array<Application> = new Array<Application>();
        applications.push(new FileApplication());
        applications.push(new MyApplication());
        return applications;
    }
}

!new MyServer();

```

>ServerConfig

```typescript
import { AbstractServerConfig, ServerConfig } from '@node-ts-autumn/server';


export class MyServerConfig extends AbstractServerConfig implements ServerConfig {

    constructor () {
        super();
        this.setPort(3000);
        this.setStartUpMessage('MyServer');
    }
}

```
npm package: @node-ts-cache/elasticsearch-storage
Description: Elasticsearch storage adapter for node-ts-cache
Author: Simon Tretter
Latest version: 1.0.1

# @node-ts-cache/elasticsearch-storage

Elasticsearch storage adapter for [node-ts-cache](https://github.com/simllll/node-ts-cache).

## Installation

```bash
npm install @node-ts-cache/core @node-ts-cache/elasticsearch-storage
```

## Usage

```typescript
import { Cache, ExpirationStrategy } from '@node-ts-cache/core';
import { ElasticsearchStorage } from '@node-ts-cache/elasticsearch-storage';

const elasticsearchCache = new ExpirationStrategy(
	new ElasticsearchStorage({
		indexName: 'my-cache-index',
		clientOptions: {
			node: 'http://localhost:9200'
		}
	})
);

class MyService {
	@Cache(elasticsearchCache, { ttl: 60 })
	async getUsers(): Promise<User[]> {
		// expensive operation
	}
}
```

## Configuration Options

```typescript
interface ElasticsearchStorageOptions {
	/** The index name to use for storing cache entries */
	indexName: string;
	/** Elasticsearch client options */
	clientOptions?: ClientOptions;
	/** Pre-configured Elasticsearch client instance (takes precedence over clientOptions) */
	client?: Client;
}
```

### Using a pre-configured client

If you already have an Elasticsearch client instance configured (e.g., with authentication), you can pass it directly:

```typescript
import { Client } from '@elastic/elasticsearch';
import { ElasticsearchStorage } from '@node-ts-cache/elasticsearch-storage';

const client = new Client({
	node: 'https://my-elasticsearch-cluster.com',
	auth: {
		apiKey: 'your-api-key'
	}
});

const storage = new ElasticsearchStorage({
	indexName: 'my-cache',
	client
});
```

## Running Tests Locally

Start Elasticsearch using Docker:

```bash
docker run -p 9200:9200 -e "discovery.type=single-node" -e "xpack.security.enabled=false" elasticsearch:8.12.0
```

Then run the tests:

```bash
npm test
```

## License

MIT
npm package: @node-ts-cache/memcached-storage
Description: Memcached storage adapter for node-ts-cache
Author: simllll
Latest version: 1.0.1

# @node-ts-cache/memcached-storage

Memcached storage adapter for [node-ts-cache](https://github.com/simllll/node-ts-cache).

## Installation

```bash
npm install @node-ts-cache/core @node-ts-cache/memcached-storage
```

## Usage

```typescript
import { Cache, ExpirationStrategy } from '@node-ts-cache/core';
import { MemcachedStorage } from '@node-ts-cache/memcached-storage';

const memcachedCache = new ExpirationStrategy(
	new MemcachedStorage({
		location: 'localhost:11211'
	})
);

class MyService {
	@Cache(memcachedCache, { ttl: 60 })
	async getUsers(): Promise<User[]> {
		// expensive operation
	}
}
```

## Configuration Options

```typescript
interface MemcachedStorageOptions {
	/** Memcached server location(s) - e.g., 'localhost:11211' or ['server1:11211', 'server2:11211'] */
	location: Memcached.Location;
	/** Memcached client options */
	options?: Memcached.options;
}
```

### Multiple Servers (Distributed)

Memcached supports distributed caching across multiple servers:

```typescript
import { MemcachedStorage } from '@node-ts-cache/memcached-storage';

const storage = new MemcachedStorage({
	location: ['server1:11211', 'server2:11211', 'server3:11211'],
	options: {
		retries: 3,
		timeout: 5000,
		poolSize: 10
	}
});
```

### Available Options

The `options` parameter accepts all standard [memcached](https://www.npmjs.com/package/memcached) options:

- `maxKeySize` - Maximum key size (default: 250)
- `maxValue` - Maximum value size (default: 1048576)
- `poolSize` - Connection pool size (default: 10)
- `retries` - Number of retries for failed operations (default: 5)
- `timeout` - Operation timeout in milliseconds (default: 5000)
- `idle` - Idle timeout for connections (default: 5000)

## Running Tests Locally

Start Memcached using Docker:

```bash
docker run -p 11211:11211 memcached:latest
```

Then run the tests:

```bash
npm test
```

## License

MIT
npm package: @node-ts-cache/redis-storage
Description: Simple and extensible caching module supporting decorators
Author: Simon Tretter
Latest version: 1.0.2

# @node-ts-cache/redis-storage

[![npm](https://img.shields.io/npm/v/@node-ts-cache/redis-storage.svg)](https://www.npmjs.org/package/@node-ts-cache/redis-storage)

Redis storage adapter for [@node-ts-cache/core](https://www.npmjs.com/package/@node-ts-cache/core) using the official `redis` package (v4.x).

## Installation

```bash
npm install @node-ts-cache/core @node-ts-cache/redis-storage
```

## Usage

### Basic Usage

```typescript
import { Cache, ExpirationStrategy } from '@node-ts-cache/core';
import { RedisStorage } from '@node-ts-cache/redis-storage';

const storage = new RedisStorage({
	socket: {
		host: 'localhost',
		port: 6379
	}
});

const strategy = new ExpirationStrategy(storage);

class UserService {
	@Cache(strategy, { ttl: 300 })
	async getUser(id: string): Promise<User> {
		return await db.users.findById(id);
	}
}
```

### With Authentication

```typescript
const storage = new RedisStorage({
	socket: {
		host: 'redis.example.com',
		port: 6379
	},
	password: 'your-password',
	database: 0
});
```

### Using URL

```typescript
const storage = new RedisStorage({
	url: 'redis://user:password@localhost:6379/0'
});
```

### Direct API Usage

```typescript
import { RedisStorage } from '@node-ts-cache/redis-storage';
import { ExpirationStrategy } from '@node-ts-cache/core';

const storage = new RedisStorage({
	socket: { host: 'localhost', port: 6379 }
});
const strategy = new ExpirationStrategy(storage);

// Store a value
await strategy.setItem('user:123', { name: 'John' }, { ttl: 60 });

// Retrieve a value
const user = await strategy.getItem<{ name: string }>('user:123');

// Clear all cached items
await strategy.clear();

// Disconnect when done
await storage.disconnect();
```

## Constructor Options

The constructor accepts [RedisClientOptions](https://github.com/redis/node-redis#configuration) from the `redis` package v4.x:

| Option     | Type     | Description                              |
| ---------- | -------- | ---------------------------------------- |
| `socket`   | `object` | Socket connection options (host, port)   |
| `url`      | `string` | Redis URL (alternative to socket config) |
| `password` | `string` | Redis authentication password            |
| `database` | `number` | Redis database number (default: 0)       |

## Interface

```typescript
interface IAsynchronousCacheType {
	getItem<T>(key: string): Promise<T | undefined>;
	setItem(key: string, content: any, options?: any): Promise<void>;
	clear(): Promise<void>;
}
```

## Dependencies

- `redis` ^4.7.0 - Official Redis client for Node.js

## Requirements

- Node.js >= 18.0.0
- Redis server

## License

MIT
npm package: @node-ts-cache/valkey-storage
Description: Valkey storage adapter for node-ts-cache
Latest version: 1.0.1

# @node-ts-cache/valkey-storage

Valkey storage adapter for [node-ts-cache](https://github.com/simllll/node-ts-cache).

[Valkey](https://valkey.io/) is an open-source, Redis-compatible in-memory data store that emerged as a community-driven fork after Redis changed its license.

## Installation

```bash
npm install @node-ts-cache/core @node-ts-cache/valkey-storage
```

## Usage

```typescript
import { Cache, ExpirationStrategy } from '@node-ts-cache/core';
import { ValkeyStorage } from '@node-ts-cache/valkey-storage';
import Valkey from 'iovalkey';

const valkeyClient = new Valkey({
	host: 'localhost',
	port: 6379
});

const valkeyCache = new ExpirationStrategy(new ValkeyStorage(() => valkeyClient, { maxAge: 3600 }));

class MyService {
	@Cache(valkeyCache, { ttl: 60 })
	async getUsers(): Promise<User[]> {
		// expensive operation
	}
}
```

## Configuration Options

```typescript
new ValkeyStorage(
	valkeyFactory: () => Valkey,
	options?: {
		maxAge: number;  // TTL in seconds (default: 86400 = 1 day)
	}
)
```

### Constructor Parameters

| Parameter        | Type           | Description                                        |
| ---------------- | -------------- | -------------------------------------------------- |
| `valkeyFactory`  | `() => Valkey` | Factory function returning a Valkey client         |
| `options`        | `object`       | Configuration options                              |
| `options.maxAge` | `number`       | Default TTL in seconds (default: 86400 = 24 hours) |

### Error Handling

You can attach an error handler for non-blocking write operations:

```typescript
const storage = new ValkeyStorage(() => valkeyClient, { maxAge: 3600 });

storage.onError(error => {
	console.error('Valkey error:', error);
	// Log to monitoring service, etc.
});
```

### Batch Operations

ValkeyStorage supports efficient batch operations:

```typescript
// Get multiple items
const items = await storage.getItems<User>(['user:1', 'user:2', 'user:3']);

// Set multiple items
await storage.setItems([
	{ key: 'user:1', content: user1 },
	{ key: 'user:2', content: user2 }
]);
```

## Running Tests Locally

Start Valkey using Docker:

```bash
docker run -p 6379:6379 valkey/valkey:latest
```

Then run the tests:

```bash
npm test
```

## Why Valkey?

- **Open Source**: Valkey is BSD-3 licensed, ensuring it remains truly open source
- **Redis Compatible**: Drop-in replacement for Redis with full protocol compatibility
- **Community Driven**: Backed by Linux Foundation with contributions from AWS, Google, Oracle, and more
- **Active Development**: Regular releases with new features and improvements

## License

MIT
npm package: @node-ts/bus-class-serializer
Description: A JSON serializer for @node-ts/bus based on class-transformer for strong marshalling of messages
Latest version: 1.1.2

# `@node-ts/bus-class-serializer`

A JSON-based serializer for [@node-ts/bus](https://bus.node-ts.com) that deserializes into strong types. This is a preferred alternative to the default serializer that does not support this.

## Installation

Install this package and its dependencies

```sh
npm i reflect-metadata class-transformer @node-ts/bus-class-serializer
```

Configure your bus to use the serializer:

```typescript
import { ClassSerializer } from '@node-ts/bus-class-serializer'

await Bus.configure().withSerializer(new ClassSerializer()).initialize()
```

**Note** This package relies on [class transformer](https://www.npmjs.com/package/class-transformer) that requires [reflect-metadata](https://www.npmjs.com/package/reflect-metadata) to be installed and called at the start of your application before any other imports. Please follow their guides on how to configure your app and contracts to serialize correctly.

## Why?

Consider the following message:

```typescript
class Update extends Command {
  constructor(readonly date: Date) {}
}
```

When serialized/deserialized this will become a plain object with no date functions on the property:

```typescript
const receivedMessage = JSON.parse(JSON.stringify(new Update(new Date())))
receivedMessage.getDate() // Error - getDate is undefined
```

Although we could manually fix and assign the date in the handle, this is tedious and adds unecessary code. Instead messages should be holistically deserialized to strong type at the boundaries of the system.

Using this serializer, a minor change to the contract is made:

```typescript
class Update extends Command {
  @Type(() => Date) readonly date: Date
  constructor(date: Date) {
    this.date = date
  }
}
```

When this is deserialized, the date should be an actual `Date`:

```typescript
const serializer = new ClassSerializer()
const receivedMessage = serializer.deserialize(
  serializer.serialize(new Update(new Date())),
  Update
)
receivedMessage.getDate() // Success - a date value
```
npm package: @node-ts/bus-core
Description: A service bus for message-based, distributed node applications
Latest version: 1.3.3

# @node-ts/bus-core

The core messaging framework. This package provides an in-memory queue and persistence by default, but is designed to be used with other @node-ts/bus-\* packages that provide compatibility with other transports (SQS, RabbitMQ, Azure Queues) and persistence technologies (PostgreSQL, SQL Server, Oracle).

🔥 View our docs at [https://bus.node-ts.com](https://bus.node-ts.com) 🔥

🤔 Have a question? [Join the Discussion](https://github.com/node-ts/bus/discussions) 🤔

## Installation

Download and install the packages:

```bash
npm i @node-ts/bus-core @node-ts/bus-messages --save
```

Configure and initialize the bus when your application starts up.

```typescript
import { Bus } from '@node-ts/bus-core'
async function run() {
  const bus = await Bus.configure().initialize()

  // Start listening for messages and dispatch them to handlers when read
  await bus.start()
}
```

For more information, visit our docs at [https://bus.node-ts.com](https://bus.node-ts.com)
npm package: @node-ts/bus-messages
Description: A core set of message definitions for distributed applications.
Latest version: 1.1.2

# @node-ts/bus-messages

This package should be consumed wherever your application defines message contracts. Messages are small pieces of data that get passed around between services. They can define an instruction to perform an action, or report that something has just occurred.

🔥 View our docs at [https://bus.node-ts.com](https://bus.node-ts.com) 🔥

🤔 Have a question? [Join the Discussion](https://github.com/node-ts/bus/discussions) 🤔

## Installation

Install the **@node-ts/bus-messages** package via npm:

```sh
npm install @node-ts/bus-messages
```
npm package: @node-ts/bus-mongodb
Description: A Mongodb persistence adapter for workflow storage in @node-ts/bus-workflow.
Latest version: 1.1.2

# @node-ts/bus-mongodb

A Mongodb based persistence for workflow storage in [@node-ts/bus](https://bus.node-ts.com)

🔥 View our docs at [https://bus.node-ts.com](https://bus.node-ts.com) 🔥

🤔 Have a question? [Join the Discussion](https://github.com/node-ts/bus/discussions) 🤔

## Installation

Install all packages and their dependencies

```bash
npm install @node-ts/bus-mongodb
```

Configure a new Mongodb persistence and register it with `Bus`:

```typescript
import { Bus } from '@node-ts/bus-core'
import { MongodbPersistence, MongodbConfiguration } from '@node-ts/bus-mongodb'

const configuration: MongodbConfiguration = {
  connection: 'mongodb://localhost:27017',
  databaseName: 'workflows'
}
const mongodbPersistence = new MongodbPersistence(configuration)

// Configure bus to use mongodb as a persistence
const run = async () => {
  const bus = Bus
    .configure()
    .withPersistence(mongodbPersistence)
    .build()
  await bus.initialize()
  await bus.start()
}
run.then(() => void)
```

## Configuration Options

The Mongodb persistence has the following configuration:

- **connection** _(required)_ The mongodb connection string to use. This can be a single server, a replica set, or a mongodb+srv connection.
- **schemaName** _(required)_ The database name to create workflow collections inside.

## Development

Local development can be done with the aid of docker to run the required infrastructure. To do so, run:

```bash
docker run --name bus-mongodb -p 27017:27017 -d mongo
```
npm package: @node-ts/bus-postgres
Description: A Postgres persistence adapter for workflow storage in @node-ts/bus-workflow.
Latest version: 1.1.2

# @node-ts/bus-postgres

A Postgres based persistence for workflow storage in [@node-ts/bus](https://bus.node-ts.com)

🔥 View our docs at [https://bus.node-ts.com](https://bus.node-ts.com) 🔥

🤔 Have a question? [Join the Discussion](https://github.com/node-ts/bus/discussions) 🤔

## Installation

Install all packages and their dependencies

```bash
npm install @node-ts/bus-postgres
```

Configure a new Postgres persistence and register it with `Bus`:

```typescript
import { Bus } from '@node-ts/bus-core'
import { PostgresPersistence, PostgresConfiguration } from '@node-ts/bus-postgres'

const configuration: PostgresConfiguration = {
  connection: {
    connectionString: 'postgres://postgres:password@localhost:5432/postgres'
  },
  schemaName: 'workflows'
}
const postgresPersistence = new PostgresPersistence(configuration)

// Configure bus to use postgres as a persistence
const run = async () => {
  const bus = Bus
    .configure()
    .withPersistence(postgresPersistence)
    .build()
  await bus.initialize()
  await bus.start()
}
run.then(() => void)
```

## Configuration Options

The Postgres persistence has the following configuration:

- **connection** _(required)_ Connection pool settings for the application to connect to the postgres instance
- **schemaName** _(required)_ The schema name to create workflow tables under. This can be the 'public' default from postgres, but it's recommended to use 'workflows' or something similar to group all workflow concerns in the one place. This schema will be created if it doesn't already exist.

## Development

Local development can be done with the aid of docker to run the required infrastructure. To do so, run:

```bash
docker run --name bus-postgres -e POSTGRES_PASSWORD=password -p 6432:5432 -d postgres
```
npm package: @node-ts/bus-rabbitmq
Description: A RabbitMQ transport adapter for @node-ts/bus-core.
Latest version: 1.1.2

# @node-ts/bus-rabbitmq

A Rabbit MQ transport adapter for [@node-ts/bus](https://bus.node-ts.com)

🔥 View our docs at [https://bus.node-ts.com](https://bus.node-ts.com) 🔥

🤔 Have a question? [Join the Discussion](https://github.com/node-ts/bus/discussions) 🤔

## Installation

Install all packages and their dependencies

```bash
npm install @node-ts/bus-rabbitmq
```

Once installed, configure a new `RabbitMqTransport` and register it for use with `Bus`:

```typescript
import { Bus } from '@node-ts/bus-core'
import {
  RabbitMqTransport,
  RabbitMqTransportConfiguration
} from '@node-ts/bus-rabbitmq'

const rabbitConfiguration: RabbitMqTransportConfiguration = {
  queueName: 'accounts-application-queue',
  connectionString: 'amqp://guest:guest@localhost',
  maxRetries: 5
}
const rabbitMqTransport = new RabbitMqTransport(rabbitConfiguration)

// Configure Bus to use RabbitMQ as a transport
const run = async () => {
  const bus = Bus.configure().withTransport(rabbitMqTransport).build()
  await bus.initialize()
}
run.catch(console.error)
```

## Configuration Options

The RabbitMQ transport has the following configuration:

- **queueName** _(required)_ The name of the service queue to create and read messages from.
- **connectionString** _(required)_ An amqp formatted connection string that's used to connect to the RabbitMQ instance
- **maxRetries** _(optional)_ The number of attempts to retry failed messages before they're routed to the dead letter queue. _Default: 10_

## Development

Local development can be done with the aid of docker to run the required infrastructure. To do so, run:

```bash
docker run -d -p 8080:15672 -p 5672:5672 rabbitmq:3-management
```
npm package: @node-ts/bus-sqs
Description: An AWS SQS transport adapter for @node-ts/bus-core.
Latest version: 1.1.5

# @node-ts/bus-sqs

An Amazon SQS transport adapter for [@node-ts/bus](https://bus.node-ts.com)

🔥 View our docs at [https://bus.node-ts.com](https://bus.node-ts.com) 🔥

🤔 Have a question? [Join the Discussion](https://github.com/node-ts/bus/discussions) 🤔

## Installation

Install packages and their dependencies

```bash
npm i @node-ts/bus-sqs @node-ts/bus-core
```

Once installed, configure Bus to use this transport during initialization:

```typescript
import { Bus } from '@node-ts/bus-core'
import { SqsTransport, SqsTransportConfiguration } from '@node-ts/bus-sqs'

const sqsConfiguration: SqsTransportConfiguration = {
  awsRegion: process.env.AWS_REGION,
  awsAccountId: process.env.AWS_ACCOUNT_ID,
  queueName: `my-service`,
  deadLetterQueueName: `my-service-dead-letter`
}
const sqsTransport = new SqsTransport(sqsConfiguration)

// Configure Bus to use SQS as a transport
const bus = Bus.configure().withTransport(sqsTransport).build()
await bus.initialize()
```

## Development

Local development can be done with the aid of docker to run the required infrastructure. To do so, run:

```bash
docker run -e SERVICES=sqs,sns -e DEFAULT_REGION=us-east-1 -p 4566-4583:4566-4583 localstack/localstack
```

This will create a localstack instance running and exposing a mock sqs/sns that's compatible with the AWS-SDK. This same environment is used when running integration tests for the `SqsTransport`.
npm package: @node-ts/bus-sqs-lambda
Description: A retrieval mechanism that receives messages from SQS-subscribed lambda.
Latest version: 1.0.1

# @node-ts/bus-sqs-lambda

An Amazon SQS and Lambda receiver for [@node-ts/bus](https://bus.node-ts.com).

This package allows the host application to receive SQS messages via a Lambda handler directly, rather than subscribing to the SQS transport.

🔥 View our docs at [https://bus.node-ts.com](https://bus.node-ts.com) 🔥

🤔 Have a question? [Join the Discussion](https://github.com/node-ts/bus/discussions) 🤔

## Installation

Install packages and their dependencies

```bash
npm i @node-ts/bus-sqs-lambda @node-ts/bus-sqs @node-ts/bus-core
```

Once installed, configure Bus to use this receiver during initialization:

```typescript
import { Bus } from '@node-ts/bus-core'
import { SqsTransport, SqsTransportConfiguration } from '@node-ts/bus-sqs'
import { BusSqsLambdaReceiver } from '@node-ts/bus-sqs-lambda'

const sqsConfiguration: SqsTransportConfiguration = {
  awsRegion: process.env.AWS_REGION,
  awsAccountId: process.env.AWS_ACCOUNT_ID,
  queueName: `my-service`,
  deadLetterQueueName: `my-service-dead-letter`
}
const sqsTransport = new SqsTransport(sqsConfiguration)

// Configure Bus to run in a Lambda
const bus = Bus.configure()
  .withTransport(sqsTransport)
  .withReceiver(new BusSqsLambdaReceiver())
  .build()

await bus.initialize()
```

## Usage

Once configured and initialized, any Lambda that is triggered by SQS messages can send these messages to Bus for processing and dispatch using the `bus.receive` method:

```typescript
// Your lambda code

module.exports.handler = bus.receive
```
npm package: @node-ts/bus-test
Description: A dev-dependency package used to test transport implementations.
Latest version: 0.0.24

# @node-ts/bus-test

This package provides a common suite of tests for [@node-ts/bus](https://bus.node-ts.com) that help to ensure consistency across packages that extend the library by adding a new [transport](https://bus.node-ts.com/guide/transports) adapter.

The package expects that [jest](https://www.npmjs.com/package/jest) is used as the test runner.

## Installation

Add this to your transport or persistence package:

```sh
npm i @node-ts/bus-test --save-dev
```

## Implementation

Transport tests are run by creating a `describe()` block and calling `transportTests()` with the following parameters:

- **transport** - A fully configured transport that's the subject under test
- **publishSystemMessage** - A callback that will publish a `@node-ts/bus-test:TestSystemMessage` with a `systemMessage` attribute set to the value of the `testSystemAttributeValue` parameter
- **systemMessageTopicIdentifier** - An optional system message topic identifier that identifies the source topic of the system message
- **readAllFromDeadLetterQueue** - A callback that will read and delete all messages on the dead letter queue

### Example

Examples of how to implement the standard transport tests can be viewed by looking at existing implementations such as:

- [RabbitMqTransport](https://github.com/node-ts/bus/blob/master/packages/bus-rabbitmq/src/rabbitmq-transport.integration.ts)
- [SqsTransport](https://github.com/node-ts/bus/blob/master/packages/bus-sqs/src/sqs-transport.integration.ts)
npm package: @node-ts/ddd-types
Description: A set of types that define core DDD objects
Author: Andrew den Hertog <andrew.denhertog@gmail.com>
Latest version: 0.2.0

# @node-ts/ddd-types

Base DDD types that define properties without implementation. This can be used to define domain based properties types separately to their application implementation, meaning the contract types can be transmitted (via APIs, messages etc) without requiring the core DDD library with all of its peer dependencies.
npm package: @node-ts/logger-pino
Description: A pino adapter for @node-ts/logger
Author: Ajith Chandran
Latest version: 0.1.2

# @node-ts/logger-pino

A Pino implementation for logger. 

## Usage

Install the package and its dependenceis

```
npm i @node-ts/logger-pino @node-ts/logger-core
```

Load the modules during application startup in inversify:

```typescript
import { Container } from 'inversify'
import { LoggerModule } from '@node-ts/logger-core'
import { PinoModule } from '@node-ts/logger-pino'

// ...

const container = new Container()
container.load(new LoggerModule())
container.load(new PinoModule())
```

## Custom Configuration

To configure the pino logger instances, provide your own `PinoConfiguration` implementation, ie:

```typescript

@injectable()
export class CustomPinoConfiguration implements PinoConfiguration {
  getConfiguration (loggerName: string): pino.LoggerOptions {
    return {
      enabled: true,
      level: 'info',
      prettyPrint: false,
      serializers: noir
      ....
    }
  }
}
```

Then to use it, rebind the `PINO_SYMBOLS.PinoConfiguration` symbol on your application startup:

```typescript
import { ContainerModule } from 'inversify'
import { CustomWinstonConfiguration } from './custom-winston-configuration'
import { PINO_SYMBOLS } from '@node-ts/logger-pino'

export class ApplicationModule extends ContainerModule {
  constructor () {
    super((_, __, ___, rebind) => {
      rebind(PINO_SYMBOLS.PinoConfiguration).to(CustomPinoConfiguration)
    })
  }
}

```
npm package: @node-ts/logger-winston
Description: A winston adapter for @node-ts/logger
Latest version: 0.1.1

# @node-ts/logger-winston

A Winston implementation for logger. 

## Usage

Install the package and its dependenceis

```
npm i @node-ts/logger-winston @node-ts/logger-core
```

Load the modules during application startup in inversify:

```typescript
import { Container } from 'inversify'
import { LoggerModule } from '@node-ts/logger-core'
import { WinstonModule } from '@node-ts/logger-winston'

// ...

const container = new Container()
container.load(new LoggerModule())
container.load(new WinstonModule())
```

## Custom Configuration

To configure the winston logger instances, provide your own `WinstonConfiguration` implementation, ie:

```typescript

@injectable()
export class CustomWinstonConfiguration implements WinstonConfiguration {
  getConfiguration (loggerName: string): winston.LoggerOptions {
    return {
      defaultMeta: { loggerName }
      // etc
    }
  }
}
```

Then to use it, rebind the `WINSTON_SYMBOLS.WinstonConfiguration` symbol on your application startup:

```typescript
import { ContainerModule } from 'inversify'
import { CustomWinstonConfiguration } from './custom-winston-configuration'
import { WINSTON_SYMBOLS } from '@node-ts/logger-winston'

export class ApplicationModule extends ContainerModule {
  constructor () {
    super((_, __, ___, rebind) => {
      rebind(WINSTON_SYMBOLS.WinstonConfiguration).to(CustomWinstonConfiguration)
    })
  }
}

```
npm package: @node2flow/airtable-mcp
Description: MCP server for Airtable API — manage records, bases, tables, fields, and webhooks through 18 tools
Author: Node2Flow
Latest version: 1.0.0

# Airtable MCP Server

MCP server for Airtable API — manage records, bases, tables, fields, and webhooks through 18 tools.

## Quick Start

### Claude Desktop / Cursor

```json
{
  "mcpServers": {
    "airtable": {
      "command": "npx",
      "args": ["-y", "@node2flow/airtable-mcp"],
      "env": {
        "AIRTABLE_PAT": "your_personal_access_token"
      }
    }
  }
}
```

### HTTP Mode

```bash
AIRTABLE_PAT=your_token npx @node2flow/airtable-mcp --http
# MCP endpoint: http://localhost:3000/mcp
```

### Cloudflare Worker

```
POST https://airtable-mcp.node2flow.net/mcp?AIRTABLE_PAT=your_token
```

## Configuration

| Variable | Required | Description |
|----------|----------|-------------|
| `AIRTABLE_PAT` | Yes | Personal Access Token from [airtable.com/create/tokens](https://airtable.com/create/tokens) |

### Getting a Personal Access Token

1. Go to [airtable.com/create/tokens](https://airtable.com/create/tokens)
2. Create a new token with required scopes:
   - `data.records:read` — Read records
   - `data.records:write` — Create/Update/Delete records
   - `schema.bases:read` — Read base schema
   - `schema.bases:write` — Modify base schema
3. Select which bases/workspaces the token can access

## Tools (18)

### Record Tools (6)
| Tool | Description |
|------|-------------|
| `airtable_list_records` | List records with filters, sorting, pagination |
| `airtable_get_record` | Get a single record by ID |
| `airtable_create_records` | Create records (batch up to 10) |
| `airtable_update_records` | Partial update records (batch up to 10) |
| `airtable_delete_records` | Delete records (batch up to 10) |
| `airtable_upsert_records` | Update-or-create by matching fields |

### Bases & Schema Tools (7)
| Tool | Description |
|------|-------------|
| `airtable_list_bases` | List all accessible bases |
| `airtable_get_base_schema` | Get all tables, fields, views |
| `airtable_create_base` | Create a new base in a workspace |
| `airtable_create_table` | Create a new table with fields |
| `airtable_update_table` | Update table name or description |
| `airtable_create_field` | Add a field to a table |
| `airtable_update_field` | Update field name or description |

### Webhook Tools (5)
| Tool | Description |
|------|-------------|
| `airtable_create_webhook` | Create webhook for data changes |
| `airtable_list_webhooks` | List all webhooks for a base |
| `airtable_refresh_webhook` | Extend webhook expiration (+7 days) |
| `airtable_list_webhook_payloads` | Get pending webhook payloads |
| `airtable_delete_webhook` | Delete a webhook |

## Docker

```bash
docker compose up -d
# Endpoint: http://localhost:3024/mcp
```

## License

MIT
npm package: @node40/mcp-server
Description: MCP server for the NODE40 Balance API
Latest version: 1.1.0

# @node40/mcp-server

NODE40 Balance is enterprise-grade blockchain data intelligence software. It transforms on-chain activity and exchange data across 20+ blockchains and leading cryptocurrency exchanges into audit-ready, reconciled financial data — giving finance teams, CPAs, and accounting firms the accuracy and verifiability they need to manage digital assets at scale.

This package is an MCP (Model Context Protocol) server that connects your AI assistant to your [NODE40 Balance](https://www.node40.com) account. Once configured, you can interact with your Balance data — accounts, ledgers, and transactions — conversationally, without writing code or making manual API calls.

Works with Claude (Desktop and Code), OpenAI (ChatGPT), Gemini, and any other MCP-compatible AI tool.

## Requirements

- Node.js 18+
- A NODE40 Balance API key and secret

## Quick Start

Add the following to your AI client's MCP configuration:

```json
{
  "mcpServers": {
    "node40-balance-api": {
      "command": "npx",
      "args": ["-y", "@node40/mcp-server"],
      "env": {
        "NODE40_API_KEY": "your-api-key-here",
        "NODE40_API_SECRET": "your-api-secret-here"
      }
    }
  }
}
```

## Documentation

For full setup instructions, client-specific configuration, and API key management, visit:

**[docs.node40.com](https://docs.node40.com)**

## License

MIT
npm package: @node581_/mathify
Description: A simple math library
Author: Ashish
Latest version: 1.0.1

# @node581_/mathify

A simple math library to perform basic mathematical operations.

## Installation

You can install `@node581_/mathify` from npm:

```bash
npm install @node581_/mathify


Usage 

// Import the library
import { add, subtract, multiply, divide } from '@node581_/mathify';

// Example usage:
const result1 = add(2, 3); // 5
const result2 = subtract(5, 3); // 2
const result3 = multiply(4, 3); // 12
const result4 = divide(6, 2); // 3

console.log(result1, result2, result3, result4);

API
add(a, b)
Returns the sum of a and b.

Parameters
a (number): The first number.
b (number): The second number.
Example
add(2, 3); // 5

subtract(a, b)
Returns the difference of a and b.

Parameters
a (number): The first number.
b (number): The second number.
subtract(5, 3); // 2