Takip et

Sequelize ile Node.js ve MySQL Kullanımı: Kapsamlı Bir Rehber

Sequelize ile Node.js ve MySQL Kullanımı: Kapsamlı Bir Rehber Node.js, modern web uygulamaları geliştirmek için popüler bir sunucu tarafı Jav

Sequelize ile Node.js ve MySQL Kullanımı: Kapsamlı Bir Rehber

Node.js, modern web uygulamaları geliştirmek için popüler bir sunucu tarafı JavaScript çalışma zamanıdır. Geliştiricilere hızlı, ölçeklenebilir ve olay tabanlı uygulamalar oluşturma imkanı sunar. Veritabanı etkileşimi, hemen hemen her web uygulamasının temel bir parçasıdır ve bu etkileşimleri yönetmek için genellikle bir Nesne İlişkisel Eşleştirici (ORM) kullanılır. Sequelize, Node.js ekosistemindeki en güçlü ve yaygın olarak kullanılan ORM’lerden biridir. Bu makalede, Sequelize’nin Node.js ve MySQL ile nasıl kullanılacağını, kurulumdan ileri seviye konulara kadar detaylı bir şekilde inceleyeceğiz.

Giriş: Sequelize Nedir ve Neden Kullanılır?

Sequelize, Node.js için Promise tabanlı bir ORM’dir. MySQL, PostgreSQL, SQLite ve MSSQL gibi çeşitli ilişkisel veritabanlarını destekler. Bir ORM, uygulama kodundaki nesneler ile veritabanındaki tablolar arasında bir köprü görevi görür. Bu sayede geliştiriciler, doğrudan SQL sorguları yazmak yerine, JavaScript nesneleri ve metotları aracılığıyla veritabanı işlemlerini gerçekleştirebilirler.

Sequelize kullanmanın başlıca avantajları şunlardır:
* Soyutlama: SQL sorguları yazma ihtiyacını azaltır, veritabanı işlemlerini daha anlaşılır ve yönetilebilir JavaScript kodu ile yapmayı sağlar.
* Veritabanı Bağımsızlığı: Uygulama kodu, temel veritabanı sisteminden (MySQL, PostgreSQL vb.) soyutlanır. Veritabanını değiştirmek gerektiğinde, kodda minimal değişiklikler yeterli olur.
* Geliştirme Hızı: Modelleri, ilişkileri ve migrasyonları yönetmek için güçlü araçlar sunarak geliştirme sürecini hızlandırır.
* Güvenlik: SQL enjeksiyonu gibi yaygın güvenlik açıklarına karşı koruma sağlar.
* Bakım Kolaylığı: Kodun daha düzenli ve okunabilir olmasını sağlayarak uzun vadeli bakımı kolaylaştırır.
* Validasyon ve Hook’lar: Veri bütünlüğünü sağlamak için güçlü validasyon mekanizmaları ve yaşam döngüsü hook’ları sunar.

Bu makalede, Node.js projesi içinde Sequelize’yi MySQL veritabanı ile adım adım nasıl kuracağımızı, modelleri nasıl tanımlayacağımızı, CRUD işlemlerini nasıl yapacağımızı, ilişkileri nasıl yöneteceğimizi ve ileri seviye bazı konuları ele alacağız.

Ortam Kurulumu ve Proje Başlatma

Sequelize ile çalışmaya başlamadan önce, sisteminizde Node.js, npm (Node.js ile birlikte gelir) ve MySQL’in kurulu olduğundan emin olmalısınız.

Node.js ve npm Kurulumu

Eğer kurulu değilse, Node.js’in resmi web sitesinden (nodejs.org) indirip kurabilirsiniz. Kurulum tamamlandıktan sonra, terminalinizde aşağıdaki komutları çalıştırarak kurulumu doğrulayabilirsiniz:

node -v
npm -v

MySQL Kurulumu

MySQL’i yerel makinenize kurmak için farklı yollar vardır:
* Doğrudan Kurulum: MySQL’in resmi web sitesinden (mysql.com) indirip işletim sisteminize uygun şekilde kurabilirsiniz.
* XAMPP/WAMP/MAMP: Bu paketler, MySQL’i Apache ve PHP ile birlikte kurarak hızlı bir geliştirme ortamı sağlar.
* Docker: Geliştirme ortamınızı izole etmek için Docker kullanabilirsiniz.

Kurulumdan sonra, MySQL sunucunuzun çalıştığından ve bir kullanıcı adı (genellikle root) ile şifreniz olduğundan emin olun. Ayrıca, Sequelize’nin bağlanacağı bir veritabanı oluşturmanız gerekecektir. Örneğin, my_database adında bir veritabanı oluşturabilirsiniz.

Yeni Bir Node.js Projesi Oluşturma

Boş bir dizin oluşturun ve terminalde o dizine gidin:

mkdir sequelize-mysql-app
cd sequelize-mysql-app

