Strapi Community Hub

https://github.com/strapi/community
Admin
Strapi Community Hub is a monorepo containing a Next.js web application, Strapi CMS, Meilisearch...
Tokens:12,536
Snippets:112
Trust Score:9.8
License:MIT
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install Dependencies with pnpm

Source: https://github.com/strapi/community/blob/develop/README.md

Installs all project dependencies using pnpm. Ensure Node.js and pnpm are installed.

```bash
pnpm install
```

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

### Start Development Servers

Source: https://github.com/strapi/community/blob/develop/README.md

Starts all applications within the monorepo in development mode. This command is useful for local development and testing.

```bash
pnpm dev
```

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

### n8n Automation Instance Setup

Source: https://context7.com/strapi/community/llms.txt

Instructions for setting up and running a containerized n8n instance for automating workflows.

```APIDOC
## n8n Automation Instance

### Description
Sets up and runs a containerized n8n instance for automating various community operations.

### Docker Compose Configuration (`apps/automation/docker-compose.yml`)
```yaml
services:
  n8n:
    image: n8nio/n8n:latest
    container_name: n8n
    environment:
      - GENERIC_TIMEZONE=Europe/Amsterdam
      - NODE_ENV=production
      - N8N_SECURE_COOKIE=false
    ports:
      - "5678:5678"
    volumes:
      - n8n_data:/home/node/.n8n
    restart: unless-stopped
```

### Starting the Instance

#### Command
```bash
pnpm --filter automation dev
```

#### Access
Access the n8n UI at `http://localhost:5678`.
```

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

### Start n8n Automation Instance

Source: https://context7.com/strapi/community/llms.txt

Command to start the n8n automation instance using pnpm. Access the n8n UI at http://localhost:5678 after starting.

```bash
# Start the n8n automation instance
pnpm --filter automation dev
# Access the n8n UI at http://localhost:5678
```

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

### Install @repo/strapi-client

Source: https://github.com/strapi/community/blob/develop/packages/strapi-client/README.md

Add the package to your workspace application's package.json to include it.

```json
{
  "dependencies": {
    "@repo/strapi-client": "workspace:*"
  }
}
```

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

### Setup Strapi Client

Source: https://github.com/strapi/community/blob/develop/packages/strapi-client/README.md

Instantiate a typed Strapi client with your Strapi instance's baseURL and an optional API token.

```APIDOC
## Setup Strapi Client

### Description
First, create a typed Strapi client instance:

### Code
```typescript
import { createTypedStrapiClient } from '@repo/strapi-client';

const strapi = createTypedStrapiClient({
  baseURL: 'http://localhost:1337',
  apiToken: 'your-api-token', // Optional
});
```
```

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

### Run Next.js Development Server

Source: https://github.com/strapi/community/blob/develop/apps/web/README.md

Use these commands to start the development server for your Next.js application. Open http://localhost:3000 in your browser to view the running application.

```bash
npm run dev
# or
yarn dev
# or
pnpm dev
# or
bun dev
```

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

### Start Strapi in Develop Mode

Source: https://github.com/strapi/community/blob/develop/apps/cms/README.md

Use this command to start your Strapi application with auto-reloading enabled for development. This is useful for making changes and seeing them reflected instantly.

```bash
npm run develop
```

```bash
yarn develop
```

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

### Start Strapi in Production Mode

Source: https://github.com/strapi/community/blob/develop/apps/cms/README.md

Use this command to start your Strapi application with auto-reloading disabled. This is typically used for production environments.

```bash
npm run start
```

```bash
yarn start
```

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

### CMS Environment Configuration

Source: https://context7.com/strapi/community/llms.txt

Example `.env` file for the Strapi CMS application, including settings for host, port, security keys, authentication, email, Meilisearch, and external integrations. Ensure to copy `.env.example` to `.env` and fill in actual values.

```bash
# apps/cms/.env
HOST=0.0.0.0
PORT=1337
APP_KEYS="key1,key2"
API_TOKEN_SALT=changeme
ADMIN_JWT_SECRET=changeme
TRANSFER_TOKEN_SALT=changeme
JWT_SECRET=changeme
ENCRYPTION_KEY=changeme

# Better Auth
BETTER_AUTH_SECRET=changeme
BETTER_AUTH_URL=http://localhost:1337
WEBSITE_URL=http://localhost:3000
SITE_NAME="Strapi Community"

# Email (Mailpit in dev)
MAILPIT_BASE_URL=http://localhost:8025
EMAIL_FROM=noreply@strapi.io

# Meilisearch
MEILISEARCH_HOST=http://localhost:7700
MEILISEARCH_API_KEY=your-meilisearch-key
MEILISEARCH_PACKAGES_INDEX_NAME=packages
MEILISEARCH_TEMPLATES_INDEX_NAME=templates
MEILISEARCH_SHOWCASES_INDEX_NAME=showcases
MEILISEARCH_RECIPES_INDEX_NAME=recipes
MEILISEARCH_INTEGRATIONS_INDEX_NAME=integrations
MEILISEARCH_MEMBERS_INDEX_NAME=members
MEILISEARCH_PARTNERS_INDEX_NAME=partners

# External integrations
GITHUB_ACCESS_TOKEN=ghp_…
AIRTABLE_API_KEY=key…
AIRTABLE_MARKET_BASE_ID=app…
SCREENSHOTONE_KEY=your-key
ENABLE_MIGRATION=false
```

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

### Fetch Raw CMS Endpoints with Custom Routes

Source: https://context7.com/strapi/community/llms.txt

Use `strapi.fetch` for custom routes, plugins, or any endpoint not covered by standard REST CRUD. Examples include URL routing, owner lookups, and user/organization content.

```typescript
import qs from 'qs';

