Pinia ORM

https://pinia-orm.codedredd.de
Admin
Pinia ORM is a Pinia plugin that enables Object-Relational Mapping access to the Pinia Store with...
Tokens:114,389
Snippets:1,048
Trust Score:5
Update:1 week ago
Show doc for...
Tokens:
Raw
### Initial Setup with Circular Imports

Source: https://pinia-orm.codedredd.de/guide/model/single-table-inheritance

An example of a circular dependency where Person.js references Adult.js and vice versa.

```javascript
// File 1: Person.js
import { Model } from 'pinia-orm'
import Adult from './Adult'
export default class Person extends Model {
  static entity = 'person'
  static types () {
    return {
      PERSON: Person,
      ADULT: Adult
    }
  }
  static fields () {
    return {
      id: this.attr(null),
      name: this.attr(''),
      type: this.attr('PERSON')
    }
  }
}
```

```javascript
// File 2: Adult.js
import Person from './Person'
export default class Adult extends Person {
  static entity = 'adult'
  static baseEntity = 'person'
  static fields() {
    return {
      ...super.fields(),
      job: this.attr(''),
      type: this.attr('ADULT')
    }
  }
}
```

--------------------------------

### get() usage example

Source: https://pinia-orm.codedredd.de/api/query/get

Shows how to use get() to retrieve all records or filter with where(). Requires importing useRepo and the User model.

```typescript
import { useRepo } from 'pinia-orm'
import User from './models/User'
const userRepo = useRepo(User)
const users = userRepo.query().get() // User[] - all 
const usersPreName = userRepo.where('prename', 'John').get() // User[] - with prename 'John'
```

--------------------------------

### Install dependencies

Source: https://pinia-orm.codedredd.de/cookbook/vue-query

Install the required packages for Vue Query and pinia-orm.

```bash
npm install @tanstack/vue-query pinia-orm
```

--------------------------------

### Request Configuration with useAxiosRepo().get()

Source: https://pinia-orm.codedredd.de/plugins/axios/guide/configuration

Configure options on a per-request basis. These options inherit global and model configurations and are passed to the request. This example sets headers and baseURL for a GET request.

```javascript
useAxiosRepo(User).api().get('/api/users', {
  headers: { 'X-Requested-With': 'XMLHttpRequest' },
  baseURL: 'https://example.com/api/'
})
```

--------------------------------

### Getting the pinia store instance with piniaStore()

Source: https://pinia-orm.codedredd.de/guide/model/pinia-options

Access the Pinia store instance for a model repository using `piniaStore()`. The example logs the current state value.

```javascript
const userRepo = useRepo(User)
console.log(userRepo.piniaStore().state.value)
```

--------------------------------

### Install with npm

Source: https://pinia-orm.codedredd.de/guide/nuxt/setup

Install the Pinia ORM Nuxt module using npm.

```bash
npm install @pinia-orm/nuxt --save
```

--------------------------------

### Enable Pinia setup store syntax

Source: https://pinia-orm.codedredd.de/changelog

Shows how to configure Pinia ORM to use the setup store syntax by setting storeType to 'setupStore' in the pinia options.

```javascript
createPiniaORM({ pinia: { storeType: 'setupStore' } })
```

--------------------------------

### Install with Yarn

Source: https://pinia-orm.codedredd.de/guide/nuxt/setup

Install the Pinia ORM Nuxt module and its core package using Yarn.

```bash
yarn add pinia-orm @pinia-orm/nuxt
```

--------------------------------

### Define piniaOptions and piniaExtend in a Model

Source: https://pinia-orm.codedredd.de/guide/getting-started/configuration

Use the `piniaOptions` property to pass setup store options and `piniaExtend` to pass configuration to other pinia plugins. The example shows a User model with these properties and decorators.

```typescript
    class User extends Model {
      static entity = 'users'
      static piniaOptions = {
        newData: ref('1'),
      }
      static piniaExtend = {
        persist: true,
      }
      @Attr(0) id!: number
      @Str('') name!: string
      @Str('') username!: string
    }
```

--------------------------------

### Install @pinia-orm/axios with NPM

Source: https://pinia-orm.codedredd.de/plugins/axios/guide/setup

Use NPM to install and save the Pinia ORM Axios plugin.

```bash
npm install @pinia-orm/axios --save
```

--------------------------------

### Install Pinia ORM via NPM

Source: https://pinia-orm.codedredd.de/guide/getting-started/quick-start

Use NPM to install and save the pinia-orm package.

```bash
npm install pinia-orm --save
```

--------------------------------

### Using useRepo outside of setup()

Source: https://pinia-orm.codedredd.de/guide/getting-started/usage

