Detalhes do pacote

core-microservice

doguyegin75MIT1.3.0

Node.js mikroservis başlatma paketi (REST + WebSocket + Swagger + Auth + MongoDB Native Driver + Redis)

microservice, express, websocket, swagger

readme (leia-me)

Core Microservice Framework

Node.js tabanlı mikroservisler için tam kapsamlı bir çerçeve. Express, MongoDB, WebSocket, Redis ve Swagger entegrasyonu ile hızlı mikroservis geliştirme.

📋 İçindekiler

🤔 Bu Paket Nedir?

Core Microservice, Node.js ile mikroservis geliştirmeyi kolaylaştıran bir framework'tür. Bu paket sayesinde:

  • ✅ Hızlı başlangıç: Tek satır kodla mikroservis oluşturabilirsiniz
  • ✅ Güvenlik: JWT ve API Key tabanlı kimlik doğrulama
  • ✅ Veritabanı yönetimi: MongoDB için gelişmiş bağlantı yönetimi
  • ✅ Çoklu proje desteği: Her proje farklı veritabanlarına bağlanabilir
  • ✅ Hazır middleware'ler: Auth, logging, error handling
  • ✅ Dokümantasyon: Otomatik Swagger API dokümantasyonu

🎯 Ne Zaman Kullanılır?

  • Mikroservis mimarisi geliştirirken
  • REST API oluştururken
  • JWT tabanlı kimlik doğrulama gerektiğinde
  • MongoDB veritabanı kullanırken
  • Hızlı prototip geliştirirken
  • Production-ready uygulamalar oluştururken

🚀 Özellikler

🔐 Kimlik Doğrulama & Yetkilendirme

  • JWT token tabanlı kimlik doğrulama
  • API Key doğrulama
  • Role-based yetkilendirme (RBAC)
  • Otomatik token yenileme
  • Güvenli password hashing

🗄️ Gelişmiş MongoDB Yönetimi

  • Connection pooling
  • Otomatik yeniden bağlanma
  • Health check ve monitoring
  • Retry mechanism
  • Backup sistemi

🏢 Çoklu Proje Desteği

  • Her proje için ayrı veritabanı
  • Config-based yapılandırma
  • Environment variables desteği
  • Geriye dönük uyumluluk

📊 API & Dokümantasyon

  • Express.js tabanlı REST API
  • Otomatik Swagger dokümantasyonu
  • WebSocket desteği (Socket.IO)
  • Rate limiting
  • CORS yapılandırması

📝 Logging & Monitoring

  • Winston tabanlı loglama
  • Structured logging
  • Log rotation
  • Performance monitoring
  • Error tracking

⚡ Cache & Performance

  • Redis cache desteği
  • Query optimization
  • Connection pooling
  • Compression support
  • Timeout management

💻 Kurulum

1. Yeni Proje Oluşturma

# Yeni proje dizini oluştur
mkdir my-microservice
cd my-microservice

# Package.json oluştur
npm init -y

# Core Microservice paketini yükle
npm install core-microservice

# Gerekli bağımlılıkları yükle
npm install express dotenv

2. Environment Variables (.env)

# MongoDB Replica Set Bağlantısı
DB_USER=UserBesdort
DB_PASSWORD=BesDort2023!.!.
DB_HOSTS=89.252.146.61:31017,89.252.179.167:31017,37.148.213.36:31017
DB_NAME=besdort
DB_AUTH_SOURCE=admin
DB_REPLICA_SET=rs0

# JWT Ayarları
JWT_SECRET=my-super-secret-jwt-key-change-this-in-production
JWT_EXPIRES_IN=48h

# API Key
API_KEY=my-api-key-here-change-this-too

# GitHub Backup (Opsiyonel)
GIT_TOKEN=ghp_xxxxxxxxxxxxxxxx
GIT_REPO=username/my-repo
GIT_NAME=Backup Bot
GIT_EMAIL=backup@myproject.com

