Chop Logic CMS

Content Management System for Chop Logic Portal

A modern, headless CMS built with Strapi and TypeScript, designed to manage content for the Chop Logic Portal. This project provides a flexible and scalable backend solution for content management with built-in API functionality, user permissions management, and cloud deployment capabilities.

✨ Features

Headless CMS: Strapi provides a flexible, API-first content management system
User Permissions: Built-in user authentication and role-based access control via the Users Permissions plugin
Cloud Support: Integrated Strapi Cloud plugin for easy deployment
TypeScript: Full TypeScript support for type-safe development
Testing: Jest testing framework with coverage reporting
Code Quality: Biome for fast code formatting and linting
Git Hooks: Husky and lint-staged for automated pre-commit checks
Conventional Commits: CommitLint ensures consistent commit messages

🔧 Prerequisites

Node.js: >= 20.0.0, <= 24.x.x
npm: >= 6.0.0
SQLite (better-sqlite3): Default database driver

📁 Project Structure

chop-logic-cms/
├── src/
│   ├── index.ts                  # Main entry point
│   ├── api/                      # API routes and controllers
│   │   └── article/              # Article content type
│   │       ├── controllers/      # Request handlers
│   │       ├── routes/          # Route definitions
│   │       ├── services/        # Business logic
│   │       └── content-types/   # Content type schemas
│   ├── admin/                    # Admin panel customizations
│   ├── extensions/               # Plugin extensions
│   ├── utils/                    # Utility functions
│   └── __tests__/               # Test files
├── types/
│   └── generated/               # Auto-generated TypeScript types
├── config/                       # Strapi configuration files
│   ├── api.ts                   # API configuration
│   ├── database.ts              # Database configuration
│   ├── middlewares.ts           # Middleware setup
│   ├── plugins.ts               # Plugin configuration
│   ├── admin.ts                 # Admin panel configuration
│   └── server.ts                # Server configuration
├── database/
│   └── migrations/              # Database migrations
├── public/
│   └── uploads/                 # Uploaded files
├── coverage/                     # Test coverage reports
├── package.json                  # Project dependencies and scripts
├── tsconfig.json                # TypeScript configuration
├── jest.config.js               # Jest testing configuration
├── biome.json                    # Biome formatter/linter configuration
└── README.md                     # Project documentation

🚀 Getting Started

1. Install Dependencies

npm install

2. Configure Environment Variables

Create a .env file in the root directory with necessary environment variables:

# Example .env configuration
NODE_ENV=development

3. Start Development Server

npm run dev

The Strapi admin panel will be available at http://localhost:1337/admin.

4. Access the API

REST API: http://localhost:1337/api/

💻 Development Workflow

Local Development

Start the development server:
```
npm run dev
```
This launches Strapi in development mode with hot-reload enabled.
Create or modify content types:
- Use the Strapi admin panel at http://localhost:1337/admin
- Navigate to Content-type Builder to create/modify schemas
Write custom API logic:
- Create controllers in src/api/[content-type]/controllers/
- Add services in src/api/[content-type]/services/
- Define routes in src/api/[content-type]/routes/

Run code quality checks:

npm run lint
npm run format
npm run typecheck

Run tests:

npm run test           # Watch mode
npm run test:coverage  # With coverage report

Code Quality Standards

All code must adhere to:

Biome formatting standards
TypeScript strict mode
ESLint/Biome rules with no errors
Jest test coverage

Git hooks (via Husky) automatically enforce these on commit.

📜 Available Scripts

Script	Command	Description
Development
`dev`	`strapi develop`	Start Strapi in development mode with file watching
`start`	`strapi start`	Start Strapi in production mode
`console`	`strapi console`	Open interactive Strapi console
Building & Deployment
`build`	`strapi build`	Build the admin panel and backend for production
`deploy`	`strapi deploy`	Deploy to Strapi Cloud
`upgrade`	`npx @strapi/upgrade latest`	Upgrade Strapi to the latest version
`upgrade:dry`	`npx @strapi/upgrade latest --dry`	Preview upgrade changes without applying
Code Quality
`lint`	`biome check`	Check code for linting issues
`lint:errors`	`biome check --diagnostic-level error --max-diagnostics 100`	Check and display only errors (max 100)
`lint:warnings`	`biome check --diagnostic-level warn --max-diagnostics 100`	Check and display warnings (max 100)
`lint:fix`	`biome check --write`	Auto-fix linting issues
`format`	`biome format --write`	Auto-format code files
`typecheck`	`tsc --pretty --noEmit`	Type-check TypeScript without emitting files
Testing
`test`	`jest --watch`	Run tests in watch mode
`test:ci`	`jest --passWithNoTests --runInBand`	Run tests in CI environment (sequential)
`test:coverage`	`jest --coverage`	Run tests with coverage report
Utilities
`strapi`	`strapi`	Direct Strapi CLI access
`prepare`	`husky`	Setup Husky git hooks

🧪 Testing

The project uses Jest for unit and integration testing.

Run Tests

Watch mode (for development):
```
npm run test
```
Coverage report:
```
npm run test:coverage
```
Reports are generated in the coverage/ directory.
CI mode (for automated testing):
```
npm run test:ci
```

Test Files Location

Test files are located in src/__tests__/ and should follow the naming convention: *.test.ts or *.spec.ts.

🔄 Strapi CMS Development Flow

Understanding the Strapi Architecture

Strapi follows a layered architecture pattern:

Routes → Controllers → Services → Models

Routes: Define API endpoints (e.g., GET /api/articles)
Controllers: Handle HTTP requests and responses
Services: Contain business logic and database operations
Models: Define content structure and relationships