When using Pinia ORM outside of setup(), you must pass the pinia instance to useRepo. The first call fails because pinia is not yet created, the second works because the pinia instance is passed.

```javascript
import User from '@/models/User'
import { createApp } from 'vue'
import App from './App.vue'
// ❌  fails because it's called before the pinia is created
const userRepo = useRepo(User)
// ✅ works because the pinia instance is passed to defineStore
const userRepo = useRepo(User, this.$pinia)
```

--------------------------------

### Install nanoid with Yarn

Source: https://pinia-orm.codedredd.de/guide/model/getting-started

Installs the nanoid package using Yarn, required for using nanoid-based uid generation.

```bash
yarn add nanoid
```

--------------------------------

### Install nanoid with NPM

Source: https://pinia-orm.codedredd.de/guide/model/getting-started

Installs the nanoid package using NPM, required for using nanoid-based uid generation.

```bash
npm install nanoid --save
```

--------------------------------

### Example Response Body

Source: https://pinia-orm.codedredd.de/plugins/axios/guide/usage

Example response body used to demonstrate the dataTransformer option.

```javascript
{
  ok: true,
  record: {
    id: 1,
    name: 'John Doe'
  }
}
```

--------------------------------

### Limit and offset query results

Source: https://pinia-orm.codedredd.de/guide/repository/retrieving-data

Use `limit` and `offset` to paginate query results. The example retrieves 30 records starting from the 10th record.

```javascript
const user = useRepo(User).limit(30).offset(10).get()
```

--------------------------------

### groupBy() usage example

Source: https://pinia-orm.codedredd.de/api/query/group-by

Shows how to use groupBy() to group users by name, and optionally by multiple columns (name and age).

```javascript
import { useRepo } from 'pinia-orm'
import User from './models/User'
const userRepo = useRepo(User)
// Group users by name.
useRepo(User).groupBy('name').get()
// You may also pass multiple columns
useRepo(User).groupBy('name', 'age').get()
```

--------------------------------

### Install Pinia ORM via Yarn

Source: https://pinia-orm.codedredd.de/guide/getting-started/quick-start

Use Yarn to add the pinia-orm package to your project.

```bash
yarn add pinia-orm
```

--------------------------------

### Install @pinia-orm/axios with PNPM

Source: https://pinia-orm.codedredd.de/plugins/axios/guide/setup

Use PNPM to add the Pinia ORM Axios plugin to your project.

```bash
pnpm add @pinia-orm/axios
```

--------------------------------

### Install Pinia ORM via PNPM

Source: https://pinia-orm.codedredd.de/guide/getting-started/quick-start

Use PNPM to add the pinia-orm package to your project.

```bash
pnpm add pinia-orm
```

--------------------------------

### Basic GET request with useAxiosRepo

Source: https://pinia-orm.codedredd.de/plugins/axios/guide/usage

Performs a GET request to fetch all users and automatically persists the response to the store.

```javascript
await useAxiosRepo(User).api().get('https://example.com/api/users')
```

--------------------------------

### Install @pinia-orm/axios with Yarn

Source: https://pinia-orm.codedredd.de/plugins/axios/guide/setup

Use Yarn to add the Pinia ORM Axios plugin to your project.

```bash
yarn add @pinia-orm/axios
```

--------------------------------

### Install uuid with Yarn

Source: https://pinia-orm.codedredd.de/guide/model/getting-started

Installs the uuid package using Yarn, required for using uuid-based uid generation.

```bash
yarn add uuid
```

--------------------------------

### Get all users with repository all()

Source: https://pinia-orm.codedredd.de/guide/repository/retrieving-data

Retrieves all users from the store. The `all()` method does not process any query chain and always returns all models.

```javascript
// Get all users from the store.
const users = useRepo(User).all()
```

--------------------------------

### Install uuid with NPM

Source: https://pinia-orm.codedredd.de/guide/model/getting-started

Installs the uuid package using NPM, required for using uuid-based uid generation.

```bash
npm install uuid --save
```

--------------------------------

### Configure @pinia-orm/axios plugin in main.ts

Source: https://pinia-orm.codedredd.de/cookbook/axios

Setup the Pinia ORM instance with the axios plugin in your main entry file.

```typescript
// main.ts
import { createApp } from 'vue'
import { createPinia } from 'pinia'
import { createORM } from 'pinia-orm'
import { createPiniaOrmAxios } from '@pinia-orm/axios'
import axios from 'axios'
import App from './App.vue'
const pinia = createPinia()
pinia.use(createORM({
  plugins: [
    createPiniaOrmAxios({
      axios,
      baseURL: 'https://api.example.com',
    }),
  ],
}))
createApp(App).use(pinia).mount('#app')
```

