پلتفرم اتوماسیون تجاری چند‌مستأجری
Universal Workflow Automation Platform

۱ تعریف محصول

این محصول یک پلتفرم اتوماسیون جریان‌کار (Workflow Automation Platform) است؛ مشابه n8n، Make.com و Zapier، اما با تفاوت کلیدی: هسته عمومی و افقی که با نصب «ماژول» به هر کسب‌وکاری تخصصی می‌شود. مشتری CRM می‌خواهد → ماژول CRM نصب می‌کند، فروشگاهی است → ماژول Ecommerce، کلینیک است → ماژول نوبت‌دهی و پیام‌رسان.

  ┌──────────┐    ┌───────────┐    ┌────────┐    ┌───────────┐    ┌────────┐
  │ Trigger  │───►│ Condition │───►│ Action │───►│ Condition │───►│ Action │
  │ (محرک)   │    │  (شرط)    │    │ (عمل)  │    │  (شرط)    │    │ (عمل)  │
  └──────────┘    └───────────┘    └────────┘    └───────────┘    └────────┘
      │
      ├─ Webhook        (دریافت داده از بیرون)
      ├─ Schedule/Cron  (زمان‌بندی)
      ├─ Event          (رویداد داخلی سیستم)
      └─ Manual         (اجرای دستی)

۱.۱ سه حالت ارائه به مشتری

۲ معماری کلان

┌──────────────────────────────────────────────────────────────────────┐
│                         PLATFORM LAYER                                │
├──────────────────────────────────────────────────────────────────────┤
│   ┌─────────────┐   ┌──────────────────┐   ┌──────────────────┐      │
│   │  SaaS Mode  │   │  Self-Hosted Mode│   │   API Gateway    │      │
│   │  (Cloud)    │   │  (On-Premise)    │   │   (REST / Token) │      │
│   └──────┬──────┘   └────────┬─────────┘   └────────┬─────────┘      │
│          └───────────────────┼──────────────────────┘                │
│                              ▼                                       │
│                 ┌────────────────────────────┐                       │
│                 │     CORE ENGINE (Laravel)  │                       │
│                 │ ┌────────────────────────┐ │                       │
│                 │ │  Workflow Engine       │ │                       │
│                 │ │  Execution Engine      │ │                       │
│                 │ │  Trigger Dispatcher    │ │                       │
│                 │ │  Action Resolver       │ │                       │
│                 │ │  Module Registry       │ │                       │
│                 │ │  License Manager       │ │                       │
│                 │ └────────────────────────┘ │                       │
│                 └──────────────┬─────────────┘                       │
│         ┌──────────────────────┼──────────────────────┐              │
│         ▼                      ▼                      ▼              │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────────┐       │
│  │ PostgreSQL / │    │  Redis /     │    │  Queue Workers   │       │
│  │   MySQL      │    │  RabbitMQ    │    │ (Laravel Horizon)│       │
│  └──────────────┘    └──────────────┘    └──────────────────┘       │
├──────────────────────────────────────────────────────────────────────┤
│                    ADMIN PANEL  (Nuxt 4 + Vue 3)                      │
└──────────────────────────────────────────────────────────────────────┘

۲.۱ جریان یک اجرا (Execution Flow)

  [Webhook / Cron / Event]
            │
            ▼
  ┌────────────────────┐
  │  Trigger Controller│  ← احراز هویت، امضای HMAC، Rate Limit
  └─────────┬──────────┘
            ▼
  ┌────────────────────┐
  │ Check Plan & Quota │  ← آیا پلن مشتری اجازه این اجرا را می‌دهد؟
  └─────────┬──────────┘
            ▼
  ┌────────────────────┐
  │  Push to Queue     │  ← ExecuteWorkflowJob (Redis)
  └─────────┬──────────┘
            ▼
  ┌────────────────────┐
  │  Graph Resolver    │  ← Topological Sort روی DAG
  └─────────┬──────────┘
            ▼
  ┌────────────────────┐
  │  Node Executor(s)  │  ← اجرای موازی شاخه‌های مستقل
  └─────────┬──────────┘
            ▼
  ┌────────────────────┐
  │ Execution Logger   │  ← لاگ هر گره + ورودی/خروجی
  └─────────┬──────────┘
            ▼
  ┌────────────────────┐
  │ Usage Meter        │  ← ثبت مصرف برای بیلینگ
  └────────────────────┘

