open-index/open-npm huggingface dataset:
npm package: @gojinko/plugin
Description: Jinko Travel plugin for Claude Code and OpenAI Codex — flight search, booking, and trip management via MCP
Author: Jinko
Latest version: 1.0.0

# Jinko Travel Plugin

Plugin for **Claude Code** and **OpenAI Codex** that enables flight search, trip booking, and booking management via the Jinko Travel API.

## What's included

- **4 skills**: search-flights, book-trip, manage-booking, account
- **MCP server config**: connects to `mcp.builders.gojinko.com`
- **Dual-platform support**: works with both Claude Code and Codex CLI

## Setup

### 1. Get an API key

Sign up at [builders.gojinko.com](https://builders.gojinko.com) and create an API key from the dashboard.

### 2. Set your API key

```bash
export JINKO_API_KEY=jnk_your_key_here
```

Or add it to your shell profile (`~/.zshrc`, `~/.bashrc`).

### 3. Install the plugin

**Claude Code:**
```bash
claude plugin install @gojinko/plugin
```

**Codex CLI:**
```bash
codex plugin install @gojinko/plugin
```

## Available skills

| Skill | Description | Example prompt |
|-------|-------------|---------------|
| `jinko:search-flights` | Find flights, explore destinations, compare prices | "Find flights from Paris to Tokyo in June" |
| `jinko:book-trip` | Book a flight with travelers and payment | "Book the cheapest flight and pay" |
| `jinko:manage-booking` | Check refund eligibility and process refunds | "Can I get a refund on booking ORD-123?" |
| `jinko:account` | Manage API keys and check usage | "How many API calls do I have left?" |

## Authentication

The plugin supports two auth methods:

- **API Key**: Set `JINKO_API_KEY` environment variable with your `jnk_*` key
- **OAuth**: If no API key is set, Codex will auto-discover OAuth and prompt you to sign in via browser

## MCP server

The plugin connects to the Jinko MCP server at:
```
https://mcp.builders.gojinko.com/mcp
```

This is the same server used by the Jinko CLI (`@gojinko/cli`) and SDK (`@gojinko/api-client`).
npm package: @gojob/eslint-config
Description: ESLint config for TypeScript projects at Gojob
Author: VinceOPS
Latest version: 5.4.0

# Gojob ESLint

Feel free to extend our opinionated ESLint configurations.

## TypeScript

With the [deprecation of TSLint](https://medium.com/palantir/tslint-in-2019-1a144c2317a9) (we'll miss you, buddy), we decided to progressively switch all our linting processes to [ESLint].

### Installation

You can extend our default configuration, in your own ESLint configuration:

```javascript
{
  "extends": [
    "@gojob/eslint-config/typescript" // or typescript-react
  ],
}
```

_Assuming you already installed `typescript`..._

```bash
yarn add --dev eslint @gojob/eslint-config prettier
# or
npm install --save-dev eslint @gojob/eslint-config prettier
```

### Integration with VSCode

At the present time, the ESLint plugin for VSCode has difficulties parsing/fixing TypeScript. Adding the following configuration to VSCode settings (`.vscode/settings.json` in your project) solves the problem:

```json
{
  "eslint.validate": [
    "javascript",
    "javascriptreact",
    { "language": "typescript", "autoFix": true },
    "typescriptreact"
  ],
  "typescript.tsdk": "node_modules/typescript/lib"
}
```

### FAQ

Q: I get the following error:
```Error while loading rule '@typescript-eslint/no-floating-promises': You have used a rule which requires parserServices to be generated. You must therefore provide a value for the "parserOptions.project" property for @typescript-eslint/parser.```

A: You need to add ```json parserOptions: { project: "<my-ts-config>.json" }``` in your eslint config file, i.e. ```json parserOptions: { project: "./tsconfig.json" }```.
npm package: @gojob/generator-ts-project
Description: TS Boilerplate with jest
Latest version: 3.0.0

## generator ts-project

A [Yeoman](http://yeoman.io/) generator for TypeScript projects.

### Prerequisite

 - Install [Yeoman](http://yeoman.io/)
 - Install [TypeScript](https://www.npmjs.com/package/typescript) and [ts-node](https://www.npmjs.com/package/typescript)

### Usage

```
npm install -g @gojob/generator-ts-project
```

### Usage

```
yo @gojob/ts-project
```
npm package: @gojob/nest-cloud-datastore
Description: Cloud Datastore module for Nestjs
Author: VinceOPS
Latest version: 1.0.2

# Nest Cloud Datastore

Cloud Datastore module for Nestjs

## Getting started

```bash
yarn add @gojob/nest-cloud-datastore
# or
npm install @gojob/nest-cloud-datastore
```

## Implementing

### Importing the module

If you use the [default configuration](https://cloud.google.com/docs/authentication/production#providing_credentials_to_your_application) of GCP client libraries, just import the module `CloudDatastoreModule` as-is.

Otherwise, the configuration passed to the constructor of [Datastore](https://cloud.google.com/nodejs/docs/reference/datastore/3.1.x/Datastore#constructor_1) can be customized in two ways:

* With the static method `forRoot`:

```typescript
import { CloudDatastoreModule, DatastoreModuleAsyncOptions } from '@gojob/nest-cloud-datastore';

const datastoreModule = CloudDatastoreModule.forRoot({ keyFile: configService.get('GCP_KEY_FILE_DATASTORE') });
export default datastoreModule;
```

* With the static method `forRootAsync`, for configuration object built dynamically:

```typescript
import { CloudDatastoreModule, DatastoreModuleAsyncOptions } from '@gojob/nest-cloud-datastore';

import { ConfigModule } from '../config/config.module';
import { ConfigService } from '../config/config.service';

const moduleConfig: DatastoreModuleAsyncOptions = {
  imports: [ConfigModule],
  inject: [ConfigService],
  useFactory: (configService: ConfigService) => ({ keyFile: configService.get('GCP_KEY_FILE_DATASTORE') }),
};

const datastoreModule = CloudDatastoreModule.forRootAsync(moduleConfig);
export default datastoreModule;
```

### Injecting the service

Once the module imported, `CloudDatastoreService` is made available in the injection scope.
Have a look at `src/cloud-datastore.integration-test.ts` to see the methods available.

## Testing

Thanks to the Docker image `google/cloud-sdk` including an emulator, testing the integration of your features with Cloud Datastore is pretty straightforward. Download `docker-compose.yml` from this git repository, then:

```bash
docker-compose up -d # run the emulator
curl localhost:8081 # ensure the emulator is available

# run your tests, with the following environment variables:
# DATASTORE_EMULATOR_HOST=localhost:8081
# DATASTORE_PROJECT_ID=datastore-testing
```

A helper class `DatastoreEmulator` is provided in this package, in order to easily:

* Remove the data stored by the emulator (`reset`)
* Remove the Datastore-specific property of an entity instantiated by the client library (`removeDatastoreKeyProp`)
* Create entities (`createEntity`, `createEntities`)
* Fetch all entities stored by the emulator (`getAll`)

Examples of tests are available `src/cloud-datastore.integration-test.ts`.

## Contributing

```bash
yarn install
```

### Build

```bash
yarn build
```

### Run tests

```bash
docker-compose up -d # start the Cloud Datastore emulator
yarn integration
docker-compose down
```
npm package: @gojob/nest-cloud-pub-sub-transport
Description: A Custom Transport strategy of the NestJS microservices pattern for Cloud Pub/Sub.
Author: VinceOPS
Latest version: 1.1.11

# Nest Cloud Pub/Sub Transport

[![CircleCI](https://circleci.com/gh/gojob-1337/nest-cloud-pub-sub-transport.svg?style=svg)](https://circleci.com/gh/gojob-1337/nest-cloud-pub-sub-transport)

A Custom Transport strategy for [Cloud Pub/Sub](https://cloud.google.com/pubsub) in [Nest microservices](https://docs.nestjs.com/microservices/basics).

> TODO: in order to open-source it for NestJs, we must use `loadPackage` (from `Server`)
> to load `@google-cloud/pubsub` dynamically instead of having it installed
> in the dependenices of the project. Also, all types used from this package
> should be duplicated into local types/interfaces.

## Getting started

```bash
yarn add @gojob/nest-cloud-pub-sub-transport
# or
npm install @gojob/nest-cloud-pub-sub-transport
```

Here is an example of implementation in your Nest application:

```typescript
async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  const configService = app.get(ConfigService);

  app.connectMicroservice({
    strategy: new CloudServerPubSub({
      // "clientConfig": configuration passed "as is" to the Cloud PubSub client
      clientConfig: {
        keyFile: configService.get('GCP_KEY_FILE_PUBSUB'),
      },
      // "options": custom options, specific to this package
      options: {
        logger: app.get(LOGGER),
        // useful when your app is using a single topic & subscription
        defaultTopic: configService.get('DEFAULT_PUB_SUB_TOPIC'),
        defaultSubscription: configService.get('DEFAULT_PUB_SUB_SUBSCRIPTION'),
      },
    }),
  });

  await app.startAllMicroservices();
  await app.listen(3000);
}
```

Then use `@EventPattern` from `@nestjs/microservices` to decorate the event handlers which will be called when a new Pub/Sub message is received in your target topic(s).

## Contributing

| Command            | Action                                                 |
| ------------------ | ------------------------------------------------------ |
| `yarn compile`     | Ensure the TypeScript code can be compiled using `tsc` |
| `yarn build`       | Build the project (transpile the code to JavaScript)   |
| `yarn lint`        | Lint the code (`ESLint`)                               |
| `yarn test`        | Run unit tests                                         |
| `yarn integration` | Run integration tests                                  |
npm package: @gojob/sfmc-rest-sdk
Description: Salesforce Marketing Cloud REST API client
Author: Yannis Torres
Latest version: 1.0.3

# @gojob/sfmc-rest-sdk

## NPM publish

**To publish a new version of this package, you have to build the project before run `npm publish`.**

## Description

The purpose of this library is to provide a Typescript wrapper around Salesforce Marketing Cloud API: [SFMC](https://developer.salesforce.com/docs/atlas.en-us.mc-apis.meta/mc-apis/index-api.htm).

## Installation

```
yarn add @gojob/sfmc-rest-sdk
```

## Usage example

```typescript
import SFMC from '@gojob/sfmc-rest-sdk';

const sdk = new SFMC({
  domain: "mcdomainname",
  clientId: "123",
  clientSecret: "456",
  grantType: "client_credentials",
});

// ...

const makeSyncRequest = async () => {
  try {
    await sdk.dataEvents.sync.insertRows(
      [{
        keys: { subscriber_key: '123' },
        values: { email: 'test-123@example.com' },
      }],
      "DATAEXTENSION_KEY"
    );
  } catch (e) {
    console.log(e);
  }
};

await makeSyncRequest();
```

## Documentation

### Authentification

When dealing with SFMC REST API, all requests have to be authentified through a OAuth token that has a time based expiration. 
All requests must also be correctly declaring permission roles.
__This sdk handle automatic authentification and token renewal through the v2/token Marketing Cloud APIs__


### Requestable

In addition to authentification, the Requestable class can be used to request any REST endpoint of the Marketing Cloud APIs that wouldn't be wrapped into existing classes

```typescript
import { Requestable } from '@gojob/sfmc-rest-sdk';

const req = new Requestable();

req.authenticatedRequest({
  type: RequestType.POST,
  endpoint: `hub/whatever/mc/endpoint`,
  scope: Scope.according_scope,
  data,
});


```

### API wrapper classes

|       Class    |                                            REST API Doc                                                   |  Description                      |
|:--------------:|:---------------------------------------------------------------------------------------------------------:|-----------------------------------|
| Auth           | [SFMC.Auth](https://developer.salesforce.com/docs/atlas.en-us.noversion.mc-apis.meta/mc-apis/getBaseURLs.htm)            | Authentification V2 token API     |
| DataEventsSync | [SFMC.DataEvents](https://developer.salesforce.com/docs/atlas.en-us.noversion.mc-apis.meta/mc-apis/asynchronous_processing_scenarios.htm)                                                | Sync operations on dataextensions |
| DataEventsASync | [SFMC.DataEvents](https://developer.salesforce.com/docs/atlas.en-us.noversion.mc-apis.meta/mc-apis/asynchronous_processing_scenarios.htm)                                                | Sync operations on dataextensions |

#### Data Events API
npm package: @gojob/tslint-config
Description: A mostly reasonable approach to TypeScript.
Latest version: 1.0.0

# tslint-config-gojob

This package provides Gojob's base TS `tslint-base.json` (without React plugins) as an extensible shared config.

## Usage

We export one TSLint configurations for your usage.

### tslint-config-gojob

Our default export contains all of our TSLint rules, including `tslint:recommended`. It requires `tslint`.

1. Install the correct versions of each package, which are listed by the command:

  ```sh
  yarn add @gojob/tslint-config --dev
  ```
  
2. Within your `tsconfig.json` add the following extends:

  ```json
  {
    "extends": "tslint-config-gojob/tslint-base"
  }
  ```
npm package: @gojob/wait-for-assertion
Description: Wait for asynchronous testing assertions
Author: VinceOPS
Latest version: 1.0.4

# Wait for Assertion

A wrapper for asynchronous testing assertions.

## Getting started

```bash
yarn add @gojob/wait-for-assertion
# or
npm install @gojob/wait-for-assertion
```

## How

By "asynchronous assertions", we means Assertions that must be executed with a delay. The typical use case that we want to avoid is the following:

```typescript
await myFunctionWithAsyncSideEffects();

await new Promise(resolve => setTimeout(resolve, 1000)); // ❌ 🤢 🤮
expect(mySideEffectExists()).toBe(true);
```

`waitForAssertion` will run the given function (containing assertions) until it stops throwing exceptions (which means that it "passed"), or will throw a Timeout error.

`waitForAssertion` accepts up to three parameters:

```typescript
function waitForAssertion(
  assertion: () => any,
  timeoutDelay: number = 1000,
  intervalDelay: number = 100
);
```

- `assertion`: Closure containing asynchronous assertions to be made.
- `timeoutDelay`: _[1000ms]_ How long should the assertion be repeated until it passes (or times out).
- `intervalDelay`: _[100ms]_ How often should the assertion be repeated during `timeoutDelay`.

## Example

```typescript
import { waitForAssertion } from '@gojob/wait-for-assertion';

// [...]

it('should asynchronously update the value in Elasticsearch', async () => {
  await request(server)
    .put(endpointURL)
    .send(input)
    .expect(HttpStatus.NO_CONTENT);

  // the document is not immediatly available in Elasticsearch: wait
  await waitForAssertion(async () => {
    const { document } = await elasticsearchService.get(UserIndex, userId);
    return expect(document.firstName).toBe(updatedUser.firstName);
  });
});
```

## Credits

Developed by [VinceOPS](https://twitter.com/VinceOPS) at [Gojob](https://twitter.com/GojobT).  
Initial blog story: 🇫🇷 [article](https://vinceops.me/nest-e2e-tests-effets-de-bord/)
npm package: @gojob/winston-bugsnag
Description: Winston Transporter for Bugsnag. Based on Niftylettuce's work (Nick Baugh).
Author: Nick Baugh
Latest version: 0.1.0


# winston-bugsnag-logger

[![node](https://img.shields.io/badge/node-4.8.4+-brightgreen.svg)][node-url]
[![bugsnag](https://img.shields.io/badge/bugsnag-1.x+-brightgreen.svg)][bugsnag-url]
[![winston](https://img.shields.io/badge/winston-2.x+-brightgreen.svg)][winston-url]
[![license](https://img.shields.io/github/license/niftylettuce/winston-bugsnag-logger.svg)][license-url]

The **maintained** and **well-documented** [Bugsnag](https://github.com/bugsnag/bugsnag-node) transport for the [winston](https://github.com/winstonjs/winston) logger.

> Full API documentation is available at: <https://docs.bugsnag.com/api/error-reporting/>

## Index

* [Install](#install)
* [Usage](#usage)
* [Options](#options-options)
  - [Log Level Mapping](#log-level-mapping)
* [License](#license)


## Install

```bash
npm install --save winston winston-bugsnag-logger
```


## Usage

You can configure `winston-bugsnag-logger` in two different ways.

With `new winston.Logger`:

```js
const winston = require('winston');
const Bugsnag = require('winston-bugsnag-logger');

const options = {
  apiKey: '*******',
  level: 'info'
};

const logger = new winston.Logger({
  transports: [
    new Bugsnag(options)
  ]
});
```

Or with winston's `add` method:

```js
const winston = require('winston');
const Bugsnag = require('winston-bugsnag-logger');

const logger = new winston.Logger();

logger.add(Bugsnag, options);
```

See [Options](#options-options) below for custom configuration.


## Options (`options`)

Per `options` variable above, here are the default options provided:

Default options:

* `apiKey` (String) - your Bugsnag API key (defaults to `process.env.BUGSNAG_API_KEY`)
* `config` (Object) - a Bugsnag configuration object
* `bugsnag` (Object) - an optional instance of `bugsnag` that is already configured via `bugsnag.register` (if provided this will be used instead of the `config` option)

Transport related options:

* `name` (String) - transport's name (defaults to `bugsnag`)
* `silent` (Boolean) - suppress logging (defaults to `false`)
* `level` (String) - transport's level of messages to log (defaults to `info`)
* `levelsMap` (Object) - log level mapping to Bugsnag (see [Log Level Mapping](#log-level-mapping) below)

### Log Level Mapping

Winston logging levels are mapped by default to Bugsnag's acceptable levels.

These defaults are set as `options.levelsMap' and are:

```js
{
  silly: 'info',
  verbose: 'info',
  info: 'info',
  debug: 'debug',
  warn: 'warning',
  error: 'error'
}
```

You can customize how log levels are mapped using the `levelsMap` option:

```js
new Bugsnag({
  levelsMap: {
    verbose: 'info'
  }
});
```

If no log level mapping was found for the given `level` passed, then it will not log anything.


## License

[MIT License][license-url]


[license-url]: LICENSE
[node-url]: https://nodejs.org
[bugsnag-url]: https://bugsnag.com
[winston-url]: https://github.com/winstonjs/winston