// Webtools router: resolve a URL path to a Strapi document
const params = qs.stringify({ path: '/plugins/strapi-plugin-i18n', status: 'published', fields: ['documentId'] });
const page = await cmsClient
  .fetch(`/webtools/router?${params}`)
  .then((r) => r.json())
  .then((r) => r.data);
// page.contentType → 'api::package.package'
// page.documentId  → 'abc123'

// Owner selector plugin: get the owner of a content entry
const owner = await cmsClient
  .fetch(`/owner?contentType=api::package.package&documentId=abc123&populate=*`)
  .then((r) => r.json());
// owner.data[0] → { name: 'Alice', url_alias: [{ url_path: '/members/alice' }] }

// User related content
const related = await cmsClient
  .fetch(`/users/42/related-content?populate=*`)
  .then((r) => r.json());

// Organization members
const members = await cmsClient
  .fetch(`/organizations/99/members?populate=*`)
  .then((r) => r.json());
```

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

### Next.js Dynamic Router for Slug-based Page Resolution

Source: https://context7.com/strapi/community/llms.txt

This Next.js example demonstrates how to dynamically route URLs based on Strapi content using the webtools plugin. It includes static generation of routes based on URL aliases.

```typescript
// apps/web/src/app/[[...slug]]/page.tsx
import { findPage } from '@/features/cms/lib/webtools';
import { PackagePage } from '@/features/cms/pages/package';
import { UserPage }    from '@/features/cms/pages/user';
// … other page imports

export const revalidate = 60; // ISR: revalidate every 60 s

const Router = async ({ params }: { params: Promise<{ slug?: string[] }> }) => {
  const { slug } = await params;
  const path = `/${slug?.join('/') || ''}`;

  const page = await findPage({ path, status: 'published', fields: ['documentId'] });
  if (!page) return null;

  switch (page.contentType) {
    case 'api::package.package':              return <PackagePage documentId={page.documentId} />;
    case 'api::template.template':            return <TemplatePage documentId={page.documentId} />;
    case 'api::integration.integration':      return <IntegrationPage documentId={page.documentId} />;
    case 'plugin::better-auth.user':          return <UserPage documentId={page.documentId} />;
    case 'plugin::better-auth.organization':  return <OrganizationPage documentId={page.documentId} />;
    case 'api::home.home':                    return <HomePage />;
    default:                                  return `No template for ${page.contentType}`;
  }
};

// Build-time static params from all registered URL aliases
export async function generateStaticParams() {
  const pages = await findUrlAliases();
  return pages
    ?.filter((p) => p.url_path)
    .map((p) => ({ slug: p.url_path!.split('/').filter(Boolean) })) ?? [];
}

export default Router;
```

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

### Query Strapi Collection with Filters and Pagination

Source: https://context7.com/strapi/community/llms.txt

Example of querying a Strapi collection type ('api::package.package') using a type-safe client. It demonstrates advanced filtering, population of relations, sorting, pagination, and field selection. The `GetQueryParams` generic ensures type safety for query parameters.

```typescript
import { createTypedStrapiClient, type GetQueryParams } from '@repo/strapi-client';
import type { UID } from '@strapi/types';

const strapi = createTypedStrapiClient({ baseURL: 'http://localhost:1337/api', auth: 'my-token' });

const contentType = 'api::package.package' satisfies UID.ContentType;

const query = {
  filters: {
    name: { $contains: 'strapi' },
    monthly_downloads: { $gte: 500 },
  },
  populate: ['icon', 'categories', 'maintainers', 'version_info', 'url_alias', 'labels'],
  sort: ['monthly_downloads:desc', 'createdAt:desc'],
  pagination: { page: 1, pageSize: 20 },
  fields: ['name', 'description', 'stars', 'monthly_downloads'],
} satisfies GetQueryParams<typeof contentType>;

const result = await strapi.collection(contentType).find(query);
// result.data — typed array of Package documents
// result.meta.pagination — { page, pageSize, pageCount, total }
console.log(result.data.map((p) => `${p.name} — ⭐ ${p.stars}`));
```

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

### Owner Selector Plugin API Endpoints

Source: https://context7.com/strapi/community/llms.txt

Exposes REST endpoints to query users/organizations and assign polymorphic ownership to packages and templates. Use GET requests to list users or organizations, and POST to assign ownership.

```bash
# List all users (for the admin panel selector)
GET /api/owner-selector/users
# → { data: [{ documentId, name, email, profile: { avatar: { url } } }] }

# List all organizations
GET /api/owner-selector/organizations
# → { data: [{ documentId, name, slug, profile: { avatar: { url } } }] }

# Get the owner of a content entry
GET /api/owner?contentType=api::package.package&documentId=abc123&populate=*
# → { data: [{ documentId, name, url_alias: [{ url_path: '/members/alice' }] }] }

# Assign an owner
POST /api/owner
Content-Type: application/json
{
  "data": {
    "contentType":       "api::package.package",
    "documentId":        "abc123",
    "ownerDocumentId":   "user-doc-id",
    "ownerType":         "plugin::better-auth.user"
  }
}
# → { success: true }
```

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

### Retrieve Single Document by ID

Source: https://context7.com/strapi/community/llms.txt

Use `findOne` to get a single document from a collection type by its ID. Supports deep population of related fields.

```typescript
const contentType = 'api::package.package' satisfies UID.ContentType;

const pkg = await strapi.collection(contentType).findOne('abc123documentId', {
  populate: {
    icon: true,
    labels: true,
    categories: true,
    version_info: true,
    maintainers: { populate: { profile: true, url_alias: true } },
  },
});