۳ طراحی ماژولار

سیستم به سه لایه مستقل تقسیم می‌شود: هسته (Core)، ماژول‌ها (Modules) و پلتفرم (Platform). هر لایه قابل تست، قابل نسخه‌بندی و قابل فروش جداگانه است.

۳.۱ هسته اتوماسیون (Core) — رایگان و ثابت

┌─────────────────────────────────────────────────────────┐
│                     CORE MODULES                          │
├─────────────────────────────────────────────────────────┤
│  automation-core                                          │
│  ├── Workflow          (تعریف جریان)                      │
│  ├── Node              (گره: trigger/action/condition)     │
│  ├── Edge              (اتصال بین گره‌ها)                  │
│  ├── Execution         (نمونه اجرا)                       │
│  ├── ExecutionContext  (زمینه اجرا و متغیرها)              │
│  └── VariableResolver  (حل {{ path.to.value }})            │
├─────────────────────────────────────────────────────────┤
│  automation-engine                                        │
│  ├── WorkflowExecutor  ← ارکستراتور اصلی                  │
│  ├── NodeDispatcher    ← انتخاب و اجرای گره               │
│  ├── ErrorHandler      ← retry / fallback / circuit break │
│  ├── ParallelExecutor  ← اجرای همزمان شاخه‌ها              │
│  └── ExecutionLogger   ← ثبت لاگ ساخت‌یافته                │
├─────────────────────────────────────────────────────────┤
│  automation-trigger                                       │
│  ├── WebhookTrigger    ├── ScheduleTrigger (Cron)         │
│  ├── EventTrigger      └── ManualTrigger                  │
├─────────────────────────────────────────────────────────┤
│  automation-action                                        │
│  ├── HttpAction        ├── EmailAction                    │
│  ├── DatabaseAction    ├── WebhookAction                  │
│  └── CustomAction (قابل توسعه توسط ماژول‌ها)              │
└─────────────────────────────────────────────────────────┘

۳.۲ ماژول‌های قابل خرید و نصب (Marketplace)

۳.۳ قرارداد (Contract) هر ماژول

هر ماژول یک Laravel Package است که ۴ مورد را register می‌کند:

// app/Modules/Crm/ModuleServiceProvider.php
class CrmServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        // ۱) گره‌های قابل استفاده در Workflow
        NodeRegistry::register([
            'crm.contact.create'  => Actions\CreateContact::class,
            'crm.deal.move_stage' => Actions\MoveDealStage::class,
            'crm.lead.capture'    => Triggers\LeadCaptured::class,
        ]);

        // ۲) شرط‌های اختصاصی
        ConditionRegistry::register([
            'crm.contact.exists' => Conditions\ContactExists::class,
        ]);

        // ۳) متریک مصرف (برای بیلینگ پلن‌محور)
        UsageMeter::define('crm.contacts_created');

        // ۴) منوی پنل و مجوزها
        AdminMenu::add('crm', 'CRM', capability: 'module.crm');
    }
}

۴ مدل تجاری‌سازی و پلن‌ها

با هدف ۳ مشتری اولیه → ۱۰۰ مشتری در ۲۴ ماه، ساختار قیمت‌گذاری باید سه لایه داشته باشد: اشتراک پلنی، فروش ماژول، و لایسنس Self-Hosted.

۴.۱ پلن‌های اشتراکی (SaaS)

۴.۲ جریان‌های درآمدی (Revenue Streams)

