home / skills / partme-ai / full-stack-skills / pinia

pinia skill

safe

This skill helps you implement Pinia state management in Vue 3 apps, covering stores, state, getters, actions, plugins, and TS support.

npx playbooks add skill partme-ai/full-stack-skills --skill pinia

Review the files below or copy the command above to add this skill to your agents.

Files (49)

SKILL.md

5.5 KB

---
name: pinia
description: Provides comprehensive guidance for Pinia state management including stores, state, getters, actions, plugins, and TypeScript support. Use when the user asks about Pinia, needs to manage application state, create stores, implement state persistence, or migrate from Vuex.
license: Complete terms in LICENSE.txt
---

## When to use this skill

Use this skill whenever the user wants to:
- Set up Pinia state management in Vue 3 applications
- Create stores with defineStore()
- Work with state, getters, and actions
- Use Pinia with Composition API
- Use Pinia with Options API
- Implement SSR (Server-Side Rendering) with Pinia
- Create and use Pinia plugins
- Access stores in components
- Share state between components
- Persist state with plugins
- Test Pinia stores
- Migrate from Vuex to Pinia

## How to use this skill

This skill is organized to match the Pinia official documentation structure (https://pinia.vuejs.org/introduction.html, https://pinia.vuejs.org/core-concepts/, https://pinia.vuejs.org/api/). When working with Pinia:

1. **Identify the topic** from the user's request:
   - Introduction/介绍 → `examples/introduction/`
   - Core Concepts/核心概念 → `examples/core-concepts/`
   - Cookbook/食谱 → `examples/cookbook/`
   - SSR/服务端渲染 → `examples/ssr/`
   - API Reference/API 参考 → `api/`

2. **Load the appropriate example file** from the `examples/` directory:

   **Introduction (介绍)** - `examples/introduction/`:
   - `examples/introduction/introduction.md`

   **Core Concepts (核心概念)** - `examples/core-concepts/`:
   - `examples/core-concepts/actions.md`
   - `examples/core-concepts/defining-a-store.md`
   - `examples/core-concepts/getters.md`
   - `examples/core-concepts/index.md`
   - `examples/core-concepts/outside-component-usage.md`
   - `examples/core-concepts/plugins.md`
   - `examples/core-concepts/state.md`

   **Cookbook (食谱)** - `examples/cookbook/`:
   - `examples/cookbook/composables.md`
   - `examples/cookbook/composing-stores.md`
   - `examples/cookbook/hot-module-replacement.md`
   - `examples/cookbook/index.md`
   - `examples/cookbook/migration-v1-v2.md`
   - `examples/cookbook/migration-v2-v3.md`
   - `examples/cookbook/migration-vuex.md`
   - `examples/cookbook/options-api.md`
   - `examples/cookbook/testing.md`
   - `examples/cookbook/vscode-snippets.md`

   **SSR (服务端渲染)** - `examples/ssr/`:
   - `examples/ssr/index.md`
   - `examples/ssr/nuxt.md`

3. **Reference API documentation** in the `api/` directory when needed:

   **Pinia Core API** - `api/pinia/`:
   - `api/pinia/enumerations/MutationType.md`
   - `api/pinia/functions/acceptHMRUpdate.md`
   - `api/pinia/functions/createPinia.md`
   - `api/pinia/functions/defineStore.md`
   - `api/pinia/functions/disposePinia.md`
   - `api/pinia/functions/getActivePinia.md`
   - `api/pinia/functions/mapActions.md`
   - `api/pinia/functions/mapState.md`
   - `api/pinia/functions/mapStores.md`
   - `api/pinia/functions/mapWritableState.md`
   - `api/pinia/functions/setMapStoreSuffix.md`
   - `api/pinia/index.md`
   - `api/pinia/interfaces/Store.md`
   - `api/pinia/interfaces/StoreActions.md`
   - `api/pinia/interfaces/StoreDefinition.md`
   - `api/pinia/interfaces/StoreGetters.md`
   - `api/pinia/interfaces/StoreProperties.md`
   - `api/pinia/interfaces/StoreState.md`

   **@pinia/nuxt** - `api/@pinia/nuxt/`:
   - `api/@pinia/nuxt/index.md`
   - `api/@pinia/nuxt/interfaces/ModuleOptions.md`
   - `api/@pinia/nuxt/variables/default.md`

   **@pinia/testing** - `api/@pinia/testing/`:
   - `api/@pinia/testing/functions/createTestingPinia.md`
   - `api/@pinia/testing/index.md`
   - `api/@pinia/testing/interfaces/TestingOptions.md`
   - `api/@pinia/testing/interfaces/TestingPinia.md`

4. **Follow the specific instructions** in that example file for syntax, structure, and best practices

   **Important Notes**:
   - All examples follow Pinia best practices
   - Examples include both JavaScript and TypeScript versions where applicable
   - Each example file includes parameters, returns, common errors, best practices, and scenarios
   - Always check the example file for best practices and common patterns

5. **Reference the official documentation** when needed:
   - Introduction: https://pinia.vuejs.org/introduction.html
   - Core Concepts: https://pinia.vuejs.org/core-concepts/
   - API Reference: https://pinia.vuejs.org/api/

## Best Practices

1. **Use defineStore()**: Always use defineStore() to create stores
2. **Store naming**: Use descriptive store IDs
3. **State structure**: Keep state flat and normalized when possible
4. **Getters**: Use getters for computed values derived from state
5. **Actions**: Use actions for async operations and mutations
6. **TypeScript**: Use TypeScript for type safety
7. **Store composition**: Split large stores into smaller, focused stores
8. **SSR**: Use proper SSR setup for server-side rendering
9. **Plugins**: Use plugins for cross-cutting concerns
10. **Testing**: Write tests for stores and actions

## Resources

- **Official Documentation**: https://pinia.vuejs.org/
- **Introduction**: https://pinia.vuejs.org/introduction.html
- **Core Concepts**: https://pinia.vuejs.org/core-concepts/
- **API Reference**: https://pinia.vuejs.org/api/
- **GitHub Repository**: https://github.com/vuejs/pinia

## Keywords

Pinia, state management, store, Vue 3, Composition API, Options API, defineStore, state, getters, actions, plugins, SSR, server-side rendering, TypeScript, Vuex migration, 状态管理, 存储, 组合式 API, 选项式 API, 插件, 服务端渲染, 类型支持

Overview

This skill provides comprehensive guidance for using Pinia state management in Vue 3 applications. It covers creating stores with defineStore, working with state/getters/actions, TypeScript support, plugins, SSR, testing, and migration from Vuex. It focuses on practical examples, patterns, and migration advice to help you manage application state reliably.

How this skill works

The skill inspects the user's request to identify the Pinia topic needed (core concepts, cookbook patterns, SSR, API usage, or migration). It then provides targeted guidance: store creation, state shape, getters, actions, plugins, TypeScript typing, persistence, and testing patterns. Recommendations follow Pinia best practices and include specific code patterns and migration steps from Vuex when appropriate.

When to use it

Setting up Pinia in a new Vue 3 project
Creating or refactoring stores with defineStore
Implementing state persistence, plugins, or SSR support
Migrating an existing Vuex store to Pinia
Writing tests for stores or using @pinia/testing
Adding TypeScript type safety to stores and actions

Best practices

Always create stores with defineStore() and use descriptive store IDs
Keep state flat and normalized; split large domains into focused stores
Use getters for derived/computed state and actions for async/mutation logic
Prefer TypeScript for store interfaces, action payloads, and return types
Use plugins for cross-cutting concerns like persistence, logging, and hydration
Configure SSR correctly: create a new Pinia instance per request and hydrate state on the client

Example use cases

Create an auth store with state, getters for currentUser, and login/logout actions
Persist cart state using a persistence plugin and selective hydration
Migrate a Vuex module to a Pinia store with typed state and actions
Test store actions and getters using @pinia/testing createTestingPinia
Compose multiple small stores for a complex domain (e.g., products, cart, user) to improve maintainability

FAQ

Can I use Pinia with both Composition API and Options API?

Yes. Pinia supports both the Composition API and Options API. defineStore works with either pattern and examples exist for each approach.

How do I migrate from Vuex to Pinia?

Migrate by mapping Vuex modules to individual Pinia stores, replace mutations with actions, move getters to Pinia getters, and introduce TypeScript types gradually. Use migration recipes and test each store after conversion.