Node.js ve MySQL ile Sequelize Nasıl Kullanılır

Yazar, Write for Donations programı kapsamında bağış almak için Açık İnternet/Özgür İfade Fonu'nu seçti.

Giriş

Sequelize, MySQL, MariaDB, SQLite, PostgreSQL veritabanları ve daha fazlasıyla çalışmayı kolaylaştıran Node.js tabanlı bir Nesne İlişkisel Eşleyici (ORM) dir. Bir Nesne İlişkisel Eşleyici, verileri nesneler olarak temsil ederek veritabanı kayıtlarını yönetme gibi işlevleri yerine getirir. Sequelize, mevcut veritabanı şemalarını yeni sürümlere dönüştürebilen güçlü bir migrasyon mekanizmasına sahiptir. Genel olarak, Sequelize veritabanı senkronizasyonu, eager loading, ilişkiler, işlemler ve veritabanı migrasyonları için mükemmel destek sunarken, geliştirme süresini kısaltır ve SQL enjeksiyonlarını önler.

Bu öğreticide, yerel geliştirme ortamınızda MySQL ile Sequelize kuracak ve yapılandıracaksınız. Daha sonra, veritabanları ve modeller oluşturmak için Sequelize'i kullanacak ve insert, select ve delete işlemlerini gerçekleştireceksiniz. Ardından, bir-bir, bir-çok ve çok-çok ilişkiler için Sequelize ilişkilerini oluşturacaksınız. Son olarak, dizi ve nesne değişiklikleri için Sequelize ham sorguları oluşturacaksınız. Bu temellere ek olarak, öğretici ayrıca ortam değişkenleri kullanarak güvenli veritabanı yapılandırmasını, şema değişikliklerini güvenli bir şekilde yönetmeyi (migrations aracılığıyla) ve sorun giderme ve performans optimizasyonu için en iyi uygulamaları da kapsıyor.

Önkoşullar

Bu eğitimi tamamlamak için ihtiyacınız olacak:

• Node.js çalıştıran bir geliştirme ortamı. Bunu kurmak için, işletim sisteminiz için Node.js'i Kurma ve Yerel Geliştirme Ortamı Oluşturma rehberini takip edin.
• Çalışma ortamınıza MySQL kurulu olmalıdır. Kullanıcı oluşturma adımlarını da içeren ortamınıza uygun MySQL Kurulum Kılavuzu'nu takip edin.
• JavaScript ve MySQL sorgularına aşina olmak, bunu How To Code in JavaScript serisi ve An Introduction to Queries in MySQL öğreticisi ile geliştirebilirsiniz.
• İlişkisel veritabanı kavramlarını temel düzeyde anlamak, bunu 'İlişkisel Veritabanlarını Anlamak' adlı öğreticide bulabilirsiniz.

Bu eğitim Node.js sürüm v24.11.1 ve npm sürüm 11.6.2 üzerinde test edilmiştir.

Sequelize Kurulumu ve Yapılandırması

Bu adımda, Sequelize'i kuracak ve MySQL veritabanınıza bağlantıyı oluşturacaksınız. Bunu yapmak için öncelikle bir Node.js uygulaması oluşturacaksınız. Ardından, Sequelize'i kuracak, MySQL veritabanını yapılandıracak ve basit bir uygulama geliştireceksiniz.

Sequelize Kurulumu

Öncelikle bir proje klasörü oluşturun. Bu örnekte hello-world kullanabilirsiniz. Klasör oluşturulduktan sonra, terminali kullanarak klasöre gidin:

mkdir hello-world

cd hello-world

Sonra, aşağıdaki komutu kullanarak örnek bir Node.js uygulaması oluşturun:

npm init

Sonraki adımda bazı kurulum sorularını yanıtlamanız istenecektir. Yapılandırmanız için aşağıdaki çıktıyı kullanın. Görüntülenen varsayılan değeri kullanmak için ENTER tuşuna basın ve ana giriş noktasını server.js olarak ayarladığınızdan emin olun. Bu, bakımı kolay bir proje yapısı oluşturur.

Çıktı aşağıdaki gibi olacaktır ve bu, package.json dosyasını dolduracaktır:

{
  "name": "hello-world",
  "version": "1.0.0",
  "description": "",
  "main": "server.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC"
}

Sonra, proje klasörünün içinde boş bir server.js dosyası oluşturun:

touch server.js

Önceki adımları takip ettikten sonra, son klasör yapınız şu şekilde görünecektir:

hello-world/
├─ package.json
├─ server.js

Artık Sequelize'i aşağıdaki komutla yükleyebilirsiniz:

npm i sequelize

Bu güncellemelerden sonra, package.json dosyası artık şöyle görünüyor:

{
  "name": "hello-world",
  "version": "1.0.0",
  "description": "",
  "main": "server.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "node server.js"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "sequelize": "^6.37.7"
  }
}

dependencies bölümünde artık bir Sequelize bağımlılığı göreceksiniz.

Projeyi kurdunuz ve Sequelize'i yüklediniz. Sıradaki adım, bağlanacağınız örnek bir veritabanı oluşturmak olacak.

Örnek Bir Veritabanı Oluşturma

Önkoşullar kapsamında MySQL’i kurup yapılandırdınız, bu süreç bir kullanıcı oluşturmayı da içeriyordu. Şimdi boş bir veritabanı oluşturacaksınız.

Bunu yapmak için önce MySQL örneğinize giriş yapmanız gerekir. Uzaktan çalışıyorsanız tercih ettiğiniz aracı kullanabilirsiniz. Yerel olarak çalışan bir MySQL örneği kullanıyorsanız, MySQL kullanıcı adınızı your_username ile değiştirerek aşağıdaki komutu kullanabilirsiniz:

mysql -u your_username -p

-u kullanıcı adıdır ve hesap bir şifreyle korunduysa -p seçeneği kullanılır.

MySQL sunucusu veritabanı şifrenizi isteyecektir. Şifrenizi girin ve ENTER tuşuna basın.

Giriş yaptıktan sonra, aşağıdaki komutu kullanarak hello_world_db adlı bir veritabanı oluşturun:

CREATE DATABASE hello_world_db;

Veritabanını başarıyla oluşturup oluşturmadığınızı doğrulamak için bu komutu kullanabilirsiniz:

SHOW DATABASES;

Çıktınız buna benzer olacaktır:

+--------------------+
|      Database      |
+--------------------+
| hello_world_db     |
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+

Örnek veritabanını oluşturduktan sonra, MySQL sunucusundan bağlantıyı kesin:

mysql> QUIT

Şimdi, seçtiğiniz veritabanı için manuel bir sürücü yüklemeniz gerekiyor. Sequelize sadece ORM özellikleri sunduğu için, dahili veritabanı sürücüleri içermez. Bu nedenle, tercihinize göre sürücüleri yüklemeniz gerekecek. Bunu yapmak için, terminali kullanarak proje dizinine gidin ve aşağıdaki komutla MySQL sürücüsünü projeye yükleyin:

npm install --save mysql2

Bu durumda, MySQL için sürücüyü kullanıyorsunuz.

Artık bir örnek veritabanınız olduğuna göre, veritabanı bağlantısına sahip ilk Sequelize uygulamanızı oluşturabilirsiniz.

MySQL Veritabanına Bağlanıyor

Bu bölümde, Node.js uygulamasını Sequelize kullanarak MySQL veritabanına bağlayacaksınız.

Veritabanına bağlanmak için, nano veya tercih ettiğiniz kod editörü ile server.js dosyasını düzenlemeye açın:

nano server.js

Burada, uygulamanızda bir Sequelize örneği kullanarak bir veritabanı bağlantısı oluşturacaksınız. new Sequelize() yönteminde, MySQL sunucu parametrelerini ve veritabanı kimlik bilgilerini aşağıdaki şekilde geçin; DATABASE_USERNAME ve DATABASE_PASSWORD yerini MySQL kullanıcı bilgileriniz ile değiştirin:

const Sequelize = require("sequelize");
const sequelize = new Sequelize(
 'hello_world_db',
 'DATABASE_USERNAME',
 'DATABASE_PASSWORD',
  {
    host: 'DATABASE_HOST',
    dialect: 'mysql'
  }
);

host, MySQL sunucusunun barındığı yerdir, bu yüzden bir sunucu URL'si veya IP adresi sağlamanız gerekir. Yerel olarak kurulu bir MySQL sunucusu kullanıyorsanız, DATABASE_HOST değerini localhost veya 127.0.0.1 ile değiştirebilirsiniz.

Benzer şekilde, bir uzak sunucu kullanıyorsanız, veritabanı bağlantı değerlerini uygun uzak sunucu bilgileriyle buna göre değiştirdiğinizden emin olun.

Sonraki adımda, uygulamaya bir veritabanı bağlantısı oluşturmak için söz sözü vaade dayalı authenticate() yöntemini çağırın. Bunu yapmak için, aşağıdaki kod bloğunu server.js dosyanıza ekleyin:

...

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

authenticate() yöntemi, veritabanına bağlanmak ve verilen kimlik bilgilerinin doğru olup olmadığını test etmek için kullanılır. Burada, veritabanı bağlantısı varsayılan olarak açıktır ve aynı bağlantı tüm sorgular için kullanılabilir. Bağlantıyı kapatmanız gerektiğinde, bu authenticate() çağrısından sonra sequelize.close() yöntemini çağırın. Sequelize hakkında daha fazla bilgi edinmek için lütfen onların başlangıç kılavuzuna bakın.

Sequelize tarafından sağlanan yöntemlerin çoğu asenkroniktir. Bu, asenkron bir kod bloğu çalışırken uygulamanızda diğer işlemleri çalıştırabileceğiniz anlamına gelir. Ayrıca, asenkron kod bloğu başarıyla çalıştırıldıktan sonra, bir sürecin sonunda döndürülen değer olan promise (söz) döner. Bu nedenle, asenkron kod bloklarında işlenmiş veriyi döndürmek için then(), catch() ve finally() yöntemlerini kullanabilirsiniz.

Bu noktada, server.js dosyası aşağıdaki gibi görünecektir:

const Sequelize = require("sequelize");

