feat(in-kind): varlık türleri, fiyat tablosu, aynî borç/alacak, birikim planı ve ödeme akışı, 008 migration

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

src/features/contacts/service.ts

@@ -65,6 +65,8 @@ async function contactTotals(householdId: Types.ObjectId, contactIds?: Types.Obj
         status: "posted",
         deletedAt: null,
         contactId: contactIds ? { $in: contactIds } : { $type: "objectId" },
+        // Aynî borç hareketleri cari TL bakiyesine girmez.
+        contactKind: { $ne: null },
       },
     },
     {
@@ -404,6 +406,7 @@ export async function getContactStatement(
   const txs = (await TransactionModel.find({
     householdId: ctx.m.householdId,
     contactId: contact._id,
+    contactKind: { $ne: null },
     status: "posted",
     deletedAt: null,
   })

src/features/in-kind/actions.ts

@@ -0,0 +1,82 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { z } from "zod";
+import { tr } from "@/i18n/tr";
+import { fail, type ActionResult } from "@/lib/action-result";
+import { getHouseholdActionContext } from "@/lib/dal";
+import {
+  assetPriceFormSchema,
+  contributionSchema,
+  inKindFormSchema,
+  paymentFormSchema,
+} from "@/shared/schemas/in-kind";
+import {
+  addContribution,
+  createInKind,
+  deleteInKind,
+  recordPayment,
+  savePrice,
+  updateInKind,
+} from "./service";
+
+const idSchema = z.string().regex(/^[a-f0-9]{24}$/i);
+
+function fieldErrors(error: z.ZodError) {
+  const out: Record<string, string> = {};
+  for (const issue of error.issues) {
+    const key = issue.path.join(".");
+    if (key && !out[key]) out[key] = issue.message;
+  }
+  return out;
+}
+
+const revalidate = () => revalidatePath("/", "layout");
+
+async function run<T>(
+  schema: z.ZodType<T>,
+  input: unknown,
+  fn: (userId: string, householdId: string, data: T) => Promise<ActionResult<unknown>>,
+): Promise<ActionResult<unknown>> {
+  const ctx = await getHouseholdActionContext("member");
+  if (!ctx) return fail(tr.common.unauthorized);
+  const parsed = schema.safeParse(input);
+  if (!parsed.success) return fail(tr.adminUsers.errors.checkFields, fieldErrors(parsed.error));
+  const result = await fn(ctx.user.id, ctx.household.id, parsed.data);
+  if (result.ok) revalidate();
+  return result;
+}
+
+export async function savePriceAction(input: unknown) {
+  return run(assetPriceFormSchema, input, savePrice);
+}
+
+/** Yeni aynî kayıt (debtId boş, contactId dolu) veya mevcut kaydı düzenle. */
+export async function saveInKindAction(contactId: unknown, debtId: unknown, input: unknown) {
+  if (debtId) {
+    const id = idSchema.safeParse(debtId);
+    if (!id.success) return fail(tr.common.notFound);
+    return run(inKindFormSchema, input, (u, h, d) => updateInKind(u, h, id.data, d));
+  }
+  const cid = idSchema.safeParse(contactId);
+  if (!cid.success) return fail(tr.common.notFound);
+  return run(inKindFormSchema, input, (u, h, d) => createInKind(u, h, cid.data, d));
+}
+
+export async function deleteInKindAction(debtId: unknown): Promise<ActionResult<unknown>> {
+  const id = idSchema.safeParse(debtId);
+  if (!id.success) return fail(tr.common.notFound);
+  return run(z.unknown(), null, (u, h) => deleteInKind(u, h, id.data));
+}
+
+export async function addContributionAction(debtId: unknown, input: unknown) {
+  const id = idSchema.safeParse(debtId);
+  if (!id.success) return fail(tr.common.notFound);
+  return run(contributionSchema, input, (u, h, d) => addContribution(u, h, id.data, d));
+}
+
+export async function recordPaymentAction(debtId: unknown, input: unknown) {
+  const id = idSchema.safeParse(debtId);
+  if (!id.success) return fail(tr.common.notFound);
+  return run(paymentFormSchema, input, (u, h, d) => recordPayment(u, h, id.data, d));
+}

src/features/in-kind/service.int.test.ts

@@ -0,0 +1,270 @@
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { listAccounts } from "@/features/accounts/service";
+import { createContact, listContacts } from "@/features/contacts/service";
+import { listTransactions, setTransactionDeleted } from "@/features/transactions/service";
+import { AccountModel } from "@/models/account";
+import { AssetPriceModel } from "@/models/asset-price";
+import { AuditLogModel } from "@/models/audit-log";
+import { InKindDebtModel } from "@/models/in-kind-debt";
+import { todayIstanbul } from "@/shared/dates";
+import { addDays, addMonths } from "@/shared/recurrence";
+import { contactFormSchema } from "@/shared/schemas/contact";
+import {
+  assetPriceFormSchema,
+  contributionSchema,
+  inKindFormSchema,
+  paymentFormSchema,
+} from "@/shared/schemas/in-kind";
+import { transactionFilterSchema } from "@/shared/schemas/transaction";
+import { setupSeededDb, teardownDb } from "@/test/seeded-db";
+import {
+  addContribution,
+  createInKind,
+  listInKind,
+  listPrices,
+  recordPayment,
+  savePrice,
+} from "./service";
+
+let ids: Awaited<ReturnType<typeof setupSeededDb>>;
+let cakir = "";
+let ayse = "";
+let emre = "";
+let zeynep = "";
+const today = todayIstanbul();
+const monthAgo = addDays(today, -30);
+
+beforeAll(async () => {
+  ids = await setupSeededDb();
+  cakir = ids.household("Çakır Ailesi");
+  ayse = ids.user("ayse");
+  emre = ids.user("emre");
+  zeynep = ids.user("zeynep");
+  // Seed örnek fiyatları bu testin fiyat senaryolarını etkilemesin.
+  await AssetPriceModel.deleteMany({});
+});
+afterAll(teardownDb);
+
+const acc = (name: string) =>
+  AccountModel.findOne({ householdId: cakir, name })
+    .lean()
+    .then((a) => String(a!._id));
+async function balance(accountId: string) {
+  return (await listAccounts(ayse, cakir))!.accounts.find((a) => a.id === accountId)!.balanceMinor!;
+}
+const price = (assetKey: string, date: string, buy: string, sell = "") =>
+  assetPriceFormSchema.parse({ assetKey, date, buy, sell });
+async function contact(name: string, isPrivate = false) {
+  const r = await createContact(
+    ayse,
+    cakir,
+    contactFormSchema.parse({ name, openingDate: monthAgo, isPrivate }),
+  );
+  return r.ok ? r.data.id : "";
+}
+async function view(id: string) {
+  return (await listInKind(ayse, cakir))!.find((v) => v.id === id)!;
+}
+
+describe("fiyat tablosu", () => {
+  it("elle fiyat; tek fiyat ikisine yazılır; gelecek tarih reddedilir; izleyici yazamaz", async () => {
+    expect((await savePrice(ayse, cakir, price("gram_gold", today, "3.200", "3.300"))).ok).toBe(
+      true,
+    );
+    expect((await savePrice(ayse, cakir, price("usd", today, "41,50"))).ok).toBe(true);
+    expect((await savePrice(ayse, cakir, price("usd", addDays(today, 1), "1"))).ok).toBe(false);
+    expect((await savePrice(zeynep, cakir, price("usd", today, "1"))).ok).toBe(false);
+    const rows = (await listPrices(ayse, cakir))!.rows;
+    expect(rows.find((r) => r.assetKey === "usd")!.latest).toMatchObject({
+      buyMinor: 41_50,
+      sellMinor: 41_50,
+    });
+    // Aynı gün yeniden giriş günceller.
+    await savePrice(ayse, cakir, price("usd", today, "42"));
+    expect(
+      (await listPrices(ayse, cakir))!.rows.find((r) => r.assetKey === "usd")!.history,
+    ).toHaveLength(1);
+  });
+});
+
+describe("aynî borç", () => {
+  let gold = "";
+  let ahmet = "";
+
+  it("borç tarihindeki fiyat tablodan; yoksa birim fiyat istenir; değer satış fiyatıyla", async () => {
+    ahmet = await contact("Altın Ahmet");
+    const input = inKindFormSchema.parse({
+      direction: "debt",
+      assetKey: "gram_gold",
+      quantity: "5",
+      date: monthAgo,
+      savingsAccountId: await acc("Birikim (Vadeli)"),
+      monthlyPlan: "2.000",
+    });
+    expect((await createInKind(ayse, cakir, ahmet, input)).ok).toBe(false);
+    await savePrice(ayse, cakir, price("gram_gold", monthAgo, "2.900", "3.000"));
+    const r = await createInKind(ayse, cakir, ahmet, input);
+    expect(r.ok).toBe(true);
+    gold = r.ok ? r.data.id : "";
+    const v = await view(gold);
+    expect(v).toMatchObject({
+      unitPriceMinor: 3_000_00,
+      valueMinor: 15_000_00,
+      label: "5 gr Gram altın (24 ayar)",
+    });
+    // Güncel: 5 × 3.300 (satış) = 16.500; birikim 0; ayda 2.000 → 9 ay.
+    expect(v.progress).toMatchObject({
+      currentValueMinor: 16_500_00,
+      accumulatedMinor: 0,
+      remainingNeedMinor: 16_500_00,
+      estimatedCloseMonth: addMonths(`${today.slice(0, 7)}-01`, 9).slice(0, 7),
+    });
+  });
+
+  it("birikim katkısı: hesaptan birikim hesabına transfer; borç kapanmaz; cari TL bakiyesi ve gelir/gider değişmez", async () => {
+    const ziraat = await acc("Ziraat Maaş");
+    const birikim = await acc("Birikim (Vadeli)");
+    const [z0, b0] = [await balance(ziraat), await balance(birikim)];
+    const sums0 = (await listTransactions(ayse, cakir, transactionFilterSchema.parse({})))!.sums;
+    const r = await addContribution(
+      ayse,
+      cakir,
+      gold,
+      contributionSchema.parse({ fromAccountId: ziraat, amount: "6.000", date: today }),
+    );
+    expect(r.ok).toBe(true);
+    expect(await balance(ziraat)).toBe(z0 - 6_000_00);
+    expect(await balance(birikim)).toBe(b0 + 6_000_00);
+    const v = await view(gold);
+    expect(v.progress.accumulatedMinor).toBe(6_000_00);
+    expect(v.progress.remainingNeedMinor).toBe(10_500_00);
+    expect(v.closedAt).toBeNull();
+    expect(
+      (await listContacts(ayse, cakir))!.contacts.find((c) => c.id === ahmet)!.balanceMinor,
+    ).toBe(0);
+    expect((await listTransactions(ayse, cakir, transactionFilterSchema.parse({})))!.sums).toEqual(
+      sums0,
+    );
+  });
+
+  it("TL karşılığıyla kısmi ödeme: miktar güncel fiyattan; birikim hesabından çıkış", async () => {
+    const birikim = await acc("Birikim (Vadeli)");
+    const b0 = await balance(birikim);
+    const r = await recordPayment(
+      ayse,
+      cakir,
+      gold,
+      paymentFormSchema.parse({ method: "cash", date: today, amount: "6.600", accountId: birikim }),
+    );
+    expect(r).toMatchObject({ ok: true, data: { closed: false } });
+    const v = await view(gold);
+    expect(v.paidQuantity).toBe(2_000);
+    expect(v.progress.remainingQuantity).toBe(3_000);
+    expect(v.progress.accumulatedMinor).toBe(0);
+    expect(await balance(birikim)).toBe(b0 - 6_600_00);
+    // Ödeme işlemi tek başına silinemez.
+    const doc = (await InKindDebtModel.findById(gold).lean())!;
+    expect(
+      (await setTransactionDeleted(ayse, cakir, String(doc.payments[0]!.transactionId), true)).ok,
+    ).toBe(false);
+  });
+
+  it("aynı varlıkla ödeme kalanı aşarsa kalana sınırlanır ve kayıt kapanır", async () => {
+    const r = await recordPayment(
+      ayse,
+      cakir,
+      gold,
+      paymentFormSchema.parse({ method: "asset", date: today, quantity: "5" }),
+    );
+    expect(r).toMatchObject({ ok: true, data: { closed: true } });
+    const v = await view(gold);
+    expect(v.paidQuantity).toBe(5_000);
+    expect(v.closedAt).toBe(today);
+    expect(await AuditLogModel.exists({ action: "inkind.close", targetId: gold })).toBeTruthy();
+    expect(
+      (
+        await recordPayment(
+          ayse,
+          cakir,
+          gold,
+          paymentFormSchema.parse({ method: "asset", date: today, quantity: "1" }),
+        )
+      ).ok,
+    ).toBe(false);
+  });
+
+  it("aynî alacak: alış fiyatıyla değerlenir, tahsilat hesaba girer; birikim planı alınmaz", async () => {
+    const elif = await contact("Döviz Elif");
+    const cuzdan = await acc("Cüzdan");
+    expect(
+      (
+        await createInKind(
+          ayse,
+          cakir,
+          elif,
+          inKindFormSchema.parse({
+            direction: "receivable",
+            assetKey: "usd",
+            quantity: "100",
+            date: today,
+            savingsAccountId: await acc("Birikim (Vadeli)"),
+          }),
+        )
+      ).ok,
+    ).toBe(false);
+    const r = await createInKind(
+      ayse,
+      cakir,
+      elif,
+      inKindFormSchema.parse({
+        direction: "receivable",
+        assetKey: "usd",
+        quantity: "100",
+        date: today,
+      }),
+    );
+    const id = r.ok ? r.data.id : "";
+    expect((await view(id)).progress.currentValueMinor).toBe(4_200_00);
+    const c0 = await balance(cuzdan);
+    await recordPayment(
+      ayse,
+      cakir,
+      id,
+      paymentFormSchema.parse({ method: "cash", date: today, amount: "2.100", accountId: cuzdan }),
+    );
+    expect(await balance(cuzdan)).toBe(c0 + 2_100_00);
+    expect((await view(id)).paidQuantity).toBe(50_000);
+  });
+
+  it("gizli cari: aynî kayıt başkasına görünmez ve eklenemez", async () => {
+    const secret = await contact("Gizli Altın", true);
+    await createInKind(
+      ayse,
+      cakir,
+      secret,
+      inKindFormSchema.parse({
+        direction: "debt",
+        assetKey: "gram_gold",
+        quantity: "1",
+        date: today,
+      }),
+    );
+    expect((await listInKind(emre, cakir))!.some((v) => v.contactId === secret)).toBe(false);
+    expect(await listInKind(emre, cakir, secret)).toBeNull();
+    expect(
+      (
+        await createInKind(
+          emre,
+          cakir,
+          secret,
+          inKindFormSchema.parse({
+            direction: "debt",
+            assetKey: "gram_gold",
+            quantity: "1",
+            date: today,
+          }),
+        )
+      ).ok,
+    ).toBe(false);
+  });
+});

src/features/in-kind/service.ts

@@ -0,0 +1,573 @@
+import "server-only";
+import mongoose, { Types } from "mongoose";
+import { hasHouseholdRole } from "@/features/households/roles";
+import { loadContext, type Ctx } from "@/features/transactions/service";
+import { tr } from "@/i18n/tr";
+import { fail, ok, type ActionResult } from "@/lib/action-result";
+import { writeAudit } from "@/lib/audit";
+import { toObjectId } from "@/lib/object-id";
+import { AssetPriceModel } from "@/models/asset-price";
+import { InKindDebtModel } from "@/models/in-kind-debt";
+import { TransactionModel } from "@/models/transaction";
+import {
+  ASSET_KEYS,
+  formatAssetQuantity,
+  inKindProgress,
+  quantityForAmount,
+  valuationPrice,
+  valueOf,
+  type AssetKey,
+  type InKindDirection,
+  type InKindProgress,
+} from "@/shared/assets";
+import { istanbulDayStart, todayIstanbul } from "@/shared/dates";
+import type {
+  AssetPriceForm,
+  ContributionForm,
+  InKindForm,
+  PaymentForm,
+} from "@/shared/schemas/in-kind";
+import { foldTr } from "@/shared/search";
+
+/**
+ * Aynî borç/alacak ve fiyat tablosu (Bölüm 6.5–6.6). Okuma: viewer; yazma: member.
+ * Görünürlük cariye bağlıdır ("yalnızca ben" cari → kayıt da gizli).
+ */
+
+const t = tr.inKind;
+
+// --- Fiyat tablosu ---
+
+export type PriceQuote = { buyMinor: number; sellMinor: number; date: string };
+
+/** Varlığın verilen tarihteki (veya öncesindeki en yakın) fiyatı. */
+export async function priceOn(
+  householdId: Types.ObjectId,
+  assetKey: AssetKey,
+  date: string,
+): Promise<PriceQuote | null> {
+  const p = await AssetPriceModel.findOne({ householdId, assetKey, date: { $lte: date } })
+    .sort({ date: -1 })
+    .lean();
+  return p ? { buyMinor: p.buyMinor, sellMinor: p.sellMinor, date: p.date } : null;
+}
+
+export type PriceRow = { assetKey: AssetKey; latest: PriceQuote | null; history: PriceQuote[] };
+
+export async function listPrices(
+  userId: string,
+  householdId: string,
+): Promise<{ rows: PriceRow[]; canWrite: boolean } | null> {
+  const ctx = await loadContext(userId, householdId, "viewer");
+  if (!ctx) return null;
+  const all = await AssetPriceModel.find({ householdId: ctx.m.householdId })
+    .sort({ date: -1 })
+    .limit(1000)
+    .lean();
+  const rows = ASSET_KEYS.map((assetKey): PriceRow => {
+    const history = all
+      .filter((p) => p.assetKey === assetKey)
+      .slice(0, 10)
+      .map((p) => ({ buyMinor: p.buyMinor, sellMinor: p.sellMinor, date: p.date }));
+    return { assetKey, latest: history[0] ?? null, history };
+  });
+  return { rows, canWrite: hasHouseholdRole(ctx.m.role, "member") };
+}
+
+export async function savePrice(
+  actorId: string,
+  householdId: string,
+  input: AssetPriceForm,
+): Promise<ActionResult> {
+  const ctx = await loadContext(actorId, householdId, "member");
+  if (!ctx) return fail(tr.common.unauthorized);
+  if (input.date > todayIstanbul()) return fail(tr.validation.date, { date: tr.validation.date });
+  await AssetPriceModel.updateOne(
+    { householdId: ctx.m.householdId, assetKey: input.assetKey, date: input.date },
+    {
+      $set: { buyMinor: input.buyMinor, sellMinor: input.sellMinor, source: "manual" },
+      $setOnInsert: { createdBy: new Types.ObjectId(actorId) },
+    },
+    { upsert: true },
+  );
+  return ok(undefined);
+}
+
+// --- Aynî kayıtlar ---
+
+type PaymentDoc = {
+  _id: Types.ObjectId;
+  date: string;
+  method: "asset" | "cash";
+  quantity: number;
+  amountMinor: number;
+  accountId?: Types.ObjectId | null;
+  transactionId?: Types.ObjectId | null;
+  note: string;
+};
+
+type DebtDoc = {
+  _id: Types.ObjectId;
+  householdId: Types.ObjectId;
+  contactId: Types.ObjectId;
+  direction: InKindDirection;
+  assetKey: AssetKey;
+  quantity: number;
+  date: string;
+  unitPriceMinor?: number | null;
+  valueMinor?: number | null;
+  note: string;
+  savingsAccountId?: Types.ObjectId | null;
+  monthlyPlanMinor?: number | null;
+  payments: PaymentDoc[];
+  closedAt?: string | null;
+};
+
+export type InKindView = {
+  id: string;
+  contactId: string;
+  contactName: string;
+  direction: InKindDirection;
+  assetKey: AssetKey;
+  label: string;
+  quantity: number;
+  paidQuantity: number;
+  date: string;
+  unitPriceMinor: number | null;
+  valueMinor: number | null;
+  note: string;
+  savingsAccount: { id: string; name: string } | null;
+  monthlyPlanMinor: number | null;
+  closedAt: string | null;
+  currentPrice: PriceQuote | null;
+  progress: InKindProgress;
+  payments: {
+    id: string;
+    date: string;
+    method: "asset" | "cash";
+    quantity: number;
+    amountMinor: number;
+    account: string | null;
+    note: string;
+  }[];
+};
+
+function contactVisible(ctx: Ctx, contactId: Types.ObjectId | string) {
+  const c = ctx.contactMap.get(String(contactId));
+  return c && !c.hidden ? c : null;
+}
+
+/** Birikim: borca bağlı katkılar (birikim hesabına giren) − birikim hesabından yapılan ödemeler. */
+async function savingsFlows(debtIds: Types.ObjectId[]) {
+  const rows = await TransactionModel.aggregate<{
+    _id: { debt: Types.ObjectId; role: string };
+    sum: number;
+  }>([
+    {
+      $match: {
+        inKindDebtId: { $in: debtIds },
+        status: "posted",
+        deletedAt: null,
+      },
+    },
+    {
+      $group: {
+        _id: { debt: "$inKindDebtId", role: "$inKindRole" },
+        sum: { $sum: "$amountMinor" },
+      },
+    },
+  ]);
+  const map = new Map<string, { contributed: number }>();
+  for (const r of rows) {
+    if (r._id.role !== "contribution") continue;
+    map.set(String(r._id.debt), { contributed: r.sum });
+  }
+  return map;
+}
+
+async function toViews(ctx: Ctx, docs: DebtDoc[]): Promise<InKindView[]> {
+  const today = todayIstanbul();
+  const flows = await savingsFlows(docs.map((d) => d._id));
+  const priceCache = new Map<string, PriceQuote | null>();
+  const views: InKindView[] = [];
+  for (const d of docs) {
+    if (!priceCache.has(d.assetKey))
+      priceCache.set(d.assetKey, await priceOn(ctx.m.householdId, d.assetKey, today));
+    const price = priceCache.get(d.assetKey)!;
+    const paidQuantity = d.payments.reduce((a, p) => a + p.quantity, 0);
+    const savingsId = d.savingsAccountId ? String(d.savingsAccountId) : null;
+    // Birikim hesabından yapılan ödemeler birikimden düşer.
+    const spentMinor = d.payments
+      .filter((p) => savingsId && String(p.accountId) === savingsId)
+      .reduce((a, p) => a + p.amountMinor, 0);
+    const savings = savingsId ? ctx.accountMap.get(savingsId) : undefined;
+    views.push({
+      id: String(d._id),
+      contactId: String(d.contactId),
+      contactName: ctx.contactMap.get(String(d.contactId))?.name ?? "—",
+      direction: d.direction,
+      assetKey: d.assetKey,
+      label: formatAssetQuantity(d.assetKey, d.quantity),
+      quantity: d.quantity,
+      paidQuantity,
+      date: d.date,
+      unitPriceMinor: d.unitPriceMinor ?? null,
+      valueMinor: d.valueMinor ?? null,
+      note: d.note,
+      savingsAccount: savings && !savings.hidden ? { id: savingsId!, name: savings.name } : null,
+      monthlyPlanMinor: d.monthlyPlanMinor ?? null,
+      closedAt: d.closedAt ?? null,
+      currentPrice: price,
+      progress: inKindProgress({
+        quantity: d.quantity,
+        paidQuantity,
+        unitPriceMinor: valuationPrice(d.direction, price),
+        contributedMinor: flows.get(String(d._id))?.contributed ?? 0,
+        spentMinor,
+        monthlyPlanMinor: d.direction === "debt" ? (d.monthlyPlanMinor ?? null) : null,
+        today,
+      }),
+      payments: d.payments.map((p) => {
+        const a = p.accountId ? ctx.accountMap.get(String(p.accountId)) : undefined;
+        return {
+          id: String(p._id),
+          date: p.date,
+          method: p.method,
+          quantity: p.quantity,
+          amountMinor: p.amountMinor,
+          account: a ? (a.hidden ? tr.transactions.list.hiddenAccount : a.name) : null,
+          note: p.note,
+        };
+      }),
+    });
+  }
+  return views;
+}
+
+/** Bir carinin (veya tüm görünür carilerin) aynî kayıtları; açıklar önce. */
+export async function listInKind(
+  userId: string,
+  householdId: string,
+  contactId?: string,
+): Promise<InKindView[] | null> {
+  const ctx = await loadContext(userId, householdId, "viewer");
+  if (!ctx) return null;
+  const filter: Record<string, unknown> = { householdId: ctx.m.householdId, deletedAt: null };
+  if (contactId) {
+    const id = toObjectId(contactId);
+    if (!id || !contactVisible(ctx, id)) return null;
+    filter.contactId = id;
+  } else {
+    filter.contactId = { $nin: ctx.hiddenContactIds };
+  }
+  const docs = await InKindDebtModel.find(filter).sort({ closedAt: 1, date: -1 }).lean<DebtDoc[]>();
+  return toViews(
+    ctx,
+    docs.filter((d) => contactVisible(ctx, d.contactId)),
+  );
+}
+
+async function loadDebt(ctx: Ctx, debtId: string) {
+  const id = toObjectId(debtId);
+  if (!id) return null;
+  const d = await InKindDebtModel.findOne({
+    _id: id,
+    householdId: ctx.m.householdId,
+    deletedAt: null,
+  }).lean<DebtDoc>();
+  return d && contactVisible(ctx, d.contactId) ? d : null;
+}
+
+function checkAccount(ctx: Ctx, id: string | null) {
+  if (!id) return null;
+  const a = ctx.accountMap.get(id);
+  return a && !a.hidden && !a.archived ? a : null;
+}
+
+async function debtFields(ctx: Ctx, input: InKindForm) {
+  let unitPriceMinor = input.unitPrice;
+  if (unitPriceMinor === null) {
+    const p = await priceOn(ctx.m.householdId, input.assetKey, input.date);
+    unitPriceMinor = valuationPrice(input.direction, p);
+  }
+  if (unitPriceMinor === null) return fail(t.errors.noPrice, { unitPrice: t.errors.noPrice });
+  if (input.savingsAccountId && input.direction !== "debt")
+    return fail(t.errors.receivablePlan, { savingsAccountId: t.errors.receivablePlan });
+  const savings = input.savingsAccountId ? checkAccount(ctx, input.savingsAccountId) : null;
+  if (input.savingsAccountId && !savings)
+    return fail(tr.transactions.validation.accountInvalid, {
+      savingsAccountId: tr.transactions.validation.accountInvalid,
+    });
+  return ok({
+    direction: input.direction,
+    assetKey: input.assetKey,
+    quantity: input.quantity,
+    date: input.date,
+    unitPriceMinor,
+    valueMinor: valueOf(input.quantity, unitPriceMinor),
+    note: input.note,
+    savingsAccountId: savings?.id ?? null,
+    monthlyPlanMinor: savings ? input.monthlyPlan : null,
+  });
+}
+
+export async function createInKind(
+  actorId: string,
+  householdId: string,
+  contactId: string,
+  input: InKindForm,
+): Promise<ActionResult<{ id: string }>> {
+  const ctx = await loadContext(actorId, householdId, "member");
+  if (!ctx) return fail(tr.common.unauthorized);
+  const cid = toObjectId(contactId);
+  const contact = cid ? contactVisible(ctx, cid) : null;
+  if (!contact) return fail(tr.common.notFound);
+  if (contact.archived) return fail(tr.contacts.errors.archived);
+  const fields = await debtFields(ctx, input);
+  if (!fields.ok) return fields;
+  const actor = new Types.ObjectId(actorId);
+  const doc = await InKindDebtModel.create({
+    ...fields.data,
+    householdId: ctx.m.householdId,
+    contactId: contact.id,
+    createdBy: actor,
+    updatedBy: actor,
+  });
+  return ok({ id: String(doc._id) });
+}
+
+export async function updateInKind(
+  actorId: string,
+  householdId: string,
+  debtId: string,
+  input: InKindForm,
+): Promise<ActionResult> {
+  const ctx = await loadContext(actorId, householdId, "member");
+  if (!ctx) return fail(tr.common.unauthorized);
+  const d = await loadDebt(ctx, debtId);
+  if (!d) return fail(tr.common.notFound);
+  const paid = d.payments.reduce((a, p) => a + p.quantity, 0);
+  if (input.quantity < paid)
+    return fail(t.errors.quantityBelowPaid, { quantity: t.errors.quantityBelowPaid });
+  // Ödeme varsa yön ve varlık değişemez (ödemeler o varlık cinsindendir).
+  if (d.payments.length && (input.direction !== d.direction || input.assetKey !== d.assetKey))
+    return fail(t.errors.closed);
+  const fields = await debtFields(ctx, input);
+  if (!fields.ok) return fields;
+  await InKindDebtModel.updateOne(
+    { _id: d._id, householdId: ctx.m.householdId },
+    {
+      $set: {
+        ...fields.data,
+        closedAt: paid >= input.quantity ? (d.closedAt ?? todayIstanbul()) : null,
+        updatedBy: new Types.ObjectId(actorId),
+      },
+    },
+  );
+  return ok(undefined);
+}
+
+export async function deleteInKind(
+  actorId: string,
+  householdId: string,
+  debtId: string,
+): Promise<ActionResult> {
+  const ctx = await loadContext(actorId, householdId, "member");
+  if (!ctx) return fail(tr.common.unauthorized);
+  const d = await loadDebt(ctx, debtId);
+  if (!d) return fail(tr.common.notFound);
+  const actor = new Types.ObjectId(actorId);
+  await InKindDebtModel.updateOne(
+    { _id: d._id },
+    { $set: { deletedAt: new Date(), updatedBy: actor } },
+  );
+  await writeAudit({
+    action: "inkind.delete",
+    actorId: actor,
+    householdId: ctx.m.householdId,
+    targetType: "inKindDebt",
+    targetId: String(d._id),
+    diff: { assetKey: d.assetKey, quantity: d.quantity, direction: d.direction },
+  });
+  return ok(undefined);
+}
+
+// --- Birikim ve ödeme ---
+
+/** Birikim katkısı: kaynak hesaptan borcun birikim hesabına transfer (borç kapanmaz). */
+export async function addContribution(
+  actorId: string,
+  householdId: string,
+  debtId: string,
+  input: ContributionForm,
+): Promise<ActionResult<{ transactionId: string }>> {
+  const ctx = await loadContext(actorId, householdId, "member");
+  if (!ctx) return fail(tr.common.unauthorized);
+  const d = await loadDebt(ctx, debtId);
+  if (!d) return fail(tr.common.notFound);
+  if (d.closedAt) return fail(t.errors.closed);
+  if (d.direction !== "debt" || !d.savingsAccountId) return fail(t.errors.noSavings);
+  const from = checkAccount(ctx, input.fromAccountId);
+  const to = checkAccount(ctx, String(d.savingsAccountId));
+  if (!from || !to)
+    return fail(tr.transactions.validation.accountInvalid, {
+      fromAccountId: tr.transactions.validation.accountInvalid,
+    });
+  if (from.id.equals(to.id))
+    return fail(t.errors.sameAccount, { fromAccountId: t.errors.sameAccount });
+  const date = istanbulDayStart(input.date);
+  if (!date) return fail(tr.validation.date, { date: tr.validation.date });
+  const actor = new Types.ObjectId(actorId);
+  const contactName = ctx.contactMap.get(String(d.contactId))?.name ?? "";
+  const description = t.contributionDescription(
+    formatAssetQuantity(d.assetKey, d.quantity),
+    contactName,
+  );
+  const tx = await TransactionModel.create({
+    householdId: ctx.m.householdId,
+    type: "transfer",
+    status: "posted",
+    date,
+    accountId: from.id,
+    toAccountId: to.id,
+    amountMinor: input.amount,
+    description,
+    searchText: foldTr(description),
+    contactId: d.contactId,
+    inKindDebtId: d._id,
+    inKindRole: "contribution",
+    createdBy: actor,
+    updatedBy: actor,
+  });
+  return ok({ transactionId: String(tx._id) });
+}
+
+/**
+ * "Ödeme gerçekleşti": kısmi ödeme miktarı düşürür, tam ödemede kayıt kapanır. TL tutar varsa
+ * hesaptan çıkış (borç) veya hesaba giriş (alacak) işlemi aynı transaction içinde oluşturulur.
+ */
+export async function recordPayment(
+  actorId: string,
+  householdId: string,
+  debtId: string,
+  input: PaymentForm,
+): Promise<ActionResult<{ closed: boolean }>> {
+  const ctx = await loadContext(actorId, householdId, "member");
+  if (!ctx) return fail(tr.common.unauthorized);
+  const d = await loadDebt(ctx, debtId);
+  if (!d) return fail(tr.common.notFound);
+  if (d.closedAt) return fail(t.errors.closed);
+  if (input.date > todayIstanbul()) return fail(tr.validation.date, { date: tr.validation.date });
+  const date = istanbulDayStart(input.date);
+  if (!date) return fail(tr.validation.date, { date: tr.validation.date });
+
+  const account = input.accountId ? checkAccount(ctx, input.accountId) : null;
+  if (input.accountId && !account)
+    return fail(tr.transactions.validation.accountInvalid, {
+      accountId: tr.transactions.validation.accountInvalid,
+    });
+
+  let quantity = input.quantity;
+  if (quantity === null) {
+    const price = valuationPrice(
+      d.direction,
+      await priceOn(ctx.m.householdId, d.assetKey, input.date),
+    );
+    if (!price) return fail(t.errors.noCurrentPrice, { quantity: t.errors.noCurrentPrice });
+    quantity = quantityForAmount(input.amount ?? 0, price);
+  }
+  const paid = d.payments.reduce((a, p) => a + p.quantity, 0);
+  const remaining = d.quantity - paid;
+  quantity = Math.min(quantity, remaining);
+  if (quantity <= 0) return fail(t.validation.quantity, { quantity: t.validation.quantity });
+  const closed = paid + quantity >= d.quantity;
+
+  const actor = new Types.ObjectId(actorId);
+  const amountMinor = input.amount ?? 0;
+  const contactName = ctx.contactMap.get(String(d.contactId))?.name ?? "";
+  const description = t.paymentDescription(
+    d.direction === "debt",
+    formatAssetQuantity(d.assetKey, quantity),
+    contactName,
+  );
+
+  await mongoose.connection.transaction(async (session) => {
+    let transactionId: Types.ObjectId | null = null;
+    if (amountMinor > 0 && account) {
+      const out = d.direction === "debt";
+      const [tx] = await TransactionModel.create(
+        [
+          {
+            householdId: ctx.m.householdId,
+            type: "transfer",
+            status: "posted",
+            date,
+            // Borç ödemesi hesaptan çıkar; alacak tahsilatı hesaba girer.
+            accountId: out ? account.id : null,
+            toAccountId: out ? null : account.id,
+            amountMinor,
+            description,
+            searchText: foldTr(description),
+            contactId: d.contactId,
+            inKindDebtId: d._id,
+            inKindRole: "payment",
+            createdBy: actor,
+            updatedBy: actor,
+          },
+        ],
+        { session },
+      );
+      transactionId = tx!._id;
+    }
+    await InKindDebtModel.updateOne(
+      { _id: d._id, householdId: ctx.m.householdId, closedAt: null },
+      {
+        $push: {
+          payments: {
+            date: input.date,
+            method: input.method,
+            quantity,
+            amountMinor,
+            accountId: account?.id ?? null,
+            transactionId,
+            note: input.note,
+            createdBy: actor,
+          },
+        },
+        $set: { closedAt: closed ? input.date : null, updatedBy: actor },
+      },
+      { session },
+    );
+    await writeAudit(
+      {
+        action: closed ? "inkind.close" : "inkind.payment",
+        actorId: actor,
+        householdId: ctx.m.householdId,
+        targetType: "inKindDebt",
+        targetId: String(d._id),
+        diff: { method: input.method, quantity, amountMinor, remaining: remaining - quantity },
+      },
+      session,
+    );
+  });
+  return ok({ closed });
+}
+
+/** Cari listesi için açık aynî kayıt özetleri (cari kimliği → etiketler). */
+export async function openInKindByContact(
+  userId: string,
+  householdId: string,
+): Promise<Map<string, { direction: InKindDirection; label: string }[]>> {
+  const views = (await listInKind(userId, householdId)) ?? [];
+  const map = new Map<string, { direction: InKindDirection; label: string }[]>();
+  for (const v of views) {
+    if (v.closedAt) continue;
+    const list = map.get(v.contactId) ?? [];
+    list.push({
+      direction: v.direction,
+      label: formatAssetQuantity(v.assetKey, v.quantity - v.paidQuantity),
+    });
+    map.set(v.contactId, list);
+  }
+  return map;
+}

src/features/transactions/service.ts

@@ -532,6 +532,8 @@ export async function setTransactionDeleted(
   if (!ctx) return fail(tr.common.unauthorized);
   const current = await loadOwnTransaction(ctx, transactionId, { includeDeleted: true });
   if (!current || Boolean(current.deletedAt) === deleted) return fail(tr.common.notFound);
+  // Aynî borç ödemesi kaydın ödeme geçmişinin parçasıdır; tek başına silinmez.
+  if (current.inKindRole === "payment") return fail(t.inKindPaymentLocked);
   const actor = new Types.ObjectId(actorId);
   await TransactionModel.updateOne(
     { _id: current._id, householdId: ctx.m.householdId },

src/features/transactions/statement.ts

@@ -201,8 +201,13 @@ export async function getAccountStatement(
   const effects = rowsAsc.map((tx) => {
     const item = toItem(ctx, tx, names);
     const counterpart = tx.type === "transfer" ? [item.account, item.toAccount] : [];
-    const hiddenContact = Boolean(item.contact && ctx.contactMap.get(item.contact.id)?.hidden);
-    if (hiddenContact && item.contact) item.contact.name = tr.transactions.list.hiddenContact;
+    // Gizli cariye bağlı hareket (cari hareketi veya aynî borç ödemesi): kişi adı ve açıklama gizlenir.
+    const hiddenContact = Boolean(tx.contactId && ctx.contactMap.get(String(tx.contactId))?.hidden);
+    if (hiddenContact) {
+      if (item.contact) item.contact.name = tr.transactions.list.hiddenContact;
+      item.description = "";
+      item.payeeName = tr.transactions.list.hiddenContact;
+    }
     const restricted =
       hiddenContact || counterpart.some((a) => a && ctx.accountMap.get(a.id)?.hidden);
     if (restricted) {