Step-by-Step Development Process

1. Define Content Types

Use the Strapi admin panel's Content-type Builder:

Navigate to http://localhost:1337/admin/content-manager
Click "Create new content type"
Define fields (text, rich text, relations, etc.)
Configure permissions in the Settings tab

Auto-generated files (after creating a content type):

src/api/[content-type]/models/ - Database models
src/api/[content-type]/services/ - Default service
src/api/[content-type]/controllers/ - Default controller
src/api/[content-type]/routes/ - Default route definitions

2. Create Custom Controllers

Controllers handle business logic and HTTP responses:

// src/api/article/controllers/article.ts
import { factories } from '@strapi/strapi';

export default factories.createCoreController('api::article.article', {
  async find(ctx) {
    // Custom find logic
    return await super.find(ctx);
  },

  async create(ctx) {
    // Custom create logic
    return await super.create(ctx);
  }
});

3. Implement Services

Services encapsulate reusable business logic:

// src/api/article/services/article.ts
import { factories } from '@strapi/strapi';

export default factories.createCoreService('api::article.article', {
  async getPublishedArticles() {
    return await strapi.entityService.findMany('api::article.article', {
      filters: { publishedAt: { $ne: null } }
    });
  }
});

4. Define Routes

Routes map HTTP requests to controllers:

// src/api/article/routes/article.ts
export default {
  routes: [
    {
      method: 'GET',
      path: '/articles/published',
      handler: 'article.find',
      config: { auth: false, policies: [] }
    }
  ]
};

5. Set Up Permissions

Configure role-based access control:

Admin panel → Settings → Roles
Define permissions for each content type
Map routes to specific roles (Public, Authenticated, Admin, etc.)

6. Test the API

Access the API at http://localhost:1337/api/:

# Get articles
curl http://localhost:1337/api/articles

# Create article
curl -X POST http://localhost:1337/api/articles \
  -H "Content-Type: application/json" \
  -d '{"data": {"title": "My Article"}}'

Database Migrations

Strapi manages the database schema automatically based on content types. For custom migrations:

# Generate migration
npm run strapi migrate:create <migration-name>

# Run migrations
npm run strapi migrate:up

Plugins Configuration

Plugins are configured in config/plugins.ts:

@strapi/plugin-users-permissions: User authentication and roles
@strapi/plugin-cloud: Cloud deployment integration
Custom plugins: Can be placed in src/plugins/ or installed from npm

Environment-Specific Configuration

Configuration files in config/ support environment variables:

// config/database.ts - automatically loads based on NODE_ENV
export default ({ env }) => ({
  defaultConnection: 'default',
  connections: {
    default: {
      connector: 'bookshelf',
      settings: {
        client: 'sqlite',
        filename: env('DATABASE_FILENAME', '.tmp/data.db'),
      }
    }
  }
});

🛠️ Code Quality

This project enforces code quality standards using:

Biome

Fast formatter and linter for JavaScript/TypeScript:

# Format code
npm run format

# Check for issues
npm run lint

# Auto-fix issues
npm run lint:fix

Configuration: biome.json

TypeScript

Static type checking:

npm run typecheck

Configuration: tsconfig.json

Husky & Lint-Staged

Automatic pre-commit checks:

Type-checks all .ts files
Formats and lints .js, .ts, .json, etc.
Prevents commits with errors

📦 Dependencies

Core Dependencies

@strapi/strapi - Headless CMS framework
@strapi/plugin-users-permissions - User authentication
@strapi/plugin-cloud - Cloud deployment
better-sqlite3 - SQLite database driver
React (^18.0.0) - Admin panel UI library
styled-components (^6.0.0) - CSS-in-JS styling

Development Dependencies

TypeScript (^5) - Static type checking
Jest - Testing framework
Biome - Code formatter and linter
Husky - Git hooks
CommitLint - Commit message validation

🚢 Deployment

Build for Production

npm run build

This creates an optimized production build.

Deploy to Strapi Cloud

npm run deploy

Requires authentication with Strapi Cloud account.

Docker Deployment

Create a Dockerfile in the root directory for containerized deployment:

FROM node:20-alpine

WORKDIR /app

COPY package*.json ./
RUN npm ci --only=production

COPY . .
RUN npm run build

EXPOSE 1337

CMD ["npm", "start"]

🤝 Contributing

Commit Guidelines

This project uses Conventional Commits enforced by CommitLint:

<type>(<scope>): <subject>
<BLANK LINE>
<body>
<BLANK LINE>
<footer>

Valid types: feat, fix, docs, style, refactor, test, chore

Example:

feat(article): add article search functionality

Implement full-text search for articles
- Add search endpoint
- Create search service

Closes #123

Pull Request Process

Create a feature branch: git checkout -b feat/my-feature
Make changes and commit with conventional messages
Push to GitHub
Create a pull request with description
Ensure all checks pass (tests, linting, types)

📝 License

This project is licensed under the MIT License. See the LICENSE file for details.

👨‍💻 Author

Dmitrii Suroviagin

🔗 Resources

Last Updated: January 28, 2026

Name		Name	Last commit message	Last commit date
Latest commit History 32 Commits
.husky		.husky
config		config
database/migrations		database/migrations
public		public
src		src
types/generated		types/generated
.env.example		.env.example
.gitignore		.gitignore
LICENSE		LICENSE
README.md		README.md
biome.json		biome.json
favicon.ico		favicon.ico
jest.config.js		jest.config.js
package-lock.json		package-lock.json
package.json		package.json
tsconfig.json		tsconfig.json

Folders and files

Latest commit

History

Repository files navigation