# Uygulama Ayarları
PORT=3000
NODE_ENV=development

3. Temel Proje Yapısı

my-microservice/
├── .env                    # Environment variables
├── .gitignore             # Git ignore dosyası
├── package.json           # Proje bağımlılıkları
├── app.js                 # Ana uygulama dosyası
├── routes/                # API route'ları
│   ├── users.js
│   ├── products.js
│   └── auth.js
├── controllers/           # Controller'lar
│   ├── userController.js
│   ├── productController.js
│   └── authController.js
├── models/               # Veri modelleri
│   ├── User.js
│   └── Product.js
├── middleware/           # Özel middleware'ler
│   ├── validation.js
│   └── rateLimiter.js
└── utils/               # Yardımcı fonksiyonlar
    ├── helpers.js
    └── constants.js

⚡ Hızlı Başlangıç

1. En Basit Kullanım

// app.js
import express from 'express';
import { Auth } from 'core-microservice';
import { createDatabaseManager } from 'core-microservice/core/database.js';

const app = express();
app.use(express.json());

// Database Manager oluştur
const dbManager = createDatabaseManager({
  database: {
    Hosts: ['89.252.146.61:31017', '89.252.179.167:31017', '37.148.213.36:31017'],
    Name: 'besdort',
    User: 'UserBesdort',
    Password: 'BesDort2023!.!.',
    AuthSource: 'admin',
    ReplicaSet: 'rs0'
  }
});

// Auth middleware oluştur
const auth = new Auth();

// Basit endpoint
app.get('/api/hello', (req, res) => {
  res.json({ message: 'Hello World!' });
});

// Korumalı endpoint
app.get('/api/protected', 
  auth.tokenAuth(),
  (req, res) => {
    res.json({ message: 'Bu endpoint korumalı!', user: req.user });
  }
);

app.listen(3000, () => {
  console.log('Server running on port 3000');
});

2. Tam Özellikli Örnek

// app.js
import express from 'express';
import { Auth } from 'core-microservice';
import { createDatabaseManager } from 'core-microservice/core/database.js';
import userRoutes from './routes/users.js';
import productRoutes from './routes/products.js';

const app = express();
app.use(express.json());

// Database Manager oluştur
const dbConfig = {
  database: {
    Hosts: process.env.DB_HOSTS ? process.env.DB_HOSTS.split(',') : ['89.252.146.61:31017', '89.252.179.167:31017', '37.148.213.36:31017'],
    Name: process.env.DB_NAME || 'besdort',
    User: process.env.DB_USER || 'UserBesdort',
    Password: process.env.DB_PASSWORD || 'BesDort2023!.!.',
    AuthSource: process.env.DB_AUTH_SOURCE || 'admin',
    ReplicaSet: process.env.DB_REPLICA_SET || 'rs0'
  }
};

const dbManager = createDatabaseManager(dbConfig);

// Auth middleware oluştur
const auth = new Auth();

// Global middleware - database manager'ı tüm route'larda kullanılabilir hale getir
app.use((req, res, next) => {
  req.dbManager = dbManager;
  next();
});

// Routes
app.use('/api/users', userRoutes);
app.use('/api/products', productRoutes);

// Health check endpoint
app.get('/health', async (req, res) => {
  try {
    const health = await dbManager.healthCheck();
    res.json({ 
      status: 'ok', 
      timestamp: new Date().toISOString(),
      database: health 
    });
  } catch (error) {
    res.status(500).json({ 
      status: 'error', 
      message: error.message 
    });
  }
});

// Error handling middleware
app.use((error, req, res, next) => {
  console.error('Error:', error);
  res.status(500).json({ 
    status: false, 
    message: 'Internal server error' 
  });
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`🚀 Server running on port ${PORT}`);
  console.log(`📊 Health check: http://localhost:${PORT}/health`);
});