--------------------------------

### Query public posts

Source: https://pinia-orm.codedredd.de/guide/repository/getting-started

Example query to fetch only public posts in published order. This is the logic that can be extracted into a custom repository.

```javascript
useRepo(Post)
  .where('public', true)
  .orderBy('publishedAt', 'desc')
  .get()
```

--------------------------------

### Eager loading relations with with()

Source: https://pinia-orm.codedredd.de/api/query/with

Demonstrates how to eager load relations using the with() method, including an example of filtering related records with a closure.

```javascript
import { useRepo } from 'pinia-orm'
import User from './models/User'
const userRepo = useRepo(User)
const usersWithComments = userRepo.with('comments').get() // User[] with comments relations
// with closure
const usersWithCommentsOnlyActive = userRepo.with('comments', (query) => {
    query.where('active', true)
}).get() // User[] with comments which are active. Don't forget that you still get all Users just with less comments
```

--------------------------------

### setAxios(axios)

Source: https://pinia-orm.codedredd.de/plugins/axios/api/repository

Sets the axios instance manually. Typically configured during installation, but may be needed later, especially with Nuxt.

```APIDOC
## setAxios(axios)

### Description
Sets the axios instance manually. Typically configured during installation, but may be needed later, especially with Nuxt.

### Parameters
- **axios** (AxiosInstance) - Required - The axios instance to set.

### Returns
- **void** - No return value.

```

--------------------------------

### whereLike() usage examples

Source: https://pinia-orm.codedredd.de/api/query/where-like

Shows how to use whereLike() with different patterns and options, including case sensitivity and combining with other where clauses.

```typescript
import { useRepo } from 'pinia-orm'
import User from './models/User'
const userRepo = useRepo(User)
// All users whose name contains "john" (case insensitive).
userRepo.whereLike('name', '%john%').get()
// All users whose name starts with "John" (case sensitive).
userRepo.whereLike('name', 'John%', true).get()
// Single character wildcard: matches "John Doe" and "Jahn Doe".
userRepo.whereLike('name', 'J_hn Doe').get()
// Combine with other where clauses.
userRepo.where('active', true).orWhereLike('name', 'jane%').get()
```

--------------------------------

### Use New Repository Query and Upsert Features

Source: https://pinia-orm.codedredd.de/changelog

Examples of using Laravel-style upserts, SQL-like filtering, and locale-aware sorting in Pinia ORM repositories.

```javascript
// Laravel style upserts
useRepo(User).updateOrCreate({ name: 'Jane Doe' }, { age: 41 })
const user = useRepo(User).firstOrCreate({ name: 'Jane Doe' }, { age: 40 })
// SQL LIKE filtering
useRepo(Project).whereLike('name', `%${query}%`).get()
// locale aware sorting
useRepo(Item).orderBy('name', 'asc', new Intl.Collator('lt')).get()
```

--------------------------------

### Define Has Many Through Models

Source: https://pinia-orm.codedredd.de/guide/relationships/one-to-many

Example models showing the setup for a Country having many Posts through a User.

```javascript
class Country extends Model {
  static entity = 'countries'
  static fields () {
    return {
      id: this.attr(null),
      posts: this.hasManyThrough(Post, User, 'country_id', 'user_id')
    }
  }
}
class User extends Model {
  static entity = 'users'
  static fields () {
    return {
      id: this.attr(null),
      country_id: this.attr(null)
    }
  }
}
class Post extends Model {
  static entity = 'posts'
  static fields () {
    return {
      id: this.attr(null),
      user_id: this.attr(null)
    }
  }
}
```

--------------------------------

### Using useCache() with different configurations

Source: https://pinia-orm.codedredd.de/api/query/use-cache

Demonstrates how to apply caching to a repository query using auto-generated keys, manual keys, and manual keys with dynamic parameters.

```javascript
import { useRepo } from 'pinia-orm'
import User from './models/User'
// Generate a cache with a auto generated key.
useRepo(User).useCache().get()
// Generate a cache with a manual key (recommanded).
useRepo(User).useCache('key').get()
// Generate a cache with a manual key and dynamic params (recommanded).
useRepo(User).useCache('key', { id: idProperty }).get()
```

--------------------------------

### Standard usage with useRepo

Source: https://pinia-orm.codedredd.de/guide/getting-started/usage

Use useRepo to get a repository for a model, then call methods like with('todos').get() to fetch related data.

```javascript
import User from './models/User'
import { useRepo } from 'pinia-orm'
const userRepo = useRepo(User)
// Getting all users with their todos as relation
const users = userRepo.with('todos').get()
```

--------------------------------

### Register the custom plugin with createORM

