diff --git a/backend/src/admin/blogs.concurrency.spec.ts b/backend/src/admin/blogs.concurrency.spec.ts new file mode 100644 index 00000000..fc250160 --- /dev/null +++ b/backend/src/admin/blogs.concurrency.spec.ts @@ -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"); + }); +}); diff --git a/backend/src/admin/blogs.service.ts b/backend/src/admin/blogs.service.ts index 3f1f8940..dd584588 100644 --- a/backend/src/admin/blogs.service.ts +++ b/backend/src/admin/blogs.service.ts @@ -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 { diff --git a/frontend/admin-panel/src/pages/OperationalAuthorization.test.tsx b/frontend/admin-panel/src/pages/OperationalAuthorization.test.tsx index 9ccbedc5..34a5dde7 100644 --- a/frontend/admin-panel/src/pages/OperationalAuthorization.test.tsx +++ b/frontend/admin-panel/src/pages/OperationalAuthorization.test.tsx @@ -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(); - 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'); }); }); diff --git a/specs/atomic-blog-concurrency/plan.md b/specs/atomic-blog-concurrency/plan.md new file mode 100644 index 00000000..8dad2b40 --- /dev/null +++ b/specs/atomic-blog-concurrency/plan.md @@ -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. diff --git a/specs/atomic-blog-concurrency/spec.md b/specs/atomic-blog-concurrency/spec.md new file mode 100644 index 00000000..4aae6767 --- /dev/null +++ b/specs/atomic-blog-concurrency/spec.md @@ -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. diff --git a/specs/atomic-blog-concurrency/tasks.md b/specs/atomic-blog-concurrency/tasks.md new file mode 100644 index 00000000..d1eec7f6 --- /dev/null +++ b/specs/atomic-blog-concurrency/tasks.md @@ -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.