// pkg.data is fully typed as a Package document
console.log(pkg.data.name, pkg.data.version_info?.version);
```

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

### Build All Applications

Source: https://github.com/strapi/community/blob/develop/README.md

Builds all applications in the monorepo. This command is typically used before deployment.

```bash
pnpm build
```

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

### Deploy Strapi Application

Source: https://github.com/strapi/community/blob/develop/apps/cms/README.md

This command initiates the deployment process for your Strapi application. Refer to the Strapi documentation for deployment options and configurations.

```bash
yarn strapi deploy
```

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

### Package Info Plugin - Fetching Package Details

Source: https://context7.com/strapi/community/llms.txt

Demonstrates how to use the `getPackageInfo` function to retrieve details about a package from various registries. It automatically resolves the registry from the provided URL and can optionally fetch README content and star counts from a GitHub repository.

```APIDOC
## getPackageInfo

### Description
Fetches download counts, star counts, README content, and version details from npm, PyPI, RubyGems, Packagist, and NuGet.

### Method
`getPackageInfo(packageUrl: string, githubUrl?: string): Promise<PackageInfo>

### Parameters
- **packageUrl** (string) - Required - The URL of the package on its registry.
- **githubUrl** (string) - Optional - The URL of the associated GitHub repository for fallback data like star counts and README.

### Returns
- **PackageInfo** - An object containing package details:
  - `registry` (string): The resolved registry.
  - `packageName` (string): The name of the package.
  - `version` (string): The current version of the package.
  - `publishedAt` (string): The publication date.
  - `installCommand` (string): The command to install the package.
  - `downloads` (object): Download statistics (`weekly`, `monthly`, `total`).
  - `readme` (string): The README content.
  - `stars` (number): The number of stars on the repository.

### Example
```typescript
import { getPackageInfo } from './get-package-info';

const info = await getPackageInfo(
  'https://www.npmjs.com/package/@strapi/plugin-i18n',
  'https://github.com/strapi/strapi'
);
// info → { registry, packageName, version, publishedAt, installCommand,
//           downloads: { weekly, monthly, total }, readme, stars }
```
```

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

### Build Strapi Admin Panel

Source: https://github.com/strapi/community/blob/develop/apps/cms/README.md

This command builds your Strapi admin panel. It is a necessary step before deploying your application to a production environment.

```bash
npm run build
```

```bash
yarn build
```

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

### Create Typed Strapi Client Instance

Source: https://github.com/strapi/community/blob/develop/packages/strapi-client/README.md

Initialize the typed Strapi client with your Strapi instance's base URL and an optional API token.

```typescript
import { createTypedStrapiClient } from '@repo/strapi-client';

const strapi = createTypedStrapiClient({
  baseURL: 'http://localhost:1337',
  apiToken: 'your-api-token', // Optional
});
```

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

### CMS Database Configuration

Source: https://context7.com/strapi/community/llms.txt

Details the database configuration options for Strapi, supporting SQLite, MySQL, and PostgreSQL, and how to select the client using environment variables.

```APIDOC
## Database Configuration

### Description
Configures the database connection for the Strapi CMS.

### Supported Clients
- SQLite (default for local development)
- MySQL
- PostgreSQL

### Selecting the Client
Set the `DATABASE_CLIENT` environment variable:
- `DATABASE_CLIENT=sqlite`
- `DATABASE_CLIENT=postgres`
- `DATABASE_CLIENT=mysql`

### Connection Parameters

#### PostgreSQL Example (`DATABASE_CLIENT=postgres`)
```typescript
// DATABASE_CLIENT=postgres
DATABASE_URL=postgresql://strapi:strapi@localhost:5432/strapi
DATABASE_SSL=false
DATABASE_POOL_MIN=2
DATABASE_POOL_MAX=10
```

#### MySQL Example (`DATABASE_CLIENT=mysql`)
```typescript
// DATABASE_CLIENT=mysql
DATABASE_HOST=localhost
DATABASE_PORT=3306
DATABASE_NAME=strapi
DATABASE_USERNAME=strapi
DATABASE_PASSWORD=strapi
```
```

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

### Monorepo Directory Structure

Source: https://github.com/strapi/community/blob/develop/README.md

Illustrates the directory structure of the monorepo, separating applications and shared packages.

```tree
apps/
── cms/               # Strapi 5 application
── web/               # Next.js 15 web application
── search/            # Meilisearch instance
── mail/              # Mailpit local email catcher
── automation/               # n8n instance
packages/
── strapi-client/ # A type-safe wrapper for `@strapi/client`
── typescript-config/ # Shared TypeScript configurations
```

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

### Package Info Plugin - Cron Tasks

Source: https://context7.com/strapi/community/llms.txt

Details the available cron tasks for synchronizing package statistics and version information in the background.

```APIDOC
## Cron Tasks

### Description
Cron tasks to keep registry data synchronized.

### syncStats()

#### Description
Synchronizes download and star statistics for all published packages and templates.

#### Returns
- `{ updated: number, failed: number }`: An object indicating the number of updated and failed synchronizations.

### syncVersionInfo()

#### Description
Synchronizes version information for all published packages and templates.

#### Returns
- `{ updated: number, failed: number }`: An object indicating the number of updated and failed synchronizations.
```

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

### Strapi Database Configuration

Source: https://context7.com/strapi/community/llms.txt

Configures the Strapi database client, supporting SQLite, MySQL, and PostgreSQL. The active client is chosen via the `DATABASE_CLIENT` environment variable, with specific connection details provided for each.