Source: https://pinia-orm.codedredd.de/plugins/introduction

Shows how to add the plugin to the Pinia ORM instance by passing it in the plugins array of createORM. Requires pinia and vue setup.

```javascript
import { createPinia, setActivePinia } from 'pinia'
import { createORM } from 'pinia-orm'
import { createApp } from 'vue'
import { piniaOrmPlugin } from './plugins'

const app = createApp({})
const pinia = createPinia()
const piniaOrm = createORM({
  plugins: [
    piniaOrmPlugin()
  ],
})
pinia.use(piniaOrm)
app.use(pinia)
setActivePinia(pinia)
```

--------------------------------

### Usage of whereNotIn()

Source: https://pinia-orm.codedredd.de/api/query/where-not-in

Shows how to use `whereNotIn()` to filter records by excluding values in an array or a Set. The example uses `useRepo` to get a repository for the `User` model and calls `whereNotIn('commentIds', [1,2,5])` and `whereNotIn('commentIds', new Set([1,2,5]))`.

```javascript
import { useRepo } from 'pinia-orm'
import User from './models/User'

const userRepo = useRepo(User)

// Filter by array
console.log(userRepo.whereNotIn('commentIds', [1,2,5]).get())

// Filter by Set
console.log(userRepo.whereNotIn('commentIds', new Set([1,2,5])).get())
```

--------------------------------

### Global Configuration with createPiniaOrmAxios

Source: https://pinia-orm.codedredd.de/plugins/axios/guide/configuration

Configure the plugin during installation by passing an object as the second argument to the Pinia ORM use() method. The axios instance is required; other options like headers and baseURL are optional and inherited by all requests.

```javascript
import axios from 'axios'
import { createORM } from 'pinia-orm'
import { createPiniaOrmPluginAxios } from '@pinia-orm/axios'
const piniaOrm = createORM({
  plugins: [
    createPiniaOrmAxios({
      axios,
      headers: { 'X-Requested-With': 'XMLHttpRequest' },
      baseURL: 'https://example.com/api/',
    }),
  ],
})
```

--------------------------------

### Usage of $getOriginal()

Source: https://pinia-orm.codedredd.de/api/model/functions/get-original

Shows how to use `$getOriginal()` to retrieve the original attribute values after modifying a model instance. The example creates a User model, changes the `name` attribute, and then calls `$getOriginal()` to get the original values. The output is shown in the comment.

```typescript
class User extends Model {
  static entity = 'users'
  @Attr('') id!: number
  @Str('') name!: string
}
const user = new User({ id: 1, name: 'John Doe' })
user.name = 'Vue JS Amsterdam'
user.$getOriginal()
// {
//    id: 1,
//    name: 'John Doe',
// }
console.log(user.name)
// 'Vue JS Amsterdam'
```

--------------------------------

### Usage: makeHidden() with useRepo

Source: https://pinia-orm.codedredd.de/api/query/make-hidden

Shows how to use `makeHidden()` on a repository to hide the 'phone' field from the returned User model. The example imports `useRepo` and the User model, then calls `makeHidden(['phone']).first()` to get the first user without the phone field.

```typescript
import { useRepo } from 'pinia-orm'
import User from './models/User'
const userRepo = useRepo(User)
// Returns User without the field 'phone'
userRepo.makeHidden(['phone']).first() 
```

--------------------------------

### Get active users with where() and get()

Source: https://pinia-orm.codedredd.de/guide/repository/retrieving-data

Retrieves users where the `active` attribute is true. The `get()` method processes the query chain.

```javascript
// Get all active users.
const users = useRepo(User).where('active', true).get()
```

--------------------------------

### Request.get

Source: https://pinia-orm.codedredd.de/plugins/axios/api/request

Performs a GET request. Takes the same arguments as the axios get method.

```APIDOC
## Request.get

### Description
Performs a GET request. Takes the same arguments as the axios get method.

### Method
GET

### Signature
`get(url: string, config: Config = {}): Promise<Response>`

### Parameters
- **url** (string) - Required - The URL to send the request to.
- **config** (Config) - Optional - Axios request configuration.

### Returns
Promise<Response> - A promise that resolves to a Response object.
```

--------------------------------

### get() TypeScript declaration

Source: https://pinia-orm.codedredd.de/api/query/get

The TypeScript declaration for the get() method, showing it returns a Collection<M>.

```typescript
function get(): Collection<M>
```

--------------------------------

### Initialize Request via Repository

Source: https://pinia-orm.codedredd.de/plugins/axios/api/request

Obtain a Request object by calling the api() method on a repository.

```javascript
const request = useAxiosRepo(User).api()
```

--------------------------------

### Usage of new() with useRepo