📚 Detaylı Kullanım Kılavuzu

Auth Sistemi

JWT Token Oluşturma

import { Auth } from 'core-microservice';

const auth = new Auth();

// Login endpoint
app.post('/api/login', async (req, res) => {
  try {
    const { email, password } = req.body;

    // Kullanıcı doğrulama (kendi mantığınız)
    const user = await validateUser(email, password);

    if (!user) {
      return res.status(401).json({ 
        status: false, 
        message: 'Geçersiz email veya şifre' 
      });
    }

    // JWT token oluştur
    const token = auth.createToken({
      id: user._id,
      email: user.email,
      roles: user.roles || ['User']
    });

    res.json({
      status: true,
      message: 'Giriş başarılı',
      data: {
        token,
        user: {
          id: user._id,
          email: user.email,
          name: user.name,
          roles: user.roles
        }
      }
    });
  } catch (error) {
    res.status(500).json({ 
      status: false, 
      message: 'Giriş yapılamadı' 
    });
  }
});

Token Doğrulama

// Korumalı endpoint
app.get('/api/profile', 
  auth.tokenAuth(), // JWT token kontrolü
  (req, res) => {
    // req.user içinde token'dan gelen bilgiler var
    res.json({
      status: true,
      data: req.user
    });
  }
);

// Role bazlı yetkilendirme
app.get('/api/admin/users',
  auth.tokenAuth(),     // Önce token kontrolü
  auth.roleAuth(['Admin']), // Sonra rol kontrolü
  (req, res) => {
    // Sadece Admin rolüne sahip kullanıcılar erişebilir
    res.json({ message: 'Admin paneli' });
  }
);

// API Key korumalı endpoint
app.get('/api/public/data',
  auth.apiAuth(), // API Key kontrolü
  (req, res) => {
    res.json({ message: 'Public data' });
  }
);

Database Yönetimi

Temel CRUD İşlemleri

// Controller örneği
const userController = {
  // Kullanıcı oluştur
  async createUser(req, res) {
    try {
      const userData = {
        name: req.body.name,
        email: req.body.email,
        password: req.body.password, // Şifre hash'lenmeli
        createdAt: new Date(),
        active: true
      };

      const result = await req.dbManager.insert('users', userData);

      res.status(201).json({
        status: true,
        message: 'Kullanıcı oluşturuldu',
        data: { userId: result.insertedId }
      });
    } catch (error) {
      res.status(500).json({ 
        status: false, 
        message: 'Kullanıcı oluşturulamadı' 
      });
    }
  },

  // Kullanıcıları listele
  async getUsers(req, res) {
    try {
      const { page = 1, limit = 10, search = '' } = req.query;

      const filter = {};
      if (search) {
        filter.$or = [
          { name: { $regex: search, $options: 'i' } },
          { email: { $regex: search, $options: 'i' } }
        ];
      }

      const users = await req.dbManager.find('users', filter, {
        sort: { createdAt: -1 },
        limit: parseInt(limit),
        skip: (parseInt(page) - 1) * parseInt(limit),
        project: { password: 0 } // Şifreleri gizle
      });

      const total = await req.dbManager.count('users', filter);

      res.json({
        status: true,
        data: users,
        pagination: {
          page: parseInt(page),
          limit: parseInt(limit),
          total,
          pages: Math.ceil(total / parseInt(limit))
        }
      });
    } catch (error) {
      res.status(500).json({ 
        status: false, 
        message: 'Kullanıcılar getirilemedi' 
      });
    }
  },

  // Kullanıcı güncelle
  async updateUser(req, res) {
    try {
      const { id } = req.params;
      const updateData = req.body;

      const result = await req.dbManager.update(
        'users', 
        { _id: id }, 
        updateData
      );

      if (result.matchedCount === 0) {
        return res.status(404).json({ 
          status: false, 
          message: 'Kullanıcı bulunamadı' 
        });
      }

      res.json({
        status: true,
        message: 'Kullanıcı güncellendi'
      });
    } catch (error) {
      res.status(500).json({ 
        status: false, 
        message: 'Kullanıcı güncellenemedi' 
      });
    }
  },

  // Kullanıcı sil
  async deleteUser(req, res) {
    try {
      const { id } = req.params;

      const result = await req.dbManager.remove('users', { _id: id });

      if (result.deletedCount === 0) {
        return res.status(404).json({ 
          status: false, 
          message: 'Kullanıcı bulunamadı' 
        });
      }

      res.json({
        status: true,
        message: 'Kullanıcı silindi'
      });
    } catch (error) {
      res.status(500).json({ 
        status: false, 
        message: 'Kullanıcı silinemedi' 
      });
    }
  }
};

