open-index/open-npm huggingface dataset:
npm package: @pyramation/postgraphile-plugin-fulltext-filter
Description: Full text searching on tsvector fields for use with postgraphile-plugin-connection-filter
Author: Mark Lipscombe
Latest version: 2.0.0

[![Package on npm](https://img.shields.io/npm/v/postgraphile-plugin-fulltext-filter.svg)](https://www.npmjs.com/package/postgraphile-plugin-fulltext-filter)
[![CircleCI](https://circleci.com/gh/mlipscombe/postgraphile-plugin-fulltext-filter/tree/master.svg?style=svg)](https://circleci.com/gh/mlipscombe/postgraphile-plugin-fulltext-filter/tree/master)

# postgraphile-plugin-fulltext-filter
This plugin implements a full text search operator for `tsvector` columns in PostGraphile v4 via @mattbretl's excellent `postgraphile-plugin-connection-filter` plugin.

## Getting Started

### CLI

``` bash
postgraphile --append-plugins postgraphile-plugin-connection-filter,postgraphile-plugin-fulltext-filter
```

See [here](https://www.graphile.org/postgraphile/extending/#loading-additional-plugins) for
more information about loading plugins with PostGraphile.

### Library

``` js
const express = require('express');
const { postgraphile } = require('postgraphile');
const PostGraphileConnectionFilterPlugin = require('postgraphile-plugin-connection-filter');
const PostGraphileFulltextFilterPlugin = require('postgraphile-plugin-fulltext-filter');

const app = express();

app.use(
  postgraphile(pgConfig, schema, {
    appendPlugins: [
      PostGraphileConnectionFilterPlugin,
      PostGraphileFulltextFilterPlugin,
    ],
  })
);

app.listen(5000);
```

## Performance

All `tsvector` columns that aren't @omit'd should have indexes on them:

``` sql
ALTER TABLE posts ADD COLUMN full_text tsvector;
CREATE INDEX full_text_idx ON posts USING gin(full_text);
```

## Operators

This plugin adds the `matches` filter operator to the filter plugin, accepting
a GraphQL String input and using the `@@` operator to perform full-text searches
on `tsvector` columns.

This plugin uses [pg-tsquery](https://github.com/caub/pg-tsquery) to parse the
user input to prevent Postgres throwing on bad user input unnecessarily.

## Fields

For each `tsvector` column, a rank column will be automatically added to the 
GraphQL type for the table by appending `Rank` to the end of the column's name.
For example, a column `full_text` will appear as `fullText` in the GraphQL type,
and a second column, `fullTextRank` will be added to the type as a `Float`.

This rank field can be used for ordering and is automatically added to the orderBy
enum for the table.

## Examples

``` graphql
query {
  allPosts(
    filter: {
      fullText: { matches: 'foo -bar' }
    }
    orderBy: FULL_TEXT_RANK_DESC
  }) {
    ...
    fullTextRank
  }
}
```
npm package: @pyramation/us-states
Description: us-states
Author: Dan Lynch
Latest version: 0.0.3

# us-states

<p align="center" width="100%">
  <img height="250" src="https://raw.githubusercontent.com/constructive-io/constructive/refs/heads/main/assets/outline-logo.svg" />
</p>

<p align="center" width="100%">
  <a href="https://github.com/pyramation/data.mom/actions/workflows/ci.yml">
    <img height="20" src="https://github.com/pyramation/data.mom/actions/workflows/ci.yml/badge.svg" />
  </a>
   <a href="https://www.npmjs.com/package/us-states"><img height="20" src="https://img.shields.io/github/package-json/v/pyramation/data.mom?filename=packages%2Fus-states%2Fpackage.json"/></a>
</p>

## Developing

This module was generated with `pgpm init`. For a complete guide on creating and testing database modules, see [Creating Your First Module](https://constructive.io/learn/modular-postgres/creating-first-module).

```sh
# Install dependencies
pnpm install

# Run tests
pnpm test

# Run tests in watch mode
pnpm test:watch

# Deploy to a database
pgpm deploy --database your_db --createdb --yes
```

## Credits

**🛠 Built by the [Constructive](https://constructive.io) team — creators of modular Postgres tooling for secure, composable backends. If you like our work, contribute on [GitHub](https://github.com/constructive-io).**

## Disclaimer

AS DESCRIBED IN THE LICENSES, THE SOFTWARE IS PROVIDED "AS IS", AT YOUR OWN RISK, AND WITHOUT WARRANTIES OF ANY KIND.

No developer or entity involved in creating this software will be liable for any claims or damages whatsoever associated with your use, inability to use, or your interaction with other users of the code, including any direct, indirect, incidental, special, exemplary, punitive or consequential damages, or loss of profits, cryptocurrencies, tokens, or anything else of value.
npm package: @pyramid-drama/nestjs-cron
Description: NestJS CRON module that allows you to easily setup CRON for your controllers or services
Author: Ruben Conde
Latest version: 0.2.3

![alt cover](./img/logo.jpg)

**Fork from this [repository](https://github.com/AlariCode/nestjs-cron)**

[![npm version](https://badgen.net/npm/v/@pyramid-drama/nestjs-cron)](https://www.npmjs.com/package/@pyramid-drama/nestjs-cron)
[![npm version](https://badgen.net/npm/license/@pyramid-drama/nestjs-cron)](https://www.npmjs.com/package/@pyramid-drama/nestjs-cron)

NestJS cron package allows you easily setup cron for your controllers or services.

```bash
npm i @pyramid-drama/nestjs-cron
```

To use cron, decorate your class with `@Scheduled()` and method with `@Cron()`.
Your class has to be a provider or a controller that is declared in any module.

```ts
import { Cron, Scheduled } from 'nestjs-cron';

@Injectable()
@Scheduled()
export class MyClass {
	@Cron('* * * * * *')
	async myMethod() {
		//...
	}
}
```

`'* * * * * *'` - is a standart cron notation. In this example it will be triggered every second.
Additionaly you can use options:

```ts
@Cron('* * * * * *', {
	delay: 10000,
	launchOnInit: true,
	sync: true,
})
async myMethod() {
	//...
}
```

-   delay - Launch job after a specified time (in milliseconds)
-   launchOnInit - Launch job one time right after start
-   sync - Wait for method to finish before launching next tick if your function takes more time than cron.

## Cron Intercepter

To intercept cron you can use `@CronIntercepter` decorator. You pass class that implements `CronIntercepterClass` as a parameter. It has one `intercept` method that returns `Promise<boolean>`.

```javascript
export class MyIntercepter implements CronIntercepterClass {
	async intercept() {
		return false;
	}
}
```

Usage example:

```javascript
@Scheduled()
@Injectable()
export class AppService {
	@CronIntercepter(MyIntercepter)
	@Cron('* * * * * *')
	getHello() {
		console.log('test');
	}
}
```

If `intercept` method returns `true` your cron will run as planned. If false method run will be skipped.
npm package: @pyramidmc/tree
Description: A selfhosted yggdrasil server made for Pyramid Launcher: nothing goes out of your computer! database is in `youruserfolder/.pyramidmc/database/tree.db`
Author: SrIzan10
Latest version: 1.0.3

# tree
A selfhosted yggdrasil server made for Pyramid Launcher: nothing goes out of your computer!
database is in `youruserfolder/.pyramidmc/database/tree.db`

# props to

- [winter's yggdrasil server on Codeberg](https://codeberg.org/winter/yggdrasil-server/src/branch/main) - An actual yggdrasil server made on Javascript and not on Python (I hate python)
- [wiki.vg's article on Legacy Mojang Authentication](https://wiki.vg/Legacy_Mojang_Authentication) - The documentation I read to know how the server worked
- [Drizzle ORM](https://orm.drizzle.team/) - An SQL ORM with type declaration just so my SQLite experience was more... bearable.

# known issues

- requestUser doesn't work
npm package: @pyramine/events
Description: ## Installation
Author: Christian Holländer
Latest version: 2.0.0

# Events

## Installation

```bash
npm install @pyramine/events
```

## Usage

First we need to define the "event-map". Therefore, we create a new interface, which keys define the event names. The
value of the interface defines the arguments for a specific event.

**Example:**

```ts
interface MyEventMap extends EventMap {
    click: [name: string];
    change: [index: number, color: string];
}
```

Here we define two events: `click` and `change`. The `click` event expects one argument, a `name` of type `string`. The second event `change` expects two arguments, an `index` of type `number` and a `color` of type `string`.

You can specify as many events as you like. Also, the arguments you define for an event is completely up to you.

### Emit events

Now, if you want to dispatch/emit an event you can do it as follows:

```ts
import {EventHub} from "@pyramine/events";

const eventHub = new EventHub<MyEventMap>();

eventHub.emit('click', 'my-name');
eventHub.emit('change', 1, 'red');
```

### Listen for Events

```ts
import {EventHub} from "@pyramine/events";

const eventHub = new EventHub<MyEventMap>();

eventHub.on('click', (name) => {
    console.log(name);
});
eventHub.on('change', (index, color) => {
    console.log(index, color);
});

// Listening only once
eventHub.once('click', (name) => {
    console.log(name);
});
```

#### Stop Listening:
```ts
eventHub.off('click', callback);
```
npm package: @pyramine/prettier-config
Description: This packages holds our prettier config
Latest version: 1.3.24

# Prettier Config

This package holds our pyramine.de Prettier config. It is used to get consistent formatting throughout our projects.

## Install
To install this package just run:

```shell
npm i -D -E @pyramine/prettier-config
```

> Note: this package only installs the prettier config. You need to install prettier separately.

# Configure
To use this configuration with your prettier installation you can simply put this into your `package.json`:

```json
{
  "prettier": "@pyramine/prettier-config"
}
```

Alternatively you can also use the `prettier.config.js` file:

```js
// just use default config:
module.exports = '@pyramine/prettier-config';
```

```js
// or if you want to extend the base config (not recomended):
const defaultConfig = require('@pyramine/prettier-config').default;

/** @type {import('prettier').Options} */
module.exports = {
    ...defaultConfig,
    singleQuote: false,
};
```
npm package: @pyramine/storage-space
Description: Make accessing the Web-Storage-API more type-safe.
Author: Christian Holländer
Latest version: 2.0.1

# Storage-Space

This packages provides a way to predefine the use `localStorage` and `sessionStorage` keys for your application. It also
provides some additional type-safety for serializing values to the storage engine.

## Installation

```bash
npm install @pyramine/storage-space
```

## Usage

First we will define our spaces:

```ts
import {sessionSpace, localSpace} from "@pyramine/storage-space";

export const storage = {
    first: await sessionSpace<string>('first').initialize('inital-value'),
    second: localSpace<{ complex: string }>('second'),
};


await storage.first.set('myValue');
await storage.second.set({complex: 'myValue'});

await storage.first.get(); // 'myValue'
await storage.second.get(); // { complex: 'myValue' }
```

### Serializers

This package provides some default serializers:

- `JsonSerializer` (used by default)
- `Base64Serializer`

You can switch the serializer at any given time:

```ts
import {Base64Serializer} from "@pyramine/storage-space";

storage.first.serializeUsing(new Base64Serializer());
```

> You can even define custom serializers by creating class which implements our `StorageSerializer` interface.

### Events

The space emit events you can listen on:

| name   | description                                                                   |
|--------|-------------------------------------------------------------------------------|
| change | Fired when ever the underlying value change. Even when the value got removed. |
| remove | Similar to `change` but only fires if the value got removed.                  |

```ts
storage.first.on('change', (event) => {
    console.log(event);
});
storage.first.once('change', (event) => {
    console.log(event);
});
```