Source: https://pinia-orm.codedredd.de/api/repository/new

Shows how to import useRepo and a User model, create a repository, and call new() to create a model with default values. Calling new() without arguments persists the model, while new(false) creates a model that will not be persisted.

```typescript
import { useRepo } from 'pinia-orm'
import User from './models/User'

const userRepo = useRepo(User)

// Make a model with default values which will be persisted
userRepo.new()

// Make a model with default values which will not be persisted
userRepo.new(false)
```

--------------------------------

### Configure main.ts

Source: https://pinia-orm.codedredd.de/cookbook/vue-query

Register the Pinia, pinia-orm, and VueQuery plugins in your main application file.

```typescript
// main.ts
import { createApp } from 'vue'
import { createPinia } from 'pinia'
import { createORM } from 'pinia-orm'
import { VueQueryPlugin } from '@tanstack/vue-query'
import App from './App.vue'
const app = createApp(App)
app.use(createPinia().use(createORM()))
app.use(VueQueryPlugin)
app.mount('#app')
```

--------------------------------

### useSortBy() usage examples

Source: https://pinia-orm.codedredd.de/api/composables/helpers/use-sort-by

Shows various ways to call useSortBy(): sorting by a string key, case-insensitive sorting, locale-aware sorting, multi-key sorting, and sorting by a callback.

```javascript
import { useRepo } from 'pinia-orm'
import { useSortBy } from 'pinia-orm/helpers'
import User from './models/User'

const users = useRepo(User).all()

// sort by the 'name' attribute
useSortBy(users, 'name')

// sort by the `name` attribute case insensitive
useSortBy(users, 'name', 'SORT_FLAG_CASE')

// sort by the `name` attribute locale aware
useSortBy(users, 'name', new Intl.Collator('lt'))

// sorts the collection by 'name' descending and then by 'lastname' ascending
useSortBy(users, [
    ['name', 'desc'],
    ['lastname', 'asc'],
])

// sort by the 'age' attribute
useSortBy(users, (model) => model.age)
```

--------------------------------

### useRepo() usage example

Source: https://pinia-orm.codedredd.de/api/composables/use-repo

Shows how to call useRepo() with a model class or a custom repository class. The first call returns a Repository<User>, the second returns a PostRepository instance.

```typescript
import { useRepo } from 'pinia-orm'
import User from './models/User'
import PostRepository from './repositories/Post'
const userRepo = useRepo(User) // Repository<User>
const postRepo = useRepo(PostRepo) // PostRepository

```

--------------------------------

### Create custom repository

Source: https://pinia-orm.codedredd.de/guide/repository/getting-started

Creates a custom repository by extending the base Repository class and setting the use property to the Post model.

```javascript
import { Repository } from 'pinia-orm'
import Post from '@/models/Post'
class PostRepository extends Repository {
  use = Post
}
```

--------------------------------

### GET request with response data and store state

Source: https://pinia-orm.codedredd.de/plugins/axios/guide/usage

Shows a basic GET request, the response body, and the resulting store state after automatic persistence.

```javascript
useAxiosRepo(User).api().get('https://example.com/api/users')
```

```json
[
  {
    "id": 1,
    "name": "John Doe",
    "age": 24
  },
  {
    "id": 2,
    "name": "Jane Doe",
    "age": 21
  }
]
```

```javascript
{
  users: {
    data: {
      1: { id: 1, name: 'John Doe', age: 24 },
      2: { id: 2, name: 'Jane Doe', age: 21 }
    }
  }
}
```

--------------------------------

### withAll() usage example

Source: https://pinia-orm.codedredd.de/api/query/with-all

Shows how to use withAll() to eager load all relations for a User model. The optional callback filters the relations (e.g., only active comments) while still returning all users.

```javascript
import { useRepo } from 'pinia-orm'
import User from './models/User'
const userRepo = useRepo(User)
const usersWithComments = userRepo.withAll().get() // User[] with all its relations loaded
// with closure
const usersWithCommentsOnlyActive = userRepo.withAll((query) => {
    query.where('active', true)
}).get() // User[] with comments which are active. Don't forget that you still get all Users just with less relations
```

--------------------------------

### static mutators()

Source: https://pinia-orm.codedredd.de/api/model/options/mutators

Defines mutators for model attributes. Each mutator can have a get function to transform the value when retrieved, and a set function to transform the value when assigned. A shorthand form can be used to define only a get mutator.

```APIDOC
## static mutators()

### Description
Defines mutators for model attributes. Each mutator can have a get function to transform the value when retrieved, and a set function to transform the value when assigned. A shorthand form can be used to define only a get mutator.

### Method
static method

### Parameters
None

### Returns
- **Mutators** - An object mapping attribute names to mutator functions or objects with get and set functions.

### Example
```js
import { Model } from 'pinia-orm'

