open-index/open-npm huggingface dataset:
npm package: @oxfordabstracts/ragu
Description: Ragu is a minimal Rust port of the popular PureScript package manager, [Spago](https://github.com/purescript/spago).
Latest version: 0.1.24

# Ragu

Ragu is a minimal Rust port of the popular PureScript package manager, [Spago](https://github.com/purescript/spago).

It is designed to be a drop-in replacement for Spago, with a focus on performance and simplicity.

## ⚠️ Early Development Stage

This project is in the early stages of development and is not yet ready for production use.

This was built with our project in mind and hasn't been thoroughly tested in other environments.

It was developed over a few days by a single developer (+ some vibe-ing), so there are several rough edges that need refinement.

Rust is relatively new to me so sorry for any smelly or non-idiomatic code...

## Reasoning

Spago is an excellent package manager for PureScript, but it is written in JavaScript and has performance issues on large workspaces. This caused significant challenges at my current company [Oxford Abstracts](https://www.oxfordabstracts.com/).

We had seen impressive performance improvements from [Rust in other areas of PureScript](https://github.com/purefunctor/purescript-analyzer) and it seemed like an ideal fit for a simple port of Spago.

## Features

Most of the key day-to-day features of Spago are supported:

- Build purs projects
- Read spago.yaml packages
- Read workspace configurations
- Install packages from git package sets
- Install packages from git repos directly
- Install packages from local paths
- Install packages from the registry

Heavy caching is implemented for packages and package sets, so slow commands typically only need to be run once.

## Key differences

There are several key differences from Spago:

- No package publishing
- No version ranges, only package sets or manually specified github packages.
- No `-p` - all nested workspace work handled by navigating to the workspace directory and running commands from there.
- Some new commands:
  - `ragu workspace` - list all local packages
  - `ragu circular-deps` - check for circular dependencies in the workspace
  - `ragu check-deps` - check for broken dependencies in the workspace and suggest fixes
  - `ragu imports` - analyze imports in source files and categorize them
  - `ragu modules` - analyze modules in source files (can be grouped or filtered by package, etc.)

The `check-deps` equivalent in Spago took around 20 minutes to run on our workspace. It now takes under a second and can be run in CI.

The same is true of `circular-deps`, which we now run along with `check-deps` to ensure dependencies in our (stupidly large) workspace remain healthy.

## Usage

```bash
ragu help
```

## Replacing Spago locally

```bash
cargo install --path .
```

Then alias `spago` to `ragu` if you want it to interact with exsiting tooling that expects `spago sources`.
npm package: @oxfordabstracts/rust-purs-gql
Description: ## Hasura roles
Latest version: 0.1.28

# Config for purescript-graphql-schema-gen

## Hasura roles

To generate schemas for each of your Hasura roles, create a .yaml file and add a ROLES_YAML env var.
The yaml should be made up of an array of strings:

```yaml
- Admin
- User
- Submitter
```

## Outside types

To replace default hasura types with Purescript types, create one or more .yaml files and add them - comma separated - to the OUTSIDE_TYPES_YAML env var.

### `outside_types`:

This section is where you define the schema objects that you want to replace values for.

For example if you wanted to change the types on the `user` object, you could add the following:

```yaml
outside_types:
  user:
    with: common
    id: id=UserId
    email: EmailAddress, Data.EmailAddress, emails
```

This would replace the 'id' field with the 'UserId' type (see 'types' section below). It would also replace the 'email' field with an inline type of the format: `[type name], [module name], [package name]`.

The `with` key is an optional special key that allows you to define a common set of types to use across multiple objects. For example, if you wanted to use a 'common' set of types on both the 'user' and 'post' objects, you would define 'common' types in the 'templates' section and then add a `with: common` key to the 'user' and 'post' objects.

### types:

This section is where you define shorthand type templates modules containing multiple types. An example for a couple of `Id` modules is:

```yaml
types:
  id: $, Data.Id.$, oa-ids
  drId: $, Data.Id.DelegateRegistration.$, oa-ids
```

The '$' symbol is a placeholder for the type name that the type is called with in templates or outside_types. For example in the 'outside_types' section above, we use `id=UserId` which is translated into `UserId, Data.Id.UserId, oa-ids`.

### `templates`:

This section is where you define the common types that you want to use across multiple objects via the `with` key. For example:

```yaml
templates
  common:
    author_id: id=AuthorId
    stage_id: id=StageId
    user_id: id=UserId
    created_by: id=UserId
    client_id: id=ClientId
    event_id: id=EventId
  event_types:
    event_title: HTML, Data.HTML
    frequency: Frequency, Data.Frequency
    created_by: id=UserId
    client_id: id=ClientId
    event_id: id=EventId
```

The keys don't have to exist on the object you call the template for, but any keys that do match will be replaced with the template value.
npm package: @oxfordabstracts/sst-provider-neon
Description: A Pulumi provider dynamically bridged from neon.
Latest version: 0.13.0

> This provider is a derived work of the [Terraform Provider](https://github.com/kislerdm/terraform-provider-neon)
> distributed under [MPL 2.0](https://www.mozilla.org/en-US/MPL/2.0/). If you encounter a bug or missing feature,
> please consult the source [`terraform-provider-neon` repo](https://github.com/kislerdm/terraform-provider-neon/issues).
npm package: @oxfordinfolabs/kinibind
Description: Data binding plus simple Ajax requests in HTML
Author: Oxford Information Labs
Latest version: 0.0.1

# kinibind

Kinibind is built upon the [tinybind js](http://blikblum.github.io/tinybind/) framework, with the addition of AJAX loading binders.
These binders are designed to assist in rapid developing and prototyping when working with simple AJAX requests for listing on HTML pages.


## Install

```bash
npm install @oxfordinfolabs/kinibind
```

Use in a script tag...

```html
<script src="../dist/kinibind.js"></script>
```

## Usage

```html
<div kb-source="https://jsonplaceholder.typicode.com/users" model="users">
    <ul>
        <li kb-each-user="users">
            <span class="label">User ID: {user.id}</span>&nbsp;<b>Name: </b>{user.name}
        </li>
    </ul>
</div>
```

```javascript
kinibind.bind(document.getElementById('my-element'));
```

## Contributing

#### Bug Reporting

1. Ensure the bug can be reproduced on the latest master.
2. Open an issue on GitHub and include an isolated [JSFiddle](http://jsfiddle.net/) demonstration of the bug. The more information you provide, the easier it will be to validate and fix.