۴.۳ منطق کنترل دسترسی (Entitlement)

  Tenant
    │
    ├── Subscription ──► Plan
    │                      │
    │                      ├── plan_limits      (max_workflows, runs/month, retention)
    │                      └── plan_modules ──┐
    │                                          ▼
    ├── ModuleAccess ──────────────► آیا این ماژول برای tenant فعال است؟
    │                                 │
    │                                 ├── از پلن (خودکار)
    │                                 ├── از خرید تکی (add-on)
    │                                 └── از trial (۱۴ روزه)
    │
    └── UsageCounter (Redis, ریست ماهانه)
           │
           ├── runs_this_month  → اگر ≥ سقف پلن ⇒ صف متوقف + اعلان ارتقا
           └── overage          → محاسبه هزینه مازاد (اختیاری)

  ┌──────────────────────────────────────────────────┐
  │  PlanGate Middleware:                            │
  │   1) tenant دارد؟  2) اشتراک فعال است؟           │
  │   3) ماژول مجاز است؟  4) سقف مصرف رد نشده؟      │
  └──────────────────────────────────────────────────┘

۵ مدل داده (Data Model)

۵.۱ رابطه‌ی موجودیت‌ها

┌──────────────┐       ┌──────────────┐       ┌──────────────┐
│   tenants    │──1:N─►│  workspaces  │──1:N─►│  workflows   │
└──────┬───────┘       └──────────────┘       └──────┬───────┘
       │                                             │
       │                          ┌──────────────────┼─────────────────┐
       │                          ▼                  ▼                 ▼
       │                   ┌─────────────┐   ┌─────────────┐   ┌──────────────┐
       │                   │workflow_nodes│  │    edges    │   │  executions  │
       │                   └──────┬──────┘   └─────────────┘   └──────┬───────┘
       │                          │                                  │
       │                   ┌──────▼──────┐                    ┌──────▼───────┐
       │                   │  node_types │                    │execution_logs│
       │                   │ (registry)  │                    │ (per node)   │
       │                   └─────────────┘                    └──────────────┘
       │
       ├──1:N─► subscriptions ──N:1──► plans ──1:N──► plan_modules
       │
       ├──1:N─► module_access ──N:1──► modules
       │
       ├──1:N─► api_keys
       ├──1:N─► webhooks      (endpoint دریافتی)
       ├──1:N─► schedules     (cron definitions)
       ├──1:N─► usage_counters (ریست ماهانه)
       ├──1:N─► secrets       (اعتبارنامه‌های رمزنگاری‌شده)
       └──1:N─► licenses      (فقط حالت Self-Hosted)

۵.۲ جدول‌های اصلی و وظیفه هرکدام

۵.۳ نمونه Migration هسته

// database/migrations/..._create_workflows_table.php
Schema::create('workflows', function (Blueprint $t) {
    $t->id();
    $t->foreignId('tenant_id')->constrained()->cascadeOnDelete();
    $t->foreignId('workspace_id')->constrained()->cascadeOnDelete();
    $t->string('name');
    $t->string('slug');
    $t->text('description')->nullable();
    $t->string('status')->default('draft'); // draft|active|paused|archived
    $t->string('trigger_type');            // webhook|schedule|event|manual
    $t->json('trigger_config')->nullable();
    $t->json('settings')->nullable();       // timeout, retry, concurrency
    $t->unsignedInteger('version')->default(1);
    $t->timestamp('last_run_at')->nullable();
    $t->timestamps();
    $t->unique(['tenant_id', 'slug']);
    $t->index(['tenant_id', 'status']);
});
// نکته: برای مقیاس ۱۰۰ مشتری، ایندکس ترکیبی tenant_id لازم است

۶ ساختار پروژه Laravel

ساختار پیشنهادی بر پایه Domain-Driven Design سبک است: سه فضای نام اصلی (Core، Modules، Platform) که مرزهای مسئولیت را شفاف نگه می‌دارند.