Gelişmiş Sorgular

// Aggregate pipeline örneği
async function getUserStats(req, res) {
  try {
    const pipeline = [
      { $match: { active: true } },
      {
        $group: {
          _id: null,
          totalUsers: { $sum: 1 },
          avgAge: { $avg: '$age' },
          userTypes: { $addToSet: '$userType' }
        }
      }
    ];

    const stats = await req.dbManager.aggregate('users', pipeline);

    res.json({
      status: true,
      data: stats[0] || {}
    });
  } catch (error) {
    res.status(500).json({ 
      status: false, 
      message: 'İstatistikler getirilemedi' 
    });
  }
}

// Text search örneği
async function searchUsers(req, res) {
  try {
    const { q } = req.query;

    const users = await req.dbManager.find('users', {
      $text: { $search: q }
    }, {
      sort: { score: { $meta: 'textScore' } },
      limit: 20
    });

    res.json({
      status: true,
      data: users
    });
  } catch (error) {
    res.status(500).json({ 
      status: false, 
      message: 'Arama yapılamadı' 
    });
  }
}

Çoklu Proje Desteği

Farklı Projeler İçin Ayrı Config

// Proje A - Development
const projectAConfig = {
  database: {
    Hosts: ['localhost:27017'],
    Name: 'project_a_dev',
    User: 'dev_user',
    Password: 'dev_password',
    AuthSource: 'admin',
    ReplicaSet: ''
  }
};

// Proje B - Production
const projectBConfig = {
  database: {
    Hosts: ['prod-server-1:27017', 'prod-server-2:27017'],
    Name: 'project_b_prod',
    User: 'prod_user',
    Password: 'prod_password',
    AuthSource: 'admin',
    ReplicaSet: 'rs0'
  }
};

// Her proje için ayrı instance oluştur
const dbManagerA = createDatabaseManager(projectAConfig);
const dbManagerB = createDatabaseManager(projectBConfig);

// Proje A'da işlem yap
await dbManagerA.connect();
await dbManagerA.insert('users', { name: 'User A', project: 'A' });

// Proje B'de işlem yap
await dbManagerB.connect();
await dbManagerB.insert('users', { name: 'User B', project: 'B' });

Environment Variables ile Config

function createConfigFromEnv() {
  return {
    database: {
      Hosts: process.env.MONGO_HOSTS ? process.env.MONGO_HOSTS.split(',') : ['localhost:27017'],
      Name: process.env.MONGO_DB_NAME || 'default_db',
      User: process.env.MONGO_USER || '',
      Password: process.env.MONGO_PASSWORD || '',
      AuthSource: process.env.MONGO_AUTH_SOURCE || 'admin',
      ReplicaSet: process.env.MONGO_REPLICA_SET || ''
    },
    git: {
      name: process.env.GIT_NAME || 'Backup Bot',
      email: process.env.GIT_EMAIL || 'backup@example.com',
      token: process.env.GIT_TOKEN || '',
      repo: process.env.GIT_REPO || 'username/repo'
    }
  };
}

const config = createConfigFromEnv();
const dbManager = createDatabaseManager(config);

