Ham SQL Sorgularından Tür Güvenliğine: Prisma ORM ile Tanışma Hikayem

Ham SQL Sorgularından Tür Güvenliğine: Prisma ORM ile Tanışma Hikayem

Modern web uygulamaları geliştirirken veritabanı etkileşimi, çoğu zaman geliştiricilerin karşılaştığı en karmaşık ve hata potansiyeli yüksek alanlardan biri olmuştur. Özellikle büyük ve hızla büyüyen projelerde, ham SQL sorguları yazmak, hem güvenlik açıkları hem de bakım zorlukları açısından ciddi riskler barındırır. Peki, bu karmaşık SQL dünyasından sıyrılıp, daha güvenli, daha hızlı ve daha tip-güvenli bir veritabanı deneyimine nasıl geçiş yapabiliriz? İşte bu noktada, Object-Relational Mapping (ORM) araçları, özellikle de Prisma ORM, geliştiricilerin imdadına yetişiyor ve veritabanı etkileşimini kökten değiştiriyor. Bu makalede, ham SQL sorgularının getirdiği zorluklardan başlayarak, Prisma ORM’in sunduğu çözümleri, adım adım kurulumunu, kullanımını ve projelerinize nasıl değer katabileceğini detaylı bir şekilde inceleyeceğiz.

Neden Ham SQL Sorguları Geliştiricilerin Kabusu Haline Gelebilir?

Veritabanı, bir uygulamanın kalbidir ve doğru veri yönetimi, uygulamanın performansı ve güvenliği için hayati önem taşır. Ancak, veritabanıyla etkileşim kurmanın en temel yolu olan ham SQL sorguları yazmak, zamanla geliştiriciler için bir dizi zorluğu beraberinde getirir. İlk başta basit görünen sorgular, uygulamanın büyümesiyle birlikte karmaşıklaşır ve yönetilmesi güç bir hal alır.

Öncelikle, SQL enjeksiyonu riski, ham SQL kullanımının en büyük güvenlik açıklarından biridir. Kullanıcı girdilerini doğrudan SQL sorgularına dahil etmek, kötü niyetli kişilerin veritabanına yetkisiz erişim sağlamasına veya hassas verileri çalmasına olanak tanır. Bu tür saldırılar, bir uygulamanın itibarını ve kullanıcı güvenini ciddi şekilde zedeler. Parametreli sorgular kullanmak bu riski azaltabilse de, her zaman doğru şekilde uygulanmayabilir ve insan hatasına açıktır.

İkinci olarak, sözdizimi hataları ve manuel veri eşleme, geliştirme sürecini yavaşlatır. Ham SQL sorgularında küçük bir yazım hatası bile tüm sorgunun başarısız olmasına neden olabilir. Ayrıca, veritabanından dönen verilerin uygulama tarafındaki nesnelere (object) dönüştürülmesi (manuel veri eşleme), tekrarlayan ve hataya açık bir süreçtir. Örneğin, bir veritabanı tablosundaki kullanici_adi sütununu uygulamanızda userName özelliğine eşlemek, her sorguda manuel olarak yapılması gereken bir işlemdir. Bu durum, özellikle büyük veri kümeleri ve karmaşık veri yapılarıyla uğraşırken zaman alıcı ve yorucu hale gelir.

Üçüncü olarak, bakım zorluğu ve kod tekrarı, projeler büyüdükçe kaçınılmaz hale gelir. Aynı veya benzer sorguları uygulamanın farklı yerlerinde tekrar tekrar yazmak, kod tekrarına yol açar. Veritabanı şemasında yapılan küçük bir değişiklik, bu sorguların tamamının güncellenmesini gerektirebilir ki bu da büyük bir iş yükü ve hata potansiyeli demektir. Örneğin, bir Users tablosuna yeni bir sütun eklendiğinde, bu sütunu kullanan tüm sorguların manuel olarak güncellenmesi gerekir. Bu durum, özellikle birden fazla geliştiricinin çalıştığı projelerde koordinasyon sorunlarına ve tutarsızlıklara yol açabilir.

Son olarak, tip güvenliği eksikliği, modern geliştirme ortamlarında önemli bir dezavantajdır. Ham SQL sorguları, derleme zamanında (compile-time) herhangi bir tip kontrolü sunmaz. Bu da, veritabanından beklenen veri tipinin veya yapısının uygulama tarafında yanlış anlaşılması durumunda çalışma zamanı (runtime) hatalarına yol açar. TypeScript gibi tip-güvenli dillerin yaygınlaşmasıyla birlikte, geliştiriciler veritabanı etkileşimlerinde de benzer bir tip güvenliği arayışına girmişlerdir. Ham SQL, bu ihtiyacı karşılamaktan uzaktır ve geliştiricilerin sürekli olarak veritabanı şemasını akıllarında tutmasını veya manuel olarak kontrol etmesini gerektirir, bu da geliştirme hızını düşürür ve hatalara davetiye çıkarır.

Bu zorluklar, geliştiricileri daha verimli, güvenli ve sürdürülebilir bir veritabanı etkileşimi yöntemi aramaya itmiştir. İşte bu noktada, Object-Relational Mapping (ORM) araçları, özellikle de Prisma ORM gibi modern çözümler, devreye girerek bu sorunlara kapsamlı çözümler sunmaktadır. Ham SQL’in getirdiği bu kabustan kurtulmak için, ORM’lerin sunduğu avantajları ve Prisma’nın özel yeteneklerini keşfetmek, modern uygulama geliştirmede kritik bir adımdır.

ORM Nedir ve Veritabanı Etkileşimini Nasıl Kolaylaştırır?

Object-Relational Mapping (ORM), Türkçe karşılığıyla Nesne-İlişkisel Eşleme, nesne yönelimli programlama (OOP) dilleri ile ilişkisel veritabanları arasında bir köprü görevi gören bir programlama tekniğidir. Kısaca, uygulamanızdaki sınıfları (class) ve nesneleri (object) veritabanı tablolarına ve satırlarına eşleyerek, veritabanı işlemlerini doğrudan programlama dilinizin nesneleri üzerinden yapmanızı sağlar. Bu sayede, SQL sorguları yazmak yerine, programlama dilinizin doğal yapısını kullanarak veritabanı etkileşiminde bulunabilirsiniz.