```typescript
// apps/cms/config/database.ts
// DATABASE_CLIENT=sqlite (default) — no extra env vars needed
// DATABASE_CLIENT=postgres
DATABASE_URL=postgresql://strapi:strapi@localhost:5432/strapi
DATABASE_SSL=false
DATABASE_POOL_MIN=2
DATABASE_POOL_MAX=10

// DATABASE_CLIENT=mysql
DATABASE_HOST=localhost
DATABASE_PORT=3306
DATABASE_NAME=strapi
DATABASE_USERNAME=strapi
DATABASE_PASSWORD=strapi
```

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

### Instantiate Type-Safe Strapi Client

Source: https://context7.com/strapi/community/llms.txt

Internal usage pattern for creating a type-safe Strapi client instance. This should be instantiated once per application, configured with the CMS base URL and an authentication token.

```typescript
// packages/strapi-client/lib/client.ts  (internal usage pattern)
import { createTypedStrapiClient } from '@repo/strapi-client';

// Instantiate once per application
export const cmsClient = createTypedStrapiClient({
  baseURL: `${process.env.NEXT_PUBLIC_CMS_URL}/api`,
  auth: process.env.CMS_BEARER_TOKEN, // Bearer token from Strapi admin
});
```

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

### Initialize Better Auth Client in Next.js

Source: https://context7.com/strapi/community/llms.txt

Create a Better Auth client instance for a Next.js application, enabling organization, 2FA, and email-OTP functionalities. This client is used within React components for authentication flows.

```typescript
// apps/web/src/features/auth/lib/client.ts
import { createAuthClient } from 'better-auth/react';
import { emailOTPClient, organizationClient, twoFactorClient } from 'better-auth/client/plugins';

export const authClient = createAuthClient({
  baseURL: `${process.env.NEXT_PUBLIC_CMS_URL}/api/better-auth`,
  plugins: [organizationClient(), twoFactorClient(), emailOTPClient()],
});

// Usage in a React Server or Client component:
// Sign up
// await authClient.signUp.email({ email: 'user@example.com', password: 'secret', name: 'Alice' });

// Sign in
// await authClient.signIn.email({ email: 'user@example.com', password: 'secret' });

// Get current session
// const session = await authClient.getSession();

// Create organization
// await authClient.organization.create({ name: 'Acme Corp', slug: 'acme-corp' });
```

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

### Fetch Package Information from Registries

Source: https://context7.com/strapi/community/llms.txt

Fetches download counts, star counts, README content, and version details from various package registries. Resolves the registry from the URL hostname automatically.

```typescript
// apps/cms/src/plugins/package-info/server/src/services/get-package-info.ts
import { getPackageInfo } from './get-package-info';

// Resolves the registry from the URL hostname automatically:
//   npmjs.com     → npm registry API
//   pypi.org      → PyPI JSON API
//   rubygems.org  → RubyGems API
//   packagist.org → Packagist API
//   nuget.org     → NuGet API
const info = await getPackageInfo(
  'https://www.npmjs.com/package/@strapi/plugin-i18n',
  'https://github.com/strapi/strapi', // optional: for star count + README fallback
);
// info → { registry, packageName, version, publishedAt, installCommand,
//           downloads: { weekly, monthly, total }, readme, stars }

// Bulk cron — sync download/star stats for all published packages + templates:
// syncStats()     → { updated: number, failed: number }
// syncVersionInfo() → { updated: number, failed: number }
```

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

### Run All Tests

Source: https://github.com/strapi/community/blob/develop/README.md

Executes all tests across all projects in the monorepo. Ensure tests are written for all new functionality.

```bash
pnpm test
```

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

### Development: Lint and Type Check

Source: https://github.com/strapi/community/blob/develop/packages/strapi-client/README.md

Run linting and type checking commands to maintain code quality within the development environment.

```bash
# Lint code
pnpm lint

# Type check
pnpm check-types
```

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

### n8n Automation Instance Docker Configuration

Source: https://context7.com/strapi/community/llms.txt

Sets up a containerized n8n instance for automating workflows. Configures timezone, environment, ports, volumes for data persistence, and restart policy.

```yaml
# apps/automation/docker-compose.yml
services:
  n8n:
    image: n8nio/n8n:latest
    container_name: n8n
    environment:
      - GENERIC_TIMEZONE=Europe/Amsterdam
      - NODE_ENV=production
      - N8N_SECURE_COOKIE=false
    ports:
      - "5678:5678"
    volumes:
      - n8n_data:/home/node/.n8n
    restart: unless-stopped
```

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

### Configure Better Auth in Strapi CMS

Source: https://context7.com/strapi/community/llms.txt

Set up Better Auth with various authentication plugins like organization, two-factor authentication (TOTP), and email OTP. Ensure to configure trusted origins, secrets, and email sending functions.

```typescript
// apps/cms/config/better-auth.ts
import { betterAuth } from 'better-auth';
import { emailOTP, organization, twoFactor } from 'better-auth/plugins';
import { strapiAdapter } from '@strapi-community/plugin-better-auth';
import { sendOtpEmail, sendResetPasswordEmail } from './better-auth-emails';

const auth = () => betterAuth({
  trustedOrigins: [process.env.WEBSITE_URL],
  secret:         process.env.BETTER_AUTH_SECRET,
  appName:        process.env.SITE_NAME ?? 'Strapi Community',
  basePath:       '/api/better-auth',
  plugins: [
    organization(),
    twoFactor({ otpOptions: { sendOTP: ({ user, otp }) => sendOtpEmail(user.email, otp) } }),
    emailOTP({
      overrideDefaultEmailVerification: true,
      sendVerificationOTP: ({ email, otp }) => sendOtpEmail(email, otp),
    }),
  ],
  emailVerification: { sendOnSignIn: true },
  emailAndPassword: {
    enabled: true,
    requireEmailVerification: true,
    sendResetPassword: ({ user, url }) => sendResetPasswordEmail(user.email, url),
  },
  database: strapiAdapter({ debugLogs: process.env.BETTER_AUTH_DEBUG === 'true' }),
  advanced: {
    database: { generateId: 'serial' },
    defaultCookieAttributes: {
      secure:   process.env.NODE_ENV === 'production',
      sameSite: process.env.NODE_ENV === 'production' ? 'none' : 'lax',
    },
  },
});

export default auth;
```

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

