open-index/open-npm huggingface dataset:
npm package: @jetti/jetti.cli
Description: Jetti CLI
Author: Jon Bolt @epicbagel
Latest version: 0.0.17

Jetti CLI
==========

The Jetti CLI is used to manage your Jetti account from the command line. It is built using [oclif](https://oclif.io).

For more about Jetti see <https://www.jetti.io>. To get started see <https://app.jetti.io/signup>

Overview
========

This is a Node-based Jetti CLI.  The goals of this project are to provide automated and a developer/operations friendly way to manage Jetti accounts, without having to interact with the Jetti web interface. For example, provide the easy provision or API tokens or task monitoring.

Getting starts
========

The CLI is in beta and the command usage will likely change.

Commands
========

- `jetti auth:login` - Login and authenticate with the Jetti API. Required before using other commands.
- `jetti auth:token` - Provision an API user / token in Jetti. There are API token limits with accounts, so we recommend using existing tokens where possible rather than generating tokens ad-hoc.
- `jetti data-exports:list` - List data exports triggered by users.
- `jetti data-imports:list` - List data imports triggered by users.
- `jetti inventory-feeds:list` - List inventory feeds in Jetti.
- `jetti users:create` - List data imports triggered by users.

Install
========

You can install globally through `npm` and using `npx`

- `npm install @jetti/jetti.cli -g`
- `jetti {{ command }}` or `npx jetti {{ command }}`

Alternatively, to get started, you can either checkout the page and build locally. To do this you can `yarn` or `npm install`. Once installed, you can execute commands by running `yarn start {{command}}`. For example, `yarn start data-exports:list -s complete`.

![](https://p-wrF6mq.t4.n0.cdn.getcloudapp.com/items/4guOkqGy/14930774-9b19-4c6a-97dc-c91ec9f53b2d.png?v=666bc97a9c1aed835b743272c74dfcf2)
npm package: @jetti/sequelize-querystring-parser
Description: Consider the following situation:
Latest version: 0.1.3

## sequelize-querystring-parser

Consider the following situation:

- You're building a standard CRUD app that more-or-less follows the [JSON:API specification](https://jsonapi.org/format/)
- This app will receive HTTP GET requests with querystrings like those in the examples below:
  - `?filter[start_date][$gt]=2020-01-01`
  - `?sort=-date,name&page[number]=1&page[size]=5`
  - `?fields[articles]=title,body&fields[people]=name`
- You need to parse these query parameters to fetch the requested data. This library transforms CRUD-related querystrings into structured data for the Sequelize ORM.

## Installation

```sh
npm install @bitovi/sequelize-querystring-parser --save
```

## Usage

```js
const querystringParser = require("@bitovi/sequelize-querystring-parser");
```

### Sort Parameters

Reference: [JSON:API - Sorting](https://jsonapi.org/format/#fetching-sorting)

```js
const result = querystringParser.parse("sort=-date,name");
console.log(result);
{
  orm: "sequelize",
  data: {
    order: [["date", "DESC"],["name","ASC"]]
 },
  errors: [],
};
```

### Pagination Parameters

Reference: [JSON:API - Pagination](https://jsonapi.org/format/#fetching-pagination)

```js
const result = querystringParser.parse("page[number]=0&page[size]=10");
console.log(result);
{
  orm: "sequelize",
  data: {
    offset: 0,
    limit: 10
 },
  errors: []
};
```

### Fields Parameters

Reference: [JSON:API - Inclusion of Related Resources](https://jsonapi.org/format/#fetching-sparse-fieldsets)

```js
const result = querystringParser.parse("fields[people]=id,name");
console.log(result);
{
  orm: "sequelize",
  data: {
    attributes: ["id","name"]
 },
  errors: []
};
```

### Include Parameters

Reference: [JSON:API - Inclusion of Related Resources](https://jsonapi.org/format/#fetching-includes)

```js
const result = querystringParser.parse("include=pets,dogs");
console.log(result);
{
  orm: "sequelize",
  data: {
    include: ["pets","dogs"]
 },
  errors: []
};
```

### Filter Parameters

```js
const result = querystringParser.parse(
  "filter=and(any('age','10','20'),equals('name','mike'))"
);
{
  orm: "sequelize",
  data: {
    where: {
      [Symbol(and)] : {
        [Symbol(any)]: {
          age: [10, 20]
        },
        [Symbol(eq)]: {
          name: 'mike'
        }
      }
    }
 },
  errors: []
};
```

** Note: Database Validations should be done before or after passing the query to the library before the database call is made. **

** Note: The Symbol(\*) uses the Op imported from the Sequelize library, it is not a direct Javascript Symbol operator. **

## Example

- A more practical example on how to use this library in your project can be found in the [here](https://github.com/bitovi/querystring-parser/tree/main/examples)
npm package: @jettxcypher/aptos-swap-sdk
Description: 🛠 An SDK for building applications on top of Pancakeswap Aptos.
Latest version: 1.0.1

# PancakeSwap Aptos Swap SDK

You can refer to the Uniswap SDK documentation [uniswap.org](https://docs.uniswap.org/sdk/2.0.0/).
npm package: @jettxcypher/awgmi
Description: Connect to Aptos with similar [wagmi](https://github.com/wagmi-dev/wagmi) React hooks.
Latest version: 1.0.1

# @jettxcypher/awgmi

Connect to Aptos with similar [wagmi](https://github.com/wagmi-dev/wagmi) React hooks.

Support Aptos Wallet Connectors:
- Petra
- Martian
- Pontem
- Fewcha
- SafePal
- Trust Wallet


```jsx
import {
  createClient,
  AwgmiConfig,
  useConnect,
  getDefaultProviders,
  defaultChains,
} from '@jettxcypher/awgmi';
import { PetraConnector } from '@jettxcypher/awgmi/connectors/petra'
import { MartianConnector } from '@jettxcypher/awgmi/connectors/martain'
import { SafePalConnector } from '@jettxcypher/awgmi/connectors/safePal'
import { BloctoConnector } from '@jettxcypher/awgmi/connectors/blocto'
import { FewchaConnector } from '@jettxcypher/awgmi/connectors/fewcha'

 // import { mainnet, testnet } from '@jettxcypher/awgmi/core'
const chains = defaultChains // mainnet, testnet, devnet

export const client = createClient({
  connectors: [
    new PetraConnector({ chains }),
    new MartianConnector({ chains }),
    new PetraConnector({ chains, options: { name: 'Trust Wallet', id: 'trustWallet' } }),
    new SafePalConnector({ chains }),
    new BloctoConnector({ chains, options: { appId: BLOCTO_APP_ID } }),
    new FewchaConnector({ chains }),
  ],
  provider: getDefaultProviders,
  autoConnect: true,
});


function App() {
  return (
    <AwgmiConfig client={client}>
      <YourApp />
    </AwgmiConfig>
  )
}
```


## Connector
```jsx
import { useConnect, useDisconnect } from '@jettxcypher/awgmi'

function ConnectButton() {
  const { connect, connectors } = useConnect()

  return (
    <div>
      {connectors.map((connector) => (
        <button type="button" key={connector.id} onClick={() => connect({ connector, networkName: 'mainnet' })}>
          {connector.name}
        </button>
      ))}
    </div>
  )
}
```


## Hooks
```jsx
import {
  useAccountBalance,
  useAccountBalances,
  useAccountResource,
  useAccountResources,
  useCoin,
  useCoins,
  useNetwork,
  useSendTransaction,
  useSimulateTransaction,
  useTableItem,
} from '@jettxcypher/awgmi'
```

### Balance
```js
const { data } = useAccountBalance({
  address: Address,
  coin: '0x1::aptos_coin::AptosCoin',
  watch: true
})
```

### Send Transaction
```js
import { UserRejectedRequestError } from '@jettxcypher/awgmi'

const { sendTransactionAsync } = useSendTransaction()

sendTransactionAsync({
  payload: {
    type: 'entry_function_payload',
    function: '<address>::message::set_message',
    arguments: ['are we gonna make it?'],
    type_arguments: [],
  },
}).catch(err => {
  if (err instanceof UserRejectedRequestError) {
    // handle user reject
  }
  // handle transaction error
})
```