🔧 Konfigürasyon

Environment Variables Detayları

# MongoDB Bağlantısı
MONGO_HOSTS=localhost:27017                    # Tek host veya virgülle ayrılmış çoklu host
MONGO_DB_NAME=my_project_db                    # Veritabanı adı
MONGO_USER=my_username                         # MongoDB kullanıcı adı
MONGO_PASSWORD=my_password                     # MongoDB şifresi
MONGO_AUTH_SOURCE=admin                        # Authentication database
MONGO_REPLICA_SET=rs0                          # Replica set adı (opsiyonel)

# JWT Ayarları
JWT_SECRET=my-super-secret-jwt-key             # JWT imzalama anahtarı (güçlü olmalı)
JWT_EXPIRES_IN=48h                             # Token geçerlilik süresi

# API Key
API_KEY=my-api-key-here                        # API anahtarı

# GitHub Backup (Opsiyonel)
GIT_TOKEN=ghp_xxxxxxxxxxxxxxxx                 # GitHub Personal Access Token
GIT_REPO=username/my-repo                      # GitHub repository (username/repo formatında)
GIT_NAME=Backup Bot                            # Backup commit'lerinde görünecek isim
GIT_EMAIL=backup@myproject.com                 # Backup commit'lerinde görünecek email

# Uygulama Ayarları
PORT=3000                                      # Uygulama portu
NODE_ENV=development                           # Ortam (development/production)

Farklı Ortamlar İçin Config

// config/database.js
import dotenv from 'dotenv';

dotenv.config();

const environments = {
  development: {
    database: {
      Hosts: ['localhost:27017'],
      Name: 'dev_db',
      User: '',
      Password: '',
      AuthSource: 'admin',
      ReplicaSet: ''
    }
  },
  staging: {
    database: {
      Hosts: ['staging-server:27017'],
      Name: 'staging_db',
      User: process.env.MONGO_USER,
      Password: process.env.MONGO_PASSWORD,
      AuthSource: 'admin',
      ReplicaSet: ''
    }
  },
  production: {
    database: {
      Hosts: ['prod-server-1:27017', 'prod-server-2:27017'],
      Name: 'prod_db',
      User: process.env.MONGO_USER,
      Password: process.env.MONGO_PASSWORD,
      AuthSource: 'admin',
      ReplicaSet: 'rs0'
    }
  }
};

const currentEnv = process.env.NODE_ENV || 'development';
export default environments[currentEnv];

🛡️ Güvenlik

JWT Güvenliği

// Güvenli JWT kullanımı
const auth = new Auth({
  validateToken: async (token) => {
    try {
      // Token'ı doğrula
      const decoded = jwt.verify(token, process.env.JWT_SECRET);

      // Kullanıcının hala aktif olduğunu kontrol et
      const user = await dbManager.find('users', { 
        _id: decoded.id, 
        active: true 
      });

      return user.length > 0 ? decoded : false;
    } catch (error) {
      return false;
    }
  }
});

API Key Güvenliği

// Güvenli API Key doğrulama
const auth = new Auth({
  validateApiKey: async (apiKey) => {
    // API Key'i veritabanından kontrol et
    const key = await dbManager.find('api_keys', { 
      key: apiKey, 
      active: true,
      expiresAt: { $gt: new Date() }
    });

    return key.length > 0;
  }
});

Rate Limiting

import rateLimit from 'express-rate-limit';

// API Key bazlı rate limiting
const apiKeyLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 dakika
  max: 100, // IP başına maksimum istek
  message: {
    status: false,
    message: 'Çok fazla istek gönderildi. Lütfen daha sonra tekrar deneyin.'
  }
});

app.use('/api/', apiKeyLimiter);

⚡ Performans

Database Optimizasyonu

// İndeks oluşturma
await dbManager.createIndex('users', { email: 1 }, { unique: true });
await dbManager.createIndex('users', { createdAt: -1 });
await dbManager.createIndex('users', { $text: { $search: 'text' } });