### Lint All Code

Source: https://github.com/strapi/community/blob/develop/README.md

Runs linting checks on all code within the monorepo to ensure consistent code style. Biome is used for linting and formatting.

```bash
pnpm lint
```

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

### Integrate Auth UI Provider in Next.js Layout

Source: https://context7.com/strapi/community/llms.txt

Wrap your Next.js application with `AuthUIProvider` to enable account pages, OTP flows, email verification, and organization dashboards. This requires configuring the auth client and navigation handlers.

```typescript
// apps/web/src/features/auth/components/providers.tsx
'use client';
import { AuthUIProvider } from 'better-auth-ui';
import Link from 'next/link';
import { useRouter } from 'next/navigation';
import { authClient } from '../lib/client';

export function AuthProviders({ children }: { children: React.ReactNode }) {
  const router = useRouter();
  return (
    <AuthUIProvider
      authClient={authClient}
      navigate={(href) => router.push(href)}
      replace={(href)  => router.replace(href)}
      Link={({ href, ...props }) => <Link href={href ?? '#'} {...props} />}
      basePath="/auth"
      baseURL={process.env.NEXT_PUBLIC_WEB_URL}
      account
      emailOTP
      emailVerification
      twoFactor={['totp']}
      organization={{ basePath: '/org', pathMode: 'slug', personalPath: '/account' }}
    >
      {children}
    </AuthUIProvider>
  );
}
// Drop-in usage in layout.tsx:
// <AuthProviders><StrapiNavbar />{children}<StrapiFooter /></AuthProviders>
```

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

### File Operations: Upload and Fetch

Source: https://github.com/strapi/community/blob/develop/packages/strapi-client/README.md

Perform file uploads and make custom requests to Strapi endpoints using the client's file and fetch methods.

```typescript
// Upload files
const file = await strapi.files.upload(formData);

// Access base URL and fetch
const response = await strapi.fetch('/custom-endpoint');
console.log(strapi.baseURL);
```

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

### Update Dependencies Interactively

Source: https://github.com/strapi/community/blob/develop/README.md

Allows for interactive updating of project dependencies. Use this command to manage and update packages within the monorepo.

```bash
pnpm update-dependencies
```

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

### Create New Collection Document

Source: https://github.com/strapi/community/blob/develop/packages/strapi-client/README.md

Create a new entry in a collection type by providing the necessary fields.

```typescript
// Create a new document
const newPackage = await strapi
  .collection('api::package.package')
  .create({
    name: 'My Package',
    description: 'A great package',
  });
```

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

### File Operations

Source: https://github.com/strapi/community/blob/develop/packages/strapi-client/README.md

Perform file uploads and make custom fetch requests using the client.

```APIDOC
## File Operations

### Description
The client also provides access to file operations:

### Upload files
```typescript
// Upload files
const file = await strapi.files.upload(formData);
```

### Custom Fetch
```typescript
// Access base URL and fetch
const response = await strapi.fetch('/custom-endpoint');
console.log(strapi.baseURL);
```
```

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

### Meilisearch Index Configuration

Source: https://context7.com/strapi/community/llms.txt

Configuration details for integrating Strapi with Meilisearch, specifying index settings, searchable attributes, and filterable attributes for different content types.

```APIDOC
## Meilisearch Configuration

### Description
Configuration for Strapi's Meilisearch integration, defining index settings for content types.

### `package` index configuration

#### Settings
- `indexName`: Name of the Meilisearch index for packages.
- `entriesQuery`: Query to fetch entries with specified population.
- `settings`:
  - `sortableAttributes`: Attributes that can be used for sorting (`monthly_downloads`, `stars`, `createdAt`).
  - `searchableAttributes`: Attributes that can be searched (`name`, `description`).
  - `filterableAttributes`: Attributes that can be used for filtering (`type`, `categories`, `labels.featured`, `labels.official`, `labels.paid`, `integrations`).

### `organization` index configuration

#### Settings
- `indexName`: Name of the Meilisearch index for organizations.
- `entriesQuery`: Query to fetch entries with specified population.
- `filterEntry`: Function to filter entries before indexing (e.g., only index partners).
- `transformEntry`: Function to transform entries before indexing (e.g., adding a `partner_level_rank`).
- `settings`:
  - `sortableAttributes`: Attributes that can be used for sorting (`createdAt`, `partner_level_rank`).
  - `filterableAttributes`: Attributes that can be used for filtering (`partner_level`, `profile.countries.name`, `profile.services.name`).

### Example Configuration (`apps/cms/config/plugins.ts`)
```typescript
meilisearch: {
  enabled: true,
  config: {
    host:   process.env.MEILISEARCH_HOST,
    apiKey: process.env.MEILISEARCH_API_KEY,

    package: {
      indexName: process.env.MEILISEARCH_PACKAGES_INDEX_NAME,
      entriesQuery: { populate: ['owner', 'maintainers', 'icon', 'labels', 'url_alias', 'categories', 'integrations'] },
      settings: {
        sortableAttributes:   ['monthly_downloads', 'stars', 'createdAt'],
        searchableAttributes: ['name', 'description'],
        filterableAttributes: ['type', 'categories', 'labels.featured', 'labels.official', 'labels.paid', 'integrations'],
      },
    },

    organization: {
      indexName: process.env.MEILISEARCH_PARTNERS_INDEX_NAME,
      entriesQuery: { populate: ['profile', 'profile.services', 'profile.countries', 'url_alias'] },
      filterEntry: ({ entry }) => entry.partner,
      transformEntry: ({ entry }) => {
        const rankMap = { Enterprise: 1, Business: 2, Community: 3 };
        return { ...entry, partner_level_rank: rankMap[entry.partner_level] * 1e13 + new Date(entry.createdAt).getTime() };
      },
      settings: {
        sortableAttributes:   ['createdAt', 'partner_level_rank'],
        filterableAttributes: ['partner_level', 'profile.countries.name', 'profile.services.name'],
      },
    },
  },
}
```
```

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