Şimdi, npm init komutu ile yeni bir Node.js projesi başlatın. Bu komut, projeniz için package.json dosyasını oluşturacaktır. Varsayılan değerleri kabul etmek için birçok kez Enter tuşuna basabilirsiniz.

npm init -y

Gerekli Paketlerin Yüklenmesi

Sequelize’yi ve MySQL ile etkileşim kurmak için gerekli sürücüyü yüklemeliyiz. Ayrıca, Sequelize CLI (komut satırı arayüzü) ve ortam değişkenlerini yönetmek için dotenv paketlerini de yükleyeceğiz.

npm install sequelize mysql2 sequelize-cli dotenv

* sequelize: Sequelize ORM’nin ana paketi.
* mysql2: MySQL veritabanı için Node.js sürücüsü. Sequelize, veritabanı ile iletişim kurmak için bu sürücüyü kullanır.
* sequelize-cli: Sequelize komut satırı arayüzü, migrasyonlar, modeller ve seed’ler oluşturmak ve yönetmek için kullanılır.
* dotenv: Ortam değişkenlerini .env dosyasından yüklemek için kullanılır. Hassas bilgileri (veritabanı kimlik bilgileri gibi) koddan ayırmak için önemlidir.

Veritabanı Bağlantısı ve Yapılandırma

Veritabanı bağlantısı, bir Sequelize uygulamasının ilk ve en önemli adımıdır.

.env Dosyasının Oluşturulması

Proje kök dizininizde .env adında bir dosya oluşturun ve veritabanı kimlik bilgilerinizi buraya ekleyin:

DB_DATABASE=my_database
DB_USERNAME=root
DB_PASSWORD=your_mysql_password
DB_HOST=localhost
DB_DIALECT=mysql

your_mysql_password yerine kendi MySQL şifrenizi yazmayı unutmayın.

Sequelize CLI Yapılandırması

sequelize-cli‘yi başlatmak için aşağıdaki komutu kullanın:

npx sequelize-cli init

Bu komut, projenizde config, migrations, models ve seeders adında dizinler oluşturacaktır. config/config.json dosyası, Sequelize CLI’nin veritabanı bağlantı bilgilerini sakladığı yerdir. config/config.json dosyasını dotenv ile entegre etmek için aşağıdaki gibi düzenleyin:

// config/config.json
{
  "development": {
    "username": process.env.DB_USERNAME,
    "password": process.env.DB_PASSWORD,
    "database": process.env.DB_DATABASE,
    "host": process.env.DB_HOST,
    "dialect": process.env.DB_DIALECT
  },
  "test": {
    "username": process.env.DB_USERNAME,
    "password": process.env.DB_PASSWORD,
    "database": process.env.DB_DATABASE + "_test",
    "host": process.env.DB_HOST,
    "dialect": process.env.DB_DIALECT
  },
  "production": {
    "username": process.env.DB_USERNAME,
    "password": process.env.DB_PASSWORD,
    "database": process.env.DB_DATABASE + "_production",
    "host": process.env.DB_HOST,
    "dialect": process.env.DB_DIALECT
  }
}

Bu yapılandırma, ortam değişkenlerini doğrudan kullanır. process.env değişkenlerine erişebilmek için, sunucu tarafı kodunuzun başında dotenv‘i yüklemeniz gerekecektir.

Sequelize Örneğinin Oluşturulması ve Bağlantının Test Edilmesi

Şimdi, Sequelize bağlantısını kuracak bir dosya oluşturalım. Örneğin, src/models/index.js (veya models/index.js eğer src dizini kullanmıyorsanız) adında bir dosya oluşturun:

// models/index.js
require('dotenv').config(); // .env dosyasını yükle

const { Sequelize } = require('sequelize');
const config = require(__dirname + '/../config/config.json').development; // Geliştirme ortamını kullan

const sequelize = new Sequelize(config.database, config.username, config.password, {
  host: config.host,
  dialect: config.dialect,
  logging: false // Konsola SQL sorgularını yazdırmayı kapat
});

// Veritabanı bağlantısını test et
async function testConnection() {
  try {
    await sequelize.authenticate();
    console.log('Veritabanı bağlantısı başarıyla kuruldu.');
  } catch (error) {
    console.error('Veritabanı bağlantısı kurulamadı:', error);
  }
}

testConnection();

// Modelleri dışa aktarmak için bir obje oluşturacağız
const db = {};
db.sequelize = sequelize;
db.Sequelize = Sequelize;

// Modelleri buraya ekleyeceğiz (bir sonraki bölümde)
// db.User = require('./user')(sequelize, Sequelize);

module.exports = db;

Bu dosya, Sequelize örneğini oluşturur ve veritabanı bağlantısını test eder. logging: false seçeneği, Sequelize’nin her SQL sorgusunu konsola yazdırmasını engeller, bu genellikle geliştirme aşamasında faydalı olsa da üretimde kapatılması tercih edilir.

Modelleri Tanımlama

Modeller, veritabanı tablolarınızın JavaScript karşılığıdır. Her model, bir veritabanı tablosunu temsil eder ve o tablodaki her bir sütun, modelin bir niteliği (attribute) olur.