app/
├── Core/                          ← موتور اتوماسیون (مستقل از کسب‌وکار)
│   ├── Workflow/
│   │   ├── Models/Workflow.php
│   │   ├── WorkflowManager.php         (سرویس اصلی CRUD + نسخه‌بندی)
│   │   ├── WorkflowBuilder.php         (DSL ساخت جریان با کد)
│   │   └── WorkflowValidator.php       (اعتبارسنجی DAG، حلقه‌ی بی‌نهایت)
│   ├── Engine/
│   │   ├── Engine.php                  (ارکستراتور)
│   │   ├── GraphResolver.php           (Topological Sort)
│   │   ├── NodeExecutor.php            (اجرای یک گره)
│   │   ├── ContextManager.php          (مسیر داده بین گره‌ها)
│   │   ├── ParallelExecutor.php
│   │   └── ErrorHandler.php            (retry/fallback/circuit-breaker)
│   ├── Trigger/
│   │   ├── Contracts/TriggerContract.php
│   │   ├── WebhookTrigger.php
│   │   ├── ScheduleTrigger.php
│   │   ├── EventTrigger.php
│   │   └── TriggerDispatcher.php
│   └── Action/
│       ├── Contracts/ActionContract.php
│       ├── NodeRegistry.php            ← رجیستری مرکزی
│       ├── HttpAction.php
│       ├── EmailAction.php
│       └── DatabaseAction.php
│
├── Modules/                       ← ماژول‌های تجاری (قابل خرید/نصب)
│   ├── Crm/
│   │   ├── Actions/  Triggers/  Conditions/  Migrations/
│   │   ├── Http/Controllers/
│   │   └── CrmServiceProvider.php
│   ├── Messaging/
│   ├── Ecommerce/
│   └── ...
│
├── Platform/                      ← لایه تجاری (در Self-Hosted غیرفعال)
│   ├── Billing/
│   │   ├── SubscriptionManager.php
│   │   ├── PlanResolver.php            (پلن فعال tenant)
│   │   └── UsageMeter.php              (شمارش مصرف)
│   ├── Licensing/
│   │   ├── LicenseManager.php
│   │   └── LicenseClient.php           (اتصال heartbeat به سرور ما)
│   ├── Tenancy/
│   │   ├── TenantManager.php
│   │   ├── TenantScope.php             (Global Scope)
│   │   └── TenantResolver.php          (ساب‌دامین/هدر/کلید)
│   └── Marketplace/
│       ├── ModuleRegistry.php
│       └── ModuleInstaller.php
│
├── Http/
│   ├── Controllers/Api/V1/        ← REST API برای مشتریان
│   ├── Controllers/Api/Admin/     ← API پنل مدیریت پلتفرم
│   └── Middleware/
│       ├── ResolveTenant.php
│       ├── EnsurePlanFeature.php       (PlanGate)
│       ├── EnsureModuleAccess.php
│       ├── EnforceQuota.php
│       └── VerifyLicense.php           (فقط Self-Hosted)
│
└── Jobs/
    ├── ExecuteWorkflowJob.php
    ├── ExecuteNodeJob.php
    ├── DispatchScheduledWorkflowsJob.php
    └── ReportUsageJob.php

۶.۱ نسخه‌بندی API و قرارداد پاسخ

// مسیرها: routes/api_v1.php
Route::prefix('v1')->middleware([
    'auth:sanctum', ResolveTenant::class,
    EnsurePlanFeature::class, EnforceQuota::class,
])->group(function () {
    Route::apiResource('workflows', WorkflowController::class);
    Route::post('workflows/{workflow}/execute', [WorkflowController::class, 'execute']);
    Route::apiResource('executions', ExecutionController::class)->only(['index', 'show']);
    Route::get('nodes/types', [NodeTypeController::class, 'index']); // رجیستری گره‌ها
    Route::apiResource('modules', ModuleController::class)->only(['index', 'show']);
    Route::post('modules/{slug}/install', [ModuleController::class, 'install']);
});

// Webhook عمومی (بدون Sanctum، با امضای HMAC)
Route::post('v1/hooks/{token}', WebhookReceiverController::class)
     ->middleware(['throttle:webhooks', VerifyWebhookSignature::class]);

۷ موتور Workflow (قلب سیستم)

۷.۱ ساختار JSON یک جریان

{
  "name": "Auto Welcome New Customer",
  "status": "active",
  "trigger": {
    "type": "webhook",
    "config": {
      "method": "POST",
      "mapping": { "email": "$.email", "name": "$.full_name" }
    }
  },
  "nodes": [
    { "id": "n1", "type": "action.http_request", "config": {
        "url": "{{ secrets.crm_url }}/contacts",
        "method": "POST",
        "body": { "email": "{{ trigger.email }}" } } },

    { "id": "n2", "type": "condition.if", "config": {
        "expression": "{{ n1.data.plan }} == 'premium'" } },

    { "id": "n3", "type": "action.send_email", "config": {
        "to": "{{ trigger.email }}", "template": "premium_welcome" } },

    { "id": "n4", "type": "action.send_email", "config": {
        "to": "{{ trigger.email }}", "template": "basic_welcome" } }
  ],
  "edges": [
    { "from": "trigger", "to": "n1" },
    { "from": "n1", "to": "n2" },
    { "from": "n2", "to": "n3", "branch": "true"  },
    { "from": "n2", "to": "n4", "branch": "false" }
  ]
}