const sequelize = new Sequelize(
   'hello_world_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

Dosyanızı kaydedin ve kapatın.

Proje dizininde, server.js uygulamasını aşağıdaki komutu çalıştırarak başlatın:

node server.js

Çıktınız şöyle görünecek:

Connection has been established successfully!

Veritabanı bağlantısını başarıyla oluşturdunuz.

Bu adımda, Sequelize'i yüklediniz, örnek bir veritabanı oluşturdunuz ve Sequelize'i veritabanına bağlanmak için kullandınız. Bir sonraki adımda, Sequelize'deki modellerle çalışacaksınız.

Sequelize Kullanarak Bir Veritabanı Tablosu Oluşturma

Artık bir örnek MySQL veritabanı oluşturduğunuza göre, Sequelize kullanarak bir tablo oluşturabilir ve bunu veri ile doldurabilirsiniz. Sequelize'de veritabanı tablolarına modeller denir. Bir model, veritabanındaki bir tabloyu temsil eden bir soyutlamadır. Modeller, tablo adı, sütun detayları ve veri türleri gibi bazı bilgileri Sequelize'e tanımlar. Bu adımda, kitap verileri için bir Sequelize modeli oluşturacaksınız.

Başlamak için, proje dizininde book.model.js adlı yeni bir dosya oluşturun:

nano book.model.js

Önceki adıma benzer şekilde, dosyanın en üstüne DataTypes için yeni bir import ekleyerek veritabanı başlatma kodunu Sequelize ile ekleyin:

const { Sequelize, DataTypes } = require("sequelize");

Sequelize birçok yerleşik veri türü içerir. Bu veri türlerine erişmek için DataTypes için bir import eklemeniz gerekir. Bu öğretici, sık kullanılan bazı veri türlerine, örneğin STRING, INTEGER ve DATEONLY gibi veri türlerine atıfta bulunmaktadır. Diğer desteklenen veri türleri hakkında daha fazla bilgi edinmek için resmi Sequelize dokümantasyonuna başvurabilirsiniz.

Sonra, MySQL veritabanınıza bağlantı oluşturmak için daha önce kullandığınız satırları dahil edin ve MySQL kimlik bilgilerinizi buna göre güncelleyin:

...

const sequelize = new Sequelize(
   'hello_world_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

Sonraki adımda, title, author, release_date ve subject ID içeren books adında bir model oluşturacaksınız. Bunu yapmak için, aşağıda gösterildiği gibi sequelize.define() metodunu kullanın:

...

const Book = sequelize.define("books", {
   title: {
     type: DataTypes.STRING,
     allowNull: false
   },
   author: {
     type: DataTypes.STRING,
     allowNull: false
   },
   release_date: {
     type: DataTypes.DATEONLY,
   },
   subject: {
     type: DataTypes.INTEGER,
   }
});

sequelize.define() yöntemi, veritabanında bir tabloyu temsil eden yeni bir model tanımlar. Bu kod bloğu, books adında bir tablo oluşturur ve kitap kayıtlarını title, author, release_date ve subject alanlarına göre saklar.

Bu kodda, allowNull model sütun değerinin null olamayacağını gösterir. Benzer şekilde, böyle bir değer ayarlamanız gerekirse, defaultValue: "value" kullanabilirsiniz.

Sonraki adımda, book modelini veritabanınıza ekleyeceksiniz. Bunu yapmak için sync() yöntemini şu şekilde kullanacaksınız:

...

sequelize.sync().then(() => {
   console.log('Book table created successfully!');
}).catch((error) => {
   console.error('Unable to create table : ', error);
});

sync() yönteminde, Sequelize’dan veritabanına birkaç işlem yapmasını istiyorsunuz. Bu çağrı ile Sequelize otomatik olarak veritabanına bir SQL sorgusu gönderecek ve bir tablo oluşturacak, ardından Book table created successfully! mesajını yazdıracaktır.

Belirtildiği gibi, sync() yöntemi promise tabanlı bir yöntemdir, bu da hata yönetimi yapabileceği anlamına gelir. Bu kod bloğunda, tablonun başarıyla oluşturulup oluşturulmadığını kontrol edeceksiniz. Eğer oluşturulmazsa, catch yöntemi aracılığıyla bir hata dönecek ve çıktıya yazdırılacaktır.

Son kod şöyle görünecek:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'hello_world_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Book = sequelize.define("books", {
   title: {
     type: DataTypes.STRING,
     allowNull: false
   },
   author: {
     type: DataTypes.STRING,
     allowNull: false
   },
   release_date: {
     type: DataTypes.DATEONLY,
   },
   subject: {
     type: DataTypes.INTEGER,
   }
});

sequelize.sync().then(() => {
   console.log('Book table created successfully!');
}).catch((error) => {
   console.error('Unable to create table : ', error);
});

Dosyanızı kaydedin ve kapatın.

Uygulamanızı aşağıdaki komutu kullanarak çalıştırın:

node book.model.js

Komut satırınızda aşağıdaki çıktıyı alacaksınız:

Executing (default): SELECT 1+1 AS result
Executing (default): CREATE TABLE IF NOT EXISTS `books` (`id` INTEGER NOT NULL auto_increment , `title` VARCHAR(255) NOT NULL, `author` VARCHAR(255) NOT NULL, `release_date` DATE, `subject` INTEGER, `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB;
Connection has been established successfully.
Executing (default): SHOW INDEX FROM `books`
Book table created successfully!

Çıktıda, dönüş kaydının Book table created successfully! mesajını içerdiğini göreceksiniz. Bunu, hello_world_db veritabanında oluşturulan yeni books tablosunu kontrol ederek doğrulayabilirsiniz.

Yeni tablo oluşturulmasını doğrulamak için MySQL örneğinize giriş yapın:

mysql -u YOUR_USERNAME -p

Şifrenizi girdikten sonra, örnek veritabanına geçin:

USE hello_world_db;

Ve ardından tabloları göstermek için komutu çalıştırın:

SHOW TABLES;

Çıktınız buna benzer olacaktır:

+---------------------------+
| Tables_in_hello_world_db |
+---------------------------+
| books                     |
+---------------------------+
1 row in set (0.00 sec)

Son olarak, MySQL sunucusundan bağlantıyı kesin:

mysql> QUIT

book modelinin başarıyla oluşturulduğunu doğruladınız. Bu süreçle, aynı prosedürü izleyerek istediğiniz sayıda model oluşturabilirsiniz.

Bu adımda, bir veritabanında bir model oluşturduk ve yerleşik yöntemleri kullanarak modelle çalışmaya başladınız. Ayrıca modelinizi tanımlamak için Sequelize tarafından desteklenen veri tiplerini kullandınız. Sonraki adımda, temel model sorguları ile çalışacaksınız.

Veritabanı Sorguları İçin Sequelize Kullanımı

Bu adımda, ekleme, seçim, koşullu seçim ve silme işlemleri için Sequelize'in yerleşik sorgularını kullanacaksınız.

Yeni Bir Kayıt Eklemek

Önceki adımda veritabanı içinde bir book modeli oluşturmuştunuz. Bu bölümde, bu modele veri ekleyeceksiniz.

Başlamak için, bir önceki adımdaki book.model.js dosyasının içeriğini kopyalayın. Sorgu mantığını yönetmek için book.controller.js adında yeni bir dosya oluşturun. book.model.js içindeki kodu book.controller.js dosyasına ekleyin.

book.controller.js dosyasında, sync() metodunu bulun. sync() metodunda, aşağıdaki vurgulanan satırları ekleyin:

...

sequelize.sync().then(() => {
   console.log('Book table created successfully!');

   Book.create({
       title: "Clean Code",
       author: "Robert Cecil Martin",
       release_date: "2021-12-14",
       subject: 3
   }).then(res => {
       console.log(res)
   }).catch((error) => {
       console.error('Failed to create a new record : ', error);
   });

}).catch((error) => {
   console.error('Unable to create table : ', error);
});

Burada, önceden oluşturduğunuz books modeline yeni bir kitap kaydı ekliyorsunuz; bu işlem, daha önce oluşturulmuş modellere yeni kayıtlar eklemeyi destekleyen sync() yöntemi kullanılarak yapılır. sync() yöntemi başarıyla çalıştıktan sonra, then() yöntemi çalıştırılır. then() yöntemi içinde, yeni kayıtları modele eklemek için create() yöntemini çağırırsınız.

Veritabanına eklemeniz gereken verileri bir nesne olarak iletmek için create() metodunu kullanırsınız. Vurgulanan kod bölümü, mevcut books tablonuza yeni bir giriş ekleyecektir. Bu örnekte, subject ID'si 3 olan bir kategoriye sahip Robert Cecil Martin tarafından yazılmış Clean Code kitabını ekliyorsunuz. Aynı kodu, diğer kitaplara ait bilgilerle güncelleyerek veritabanınıza yeni kayıtlar eklemek için kullanabilirsiniz.

Dosyayı kaydedip kapat.

Uygulamayı şu komutu kullanarak çalıştırın:

node book.controller.js

Çıktınız aşağıdakine benzer görünecektir:

books {
  dataValues:
   { id: 1,
     title: 'Clean Code',
     author: 'Robert Cecil Martin',
     release_date: '2021-12-14',
     subject: 3,
     updatedAt: 2021-12-14T10:12:16.644Z,
   ...
}

Veritabanında oluşturduğunuz modele yeni bir kayıt eklediniz. Aynı işlemi kullanarak birden fazla kayıt eklemeye devam edebilirsiniz.

Tüm Kayıtları Seçme

Bu bölümde, findAll() yöntemiyle veritabanındaki tüm kitap kayıtlarını seçip alacaksınız. Bunu yapmak için öncelikle book.controller.js dosyasını açın ve önceki Book.create() yöntemini kaldırın. sync() yönteminde, aşağıda gösterildiği gibi Book.findAll() yöntemini ekleyin:

...

sequelize.sync().then(() => {

    Book.findAll().then(res => {
        console.log(res)
    }).catch((error) => {
        console.error('Failed to retrieve data : ', error);
    });

}).catch((error) => {
    console.error('Unable to create table : ', error);
});

...

Dosyayı kaydedip kapat.

Ardından, uygulamayı tekrar çalıştırmak için aşağıdaki komutu kullanın:

node book.controller.js

Çıktınız aşağıdakine benzer görünecektir:

[
  books {
    dataValues: {
      id: 1,
      title: 'Clean Code',
      author: 'Robert Cecil Martin',
      release_date: '2020-01-01',
      subject: 3,
      createdAt: 2021-02-22T09:13:55.000Z,
      updatedAt: 2021-02-22T09:13:55.000Z
    },
    _previousDataValues: {
      id: 1,
      title: 'Clean Code',
      author: 'Robert Cecil Martin',
      release_date: '2020-01-01',
      subject: 3,
      createdAt: 2021-02-22T09:13:55.000Z,
      updatedAt: 2021-02-22T09:13:55.000Z
    },
...
]

Çıktı, tüm kitap verilerini bir dizi nesne olarak içerir. Veritabanından tüm kitap verilerini döndürmek için Sequelize findAll() metodunu başarıyla kullandınız.

where İfadesi ile Seçim Yapmak

Bu bölümde, where ifadesini kullanarak koşullu değerler seçeceksiniz. where ifadesi, veri alırken bir koşul belirtmek için kullanılır. Bu eğitimde, findOne() yöntemi ile veritabanından belirli bir kayıt ID'sine sahip bir kitabı alacaksınız.

Bunu yapmak için, düzenleme için book.controller.js dosyasını açın, findAll() metodunu silin ve aşağıdaki satırları ekleyin:

...

sequelize.sync().then(() => {

    Book.findOne({
        where: {
            id: 1
        }
    }).then(res => {
        console.log(res)
    }).catch((error) => {
        console.error('Failed to retrieve data : ', error);
    });

}).catch((error) => {
    console.error('Unable to create table : ', error);
});

Burada, veritabanından belirli bir kitap kaydını where seçeneği ile findOne() yöntemi kullanarak seçiyorsunuz. Bu örnekte, id'si 1 olan kitabın verilerini alıyorsunuz.

Dosyayı kaydedip kapat.

Sonra, uygulamayı çalıştırın:

node book.controller.js

Çıktınız aşağıdakine benzer görünecektir:

books {
  dataValues: {
    id: 1,
    title: 'Clean Code',
    author: 'Robert Cecil Martin',
    release_date: '2020-01-01',
    subject: 'Science',
    createdAt: 2021-02-22T09:13:55.000Z,
    updatedAt: 2021-02-22T09:13:55.000Z
  },
  ...
}

where koşullarını kullanarak Sequelize modellerinden veri almayı başarıyla gerçekleştirdiniz. Veritabanı uygulamasında şartlı verileri yakalamak için where koşulunu kullanabilirsiniz.

Bir Kaydı Silmek

Veritabanı modelinden belirli bir kaydı silmek için destroy() yöntemini where seçeneği ile kullanırsınız. Bunu yapmak için book.controller.js dosyasını açın, findOne() yöntemini kaldırın ve aşağıda vurgulanan satırları ekleyin:

...
sequelize.sync().then(() => {

  Book.destroy({
      where: {
        id: 2
      }
  }).then(() => {
      console.log("Successfully deleted record.")
  }).catch((error) => {
      console.error('Failed to delete record : ', error);
  });

}).catch((error) => {
    console.error('Unable to create table : ', error);
});

Burada, destroy() yöntemini where seçeneğiyle kullanarak ve silinecek kitabın id'sini geçirerek veritabanından bir kitap kaydını kaldırırsınız. id'si 2 olan kitap kaydını kaldıracaksınız.

Dosyayı kaydedip kapat.

Sonra, uygulamayı çalıştırın:

node book.controller.js

Çıktınız şu şekilde görünecektir:

Successfully deleted record.

Kayıt silindi.

Bu adımda, veritabanı modeliniz ve model sorgulama ile denemeler yaptınız. Veritabanını başlattınız, modeller oluşturdu, kayıtlar eklediniz, kayıtları aldınız, where ifadesini kullanarak koşullu kayıtlar getirdiniz ve seçilen kayıtları sildiniz. Sequelize bilgisi ile şimdi Sequelize'de ilişkiler oluşturacaksınız. Bundan sonra, Sequelize modellerini kullanarak çeşitli ilişkileri tanımlayabilir ve onlarla çalışabilirsiniz.

Sequelize Kullanarak İlişkiler Oluşturma

Bu adımda, Sequelize'in desteklediği standart ilişki türlerini kullanacaksınız: bir-bir, bir-çok ve çok-çok ilişkiler. Öğrenciler, dersler ve sınıf seviyeleri hakkında örnek veriler kullanacaksınız.

Sequelize, aşağıdaki veritabanı ilişkilerine dayalı ilişki türlerini kullanır:

• bire bir ilişki: Bire bir ilişki, bir tablodaki bir kaydın başka bir tablodaki tam olarak bir kayıtla ilişkili olduğu anlamına gelir. Sequelize açısından, bu tür bir ilişki oluşturmak için belongsTo() ve hasOne() ilişkilerini kullanabilirsiniz.

• birden çoğa ilişki: Birden çoğa ilişki, bir tablodaki bir kaydın başka bir tablodaki birden fazla kayıtla ilişkili olduğu anlamına gelir. Sequelize ile bu tür bir ilişkiyi oluşturmak için hasMany() ilişki yöntemlerini kullanabilirsiniz.

• çoktan-çoğa ilişki: Çoktan-çoğa ilişki, bir tablodaki birden çok kaydın diğer tablodaki birden çok kayıtla ilişkilendirildiği anlamına gelir. Sequelize ile bu tür bir ilişkiyi oluşturmak için belongsToMany() ilişkilerini kullanabilirsiniz.

Bu ilişkileri oluşturmadan önce, öncelikle student_db adında yeni bir veritabanı oluşturacak ve öğrenciler, dersler ve sınıf seviyeleri için yeni modeller ve bazı örnek veriler ekleyeceksiniz.

Veritabanını oluşturmak için, MySQL'e giriş yapmak ve student_db adlı bir veritabanı oluşturmak için Sequelize'ı Kurma ve Yapılandırma bölümündeki aynı süreci izleyin. Yeni veritabanı oluşturulduktan sonra, MySQL'den çıkış yapın. Sonraki adım olarak, veritabanı ilişkilerini oluşturmaya başlayacaksınız.

belongsTo() ile Bire Bir İlişki Oluşturma

Bu bölümde, Sequelize modelleri kullanarak bire bir ilişki oluşturacaksınız. Bir öğrencinin not seviyesiyle birlikte detaylarını almak istediğinizi hayal edin. Bir öğrencinin sadece bir not seviyesi olabileceği için, bu tür bir ilişki bire bir ilişkidir ve belongsTo() metodunu kullanabilirsiniz.

belongsTo() yöntemi, iki Sequelize modeli arasında bire bir ilişki oluşturmanıza olanak tanır. Bu örnekte, Student ve Grade modellerini kullanıyorsunuz.

Yeni bir dosya oluşturun ve adını one_to_one.js koyun. Önceki bölümde, MySQL Veritabanına Bağlanma kısmında yaptığınız gibi, dosyanın en üstüne veritabanına bağlantı oluşturacak ve MySQL kullanıcı doğrulamanızı yapacak satırları ekleyin. Gerektiğinde MySQL kimlik bilgilerini güncellemeyi unutmayın:

const { Sequelize, DataTypes } = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

Bu bölümde, yeni student_db veritabanında üç model oluşturacaksınız: Student, Grade ve Course. Student ve Grade modellerini oluşturarak başlayacaksınız. Bu adımın ilerleyen kısmında ise Courses modelini oluşturacaksınız.

Student modeli için, aşağıdaki kod bloğunu one_to_one.js dosyasına ekleyin:

...
const Student = sequelize.define("students", {
   student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
       primaryKey: true,
   },
   name: {
       type: DataTypes.STRING,
       allowNull: false
   }
});

Bu öğrenci modeli iki sütun içerir: student_id ve name.

Sonraki adımda, Grade modeli için bir kod bloğu ekleyin:

...
const Grade = sequelize.define("grades", {
   grade: {
       type: DataTypes.INTEGER,
       allowNull: false
   }
});

Grade modeli grade sütununu içerir.

İlişkileri göstermek için veritabanına örnek veri eklemeniz gerekecek. Bunun için bulk() metodunu kullanacaksınız. Verileri tek tek satırlara eklemek yerine, bulkCreate() metodu, veritabanı modellerinize birden fazla satırı aynı anda eklemenize olanak tanır.

Şimdi, Grade ve Student verilerini veritabanındaki ilgili modellere şu şekilde aktarın:

...
const grade_data = [{grade : 9}, {grade : 10}, {grade : 11}]

const student_data = [
   {name : "John Baker", gradeId: 2},
   {name : "Max Butler", gradeId: 1},
   {name : "Ryan Fisher", gradeId: 3},
   {name : "Robert Gray", gradeId: 2},
   {name : "Sam Lewis", gradeId: 1}
]

sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           …
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create the table : ', error);
});

Burada, örnek verileri sağlıyorsunuz ve verileri Student ve Grade modellerine ekliyorsunuz. Veritabanınız, modelleriniz ve örnek verileriniz hazır olduğunda, ilişkilendirmeler oluşturmak için hazırsınız.

one-to-one.js dosyasında, student_data bloğunun altına aşağıdaki satırı ekleyin:

...
Student.belongsTo(Grade);

Sonraki adımda, ilişkilendirmenin düzgün çalışıp çalışmadığını kontrol etmeniz gerekecek. Bunu yapmak için, findAll() metodunun içine include parametresini geçirerek bütün öğrencilerin verilerini ve ilgili sınıf seviyelerini alabilirsiniz.

Öğrenci not seviyesini almanız gerektiğinden, modeli olarak Grade'i geçeceksiniz. sequelize.sync() yönteminde, aşağıda gösterildiği gibi vurgulanan satırları ekleyin:

...
sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           Student.findAll({
               include: [{
                   model: Grade
               }]
           }).then(result => {
               console.log(result)
           }).catch((error) => {
               console.error('Failed to retrieve data : ', error);
           });
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create the table : ', error);
});

Tam kod aşağıdaki gibi görünmektedir:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );
sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
   student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
       primaryKey: true,
   },
   name: {
       type: DataTypes.STRING,
       allowNull: false
   }
});

const Grade = sequelize.define("grades", {
   grade: {
       type: DataTypes.INTEGER,
       allowNull: false
   }
});

const grade_data = [{grade : 9}, {grade : 10}, {grade : 11}]

const student_data = [
   {name : "John Baker", gradeId: 2},
   {name : "Max Butler", gradeId: 1},
   {name : "Ryan Fisher", gradeId: 3},
   {name : "Robert Gray", gradeId: 2},
   {name : "Sam Lewis", gradeId: 1}
]

// One-To-One association
Student.belongsTo(Grade);

sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           Student.findAll({
               include: [{
                   model: Grade
               }]
           }).then(result => {
               console.log(result)
           }).catch((error) => {
               console.error('Failed to retrieve data : ', error);
           });
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create the table : ', error);
});

Dosyanızı kaydedip kapatın.

Dosyayı şu komutu kullanarak çalıştırın:

node one_to_one.js

Çıktı uzun olacak ve tüm öğrencilerin verilerini ve sınıf seviyelerini göreceksiniz. İşte öğrenci verilerini gösteren çıktının bir örneği:

students {
    dataValues:
   { student_id: '3e786a8f-7f27-4c59-8e9c-a8c606892288',
       name: 'Sam Lewis',
       createdAt: 2021-12-16T08:49:38.000Z,
       updatedAt: 2021-12-16T08:49:38.000Z,
       gradeId: 1,
       grade: [grades] },
    _previousDataValues:
...

Kullandığınız komut satırı araçlarına bağlı olarak, çıktı genişletilmiş bir görünüm olarak veya olmayacak şekilde yazdırılabilir. Eğer genişletilmiş bir görünüm ise, grade nesnesini genişletilmiş şekilde çıktılar.

Bu bölümde, Student.belongsTo(Grade); metodunu kullanarak bire bir ilişki oluşturdunuz ve oluşturduğunuz ilişkiye göre detayları aldınız.

hasMany() ile Birden Çoğa İlişki Oluşturma

Bu bölümde, Sequelize modelleri kullanarak bire çok ilişkisi oluşturacaksınız. Seçili bir sınıf düzeyiyle ilişkili tüm öğrencileri almak istediğinizi hayal edin. Belirli bir sınıf düzeyinin birden fazla öğrencisi olabileceğinden, bu bir bire çok ilişkidir.

Başlamak için, one_to_one.js dosyasının içeriğini one_to_many.js adında yeni bir dosyaya kopyalayın. one_to_many.js dosyasında, student_data bloğunun sonraki satırlarını kaldırın. one_to_many.js dosyanız şöyle görünecek:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
   student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
       primaryKey: true,
   },
   name: {
       type: DataTypes.STRING,
       allowNull: false
   }
});
const Grade = sequelize.define("grades", {
   grade: {
       type: DataTypes.INTEGER,
       allowNull: false
   }
});

const grade_data = [ {grade : 9}, {grade : 10}, {grade : 11}]

const student_data = [
   {name : "John Baker", gradeId: 2},
   {name : "Max Butler", gradeId: 1},
   {name : "Ryan Fisher", gradeId: 3},
   {name : "Robert Gray", gradeId: 2},
   {name : "Sam Lewis", gradeId: 1}
]

student_data bloğundan sonra, yeni bir ilişki oluşturmak için hasMany() metodunu kullanın:

...
Grade.hasMany(Student)

hasMany() metodu, iki Sequelize modeli arasında bire-çok ilişki oluşturmanıza olanak tanır. Burada, Grade ve Student modellerini kullanıyorsunuz.

Sonraki adım olarak, hasMany() satırının altına findAll() yöntemi ile birlikte sequelize.sync() yöntemini ekleyin:

...
sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           Grade.findAll({
               where: {
                   grade: 9
               },
               include: [{
                   model: Student
               }]
           }).then(result => {
               console.dir(result, { depth: 5 });
           }).catch((error) => {
               console.error('Failed to retrieve data : ', error);
           });
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create table : ', error);
});

Burada, belirli bir sınıf düzeyindeki tüm öğrencilere erişmeye çalışıyorsunuz—bu durumda, 9 sınıfındaki tüm öğrenciler. Ayrıca include seçeneğine Student modelini eklediniz.

İşte tam kod:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
  );

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
   student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
       primaryKey: true,
   },
   name: {
       type: DataTypes.STRING,
       allowNull: false
   }
});
const Grade = sequelize.define("grades", {
   grade: {
       type: DataTypes.INTEGER,
       allowNull: false
   }
});

const grade_data = [ {grade : 9}, {grade : 10}, {grade : 11}]

const student_data = [
   {name : "John Baker", gradeId: 2},
   {name : "Max Butler", gradeId: 1},
   {name : "Ryan Fisher", gradeId: 3},
   {name : "Robert Gray", gradeId: 2},
   {name : "Sam Lewis", gradeId: 1}
]

// One-To-Many relationship
Grade.hasMany(Student);

sequelize.sync({ force: true }).then(() => {
   Grade.bulkCreate(grade_data, { validate: true }).then(() => {
       Student.bulkCreate(student_data, { validate: true }).then(() => {
           Grade.findAll({
               where: {
                   grade: 9
               },
               include: [{
                   model: Student
               }]
           }).then(result => {
               console.dir(result, { depth: 5 });
           }).catch((error) => {
               console.error('Failed to retrieve data : ', error);
           });
       }).catch((err) => { console.log(err); });
   }).catch((err) => { console.log(err); });
}).catch((error) => {
   console.error('Unable to create table : ', error);
});

Dosyanızı kaydedin ve kapatın.

Dosyayı aşağıdaki komutla çalıştırın:

node one_to_many.js

Çıktı aşağıdakine benzer görünecektir. Oldukça uzun olacak, ancak 9. sınıftaki tüm öğrenciler şu şekilde listelenecektir:

[ grades {
    dataValues:
     { id: 1,
       grade: 9,
       createdAt: 2021-12-20T05:12:31.000Z,
       updatedAt: 2021-12-20T05:12:31.000Z,
       students:
        [ students {
            dataValues:
             { student_id: '8a648756-4e22-4bc0-8227-f590335f9965',
               name: 'Sam Lewis',
               createdAt: 2021-12-20T05:12:31.000Z,
               updatedAt: 2021-12-20T05:12:31.000Z,
               gradeId: 1 },
...
          students {
            dataValues:
             { student_id: 'f0304585-91e5-4efc-bdca-501b3dc77ee5',
               name: 'Max Butler',
               createdAt: 2021-12-20T05:12:31.000Z,
               updatedAt: 2021-12-20T05:12:31.000Z,
               gradeId: 1 },
...

Bu bölümde, Grade.hasMany(Student); yöntem çağrısını kullanarak bire-çok ilişki oluşturdunuz. Çıktıda, oluşturduğunuz ilişkiye göre detayları aldınız.

belongsToMany() ile Çoktan Çoka İlişkiler Oluşturma

Bu bölümde, Sequelize modelleri kullanarak çoktan-çoğa ilişkiler oluşturacaksınız. Örnek olarak, öğrencilerin kurslara kayıtlı olduğu bir durumu düşünün. Bir öğrenci birçok kursa kaydolabilir ve bir kursta birçok öğrenci olabilir. Bu, çoktan-çoğa bir ilişkidir. Bunu Sequelize kullanarak uygulamak için Student, Course ve StudentCourse modellerini belongsToMany() yöntemiyle kullanacaksınız.

Başlamak için, many_to_many.js adlı bir dosya oluşturun ve veritabanı başlatma ve kimlik doğrulama kod bloklarını aşağıdaki gibi ekleyin. (Önceki one_to_many.js örneğindeki kod bloklarını yeniden kullanabilirsiniz.) Gerektiğinde vurgulanan veritabanı bağlantı değerlerini güncellediğinizden emin olun.

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
);

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

Sonraki adımda, çoktan-çoğa ilişkiler için veritabanı modellerini oluşturacaksınız: Student ve Course. Ardından bu modellere bazı örnek veriler ekleyeceksiniz.

...

const Student = sequelize.define("students", {
    student_id: {
        type: DataTypes.UUID,
        defaultValue: DataTypes.UUIDV4,
    },
    name: {
        type: DataTypes.STRING,
        allowNull: false
    }
});

const Course = sequelize.define("courses", {
    course_name: {
        type: DataTypes.STRING,
        allowNull: false
    }
});

const StudentCourse = sequelize.define('StudentCourse', {
    id: {
      type: DataTypes.INTEGER,
      primaryKey: true,
      autoIncrement: true,
      allowNull: false
    }
  });

const course_data = [
    {course_name : "Science"},
    {course_name : "Maths"},
    {course_name : "History"}
]

const student_data = [
    {name : "John Baker", courseId: 2},
    {name : "Max Butler", courseId: 1},
    {name : "Ryan Fisher", courseId: 3},
    {name : "Robert Gray", courseId: 2},
    {name : "Sam Lewis", courseId: 1}
]

const student_course_data = [
    {studentId : 1, courseId: 1},
    {studentId : 2, courseId: 1},
    {studentId : 2, courseId: 3},
    {studentId : 3, courseId: 2},
    {studentId : 1, courseId: 2},
]

Burada, Student ve Course modellerini oluşturuyorsunuz ve bazı örnek veriler sağlıyorsunuz. Ayrıca, bu ilişki türüne göre öğrencileri almak için kullanacağınız bir courseID de belirliyorsunuz.

Son olarak, StudentCourse adlı yeni bir model tanımladınız, bu model Student ve Course arasındaki ilişki verilerini yönetir. Bu örnekte, studentId 1, courseId 1 ve courseId 2 derslerine kayıtlıdır.

Veritabanı başlatmasını tamamladınız ve veritabanına örnek veri eklediniz. Sonraki adım olarak, aşağıda gösterildiği gibi belongsToMany() yöntemini kullanarak çoktan çoğa ilişkiler oluşturun:

...
Course.belongsToMany(Student, { through: 'StudentCourse'})
Student.belongsToMany(Course, { through: 'StudentCourse'})

belongsToMany() metodunda, yapılandırma seçeneği olarak modelin adını through yapılandırması ile geçirirsiniz. Bu durumda, StudentCourse söz konusudur. Bu, çoktan-çoğa ilişkileri yöneten tablodur.

Son olarak, ilişkilendirmenin doğru çalışıp çalışmadığını, tüm kurs verilerini ilişkilendirilen öğrencilerle birlikte alarak kontrol edebilirsiniz. Bunu, findAll() metodunun içine include parametresini geçirerek yapacaksınız. Aşağıdaki satırları many_to_many.js dosyasına ekleyin:

...
sequelize.sync({ force: true }).then(() => {
    Course.bulkCreate(course_data, { validate: true }).then(() => {
        Student.bulkCreate(student_data, { validate: true }).then(() => {
            StudentCourse.bulkCreate(student_course_data, { validate: true }).then(() => {
                Course.findAll({
                    include: {
                        model: Student,
                    },
                }).then(result => {
                    console.log(result);
                }).catch((error) => {
                    console.error('Failed to retrieve data : ', error);
                });
            }).catch((error) => {
                console.log(error);
            });
        }).catch((error) => {
            console.log(error);
        });
    }).catch((error) => {
        console.log(error);
    });
}).catch((error) => {
    console.error('Unable to create table : ', error);
});

Tam kod aşağıdaki gibi görünmektedir:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
);

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
    student_id: {
       type: DataTypes.UUID,
       defaultValue: DataTypes.UUIDV4,
    },
    name: {
       type: DataTypes.STRING,
       allowNull: false
    }
});

const Course = sequelize.define("courses", {
    course_name: {
        type: DataTypes.STRING,
        allowNull: false
    }
});

const StudentCourse = sequelize.define('StudentCourse', {
    id: {
      type: DataTypes.INTEGER,
      primaryKey: true,
      autoIncrement: true,
      allowNull: false
    }
  });

const course_data = [
    {course_name : "Science"},
    {course_name : "Maths"},
    {course_name : "History"}
]

const student_data = [
    {name : "John Baker", courseId: 2},
    {name : "Max Butler", courseId: 1},
    {name : "Ryan Fisher", courseId: 3},
    {name : "Robert Gray", courseId: 2},
    {name : "Sam Lewis", courseId: 1}
]

const student_course_data = [
    {studentId : 1, courseId: 1},
    {studentId : 2, courseId: 1},
    {studentId : 2, courseId: 3},
    {studentId : 3, courseId: 2},
    {studentId : 1, courseId: 2},
]

Course.belongsToMany(Student, { through: 'StudentCourse'})
Student.belongsToMany(Course, { through: 'StudentCourse'})

sequelize.sync({ force: true }).then(() => {
    Course.bulkCreate(course_data, { validate: true }).then(() => {
        Student.bulkCreate(student_data, { validate: true }).then(() => {
            StudentCourse.bulkCreate(student_course_data, { validate: true }).then(() => {
                Course.findAll({
                    include: {
                        model: Student,
                    },
                }).then(result => {
                    console.log(result);
                }).catch((error) => {
                    console.error('Failed to retrieve data : ', error);
                });
            }).catch((error) => {
                console.log(error);
            });
        }).catch((error) => {
            console.log(error);
        });
    }).catch((error) => {
        console.log(error);
    });
}).catch((error) => {
    console.error('Unable to create table : ', error);
});

Dosyayı kaydedip kapat.

Dosyayı aşağıdaki komutu kullanarak çalıştırın:

node many_to_many.js

Çıktı uzun olacak, ancak aşağıdakine benzer görünecek:

[ courses {
    dataValues:
     { id: 1,
       course_name: 'Science',
       createdAt: 2022-05-11T04:27:37.000Z,
       updatedAt: 2022-05-11T04:27:37.000Z,
       students: [Array] },
    _previousDataValues:
     { id: 1,
       course_name: 'Science',
       createdAt: 2022-05-11T04:27:37.000Z,
       updatedAt: 2022-05-11T04:27:37.000Z,
       students: [Array] },
    _changed: Set {},
    _options:
     { isNewRecord: false,
       _schema: null,
       _schemaDelimiter: '',
       include: [Array],
       includeNames: [Array],
       includeMap: [Object],
       includeValidated: true,
       attributes: [Array],
       raw: true },
    isNewRecord: false,
    students: [ [students], [students] ] },
  courses {
    dataValues:
     { id: 2,
       course_name: 'Maths',
       createdAt: 2022-05-11T04:27:37.000Z,
       updatedAt: 2022-05-11T04:27:37.000Z,
       students: [Array] },
    _previousDataValues:
...

Bu çıktıda görebileceğiniz gibi, ilişkili öğrencileri olan dersler alındı. courses bloğu içinde, her dersi gösteren ayrı id değerlerini göreceksiniz. Örneğin, id: 1, Fen sınıfı için course_name: Science ile bağlantılıdır; id: 2 ise Matematik sınıfıdır ve böyle devam eder.

Veritabanında, eklediğiniz örnek verilerle oluşturulmuş üç tabloyu görebilirsiniz.

Bu adımda, Sequelize kullanarak bire bir, bire çok ve çok çok ilişkiler oluşturdunuz. Sonraki adımda ise ham sorgularla çalışacaksınız.

Ham Sorgularla Çalışmak

Bu adımda, Sequelize'de ham sorgularla çalışacaksınız. Önceki adımlarda, veritabanına veri ekleme ve seçim işlemlerini yapmak için insert() ve findAll() gibi Sequelize'in yerleşik yöntemlerini kullandınız. Bu yöntemlerin sorgu yazmak için belirli bir deseni takip ettiğini fark etmiş olabilirsiniz. Ancak, ham sorgular kullanıldığında, Sequelize'in yerleşik yöntemleri ve desenleri hakkında endişelenmenize gerek yoktur. SQL sorguları bilginizi kullanarak, basitten ileri düzeye kadar çeşitli sorguları Sequelize'de gerçekleştirebilirsiniz.

İşte belirli bir tablodaki tüm değerleri seçme, seçilen değerleri koşula göre silme ve tabloyu verilen değerlerle güncelleme işlemini gerçekleştiren ham sorgulara bir örnek.

SELECT * FROM table_name;
DELETE FROM table_name WHERE condition;
UPDATE table_name SET y = 42 WHERE x = 12;

Sequelize'de, ham sorgular öncelikle iki yöntemle kullanılabilir: dizi ile değiştirme ve nesne ile değiştirme. SQL sorgusuna değerler gönderirken, bu değişikliği yapmak için ya bir dizi ya da bir nesne kullanabilirsiniz.

Ham bir sorgu yazmadan önce, örnek bir veritabanında öğrenci verilerini sağlamanız gerekecektir. Bir önceki bölüm olan Örnek Bir Veritabanı Oluşturma bölümünü takip ederek, MySQL'e giriş yapın, sample_student_db adında bir veritabanı oluşturun ve MySQL'den çıkış yapın.

Sonraki adımda, ham sorgularla çalışmaya başlamak için bazı ham veriler ekleyeceksiniz. add_student_records.js adında yeni bir dosya oluşturun ve daha önce tartışılan authenticate(), sync() ve bulkCreate() Sequelize yöntemlerini içeren aşağıdaki kod bloklarını ekleyin.

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

const Student = sequelize.define("students", {
    student_id: {
        type: DataTypes.UUID,
        defaultValue: DataTypes.UUIDV4,
        primaryKey: true,
    },
    name: {
        type: DataTypes.STRING,
        allowNull: false
    }
});

const student_data = [
    {name : "John Baker"},
    {name : "Max Butler"},
    {name : "Ryan Fisher"},
    {name : "Robert Gray"},
    {name : "Sam Lewis"}
]

sequelize.sync({ force: true }).then(() => {

    Student.bulkCreate(student_data, { validate: true }).then((result) => {
        console.log(result);
    }).catch((error) => {
        console.log(error);
    });

}).catch((error) => {
    console.error('Unable to create table : ', error);
});

Burada, veritabanı bağlantısını başlatır, modeli oluşturur ve yeni veritabanına birkaç öğrenci kaydı eklersiniz.

Dosyayı kaydedip kapat.

Sonraki olarak, bu betiği aşağıdaki komutu kullanarak çalıştırın:

node add_student_records.js

Çıktı aşağıdakilere benzer olacaktır. Oldukça uzun olabilir, ancak eklediğiniz tüm öğrenci kayıtları aşağıdaki şekilde geri dönecektir. student_id otomatik olarak oluşturulan bir UUID (Evrensel Benzersiz Tanımlayıcılar) değeri olduğu için, kullanıcıya bağlı olarak farklı olacağını unutmayın.

Executing (default): SELECT 1+1 AS result
Executing (default): DROP TABLE IF EXISTS `students`;
Connection has been established successfully.
Executing (default): DROP TABLE IF EXISTS `students`;
Executing (default): CREATE TABLE IF NOT EXISTS `students` (`student_id` CHAR(36) BINARY , `name` VARCHAR(255) NOT NULL, `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL, PRIMARY KEY (`student_id`)) ENGINE=InnoDB;
Executing (default): SHOW INDEX FROM `students`
Executing (default): INSERT INTO `students` (`student_id`,`name`,`createdAt`,`updatedAt`) VALUES ('45d1f26c-ba76-431f-ac5f-f41282351710','John Baker','2022-06-03 07:27:49','2022-06-03 07:27:49'),('1cb4e34d-bfcf-4a97-9624-e400b9a1a5f2','Max Butler','2022-06-03 07:27:49','2022-06-03 07:27:49'),('954c576b-ba1c-4dbc-a5c6-8eaf22bbbb04','Ryan Fisher','2022-06-03 07:27:49','2022-06-03 07:27:49'),('e0f15cd3-0025-4032-bfe8-774e38e14c5f','Robert Gray','2022-06-03 07:27:49','2022-06-03 07:27:49'),('826a0ec9-edd0-443f-bb12-068235806659','Sam Lewis','2022-06-03 07:27:49','2022-06-03 07:27:49');
[
  students {
    dataValues: {
      student_id: '45d1f26c-ba76-431f-ac5f-f41282351710',
      name: 'John Baker',
      createdAt: 2022-06-03T07:27:49.453Z,
      updatedAt: 2022-06-03T07:27:49.453Z
    },
    _previousDataValues: {
      name: 'John Baker',
      student_id: '45d1f26c-ba76-431f-ac5f-f41282351710',
      createdAt: 2022-06-03T07:27:49.453Z,
      updatedAt: 2022-06-03T07:27:49.453Z
    },

…

Bir sonraki bölümde, yukarıdaki kod bloğundaki student_id çıktılarından birini kullanarak ham sorgular uygulayacaksınız. Bunu bir kenara not edin, böylece bir sonraki bölümlerde query() yöntemini dizi ve nesne değiştirmeleri için kullanabilirsiniz.

Dizi Değiştirme

Bu bölümde, bir dizi değişimi için query() metodunu kullanacaksınız. Bu yöntemle, Sequelize ham veya önceden hazırlanmış SQL sorgularını çalıştırabilir.

Başlamak için, 1. Adım'daki server.js dosyasının içeriğini kopyalayın, çünkü bu dosya Sequelize() başlatma yöntemi ve veritabanı başlatmayı içerir. İçeriği array_raw_query.js adında yeni bir dosyaya yapıştırın. Veritabanı adını sample_student_db olarak güncelleyin:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

Dosyanın sonunda, bir dizi değişimi için aşağıdaki kod bloğunu ekleyin ve önceki bölümde kopyaladığınız student_id değeri ile REPLACE_STUDENT_ID öğesini değiştirdiğinizden emin olun.

...
sequelize.query(
    'SELECT * FROM students WHERE student_id = ?',
    {
      replacements: ['REPLACE_STUDENT_ID'],
      type: sequelize.QueryTypes.SELECT
    }
).then(result => {
    console.log(result);
}).catch((error) => {
    console.error('Failed to insert data : ', error);
});

Dizi değişimi için, SQL sorgusu ve yapılandırma nesnesi ile query() metodunu kullanırsınız. Yapılandırma nesnesi replacements değerini ve türünü içerir. Değişimler için verileri bir dizi olarak iletir ve bu değerleri soru işareti (?) sembolü ile yakalarsınız.

Sonra, belirli bir öğrenci hakkında veri almanız gerektiği için student_id ikinci parametre olarak geçilir. Daha sonra, veritabanından veri seçmek için kullanabileceğiniz type: sequelize.QueryTypes.SELECT anahtar-değer çiftini geçersiniz.

Bunun yanı sıra QueryTypes.UPDATE ve QueryTypes.DELETE gibi bazı diğer türler de vardır. Gereksinime bağlı olarak amacınıza uygun olan türü seçebilirsiniz.

Aşağıda tam kod bloğu gösterilmektedir. Burada veritabanına bağlanır ve seçilen öğrenci verilerini ham sorgu kullanarak alırsınız.

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

sequelize.query(
    'SELECT * FROM students WHERE student_id = ?',
    {
      replacements: ['REPLACE_STUDENT_ID'],
      type: sequelize.QueryTypes.SELECT
    }
).then(result => {
    console.log(result);
}).catch((error) => {
    console.error('Failed to insert data : ', error);
});

Dosyanızı kaydedin ve kapatın.

Sonraki adımda, bu betiği şu komutu kullanarak çalıştırabilirsiniz:

node array_raw_query.js

Aşağıdakine benzer bir çıktı göreceksiniz:

Connection has been established successfully.
[ { student_id: 'STUDENT_ID_YOU_RETRIEVED',
    name: 'Robert Gray',
    createdAt: 2022-05-06T13:14:50.000Z,
    updatedAt: 2022-05-06T13:14:50.000Z } ]

Seçilen student_id nedeniyle çıktı değerleriniz farklı olabilir.

Nesne Değiştirme

Görünüşte, nesne değiştirme dizi değiştirmeye benzer, ancak ham sorguya veri geçirme şekli farklıdır. Değiştirme seçeneğinde verileri bir nesne olarak geçirirsiniz, sorgu seçeneğinde ise :key gibi değerler kullanırsınız.

Başlamak için, object_raw_query.js adında yeni bir dosya oluşturun ve server.js dosyasındaki tüm kod bloklarını buraya yapıştırın, ardından veritabanını sample_student_db olarak güncelleyin.

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

Sonra, yeni object_raw_query.js dosyasının sonuna aşağıdaki kod bloğunu ekleyin:

...
sequelize.query(
  'SELECT * FROM students WHERE student_id = :id',
  {
    replacements: { id: 'REPLACE_STUDENT_ID' },
    type: sequelize.QueryTypes.SELECT
  }
 ).then(result => {
    console.log(result);
}).catch((error) => {
    console.error('Failed to insert data : ', error);
});

Burada, nesne değiştirme yöntemi kullanarak seçilen öğrenci verilerini alırsınız. Bir replacement nesnesi oluşturursunuz ve id'yi almak istediğiniz öğrenci bilgisi olarak ayarlarsınız: { id: '<mark>REPLACE_STUDENT_ID</mark>' }.

query() içinde şunu belirtiyorsunuz: 'SELECT * FROM students WHERE student_id=:id'. query() yöntemini kullanırken, yer değiştirme değerini bir nesne olarak geçirirsiniz; bu yüzden bu yöntem nesne yer değiştirme olarak bilinir.

İşte tam kod:

const {Sequelize, DataTypes} = require("sequelize");

const sequelize = new Sequelize(
   'sample_student_db',
   'DATABASE_USERNAME',
   'DATABASE_PASSWORD',
    {
      host: 'DATABASE_HOST',
      dialect: 'mysql'
    }
   );

sequelize.authenticate().then(() => {
    console.log('Connection has been established successfully.');
}).catch((error) => {
    console.error('Unable to connect to the database: ', error);
});

sequelize.query(
  'SELECT * FROM students WHERE student_id = :id',
  {
    replacements: { id: 'REPLACE_STUDENT_ID' },
    type: sequelize.QueryTypes.SELECT
  }
 ).then(result => {
    console.log(result);
}).catch((error) => {
    console.error('Failed to insert data : ', error);
});

Dosyayı kaydedip kapat.

Sonraki olarak, bu betiği aşağıdaki komutu kullanarak çalıştırın:

node object_raw_query.js

Çıktı aşağıdakine benzer görünecektir:

Connection has been established successfully.
[ { student_id: 'STUDENT_ID_YOU_RETRIEVED',
    name: 'Robert Gray',
    createdAt: 2022-05-06T13:14:50.000Z,
    updatedAt: 2022-05-06T13:14:50.000Z } ]

Seçilen student_id nedeniyle çıktı değerleriniz farklı olabilir.

Bu adımda, Sequelize ham sorguları ile iki farklı yöntem kullanarak çalıştınız: dizi değişimi ve nesne değişimi.

Güvenli Veritabanı Bağlantıları için Ortam Değişkenlerini Yapılandırma

Şu ana kadar, veritabanı kimlik bilgilerini doğrudan kodunuzda depoladınız. Bu yöntem yerel denemeler için işe yarasa da güvenli değildir. Kimlik bilgilerini sabit olarak kodlamak, veritabanı şifreleri ve sunucu adları gibi hassas bilgilerin açığa çıkmasına neden olur ve kod paylaşıldığında veya dağıtıldığında ihlal riskini artırır. Bu bölümde, bu kimlik bilgilerini ortam değişkenleri kullanarak nasıl güvenli bir şekilde depolayacağınızı öğreneceksiniz.

Neden Ortam Değişkenleri Kullanılır?

Ortam değişkenleri, uygulamanızın çalışma zamanında okuyabileceği harici yapılandırma parametreleri olarak işlev görür. Kimlik bilgilerini doğrudan kodunuza gömmek yerine, bunlar sisteminizde veya sürüm kontrolüne asla eklenmeyen ayrı bir yapılandırma dosyasında saklanır. Bu yaklaşım birden fazla fayda sağlar:

• Güvenlik: Kimlik bilgilerinizi genel depolardan ve sürüm kontrol sistemlerinden gizli tutar.
• Esneklik: Her ortam (geliştirme, test, üretim) kaynak kodunu değiştirmeden farklı bir veritabanı yapılandırması kullanabilir.
• Bakım Kolaylığı: Merkezi yapılandırma, güncellemeleri kolaylaştırır; veri tabanı şifresi değişirse, sadece bir dosya veya değişkeni değiştirmeniz yeterlidir.
• Uyumluluk: Bu uygulama, ölçeklenebilir uygulamalar için ortam-specific yapılandırma yönetimini teşvik eden On İki Faktörlü Uygulama metodolojisi ile uyumludur.

Ortam Değişkenlerini Ayarlama

Node.js'te ortam değişkenlerinizi yönetmek için dotenv paketini kullanacaksınız. Bu kütüphane, değişkenleri bir .env dosyasından okur ve bunları Node.js process.env nesnesine ekler, böylece uygulamanızın her yerinde erişilebilir hale getirir.

Aşağıdaki komutu çalıştırarak dotenv paketini yükleyin:

npm install dotenv

Kurulumdan sonra, projenizin kök dizininde .env adında yeni bir dosya oluşturun. Bu dosya, veritabanı bağlantısı için gereken tüm hassas verileri tutacaktır.

İşte Sequelize kurulumu için bir .env dosyası yapılandırma örneği:

DB_NAME=hello_world_db
DB_USER=your_username
DB_PASSWORD=your_password
DB_HOST=localhost
DB_DIALECT=mysql

Her değişken, Sequelize'ın bağlantıyı kurmak için kullandığı belirli bir parametreye karşılık gelir.

.env Dosyasını Güvence Altına Alma

.env dosyanızın hiçbir zaman sürüm kontrolünde görünmemesi çok önemlidir. Bunu önlemek için, değişiklikleri işlerken Git’in atlaması için .gitignore dosyanıza ekleyin:

.env

Üretim ortamlarında, ortam değişkenleri genellikle yerel bir .env dosyası yerine barındırma platformunuzun ayarlarında veya gizli yönetici aracında doğrudan yapılandırılır.

Sequelize Yapılandırmanızı Güncelleme

Artık ortam değişkenlerini tanımladığınıza göre, Sequelize başlatmanızı bunları kullanacak şekilde güncelleyin. Bunu, ana sunucu dosyanızın (örneğin, server.js) en üstünde dotenv öğesini içe aktararak ve yapılandırarak başlatın:

require('dotenv').config();
const Sequelize = require('sequelize');

const sequelize = new Sequelize(
  process.env.DB_NAME,
  process.env.DB_USER,
  process.env.DB_PASSWORD,
  {
    host: process.env.DB_HOST,
    dialect: process.env.DB_DIALECT
  }
);

sequelize.authenticate().then(() => {
   console.log('Connection has been established successfully.');
}).catch((error) => {
   console.error('Unable to connect to the database:', error);
});

1. require('dotenv').config() satırı, .env dosyasında tanımlanan tüm değişkenleri process.env içine yükler.
2. Sequelize, yeni bir örnek başlatırken ortam değişkenlerini okur.
3. Bu, kullanıcı adları veya şifreler gibi hassas bilgilerin kodunuzda görünmemesini sağlar.

Bu yaklaşım güvenliği artırır ve farklı ortamların yalnızca ortam değişkeni değerlerini değiştirerek benzersiz yapılandırmalar kullanmasına olanak tanır.

Yapılandırmayı Doğrulama

Yapılandırmanızı güncelledikten sonra, Node.js uygulamanızı çalıştırarak bağlantıyı doğrulayabilirsiniz:

node server.js

Eğer .env dosyanız doğru şekilde ayarlanmışsa ve MySQL sunucusu çalışıyorsa, aşağıdaki çıktıyı göreceksiniz:

Connection has been established successfully.

Bir hata görünürse, şunları tekrar kontrol edin:

• .env dosyanızdaki kimlik bilgileri, MySQL örneğinizdeki bilgilerle eşleşiyor.
• MySQL sunucusu çalışıyor ve bilgisayarınızdan erişilebilir durumda.
• .env dosyası proje kök dizininizde bulunur ve düzgün bir şekilde biçimlendirilmiştir.

Güvenli Yapılandırma İçin En İyi Uygulamalar

Ortam değişkenlerini kullanmak, güvenli yapılandırma yönetimi için güçlü bir ilk adımdır. Sürekli güvenlik ve güvenilirlik sağlamak için aşağıdaki ek en iyi uygulamaları göz önünde bulundurabilirsiniz:

• Her ortam için ayrı yapılandırmalar kullanın: development, staging ve production için farklı .env dosyaları tutun. Bunlara .env.development, .env.staging ve .env.production isimlerini verebilirsiniz.
• Gizli yöneticilerden yararlanın: Üretim ortamları için, gizli bilgileri dosyalarda saklamak yerine gizli yöneticileri kullanın.
• Ortam değişkenlerini doğrulayın: Uygulama çalışmadan önce gerekli değişkenlerin tanımlı olup olmadığını kontrol eden bir yapılandırma aracı veya başlatma betiği kullanın. Bu, çalışma zamanı hatalarını önlemeye yardımcı olur.
• Kimlik bilgilerini düzenli olarak değiştirin: Olası sızıntıların etkisini azaltmak için veritabanı kimlik bilgilerini periyodik olarak güncelleyin.
• Veritabanı erişimini sınırlayın: Veritabanı kullanıcı rollerini, uygulama için gerekli olan en az ayrıcalığa sahip olacak şekilde yapılandırın.

Çevre değişkenlerini uygulayarak ve bu uygulamaları takip ederek, Sequelize uygulamanızın hem geliştirme hem de üretim ortamlarında esnekliğini ve güvenliğini korumasını sağlarsınız.

Göç ve Senkronizasyon En İyi Uygulamaları

Bir veritabanı şemasını geliştirirken, Sequelize ile iki temel yaklaşımınız vardır: açıkça tanımlanmış migrationlar yazarak çalıştırmak veya sequelize.sync() kullanarak Sequelize’in şema değişikliklerini otomatik olarak üretmesine izin vermek. Her iki yaklaşım da geçerlidir, ancak farklı amaçlara hizmet eder ve farklı avantajlarla dezavantajlar içerir. Hangi durumda hangisinin kullanılacağını, güvenli migration’ların nasıl yazılacağını ve bunların geliştirme ve üretim ortamında nasıl güvenilir bir şekilde çalıştırılacağını anlamaya çalışalım.

Göçler ve sequelize.sync() — hangisini ne zaman kullanmalı

• Göçler (üretim için önerilir): Göçler, şemanızda yapılan açık ve sürümlü değişikliklerdir. Kaynak kontrolünde saklanır, kod incelemesinden geçirilir ve dağıtım sürecinizin bir parçası olarak uygulanır. Veri bütünlüğünü veya kullanılabilirliğini etkileyen herhangi bir şema değişikliği için üretimde göçleri kullanın.

• sequelize.sync() (sadece geliştirme ve prototipler için kullanılır): sync(), tabloları otomatik olarak oluşturabildiği veya ayarlayabildiği için yerel geliştirme, testler ve hızlı prototipler için kullanışlıdır. Ancak, üretimde sync({ force: true }) veya sync({ alter: true }) kullanmayın: bu seçenekler verileri silebilir veya kontrollü bir geri alma yolu olmadan güvensiz değişiklikler yapabilir.

Araçlar: sequelize-cli ve göç yürütücüleri

Resmî CLI olan sequelize-cli, Sequelize ile migration yönetmenin en basit yoludur. Daha fazla kontrol veya özel iş akışlarına ihtiyaç duyan ekipler için umzug popüler bir alternatif olarak kullanılmaktadır.

Projenize CLI'yi kurmak ve başlatmak için şunu çalıştırın:

npm install --save-dev sequelize-cli

npx sequelize-cli init

Bu, aşağıdaki klasörleri oluşturur:

config/        # Stores database configuration files
models/        # Stores your Sequelize model definitions
migrations/    # Stores migration files
seeders/       # Stores seeder files for inserting initial data

Bu klasörleri sürüm kontrolüne eklemelisiniz (kimlik bilgilerini içeren dosyalar hariç). Bu, her ortamın aynı veritabanı değişikliklerini tutarlı bir şekilde çalıştırmasını sağlar.

Göçler Oluşturma ve Çalıştırma

Yeni bir göç dosyası oluşturmak için aşağıdaki komutu kullanın:

npx sequelize-cli migration:generate --name add-isbn-to-books

Bu, migrations/ klasöründe zaman damgalı bir dosya oluşturur. Dosyayı açın ve geçişi uyguladığınızda (up) ne olacağını ve nasıl geri alacağınızı (down) tanımlayın:

module.exports = {
  async up(queryInterface, Sequelize) {
    await queryInterface.addColumn('books', 'isbn', {
      type: Sequelize.STRING
    });
  },
  async down(queryInterface) {
    await queryInterface.removeColumn('books', 'isbn');
  }
};

• up fonksiyonu migrasyonu uygular (kolon ekler).
• down fonksiyonu değişikliği geri alır (kolonu kaldırır).

Göçü şunu kullanarak çalıştırın:

npx sequelize-cli db:migrate

Son göçü geri almak için şunu kullanın:

npx sequelize-cli db:migrate:undo

Geliştirmede tüm geçişleri şu komutu çalıştırarak geri alabilirsiniz:

npx sequelize-cli db:migrate:undo:all

Güvenli, tekrarlanabilir göçler yazmak

Göçler (migrations) oluştururken bu kurallara uyun:

• İşlemleri veritabanı destekliyorsa transaction içinde yapın. Bu, geçişin ya tamamen başarılı olmasını ya da bir hata durumunda tamamen geri alınmasını sağlar.

  module.exports = {
    async up(queryInterface, Sequelize) {
      return queryInterface.sequelize.transaction(async (t) => {
        await queryInterface.addColumn('books', 'isbn', {
          type: Sequelize.STRING
        }, { transaction: t });
      });
    },
    async down(queryInterface) {
      return queryInterface.sequelize.transaction(async (t) => {
        await queryInterface.removeColumn('books', 'isbn', { transaction: t });
      });
    }
  };

• Göçleri küçük ve odaklı tutun. Her göç, tek bir mantıksal değişikliği gerçekleştirmelidir (bir sütun eklemek, bir indeks oluşturmak, bir sütunu yeniden adlandırmak). Daha küçük göçler, gözden geçirmeyi, test etmeyi ve geri almayı kolaylaştırır.

• Savunmacı ve değişmez olun. Uygun olduğunda, sapma olan ortamlarda hatalardan kaçınmak için varlığı kontrol edin. İşlemleri korumak için queryInterface.describeTable() veya ham sorgular kullanın.

• Yıkıcı işlemleri tek adımda yapmaktan kaçının. Örneğin, bir sütunu güvenli bir şekilde kaldırmak için önce yeni sütunu ekleyin, verileri geri doldurun, uygulama kodunda okumaları yeni sütuna yönlendirin ve ancak daha sonra eski sütunu sonraki bir geçişte kaldırın.

Uzun süren ve kesintisiz geçişler

Büyük tablolar ve indeks işlemleri kilitlenmelere neden olabilir. Etkiyi en aza indirmek için bu stratejileri kullanın:

1. Önce null değeri kabul edebilen sütunları ekleyin. Null değeri kabul edebilen bir sütun eklemek genellikle hızlıdır. Tüm tabloyu yeniden yazmayı tetikleyen karmaşık varsayılan değerleri olan sütunları eklemekten kaçının.
2. Verileri küçük partiler halinde doldurun. Tek bir büyük UPDATE çalıştırmak yerine, yeni sütunları parça parça doldurmak için arka plan görevi uygulayın.
3. Mümkünse özel kilitler olmadan indeks oluşturun. Göçler sırasında veritabanına özgü özellikleri (örneğin, Postgres CONCURRENTLY ve yeni MySQL çevrimiçi DDL) ham SQL ile kullanın.
4. Özellik bayrağı dağıtımları. Yeni sütunu okuyan uygulama kodunu bir özellik bayrağı arkasında dağıtın. Geri dolum tamamlandıktan ve testler geçtikten sonra bayrağı değiştirin ve daha sonra eski alanı kaldırın.

Geri alma işlemleri ve acil düzeltmeler

• down göçünü sağlayın. Her up işleminin, değişikliği nasıl geri alacağınızı belgeleyen bir ters down işlemi olmalıdır. Üretimde down işlemini nadiren çalıştırmanız bile, bunu net bir geri alma planı olarak hizmet eder.
• Acil geri alma planı yapın. Bir geçiş sorunlara yol açarsa, önce uygulama kodunu geri alacak ve gerekiyorsa veritabanını yedeklerden geri yüklemeye hazır olun. Geri yükleme prosedürlerini düzenli olarak test edin.

Veri ve şema değişikliklerini ekleme

• Seed verilerini minimum ve stabil tutun. Seedleri, temel arama veya yapılandırma satırları için kullanın. İş verilerinin büyük hacimlerde migration üzerinden eklenmesinden kaçının.
• Tohumları yapısal göçlerden ayırın. Eğer şema değişikliğine bağlı verileri doldurmanız gerekiyorsa, sorumlulukların net kalmasını sağlamak için tercih olarak takip eden bir tohumlayıcı kullanın.

Sürekli Entegrasyon (CI), kod incelemesi ve dağıtım otomasyonu

• Önce CI ve staging ortamında migration'ları çalıştırın. Hataları erken yakalamak için geçici bir veritabanı üzerinde migration'ları çalıştıran bir CI adımı ekleyin.

• Göçleri kod gibi ele alın. Pull request'lerde göç dosyalarını lint edin ve inceleyin. Mümkün olduğunda otomatik kontroller ekleyin.

• Dağıtımlar sırasında migration işlemlerini otomatikleştirin. Migrationların, uygulama süreçleri trafik almadan önce çalışmasını sağlayın. Örnek package.json betikleri:

  "scripts": {
    "migrate": "npx sequelize-cli db:migrate",
    "start": "node server.js",
    "deploy": "npm run migrate && npm run start"
  }

Konteyner tabanlı dağıtımlarda, geçişleri bir init container olarak veya bir deploy kancasında çalıştırın, böylece web süreçleri yalnızca geçişler tamamlandıktan sonra başlar.

Göçleri test etme

• Her iki yönü de test edin. db:migrate ardından db:migrate:undo:all komutlarını yerel ortamda ve CI üzerinde çalıştırarak up ve down işlemlerinin ikisinin de çalıştığını doğrulayın.
• Testler için tek kullanımlık veritabanları kullanın. Kesin sonuçlar elde etmek için geçici veritabanlarını veya konteynerleri tercih edin.

Bu en iyi uygulamaları takip etmek, Sequelize göçlerinizin uzun vadeli projeler için güvenilir, izlenebilir ve güvenli kalmasını sağlar.

Sorun Giderme ve Performans İpuçları

Sağlam bir kurulumla bile, Sequelize uygulamaları bazen veritabanı bağlantı hataları, göç (migration) başarısızlıkları, yavaş sorgular, kilitlenmeler veya eşzamanlılık çatışmaları gibi beklenmedik sorunlarla karşılaşabilir. Bu bölüm, bu sorunları tanımlama ve çözme konusunda adım adım rehberlik sağlar ve uygulamanızın stabil ve verimli kalmasına yardımcı olan performans en iyi uygulamalarını sunar.

Yaygın Sorunları Giderme

1. Bağlantı Hataları

Sorun: Sequelize, MySQL veritabanına bağlanamıyor ve SequelizeConnectionError: connect ECONNREFUSED, Access denied for user veya SequelizeHostNotFoundError gibi hatalar veriyor.

Nasıl Düzeltilir:

Bağlantı bilgilerinizin doğru olduğunu doğrulamakla başlayın. .env dosyanızdaki değerleri, veritabanı adı, kullanıcı adı, şifre, sunucu ve port dahil olmak üzere tekrar kontrol edin. Küçük bir yazım hatası veya sondaki boşluk bile Sequelize'in bağlanamamasına neden olabilir.

Sonraki adımda, MySQL sunucunuzun çalıştığından ve varsayılan portta (3306) dinlediğinden emin olun. Bağlantıyı manuel olarak giriş yaparak test edebilirsiniz:

mysql -u your_username -p -h your_host -P 3306

Eğer bu komut başarısız olursa, sorun muhtemelen MySQL servisinizde veya kimlik bilgilerinizdedir.

Eğer dotenv paketini kullanıyorsanız, require('dotenv').config() ifadesinin Sequelize başlatılmadan önce geldiğinden emin olun. Bu adım, tüm ortam değişkenlerinin çalışma zamanında kullanılabilir olmasını sağlar.

Son olarak, uzak bağlantılar için, güvenlik duvarı ayarlarınızı veya güvenlik grubu kurallarınızı kontrol edin. MySQL sunucusu, uygulamanızın çalıştığı cihazdan gelen gelen bağlantıları kabul etmelidir.

2. Göç Başarısızlıkları

Problem: npx sequelize-cli db:migrate veya sequelize.sync() komutlarını çalıştırdığınızda eksik tablolar, tekrar eden sütunlar veya şema uyumsuzlukları gibi hatalarla karşılaşırsınız.

Nasıl Düzeltilir:

Göç sorunları genellikle dosyalar yanlış sırayla çalıştırıldığında veya SQL işlemlerinde hatalar bulunduğunda ortaya çıkar. Sequelize, göçleri dosya adlarındaki zaman damgalarına göre işler, bu nedenle dosyaların doğru şekilde adlandırıldığını doğrulayın.

Bir göç başarısız olursa, hata mesajını detaylı bir şekilde inceleyin. Ardından, son göçü güvenli bir şekilde geri almak için şunu kullanın:

npx sequelize-cli db:migrate:undo

Taşıma dosyasını düzelttikten sonra tekrar çalıştırın.

Göç mantığınızı her zaman işlem (transaction) içine alın, böylece atomiklik sağlanmış olur: ya tüm değişiklikler başarılı olur ya da hiçbiri olmaz. Üretim ortamında göçleri çalıştırmadan önce, doğruluğunu onaylamak için bunları bir test veya yerel veritabanında iyice test edin.

3. Model Senkronizasyon Sorunları

Problem: Sequelize modelleriniz ve veritabanı şemanız eşleşmiyor, bu da eksik sütunlara, yanlış veri tiplerine veya güncel olmayan tablolara yol açıyor.

Nasıl Onarılır:

Üretim ortamında sequelize.sync({ force: true }) kullanmaktan kaçının, çünkü bu tabloyu silip yeniden oluşturur ve geri dönüşü olmayan veri kaybına yol açar. Benzer şekilde, sequelize.sync({ alter: true }) kullanırken dikkatli olun; şemaları öngörülemez şekilde değiştirebilir.

Bunun yerine, her şema değişikliğini açıkça tanımlayan belirgin göçleri tercih edin. Modellerinizi gerçek veritabanı yapısıyla karşılaştırmak için şunu kullanın:

await queryInterface.describeTable('tableName');

Bu, üretimi etkilemeden önce uyumsuzlukları tespit etmeye yardımcı olur.

4. Sorgu ve Zaman Aşımı Hataları

Problem: Bağlantı zaman aşımı veya Çok fazla bağlantı gibi zaman aşımıyla ilgili hatalar görüyorsunuz.

Nasıl Onarılır:

Zaman aşımı sorunları genellikle tükenmiş bağlantı havuzları veya kapatılmamış bağlantılardan kaynaklanır. Tüm Sequelize sorgularının düzgün bir şekilde bekletildiğinden emin olun, böylece kullanım sonrası bağlantılar havuza geri dönebilir.

Sequelize’in havuz yapılandırmasını, uygulamanızın iş yüküne daha uygun hale getirmek için de ince ayar yapabilirsiniz:

const sequelize = new Sequelize(DB_NAME, DB_USER, DB_PASSWORD, {
  host: DB_HOST,
  dialect: 'mysql',
  pool: {
    max: 10,
    min: 0,
    acquire: 30000,
    idle: 10000
  }
});

Uygulamanız birçok eşzamanlı kullanıcıyı yönetiyorsa, veritabanı yapılandırmanızda MySQL max_connections parametresini artırmayı düşünün. MySQL'de SHOW PROCESSLIST; komutunu kullanarak aktif bağlantıları izleyin ve sızıntı veya kullanılmayan oturumları tespit edin.

5. Yavaş Sorgu Performansı

Problem: Belirli sorgular beklenenden çok daha uzun sürüyor ve bu da API yanıtlarının yavaşlamasına veya yüksek gecikmeye neden oluyor.

Nasıl Teşhis Edilir:

Öncelikle hangi sorguların yavaş olduğunu belirleyerek başlayın. Sequelize'in çalıştırdığı tüm sorguları geçici olarak günlüklemeyi etkinleştirerek kaydedebilirsiniz:

const sequelize = new Sequelize(..., { logging: console.log });

Sonra, veritabanının sorguyu nasıl çalıştırdığını anlamak için MySQL’in EXPLAIN ifadesini kullanın:

EXPLAIN SELECT * FROM users WHERE email = 'user@example.com';

Eğer çıktıda “tam tablo taraması” görünüyorsa, sorguda bir indeks eksik demektir.

Ayrıca MySQL yavaş sorgu günlüğünü etkinleştirerek yavaş işlemleri otomatik olarak kaydedebilirsiniz:

SET GLOBAL slow_query_log = 'ON';
SET GLOBAL long_query_time = 1;

Nasıl Düzeltilir:

Sık sorgulanan sütunlara indeks ekleyin (özellikle WHERE, JOIN ve ORDER BY ifadelerinde kullanılanlar). SELECT * kullanmaktan kaçının, bunun yerine sadece ihtiyacınız olan alanları attributes seçeneğini kullanarak açıkça alın.

Sequelize gereksiz birleşimler içeren verimsiz sorgular üretiyorsa, sorguyu ham SQL kullanarak yeniden yazın. Büyük raporlar veya analiz sorguları için, bunları daha küçük adımlara bölün veya tekrar eden sonuçları depolamak için Redis gibi önbellekleme araçlarını kullanın.

6. Kilitlenmeler ve Eşzamanlılık Hataları

Problem: Özellikle yüksek yük altında, Deadlock found when trying to get lock; try restarting transaction gibi hatalar alırsınız.

Nasıl Teşhis Edilir:

Hangi sorguların veya tabloların dahil olduğunu belirlemek için MySQL'de InnoDB'nin durumunu kontrol edin:

SHOW ENGINE INNODB STATUS\G

Bu çıktı, son kilitlenmeler ve kilit beklemeleri hakkında ayrıntılı bilgiler içerir. Ayrıca, soruna yol açan sorgu dizilimini incelemek için genel veya işlem günlüklerini etkinleştirebilirsiniz.

Nasıl Düzeltilir:

Veri kilitleri birbirlerini beklediğinde ölü kilitler oluşur. Bunları minimize etmek için:

1. İşlemleri mümkün olduğunca kısa tutun. Kilit tutarken dış servisleri çağırmayın veya yoğun hesaplamalar yapmayın.

2. Dairesel beklemeleri önlemek için tablolar ve satırlara işlemler arasında her zaman aynı sırayla erişin.

3. Tekrarlayan kilitlenmeler için, üssel geri çekilmeli basit bir yeniden deneme mekanizması uygulayın:

   async function runWithRetry(fn, retries = 3) {
     for (let i = 0; i < retries; i++) {
       try {
         return await fn();
       } catch (err) {
         if (isDeadlockError(err) && i < retries - 1) {
           await sleep(100 * (i + 1));
           continue;
         }
         throw err;
       }
     }
   }

4. Satır düzeyinde kilitleri (SELECT ... FOR UPDATE) yalnızca gerektiğinde kullanın ve bunları hızlı bir şekilde serbest bırakın.

5. Büyük işlemleri, rekabeti azaltmak için daha küçük parçalara bölün.

6. Uygun olduğunda işlem izolasyon seviyelerini ayarlayın, ancak bunun veri tutarlılığını etkilemeyeceğini doğruladıktan sonra yapın.

Performans Optimizasyonu İpuçları

Performans sorunları genellikle verimsiz sorgulardan, eksik indekslerden veya kötü bağlantı yönetiminden kaynaklanır. İşte Sequelize performansını açıklık veya sürdürülebilirlikten ödün vermeden artırmak için birkaç pratik ipucu.

1. Sorguları Optimize Edin

Sadece gerekli olanı isteyen sorgular yazın. Gereksiz veri almak bellek kullanımını artırır ve yanıt sürelerini yavaşlatır. Alanları sınırlamak için attributes kullanın:

const users = await User.findAll({ attributes: ['id', 'name'] });

Her zaman sonuçları dizinlenmiş sütunları kullanarak filtreleyin ve mümkün olduğunda LIKE '%term%' gibi geniş aramalardan kaçının.

2. İndeksleri Etkili Bir Şekilde Kullanın

Dizinler aramaları hızlandırır, ancak yazma işlemlerini yavaşlatabilir. Dizinleri yalnızca ölçülebilir fayda sağladıkları yerlerde ekleyin. Bir dizin eklemeden önce ve sonra iyileşmeleri doğrulamak için MySQL’in EXPLAIN komutuyla sorgu performansını analiz edin:

await queryInterface.addIndex('users', ['email']);

3. Bağlantı Havuzunu Ayarla

Bağlantı havuzu, Sequelize'in kaç tane veritabanı bağlantısı sürdüreceğini belirler.

• Küçük uygulamalar için genellikle 5–10 bağlantı yeterlidir.
• Yüksek trafikli sistemler için, havuz boyutunu artırın ve bağlantı tıkanıklıklarını önlemek için zaman aşımlarını ayarlayın. Kullanımı düzenli olarak MySQL’in SHOW PROCESSLIST; komutunu kullanarak izleyin.

4. Günlük Kaydı ve İzlemeyi Etkinleştirin

SQL sorgularını incelemek için geçici olarak Sequelize loglamayı açın. Performans eşiklerinizi aşan sorguları tespit etmek için MySQL yavaş sorgu logunu kullanın. Gerçek zamanlı izleme için gecikme ve kaynak kullanımını ölçmek amacıyla PM2, New Relic veya Datadog gibi izleme araçlarını entegre edin.

5. Sık Yapılan Sorguları Önbelleğe Al

Sık değişmeyen veriler için sonuçları önbelleğe alın. Redis veya Memcached gibi araçlar, özellikle okuma ağırlıklı işler için veritabanı sorgularını azaltır ve yanıt sürelerini iyileştirir.

6. Sonuçları Sayfalandır

Büyük sonuç kümeleri önemli miktarda bellek tüketir. API’lerde sorguları her zaman sayfalandırın:

const users = await User.findAll({ limit: 50, offset: 100 });

Sayfalama, yanıtları hafif ve yük altında tutarlı kılar.

7. Karmaşık İşlemler İçin Ham Sorguları Kullanın

Eğer Sequelize’in soyutlaması belirli bir kullanım durumu için verimsiz SQL üretiyorsa, ham SQL sorgusunu doğrudan çalıştırın:

const [results] = await sequelize.query('SELECT name FROM users WHERE active = 1');

Ham sorguları sınırlı ve ihtiyatlı şekilde kullanın ve gelecekteki bakım için açıkça belgeleyin.

SSS

1. Node.js'te Sequelize nedir?

Sequelize, Node.js için bir nesne-ilişkisel eşleyici (ORM) olup, MySQL, PostgreSQL, SQLite ve MariaDB gibi SQL veritabanlarıyla çalışmak için yüksek seviyeli, JavaScript tabanlı bir API sağlar. Her işlem için ham SQL yazmak yerine, veritabanı tablolarına karşılık gelen modeller tanımlarsınız ve kayıt eklemek, sorgulamak, güncellemek ve silmek için model yöntemlerini kullanırsınız. Sequelize ayrıca modeller arasındaki ilişkiler (associations), işlemler (transactions), göçler (migrations) ve doğrudan SQL kullanmanız gerektiğinde ham sorguları da destekler.

2. Sequelize'i MySQL'e nasıl bağlarım?

Sequelize'u MySQL'e bağlamak için, veritabanı kimlik bilgilerinizi ve seçeneklerinizi kullanarak bir Sequelize örneği oluşturursunuz. Bir Node.js dosyasında Sequelize'i require edin, isteğe bağlı olarak ortam değişkenlerini yükleyin ve ardından veritabanı adı, kullanıcı adı, şifre ve host/dialect seçenekleri ile onu başlatın. Örneğin:

require('dotenv').config();
const { Sequelize } = require('sequelize');

const sequelize = new Sequelize(
  process.env.DB_NAME,
  process.env.DB_USER,
  process.env.DB_PASSWORD,
  {
    host: process.env.DB_HOST || 'localhost',
    dialect: 'mysql'
  }
);

await sequelize.authenticate();
console.log('Connected to the database successfully!');

Kimlik bilgilerini her zaman kaynak kontrolünün dışında tutun (örneğin, bir .env dosyasında veya bir gizli bilgiler yöneticisinde).

3. Sequelize'de modelleri nasıl oluşturur ve senkronize ederim?

Sequelize'da, modeller tabloları temsil eder. Bunları sequelize.define() kullanarak veya Model sınıfını genişleterek tanımlarsınız. Bundan sonra, bunları veritabanınızla eşleyebilir ve Sequelize'ın tabloları otomatik olarak oluşturmasını sağlayabilirsiniz (geliştirme için harika). İşte küçük bir örnek:

const { DataTypes } = require('sequelize');

const Book = sequelize.define('Book', {
  title: { type: DataTypes.STRING, allowNull: false },
  author: { type: DataTypes.STRING, allowNull: false },
  releaseDate: DataTypes.DATEONLY
});

// Create the table if it does not exist
await sequelize.sync();

Üretim ortamları için, şema değişiklikleri üzerinde sürüm kontrolüne sahip olmanız açısından migration kullanmak daha iyidir.

4. Sequelize'yi Express ile nasıl kullanırım?

Bir Express uygulamasında, Sequelize'i ayrı bir dosyada (örneğin db.js) başlatın, bağlı örneği ve modelleri dışa aktarın ve bunları route handler'larınızda veya controller'larınızda ihtiyacınız olan yerde içe aktarın. Route handler'larda Sequelize model yöntemlerini çağırmak için async/await kullanın ve hataları try/catch ile veya bir hata middleware'i ile yönetin. İşte pratikte bunun nasıl göründüğü:

// db.js
const sequelize = new Sequelize(...);
const User = sequelize.define(...);
module.exports = { sequelize, User };

// app.js
const { User } = require('./db');
app.get('/users', async (req, res) => {
  const users = await User.findAll();
  res.json(users);
});

İstekler geldiğinde veritabanı tablolarınızın mevcut olması için Express sunucunuzu başlatmadan önce göçleri çalıştırdığınızdan veya sequelize.sync() çağrısını kullandığınızdan emin olun.

5. Sequelize ile ham SQL sorguları arasındaki fark nedir?

Sequelize, veritabanı mantığını JavaScript ile yazmanıza olanak tanır, ham SQL ise SQL ifadelerini doğrudan yazmak anlamına gelir. Sequelize, modelleri ve ilişkileri bir kez tanımlayıp uygulamanızın her yerinde kullanabilmenizi sağladığı için kodunuzu daha temiz ve bakımı kolay hale getirir. Ham SQL ise daha fazla kontrol sağlar ve çok karmaşık sorgular için bazen daha hızlı olabilir.

Kısacası, çoğu günlük işlem için Sequelize kullanın ve performansı ince ayarlamanız gerektiğinde veya Sequelize’in kolayca ifade edemediği bir şeyi çalıştırmanız gerektiğinde raw SQL kullanın.

6. Sequelize'de ilişkileri nasıl tanımlayabilirim?

Sequelize, tablolar arasındaki ilişkileri tanımlamayı kolaylaştırır. hasOne, hasMany ve belongsToMany gibi basit yöntemleri kullanarak bire bir, bire çok veya çoktan çoğa ilişkiler kurabilirsiniz. Örneğin:

// One to one
User.hasOne(Profile);
Profile.belongsTo(User);

// One to many
Author.hasMany(Book);
Book.belongsTo(Author);

// Many to many
Student.belongsToMany(Course, { through: 'StudentCourse' });
Course.belongsToMany(Student, { through: 'StudentCourse' });

Bir kez tanımlandıktan sonra, ilgili verileri otomatik olarak çekmek için sorgularınızda include kullanabilirsiniz.

7. Göçler ve şema değişikliklerini nasıl yönetirim?

Geliştirme sürecinde tabloları hızlıca oluşturmak için sequelize.sync() kullanabilirsiniz. Ancak üretim ortamında her zaman migration kullanmalısınız. Migrationlar, veritabanı şemanızın zaman içindeki değişikliklerini tanımlayan ve Git commitlerinin kod değişikliklerini takip etmesine benzer şekilde versiyonlanmış dosyalardır.

Sequelize CLI ile bir göç (migration) oluşturabilirsiniz:

npx sequelize-cli migration:generate --name add-users-table

Her göç işleminde değişikliği uygulamak için bir up ve geri almak için bir down yöntemi bulunur. Göçlerinizi şu şekilde çalıştırın:

npx sequelize-cli db:migrate

Böylece, ekibinizdeki herkes (ve her dağıtım) aynı veritabanı yapısını korur.

Hızlı testler için sequelize.sync() kullanın, ancak uygulamanız yayında olduğunda göçler (migrations) ile devam edin çünkü onlar daha güvenli, geri alınabilir ve takip edilmesi daha kolaydır.

Sonuç

Bu öğreticide, verileri modeller, ilişkiler ve göçler aracılığıyla yönetmek için Node.js ve MySQL ile Sequelize kurulumunu gerçekleştirdiniz. Ayrıca, veritabanı bilgilerinizi ortam değişkenleri ile güvence altına aldınız ve hata ayıklama ve performans optimizasyonu için en iyi uygulamaları incelediniz.

Bu adımlar sayesinde artık Sequelize ve MySQL kullanarak veri yönetimi yapan güvenli ve verimli Node.js uygulamaları oluşturmak ve sürdürmek için sağlam bir temele sahipsiniz.

Sequelize hakkında daha fazla bilgi edinmek için ürün dokümantasyonuna göz atın. Benzer Node.js eğitimleri için aşağıdaki makalelere göz atabilirsiniz:

• Node.js'te Apollo Server ve Sequelize ile GraphQL Sunucusu Nasıl Kurulur
• Node.js'te Redis Kullanarak Önbellekleme Nasıl Uygulanır
• HTTP Modülü ile Node.js'te Web Sunucusu Nasıl Oluşturulur

Linux-Console.net Topluluğu ile öğrenme sürecine katıldığınız için teşekkürler.