sequelize-cli ile Model Oluşturma

Yeni bir model oluşturmak için sequelize-cli kullanmak en iyi yoldur. Örneğin, User adında bir model oluşturalım:

npx sequelize-cli model:generate --name User --attributes firstName:string,lastName:string,email:string,password:string

Bu komut, models/user.js adında bir model dosyası ve migrations/ dizininde ilgili bir migrasyon dosyası oluşturacaktır.

models/user.js dosyası şöyle görünecektir:

// models/user.js
'use strict';
const {
  Model
} = require('sequelize');
module.exports = (sequelize, DataTypes) => {
  class User extends Model {
    /
     * Helper method for defining associations.
     * This method is not a part of Sequelize lifecycle.
     * The models/index file will call this method automatically.
     */
    static associate(models) {
      // define association here
    }
  }
  User.init({
    firstName: DataTypes.STRING,
    lastName: DataTypes.STRING,
    email: {
      type: DataTypes.STRING,
      unique: true, // E-posta adresinin benzersiz olmasını sağlar
      allowNull: false, // E-posta adresinin boş olmamasını sağlar
      validate: {
        isEmail: true // E-posta formatını doğrular
      }
    },
    password: {
      type: DataTypes.STRING,
      allowNull: false
    }
  }, {
    sequelize,
    modelName: 'User',
    tableName: 'users', // Tablo adını açıkça belirtmek iyi bir pratiktir
    timestamps: true, // createdAt ve updatedAt sütunlarını otomatik ekler
    paranoid: true // deletedAt sütununu ekler ve "soft delete" sağlar
  });
  return User;
};

Model tanımında dikkat edilmesi gerekenler:
* User.init(): Modelin niteliklerini (sütunları) ve seçeneklerini tanımladığımız yerdir.
* DataTypes: Sequelize tarafından sağlanan veri tipleri (STRING, INTEGER, BOOLEAN, DATE vb.).
* Nitelik Seçenekleri:
* unique: true: Sütunun değerlerinin benzersiz olmasını sağlar.
* allowNull: false: Sütunun boş (NULL) olmamasını sağlar.
* validate: { isEmail: true }: Veri girişinde e-posta formatı doğrulaması yapar.
* Model Seçenekleri:
* sequelize: Bağlantı örneği.
* modelName: Modelin adı (PascalCase).
* tableName: Veritabanındaki tablonun adı (kebab-case veya snake_case). Sequelize varsayılan olarak model adının çoğulunu kullanır, ancak açıkça belirtmek daha güvenlidir.
* timestamps: true: createdAt ve updatedAt adında iki sütunu otomatik olarak ekler ve yönetir.
* paranoid: true: deletedAt adında bir sütun ekler. Bir kayıt silindiğinde, aslında veritabanından silinmez, sadece deletedAt sütunu doldurulur (soft delete).

Son olarak, models/index.js dosyasını güncelleyerek oluşturduğunuz modeli yüklemeniz gerekir:

// models/index.js
// ... (mevcut kodlar) ...

const db = {};
db.sequelize = sequelize;
db.Sequelize = Sequelize;

// Modelleri dinamik olarak yükle
fs.readdirSync(__dirname)
  .filter(file => {
    return (
      file.indexOf('.') !== 0 &&
      file !== basename &&
      file.slice(-3) === '.js' &&
      file.indexOf('.test.js') === -1
    );
  })
  .forEach(file => {
    const model = require(path.join(__dirname, file))(sequelize, Sequelize.DataTypes);
    db[model.name] = model;
  });

Object.keys(db).forEach(modelName => {
  if (db[modelName].associate) {
    db[modelName].associate(db);
  }
});

module.exports = db;

Bu kod parçası, models dizinindeki tüm model dosyalarını otomatik olarak yükler ve ilişkileri (associate metodu) tanımlar.

Veritabanı Migrasyonları

Migrasyonlar, veritabanı şemanızdaki değişiklikleri (tablo oluşturma, sütun ekleme/çıkarma vb.) versiyon kontrolü altında tutmanızı sağlayan betiklerdir. Bu, takım ortamında çalışırken veya üretim ortamına dağıtım yaparken çok önemlidir.

Migrasyon Oluşturma ve Çalıştırma

sequelize-cli model:generate komutu, modeli oluştururken aynı zamanda bir migrasyon dosyası da oluşturmuştu. Şimdi bu migrasyon dosyasını inceleyelim:

// migrations/XXXXXXXXXXXXXX-create-user.js
'use strict';
/ @type {import('sequelize-cli').Migration} */
module.exports = {
  async up(queryInterface, Sequelize) {
    await queryInterface.createTable('Users', {
      id: {
        allowNull: false,
        autoIncrement: true,
        primaryKey: true,
        type: Sequelize.INTEGER
      },
      firstName: {
        type: Sequelize.STRING
      },
      lastName: {
        type: Sequelize.STRING
      },
      email: {
        type: Sequelize.STRING,
        unique: true,
        allowNull: false
      },
      password: {
        type: Sequelize.STRING,
        allowNull: false
      },
      createdAt: {
        allowNull: false,
        type: Sequelize.DATE
      },
      updatedAt: {
        allowNull: false,
        type: Sequelize.DATE
      },
      deletedAt: { // paranoid: true olduğu için bu sütunu ekledik
        type: Sequelize.DATE
      }
    });
  },
  async down(queryInterface, Sequelize) {
    await queryInterface.dropTable('Users');
  }
};

* up metodu: Migrasyonun uygulanması durumunda çalışacak kodları içerir (örneğin, tablo oluşturma).
* down metodu: Migrasyonun geri alınması durumunda çalışacak kodları içerir (örneğin, tablo silme).

Migrasyonu çalıştırmak ve Users tablosunu veritabanında oluşturmak için:

npx sequelize-cli db:migrate

Bu komut, veritabanınızda SequelizeMeta adında bir tablo oluşturacak ve uygulanan migrasyonları kaydedecektir.

Migrasyonu Geri Alma

Eğer bir migrasyonu geri almak isterseniz:

npx sequelize-cli db:migrate:undo # Son migrasyonu geri alır
npx sequelize-cli db:migrate:undo:all # Tüm migrasyonları geri alır

Temel CRUD İşlemleri

CRUD (Create, Read, Update, Delete) işlemleri, bir uygulamanın veritabanı ile etkileşiminin temelini oluşturur.

Veri Ekleme (Create)

Bir model örneği oluşturmak ve veritabanına kaydetmek için create() metodunu kullanırız:

// app.js veya bir controller dosyası
const db = require('./models'); // models/index.js dosyasını import et

async function createUser() {
  try {
    const newUser = await db.User.create({
      firstName: 'John',
      lastName: 'Doe',
      email: 'john.doe@example.com',
      password: 'hashedpassword123' // Şifre hashlenmelidir!
    });
    console.log('Yeni kullanıcı oluşturuldu:', newUser.toJSON());

    // Birden fazla kayıt ekleme
    await db.User.bulkCreate([
      { firstName: 'Jane', lastName: 'Doe', email: 'jane.doe@example.com', password: 'hashedpassword456' },
      { firstName: 'Peter', lastName: 'Jones', email: 'peter.jones@example.com', password: 'hashedpassword789' }
    ]);
    console.log('Birden fazla kullanıcı eklendi.');

  } catch (error) {
    console.error('Kullanıcı oluşturulurken hata oluştu:', error);
  }
}

createUser();

bulkCreate() metodu, tek seferde birden fazla kayıt eklemek için kullanılır ve genellikle daha performanslıdır.

Veri Okuma (Read)

Veritabanından veri okumak için çeşitli metotlar mevcuttur:

async function readUsers() {
  try {
    // Tüm kullanıcıları getir
    const allUsers = await db.User.findAll();
    console.log('Tüm kullanıcılar:', allUsers.map(user => user.toJSON()));

    // Belirli koşullara göre kullanıcıları getir (WHERE clause)
    const john = await db.User.findOne({
      where: {
        firstName: 'John'
      }
    });
    console.log('John adında kullanıcı:', john ? john.toJSON() : 'Bulunamadı');

    // ID'ye göre kullanıcıyı getir
    const userById = await db.User.findByPk(1);
    console.log('ID 1 olan kullanıcı:', userById ? userById.toJSON() : 'Bulunamadı');

    // Sadece belirli sütunları seç (attributes) ve sırala (order)
    const limitedUsers = await db.User.findAll({
      attributes: ['firstName', 'email'],
      where: {
        lastName: 'Doe'
      },
      order: [['firstName', 'ASC']],
      limit: 1, // Sadece 1 kayıt getir
      offset: 0 // İlk kayıttan başla
    });
    console.log('Sınırlı kullanıcılar:', limitedUsers.map(user => user.toJSON()));

  } catch (error) {
    console.error('Kullanıcılar okunurken hata oluştu:', error);
  }
}

readUsers();

* findAll(): Belirtilen koşullara uyan tüm kayıtları getirir.
* findOne(): Belirtilen koşullara uyan ilk kaydı getirir.
* findByPk(): Birincil anahtara (Primary Key) göre kaydı getirir.
* Seçenekler:
* where: SQL WHERE koşulunu tanımlar.
* attributes: Sadece belirli sütunları seçmenizi sağlar.
* order: Sonuçları belirli bir sütuna göre sıralar.
* limit: Getirilecek kayıt sayısını sınırlar.
* offset: Belirtilen sayıdaki kaydı atlayarak sonraki kayıtlardan başlar (sayfalama için kullanılır).

Veri Güncelleme (Update)

Kayıtları güncellemek için update() metodunu veya bir model örneği üzerinde save() metodunu kullanabiliriz:

async function updateUser() {
  try {
    // Belirli koşullara göre güncelleme
    const [affectedRows] = await db.User.update(
      { lastName: 'Smith' },
      {
        where: {
          firstName: 'John'
        }
      }
    );
    console.log(${affectedRows} adet kullanıcı güncellendi.);

    // Bir model örneğini güncelleyip kaydetme
    const jane = await db.User.findOne({ where: { email: 'jane.doe@example.com' } });
    if (jane) {
      jane.email = 'jane.smith@example.com';
      await jane.save(); // Güncellenen örneği veritabanına kaydet
      console.log('Jane kullanıcısının e-postası güncellendi:', jane.toJSON());
    }

  } catch (error) {
    console.error('Kullanıcı güncellenirken hata oluştu:', error);
  }
}

updateUser();

update() metodu, where koşulu ile birden fazla kaydı aynı anda güncelleyebilir. save() metodu ise, önceden yüklenmiş bir model örneğinin niteliklerini değiştirdikten sonra veritabanına kaydeder.

Veri Silme (Delete)

Kayıtları silmek için destroy() metodunu kullanırız:

async function deleteUser() {
  try {
    // Belirli koşullara göre silme (soft delete eğer paranoid: true ise)
    const deletedRows = await db.User.destroy({
      where: {
        email: 'peter.jones@example.com'
      }
    });
    console.log(${deletedRows} adet kullanıcı silindi (soft delete).);

    // Eğer gerçekten silmek isterseniz (paranoid: true olsa bile)
    const reallyDeletedRows = await db.User.destroy({
      where: {
        email: 'john.doe@example.com'
      },
      force: true // Gerçekten siler, deletedAt sütununu kullanmaz
    });
    console.log(${reallyDeletedRows} adet kullanıcı kalıcı olarak silindi.);

  } catch (error) {
    console.error('Kullanıcı silinirken hata oluştu:', error);
  }
}

deleteUser();

Eğer modelinizde paranoid: true ayarı varsa, destroy() metodu kaydı gerçekten silmek yerine deletedAt sütununu doldurur. Kalıcı silme işlemi için force: true seçeneğini kullanmanız gerekir.

Modeller Arası İlişkiler (Associations)

Gerçek dünya uygulamalarında, veritabanı tabloları genellikle birbiriyle ilişkilidir. Sequelize, bu ilişkileri tanımlamak ve yönetmek için güçlü bir yapı sunar.

İlişki Türleri

Sequelize dört ana ilişki türünü destekler:

1. Bire Bir (One-to-One): Bir modelin bir diğer modelle sadece bir ilişkisi vardır. Örneğin, User‘ın bir Profile‘ı olabilir ve bir Profile sadece bir User‘a ait olabilir.
* hasOne(): Kaynağın hedefle birebir ilişkisi olduğunu belirtir.
* belongsTo(): Hedefin kaynakla birebir ilişkisi olduğunu belirtir.

2. Bire Çok (One-to-Many): Bir modelin birden çok diğer modelle ilişkisi vardır, ancak diğer modelin sadece bir ilişkisi vardır. Örneğin, bir User‘ın birden çok Post‘u olabilir, ancak bir Post sadece bir User‘a aittir.
* hasMany(): Kaynağın hedefle bire çok ilişkisi olduğunu belirtir.
* belongsTo(): Hedefin kaynakla bire çok ilişkisi olduğunu belirtir (kaynağın birincil anahtarını kendi tablosunda tutar).

3. Çoka Çok (Many-to-Many): Her iki modelin de birden çok diğer modelle ilişkisi vardır. Örneğin, bir Post‘un birden çok Tag‘i olabilir ve bir Tag birden çok Post‘ta bulunabilir. Bu tür ilişkiler için genellikle bir ara tablo (junction table) kullanılır.
* belongsToMany(): Her iki modelin de çoka çok ilişkisi olduğunu belirtir.

İlişkileri Tanımlama

İlişkiler, modellerin associate metodunda tanımlanır.

Örnek: User ve Post modelleri (Bire Çok İlişki)

Önce Post modelini oluşturalım:

npx sequelize-cli model:generate --name Post --attributes title:string,content:text,userId:integer

models/post.js dosyasını güncelleyelim:

// models/post.js
'use strict';
const {
  Model
} = require('sequelize');
module.exports = (sequelize, DataTypes) => {
  class Post extends Model {
    static associate(models) {
      // Bir Post bir User'a aittir (belongsTo)
      Post.belongsTo(models.User, {
        foreignKey: 'userId', // Post tablosundaki foreign key
        as: 'author' // İlişkinin takma adı
      });
    }
  }
  Post.init({
    title: DataTypes.STRING,
    content: DataTypes.TEXT,
    userId: {
      type: DataTypes.INTEGER,
      allowNull: false // Bir post'un mutlaka bir yazarı olmalı
    }
  }, {
    sequelize,
    modelName: 'Post',
    tableName: 'posts',
    timestamps: true,
    paranoid: true
  });
  return Post;
};

Şimdi User modeline hasMany ilişkisini ekleyelim (models/user.js):