۷.۲ قرارداد اجرای یک گره (Node Contract)

interface NodeContract
{
    public static function slug(): string;          // 'action.http_request'
    public static function schema(): array;           // فرم داینامیک پنل
    public static function outputSchema(): array;     // برای auto-complete متغیرها
    public function execute(NodeContext $ctx): NodeResult;
    public function validate(array $config): void;        // پیش از ذخیره
    public function retryPolicy(): RetryPolicy;
}

۷.۳ الگوریتم‌های کلیدی موتور

┌───────────────────────────────────────────────────────────────┐
│                  EXECUTION ALGORITHM                           │
├───────────────────────────────────────────────────────────────┤
│  1) اعتبارسنجی گراف                                            │
│     ├── آیا DAG است؟ (تشخیص حلقه با DFS)                       │
│     ├── آیا همه گره‌ها به هم متصل‌اند؟ (unreachable nodes)      │
│     └── آیا انواع گره در رجیستری فعال tenant وجود دارد؟        │
│                                                                │
│  2) Topological Sort  →  تعیین ترتیب اجرا                      │
│                                                                │
│  3) اجرای گره‌به‌گره                                            │
│     ├── Context مشترک: { trigger, nodes.{id}.data, env }       │
│     ├── VariableResolver: حل {{ path.to.value }}               │
│     ├── شاخه‌های مستقل ⇒ همزمان (Queue::batch)                 │
│     ├── Wait/Delay ⇒ Delayed Job                              │
│     └── شرط شرطی ⇒ انتخاب یال branch                          │
│                                                                │
│  4) مدیریت خطا در هر گره                                        │
│     ├── Retry با backoff نمایی  (1s, 5s, 30s)                  │
│     ├── Error Output Branch  (مسیر جایگزین)                    │
│     ├── Circuit Breaker  (قطع پس از N خطای متوالی)             │
│     └── Continue On Fail  (ادامه بدون توقف کل جریان)           │
│                                                                │
│  5) ثبت نتیجه                                                  │
│     ├── execution_logs هر گره (input/output masked)            │
│     ├── به‌روزرسانی usage_counter                              │
│     └── رویداد WebSocket برای نمایش زنده در پنل                │
└───────────────────────────────────────────────────────────────┘

۷.۴ نمونه کد اجرای جریان

class ExecuteWorkflowJob implements ShouldQueue
{
    public function handle(Engine $engine): void
    {
        $execution = Execution::create([
            'workflow_id' => $this->workflow->id,
            'status'      => 'running',
            'payload'     => $this->payload,
        ]);

        $engine->run(
            workflow:  $this->workflow,
            context:   ContextManager::from($this->payload, $this->workflow->settings),
            execution: $execution,
        );
    }

    public function failed(Throwable $e): void
    {
        // اطلاع‌رسانی به tenant + ثبت در monitoring
    }
}

۸ چند‌مستأجری (Multi-Tenancy)

۸.۱ انتخاب استراتژی

۸.۲ زنجیره تشخیص tenant

┌────────────────────────────────────────────────────────────┐
│              TENANT RESOLUTION CHAIN                        │
├────────────────────────────────────────────────────────────┤
│  ۱. Subdomain    →  acme.automation.ir   →  tenant #1      │
│  ۲. Custom Domain→  automation.acme.ir   →  tenant #1      │
│  ۳. API Key      →  ak_live_xxxx (prefix lookup)           │
│  ۴. JWT Claim    →  tid: 1                                 │
│  ۵. Header       →  X-Tenant-Id: 1   (فقط برای Super Admin)│
│                                                            │
│  نتیجه → app(TenantManager::class)->set($tenant)           │
│         → TenantScope روی همه مدل‌ها اعمال می‌شود           │
└────────────────────────────────────────────────────────────┘