### Custom Fetch for Raw CMS Endpoints

Source: https://context7.com/strapi/community/llms.txt

Utilize `strapi.fetch` for custom routes, plugin endpoints, or any API interaction not covered by standard CRUD operations. Allows for flexible data retrieval.

```APIDOC
## Custom Fetch — Raw CMS Endpoints

For endpoints outside the standard REST CRUD (custom routes, plugins), use `strapi.fetch`.

```typescript
import qs from 'qs';

// Webtools router: resolve a URL path to a Strapi document
const params = qs.stringify({ path: '/plugins/strapi-plugin-i18n', status: 'published', fields: ['documentId'] });
const page = await cmsClient
  .fetch(`/webtools/router?${params}`)
  .then((r) => r.json())
  .then((r) => r.data);
// page.contentType → 'api::package.package'
// page.documentId  → 'abc123'

// Owner selector plugin: get the owner of a content entry
const owner = await cmsClient
  .fetch(`/owner?contentType=api::package.package&documentId=abc123&populate=*`)
  .then((r) => r.json());
// owner.data[0] → { name: 'Alice', url_alias: [{ url_path: '/members/alice' }] }

// User related content
const related = await cmsClient
  .fetch(`/users/42/related-content?populate=*`)
  .then((r) => r.json());

// Organization members
const members = await cmsClient
  .fetch(`/organizations/99/members?populate=*`)
  .then((r) => r.json());
```
```

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

### Resolve CMS Asset URLs with cmsImageUrl

Source: https://context7.com/strapi/community/llms.txt

Converts relative Strapi media paths to absolute URLs. Already absolute URLs are returned as-is. Relative paths are prefixed with NEXT_PUBLIC_CMS_URL. Useful for integrating with next/image.

```typescript
import { cmsImageUrl } from '@/features/cms/lib/image-url';

// Absolute URL → returned as-is
cmsImageUrl('https://cdn.example.com/logo.png');
// → 'https://cdn.example.com/logo.png'

// Relative path → prefixed with NEXT_PUBLIC_CMS_URL
cmsImageUrl('/uploads/icon_abc123.png');
// → 'http://localhost:1337/uploads/icon_abc123.png'

// Typical usage with next/image:
<Image src={cmsImageUrl(pkg.icon?.url ?? '/fallback.png')} width={64} height={64} alt={pkg.name} />
```

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

### Meilisearch Index Configuration for Strapi

Source: https://context7.com/strapi/community/llms.txt

Configures Meilisearch indexes for Strapi content types, defining index names, query parameters, and settings for sortable, searchable, and filterable attributes. Supports custom entry filtering and transformation.

```typescript
// apps/cms/config/plugins.ts  (excerpt)
meilisearch: {
  enabled: true,
  config: {
    host:   process.env.MEILISEARCH_HOST,
    apiKey: process.env.MEILISEARCH_API_KEY,

    package: {
      indexName: process.env.MEILISEARCH_PACKAGES_INDEX_NAME,
      entriesQuery: { populate: ['owner', 'maintainers', 'icon', 'labels', 'url_alias', 'categories', 'integrations'] },
      settings: {
        sortableAttributes:   ['monthly_downloads', 'stars', 'createdAt'],
        searchableAttributes: ['name', 'description'],
        filterableAttributes: ['type', 'categories', 'labels.featured', 'labels.official', 'labels.paid', 'integrations'],
      },
    },

    organization: {
      indexName: process.env.MEILISEARCH_PARTNERS_INDEX_NAME,
      entriesQuery: { populate: ['profile', 'profile.services', 'profile.countries', 'url_alias'] },
      filterEntry: ({ entry }) => entry.partner, // only index partners
      transformEntry: ({ entry }) => {
        const rankMap = { Enterprise: 1, Business: 2, Community: 3 };
        return { ...entry, partner_level_rank: rankMap[entry.partner_level] * 1e13 + new Date(entry.createdAt).getTime() };
      },
      settings: {
        sortableAttributes:   ['createdAt', 'partner_level_rank'],
        filterableAttributes: ['partner_level', 'profile.countries.name', 'profile.services.name'],
      },
    },
  },
}
```

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

### Type-Safe Query Parameters

Source: https://github.com/strapi/community/blob/develop/packages/strapi-client/README.md

Utilize type-safe filters, population, sorting, and pagination for precise data retrieval.

```typescript
const results = await strapi
  .collection('api::package.package')
  .find({
    // Type-safe filters
    filters: {
      name: { $contains: 'strapi' },
      downloads: { $gte: 1000 },
    },
    
    // Type-safe population
    populate: ['category', 'author.profile'],
    
    // Type-safe sorting
    sort: ['createdAt:desc', 'name:asc'],
    
    // Type-safe pagination
    pagination: {
      page: 1,
      pageSize: 25,
    },
    
    // Type-safe fields selection
    fields: ['name', 'description', 'downloads'],
  });
```

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

### Working with Collections

Source: https://github.com/strapi/community/blob/develop/packages/strapi-client/README.md

Perform CRUD operations and queries on collection types, which can have multiple entries.