class User extends Model {
  static entity = 'users'
  static fields () {
    return {
      id: this.attr(null),
      firstName: this.attr(''),
      lastName: this.attr('')
    }
  }
  static mutators() {
    return {
      firstName: {
        get: (value: any) => value.toLowerCase(),
        set: (value: any) => value.toUpperCase(),
      },
      lastName(value: any) => value.toLowerCase()
    }
  }
}
```
```

--------------------------------

### Instantiate Request Class

Source: https://pinia-orm.codedredd.de/plugins/axios/api/request

Create a new Request instance manually by passing a repository to the constructor.

```javascript
import { Request } from '@pinia-orm/axios'
const request = new Request(useAxiosRepo(User))
```

--------------------------------

### Usage of useGroupBy()

Source: https://pinia-orm.codedredd.de/api/composables/helpers/use-group-by

Shows how to import useRepo, useGroupBy, and a User model, then group all users by the 'name' attribute or by both 'name' and 'age' attributes.

```javascript
import { useRepo } from 'pinia-orm'
import { useGroupBy } from 'pinia-orm/helpers'
import User from './models/User'

const users = useRepo(User).all()
// group by the 'name' attribute
useGroupBy(users, 'name')
// group by the 'name' and 'age' attribute
useGroupBy(users, ['name', 'age'])
```

--------------------------------

### usePluck() usage example

Source: https://pinia-orm.codedredd.de/api/composables/helpers/use-pluck

Shows how to import useRepo, usePluck, and a User model, then retrieve all values of the 'age' attribute and the 'role.title' attribute (dot notation works only for 1n1 relations).

```typescript
import { useRepo } from 'pinia-orm'
import { usePluck } from 'pinia-orm/helpers'
import User from './models/User'

const users = useRepo(User).all()

// retrieve all values of the 'age' attribute
usePluck(users, 'age')

// retrieve all values of the 'role.title' attribute. The dot notation works only for 1n1 Relations
usePluck(users, 'role.title')
```

--------------------------------

### Retrieve primary keys with useKeys()

Source: https://pinia-orm.codedredd.de/api/composables/helpers/use-keys

Demonstrates how to import and use the useKeys helper to extract primary keys from a collection of models retrieved via useRepo.

```typescript
import { useRepo } from 'pinia-orm'
import { useKeys } from 'pinia-orm/helpers'
import User from './models/User'
const users = useRepo(User).all()
// retrieve all primary keys
useKeys(users)
```

--------------------------------

### Circular Dependency Error

Source: https://pinia-orm.codedredd.de/guide/model/single-table-inheritance

Example of a runtime error caused by circular dependencies in model imports.

```text
TypeError: Super expression must either be null or a function, not undefined.
```

--------------------------------

### Create model instance with default values

Source: https://pinia-orm.codedredd.de/guide/repository/inserting-data

Pass an object to the make method to set initial values.

```javascript
const user = useRepo(User).make({
  name: 'John Doe',
  age: 30
})
```

--------------------------------

### orWhereIn()

Source: https://pinia-orm.codedredd.de/api/query/or-where-in

Documentation for the `orWhereIn()` method in Pinia ORM, including usage examples and TypeScript declaration.

```APIDOC
## `orWhereIn()`

### Description
Adds an "or where in" clause to the query, filtering records where the given field's value is in the provided array or Set.

### Method
`orWhereIn`

### Signature
`function orWhereIn(field: string, values: any[]|Set): Query`

### Parameters
- **field** (string) - Required - The field name to check.
- **values** (any[] | Set) - Required - An array or Set of values to match against.

### Usage Example
```js
import { useRepo } from 'pinia-orm'
import User from './models/User'

const userRepo = useRepo(User)

// Filter by array
console.log(userRepo.orWhereIn('commentIds', [1,2,5]).get())

// Filter by Set
console.log(userRepo.orWhereIn('commentIds', new Set([1,2,5])).get())
```

### Return Value
Returns a `Query` instance for further chaining.
```

--------------------------------

### belongsToMany

Source: https://pinia-orm.codedredd.de/api/model/options/fields-relations/belongs-to-many

Documentation for the belongsToMany method in Pinia ORM, including usage examples and TypeScript declarations.

```APIDOC
## `belongsToMany`

### Description
Defines a many-to-many relationship between the current model and a related model through a pivot model.

### Usage
```javascript
import { Model } from 'pinia-orm'
import Role from './Role'
import RoleUser from './RoleUser'

