fix(blogs): enforce atomic optimistic update concurrency
Deploy Canina / deploy (push) Successful in 52s

This commit is contained in:
Canina Automation committed 2026-10-27 08:20:33 +00:00
1 parent 0e952ef701
commit 0ad39bb92c
6 files changed
+202 -35

No files matched your search

+117
View File
@@ -0,0 +1,117 @@
import { BadRequestException, ConflictException, NotFoundException } from "@nestjs/common";
import { BlogsService } from "./blogs.service";
// Stateful transactional double: deliberately interleave after snapshot read.
// Complements the DB integration test; it does not assert PostgreSQL locking.
describe("BlogsService atomic optimistic update", () => {
const token = "2026-10-24T23:36:08.501Z";
let row: any;
let service: BlogsService;
let prisma: any;
let revalidate: jest.Mock;
let afterRead: (() => void) | undefined;
let failRelations: boolean;
beforeEach(() => {
row = { id: "b1", slug: "post", title: "Original", updatedAt: new Date(token), tags: ["old"] };
afterRead = undefined;
failRelations = false;
const blog = {
findUnique: jest.fn(async () => {
const snapshot = { ...row };
afterRead?.();
return snapshot;
}),
updateMany: jest.fn(async ({ where, data }) => {
if (row.updatedAt >= where.updatedAt.gte && row.updatedAt < where.updatedAt.lt) {
row = { ...row, ...data };
return { count: 1 };
}
return { count: 0 };
}),
update: jest.fn(async ({ data }) => {
if (failRelations) throw new Error("relation failure");
row = { ...row, ...data };
return { ...row };
}),
};
// Serialize transactions like row locks. Rollback restores only transaction writes.
let tail = Promise.resolve();
prisma = { blog, $transaction: jest.fn((cb) => {
const next = tail.then(async () => {
const before = { ...row };
try { return await cb({ blog }); } catch (error) { row = before; throw error; }
});
tail = next.catch(() => undefined);
return next;
}) };
revalidate = jest.fn().mockResolvedValue(true);
service = new BlogsService(prisma, { revalidateBlog: revalidate } as any);
});
it.each([null, 0, 123, true, {}, [], "", "garbage", "2026-02-30T00:00:00.000Z", "2026-10-24", "2026-10-24T23:36:08.501001Z"])("rejects invalid token %p without mutations", async (value) => {
await expect(service.updateBlog("b1", { title: "bad", expectedUpdatedAt: value })).rejects.toBeInstanceOf(ConflictException);
expect(prisma.blog.update).not.toHaveBeenCalled();
expect(prisma.blog.updateMany).not.toHaveBeenCalled();
expect(revalidate).not.toHaveBeenCalled();
});
it("rejects stale token and leaves all relations untouched", async () => {
await expect(service.updateBlog("b1", { expectedUpdatedAt: "2026-10-20T00:00:00.000Z", tagNames: ["new"], categoryId: "c" })).rejects.toBeInstanceOf(ConflictException);
expect(row.tags).toEqual(["old"]);
expect(prisma.blog.update).not.toHaveBeenCalled();
expect(revalidate).not.toHaveBeenCalled();
});
it.each([token, "2026-10-25T01:36:08.501+02:00"])("accepts current token %s and atomically includes relations", async (expectedUpdatedAt) => {
const result = await service.updateBlog("b1", { title: "new", expectedUpdatedAt, authorId: "a", categoryId: "c", tagNames: ["new"] });
expect(result.title).toBe("new");
expect(prisma.$transaction).toHaveBeenCalledTimes(1);
expect(prisma.blog.updateMany).toHaveBeenCalledWith({ where: { id: "b1", updatedAt: { gte: new Date(token), lt: new Date(new Date(token).getTime() + 1) } }, data: { updatedAt: expect.any(Date) } });
expect(prisma.blog.update.mock.calls[0][0].data).toMatchObject({ author: { connect: { id: "a" } }, category: { connect: { id: "c" } }, tags: { set: [], connectOrCreate: expect.any(Array) } });
expect(prisma.blog.update.mock.calls[0][0].data).not.toHaveProperty("expectedUpdatedAt");
expect(result.updatedAt.getTime()).toBeGreaterThan(new Date(token).getTime());
expect(revalidate).toHaveBeenCalledTimes(1);
});
it("detects writer interleaving after read before write", async () => {
afterRead = () => { row = { ...row, title: "winner", updatedAt: new Date("2026-10-24T23:36:08.502Z"), tags: ["winner"] }; };
await expect(service.updateBlog("b1", { expectedUpdatedAt: token, title: "loser", tagNames: ["loser"] })).rejects.toBeInstanceOf(ConflictException);
expect(row.title).toBe("winner");
expect(row.tags).toEqual(["winner"]);
expect(prisma.blog.update).not.toHaveBeenCalled();
expect(revalidate).not.toHaveBeenCalled();
});
it("permits exactly one of two requests sharing a token", async () => {
const results = await Promise.allSettled([service.updateBlog("b1", { expectedUpdatedAt: token, title: "a" }), service.updateBlog("b1", { expectedUpdatedAt: token, title: "b" })]);
expect(results.filter(r => r.status === "fulfilled")).toHaveLength(1);
const rejected = results.find(r => r.status === "rejected") as PromiseRejectedResult;
expect(rejected.reason).toBeInstanceOf(ConflictException);
expect(revalidate).toHaveBeenCalledTimes(1);
});
it("advances token even when clock is within same millisecond", async () => {
jest.useFakeTimers().setSystemTime(new Date(token));
try {
await service.updateBlog("b1", { expectedUpdatedAt: token, title: "first" });
await expect(service.updateBlog("b1", { expectedUpdatedAt: token, title: "second" })).rejects.toBeInstanceOf(ConflictException);
} finally { jest.useRealTimers(); }
});
it("rolls back claim on nested relation failure without invalidating cache", async () => {
failRelations = true;
await expect(service.updateBlog("b1", { expectedUpdatedAt: token, tagNames: ["new"] })).rejects.toThrow("relation failure");
expect(row.updatedAt.toISOString()).toBe(token);
expect(row.tags).toEqual(["old"]);
expect(revalidate).not.toHaveBeenCalled();
});
it("preserves legacy omission without demanding a token", async () => {
await service.updateBlog("b1", { title: "legacy" });
expect(row.title).toBe("legacy");
expect(prisma.$transaction).not.toHaveBeenCalled();
});
it("returns 404 for a missing blog", async () => {
prisma.blog.findUnique.mockResolvedValue(null);
await expect(service.updateBlog("missing", { expectedUpdatedAt: token })).rejects.toBeInstanceOf(NotFoundException);
});
it("does not fail committed writes if revalidation throws", async () => {
revalidate.mockRejectedValue(new Error("cache down"));
const result = await service.updateBlog("b1", { expectedUpdatedAt: token, title: "saved" });
expect(result.cacheRevalidation).toBe("failed");
expect(row.title).toBe("saved");
});
});
+56 -9
View File
@@ -1,5 +1,6 @@
import {
BadRequestException,
ConflictException,
Injectable,
NotFoundException,
OnModuleInit,
@@ -285,8 +286,30 @@ export class BlogsService implements OnModuleInit, OnModuleDestroy {
readingTime,
markContentUpdated,
contentUpdatedAt,
expectedUpdatedAt,
} = data;
const conflict = () => new ConflictException(
"CONCURRENT_MODIFICATION: Blog has been modified by another process",
);
let expectedTime: number | undefined;
if (expectedUpdatedAt !== undefined) {
// Only accept the millisecond, timezone-qualified ISO token returned by GET
// (or an equivalent offset). Avoid Date's coercion of null, numbers, arrays,
// and its normalization of impossible calendar dates.
const match = typeof expectedUpdatedAt === "string" && expectedUpdatedAt.match(
/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,3}))?(Z|[+-]\d{2}:\d{2})$/,
);
if (!match) throw conflict();
expectedTime = Date.parse(expectedUpdatedAt);
const calendar = new Date(`${match[1]}-${match[2]}-${match[3]}T00:00:00.000Z`);
if (!Number.isFinite(expectedTime) ||
calendar.toISOString().slice(0, 10) !== `${match[1]}-${match[2]}-${match[3]}` ||
Number(match[4]) > 23 || Number(match[5]) > 59 || Number(match[6]) > 59) {
throw conflict();
}
}
const mutableScalarFields = [
"title",
"slug",
@@ -403,15 +426,39 @@ export class BlogsService implements OnModuleInit, OnModuleDestroy {
};
}
const updated = await this.prisma.blog.update({
where: { id },
data: updatePayload,
include: {
author: { select: { firstName: true, lastName: true } },
category: true,
tags: true,
},
});
const include = {
author: { select: { firstName: true, lastName: true } },
category: true,
tags: true,
};
// Legacy UI requests without a token intentionally retain last-write-wins.
// Guarded requests claim the row using a DB predicate, not the earlier read.
const updated = expectedTime === undefined
? await this.prisma.blog.update({ where: { id }, data: updatePayload, include })
: await this.prisma.$transaction(async (tx) => {
// PostgreSQL timestamptz defaults to microseconds; JSON/JS Dates expose
// milliseconds. Match the entire represented millisecond, then move
// strictly beyond it (including same-ms writes and clock rollback).
const claimedAt = new Date(Math.max(Date.now(), expectedTime + 1));
const claim = await tx.blog.updateMany({
where: {
id,
updatedAt: {
gte: new Date(expectedTime),
lt: new Date(expectedTime + 1),
},
},
data: { updatedAt: claimedAt },
});
if (claim.count !== 1) throw conflict();
// The claim holds the row lock until this nested mutation commits.
// Any relation failure rolls back both the claim and all data writes.
return tx.blog.update({
where: { id },
data: { ...updatePayload, updatedAt: claimedAt },
include,
});
});
let cacheRevalidation: "success" | "failed" = "failed";
try {
@@ -1,31 +1,15 @@
import { render, screen } from '@testing-library/react';
import { beforeEach, describe, expect, it, vi } from 'vitest';
import api from '../services/api';
import ApprovalsPage from './ApprovalsPage';
import { describe, expect, it } from 'vitest';
import routes from '../routes/adminRoutes.tsx?raw';
vi.mock('../services/api', () => ({ default: { get: vi.fn(), post: vi.fn(), put: vi.fn() } }));
vi.mock('react-hot-toast', () => ({ default: { success: vi.fn(), error: vi.fn() } }));
const item = (id: string, category: string, status = 'PENDING') => ({
id, category, status, department: category === 'SEO' ? 'SEO' : 'B2B',
title: id, payload: {}, createdAt: '2026-10-19T10:00:00Z',
});
const pages = import.meta.glob('./*.tsx');
// Approvals and manager actions were removed in effe30e. Keep this boundary
// covered without importing the deleted page or restoring its obsolete UI.
describe('operational authorization boundary', () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(api.get).mockResolvedValue({ data: {
success: true,
data: [item('supplier-action', 'B2B_SUPPLIER_STRATEGY'), item('seo-approval', 'SEO')],
meta: { pendingCount: 2 },
} });
});
it('does not expose a supplier manager action as authorization while SEO remains', async () => {
render(<ApprovalsPage />);
expect(await screen.findByText('seo-approval')).toBeInTheDocument();
expect(screen.queryByText('supplier-action')).not.toBeInTheDocument();
expect(screen.getAllByRole('button', { name: /تایید و صدور مجوز اجرا/ })).toHaveLength(1);
expect(screen.getByText(/1 پیشنهاد منتظر تصمیم شما/)).toBeInTheDocument();
it('does not register removed approvals or manager-action pages', () => {
expect(routes).not.toMatch(/ApprovalsPage|ManagerActionsPage/);
expect(routes).not.toMatch(/path:\s*['"](?:approvals|manager-actions)(?:\/\*)?['"]/);
expect(pages).not.toHaveProperty('./ApprovalsPage.tsx');
expect(pages).not.toHaveProperty('./ManagerActionsPage.tsx');
});
});
+5
View File
@@ -0,0 +1,5 @@
# Plan and clarified contract
Base develop 0e952ef70184040a27a6b53d7b59073502d25743 fetched via verified nested SSH proxy (origin is local bundle).
Graphify query before editing identified BlogsController -> BlogsService -> PrismaService and RevalidationService; graph source locations service update L144 and controller L29 are old, so inspect current source. Actual source has PUT admin/blogs/:id @Body any, not public UpdateBlogDto. Global whitelist is skipped for Object/any metatype, so service explicit scalar allowlist is authoritative; expectedUpdatedAt is consumed separately, never persisted. UI omission remains accepted.
Blog.updatedAt is @db.Timestamptz() (PostgreSQL default precision 6), @updatedAt. JS/JSON tokens have millisecond precision. CAS predicate uses [token,token+1ms), not exact equality to truncated DB value. Atomic claim via blog.updateMany inside interactive transaction, advancing updatedAt strictly beyond token millisecond; if count !=1 throw 409. Then nested blog.update (author/category/tags) in same transaction, retaining claimed timestamp. Relation failures roll back claim. No relation writes outside transaction. Revalidation occurs after transaction resolves only. Invalid tokens restricted to timezone-qualified ISO string with <=3 fractional digits and valid calendar round-trip; no coercive Date/null/number acceptance.
Deployed runtime version/column precision still need read-only release evidence; source evidence is not deployed proof. No writes to shared services during validation.
+3
View File
@@ -0,0 +1,3 @@
# Atomic blog update prerequisite
Guarded publishers submit the updatedAt string returned by GET to PUT /admin/blogs/:id as expectedUpdatedAt. A stale or invalid supplied token must return 409 before any scalar, relation, tag creation, or cache side effect. Exactly one competing guarded writer sharing a token can commit. Missing records retain 404. Existing UI callers omitting the token retain legacy last-write-wins behavior deliberately; they are not concurrency-protected. No production content writes or migrations are permitted.
Acceptance: current token succeeds; stale/invalid/null/number/object/array tokens fail; offset-equivalent timestamps work; microsecond DB timestamps round-trip through millisecond JSON; same-millisecond successors invalidate old tokens; relation failure rolls back scalar claim; postcommit revalidation remains fail-safe.
+11
View File
@@ -0,0 +1,11 @@
# Verified release tasks
- [x] Specify guarded update/legacy omission and timestamp precision.
- [x] RED then GREEN atomic predicate, race, rollback and token tests.
- [x] Backend: 92 suites/798 tests; targeted 5 suites/105 tests. Existing 2 suites/3 tests remain skipped. All three builds passed.
- [x] Repair obsolete removed-ApprovalsPage admin test after RED, no runtime edits: 51 files/310 tests.
- [x] Storefront candidate and identical base full runs: 98 files/501 tests each; 180s external deadline was insufficient, 420s bounded runs passed without test-timeout/config changes.
- [x] Disposable actual PostgreSQL16.14, Prisma5.22: two distinct backend PIDs, one commit/one409, precision6, four microsecond boundaries, loser tags absent, full nested rollback with existing nonnull author and attempted supported author connect. Additional evidence-only disconnect adapter separately disclosed.
- [ ] Independent exact source/diff review.
- [ ] Commit/push develop, CI and Stage acceptance. No main/production authorization here.
Local evidence is preserved under evidence/concurrency and evidence/concurrency/release-prep, excluded from staging with dependency trees, baseline archive and graph stamp. Prior atomic patch SHA256 5cfce33a47d5c00ed179029dd2314d93423e73ad1162511908a8f000472d0ced exactly reconstructed from current service plus new unit spec. Remote gitea/develop fetched and equals base0e952ef70184040a27a6b53d7b59073502d25743.