۸.۳ پیاده‌سازی Global Scope

trait BelongsToTenant
{
    protected static function bootBelongsToTenant(): void
    {
        // ۱) فیلتر خودکار همه کوئری‌ها
        static::addGlobalScope('tenant', function (Builder $q) {
            if ($id = app(TenantManager::class)->id()) {
                $q->where($q->getModel()->getTable().'.tenant_id', $id);
            }
        });

        // ۲) مقداردهی خودکار هنگام ساخت رکورد
        static::creating(function ($model) {
            if (empty($model->tenant_id)) {
                $model->tenant_id = app(TenantManager::class)->id();
            }
        });
    }
}

۹ معماری Self-Hosted و سیستم لایسنس

این بخش تعیین‌کننده‌ی مدل درآمدی پرسود محصول است. چالش اصلی: مشتری روی سرور خودش نصب می‌کند، پس چطور مطمئن شویم لایسنس معتبر است و از محدوده خارج نشده؟

۹.۱ معماری ارتباط با سرور لایسنس

┌───────────────────────────────────────────────────────────────┐
│                  SELF-HOSTED ARCHITECTURE                      │
├───────────────────────────────────────────────────────────────┤
│                                                                │
│   سرور مشتری                          سرور ما (License Server) │
│  ┌────────────────┐                  ┌───────────────────────┐ │
│  │  Laravel App   │   HTTPS POST     │  License API          │ │
│  │ (همان کدبیس)   │ ───────────────► │  ├─ validate(key)     │ │
│  │                │ ◄─────────────── │  ├─ bind(domain,fp)   │ │
│  │ LicenseMiddleware  Signed JWT     │  ├─ heartbeat()       │ │
│  │  ▼ cache 24h   │                  │  └─ usage report      │ │
│  │                │   POST /usage    │                       │ │
│  │ UsageReporter  │ ───────────────► │  Metering + Billing   │ │
│  └────────────────┘                  └───────────────────────┘ │
│                                                                │
│  حالت آفلاین:  Grace Period ۷ روزه (لایسنس در cache)           │
│  محافظت:       امضای دیجیتال کد + تشخیص دستکاری فایل‌ها        │
│  توزیع:        docker-compose + اسکریپت نصب یک‌خطی              │
└───────────────────────────────────────────────────────────────┘

۹.۲ چرخه حیات لایسنس

۹.۳ کد اعتبارسنجی لایسنس

class LicenseMiddleware
{
    public function handle($request, Closure $next)
    {
        if (config('app.mode') !== 'self_hosted') {
            return $next($request);   // در حالت SaaS بررسی لازم نیست
        }

        $license = Cache::remember('license.state', now()->addDay(), function () {
            return app(LicenseClient::class)->verify();
        });

        if (! $license->isValid() && $license->expiredMoreThan(7)) {
            return response()->json([
                'error'   => 'license_invalid',
                'message' => 'لایسنس منقضی شده است. برای تمدید با پشتیبانی تماس بگیرید.',
                'renew_url' => config('license.renew_url'),
            ], 402);
        }

        return $next($request);
    }
}

۱۰ طراحی RESTful API

قرارداد اصلی: پاسخ‌ها همیشه ساختار ثابت داشته باشند، خطاها معنادار و نسخه‌بندی از روز اول موجود باشد.

۱۰.۱ نقاط پایانی (Endpoints)

۱۰.۲ قرارداد ثابت پاسخ

// موفق
{
  "data": { "id": "wf_01H...", "name": "...", "status": "active" },
  "meta": { "request_id": "req_...", "tenant": "acme" }
}

// خطا (همیشه یک ساختار)
{
  "error": {
    "code": "quota_exceeded",
    "message": "سقف اجرای ماهانه پلن شما تکمیل شده است.",
    "details": { "limit": 500, "used": 500, "resets_at": "2026-10-01T00:00:00Z" },
    "upgrade_url": "https://panel.example.com/billing"
  }
}

۱۰.۳ امنیت API

۱۱ پنل مدیریت (Nuxt 4 + Vue 3)