class User extends Model {
  static entity = 'users'
  static fields () {
    return {
      id: this.attr(null),
      roles: this.belongsToMany(Role, RoleUser, 'user_id', 'role_id')
    }
  }
}
```

### With Decorator
```javascript
import { Model } from 'pinia-orm'
import { Attr, BelongsToMany, Str } from 'pinia-orm/decorators'
import Role from './Role'
import RoleUser from './RoleUser'

class User extends Model {
  static entity = 'users'
  
  @Attr(null) id!: number | null
  @BelongsToMany(() => Role, () => RoleUser, 'user_id', 'role_id') roles!: Role[]
  // or if you have other pivot key
  // @BelongsToMany(() => Role, { as: 'userPivot', model: () => RoleUser }, 'user_id', 'role_id')
}
```

### TypeScript Declarations
```typescript
function belongsToMany(
  related: typeof Model,
  pivot: (() => typeof Model) | {
    as: string
    model: () => typeof Model
  },
  foreignPivotKey: string,
  relatedPivotKey: string,
  parentKey?: string,
  relatedKey?: string,
): BelongsToMany
```
```

--------------------------------

### whereNull() usage example

Source: https://pinia-orm.codedredd.de/api/query/where-null

Imports useRepo and User model, then retrieves all users where the 'age' field is null.

```typescript
import { useRepo } from 'pinia-orm'
import User from './models/User'
const userRepo = useRepo(User)
console.log(userRepo.whereNull('age').get()) // User[] - with age set to null
```

--------------------------------

### Equivalent request configuration for the fetch action

Source: https://pinia-orm.codedredd.de/plugins/axios/guide/custom-actions

Shows the equivalent request configuration for the custom `fetch` action defined above. Calling `request` with `method: 'get'` and `url: '/api/users'` performs the same API call.

```javascript
useAxiosRepo(User).api().request({
  method: 'get',
  url: '/api/users'
})
```

--------------------------------

### Find records by ID with useRepo().find()

Source: https://pinia-orm.codedredd.de/api/query/find

Shows how to use the find() method to retrieve a single record by primary key or multiple records by an array of keys. The first call returns a single User instance, the second returns a collection of User instances.

```javascript
import { useRepo } from 'pinia-orm'
import User from './models/User'
const userRepo = useRepo(User)
console.log(userRepo.find(1)) // User
console.log(userRepo.find([1,2,5])) // User[]
```

--------------------------------

### Customize Has Many Through Keys

Source: https://pinia-orm.codedredd.de/guide/relationships/one-to-many

Example of passing custom local keys as the 5th and 6th arguments to the hasManyThrough method.

```javascript
this.hasManyThrough(
  Post,               // Final model we wish to access.
  User,               // Intermediate model.
  'country_id',       // Foreign key on User model.
  'user_id',          // Foreign key on Post model.
  'local_country_id', // Local key on Country model.
  'local_user_id'     // Local key on User model.
)
```

--------------------------------

### Usage of make() with default values, single record, and multiple records

Source: https://pinia-orm.codedredd.de/api/repository/make

Shows how to use make() to create a model with default values, with a single record, and with an array of records. The method does not save to the store and does not fire hooks.

```javascript
import { useRepo } from 'pinia-orm'
import User from './models/User'

const userRepo = useRepo(User)

// Make a model with default values
userRepo.make()

// Make a model with values
userRepo.make({
  id: 1,
  name: 'Jane Doe',
})

// Make many models with values
userRepo.make([
  {
    id: 1,
    name: 'Jane Doe',
  },
  {
    id: 2,
    name: 'John Doe',
  },
])
```

--------------------------------

### Example data structure for hasManyBy

Source: https://pinia-orm.codedredd.de/guide/relationships/one-to-many

Shows a data structure where a parent model contains an array of foreign keys.

```json
{
  nodes: {
    1: { id: 1, name: 'Node 01' },
    2: { id: 2, name: 'Node 02' }
  },
  clusters: {
    1: {
      id: 1,
      name: 'Cluster 01',
      nodeIds: [1, 2]
    }
  }
}
```

--------------------------------

### Define Many-to-Many Relationship

Source: https://pinia-orm.codedredd.de/guide/relationships/many-to-many

Basic setup for a many-to-many relationship using User, Role, and RoleUser models with belongsToMany.

```javascript
class User extends Model {
  static entity = 'users'
  static fields () {
    return {
      id: this.attr(null),
      roles: this.belongsToMany(Role, RoleUser, 'user_id', 'role_id')
    }
  }
}
class Role extends Model {
  static entity = 'roles'
  static fields () {
    return {
      id: this.attr(null)
    }
  }
}
class RoleUser extends Model {
  static entity = 'roleUser'
  static primaryKey = ['role_id', 'user_id']
  static fields () {
    return {
      role_id: this.attr(null),
      user_id: this.attr(null)
    }
  }
}
```