```APIDOC
## Working with Collections

### Description
Collection types represent content types that can have multiple entries (e.g., articles, products, users).

### Find all documents
```typescript
// Find all documents
const packages = await strapi
  .collection('api::package.package')
  .find({
    filters: { published: true },
    populate: ['category', 'author'],
    sort: 'createdAt:desc',
    pagination: { page: 1, pageSize: 10 },
  });
```

### Find a single document by ID
```typescript
// Find a single document by ID
const package = await strapi
  .collection('api::package.package')
  .findOne('document-id-here', {
    populate: ['category'],
  });
```

### Create a new document
```typescript
// Create a new document
const newPackage = await strapi
  .collection('api::package.package')
  .create({
    name: 'My Package',
    description: 'A great package',
  });
```

### Update a document
```typescript
// Update a document
const updatedPackage = await strapi
  .collection('api::package.package')
  .update('document-id-here', {
    name: 'Updated Package Name',
  });
```

### Delete a document
```typescript
// Delete a document
await strapi
  .collection('api::package.package')
  .delete('document-id-here');
```
```

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

### Working with Single Types

Source: https://github.com/strapi/community/blob/develop/packages/strapi-client/README.md

Interact with single types, which represent content types with only one entry.

```APIDOC
## Working with Single Types

### Description
Single types represent content types that can only have one entry (e.g., homepage, settings).

### Find the single type document
```typescript
// Find the single type document
const home = await strapi
  .single('api::home.home')
  .find({
    populate: ['hero', 'sections'],
  });
```

### Update the single type document
```typescript
// Update the single type document
const updatedHome = await strapi
  .single('api::home.home')
  .update({
    title: 'Welcome to our site',
  });
```

### Delete the single type document
```typescript
// Delete the single type document
await strapi
  .single('api::home.home')
  .delete();
```
```

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

### Type-safe Query Parameters

Source: https://github.com/strapi/community/blob/develop/packages/strapi-client/README.md

Utilize type-safe options for filters, population, sorting, and pagination when querying collections.

```APIDOC
## Query Parameters

### Description
All query parameters are type-safe:

### Code
```typescript
const results = await strapi
  .collection('api::package.package')
  .find({
    // Type-safe filters
    filters: {
      name: { $contains: 'strapi' },
      downloads: { $gte: 1000 },
    },
    
    // Type-safe population
    populate: ['category', 'author.profile'],
    
    // Type-safe sorting
    sort: ['createdAt:desc', 'name:asc'],
    
    // Type-safe pagination
    pagination: {
      page: 1,
      pageSize: 25,
    },
    
    // Type-safe fields selection
    fields: ['name', 'description', 'downloads'],
  });
```
```

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

### Transactional Email Helpers for Strapi

Source: https://context7.com/strapi/community/llms.txt

Helper functions to send transactional emails from Strapi, including email verification, password reset links, and OTP codes. These utilize React Email templates and Strapi's email plugin.

```typescript
// apps/cms/config/better-auth-emails.ts  (selected helpers)
import { sendVerificationEmail, sendResetPasswordEmail, sendOtpEmail } from './better-auth-emails';

// Trigger email verification
// await sendVerificationEmail('user@example.com', 'https://example.com/verify?token=abc');

// Send password-reset link
// await sendResetPasswordEmail('user@example.com', 'https://example.com/reset?token=xyz');

// Send a 2FA / email-OTP code (default expiry: 3 minutes)
// await sendOtpEmail('user@example.com', '847291', 3);
```

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

### Find All Collection Documents

Source: https://github.com/strapi/community/blob/develop/packages/strapi-client/README.md

Retrieve all entries from a collection type, with options for filtering, population, sorting, and pagination.

```typescript
// Find all documents
const packages = await strapi
  .collection('api::package.package')
  .find({
    filters: { published: true },
    populate: ['category', 'author'],
    sort: 'createdAt:desc',
    pagination: { page: 1, pageSize: 10 },
  });
```

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

### Owner Selector Plugin - REST Endpoints

Source: https://context7.com/strapi/community/llms.txt

Provides REST API endpoints for managing content ownership, including listing users and organizations, retrieving ownership details, and assigning owners to content entries.

```APIDOC
## Owner Selector Plugin REST API

### List all users

#### Endpoint
`GET /api/owner-selector/users`

#### Description
Retrieves a list of all users, typically for populating a selector in the admin panel.

#### Response (200)
- `data` (array): An array of user objects, each containing `documentId`, `name`, `email`, and `profile.avatar.url`.

### List all organizations

#### Endpoint
`GET /api/owner-selector/organizations`

#### Description
Retrieves a list of all organizations.

#### Response (200)
- `data` (array): An array of organization objects, each containing `documentId`, `name`, `slug`, and `profile.avatar.url`.

### Get the owner of a content entry

#### Endpoint
`GET /api/owner`

#### Query Parameters
- **contentType** (string) - Required - The content type of the entry (e.g., `api::package.package`).
- **documentId** (string) - Required - The ID of the content entry.
- **populate** (string) - Optional - Specifies which relations to populate (e.g., `*`).

#### Response (200)
- `data` (array): An array containing the owner object, which includes `documentId`, `name`, and `url_alias`.

### Assign an owner

#### Endpoint
`POST /api/owner`

#### Request Body
- `data` (object) - Required:
  - `contentType` (string) - Required - The content type of the entry.
  - `documentId` (string) - Required - The ID of the content entry.
  - `ownerDocumentId` (string) - Required - The ID of the owner document.
  - `ownerType` (string) - Required - The type of the owner (e.g., `plugin::better-auth.user`).

#### Response (200)
- `success` (boolean): Indicates if the assignment was successful.
```

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

