Дата: 2025-11-10
Версия: 1.0.0
Цель: Изучить топовые фреймворки, взять лучшие архитектурные решения
Архитектурный подход:
Hasura (metadata-driven)
+ Amplication (code generation)
+ Strapi (plugin system)
+ Prisma (schema-first)
+ AI (Claude для интеллекта)
= Наша архитектура
Hasura - GraphQL движок, который генерирует API из PostgreSQL схемы мгновенно.
Компания: Hasura (YC W18)
GitHub: 31K+ ⭐
Используют: GitLab, Netflix, Roblox
┌─────────────────────────────────────────────────────────┐
│ HASURA ENGINE │
│ │
│ ┌───────────────────────────────────────────────────┐ │
│ │ Metadata (JSON/YAML) │ │
│ │ - Tables tracking │ │
│ │ - Relationships │ │
│ │ - Permissions │ │
│ │ - Custom GraphQL schema │ │
│ └──────────────────┬────────────────────────────────┘ │
│ ↓ │
│ ┌───────────────────────────────────────────────────┐ │
│ │ GraphQL Schema Generator │ │
│ │ Introspects DB → Generates GraphQL Types │ │
│ └──────────────────┬────────────────────────────────┘ │
│ ↓ │
│ ┌───────────────────────────────────────────────────┐ │
│ │ Query Compiler │ │
│ │ GraphQL Query → Optimized SQL │ │
│ └──────────────────┬────────────────────────────────┘ │
│ ↓ │
│ ┌───────────────────────────────────────────────────┐ │
│ │ Permission Engine │ │
│ │ Row-level security, Role-based access │ │
│ └──────────────────┬────────────────────────────────┘ │
└──────────────────────┼──────────────────────────────────┘
↓
┌──────────────────────────────────────────────────────────┐
│ PostgreSQL │
│ ┌────────────┐ ┌────────────┐ ┌────────────┐ │
│ │ users │ │ posts │ │ comments │ │
│ └────────────┘ └────────────┘ └────────────┘ │
└──────────────────────────────────────────────────────────┘
Hasura не генерирует код! Всё работает через метаданные:
# metadata/tables.yaml
- table:
schema: public
name: users
select_permissions:
- role: user
permission:
columns: [id, email, name]
filter:
id: {_eq: X-Hasura-User-Id}
relationships:
- name: posts
using:
foreign_key_constraint_on:
column: author_id
table:
schema: public
name: posts
После этого:
- ✅ GraphQL API сразу работает
- ✅ Subscriptions (real-time)
- ✅ Permissions автоматически
- ✅ Joins оптимизированы
-- 1. Создаёте таблицу в PostgreSQL
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email TEXT UNIQUE NOT NULL,
name TEXT
);
-- 2. Hasura автоматически видит таблицу
-- 3. GraphQL API мгновенно доступен:
# GraphQL Query (автосгенерирован!)
query {
users {
id
email
name
}
}
# Mutation (автосгенерирован!)
mutation {
insert_users_one(object: {
email: "test@example.com"
name: "John"
}) {
id
email
}
}
# Subscription (real-time!)
subscription {
users(where: {is_active: {_eq: true}}) {
id
email
name
}
}
1. Metadata-Driven Architecture
Вместо генерации кода → хранить метаданные и интерпретировать их.
Плюсы:
- ✅ Мгновенные изменения (нет перекомпиляции)
- ✅ Легко версионировать (JSON/YAML)
- ✅ Горячая перезагрузка
Для ЦИФРА:
# metadata/entities/User.yaml
entity: User
table: users
fields:
- name: id
type: integer
- name: email
type: string
api:
auto_generate: true # ← Мгновенно работает!
2. Permission Engine
Row-level security через метаданные:
permissions:
role: user
select:
filter: {user_id: {_eq: X-User-Id}} # ← Видит только свои записи
3. Relationship Tracking
Автоматические joins:
relationships:
- name: posts
type: one_to_many
foreign_key: author_id
GraphQL автоматически позволяет:
query {
users {
id
posts { # ← JOIN автоматически!
title
}
}
}
Supabase - Open Source Firebase альтернатива. PostgreSQL + мгновенный API.
Компания: Supabase (YC S20)
GitHub: 70K+ ⭐
Используют: GitHub Copilot, Mozilla, Epsilon3
┌─────────────────────────────────────────────────────────┐
│ SUPABASE STACK │
├─────────────────────────────────────────────────────────┤
│ ┌───────────────────────────────────────────────────┐ │
│ │ Studio (Dashboard) │ │
│ │ - Table Editor (GUI для создания таблиц) │ │
│ │ - SQL Editor │ │
│ │ - API Docs (автогенерируются) │ │
│ └───────────────────────────────────────────────────┘ │
├─────────────────────────────────────────────────────────┤
│ ┌────────────────┐ ┌────────────────┐ │
│ │ PostgREST │ │ Realtime │ │
│ │ (REST API) │ │ (WebSocket) │ │
│ └────────────────┘ └────────────────┘ │
├─────────────────────────────────────────────────────────┤
│ ┌────────────────┐ ┌────────────────┐ │
│ │ GoTrue │ │ Storage │ │
│ │ (Auth) │ │ (Files) │ │
│ └────────────────┘ └────────────────┘ │
├─────────────────────────────────────────────────────────┤
│ ┌───────────────────────────────────────────────────┐ │
│ │ PostgreSQL │ │
│ │ - Row Level Security (RLS) │ │
│ │ - Triggers, Functions │ │
│ └───────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘
1. PostgREST - REST API из PostgreSQL
-- Создали таблицу
CREATE TABLE products (
id SERIAL PRIMARY KEY,
name TEXT,
price INTEGER
);
-- REST API сразу работает:
GET /products -- Список
POST /products -- Создать
GET /products?id=eq.1 -- Получить
PATCH /products?id=eq.1 -- Обновить
DELETE /products?id=eq.1 -- Удалить
2. Realtime - PostgreSQL Changes → WebSocket
// Frontend подписывается на изменения
const subscription = supabase
.from('products')
.on('INSERT', payload => {
console.log('Новый продукт!', payload.new)
})
.subscribe()
3. Row Level Security (RLS)
-- Политика доступа на уровне БД
CREATE POLICY "Users see only own data"
ON products
FOR SELECT
USING (auth.uid() = user_id);
4. Storage - файловое хранилище
// Загрузка файлов
await supabase.storage
.from('avatars')
.upload('public/avatar1.png', file)
1. Схема БД = API
Не нужно писать API вручную. Создал таблицу → API готов.
Для ЦИФРА:
# После создания SQLAlchemy модели
class Product(Base):
id = Column(Integer, primary_key=True)
name = Column(String)
# API автоматически создаётся:
# GET /api/products
# POST /api/products
# ...
2. Realtime из коробки
PostgreSQL LISTEN/NOTIFY → WebSocket:
# При INSERT в БД
# → автоматически отправляется в WebSocket
# → все подключенные клиенты получают обновление
3. Dashboard для управления
GUI для создания таблиц, просмотра данных, SQL редактор.
Для ЦИФРА:
/admin
/tables - CRUD таблиц
/api-docs - Автодокументация
/sql-editor - Выполнение запросов
4. Row Level Security
Безопасность на уровне БД, не приложения:
-- Политики в PostgreSQL
CREATE POLICY ...
Vs приложение:
# Проверка в коде (менее надёжно)
if user.id != resource.owner_id:
raise Forbidden()
Strapi - Headless CMS с визуальным конструктором контента.
GitHub: 62K+ ⭐
Используют: NASA, IBM, Walmart
┌─────────────────────────────────────────────────────────┐
│ STRAPI ADMIN PANEL │
│ ┌───────────────────────────────────────────────────┐ │
│ │ Content-Type Builder (GUI) │ │
│ │ - Создаёшь поля через drag&drop │ │
│ │ - Отношения визуально │ │
│ │ - Валидация через UI │ │
│ └──────────────────┬────────────────────────────────┘ │
│ ↓ │
│ ┌───────────────────────────────────────────────────┐ │
│ │ Content Manager │ │
│ │ - CRUD записей через GUI │ │
│ │ - Rich Text Editor │ │
│ │ - Media Library │ │
│ └───────────────────────────────────────────────────┘ │
└──────────────────────┬──────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────┐
│ STRAPI CORE (Node.js) │
│ ┌───────────────────────────────────────────────────┐ │
│ │ Schema Definition (JSON) │ │
│ │ { │ │
│ │ "kind": "collectionType", │ │
│ │ "attributes": { │ │
│ │ "title": { "type": "string" }, │ │
│ │ "content": { "type": "richtext" } │ │
│ │ } │ │
│ │ } │ │
│ └──────────────────┬────────────────────────────────┘ │
│ ↓ │
│ ┌───────────────────────────────────────────────────┐ │
│ │ API Generator (REST + GraphQL) │ │
│ │ - Автогенерация endpoints │ │
│ │ - CRUD операции │ │
│ │ - Фильтры, пагинация │ │
│ └──────────────────┬────────────────────────────────┘ │
│ ↓ │
│ ┌───────────────────────────────────────────────────┐ │
│ │ Plugin System │ │
│ │ - Users & Permissions (встроенный) │ │
│ │ - Upload (файлы) │ │
│ │ - i18n (мультиязычность) │ │
│ │ - Custom plugins │ │
│ └───────────────────────────────────────────────────┘ │
└──────────────────────┬──────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────┐
│ Database (PostgreSQL/MySQL/SQLite) │
└─────────────────────────────────────────────────────────┘
Визуальное создание моделей:
GUI:
┌─────────────────────────────────────┐
│ Create New Collection Type │
├─────────────────────────────────────┤
│ Name: Article │
│ │
│ Fields: │
│ + Title [Text] ✓ Required │
│ + Content [Rich Text] │
│ + Author [Relation → User] │
│ + Published [Boolean] │
│ + Cover [Media] │
│ │
│ [Save] │
└─────────────────────────────────────┘
↓ После сохранения
Автоматически создаётся:
✅ Таблица в БД
✅ REST API endpoints
✅ GraphQL schema
✅ Admin интерфейс для управления
Сгенерированный API:
GET /api/articles # Список
POST /api/articles # Создать
GET /api/articles/1 # Получить
PUT /api/articles/1 # Обновить
DELETE /api/articles/1 # Удалить
# С фильтрами
GET /api/articles?filters[published][$eq]=true
GET /api/articles?populate=author,cover
GET /api/articles?sort=createdAt:desc
1. GUI для создания моделей
Не писать YAML/код - создавать через UI.
Для ЦИФРА:
/admin/model-builder
→ Drag & drop поля
→ Визуальные отношения
→ Сразу видишь результат
2. Plugin System
Расширяемость через плагины:
// strapi-plugin-my-feature/
module.exports = {
register({ strapi }) {
// Регистрация новых endpoints
},
bootstrap({ strapi }) {
// Инициализация
}
}
Для ЦИФРА:
# plugins/analytics/
class AnalyticsPlugin(BasePlugin):
def register(self, app):
app.add_route("/analytics/dashboard", ...)
3. Rich Content Management
Не только CRUD, но и:
- Media Library (файлы, изображения)
- Rich Text Editor
- Drafts / Publishing workflow
Amplication - Low-code платформа для генерации Node.js/NestJS backend.
GitHub: 15K+ ⭐
Особенность: Генерирует полноценный код, не runtime
┌─────────────────────────────────────────────────────────┐
│ AMPLICATION WEB UI │
│ ┌───────────────────────────────────────────────────┐ │
│ │ Visual Data Model Designer │ │
│ │ - Entities (drag & drop) │ │
│ │ - Fields with types │ │
│ │ - Relationships (visual arrows) │ │
│ │ - Roles & Permissions │ │
│ └──────────────────┬────────────────────────────────┘ │
│ ↓ │
│ ┌───────────────────────────────────────────────────┐ │
│ │ Build Configuration │ │
│ │ - Technology: NestJS / Node.js │ │
│ │ - Database: PostgreSQL / MongoDB │ │
│ │ - Auth: JWT / Auth0 │ │
│ │ - APIs: REST + GraphQL │ │
│ └──────────────────┬────────────────────────────────┘ │
└──────────────────────┼──────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────┐
│ CODE GENERATION ENGINE │
│ ┌───────────────────────────────────────────────────┐ │
│ │ Template Engine │ │
│ │ - NestJS modules templates │ │
│ │ - TypeORM entities templates │ │
│ │ - GraphQL resolvers templates │ │
│ │ - Prisma schema templates │ │
│ └──────────────────┬────────────────────────────────┘ │
│ ↓ │
│ ┌───────────────────────────────────────────────────┐ │
│ │ Code Generator │ │
│ │ - Entities → TypeORM Models │ │
│ │ - Services → NestJS Services │ │
│ │ - Controllers → REST Controllers │ │
│ │ - Resolvers → GraphQL Resolvers │ │
│ └──────────────────┬────────────────────────────────┘ │
│ ↓ │
│ ┌───────────────────────────────────────────────────┐ │
│ │ Git Integration │ │
│ │ - Commit to GitHub repo │ │
│ │ - Pull Request with changes │ │
│ └───────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────┐
│ GENERATED CODE (NestJS Project) │
│ ├── src/ │
│ │ ├── user/ │
│ │ │ ├── user.entity.ts (TypeORM) │
│ │ │ ├── user.service.ts (Business Logic) │
│ │ │ ├── user.controller.ts (REST) │
│ │ │ └── user.resolver.ts (GraphQL) │
│ │ ├── post/ │
│ │ └── ... │
│ ├── prisma/ │
│ │ └── schema.prisma │
│ └── package.json │
└─────────────────────────────────────────────────────────┘
Из визуальной модели:
Visual Model:
Entity: User
- email: String (unique)
- username: String
- posts: Relation[Post] (one-to-many)
Генерируется:
// src/user/user.entity.ts
import { Entity, Column, PrimaryGeneratedColumn, OneToMany } from 'typeorm';
import { Post } from '../post/post.entity';
@Entity()
export class User {
@PrimaryGeneratedColumn()
id: number;
@Column({ unique: true })
email: string;
@Column()
username: string;
@OneToMany(() => Post, post => post.author)
posts: Post[];
}
// src/user/user.service.ts
@Injectable()
export class UserService {
constructor(
@InjectRepository(User)
private userRepository: Repository<User>,
) {}
async findAll(): Promise<User[]> {
return this.userRepository.find({ relations: ['posts'] });
}
async findOne(id: number): Promise<User> {
return this.userRepository.findOne({ where: { id }, relations: ['posts'] });
}
async create(createUserDto: CreateUserDto): Promise<User> {
const user = this.userRepository.create(createUserDto);
return this.userRepository.save(user);
}
// ... update, delete
}
// src/user/user.controller.ts
@Controller('users')
export class UserController {
constructor(private readonly userService: UserService) {}
@Get()
findAll(): Promise<User[]> {
return this.userService.findAll();
}
@Post()
create(@Body() createUserDto: CreateUserDto): Promise<User> {
return this.userService.create(createUserDto);
}
// ... other endpoints
}
// src/user/user.resolver.ts (GraphQL)
@Resolver(() => User)
export class UserResolver {
constructor(private userService: UserService) {}
@Query(() => [User])
users() {
return this.userService.findAll();
}
@Mutation(() => User)
createUser(@Args('input') input: CreateUserInput) {
return this.userService.create(input);
}
}
1. Code Generation (не runtime!)
В отличие от Hasura/Supabase, Amplication генерирует код.
Плюсы:
- ✅ Полный контроль (можно редактировать)
- ✅ Нет vendor lock-in
- ✅ Можно деплоить куда угодно
Минусы:
- ❌ Изменения в UI → нужна регенерация
- ❌ Кастомный код может перезаписаться
Для ЦИФРА:
Гибридный подход:
- Базовый CRUD → генерация кода
- Кастомная логика → защищённые блоки
# generated/api/users.py
# @@GENERATED_START
@app.get("/users")
async def list_users():
return await db.fetch_all("SELECT * FROM users")
# @@GENERATED_END
# @@CUSTOM_START
@app.get("/users/stats")
async def user_stats():
# Кастомная логика - не перезаписывается!
pass
# @@CUSTOM_END
2. Visual Model Builder
Drag & drop entities, relationships видны как стрелки.
3. Git Integration
Каждое изменение → Git commit → Pull Request.
Для ЦИФРА:
User изменил модель в UI
↓
Генерация кода
↓
Git commit
↓
CI/CD → Deploy
Prisma - современный ORM с уникальным подходом.
GitHub: 38K+ ⭐
┌─────────────────────────────────────────────────────────┐
│ PRISMA WORKFLOW │
├─────────────────────────────────────────────────────────┤
│ 1. Schema Definition (schema.prisma) │
│ │
│ model User { │
│ id Int @id @default(autoincrement()) │
│ email String @unique │
│ posts Post[] │
│ } │
│ │
│ model Post { │
│ id Int @id @default(autoincrement()) │
│ title String │
│ authorId Int │
│ author User @relation(...) │
│ } │
├─────────────────────────────────────────────────────────┤
│ 2. Migration Generation │
│ │
│ $ prisma migrate dev --name init │
│ │
│ ↓ Генерируется SQL миграция │
│ │
│ CREATE TABLE "User" ( │
│ id SERIAL PRIMARY KEY, │
│ email TEXT UNIQUE │
│ ); │
├─────────────────────────────────────────────────────────┤
│ 3. Client Generation │
│ │
│ $ prisma generate │
│ │
│ ↓ Генерируется TypeScript типизированный клиент │
│ │
│ PrismaClient { │
│ user: { │
│ create(), findMany(), update(), ... │
│ } │
│ post: { ... } │
│ } │
├─────────────────────────────────────────────────────────┤
│ 4. Type-Safe Queries │
│ │
│ const user = await prisma.user.create({ │
│ data: { │
│ email: "test@example.com", │
│ posts: { │
│ create: [ │
│ { title: "Hello" } │
│ ] │
│ } │
│ } │
│ }) │
│ │
│ // ↑ Полная типизация! IDE подсказывает всё │
└─────────────────────────────────────────────────────────┘
1. Schema-First подход
Одна схема → миграции + клиент + типы.
Для ЦИФРА:
# schema.cidl → всё генерируется
entity: User
fields: ...
↓ cifra-codegen generate
✅ SQLAlchemy models
✅ Pydantic schemas (типизация)
✅ FastAPI client (typesafe)
✅ Alembic migrations
2. Developer Experience
| Фреймворк | Подход | Генерация | GUI | Кастомизация | Type Safety |
|---|---|---|---|---|---|
| Hasura | Metadata-driven | ❌ Runtime | ✅ Да | 🟡 Средняя | ✅ GraphQL |
| Supabase | DB-first | ❌ Runtime | ✅ Да | 🟡 Средняя | 🟡 Частично |
| Strapi | CMS-first | 🟡 Hybrid | ✅ Да (лучший!) | ✅ Высокая | ❌ Нет |
| Amplication | Code-gen | ✅ Полная | ✅ Да | ✅ Высокая | ✅ TypeScript |
| Prisma | Schema-first | ✅ Client | ❌ Нет | ✅ Высокая | ✅ TypeScript |
| PostgREST | DB-first | ❌ Runtime | ❌ Нет | 🟡 Средняя | ❌ Нет |
| Directus | Data-first | ❌ Runtime | ✅ Да | ✅ Высокая | ❌ Нет |
┌─────────────────────────────────────────────────────────┐
│ ПЛАТФОРМА ЦИФРА ARCHITECTURE │
├─────────────────────────────────────────────────────────┤
│ │
│ ┌───────────────────────────────────────────────────┐ │
│ │ LAYER 1: Definition (Schema) │ │
│ │ │ │
│ │ CIDL (YAML) ← взято из Prisma подхода │ │
│ │ - Entity definition │ │
│ │ - Fields, relationships │ │
│ │ - API spec │ │
│ │ - Permissions │ │
│ │ │ │
│ │ + AI Generation (Claude создаёт CIDL из текста) │ │
│ └───────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌───────────────────────────────────────────────────┐ │
│ │ LAYER 2: Code Generation │ │
│ │ │ │
│ │ Code Generator ← взято из Amplication │ │
│ │ - SQLAlchemy models │ │
│ │ - Pydantic schemas (type-safe) │ │
│ │ - FastAPI endpoints │ │
│ │ - Alembic migrations │ │
│ │ - Tests │ │
│ │ │ │
│ │ Protected blocks для кастомного кода │ │
│ └───────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌───────────────────────────────────────────────────┐ │
│ │ LAYER 3: Metadata Runtime │ │
│ │ │ │
│ │ Metadata Engine ← взято из Hasura │ │
│ │ - Permissions проверяются через metadata │ │
│ │ - Relationships динамические │ │
│ │ - Hot reload при изменении │ │
│ │ │ │
│ │ Можно изменять без регенерации кода! │ │
│ └───────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌───────────────────────────────────────────────────┐ │
│ │ LAYER 4: Admin UI │ │
│ │ │ │
│ │ Visual Builder ← взято из Strapi │ │
│ │ - Drag & drop entities │ │
│ │ - Visual relationships │ │
│ │ - Content management │ │
│ │ - SQL Editor │ │
│ │ │ │
│ │ + AI Chat для управления ← УНИКАЛЬНО! │ │
│ └───────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌───────────────────────────────────────────────────┐ │
│ │ LAYER 5: Plugin System │ │
│ │ │ │
│ │ Plugins ← взято из Strapi │ │
│ │ - Core plugins (auth, storage, analytics) │ │
│ │ - Custom plugins │ │
│ │ - Community plugins │ │
│ └───────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘
1. Описание через AI:
"Создай User с email, password и ролями"
↓
Claude генерирует CIDL
2. Генерация кода:
cifra-codegen generate User.cidl
↓
Создаётся: models, api, schemas, migrations, tests
3. Кастомизация:
Редактируешь код в защищённых блоках
@@CUSTOM_START ... @@CUSTOM_END
4. Hot-reload метаданных:
Изменяешь permissions в GUI → работает сразу!
(без регенерации)
5. Git integration:
Автокоммит изменений → CI/CD → Deploy
✅ Metadata-Driven подход
- Permissions как метаданные
- Relationships динамические
- Hot-reload без перезапуска
✅ GraphQL introspection
- Автогенерация схемы из БД
✅ Realtime из коробки
- PostgreSQL LISTEN/NOTIFY → WebSocket
- Row Level Security (RLS)
✅ Dashboard для всего
- Table editor
- SQL editor
- API docs
✅ Visual Content-Type Builder
- Drag & drop поля
- Visual relationships
- Rich content management
✅ Plugin System
- Расширяемость
- Core + custom plugins
✅ Code Generation (не runtime)
- Генерация полноценного кода
- Protected blocks для кастома
- Git integration
✅ Visual Data Modeler
- Entities как блоки
- Relationships как стрелки
✅ Schema-First подход
- Одна схема → всё остальное
- Type-safe client
- Developer Experience
✅ Миграции автоматом
- prisma migrate dev
- Introspection
# 1. CIDL Schema (как Prisma)
entity: User
fields: ...
api: ...
permissions: ...
# 2. Code Generation (как Amplication)
$ cifra-codegen generate User.cidl
# → Создаёт Python код (FastAPI + SQLAlchemy)
# 3. Metadata Runtime (как Hasura)
# Permissions проверяются через metadata (hot-reload)
# 4. Visual Builder (как Strapi)
# GUI для создания entities, drag & drop
# 5. AI Integration (УНИКАЛЬНО!)
# Claude генерирует CIDL из текста
# 6. Plugin System (как Strapi)
# Расширяемость через плагины
Backend:
- FastAPI (веб-фреймворк)
- SQLAlchemy (ORM)
- Alembic (миграции)
- Pydantic (валидация + type-safety)
Generation:
- Jinja2 (шаблоны кода)
- PyYAML (парсинг CIDL)
- AST (если нужна гибкость)
Frontend:
- React (UI для builder)
- Monaco Editor (код-редактор)
- React Flow (visual relationships)
AI:
- Anthropic Claude API (генерация CIDL)
Database:
- PostgreSQL (основная БД)
- Redis (кэш + real-time)
Гибридный подход:
Prisma (schema-first)
+ Amplication (code generation)
+ Hasura (metadata runtime)
+ Strapi (visual UI + plugins)
+ Claude AI (intelligence)
= ПЛАТФОРМА ЦИФРА
Phase 0: CIDL Parser + базовая генерация (2 недели)
Phase 1: Visual Builder GUI (3 недели)
Phase 2: Metadata Runtime (2 недели)
Phase 3: AI Integration (2 недели)
Phase 4: Plugin System (2 недели)
Итого: ~11 недель до MVP
Версия: 1.0.0
Статус: Архитектура определена
Следующий шаг: Начать разработку CIDL + генератора?