۱۱.۱ ساختار پروژه پنل

panel/                                (Nuxt 4)
├── app/
│   ├── pages/
│   │   ├── index.vue                  (داشبورد: مصرف، اجراها، خطاها)
│   │   ├── workflows/
│   │   │   ├── index.vue              (لیست جریان‌ها)
│   │   │   ├── [id].vue               (★ Builder بصری)
│   │   │   └── [id]/executions.vue    (تاریخچه اجرا)
│   │   ├── executions/
│   │   │   ├── index.vue
│   │   │   └── [id].vue               (timeline اجرای گره‌ها)
│   │   ├── marketplace/index.vue      (کاتالوگ + خرید ماژول)
│   │   ├── secrets/index.vue          (مدیریت اعتبارنامه‌ها)
│   │   ├── api-keys/index.vue
│   │   ├── billing/
│   │   │   ├── plans.vue
│   │   │   └── invoices.vue
│   │   ├── settings/                  (کاربران، نقش‌ها، دامنه)
│   │   └── admin/                     (★ فقط Super Admin پلتفرم)
│   │       ├── tenants.vue            (مدیریت مشتریان)
│   │       ├── licenses.vue
│   │       ├── modules.vue            (انتشار ماژول)
│   │       └── revenue.vue            (MRR, Churn, Usage)
│   ├── components/
│   │   ├── builder/                   ← ★ بخش حیاتی پروژه
│   │   │   ├── FlowCanvas.vue         (Vue Flow + کانواس)
│   │   │   ├── NodePalette.vue        (لیست گره‌ها، جست‌وجو)
│   │   │   ├── NodeConfigPanel.vue    (فرم داینامیک از schema)
│   │   │   ├── VariablePicker.vue     (انتخاب {{ }} با autocomplete)
│   │   │   ├── TestRunPanel.vue       (اجرای آزمایشی + نمایش نتیجه)
│   │   │   └── TriggerConfig.vue
│   │   └── ui/                        (دکمه، جدول، مودال، Toast)
│   ├── composables/
│   │   ├── useApi.ts                  (لایه fetch + retry + خطا)
│   │   ├── useWorkflow.ts
│   │   ├── useNodeRegistry.ts
│   │   ├── useUsage.ts
│   │   └── useRealtime.ts             (Laravel Echo / WebSocket)
│   ├── stores/
│   │   ├── auth.ts                    (Pinia)
│   │   ├── tenant.ts
│   │   ├── workflowBuilder.ts         (state کانواس)
│   │   └── notifications.ts
│   └── middleware/
│       ├── auth.ts
│       └── planGuard.ts               (قفل UI بر اساس پلن)
│
└── nuxt.config.ts

۱۱.۲ فهرست صفحه‌ها و مسئولیت هرکدام

۱۱.۳ کتابخانه‌های پیشنهادی

۱۲ نقشه‌راه توسعه

با هدف ۳ مشتری در ۶ ماه اول و ۱۰۰ مشتری در ۲۴ ماه، اولویت‌بندی بر پایه «اول درآمد، بعد مقیاس» است.

۱۳ نکات کلیدی فنی

۱۳.۱ چالش‌های پیش‌بینی‌شده و راهکار

۱۴ تصمیمات معماری

انتخاب‌شده: MONOREPO
├── packages/
│   ├── core/         (موتور اتوماسیون — قابل استفاده در همه حالت‌ها)
│   ├── modules/      (ماژول‌های تجاری)
│   └── platform/     (بیلینگ، چند‌مستأجری، لایسنس)
├── apps/
│   ├── api/          (Laravel)
│   └── panel/        (Nuxt)
└── docker/           (بسته Self-Hosted)

مزیت: یک کدبیس ⇒ SaaS و Self-Hosted هر دو از یک منبع
عیب:  نیاز به انضباط در جداسازی لایه‌ها (تست‌های مرزی)

۱۵ جمع‌بندی و گام بعدی

۱۵.۱ نمای کلی نهایی

۱۵.۲ پنج اصل غیرقابل مذاکره

۱۵.۳ گام بعدی پیشنهادی

۱۵.۴ سؤالات باز برای تصمیم‌گیری