open-index/open-npm huggingface dataset:
npm package: @ronin/better-auth
Description: A Better Auth adapter for RONIN
Author: ronin
Latest version: 1.0.0

# Better Auth + RONIN

[![tests](https://img.shields.io/github/actions/workflow/status/ronin-co/better-auth/validate.yml?label=tests)](https://github.com/ronin-co/better-auth/actions/workflows/validate.yml)
[![code coverage](https://img.shields.io/codecov/c/github/ronin-co/better-auth)](https://codecov.io/github/ronin-co/better-auth)
[![install size](https://packagephobia.com/badge?p=@ronin/better-auth)](https://packagephobia.com/result?p=@ronin/better-auth)

A [Better Auth adapter](https://www.better-auth.com/docs/concepts/database#adapters) for storing session data in [RONIN](https://ronin.co/) with ease.

## Usage

```typescript
import { betterAuth } from 'better-auth';
import { ronin } from "@ronin/better-auth";

const auth = betterAuth({
  database: ronin(),
  // ...
});
```

Or if you want to use a custom client instance:

```typescript
import { betterAuth } from 'better-auth';
import { ronin } from "@ronin/better-auth";
import { createSyntaxFactory } from 'ronin';

const client = createSyntaxFactory({
  token: process.env.RONIN_TOKEN,
});

const auth = betterAuth({
  database: ronin(client),
  // ...
});
```

## Schema

Better Auth requires a number of schema models / tables to be created in your database. This is referred to in the Better Auth documentation as the "core schema".

To help get started, here is that "core schema" translated to a RONIN database schema:

```ts
// schema/index.ts

import { blob, boolean, date, link, model, string } from 'ronin/schema';

export const User = model({
  slug: 'user',
  fields: {
    email: string({ required: true, unique: true }),
    emailVerified: boolean({ required: true }),
    image: blob(),
    name: string({ required: true }),
  },
});

export const Session = model({
  slug: 'session',
  fields: {
    expiresAt: date({ required: true }),
    ipAddress: string(),
    token: string({ required: true, unique: true }),
    userId: link({ required: true, target: 'user' }),
    userAgent: string(),
  },
});

export const Account = model({
  slug: 'account',
  pluralSlug: 'accounts',
  fields: {
    accessToken: string(),
    accessTokenExpiresAt: date(),
    accountId: string({ required: true }),
    idToken: string(),
    password: string(),
    providerId: string({ required: true }),
    refreshToken: string(),
    refreshTokenExpiresAt: date(),
    scope: string(),
    userId: link({ required: true, target: 'user' }),
  },
});

export const Verification = model({
  slug: 'verification',
  pluralSlug: 'verifications',
  fields: {
    expiresAt: date({ required: true }),
    identifier: string({ required: true }),
    value: string({ required: true }),
  },
});
```

## Testing

Use the following command to run the test suite:

```
bun test
```
npm package: @ronin/cli
Description: The command-line interface for RONIN.
Author: ronin
Latest version: 0.3.20

# RONIN CLI

[![tests](https://img.shields.io/github/actions/workflow/status/ronin-co/cli/validate.yml?label=tests)](https://github.com/ronin-co/cli/actions/workflows/validate.yml)
[![code coverage](https://img.shields.io/codecov/c/github/ronin-co/cli)](https://codecov.io/github/ronin-co/cli)
[![install size](https://packagephobia.com/badge?p=@ronin/cli)](https://packagephobia.com/result?p=@ronin/cli)

This package exposes the `ronin` command, which you can run from your terminal to interact with [RONIN](https://ronin.co).

## Setup

You don't need to install this package explicitly, as it is already included in the [RONIN client](https://github.com/ronin-co/client).

However, we would be excited to welcome your feature suggestions or bug fixes for the RONIN CLI. Read on to learn more about how to suggest changes.

## Contributing

To start contributing code, first make sure you have [Bun](https://bun.sh) installed, which is a JavaScript runtime.

Next, [clone the repo](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository) and install its dependencies:

```bash
bun install
```

Once that's done, link the package to make it available to all of your local projects:

```bash
bun link
```

Inside the [@ronin/client](https://github.com/ronin-co/client) repo (which imports `@ronin/cli` and registers it as an executable), you can then run the following command, which is similar to `bun add @ronin/cli` or `npm install @ronin/cli`, except that it doesn't install `@ronin/cli` from npm, but instead uses your local clone of the package:

```bash
bun link @ronin/cli
```

### Transpilation

In order to be compatible with a wide range of projects, the source code of the `cli` repo needs to be compiled (transpiled) whenever you make changes to it. To automate this, you can keep this command running in your terminal:

```bash
bun run dev
```

Whenever you make a change to the source code, it will then automatically be transpiled again.

### Running Tests

The RONIN CLI has 100% test coverage, which means that every single line of code is tested automatically, to ensure that any change to the source code doesn't cause a regression.

Before you create a pull request on the `cli` repo, it is therefore advised to run those tests in order to ensure everything works as expected:

```bash
# Run all tests
bun test

# Alternatively, run a single test
bun test -t 'your test name'
```
npm package: @ronin/codegen
Description: Generates TypeScript code from RONIN models.
Author: ronin
Latest version: 1.7.4

# RONIN Codegen

[![tests](https://img.shields.io/github/actions/workflow/status/ronin-co/codegen/validate.yml?label=tests)](https://github.com/ronin-co/codegen/actions/workflows/validate.yml)
[![code coverage](https://img.shields.io/codecov/c/github/ronin-co/codegen)](https://codecov.io/github/ronin-co/codegen)
[![install size](https://packagephobia.com/badge?p=@ronin/codegen)](https://packagephobia.com/result?p=@ronin/codegen)

This package generates TypeScript code based on RONIN models.

## Usage
```typescript
import { generate } from '@ronin/codegen';
import { model, string } from 'ronin/schema';

const User = model({
  slug: 'user',
  pluralSlug: 'users',
  fields: {
    name: string(),
    email: string({ required: true }),
  },
});

const generateCode = generate([User]);
//       ^? string
```

## Testing

Use the following command to run the test suite:

```
bun test
```