@devoplus/one-sdk 0.0.0-stage → 0.2.0-next.112

package/dist/data/crud.js

@@ -0,0 +1,614 @@
+// Kayıt işlemleri (D-84): `one.data.json`'daki bir varlık için hazır liste/okuma/oluşturma/güncelleme/silme uçları +
+// dışa aktarma (D-85). Uygulama yazmaz, yapılandırır:
+//
+//   const requests = createCrudHandler({ model: dataModel, entity: 'requests', records: 'shared', canWrite: 'One.Talep.Write' })
+//   const res = await requests.handle(request, env.DB); if (res) return res
+//
+// Uçlar (`basePath` varsayılan `/api`):
+//   GET    /api/<varlık>                   sayfalı liste — ?_page=1&_size=50&_sort=-created_at · <alan>=<değer> (eşitlik) ·
+//                                          <alan>.contains=<metin> (metin içerir; Türkçe katlanmış — büyük/küçük harf ve
+//                                          ç/ğ/ı/ö/ş/ü duyarsız, S15) · <alan>.from / <alan>.to (aralık, dahil)
+//   POST   /api/<varlık>                   kayıt oluşturur (201)
+//   GET    /api/<varlık>/<id>              tek kayıt
+//   PATCH  /api/<varlık>/<id>              gönderilen alanları günceller
+//   DELETE /api/<varlık>/<id>              siler (varsayılan yumuşak silme: `deleted_at` dolar) — 204
+//   GET    /api/<varlık>/export.csv|export.xlsx   listeyle aynı süzgeçlerle dışa aktarma (?_lang=tr|en)
+//   GET    /api/<varlık>/report.html       yazdırmaya uygun rapor sayfası (aynı süzgeçler)
+//
+// ⛔ Güvenlik:
+//  • SQL'e yalnız MODELDEKİ adlar (tırnaklı) girer; her değer bağlı parametredir (`?`). Sıralama alanı da modelden seçilir.
+//  • `created_by` / `updated_by` oturumdan yazılır; gövdedeki sistem alanı (id, created_by …) REDDEDİLİR.
+//  • Okuma ve yazma oturum ister (401). `canRead` / `canWrite` uygulama izni (`hasPermission`) ya da işlev alır (403).
+//  • Vekalet / Yerine Görüntüle oturumunda yazma varsayılan KAPALIDIR (`actingSessions: 'write'` ile açılır; manifest'te de
+//    `actingSessions: "write"` beyan edilmelidir — platform kapısı onsuz isteği zaten durdurur, bu ikinci savunmadır).
+//  • `records: 'own'` her sorguya `created_by = <oturumdaki kişi>` koşulunu ekler: kişi yalnız kendi kayıtlarını görür.
+import { OneError, hasPermission, isActingSession, readContext, requireUser } from '../context.js';
+import { logEvent } from '../log.js';
+import { problemResponse } from '../problem.js';
+import { DEFAULT_TIME_ZONE, formatDate } from '../export/columns.js';
+import { toCsv } from '../export/csv.js';
+import { renderPrintableReport, reportResponse } from '../export/report.js';
+import { exportResponse } from '../export/response.js';
+import { toXlsx } from '../export/xlsx.js';
+import { DataModelError, SYSTEM_COLUMNS, parseDataModel } from './model.js';
+import { foldSearchText, foldSqlExpression } from './fold.js';
+import { coerceFilter, coerceInput, defaultDbValue, outputValue } from './values.js';
+export const CRUD_MAX_PAGE_SIZE = 200;
+export const CRUD_MAX_FILTERS = 20;
+export const CRUD_MAX_BODY_BYTES = 1024 * 1024;
+export const CRUD_REPORT_MAX_ROWS = 2_000;
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+/** Alan hatalarını taşıyan hata — yanıtta RFC 9457 gövdesine `errors: [{ field, message }]` olarak eklenir. */
+export class DataValidationError extends OneError {
+    errors;
+    constructor(status, code, detail, errors) {
+        super(status, code, detail);
+        this.errors = errors;
+    }
+}
+const parsedModels = new WeakMap();
+/** Modeli doğrulamadan (ham `one.data.json` biçiminde) bir varlıkta verilen adda alan var mı? */
+function fieldNameIn(model, entity, field) {
+    const fields = model.entities?.[entity]?.fields;
+    return fields !== undefined && Object.prototype.hasOwnProperty.call(fields, field);
+}
+function loadModel(model) {
+    const cached = parsedModels.get(model);
+    if (cached)
+        return cached;
+    try {
+        const parsed = parseDataModel(model);
+        parsedModels.set(model, parsed);
+        return parsed;
+    }
+    catch (e) {
+        if (e instanceof DataModelError)
+            throw new OneError(500, 'ONE-SDK-E-100', `Veri modeli geçersiz: ${e.message}`);
+        throw e;
+    }
+}
+const q = (name) => `"${name}"`;
+const SYSTEM_SET = new Set(SYSTEM_COLUMNS);
+function allowed(ctx, rule) {
+    if (rule === undefined)
+        return true;
+    return typeof rule === 'string' ? hasPermission(ctx, rule) : rule(ctx) === true;
+}
+function problem(e) {
+    const body = { type: 'about:blank', title: e.code, status: e.status, detail: e.message, code: e.code };
+    if (e instanceof DataValidationError)
+        body.errors = e.errors;
+    const headers = new Headers({ 'content-type': 'application/problem+json; charset=utf-8' });
+    if (e.status === 405)
+        headers.set('allow', e.message.match(/\(([^)]+)\)/)?.[1] ?? '');
+    return new Response(JSON.stringify(body), { status: e.status, headers });
+}
+const json = (body, status = 200, headers = {}) => new Response(JSON.stringify(body), { status, headers: { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store', ...headers } });
+async function readJsonBody(request) {
+    const type = (request.headers.get('content-type') ?? '').split(';')[0].trim().toLowerCase();
+    if (type !== 'application/json')
+        throw new OneError(415, 'ONE-SDK-E-109', 'Gövde application/json türünde olmalı.');
+    const declared = request.headers.get('content-length');
+    if (declared !== null && Number(declared) > CRUD_MAX_BODY_BYTES)
+        throw new OneError(413, 'ONE-SDK-E-108', 'Gövde 1 MB sınırını aşıyor.');
+    const chunks = [];
+    let total = 0;
+    if (request.body) {
+        const reader = request.body.getReader();
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            total += value.byteLength;
+            if (total > CRUD_MAX_BODY_BYTES) {
+                await reader.cancel().catch(() => undefined);
+                throw new OneError(413, 'ONE-SDK-E-108', 'Gövde 1 MB sınırını aşıyor.');
+            }
+            chunks.push(value);
+        }
+    }
+    const bytes = new Uint8Array(total);
+    let offset = 0;
+    for (const c of chunks) {
+        bytes.set(c, offset);
+        offset += c.byteLength;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(new TextDecoder().decode(bytes));
+    }
+    catch {
+        throw new OneError(400, 'ONE-SDK-E-101', 'Gövde geçerli JSON değil.');
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+        throw new OneError(400, 'ONE-SDK-E-101', 'Gövde bir JSON nesnesi olmalı.');
+    return parsed;
+}
+const RANGE_TYPES = new Set(['number', 'money', 'date', 'datetime']);
+const CONTAINS_TYPES = new Set(['text', 'longText']);
+const SYSTEM_DATETIME = ['created_at', 'updated_at'].map((name) => ({
+    name,
+    column: name,
+    type: 'datetime',
+    title: { tr: name === 'created_at' ? 'Oluşturulma' : 'Güncellenme', en: name === 'created_at' ? 'Created' : 'Updated' },
+    required: true,
+    unique: false,
+    index: false,
+    default: undefined,
+    choices: [],
+    maxLength: undefined,
+    foldColumn: undefined,
+    min: undefined,
+    max: undefined,
+}));
+const CREATED_BY_FIELD = { ...SYSTEM_DATETIME[0], name: 'created_by', column: 'created_by', type: 'person', title: { tr: 'Oluşturan', en: 'Created by' } };
+/**
+ * `içerir` koşulu (S15): alanın Türkçe katlanmış gölgesinde arar; gölge boşsa (eski ya da elle yazılmış kayıt) aynı
+ * katlama veritabanında anında uygulanır. `instr` desen dili kullanmaz: % ve _ joker değildir, kaçış gerekmez.
+ * Aranan ifade de AYNI kuralla katlanır (`foldSearchText`) — çağıran onu bağlı parametre olarak ekler.
+ */
+function containsClause(f) {
+    const fold = f.foldColumn ?? f.column;
+    return `instr(coalesce(${q(fold)}, ${foldSqlExpression(f.column)}), ?) > 0`;
+}
+/**
+ * Hazır liste bileşeninin (`<one-table src>`, D-83) sorgu lehçesi → bu uçların lehçesi. Bileşen `limit` · `page` ·
+ * `cursor` · `sort` + `order` · `q` · `<alan>From` / `<alan>To` · `lang` gönderir; uçlar `_size` · `_page` · `_sort` ·
+ * `<alan>.contains` · `<alan>.from` / `<alan>.to` · `_lang` bekler. İki lehçe aynı uçta çalışır: bileşen `src` olarak
+ * doğrudan `/api/<varlık>` alabilir (D-82 şablonları bunu kullanır; önce 400 "Bilinmeyen sorgu parametresi" dönüyordu).
+ *
+ * ⚠️ Lehçe adı modeldeki bir ALAN adıysa (ör. alanın adı `page`) o parametre alan süzgecidir — model önceliklidir
+ * (geriye uyum). `q` metin alanlarının (text · longText) HERHANGİ birinde içerir araması yapar (Türkçe katlanmış,
+ * `.contains` ile aynı kural). `cursor` bu uçlarda sayfa numarasıdır (yanıttaki `nextCursor`).
+ */
+export function translateTableDialect(entity, params) {
+    const fieldNames = new Set(entity.fields.map((f) => f.name));
+    const out = new URLSearchParams();
+    const issues = [];
+    let search = null;
+    let sort = null;
+    let order = null;
+    const alias = (from, to, value) => {
+        if (params.has(to))
+            issues.push({ field: from, message: `"${from}" ile "${to}" birlikte verilemez.` });
+        else
+            out.append(to, value);
+    };
+    for (const [key, value] of params) {
+        if (fieldNames.has(key)) {
+            out.append(key, value);
+            continue;
+        }
+        if (key === 'limit')
+            alias(key, '_size', value);
+        else if (key === 'page')
+            alias(key, '_page', value);
+        else if (key === 'cursor') {
+            if (!/^\d{1,6}$/.test(value))
+                issues.push({ field: key, message: '"cursor" geçersiz (bu uçta sayfa numarasıdır).' });
+            else if (params.has('page') || params.has('_page'))
+                issues.push({ field: key, message: '"cursor" sayfa parametresiyle birlikte verilemez.' });
+            else
+                out.append('_page', value);
+        }
+        else if (key === 'sort' || key === 'order') {
+            if (params.getAll(key).length > 1)
+                issues.push({ field: key, message: `"${key}" sorgu parametresi bir kez verilebilir.` });
+            else if (key === 'sort')
+                sort = value;
+            else
+                order = value;
+        }
+        else if (key === 'q') {
+            if (params.getAll('q').length > 1)
+                issues.push({ field: key, message: '"q" sorgu parametresi bir kez verilebilir.' });
+            else
+                search = value;
+        }
+        else if (key === 'lang')
+            alias(key, '_lang', value);
+        else {
+            const m = /^([a-z][a-z0-9_]*)(From|To)$/.exec(key);
+            if (m && fieldNames.has(m[1]))
+                out.append(`${m[1]}.${m[2] === 'From' ? 'from' : 'to'}`, value);
+            else
+                out.append(key, value);
+        }
+    }
+    if (order !== null && order !== 'asc' && order !== 'desc')
+        issues.push({ field: 'order', message: '"order" asc ya da desc olmalı.' });
+    else if (sort !== null)
+        alias('sort', '_sort', `${order === 'desc' ? '-' : ''}${sort}`);
+    else if (order !== null)
+        issues.push({ field: 'order', message: '"order" yalnız "sort" ile verilir.' });
+    if (search !== null) {
+        const trimmed = search.trim();
+        if (trimmed === '')
+            search = null;
+        else if (trimmed.length > 200)
+            issues.push({ field: 'q', message: 'Arama en çok 200 karakter olabilir.' });
+        else if (!entity.fields.some((f) => CONTAINS_TYPES.has(f.type)))
+            issues.push({ field: 'q', message: 'Bu kayıtlarda metin araması yapılamaz.' });
+        else
+            search = trimmed;
+    }
+    return { params: out, search, issues };
+}
+export function parseListQuery(entity, raw, defaults) {
+    const dialect = translateTableDialect(entity, raw);
+    const params = dialect.params;
+    const issues = [...dialect.issues];
+    const where = ['"deleted_at" IS NULL'];
+    const values = [];
+    let page = 1;
+    let size = defaults.pageSize;
+    let orderBy = '"created_at" DESC, "id" DESC';
+    let lang = 'tr';
+    const fields = new Map([...entity.fields, ...SYSTEM_DATETIME, CREATED_BY_FIELD].map((f) => [f.name, f]));
+    const seen = new Set();
+    let filters = 0;
+    for (const key of params.keys()) {
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const all = params.getAll(key);
+        if (all.length > 1) {
+            issues.push({ field: key, message: `"${key}" sorgu parametresi bir kez verilebilir.` });
+            continue;
+        }
+        const raw = all[0];
+        if (key === '_page' || key === '_size') {
+            const n = /^\d{1,6}$/.test(raw) ? Number(raw) : NaN;
+            const max = key === '_page' ? 100_000 : CRUD_MAX_PAGE_SIZE;
+            if (!Number.isInteger(n) || n < 1 || n > max)
+                issues.push({ field: key, message: `"${key}" 1 ile ${max} arasında bir tamsayı olmalı.` });
+            else if (key === '_page')
+                page = n;
+            else
+                size = n;
+            continue;
+        }
+        if (key === '_lang') {
+            if (raw !== 'tr' && raw !== 'en')
+                issues.push({ field: key, message: '"_lang" tr ya da en olmalı.' });
+            else
+                lang = raw;
+            continue;
+        }
+        if (key === '_sort') {
+            const desc = raw.startsWith('-');
+            const name = desc ? raw.slice(1) : raw;
+            const f = fields.get(name);
+            if (!f || f.type === 'longText' || f.name === 'created_by')
+                issues.push({ field: key, message: `"${name}" alanına göre sıralanamaz.` });
+            else
+                orderBy = `${q(f.column)} ${desc ? 'DESC' : 'ASC'}, "id" ${desc ? 'DESC' : 'ASC'}`;
+            continue;
+        }
+        const dot = key.lastIndexOf('.');
+        const name = dot < 0 ? key : key.slice(0, dot);
+        const op = dot < 0 ? 'eq' : key.slice(dot + 1);
+        const f = fields.get(name);
+        if (!f || !['eq', 'contains', 'from', 'to'].includes(op)) {
+            issues.push({ field: key, message: `Bilinmeyen sorgu parametresi "${key}".` });
+            continue;
+        }
+        if (++filters > CRUD_MAX_FILTERS) {
+            issues.push({ field: key, message: `En çok ${CRUD_MAX_FILTERS} süzgeç verilebilir.` });
+            continue;
+        }
+        if (op === 'contains') {
+            if (!CONTAINS_TYPES.has(f.type))
+                issues.push({ field: key, message: `"${f.title.tr}" alanında "içerir" süzgeci kullanılamaz.` });
+            else if (raw === '' || raw.length > 200)
+                issues.push({ field: key, message: `"${f.title.tr}" araması 1-200 karakter olmalı.` });
+            else {
+                where.push(containsClause(f));
+                values.push(foldSearchText(raw));
+            }
+            continue;
+        }
+        if ((op === 'from' || op === 'to') && !RANGE_TYPES.has(f.type)) {
+            issues.push({ field: key, message: `"${f.title.tr}" alanında aralık süzgeci kullanılamaz.` });
+            continue;
+        }
+        if (op === 'eq' && f.type === 'longText') {
+            issues.push({ field: key, message: `"${f.title.tr}" alanında eşitlik süzgeci kullanılamaz; "${name}.contains" kullanın.` });
+            continue;
+        }
+        const c = coerceFilter(f, raw);
+        if (!c.ok || c.value === null) {
+            issues.push({ field: key, message: c.ok ? `"${f.title.tr}" süzgeci boş olamaz.` : c.message });
+            continue;
+        }
+        where.push(`${q(f.column)} ${op === 'eq' ? '=' : op === 'from' ? '>=' : '<='} ?`);
+        values.push(c.value);
+    }
+    if (dialect.search !== null && issues.length === 0) {
+        // `q`: metin alanlarının herhangi birinde içerir — her alan için ayrı bağlı parametre (değer SQL'e girmez).
+        const textFields = entity.fields.filter((f) => CONTAINS_TYPES.has(f.type));
+        where.push(`(${textFields.map(containsClause).join(' OR ')})`);
+        const folded = foldSearchText(dialect.search);
+        for (let i = 0; i < textFields.length; i++)
+            values.push(folded);
+    }
+    if (issues.length > 0)
+        throw new DataValidationError(400, 'ONE-SDK-E-104', 'Sorgu parametreleri geçersiz.', issues);
+    return { where, params: values, orderBy, page, size, lang };
+}
+function selectColumns(entity) {
+    return ['id', 'created_at', 'created_by', 'updated_at', 'updated_by', ...entity.fields.map((f) => f.column)].map(q).join(', ');
+}
+function rowToRecord(entity, row) {
+    const out = {
+        id: row.id,
+        created_at: row.created_at,
+        created_by: row.created_by,
+        updated_at: row.updated_at,
+        updated_by: row.updated_by,
+    };
+    for (const f of entity.fields)
+        out[f.name] = outputValue(f, row[f.column]);
+    return out;
+}
+const bind = (stmt, params) => (params.length > 0 ? stmt.bind(...params) : stmt);
+/** Yazılacak kolonlar: alan kolonu + (metin alanında) arama gölgesi — gölge değerden katlanarak üretilir (S15). */
+function writeColumns(values) {
+    const out = [];
+    for (const [f, v] of values) {
+        out.push([f.column, v]);
+        if (f.foldColumn !== undefined)
+            out.push([f.foldColumn, typeof v === 'string' ? foldSearchText(v) : null]);
+    }
+    return out;
+}
+/** Benzersizlik ihlali iletisinden (`UNIQUE constraint failed: <tablo>.<kolon>`) alanı bulur. */
+export function uniqueViolationField(entity, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!/UNIQUE constraint failed/i.test(message))
+        return undefined;
+    const m = /UNIQUE constraint failed:\s*"?([a-z0-9_]+)"?\."?([a-z0-9_]+)"?/i.exec(message);
+    return (m && m[1] === entity.name && entity.fields.find((f) => f.column === m[2])) || null;
+}
+/** Model + varlık için uç işleyicisi. Model ilk kullanımda doğrulanır (geçersizse her istek 500 `ONE-SDK-E-100`). */
+export function createCrudHandler(options) {
+    const basePath = (options.basePath ?? '/api').replace(/\/+$/, '');
+    if (!/^(\/[a-z0-9_-]+)*$/i.test(basePath))
+        throw new OneError(500, 'ONE-SDK-E-100', `basePath geçersiz: ${options.basePath}`);
+    if (options.records !== 'shared' && options.records !== 'own')
+        throw new OneError(500, 'ONE-SDK-E-100', '"records" "shared" ya da "own" olmalı (kayıtları kim görecek?).');
+    const pageSize = options.pageSize ?? 50;
+    if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > CRUD_MAX_PAGE_SIZE)
+        throw new OneError(500, 'ONE-SDK-E-100', `pageSize 1 ile ${CRUD_MAX_PAGE_SIZE} arasında olmalı.`);
+    const exportLimit = Math.min(options.exportLimit ?? 10_000, 50_000);
+    const timeZone = options.timeZone ?? DEFAULT_TIME_ZONE;
+    const path = `${basePath}/${options.entity}`;
+    let entityCache;
+    const entityOf = () => {
+        if (entityCache)
+            return entityCache;
+        const model = loadModel(options.model);
+        const entity = model.entities.find((e) => e.name === options.entity);
+        if (!entity)
+            throw new OneError(500, 'ONE-SDK-E-100', `Veri modelinde "${options.entity}" varlığı yok.`);
+        entityCache = entity;
+        return entity;
+    };
+    const ownerClause = (user) => options.records === 'own' ? { sql: ['"created_by" = ?'], params: [user.sub] } : { sql: [], params: [] };
+    async function findRow(db, entity, id, owner) {
+        const where = ['"id" = ?', '"deleted_at" IS NULL', ...owner.sql].join(' AND ');
+        return bind(db.prepare(`SELECT ${selectColumns(entity)} FROM ${q(entity.name)} WHERE ${where} LIMIT 1`), [id, ...owner.params]).first();
+    }
+    async function writeOrConflict(entity, run) {
+        try {
+            await run();
+        }
+        catch (e) {
+            const f = uniqueViolationField(entity, e);
+            if (f === undefined)
+                throw e;
+            const field = f?.name ?? '';
+            throw new DataValidationError(409, 'ONE-SDK-E-103', 'Bu değer başka bir kayıtta kullanılıyor.', [
+                { field, message: f ? `"${f.title.tr}" değeri başka bir kayıtta kullanılıyor.` : 'Bu değer başka bir kayıtta kullanılıyor.' },
+            ]);
+        }
+    }
+    function validateBody(entity, body, mode) {
+        const issues = [];
+        const byName = new Map(entity.fields.map((f) => [f.name, f]));
+        for (const key of Object.keys(body)) {
+            if (SYSTEM_SET.has(key))
+                issues.push({ field: key, message: `"${key}" platform tarafından yazılır; gövdede gönderilemez.` });
+            else if (!byName.has(key))
+                issues.push({ field: key, message: `"${key}" bu kayıtta bulunmayan bir alan.` });
+        }
+        const out = new Map();
+        for (const f of entity.fields) {
+            const present = Object.prototype.hasOwnProperty.call(body, f.name);
+            if (!present && mode === 'update')
+                continue;
+            let value = null;
+            if (present) {
+                const c = coerceInput(f, body[f.name]);
+                if (!c.ok) {
+                    issues.push({ field: f.name, message: c.message });
+                    continue;
+                }
+                value = c.value;
+            }
+            if (value === null && mode === 'create')
+                value = defaultDbValue(f) ?? null;
+            if (value === null && f.required) {
+                issues.push({ field: f.name, message: `"${f.title.tr}" zorunlu.` });
+                continue;
+            }
+            out.set(f, value);
+        }
+        if (mode === 'update' && issues.length === 0 && out.size === 0)
+            issues.push({ field: '', message: 'Güncellenecek alan gönderilmedi.' });
+        if (issues.length > 0)
+            throw new DataValidationError(400, 'ONE-SDK-E-101', 'Kayıt doğrulanamadı.', issues);
+        return out;
+    }
+    function guardWrite(ctx) {
+        const user = requireUser(ctx);
+        if (isActingSession(ctx) && options.actingSessions !== 'write')
+            throw new OneError(403, 'ONE-SDK-E-106', 'Vekalet ya da Yerine Görüntüle oturumunda bu uygulamada kayıt değiştirilemez; yalnız görüntüleyebilirsiniz.');
+        if (!allowed(ctx, options.canWrite))
+            throw new OneError(403, 'ONE-SDK-E-107', 'Bu kaydı değiştirme yetkiniz yok.');
+        return user;
+    }
+    function guardRead(ctx) {
+        const user = requireUser(ctx);
+        if (!allowed(ctx, options.canRead))
+            throw new OneError(403, 'ONE-SDK-E-107', 'Bu kayıtları görme yetkiniz yok.');
+        return user;
+    }
+    async function listRows(db, entity, lq, owner, limit, offset) {
+        const where = [...lq.where, ...owner.sql].join(' AND ');
+        const params = [...lq.params, ...owner.params];
+        const count = bind(db.prepare(`SELECT COUNT(*) AS "n" FROM ${q(entity.name)} WHERE ${where}`), params);
+        const list = bind(db.prepare(`SELECT ${selectColumns(entity)} FROM ${q(entity.name)} WHERE ${where} ORDER BY ${lq.orderBy} LIMIT ? OFFSET ?`), [
+            ...params,
+            limit,
+            offset,
+        ]);
+        const [countResult, listResult] = await db.batch([count, list]);
+        const total = Number(countResult?.results[0]?.n ?? 0);
+        return { total, rows: (listResult?.results ?? []).map((r) => rowToRecord(entity, r)) };
+    }
+    function exportColumns(entity) {
+        const cols = entity.fields.map((f) => {
+            const type = f.type === 'number' || f.type === 'money' || f.type === 'date' || f.type === 'datetime' || f.type === 'boolean' ? f.type : 'text';
+            const col = { key: f.name, title: f.title, type };
+            if (f.type === 'choice')
+                col.labels = Object.fromEntries(f.choices.map((c) => [c.value, c.title]));
+            return col;
+        });
+        cols.push({ key: 'created_at', title: { tr: 'Oluşturulma', en: 'Created' }, type: 'datetime' });
+        return cols;
+    }
+    async function handle(request, db, given) {
+        const url = new URL(request.url);
+        let rest = url.pathname === path ? '' : url.pathname.startsWith(`${path}/`) ? url.pathname.slice(path.length + 1) : null;
+        if (rest === null)
+            return null;
+        // Hazır liste bileşeni (`<one-table export>`) dışa aktarmayı listeyle aynı adreste `?format=xlsx|csv` ile ister.
+        const format = rest === '' && !fieldNameIn(options.model, options.entity, 'format') ? url.searchParams.get('format') : null;
+        let ctx = given;
+        try {
+            ctx ??= readContext(request.headers);
+            const entity = entityOf();
+            const method = request.method.toUpperCase();
+            if (format !== null) {
+                if (url.searchParams.getAll('format').length > 1 || (format !== 'xlsx' && format !== 'csv'))
+                    throw new DataValidationError(400, 'ONE-SDK-E-104', 'Sorgu parametreleri geçersiz.', [{ field: 'format', message: '"format" xlsx ya da csv olmalı.' }]);
+                url.searchParams.delete('format');
+                rest = `export.${format}`;
+            }
+            if (rest === 'export.csv' || rest === 'export.xlsx' || rest === 'report.html') {
+                if (method !== 'GET' && method !== 'HEAD')
+                    throw new OneError(405, 'ONE-SDK-E-105', 'Bu adreste yalnız okuma yapılır (GET).');
+                const user = guardRead(ctx);
+                const lq = parseListQuery(entity, url.searchParams, { pageSize });
+                const limit = rest === 'report.html' ? Math.min(exportLimit, CRUD_REPORT_MAX_ROWS) : exportLimit;
+                const { total, rows } = await listRows(db, entity, lq, ownerClause(user), limit, 0);
+                if (total > limit)
+                    throw new OneError(400, 'ONE-SDK-E-110', `${total.toLocaleString('tr-TR')} kayıt var; en çok ${limit.toLocaleString('tr-TR')} kayıt aktarılabilir. Süzgeci daraltın.`);
+                const columns = exportColumns(entity);
+                const title = entity.title[lq.lang];
+                const today = new Date().toISOString().slice(0, 10);
+                const fileName = `${title} ${formatDate(today, lq.lang)}`;
+                logEvent(ctx, 'info', 'data.export', { entity: entity.name, format: rest, rows: rows.length });
+                if (rest === 'export.csv')
+                    return exportResponse(toCsv(rows, columns, { lang: lq.lang, timeZone }), { fileName, format: 'csv' });
+                if (rest === 'export.xlsx')
+                    return exportResponse(toXlsx(rows, columns, { lang: lq.lang, timeZone, sheetName: title }), { fileName, format: 'xlsx' });
+                const totals = columns.filter((c) => c.type === 'money').map((c) => c.key);
+                return reportResponse(renderPrintableReport({ title, columns, rows, totals, lang: lq.lang, timeZone }));
+            }
+            if (rest === '') {
+                if (method === 'GET' || method === 'HEAD') {
+                    const user = guardRead(ctx);
+                    const lq = parseListQuery(entity, url.searchParams, { pageSize });
+                    const { total, rows } = await listRows(db, entity, lq, ownerClause(user), lq.size, (lq.page - 1) * lq.size);
+                    // `nextCursor`: hazır liste bileşeninin "sonraki sayfa" imleci (bu uçlarda sayfa numarası); son sayfada null.
+                    return json({ items: rows, page: lq.page, pageSize: lq.size, total, nextCursor: lq.page * lq.size < total ? String(lq.page + 1) : null });
+                }
+                if (method === 'POST') {
+                    const user = guardWrite(ctx);
+                    const values = validateBody(entity, await readJsonBody(request), 'create');
+                    const id = crypto.randomUUID();
+                    const now = new Date().toISOString();
+                    const written = writeColumns(values);
+                    const cols = ['id', 'created_at', 'created_by', 'updated_at', 'updated_by', ...written.map(([c]) => c)];
+                    const params = [id, now, user.sub, now, user.sub, ...written.map(([, v]) => v)];
+                    await writeOrConflict(entity, () => bind(db.prepare(`INSERT INTO ${q(entity.name)} (${cols.map(q).join(', ')}) VALUES (${cols.map(() => '?').join(', ')})`), params).run());
+                    if (isActingSession(ctx))
+                        logEvent(ctx, 'info', 'data.acting-write', { entity: entity.name, id, actor: ctx.actor?.sub ?? null });
+                    const row = await findRow(db, entity, id, { sql: [], params: [] });
+                    return json(row ? rowToRecord(entity, row) : { id }, 201, { location: `${path}/${id}` });
+                }
+                throw new OneError(405, 'ONE-SDK-E-105', 'Bu adreste bu yöntem kullanılamaz (GET, HEAD, POST).');
+            }
+            if (!UUID_RE.test(rest))
+                throw new OneError(404, 'ONE-SDK-E-102', 'Kayıt bulunamadı.');
+            const id = rest;
+            if (method === 'GET' || method === 'HEAD') {
+                const user = guardRead(ctx);
+                const row = await findRow(db, entity, id, ownerClause(user));
+                if (!row)
+                    throw new OneError(404, 'ONE-SDK-E-102', 'Kayıt bulunamadı.');
+                return json(rowToRecord(entity, row));
+            }
+            if (method === 'PATCH' || method === 'DELETE') {
+                const user = guardWrite(ctx);
+                const owner = ownerClause(user);
+                const values = method === 'PATCH' ? validateBody(entity, await readJsonBody(request), 'update') : null;
+                if (!(await findRow(db, entity, id, owner)))
+                    throw new OneError(404, 'ONE-SDK-E-102', 'Kayıt bulunamadı.');
+                const now = new Date().toISOString();
+                const guard = ['"id" = ?', '"deleted_at" IS NULL', ...owner.sql].join(' AND ');
+                if (values) {
+                    const written = writeColumns(values);
+                    const sets = [...written.map(([c]) => `${q(c)} = ?`), '"updated_at" = ?', '"updated_by" = ?'];
+                    await writeOrConflict(entity, () => bind(db.prepare(`UPDATE ${q(entity.name)} SET ${sets.join(', ')} WHERE ${guard}`), [
+                        ...written.map(([, v]) => v),
+                        now,
+                        user.sub,
+                        id,
+                        ...owner.params,
+                    ]).run());
+                    if (isActingSession(ctx))
+                        logEvent(ctx, 'info', 'data.acting-write', { entity: entity.name, id, actor: ctx.actor?.sub ?? null });
+                    const row = await findRow(db, entity, id, owner);
+                    if (!row)
+                        throw new OneError(404, 'ONE-SDK-E-102', 'Kayıt bulunamadı.');
+                    return json(rowToRecord(entity, row));
+                }
+                if (entity.softDelete)
+                    await bind(db.prepare(`UPDATE ${q(entity.name)} SET "deleted_at" = ?, "updated_at" = ?, "updated_by" = ? WHERE ${guard}`), [
+                        now,
+                        now,
+                        user.sub,
+                        id,
+                        ...owner.params,
+                    ]).run();
+                else
+                    await bind(db.prepare(`DELETE FROM ${q(entity.name)} WHERE ${guard}`), [id, ...owner.params]).run();
+                if (isActingSession(ctx))
+                    logEvent(ctx, 'info', 'data.acting-write', { entity: entity.name, id, actor: ctx.actor?.sub ?? null, deleted: true });
+                return new Response(null, { status: 204 });
+            }
+            throw new OneError(405, 'ONE-SDK-E-105', 'Bu adreste bu yöntem kullanılamaz (GET, HEAD, PATCH, DELETE).');
+        }
+        catch (e) {
+            if (e instanceof OneError)
+                return problem(e);
+            // Bilinmeyen hata: iç ileti yanıta sızmaz, olay günlüğüne yazılır (D-45).
+            return problemResponse(e, ctx);
+        }
+    }
+    return { path, handle };
+}
+//# sourceMappingURL=crud.js.map