--------------------------------

### Generate a user and inspect id

Source: https://pinia-orm.codedredd.de/guide/model/getting-started

Creates a new user with useRepo(User).make() and shows the generated UUID value in the id property.

```javascript
const user = useRepo(User).make()
user.id // <- '2c5ea4c0-4067-11e9-8bad-9b1deb4d3b7d'
```

--------------------------------

### Register Pinia ORM plugins with createORM options

Source: https://pinia-orm.codedredd.de/changelog

Shows the new way to register plugins for Pinia ORM. Previously plugins were registered via piniaOrm().use(), now they must be passed in the plugins array of createORM(). The diff shows the old (removed) and new (added) syntax.

```diff
- const piniaOrm = createORM()
- piniaOrm().use(createPiniaOrmAxios({
-   axios,
- }))
+ const piniaOrm = createORM({
+    plugins: [
+       createPiniaOrmAxios({
+        axios,
+       }),
+    ],
+   })
```

--------------------------------

### offset() usage example

Source: https://pinia-orm.codedredd.de/api/query/offset

Shows how to use offset() to skip the last 30 users in a query. It imports useRepo and User model, then calls offset(30).get() to retrieve the remaining users.

```typescript
import { useRepo } from 'pinia-orm'
import User from './models/User'
const userRepo = useRepo(User)
// Remove the last 30 users
useRepo(User).offset(30).get()
```

--------------------------------

### useSum() usage example

Source: https://pinia-orm.codedredd.de/api/composables/helpers/use-sum

Imports useRepo, useSum, and a User model, then retrieves all users and calculates the sum of the 'age' attribute. Also demonstrates dot notation for a 1:1 relation attribute 'role.title'.

```typescript
import { useRepo } from 'pinia-orm'
import { useSum } from 'pinia-orm/helpers'
import User from './models/User'
const users = useRepo(User).all()
// get the sum of the 'age' attribute
useSum(users, 'age')
// get the sum of the 'role.title' attribute. The dot notation works only for 1n1 Relations
useSum(users, 'role.title')
```

--------------------------------

### Define belongsToMany with Decorators

Source: https://pinia-orm.codedredd.de/api/model/options/fields-relations/belongs-to-many

Using decorators to define the many-to-many relationship. Includes an example of how to handle custom pivot keys.

```typescript
import { Model } from 'pinia-orm'
import { Attr, BelongsToMany, Str } from 'pinia-orm/decorators'
import Role from './Role'
import RoleUser from './RoleUser'
class User extends Model {
  static entity = 'users'
  
  @Attr(null) id!: number | null
  @BelongsToMany(() => Role, () => RoleUser, 'user_id', 'role_id') roles!: Role[]
  // or if you have other pivot key
  // @BelongsToMany(() => Role, { as: 'userPivot', model: () => RoleUser }, 'user_id', 'role_id')
}
```

--------------------------------

### Usage: limit(30).get()

Source: https://pinia-orm.codedredd.de/api/query/limit

Imports `useRepo` and a User model, then returns only 30 users using `limit(30).get()`.

```javascript
import { useRepo } from 'pinia-orm'
import User from './models/User'
const userRepo = useRepo(User)
// Return only 30 users
useRepo(User).limit(30).get()
```

--------------------------------

### $getAttributes()

Source: https://pinia-orm.codedredd.de/api/model/functions/get-attributes

Returns the model's attributes, excluding relations. The example shows that relations like posts are omitted from the result.

```APIDOC
## $getAttributes()

### Description
Returns the model's attributes, excluding any relations. In the example, the `posts` relation is not included in the returned object.

### Method
$getAttributes()

### Usage Example
```js
class User extends Model {
  static entity = 'users'
  @Attr('') id!: number
  @Str('') name!: string
  @HasMany(() => Post, 'userId') posts!: Post[]
}
const user = new User({ id: 1, name: 'John Doe', posts: [{ id: 1, title: 'Merry Christmas' }] })
user.$getAttributes()
// {
//    id: 1,
//    name: 'John Doe',
// }
```

### TypeScript Declaration
```ts
function $getAttributes(): Element
```
```

--------------------------------

### Access cache instance with cache method

Source: https://pinia-orm.codedredd.de/guide/repository/retrieving-data

Retrieves the current cache instance. Can get its size or check if a specific key exists.

```javascript
// Get the repos cache instance
const cache = useRepo(User).cache()
// Getting the size of the current cache
useRepo(User).cache().size
// Checking if a specific key exist
useRepo(User).cache().has('key')
```
Tokens:
Raw