// models/user.js
'use strict';
const {
  Model
} = require('sequelize');
module.exports = (sequelize, DataTypes) => {
  class User extends Model {
    static associate(models) {
      // Bir User'ın birden çok Post'u vardır (hasMany)
      User.hasMany(models.Post, {
        foreignKey: 'userId',
        as: 'posts'
      });
    }
  }
  // ... (User.init kısmı) ...
  return User;
};

Yeni posts tablosunu oluşturmak için migrasyonu çalıştırın:

npx sequelize-cli db:migrate

İlişkili Verileri Sorgulama (include)

İlişkili verileri sorgulamak için include seçeneğini kullanırız:

async function queryAssociations() {
  try {
    // Bir kullanıcı ve onun tüm gönderilerini getir
    const userWithPosts = await db.User.findByPk(1, {
      include: [{
        model: db.Post,
        as: 'posts' // User modelindeki 'as' değeri ile eşleşmeli
      }]
    });
    console.log('Kullanıcı ve gönderileri:', userWithPosts ? userWithPosts.toJSON() : 'Bulunamadı');

    // Bir gönderi ve onun yazarını getir
    const postWithAuthor = await db.Post.findOne({
      where: { title: 'İlk Gönderim' },
      include: [{
        model: db.User,
        as: 'author', // Post modelindeki 'as' değeri ile eşleşmeli
        attributes: ['firstName', 'lastName', 'email'] // Sadece belirli yazar bilgilerini getir
      }]
    });
    console.log('Gönderi ve yazarı:', postWithAuthor ? postWithAuthor.toJSON() : 'Bulunamadı');

    // İç içe include (örneğin, User -> Post -> Tag)
    // Bunun için Tag modelini ve Post-Tag Many-to-Many ilişkisini tanımlamamız gerekir.
  } catch (error) {
    console.error('İlişkili veriler sorgulanırken hata oluştu:', error);
  }
}

// Önce bazı örnek veriler oluşturalım
async function createSampleData() {
  await db.User.create({ firstName: 'Alice', lastName: 'Wonder', email: 'alice@example.com', password: 'password1' });
  await db.Post.create({ title: 'İlk Gönderim', content: 'Bu benim ilk gönderim.', userId: 1 });
  await db.Post.create({ title: 'İkinci Gönderim', content: 'Bu benim ikinci gönderim.', userId: 1 });
}

// createSampleData().then(() => queryAssociations());

include seçeneği, ilişkili modelleri sorguya dahil etmenizi sağlar. as anahtarı, ilişkili modelin nasıl adlandırılacağını belirtir. attributes ile sadece belirli sütunları seçebilirsiniz.

Gelişmiş Konular

Sequelize, uygulamanızın daha sağlam ve esnek olmasını sağlayacak birçok gelişmiş özellik sunar.

Validasyonlar

Model seviyesinde validasyonlar, veritabanına kaydedilmeden önce verinin geçerliliğini kontrol etmenizi sağlar.

// models/user.js (güncellenmiş)
// ...
  User.init({
    firstName: {
      type: DataTypes.STRING,
      allowNull: false,
      validate: {
        notEmpty: { msg: 'Ad alanı boş bırakılamaz.' },
        len: { args: [2, 50], msg: 'Ad en az 2, en fazla 50 karakter olmalıdır.' }
      }
    },
    email: {
      type: DataTypes.STRING,
      unique: { msg: 'Bu e-posta adresi zaten kullanımda.' },
      allowNull: false,
      validate: {
        isEmail: { msg: 'Geçerli bir e-posta adresi giriniz.' }
      }
    },
    password: {
      type: DataTypes.STRING,
      allowNull: false,
      validate: {
        len: { args: [6, 255], msg: 'Şifre en az 6 karakter olmalıdır.' }
      }
    }
  }, {
    sequelize,
    modelName: 'User',
    tableName: 'users'
  });
// ...

Sequelize birçok yerleşik validatör sunar (notEmpty, isEmail, len, isNumeric vb.). Ayrıca kendi özel validasyonlarınızı da yazabilirsiniz.

Hook’lar (Yaşam Döngüsü Olayları)

Hook’lar, bir modelin yaşam döngüsündeki belirli olaylar (oluşturma, güncelleme, silme vb.) sırasında kod çalıştırmanıza olanak tanır. Örneğin, şifreleri veritabanına kaydetmeden önce hashlemek için kullanılabilir.

// models/user.js (güncellenmiş)
const bcrypt = require('bcrypt'); // npm install bcrypt

// ...
  User.init({
    // ... (nitelikler) ...
  }, {
    sequelize,
    modelName: 'User',
    tableName: 'users',
    timestamps: true,
    paranoid: true,
    hooks: {
      beforeCreate: async (user) => {
        if (user.password) {
          const salt = await bcrypt.genSalt(10);
          user.password = await bcrypt.hash(user.password, salt);
        }
      },
      beforeUpdate: async (user) => {
        if (user.changed('password')) { // Sadece şifre değiştiyse hashle
          const salt = await bcrypt.genSalt(10);
          user.password = await bcrypt.hash(user.password, salt);
        }
      }
    }
  });