ORM kullanmanın en önemli avantajlarından biri veritabanından bağımsızlık sağlamasıdır. Çoğu ORM aracı, farklı veritabanı sistemlerini (PostgreSQL, MySQL, SQL Server, SQLite vb.) destekler. Bu, uygulamanızın veritabanı katmanını değiştirmek istediğinizde, kodunuzun büyük bir kısmını yeniden yazmak zorunda kalmamanız anlamına gelir. Örneğin, uygulamanızı geliştirirken SQLite kullanıp daha sonra üretim ortamında PostgreSQL’e geçmek istediğinizde, ORM sayesinde veritabanı bağlantı ayarlarını değiştirmek çoğu zaman yeterli olacaktır. Bu, geliştirme esnekliğini artırır ve gelecekteki değişikliklere karşı uygulamanızı daha dirençli hale getirir.

Diğer bir büyük avantaj ise tip güvenliği ve kod okunabilirliğidir. Özellikle TypeScript gibi statik tipli dillerle kullanıldığında, ORM’ler veritabanı şemanızı uygulama kodunuza yansıtan tipler (types) üretir. Bu sayede, sorgularınızı yazarken otomatik tamamlama (autocomplete) özelliklerinden faydalanabilir, olası tip hatalarını derleme zamanında yakalayabilir ve çalışma zamanı (runtime) hatalarını minimuma indirebilirsiniz. Kodunuz daha okunaklı ve anlaşılır hale gelir, çünkü veritabanı tabloları yerine tanıdık nesneler ve özelliklerle çalışırsınız. Örneğin, bir kullanıcının adını almak için SELECT name FROM users WHERE id = 1; yazmak yerine, await prisma.user.findUnique({ where: { id: 1 } }).name; gibi daha sezgisel bir ifade kullanırsınız.

ORM’ler ayrıca geliştirme hızını artırır. Tekrarlayan SQL sorguları yazma ve veri eşleme işlemlerini otomatikleştirerek, geliştiricilerin daha çok iş mantığına odaklanmasını sağlar. Karmaşık sorguları bile birkaç satır kodla ifade etme yeteneği, prototipleme ve özellik geliştirme süreçlerini hızlandırır. Örneğin, bir kullanıcının tüm gönderilerini çekmek için karmaşık bir JOIN sorgusu yazmak yerine, ORM genellikle tek bir metot çağrısı ile bu işlemi halleder.

Elbette, ORM’lerin bazı dezavantajları da vardır. Başlangıçta bir öğrenme eğrisi olabilir ve ORM’in nasıl çalıştığını anlamak zaman alabilir. Bazı durumlarda, ORM’in ürettiği SQL sorguları manuel yazılan sorgular kadar optimize olmayabilir, bu da potansiyel performans sorunlarına yol açabilir. Ancak modern ORM’ler, bu tür sorunları minimize etmek için sürekli olarak geliştirilmektedir. Prisma, bu konuda özellikle başarılıdır; sorguları doğrudan veritabanına göndererek ve karmaşık JOIN’ler yerine akıllı sorgu optimizasyonları yaparak yüksek performans sunar.

Prisma’nın diğer ORM’lerden farkı, schema-first (şema öncelikli) yaklaşımı ve güçlü TypeScript entegrasyonudur. Prisma, veritabanı şemanızı tanımladığınız ayrı bir schema.prisma dosyası kullanır. Bu şema dosyasından yola çıkarak, veritabanınızı oluşturur/günceller ve uygulamanız için tip-güvenli bir istemci (Prisma Client) üretir. Bu yaklaşım, veritabanı ve uygulama kodunuz arasında her zaman tutarlılık olmasını sağlar. Geliştiriciler, veritabanı şemalarını tek bir merkezi yerden yönetirken, aynı zamanda uygulama kodlarında tam tip güvenliği ve otomatik tamamlama özelliklerinden faydalanır. Bu benzersiz yaklaşım, Prisma’yı modern web geliştirme dünyasında öne çıkaran temel özelliklerden biridir.

Prisma ORM’e İlk Adımlar: Kurulum ve Schema Tanımlama Süreci Nasıl İşler?

Prisma ORM ile çalışmaya başlamak, ham SQL’in karmaşık dünyasından uzaklaşarak daha düzenli ve tip-güvenli bir veritabanı etkileşimi yolculuğuna çıkmanın ilk adımıdır. Bu bölümde, Prisma’yı projenize nasıl kuracağınızı, temel şema (schema) tanımlamalarını nasıl yapacağınızı ve veritabanınızı nasıl senkronize edeceğinizi adım adım öğreneceğiz.

Prisma Kurulumu

Prisma’yı projenize dahil etmek oldukça basittir. Öncelikle, projenizin kök dizininde bir terminal açın ve aşağıdaki komutları çalıştırarak Prisma CLI’yı ve Prisma Client’ı yükleyin:

npm install prisma --save-dev
npm install @prisma/client

Burada prisma paketi, Prisma CLI (Komut Satırı Arayüzü) araçlarını içerir ve geliştirme bağımlılığı olarak eklenir. @prisma/client ise uygulamanızın veritabanıyla etkileşim kurmasını sağlayan tip-güvenli istemciyi içerir ve üretim bağımlılığı olarak eklenir.

Kurulum tamamlandıktan sonra, Prisma projenizi başlatmak için aşağıdaki komutu kullanın:

npx prisma init

Bu komut, projenizin kök dizininde bir prisma klasörü oluşturacak ve bu klasörün içine schema.prisma adında bir dosya yerleştirecektir. Ayrıca, veritabanı bağlantı ayarlarınızı tutmak için bir .env dosyası da oluşturulacaktır. .env dosyasında, veritabanı bağlantı dizenizi (connection string) tanımlamanız gerekecektir. Örneğin, PostgreSQL için şöyle bir bağlantı dizesi kullanabilirsiniz:

DATABASE_URL="postgresql://user:password@localhost:5432/mydb?schema=public"

Veritabanı türünüze göre bu dizeyi uygun şekilde düzenlemeniz önemlidir.

Schema Tanımlama: schema.prisma Dosyasının Yapısı

schema.prisma dosyası, Prisma’nın kalbidir. Bu dosya, veritabanı bağlantınızı, kullanılacak istemciyi ve veritabanı model tanımlarınızı içerir. Temel olarak üç ana bloktan oluşur:

• datasource bloğu: Veritabanı bağlantı bilgilerinizi tanımlar. Hangi veritabanı sağlayıcısını kullandığınızı ve bağlantı URL’sini belirtir.
• generator bloğu: Prisma Client’ın nasıl oluşturulacağını tanımlar. Genellikle provider = "prisma-client-js" olarak ayarlanır ve TypeScript veya JavaScript için istemci kodunu üretir.
• model blokları: Veritabanınızdaki tabloları ve bunların sütunlarını temsil eden modelleri tanımlar. Bu bloklar, uygulamanızdaki veri yapılarına doğrudan karşılık gelir ve Prisma’nın tip güvenliği sağlamasının temelini oluşturur.

Basit bir User (Kullanıcı) modeli örneği üzerinden gidelim. Bir kullanıcı modelinin kimlik (id), e-posta (email), isim (name) ve kayıt tarihi (createdAt) alanlarına sahip olduğunu varsayalım:

// prisma/schema.prisma

datasource db {
  provider = "postgresql" // veya "mysql", "sqlite", "sqlserver"
  url      = env("DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}

model User {
  id        Int      @id @default(autoincrement())
  email     String   @unique
  name      String?
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
}

Yukarıdaki model tanımında dikkat etmeniz gereken bazı noktalar var:

• model User { ... }: Bir User modeli tanımlar. Bu, veritabanında users adında bir tabloya karşılık gelecektir (Prisma varsayılan olarak çoğul isimlendirme kullanır).
• id Int @id @default(autoincrement()): id alanı bir tam sayıdır (Int), birincil anahtardır (@id) ve otomatik artan bir değere sahiptir (@default(autoincrement())).
• email String @unique: email alanı bir metin dizisidir (String) ve her kullanıcının e-postası benzersiz olmalıdır (@unique).
• name String?: name alanı isteğe bağlıdır (? işareti, bu alanın null olabileceğini belirtir).
• createdAt DateTime @default(now()): createdAt alanı bir tarih ve saat tipindedir ve varsayılan olarak kaydın oluşturulduğu anı alır.
• updatedAt DateTime @updatedAt: updatedAt alanı da bir tarih ve saat tipindedir ve kayıt her güncellendiğinde otomatik olarak güncellenir.

Veritabanı Senkronizasyonu: Prisma Migrate

schema.prisma dosyasında modellerinizi tanımladıktan sonra, bu şemayı veritabanınıza uygulamak için Prisma Migrate’i kullanmanız gerekir. Migrate, veritabanınızdaki şema değişikliklerini izlemenizi ve yönetmenizi sağlayan güçlü bir araçtır.

npx prisma migrate dev --name init

Bu komut:

• Veritabanınızda _prisma_migrations adında bir tablo oluşturur (eğer yoksa) ve bu tabloya migrasyon geçmişini kaydeder.
• prisma/migrations klasörü içinde yeni bir migrasyon dosyası oluşturur. Bu dosya, veritabanı şemanızdaki değişiklikleri içeren SQL komutlarını barındırır.
• Veritabanınızda User tablosunu oluşturur.
• Son olarak, en güncel Prisma Client’ı oluşturur veya günceller.

Artık veritabanınız, schema.prisma dosyanızdaki tanımlara uygun olarak hazır. Bir sonraki adımda, bu şema üzerinden nasıl veri sorgulayacağımızı ve manipüle edeceğimizi öğreneceğiz.

Prisma Client ile Güvenli Veri Sorgulamaları Nasıl Yapılır?

Prisma Client, schema.prisma dosyanızdan otomatik olarak üretilen tip-güvenli bir sorgu oluşturucudur. Uygulamanızın veritabanıyla etkileşim kurmasını sağlayan ana araçtır. Geliştirme ortamınızda Prisma Client’ı kullanarak, ham SQL sorguları yazma derdinden kurtulur ve TypeScript’in sunduğu tüm tip güvenliği avantajlarından faydalanırsınız. Bu sayede, hem kodunuz daha temiz ve okunabilir olur hem de olası hataları derleme zamanında yakalayarak çalışma zamanı hatalarını minimize edersiniz.

Prisma Client’ın Başlatılması

Prisma Client’ı kullanmaya başlamadan önce, uygulamanızda onu başlatmanız gerekir. Genellikle, uygulamanızın başlangıç dosyasında (örneğin index.ts veya app.ts) tek bir örnek (instance) oluşturulur ve bu örnek uygulamanın diğer bölümlerinde kullanılır.

// src/index.ts (veya benzeri bir dosya)
import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

async function main() {
  // Veritabanı işlemleri burada yapılacak
}

main()
  .catch(e => {
    console.error(e);
    process.exit(1);
  })
  .finally(async () => {
    await prisma.$disconnect(); // Uygulama kapanırken bağlantıyı kes
  });

Yukarıdaki kodda, PrismaClient sınıfını içe aktarıyor ve ondan bir örnek oluşturuyoruz. main fonksiyonu içinde asenkron veritabanı işlemlerimizi gerçekleştireceğiz. finally bloğu, uygulamanın kapanması durumunda veritabanı bağlantısının düzgün bir şekilde kesilmesini sağlar.

Temel CRUD İşlemleri (Create, Read, Update, Delete)

Prisma Client, veritabanındaki CRUD (Create, Read, Update, Delete) işlemlerini gerçekleştirmek için sezgisel ve tip-güvenli metotlar sunar. Daha önce tanımladığımız User modelini kullanarak bu işlemleri inceleyelim:

1. Veri Oluşturma (Create)

Yeni bir kayıt eklemek için create metodunu kullanırız. Bu metot, eklemek istediğiniz verileri bir nesne (object) olarak alır:

async function createUser() {
  const user = await prisma.user.create({
    data: {
      email: 'test@example.com',
      name: 'Test Kullanıcı',
    },
  });
  console.log('Oluşturulan Kullanıcı:', user);
  return user;
}

Prisma, data nesnesindeki alanların User modelinizle eşleştiğini otomatik olarak kontrol eder. TypeScript kullanıyorsanız, yanlış bir alan adı veya tip kullanmanız durumunda derleme zamanında hata alırsınız.

2. Veri Okuma (Read)

Veritabanından veri çekmek için çeşitli metotlar bulunur:

• findMany: Birden fazla kayıt çekmek için kullanılır. Filtreleme, sıralama ve sayfalama seçenekleri sunar.
• findUnique: Benzersiz bir alan (örneğin @unique veya @id ile işaretlenmiş alan) üzerinden tek bir kayıt çekmek için kullanılır.
• findFirst: Belirtilen koşullara uyan ilk kaydı döndürür.

async function findUsers() {
  // Tüm kullanıcıları çekme
  const allUsers = await prisma.user.findMany();
  console.log('Tüm Kullanıcılar:', allUsers);

  // Belirli bir e-posta adresine sahip kullanıcıyı çekme
  const userByEmail = await prisma.user.findUnique({
    where: {
      email: 'test@example.com',
    },
  });
  console.log('E-posta ile Kullanıcı:', userByEmail);

  // Adı "Test" ile başlayan ilk kullanıcıyı çekme
  const firstUserWithNameTest = await prisma.user.findFirst({
    where: {
      name: {
        startsWith: 'Test',
      },
    },
  });
  console.log('Adı Test ile Başlayan İlk Kullanıcı:', firstUserWithNameTest);
}

Bu sorgularda where nesnesi, SQL’deki WHERE koşuluna karşılık gelir ve gelişmiş filtreleme seçenekleri sunar.

3. Veri Güncelleme (Update)

Mevcut kayıtları güncellemek için update veya updateMany metotlarını kullanırız:

• update: Benzersiz bir koşul (genellikle id veya @unique alan) üzerinden tek bir kaydı günceller.
• updateMany: Belirtilen koşullara uyan birden fazla kaydı günceller.

async function updateUser(userId: number) {
  const updatedUser = await prisma.user.update({
    where: {
      id: userId,
    },
    data: {
      name: 'Güncel İsim',
      email: 'updated@example.com',
    },
  });
  console.log('Güncellenen Kullanıcı:', updatedUser);
  return updatedUser;
}

async function updateMultipleUsers() {
  const { count } = await prisma.user.updateMany({
    where: {
      name: {
        contains: 'Kullanıcı',
      },
    },
    data: {
      name: 'Yeni Genel İsim',
    },
  });
  console.log(${count} kullanıcı güncellendi.);
}

updateMany metodu, kaç kaydın güncellendiğini belirten bir nesne döndürür.

4. Veri Silme (Delete)

Kayıtları silmek için delete veya deleteMany metotlarını kullanırız:

• delete: Benzersiz bir koşul üzerinden tek bir kaydı siler.
• deleteMany: Belirtilen koşullara uyan birden fazla kaydı siler.

async function deleteUser(userId: number) {
  const deletedUser = await prisma.user.delete({
    where: {
      id: userId,
    },
  });
  console.log('Silinen Kullanıcı:', deletedUser);
  return deletedUser;
}

async function deleteMultipleUsers() {
  const { count } = await prisma.user.deleteMany({
    where: {
      email: {
        endsWith: '@example.com',
      },
    },
  });
  console.log(${count} kullanıcı silindi.);
}

Prisma Client, bu temel CRUD işlemlerini TypeScript ile tam entegre bir şekilde sunarak geliştiricilere güvenli, hızlı ve hatasız bir veritabanı etkileşimi deneyimi sağlar. Her bir metodun parametreleri ve dönüş tipleri, model tanımlarınızdan otomatik olarak türetilir, bu da size mükemmel bir geliştirici deneyimi ve güçlü bir tip güvenliği katmanı sunar.

İlişkisel Veritabanı Modelleri ve Prisma’nın İlişki Yönetimi Yetenekleri

Modern uygulamalar genellikle birden fazla veri modelini ve bu modeller arasındaki ilişkileri içerir. Örneğin, bir blog uygulamasında kullanıcılar (User) gönderiler (Post) oluşturabilir, gönderilerin yorumları (Comment) olabilir ve bu yorumlar da belirli kullanıcılara ait olabilir. Prisma ORM, bu tür karmaşık ilişkisel yapıları schema.prisma dosyasında kolayca tanımlamanıza ve bu ilişkiler üzerinden veri sorgulamanıza olanak tanır.

Model İlişkileri Tanımlama

Prisma’da ilişkiler, model alanlarına eklenen özel nitelikler (attributes) ve tipler (types) aracılığıyla tanımlanır. En yaygın ilişki türleri şunlardır:

1. Bire Bir (One-to-One): Bir modelin bir örneği, diğer modelin yalnızca bir örneğiyle ilişkilidir.
2. Bire Çok (One-to-Many): Bir modelin bir örneği, diğer modelin birden çok örneğiyle ilişkilidir.
3. Çoka Çok (Many-to-Many): Bir modelin birden çok örneği, diğer modelin birden çok örneğiyle ilişkilidir.

Örnek olarak, bir User‘ın birden fazla Post‘u olabileceği “Bire Çok” ilişkisini inceleyelim. Öncelikle schema.prisma dosyamızı güncelleyelim:

// prisma/schema.prisma

model User {
  id        Int      @id @default(autoincrement())
  email     String   @unique
  name      String?
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
  posts     Post[] // Bir kullanıcının birden fazla gönderisi olabilir
}

model Post {
  id        Int      @id @default(autoincrement())
  title     String
  content   String?
  published Boolean  @default(false)
  author    User     @relation(fields: [authorId], references: [id]) // Gönderinin bir yazarı var
  authorId  Int      // Yazarın ID'si
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
}

Yukarıdaki örnekte:

• User modeline posts Post[] alanı eklendi. Bu, bir User örneğinin birden fazla Post örneğine sahip olabileceğini belirtir. Post[], bir Post dizisi (array) anlamına gelir.
• Post modeline ise author User @relation(fields: [authorId], references: [id]) ve authorId Int alanları eklendi.
  • authorId Int: Bu, User modelinin birincil anahtarına (id) referans veren yabancı anahtar (foreign key) sütunudur.
  • author User: Bu, Post örneğinin ilişkili olduğu User nesnesini temsil eden bir ilişki alanıdır.
  • @relation(fields: [authorId], references: [id]): Bu nitelik, Post modelindeki authorId alanının User modelindeki id alanına referans verdiğini Prisma’ya bildirir.

Şema değişikliklerini uyguladıktan sonra, yeni bir migrasyon oluşturmayı unutmayın:

npx prisma migrate dev --name add_post_model

İlişkili Verileri Sorgulama: include ve select

Prisma Client, ilişkili verileri çekmek için güçlü include ve select seçenekleri sunar. Bu sayede, ihtiyacınız olan verileri tek bir sorguyla veritabanından alabilirsiniz, bu da N+1 sorgu sorununu (N+1 query problem) önlemeye yardımcı olur.

include ile İlişkili Verileri Çekme

Bir User‘ı çekerken, aynı zamanda o kullanıcının tüm gönderilerini de çekmek isteyebilirsiniz. Bunun için include seçeneğini kullanırız:

async function getUserWithPosts(userId: number) {
  const userWithPosts = await prisma.user.findUnique({
    where: { id: userId },
    include: {
      posts: true, // Kullanıcının gönderilerini de dahil et
    },
  });
  console.log('Kullanıcı ve Gönderileri:', userWithPosts);
  return userWithPosts;
}

Bu sorgu, User nesnesini ve bu nesnenin posts özelliği altında ilgili tüm Post nesnelerini döndürecektir. TypeScript, bu dönüş tipini otomatik olarak algılar ve size tip güvenliği sağlar.

Benzer şekilde, bir Post‘u çekerken yazar bilgilerini de dahil edebiliriz:

async function getPostWithAuthor(postId: number) {
  const postWithAuthor = await prisma.post.findUnique({
    where: { id: postId },
    include: {
      author: true, // Gönderinin yazarını dahil et
    },
  });
  console.log('Gönderi ve Yazarı:', postWithAuthor);
  return postWithAuthor;
}

select ile Belirli Alanları ve İlişkili Verileri Çekme

Bazen bir modelin tüm alanlarını veya ilişkili modelin tüm alanlarını çekmek istemeyebilirsiniz. Bu durumda select seçeneği devreye girer. select ile hem ana modelden hem de ilişkili modellerden çekmek istediğiniz belirli alanları belirtebilirsiniz:

async function getUserAndPostTitles(userId: number) {
  const user = await prisma.user.findUnique({
    where: { id: userId },
    select: {
      name: true,
      email: true,
      posts: {
        select: {
          title: true,
          published: true,
        },
      },
    },
  });
  console.log('Kullanıcı Adı, E-posta ve Gönderi Başlıkları:', user);
  return user;
}

Bu sorgu, sadece kullanıcının adını, e-postasını ve her bir gönderisinin başlığını ve yayınlanma durumunu döndürür. Bu, ağ trafiğini azaltır ve sadece ihtiyacınız olan verileri çekerek performansı artırır.

Prisma’nın ilişki yönetimi yetenekleri, karmaşık veri modelleriyle çalışırken geliştirici deneyimini önemli ölçüde iyileştirir. İlişkileri açıkça tanımlayarak ve include/select gibi güçlü sorgulama seçeneklerini kullanarak, uygulamanızın veritabanı etkileşimini daha verimli, okunabilir ve hatasız hale getirebilirsiniz. Bu, özellikle büyük ölçekli ve veri yoğun uygulamalar geliştirirken zaman ve kaynak tasarrufu sağlar.

Gelişmiş Prisma Kullanımı: Filtreleme, Sıralama ve Sayfalama Teknikleri

Uygulamalar büyüdükçe ve veri miktarı arttıkça, sadece temel CRUD işlemleri yeterli olmaz. Kullanıcıların belirli kriterlere göre verileri filtrelemesi, sonuçları belirli bir düzene göre sıralaması ve büyük veri kümelerini küçük, yönetilebilir sayfalara bölerek görüntülemesi gerekir. Prisma ORM, bu gelişmiş ihtiyaçları karşılamak için zengin sorgu seçenekleri sunar. Bu bölümde, Prisma ile güçlü filtreleme, sıralama ve sayfalama tekniklerini nasıl uygulayacağınızı inceleyeceğiz.

Güçlü Filtreleme (where Koşulları)

Prisma’nın where seçeneği, verileri belirli koşullara göre filtrelemek için son derece esnek ve güçlü bir yapı sunar. SQL’deki WHERE yan tümcesine benzer şekilde çalışır, ancak JavaScript/TypeScript nesneleri aracılığıyla daha sezgisel bir arayüz sağlar.

async function getFilteredPosts() {
  // Başlığı "Prisma" içeren ve yayınlanmış gönderileri bul
  const publishedPrismaPosts = await prisma.post.findMany({
    where: {
      title: {
        contains: 'Prisma', // SQL LIKE '%Prisma%'
      },
      published: true,
    },
  });
  console.log('Yayınlanmış Prisma Gönderileri:', publishedPrismaPosts);

  // Belirli bir tarihten sonra oluşturulan gönderileri bul
  const postsAfterDate = await prisma.post.findMany({
    where: {
      createdAt: {
        gte: new Date('2023-01-01T00:00:00.000Z'), // Greater Than or Equal
      },
    },
  });
  console.log('Belirli Tarihten Sonraki Gönderiler:', postsAfterDate);
}

Prisma, ayrıca mantıksal operatörler (AND, OR, NOT) kullanarak daha karmaşık filtreler oluşturmanıza olanak tanır:

async function getComplexFilteredUsers() {
  const users = await prisma.user.findMany({
    where: {
      OR: [ // VEYA koşulu
        {
          email: {
            endsWith: '@example.com',
          },
        },
        {
          name: {
            startsWith: 'A',
          },
        },
      ],
      NOT: { // DEĞİL koşulu
        name: null, // Adı null olmayan kullanıcılar
      },
    },
  });
  console.log('Karmaşık Filtreli Kullanıcılar:', users);
}

Bu filtreleme yetenekleri, kullanıcıların arama ve filtreleme ihtiyaçlarını karşılamak için son derece önemlidir.

Sıralama (orderBy)

Sorgu sonuçlarını belirli bir alana göre artan (ascending) veya azalan (descending) düzende sıralamak için orderBy seçeneğini kullanırız:

async function getOrderedPosts() {
  // Başlığa göre alfabetik sıralanmış gönderiler
  const postsByTitle = await prisma.post.findMany({
    orderBy: {
      title: 'asc', // Artan sıra (A-Z)
    },
  });
  console.log('Başlığa Göre Sıralı Gönderiler:', postsByTitle);

  // En son oluşturulan gönderiler
  const latestPosts = await prisma.post.findMany({
    orderBy: {
      createdAt: 'desc', // Azalan sıra (en yeni en başta)
    },
  });
  console.log('En Son Oluşturulan Gönderiler:', latestPosts);
}

Birden fazla sıralama kriteri de belirleyebilirsiniz:

async function getMultiOrderedPosts() {
  const posts = await prisma.post.findMany({
    orderBy: [
      { published: 'desc' }, // Önce yayınlanmış olanlar
      { createdAt: 'desc' }, // Sonra en yeniler
    ],
  });
  console.log('Çoklu Sıralamalı Gönderiler:', posts);
}

Sayfalama (Pagination)

Büyük veri kümelerini yönetmek için sayfalama, kullanıcı deneyimi açısından kritik öneme sahiptir. Prisma, skip (atla) ve take (al) seçenekleriyle kolayca sayfalama yapmanızı sağlar:

async function getPaginatedPosts(page: number, pageSize: number) {
  const skip = (page - 1) * pageSize;
  const take = pageSize;

  const posts = await prisma.post.findMany({
    skip: skip,
    take: take,
    orderBy: {
      createdAt: 'desc',
    },
  });

  const totalPosts = await prisma.post.count(); // Toplam gönderi sayısını al
  console.log(Sayfa ${page}, ${pageSize} gönderi:, posts);
  console.log(Toplam Gönderi Sayısı: ${totalPosts});
  return { posts, totalPosts };
}

// Örnek kullanım: 2. sayfadaki 5 gönderiyi çek
// getPaginatedPosts(2, 5);

Bu yöntem, “offset-based pagination” olarak bilinir. Kullanıcı arayüzlerinde “Sonraki Sayfa” veya “Önceki Sayfa” butonlarını uygulamak için idealdir. prisma.model.count() metodu ise toplam kayıt sayısını alarak sayfa numaralarını veya toplam sayfa sayısını hesaplamanıza yardımcı olur.

İleri Düzey Kullanım: Ham SQL Sorguları ($queryRaw, $executeRaw)

Prisma’nın güçlü ORM yeteneklerine rağmen, bazen çok özel veya optimize edilmiş ham SQL sorguları çalıştırmanız gerekebilir. Prisma, bu tür durumlar için $queryRaw ve $executeRaw metotlarını sunar. Bu metotlar, Prisma Client aracılığıyla tip-güvenli bir şekilde ham SQL sorguları çalıştırmanıza olanak tanır.

• $queryRaw: Veritabanından veri döndüren SELECT gibi sorgular için kullanılır.
• $executeRaw: Veritabanında değişiklik yapan INSERT, UPDATE, DELETE gibi sorgular için kullanılır ve etkilenen satır sayısını döndürür.

async function runRawQuery() {
  // Ham SQL ile belirli bir kullanıcının e-postasını çekme
  const result = await prisma.$queryRawSELECT email FROM "User" WHERE id = ${1};;
  console.log('Ham Sorgu Sonucu:', result);

  // Ham SQL ile bir kullanıcının adını güncelleme
  const updatedCount = await prisma.$executeRawUPDATE "User" SET name = ${'Ham SQL ile Güncellendi'} WHERE id = ${1};;
  console.log(${updatedCount} satır güncellendi.);
}

Bu metotları kullanırken, SQL enjeksiyon riskini önlemek için parametreli sorgu sözdizimini (yukarıdaki örnekte ${variable}) kullanmak hayati önem taşır. Prisma, bu parametreleri güvenli bir şekilde işleyerek olası saldırıları engeller. Bu sayede, Prisma’nın genel tip güvenliği ve kullanım kolaylığından ödün vermeden, gerektiğinde ham SQL’in gücünden faydalanabilirsiniz.

Transaction Yönetimi

Birden fazla veritabanı işleminin atomik (ya hep ya hiç) bir şekilde gerçekleşmesini sağlamak için transaction’lar (işlemler) kullanılır. Prisma, $transaction metodu ile transaction yönetimini basitleştirir:

async function createPostAndUserInTransaction() {
  try {
    const [newUser, newPost] = await prisma.$transaction([
      prisma.user.create({ data: { email: 'transaction@example.com', name: 'Transaction User' } }),
      prisma.post.create({ data: { title: 'Transaction Post', content: 'This is a post from a transaction.', published: true, author: { connect: { email: 'transaction@example.com' } } } }),
    ]);
    console.log('Transaction başarılı:', newUser, newPost);
  } catch (error) {
    console.error('Transaction başarısız oldu, geri alındı:', error);
  }
}

Bu örnekte, hem yeni bir kullanıcı oluşturuluyor hem de bu kullanıcıya ait bir gönderi ekleniyor. Eğer işlemlerden biri başarısız olursa, her ikisi de geri alınır ve veritabanı tutarlı kalır.

Prisma’nın sunduğu bu gelişmiş sorgulama, sayfalama, filtreleme ve transaction yönetimi yetenekleri, modern uygulamaların karmaşık veri ihtiyaçlarını karşılamak için geliştiricilere kapsamlı bir araç seti sunar. Bu özellikler sayesinde, veritabanı etkileşimi daha verimli, güvenli ve yönetilebilir hale gelir.

Prisma ORM ile Uygulamanızda Nasıl Bir Dönüşüm Yaşarsınız?

Prisma ORM’i bir projeye entegre etmek, sadece veritabanı sorgulama şeklinizi değiştirmekle kalmaz, aynı zamanda tüm geliştirme sürecinizde ve uygulamanızın genel sağlığında önemli bir dönüşüm yaratır. Ham SQL’den Prisma’ya geçişin getirdiği bu dönüşüm, hem geliştirme hızı hem de uygulamanın uzun vadeli sürdürülebilirliği açısından kayda değer faydalar sunar.

Geliştirme Hızı ve Hata Azaltma

Prisma’nın en belirgin faydalarından biri, geliştirme hızını önemli ölçüde artırmasıdır. Otomatik olarak üretilen tip-güvenli Prisma Client sayesinde, veritabanı etkileşimleri için manuel SQL sorguları yazma, parametreleri elle bağlama ve veri eşleme gibi tekrarlayan ve zaman alıcı görevlerden kurtulursunuz. TypeScript ile tam entegrasyonu, IDE’nizin (Entegre Geliştirme Ortamı) otomatik tamamlama (autocomplete) özelliklerini kullanarak çok daha hızlı kod yazmanızı sağlar. Bu, özellikle yeni özellikler geliştirirken veya mevcut kodda değişiklik yaparken zaman kazandırır.

// Ham SQL ile kullanıcı çekme (örnek)
// const user = await db.query('SELECT * FROM users WHERE id = $1', [userId]);
// return { id: user.rows[0].id, email: user.rows[0].email, ... };

// Prisma ile kullanıcı çekme
const user = await prisma.user.findUnique({ where: { id: userId } });
// user nesnesi doğrudan tip-güvenli olarak gelir, manuel eşlemeye gerek yok.

Bu hız artışının yanı sıra, hata oranlarında da ciddi bir azalma görülür. Ham SQL sorgularındaki yazım hataları, yanlış alan adları veya tip uyuşmazlıkları genellikle çalışma zamanında (runtime) ortaya çıkar ve hata ayıklaması (debugging) zor olabilir. Prisma’nın tip güvenliği sayesinde, bu tür hataların çoğu daha kod yazılırken veya derleme zamanında yakalanır. Bu, uygulamanızın daha kararlı ve güvenilir olmasını sağlar, üretim ortamında karşılaşacağınız beklenmedik hataları en aza indirir.

Bakım Kolaylığı ve Ekip Verimliliği

Uygulamalar büyüdükçe, kodun bakımı ve güncellenmesi giderek zorlaşır. Prisma, bu konuda da önemli avantajlar sunar. Veritabanı şemasının tek bir merkezi yerde (schema.prisma) tanımlanması, hem veritabanı yapısını anlamayı kolaylaştırır hem de şema değişikliklerinin yönetimini basitleştirir. Bir sütun adı değiştiğinde veya yeni bir model eklendiğinde, Prisma Migrate araçları bu değişiklikleri veritabanına sorunsuz bir şekilde uygular ve Prisma Client’ı güncelleyerek uygulama kodunuzun da otomatik olarak güncellenen tiplere sahip olmasını sağlar.

Bu merkezi şema yönetimi ve otomatik tip üretimi, özellikle büyük ekiplerde verimliliği artırır. Geliştiriciler, veritabanı şeması hakkında sürekli endişelenmek yerine, iş mantığına odaklanabilirler. Herkesin aynı, tip-güvenli arayüz üzerinden veritabanıyla etkileşim kurması, kod tabanında tutarlılık sağlar ve yeni ekip üyelerinin projeye adaptasyon sürecini hızlandırır. Kod incelemeleri (code reviews) daha verimli hale gelir, çünkü veritabanı etkileşimlerinin doğruluğu Prisma tarafından garanti altına alınmıştır.

Ölçeklenebilirlik ve Performans Değerlendirmesi

Prisma’nın mimarisi, yüksek performans ve ölçeklenebilirlik göz önünde bulundurularak tasarlanmıştır. Diğer ORM’lerin aksine, Prisma Client doğrudan veritabanına bağlanır ve sorguları optimize edilmiş SQL’e dönüştürür. Bu, gereksiz soyutlama katmanlarını ortadan kaldırarak daha düşük gecikme süresi (latency) ve daha yüksek verim (throughput) sağlar. Prisma’nın “prepared statements” (hazırlanmış ifadeler) kullanması, SQL enjeksiyonuna karşı güvenlik sağlarken aynı zamanda sorgu performansını artırır.

Ancak, her ORM gibi, Prisma’nın da bazı durumlarda manuel olarak optimize edilmiş SQL sorgularından biraz daha yavaş çalışabileceği durumlar olabilir. Bu tür senaryolar genellikle çok karmaşık raporlama sorguları veya büyük veri kümeleri üzerinde yoğun analiz gerektiren işlemlerdir. Bu gibi durumlarda, Prisma’nın $queryRaw ve $executeRaw metotları devreye girer. Geliştiriciler, gerektiğinde ham SQL’in gücünden faydalanarak performans darboğazlarını aşabilirler. Bu esneklik, Prisma’yı hem hızlı geliştirme hem de performans odaklı uygulamalar için uygun bir çözüm haline getirir.

Gerçek Dünya Senaryosu: Bir Startup’ın Prisma’ya Geçişi

Bir e-ticaret startup’ı düşünelim. Başlangıçta, küçük bir ekip ham SQL sorguları kullanarak ürün kataloglarını, kullanıcılarını ve siparişlerini yönetiyordu. Proje büyüdükçe, yeni özellikler eklemek, SQL enjeksiyonu endişeleriyle başa çıkmak ve veritabanı şemasındaki değişiklikleri tüm sorgulara yansıtmak ciddi bir baş ağrısı haline geldi. Geliştiriciler, sürekli olarak SQL sorgularını test etmek ve manuel veri eşleme hatalarını ayıklamakla zaman kaybediyordu.

Prisma ORM’e geçiş yapmaya karar verdiklerinde, ilk olarak mevcut veritabanı şemalarını Prisma modellerine dönüştürdüler. Prisma Migrate ile migrasyonları yönetmeye başladılar. Bu geçişin ardından, geliştiriciler şu faydaları gözlemledi:

• Hızlanan Geliştirme: Yeni ürün ekleme, sipariş detaylarını çekme gibi işlemler için saatler süren SQL yazma ve test etme süreçleri, dakikalara indi. Otomatik tamamlama sayesinde, veritabanı alan adlarını hatırlama derdi kalmadı.
• Azalan Hata Oranı: Özellikle tip uyuşmazlığı ve yanlış alan adı kullanımı kaynaklı hatalar, derleme zamanında yakalandığı için üretim ortamında neredeyse sıfıra indi.
• Kolay Bakım: Ürün modeline yeni bir özellik (örneğin “stok adedi”) eklendiğinde, sadece schema.prisma dosyasını güncelleyip migrasyon çalıştırmak yeterli oldu. İlişkili tüm kodlar, Prisma Client’ın otomatik güncellenmesi sayesinde tip-güvenli kaldı.
• Ekip İşbirliği: Yeni geliştiricilerin projeye adaptasyonu hızlandı. Veritabanı şeması açık ve anlaşılır bir şekilde tanımlandığı için, veritabanı yapısını anlamak için saatler harcamak yerine doğrudan iş mantığına odaklanabildiler.

Bu senaryo, Prisma’nın bir uygulamanın ve onu geliştiren ekibin üzerinde nasıl dönüştürücü bir etki yaratabileceğinin somut bir örneğidir. Ham SQL’in getirdiği zorluklardan kurtulup, daha modern, güvenli ve verimli bir geliştirme sürecine geçiş yapmak isteyen her proje için Prisma ORM, güçlü bir adaydır.

Sonuç: Ham SQL’den Tür Güvenliğine Yolculuğunuzda Prisma Neden Yanınızda Olmalı?

Ham SQL sorgularının karmaşıklığı, güvenlik riskleri ve bakım zorlukları, modern uygulama geliştiricileri için uzun yıllardır süregelen bir sorundu. Özellikle TypeScript gibi tip-güvenli dillerin yaygınlaşmasıyla birlikte, veritabanı etkileşimlerinde de benzer bir güvenliği ve verimliliği arayışına girildi. İşte bu noktada, Prisma ORM, geliştiricilerin bu arayışına güçlü ve kapsamlı bir yanıt sunarak, ham SQL’den tür güvenliğine doğru yapılan yolculukta vazgeçilmez bir araç haline gelmiştir.

Prisma’nın sunduğu temel avantajları özetlemek gerekirse:

• Tip Güvenliği: TypeScript ile tam entegrasyonu sayesinde, veritabanı sorgularınızda derleme zamanı tip kontrolü sağlar, hataları çalışma zamanına taşımadan önce yakalamanıza yardımcı olur.
• Geliştirici Deneyimi (DX): Sezgisel API’si, otomatik tamamlama özellikleri ve kolay okunabilir sorgu yapısı ile geliştirme sürecini hızlandırır ve daha keyifli hale getirir.
• Schema-First Yaklaşım: Veritabanı şemanızı tek bir merkezi dosyada (schema.prisma) tanımlamanıza olanak tanır. Bu, hem veritabanı yapısını anlamayı hem de migrasyonları yönetmeyi basitleştirir.
• Güvenlik: Parametreli sorguları otomatik olarak kullanarak SQL enjeksiyonu gibi yaygın güvenlik açıklarına karşı koruma sağlar.
• Performans: Doğrudan veritabanına bağlanma ve optimize edilmiş SQL üretme yeteneği sayesinde yüksek performans sunar. Gerektiğinde ham SQL sorgularına da izin vererek esneklik sağlar.
• Bakım Kolaylığı: Kod tekrarını azaltır, veritabanı şeması değişikliklerini kolayca yönetmenizi sağlar ve uygulamanızın uzun vadeli sürdürülebilirliğini artırır.

Bir e-ticaret uygulamasının geliştirme sürecini hızlandırmasından, büyük bir ekibin veritabanı etkileşimlerinde tutarlılık sağlamasına kadar, Prisma ORM’in gerçek dünya projelerine kattığı değer ortadadır. Geliştiricilerin daha az hata yapmasını, daha hızlı kod yazmasını ve en önemlisi, uygulamanın iş mantığına odaklanmasını sağlayarak, veritabanı yönetimini bir yük olmaktan çıkarıp bir avantaj haline getirir.

Eğer siz de ham SQL sorgularının getirdiği kısıtlamalardan sıkıldıysanız ve modern, tip-güvenli ve verimli bir veritabanı etkileşimi arıyorsanız, Prisma ORM’i projenize dahil etmek, atabileceğiniz en iyi adımlardan biri olacaktır. Bu, sadece bugünün değil, yarının da gereksinimlerini karşılayacak, daha sağlam ve ölçeklenebilir uygulamalar inşa etmenize yardımcı olacaktır.

Sıkça Sorulan Sorular (SSS)

Prisma sadece TypeScript ile mi kullanılır?

Hayır, Prisma hem TypeScript hem de JavaScript projelerinde kullanılabilir. Ancak, TypeScript ile kullanıldığında, Prisma’nın otomatik olarak ürettiği tip tanımlamaları sayesinde tam tip güvenliğinden ve geliştirici deneyiminden en üst düzeyde faydalanırsınız.

Prisma hangi veritabanlarını destekler?

Prisma; PostgreSQL, MySQL, SQLite, SQL Server ve CockroachDB gibi popüler ilişkisel veritabanlarını destekler. Yeni veritabanı sağlayıcıları için destek sürekli olarak geliştirilmektedir.

Prisma’nın performansı nasıldır?

Prisma, performansı yüksek bir ORM’dir. Doğrudan veritabanına bağlanır, optimize edilmiş SQL sorguları üretir ve “prepared statements” kullanır. Bu sayede çoğu senaryoda manuel yazılmış SQL sorgularına yakın veya eşit performans sunar. Çok özel durumlarda, $queryRaw veya $executeRaw metotları ile ham SQL çalıştırarak performansı daha da optimize edebilirsiniz.

Prisma ile ham SQL sorguları çalıştırabilir miyim?

Evet, Prisma, $queryRaw ve $executeRaw metotları aracılığıyla ham SQL sorguları çalıştırmanıza olanak tanır. Bu, ORM’in yetersiz kaldığı veya özel optimizasyon gerektiren durumlar için büyük bir esneklik sağlar. Ancak, SQL enjeksiyonu riskini önlemek için bu metotları kullanırken parametreli sorgu sözdizimine dikkat etmeniz önemlidir.

Prisma öğrenmesi zor bir ORM midir?

Prisma’nın temel kavramları (schema tanımlama, modelleme, temel CRUD) oldukça sezgisel ve kolay öğrenilebilir. Özellikle TypeScript kullanıcıları için sunduğu tip güvenliği ve otomatik tamamlama, öğrenme sürecini hızlandırır. Karmaşık ilişkiler ve gelişmiş sorgulama teknikleri biraz pratik gerektirse de, genel olarak diğer ORM’lere göre daha modern ve kullanıcı dostu bir öğrenme eğrisine sahiptir.

#PrismaORM #VeritabanıYönetimi #TypeScript #WebGeliştirme #SQL