### Configure TypeScript Type Inference

Source: https://github.com/strapi/community/blob/develop/packages/strapi-client/README.md

Include Strapi's generated types in your tsconfig.json to enable type inference.

```json
{
  "include": {
    "../../apps/cms/types/generated/*.d.ts"
  }
}
```

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

### Perform CRUD Operations on Collection Types

Source: https://context7.com/strapi/community/llms.txt

Strapi's collection API supports full Create, Read (implicitly via findOne/find), Update, and Delete operations.

```typescript
const contentType = 'api::package.package' satisfies UID.ContentType;

// Create
const created = await strapi.collection(contentType).create({
  name: 'strapi-plugin-example',
  description: 'An example Strapi plugin',
  type: 'plugin',
  slug: 'strapi-plugin-example',
});

// Update
await strapi.collection(contentType).update(created.data.documentId, {
  stars: 42,
  monthly_downloads: 1500,
});

// Delete
await strapi.collection(contentType).delete(created.data.documentId);
```

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

### Collection Type CRUD Operations

Source: https://context7.com/strapi/community/llms.txt

Perform Create, Update, and Delete operations on collection types. This includes creating new entries, modifying existing ones, and removing them.

```APIDOC
## Collection Type — `create`, `update`, `delete`

Full CRUD operations on collection content types.

```typescript
const contentType = 'api::package.package' satisfies UID.ContentType;

// Create
const created = await strapi.collection(contentType).create({
  name: 'strapi-plugin-example',
  description: 'An example Strapi plugin',
  type: 'plugin',
  slug: 'strapi-plugin-example',
});

// Update
await strapi.collection(contentType).update(created.data.documentId, {
  stars: 42,
  monthly_downloads: 1500,
});

// Delete
await strapi.collection(contentType).delete(created.data.documentId);
```
```

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

### Find and Update Single Type

Source: https://context7.com/strapi/community/llms.txt

Access single types using `.single()` and retrieve their document with `find`, supporting complex query parameters for population. Updates can be done with partial data.

```typescript
import type { GetQueryParams } from '@repo/strapi-client';
import type { UID } from '@strapi/types';

const contentType = 'api::home.home' satisfies UID.ContentType;

const query = {
  populate: {
    cta_buttons: true,
    sections: {
      populate: '*',
      on: {
        'sections.cta':  { populate: { cta: { populate: { image: true, button: true } } } },
        'sections.highlights': true,
      },
    },
  },
} satisfies GetQueryParams<typeof contentType>;

const home = await strapi.single(contentType).find(query);
// home.data.sections — polymorphic section list

await strapi.single(contentType).update({ title: 'Welcome to Strapi Community' });
```

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

### Check TypeScript Types

Source: https://github.com/strapi/community/blob/develop/README.md

Performs type checking across the entire workspace using TypeScript. This helps catch type-related errors early.

```bash
pnpm check-types
```

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

### Find Single Type Document

Source: https://github.com/strapi/community/blob/develop/packages/strapi-client/README.md

Retrieve the single entry for a single type content type, with options for population.

```typescript
// Find the single type document
const home = await strapi
  .single('api::home.home')
  .find({
    populate: ['hero', 'sections'],
  });
```

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

### Single Type Find and Update

Source: https://context7.com/strapi/community/llms.txt

Access and modify the single document associated with a single type content type. Useful for global settings or landing pages.

```APIDOC
## Single Type — `find` and `update`

Single types have exactly one document (e.g., the home page). Access them via `.single()`.

```typescript
import type { GetQueryParams } from '@repo/strapi-client';
import type { UID } from '@strapi/types';

const contentType = 'api::home.home' satisfies UID.ContentType;

const query = {
  populate: {
    cta_buttons: true,
    sections: {
      populate: '*',
      on: {
        'sections.cta':  { populate: { cta: { populate: { image: true, button: true } } } },
        'sections.highlights': true,
      },
    },
  },
} satisfies GetQueryParams<typeof contentType>;

const home = await strapi.single(contentType).find(query);
// home.data.sections — polymorphic section list

await strapi.single(contentType).update({ title: 'Welcome to Strapi Community' });
```
```

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

### Update Single Type Document

Source: https://github.com/strapi/community/blob/develop/packages/strapi-client/README.md

Modify the single entry for a single type content type by providing the fields to update.

```typescript
// Update the single type document
const updatedHome = await strapi
  .single('api::home.home')
  .update({
    title: 'Welcome to our site',
  });
```

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

### Delete Single Type Document

Source: https://github.com/strapi/community/blob/develop/packages/strapi-client/README.md

Remove the single entry for a single type content type.

```typescript
// Delete the single type document
await strapi
  .single('api::home.home')
  .delete();
```

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

### Find Single Collection Document by ID

Source: https://github.com/strapi/community/blob/develop/packages/strapi-client/README.md

Retrieve a specific entry from a collection type using its unique ID, with options for population.

```typescript
// Find a single document by ID
const package = await strapi
  .collection('api::package.package')
  .findOne('document-id-here', {
    populate: ['category'],
  });
```

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

### Update Collection Document

Source: https://github.com/strapi/community/blob/develop/packages/strapi-client/README.md

Modify an existing entry in a collection type by providing its ID and the fields to update.

```typescript
// Update a document
const updatedPackage = await strapi
  .collection('api::package.package')
  .update('document-id-here', {
    name: 'Updated Package Name',
  });
```

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

### Delete Collection Document

Source: https://github.com/strapi/community/blob/develop/packages/strapi-client/README.md

Remove an entry from a collection type by providing its ID.

```typescript
// Delete a document
await strapi
  .collection('api::package.package')
  .delete('document-id-here');
```
Tokens:
Raw