// ...

Bu örnekte, beforeCreate ve beforeUpdate hook’ları kullanılarak, bir kullanıcı oluşturulmadan veya güncellenmeden önce şifresi bcrypt ile hashlenir.

Scope’lar

Scope’lar, model üzerinde tekrar kullanılabilir sorgu tanımlamalarıdır. Belirli koşullara göre sıkça kullanılan sorguları soyutlamanıza yardımcı olur.

// models/post.js (güncellenmiş)
// ...
  class Post extends Model {
    // ... (associate metodu) ...
  }
  Post.init({
    // ... (nitelikler) ...
  }, {
    sequelize,
    modelName: 'Post',
    tableName: 'posts',
    timestamps: true,
    paranoid: true,
    scopes: {
      published: {
        where: {
          publishedAt: {
            [Sequelize.Op.ne]: null // publishedAt null olmayan gönderiler
          }
        }
      },
      recent: {
        order: [['createdAt', 'DESC']],
        limit: 5
      },
      withAuthor: {
        include: [{
          model: sequelize.models.User,
          as: 'author',
          attributes: ['firstName', 'lastName']
        }]
      }
    }
  });
// ...

// Kullanımı:
async function getScopedPosts() {
  const publishedPosts = await db.Post.scope('published').findAll();
  const recentPosts = await db.Post.scope('recent').findAll();
  const recentPublishedPostsWithAuthor = await db.Post.scope('published', 'recent', 'withAuthor').findAll();
}

İşlemler (Transactions)

İşlemler, birden fazla veritabanı işlemini tek bir atomik birim olarak yürütmenizi sağlar. Tüm işlemler başarılı olursa değişiklikler kalıcı olur, aksi takdirde tüm değişiklikler geri alınır (rollback).

async function transferMoney(fromUserId, toUserId, amount) {
  const t = await db.sequelize.transaction(); // Yeni bir işlem başlat

  try {
    const fromUser = await db.User.findByPk(fromUserId, { transaction: t });
    const toUser = await db.User.findByPk(toUserId, { transaction: t });

    if (!fromUser || !toUser) {
      throw new Error('Kullanıcı bulunamadı.');
    }
    if (fromUser.balance < amount) { // balance sütunu olduğunu varsayalım
      throw new Error('Yetersiz bakiye.');
    }

    await fromUser.update({ balance: fromUser.balance - amount }, { transaction: t });
    await toUser.update({ balance: toUser.balance + amount }, { transaction: t });

    await t.commit(); // İşlemi onayla
    console.log('Para transferi başarıyla gerçekleşti.');
  } catch (error) {
    await t.rollback(); // Hata durumunda işlemi geri al
    console.error('Para transferi sırasında hata oluştu:', error.message);
  }
}

Raw Queries (Ham Sorgular)

Sequelize, çoğu durumda ORM metodları ile yeterli olsa da, bazen çok karmaşık veya performans kritik sorgular için ham SQL yazmanız gerekebilir.

async function rawQueryExample() {
  try {
    const [results, metadata] = await db.sequelize.query("SELECT * FROM Users WHERE email LIKE '%example.com%'");
    console.log('Ham sorgu sonuçları:', results);

    // Bir INSERT sorgusu çalıştırma
    await db.sequelize.query("INSERT INTO Posts (title, content, userId, createdAt, updatedAt) VALUES (?, ?, ?, NOW(), NOW())", {
      replacements: ['Yeni Başlık', 'Yeni İçerik', 1],
      type: db.sequelize.QueryTypes.INSERT
    });
    console.log('Ham INSERT sorgusu çalıştırıldı.');

  } catch (error) {
    console.error('Ham sorgu çalıştırılırken hata oluştu:', error);
  }
}

replacements seçeneği, SQL enjeksiyonuna karşı koruma sağlamak için kullanılır. QueryTypes ile sorgunun türünü belirtebilirsiniz.

Seed'ler (Veri Tohumlama)

Seed'ler, veritabanınıza başlangıç verileri (örneğin, test verileri veya varsayılan ayarlar) eklemek için kullanılır.

npx sequelize-cli seed:generate --name demo-users

seeders/XXXXXXXXXXXXXX-demo-users.js dosyasını düzenleyin:

// seeders/XXXXXXXXXXXXXX-demo-users.js
'use strict';

/ @type {import('sequelize-cli').Migration} */
module.exports = {
  async up (queryInterface, Sequelize) {
    await queryInterface.bulkInsert('Users', [{
      firstName: 'Demo',
      lastName: 'User',
      email: 'demo@example.com',
      password: 'demopassword', // Gerçek uygulamada hashlenmiş şifre olmalı
      createdAt: new Date(),
      updatedAt: new Date()
    }, {
      firstName: 'Test',
      lastName: 'User',
      email: 'test@example.com',
      password: 'testpassword',
      createdAt: new Date(),
      updatedAt: new Date()
    }], {});
  },

  async down (queryInterface, Sequelize) {
    await queryInterface.bulkDelete('Users', null, {});
  }
};