// Query optimizasyonu
const users = await dbManager.find('users', 
  { active: true }, // Sadece gerekli alanları seç
  {
    project: { name: 1, email: 1, _id: 0 },
    sort: { createdAt: -1 },
    limit: 20
  }
);

Caching

import { Cache } from 'core-microservice';

const cache = new Cache({
  host: process.env.REDIS_HOST || 'localhost',
  port: process.env.REDIS_PORT || 6379,
  password: process.env.REDIS_PASSWORD
});

// Cache middleware
const cacheMiddleware = async (req, res, next) => {
  const key = `cache:${req.originalUrl}`;
  const cached = await cache.get(key);

  if (cached) {
    return res.json(JSON.parse(cached));
  }

  // Response'u cache'le
  const originalSend = res.json;
  res.json = function(data) {
    cache.set(key, JSON.stringify(data), 300); // 5 dakika
    originalSend.call(this, data);
  };

  next();
};

app.use('/api/public/', cacheMiddleware);

🔍 Sorun Giderme

Yaygın Hatalar ve Çözümleri

1. MongoDB Bağlantı Hatası

// Hata: MongoNetworkError: connect ECONNREFUSED
// Çözüm: MongoDB servisinin çalıştığından emin olun

// MongoDB'yi başlat
sudo systemctl start mongod

// Bağlantıyı test et
const health = await dbManager.healthCheck();
console.log('DB Health:', health);

2. JWT Token Hatası

// Hata: JsonWebTokenError: invalid signature
// Çözüm: JWT_SECRET'ı kontrol edin

// .env dosyasında
JWT_SECRET=your-very-long-and-secure-secret-key

// Token'ı test et
const isValid = auth.verifyToken(token);
console.log('Token valid:', isValid);

3. API Key Hatası

// Hata: API anahtarı gerekli
// Çözüm: Header'da API key gönderin

// Axios ile
axios.get('/api/protected', {
  headers: {
    'x-api-key': 'your-api-key'
  }
});

// Fetch ile
fetch('/api/protected', {
  headers: {
    'x-api-key': 'your-api-key'
  }
});

4. Database Connection Pool Hatası

// Hata: MongoServerSelectionError: connection pool exhausted
// Çözüm: Connection pool ayarlarını optimize edin

const dbManager = createDatabaseManager({
  database: {
    // ... diğer ayarlar
  },
  options: {
    maxPoolSize: 50,        // Maksimum bağlantı sayısı
    minPoolSize: 5,         // Minimum bağlantı sayısı
    maxIdleTimeMS: 300000,  // 5 dakika idle
    serverSelectionTimeoutMS: 5000
  }
});

Debug Modu

// Debug modunu etkinleştir
const dbManager = createDatabaseManager(config);

// Config'i debug et
dbManager.debugConfig();

// Health check
const health = await dbManager.healthCheck();
console.log('Health:', health);

// Connection durumu
console.log('Connected:', dbManager.isConnected());

📋 Örnekler

Tam Örnek Proje

# Örnek projeyi indir
git clone https://github.com/username/core-microservice-examples.git
cd core-microservice-examples

# Bağımlılıkları yükle
npm install

# Environment variables'ları ayarla
cp .env.example .env
# .env dosyasını düzenle

# Uygulamayı başlat
npm start

Örnek Dosyalar

Daha fazla örnek için examples/ dizinini inceleyin:

  • examples/database-usage.js - Database kullanım örnekleri
  • examples/auth-examples.js - Auth sistemi örnekleri
  • examples/multi-project.js - Çoklu proje örnekleri

📚 API Referansı

Database Manager

createDatabaseManager(config)

Yeni bir DatabaseManager instance'ı oluşturur.

Parametreler:

  • config (Object): Database konfigürasyonu

Örnek:

const dbManager = createDatabaseManager({
  database: {
    Hosts: ['localhost:27017'],
    Name: 'my_db',
    User: 'user',
    Password: 'pass',
    AuthSource: 'admin'
  }
});

connect()

Veritabanına bağlanır.

Dönen değer: Promise<[MongoClient, Db]>

find(collection, filter, options)

Dokümanları arar.

Parametreler:

  • collection (String): Koleksiyon adı
  • filter (Object): Sorgu filtresi
  • options (Object): Sorgu seçenekleri

Örnek:

const users = await dbManager.find('users', 
  { active: true },
  {
    sort: { createdAt: -1 },
    limit: 10,
    skip: 0,
    project: { name: 1, email: 1, _id: 0 }
  }
);

insert(collection, document)

Doküman ekler.

Parametreler:

  • collection (String): Koleksiyon adı
  • document (Object): Eklenecek doküman

Dönen değer: Promise<InsertOneResult>

update(collection, filter, update, options)

Dokümanları günceller.

Parametreler:

  • collection (String): Koleksiyon adı
  • filter (Object): Güncellenecek dokümanların filtresi
  • update (Object): Güncelleme verisi
  • options (Object): Güncelleme seçenekleri

remove(collection, filter)

Dokümanları siler.

Parametreler:

  • collection (String): Koleksiyon adı
  • filter (Object): Silinecek dokümanların filtresi

count(collection, filter)

Doküman sayısını döndürür.

Parametreler:

  • collection (String): Koleksiyon adı
  • filter (Object): Sorgu filtresi

aggregate(collection, pipeline)

Aggregation pipeline çalıştırır.

Parametreler:

  • collection (String): Koleksiyon adı
  • pipeline (Array): Aggregation pipeline

healthCheck()

Veritabanı bağlantı durumunu kontrol eder.

Dönen değer: Promise<Object>

Auth Class

apiAuth()

API Key doğrulama middleware'i döndürür.

Dönen değer: Function (Express middleware)

tokenAuth()

JWT token doğrulama middleware'i döndürür.

Dönen değer: Function (Express middleware)

roleAuth(roles)

Role bazlı yetkilendirme middleware'i döndürür.

Parametreler:

  • roles (Array): İzin verilen roller

Dönen değer: Function (Express middleware)

adminAuth()

Admin rolü kontrolü middleware'i döndürür.

Dönen değer: Function (Express middleware)

createToken(payload, options)

JWT token oluşturur.

Parametreler:

  • payload (Object): Token içine gömülecek veriler
  • options (Object): JWT seçenekleri

Dönen değer: String (JWT token)

verifyToken(token)

Token doğrular.

Parametreler:

  • token (String): Doğrulanacak token

Dönen değer: Object|false (Decoded payload veya false)

🤝 Katkıda Bulunma

Geliştirme Ortamı Kurulumu

# Repository'yi fork edin
git clone https://github.com/your-username/core-microservice.git
cd core-microservice

# Bağımlılıkları yükleyin
npm install

# Test'leri çalıştırın
npm test

# Linting yapın
npm run lint

Katkı Süreci

  1. Fork yapın - GitHub'da repository'yi fork edin
  2. Branch oluşturun - git checkout -b feature/amazing-feature
  3. Değişiklikleri commit edin - git commit -m 'Add amazing feature'
  4. Push yapın - git push origin feature/amazing-feature
  5. Pull Request oluşturun - GitHub'da PR açın

Kod Standartları

  • ES6+ syntax kullanın
  • JSDoc yorumları ekleyin
  • Unit test yazın
  • Error handling ekleyin
  • TypeScript desteği düşünün

📄 Lisans

MIT License - detaylar için LICENSE dosyasına bakın.

📞 Destek

Sorularınız İçin

Dokümantasyon

Topluluk

Core Microservice ile hızlı, güvenli ve ölçeklenebilir mikroservisler geliştirin! 🚀