Seed'leri çalıştırmak için:

npx sequelize-cli db:seed:all

Seed'leri geri almak için:

npx sequelize-cli db:seed:undo:all

Hata Yönetimi ve Loglama

Hata yönetimi, sağlam bir uygulamanın olmazsa olmazıdır. Sequelize, çeşitli hata türleri fırlatır ve bunları try-catch blokları ile yakalamak önemlidir.

async function handleErrors() {
  try {
    // Benzersiz e-posta kısıtlamasını ihlal eden bir kullanıcı oluşturmaya çalışalım
    await db.User.create({
      firstName: 'John',
      lastName: 'Doe',
      email: 'john.doe@example.com', // Bu e-posta zaten var
      password: 'password123'
    });
  } catch (error) {
    if (error.name === 'SequelizeUniqueConstraintError') {
      console.error('Hata: Bu e-posta adresi zaten kullanımda.');
    } else if (error.name === 'SequelizeValidationError') {
      console.error('Validasyon hatası:', error.errors.map(err => err.message));
    } else {
      console.error('Beklenmeyen bir hata oluştu:', error);
    }
  }
}

Sequelize'nin logging seçeneği ile SQL sorgularını ve diğer bilgileri loglayabilirsiniz. Kendi özel logger'ınızı da tanımlayabilirsiniz.

// models/index.js (güncellenmiş)
const sequelize = new Sequelize(config.database, config.username, config.password, {
  host: config.host,
  dialect: config.dialect,
  logging: console.log // SQL sorgularını konsola yazdır
  // logging: (msg) => myCustomLogger.info(msg) // Özel bir logger kullan
});

En İyi Uygulamalar ve İpuçları

* Proje Yapısı: Modelleri, migrasyonları, konfigürasyonları ve seed'leri ilgili dizinlerde tutmak projenizi düzenli tutar. Genellikle bir src dizini altında controllers, services, routes, models gibi ayrı dizinler oluşturulur.
* Güvenlik:
* Hassas bilgileri (veritabanı şifreleri) .env dosyalarında tutun ve .gitignore dosyasına ekleyerek versiyon kontrolüne dahil etmeyin.
* Ham SQL sorguları kullanırken replacements veya bind seçeneklerini kullanarak SQL enjeksiyonuna karşı koruma sağlayın.
* Şifreleri her zaman hashleyerek saklayın.
* Performans:
* Gereksiz yere tüm verileri çekmek yerine attributes ile sadece ihtiyacınız olan sütunları seçin.
* İlişkili verileri sorgularken include seçeneğini dikkatli kullanın. Çok fazla iç içe include sorgu performansını düşürebilir (N+1 problemi). Gerekirse eager loading (include ile önden yükleme) yerine lazy loading (ihtiyaç anında yükleme) kullanın.
* Sık sorgulanan sütunlara indeks ekleyin.
* Büyük veri kümeleriyle çalışırken limit ve offset ile sayfalama uygulayın.
* Bakım:
* Migrasyonları düzenli olarak kullanın ve her şema değişikliği için yeni bir migrasyon oluşturun.
* Model tanımında tableName ve ilişkilerde as seçeneklerini açıkça belirtmek kodun okunabilirliğini artırır.
* Validasyonları model seviyesinde uygulayarak veri bütünlüğünü sağlayın.

Sonuç

Sequelize, Node.js geliştiricileri için güçlü, esnek ve kullanımı kolay bir ORM'dir. Bu makalede, Sequelize'nin Node.js ve MySQL ile nasıl kurulacağını, modellerin, migrasyonların ve ilişkilerin nasıl tanımlanacağını, temel CRUD işlemlerinin nasıl yapılacağını ve validasyonlar, hook'lar, işlemler, scope'lar gibi ileri seviye konuları detaylı bir şekilde inceledik.

Sequelize'yi kullanarak, veritabanı etkileşimlerinizi daha soyut, güvenli ve yönetilebilir bir şekilde gerçekleştirebilirsiniz. Bu da Node.js uygulamalarınızın geliştirme sürecini hızlandırır, kod kalitesini artırır ve uzun vadeli bakımı kolaylaştırır. Umarım bu kapsamlı rehber, Sequelize ile Node.js ve MySQL kullanarak güçlü uygulamalar geliştirmeniz için sağlam bir temel oluşturmuştur.

Yorumlar
İçeriği beğendiniz mi? Bir tartışma başlatın veya görüşlerinizi paylaşın.
Yorum Yaz

Bir yanıt yazın

E-posta adresiniz yayınlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir

Gönder

E-posta Bülteni
Yazılım Topluluğuna Katılın
En son güncellemeleri, yaratıcı ipuçlarını ve özel kaynakları doğrudan e-posta kutunuza alın. Tasarım ve inovasyonun geleceğini birlikte keşfedelim.
Mobil sürümden çık