feat(hermes): persist guarded corporate orchestration backend
This commit is contained in:
1 parent
5550c80a75
commit
cc365bcda2
13 files changed
+1734
No files matched your search
@@ -1,3 +1,5 @@
|
||||
import { CorporateController } from "./hermes/corporate.controller";
|
||||
import { CorporateService } from "./hermes/corporate.service";
|
||||
import { Module } from "@nestjs/common";
|
||||
import { AdminController } from "./admin.controller";
|
||||
import { AdminService } from "./admin.service";
|
||||
@@ -30,6 +32,7 @@ import { SupportChatAnalyticsService } from "./support-chat-analytics.service";
|
||||
@Module({
|
||||
imports: [PrismaModule, RedisModule, SettingsModule],
|
||||
controllers: [
|
||||
CorporateController,
|
||||
AdminController,
|
||||
ReportsController,
|
||||
MediaController,
|
||||
@@ -46,6 +49,7 @@ import { SupportChatAnalyticsService } from "./support-chat-analytics.service";
|
||||
SupportChatAnalyticsController,
|
||||
],
|
||||
providers: [
|
||||
CorporateService,
|
||||
AdminService,
|
||||
ReportsService,
|
||||
MediaService,
|
||||
|
||||
@@ -0,0 +1,32 @@
|
||||
import { normalizeSearch, pagination, taskInput } from './corporate-policy';
|
||||
describe('corporate contract policy', () => {
|
||||
it('normalizes Persian letters, digits and separators', () => {
|
||||
expect(normalizeSearch('كيك ۱۲۳ (ة)')).toBe('کیک 123 ه');
|
||||
});
|
||||
it('bounds pagination and sort keys', () => {
|
||||
expect(pagination({ limit: '100' }).limit).toBe(100);
|
||||
expect(() => pagination({ limit: '101' })).toThrow();
|
||||
expect(() => pagination({ page: '-1' })).toThrow();
|
||||
expect(() => pagination({ sortBy: 'password' })).toThrow();
|
||||
});
|
||||
it('defaults CEO priority and rejects status/command injection', () => {
|
||||
expect(
|
||||
taskInput({
|
||||
title: 'عنوان',
|
||||
description: 'کار',
|
||||
department: 'CONTENT_SEO',
|
||||
}).priority,
|
||||
).toBe('CEO_EXPEDITE');
|
||||
expect(() =>
|
||||
taskInput({
|
||||
title: 'x',
|
||||
description: 'x',
|
||||
department: 'CONTENT_SEO',
|
||||
status: 'DONE',
|
||||
}),
|
||||
).toThrow();
|
||||
expect(() =>
|
||||
taskInput({ title: '', description: 'x', department: 'CONTENT_SEO' }),
|
||||
).toThrow();
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,174 @@
|
||||
import { BadRequestException } from '@nestjs/common';
|
||||
export const departments = [
|
||||
'CONTENT_SEO',
|
||||
'CATALOG_COMMERCE',
|
||||
'WIKI_SCIENTIFIC',
|
||||
'TECH_DEVOPS',
|
||||
'MARKET_INTELLIGENCE',
|
||||
];
|
||||
export const priorities = ['CEO_EXPEDITE', 'CRITICAL', 'HIGH', 'MEDIUM', 'LOW'];
|
||||
export const statuses = [
|
||||
'TODO',
|
||||
'IN_PROGRESS',
|
||||
'TEST',
|
||||
'DONE',
|
||||
'BLOCKED',
|
||||
'REJECTED',
|
||||
'CANCELLED',
|
||||
];
|
||||
export function object(value: unknown, keys: string[]): Record<string, any> {
|
||||
if (
|
||||
!value ||
|
||||
typeof value !== 'object' ||
|
||||
Array.isArray(value) ||
|
||||
Object.keys(value).some((k) => !keys.includes(k))
|
||||
)
|
||||
throw new BadRequestException('Invalid fields');
|
||||
return value as Record<string, any>;
|
||||
}
|
||||
export function text(value: unknown, max = 10000): string {
|
||||
if (typeof value !== 'string' || !value.trim() || value.length > max)
|
||||
throw new BadRequestException('Invalid text');
|
||||
return value.trim();
|
||||
}
|
||||
export function uuid(value: unknown): string {
|
||||
const id = text(value, 36);
|
||||
if (
|
||||
!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
|
||||
id,
|
||||
)
|
||||
)
|
||||
throw new BadRequestException('Invalid UUID');
|
||||
return id;
|
||||
}
|
||||
export function choice(value: unknown, values: string[]): string {
|
||||
if (typeof value !== 'string' || !values.includes(value))
|
||||
throw new BadRequestException('Invalid enum');
|
||||
return value;
|
||||
}
|
||||
export function normalizeSearch(value: string): string {
|
||||
return value
|
||||
.normalize('NFKC')
|
||||
.toLowerCase()
|
||||
.replace(/[يى]/g, 'ی')
|
||||
.replace(/ك/g, 'ک')
|
||||
.replace(/ة/g, 'ه')
|
||||
.replace(/[۰-۹٠-٩]/g, (c) =>
|
||||
String(
|
||||
'۰۱۲۳۴۵۶۷۸۹'.includes(c)
|
||||
? '۰۱۲۳۴۵۶۷۸۹'.indexOf(c)
|
||||
: '٠١٢٣٤٥٦٧٨٩'.indexOf(c),
|
||||
),
|
||||
)
|
||||
.replace(/[\u200c\u200d()()]/g, ' ')
|
||||
.replace(/[\u064b-\u065f]/g, '')
|
||||
.replace(/\s+/g, ' ')
|
||||
.trim();
|
||||
}
|
||||
export function pagination(q: Record<string, any>) {
|
||||
const page = Number(q.page ?? 1),
|
||||
limit = Number(q.limit ?? 20);
|
||||
if (
|
||||
!Number.isSafeInteger(page) ||
|
||||
page < 1 ||
|
||||
page > 1000000 ||
|
||||
!Number.isInteger(limit) ||
|
||||
limit < 1 ||
|
||||
limit > 100
|
||||
)
|
||||
throw new BadRequestException('Invalid pagination');
|
||||
const sortBy = choice(q.sortBy ?? 'createdAt', [
|
||||
'createdAt',
|
||||
'updatedAt',
|
||||
'title',
|
||||
'taskCode',
|
||||
'priority',
|
||||
'status',
|
||||
]);
|
||||
const sortOrder = choice(q.sortOrder ?? 'desc', ['asc', 'desc']) as
|
||||
| 'asc'
|
||||
| 'desc';
|
||||
return { page, limit, skip: (page - 1) * limit, sortBy, sortOrder };
|
||||
}
|
||||
export function meta(total: number, page: number, limit: number) {
|
||||
const totalPages = Math.ceil(total / limit);
|
||||
return {
|
||||
total,
|
||||
page,
|
||||
limit,
|
||||
totalPages,
|
||||
hasNextPage: page < totalPages,
|
||||
hasPrevPage: page > 1,
|
||||
};
|
||||
}
|
||||
export function taskInput(input: unknown) {
|
||||
const b = object(input, [
|
||||
'title',
|
||||
'department',
|
||||
'description',
|
||||
'priority',
|
||||
'parentId',
|
||||
'goalId',
|
||||
'actionType',
|
||||
'dueCycle',
|
||||
]);
|
||||
return {
|
||||
title: text(b.title, 300),
|
||||
description: text(b.description),
|
||||
department: choice(b.department, departments),
|
||||
priority: choice(b.priority ?? 'CEO_EXPEDITE', priorities),
|
||||
parentId: b.parentId === undefined ? undefined : uuid(b.parentId),
|
||||
goalId: b.goalId === undefined ? undefined : uuid(b.goalId),
|
||||
actionType: choice(b.actionType ?? 'CEO_DIRECTIVE', [
|
||||
'CEO_DIRECTIVE',
|
||||
'BLOG_NEW',
|
||||
'BLOG_UPDATE',
|
||||
'CATALOG_ENRICH',
|
||||
'RESEARCH',
|
||||
'ENGINEERING',
|
||||
]),
|
||||
dueCycle: b.dueCycle === undefined ? undefined : text(b.dueCycle, 40),
|
||||
};
|
||||
}
|
||||
export function canonical(value: any): string {
|
||||
if (Array.isArray(value)) return '[' + value.map(canonical).join(',') + ']';
|
||||
if (value && typeof value === 'object')
|
||||
return (
|
||||
'{' +
|
||||
Object.keys(value)
|
||||
.sort()
|
||||
.map((k) => JSON.stringify(k) + ':' + canonical(value[k]))
|
||||
.join(',') +
|
||||
'}'
|
||||
);
|
||||
return JSON.stringify(value);
|
||||
}
|
||||
export function evidenceInput(input: unknown) {
|
||||
const b = object(input, [
|
||||
'claimToken',
|
||||
'artifactUri',
|
||||
'sha256',
|
||||
'summary',
|
||||
'tool',
|
||||
'result',
|
||||
]);
|
||||
const uri = text(b.artifactUri, 2000);
|
||||
if (
|
||||
!/^(https:\/\/|urn:sha256:)/.test(uri) ||
|
||||
/example\.(com|org)|localhost|127\.0\.0\.1/.test(uri)
|
||||
)
|
||||
throw new BadRequestException(
|
||||
'Evidence locator must be a real HTTPS artifact or content digest',
|
||||
);
|
||||
const sha = text(b.sha256, 64);
|
||||
if (!/^[a-f0-9]{64}$/.test(sha))
|
||||
throw new BadRequestException('Invalid digest');
|
||||
return {
|
||||
claimToken: uuid(b.claimToken),
|
||||
artifactUri: uri,
|
||||
sha256: sha,
|
||||
summary: text(b.summary),
|
||||
tool: text(b.tool, 100),
|
||||
result: text(b.result),
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,121 @@
|
||||
import {
|
||||
Body,
|
||||
Controller,
|
||||
Get,
|
||||
Headers,
|
||||
Param,
|
||||
Post,
|
||||
Query,
|
||||
Req,
|
||||
UnauthorizedException,
|
||||
UseGuards,
|
||||
} from '@nestjs/common';
|
||||
import { JwtAuthGuard } from '../../auth/jwt-auth.guard';
|
||||
import { RolesGuard } from '../../common/guards/roles.guard';
|
||||
import { Roles } from '../../common/decorators/roles.decorator';
|
||||
import { CorporateService } from './corporate.service';
|
||||
import { randomUUID } from 'crypto';
|
||||
import { text } from './corporate-policy';
|
||||
|
||||
@UseGuards(JwtAuthGuard, RolesGuard)
|
||||
@Roles('Admin', 'SUPER_ADMIN')
|
||||
@Controller('admin/hermes')
|
||||
export class CorporateController {
|
||||
constructor(private readonly service: CorporateService) {}
|
||||
private actor(req: any) {
|
||||
// API keys must use their authenticated key identity, not an editable worker label.
|
||||
const user = req.user;
|
||||
const id = user?.id ?? user?.sub;
|
||||
if (!id) throw new UnauthorizedException('Authenticated subject required');
|
||||
return (user.isApiKey ? 'apikey:' : 'user:') + text(String(id), 200);
|
||||
}
|
||||
private key(key?: string) {
|
||||
return text(key, 200);
|
||||
}
|
||||
@Get('runtime') runtime() {
|
||||
return {
|
||||
mode: 'MANUAL_DORMANT',
|
||||
schedulesEnabled: false,
|
||||
externalExecutionEnabled: false,
|
||||
};
|
||||
}
|
||||
@Get('tasks') tasks(@Query() query: Record<string, any>) {
|
||||
return this.service.tasks(query);
|
||||
}
|
||||
@Get('tasks/:id') detail(@Param('id') id: string) {
|
||||
return this.service.detail(id);
|
||||
}
|
||||
@Post('tasks') create(
|
||||
@Req() req: any,
|
||||
@Headers('idempotency-key') key: string,
|
||||
@Body() body: unknown,
|
||||
) {
|
||||
return this.service.create(this.actor(req), key ?? randomUUID(), body);
|
||||
}
|
||||
@Post('claims') claim(
|
||||
@Req() req: any,
|
||||
@Headers('idempotency-key') key: string,
|
||||
@Body() body: unknown,
|
||||
) {
|
||||
return this.service.claim(this.actor(req), this.key(key), body);
|
||||
}
|
||||
@Post('tasks/:id/evidence') evidence(
|
||||
@Req() req: any,
|
||||
@Headers('idempotency-key') key: string,
|
||||
@Param('id') id: string,
|
||||
@Body() body: unknown,
|
||||
) {
|
||||
return this.service.submitEvidence(
|
||||
this.actor(req),
|
||||
this.key(key),
|
||||
id,
|
||||
body,
|
||||
);
|
||||
}
|
||||
@Post('tasks/:id/reviews') review(
|
||||
@Req() req: any,
|
||||
@Headers('idempotency-key') key: string,
|
||||
@Param('id') id: string,
|
||||
@Body() body: unknown,
|
||||
) {
|
||||
return this.service.review(this.actor(req), this.key(key), id, body);
|
||||
}
|
||||
@Post('tasks/:id/effects') effect(
|
||||
@Req() req: any,
|
||||
@Headers('idempotency-key') key: string,
|
||||
@Param('id') id: string,
|
||||
@Body() body: unknown,
|
||||
) {
|
||||
return this.service.effect(this.actor(req), this.key(key), id, body);
|
||||
}
|
||||
@Get('market-insights') insights(@Query() q: Record<string, any>) {
|
||||
return this.service.collection('market-insights', q);
|
||||
}
|
||||
@Post('market-insights') research(
|
||||
@Req() req: any,
|
||||
@Headers('idempotency-key') key: string,
|
||||
@Body() body: unknown,
|
||||
) {
|
||||
return this.service.research(this.actor(req), this.key(key), body);
|
||||
}
|
||||
@Get('monthly-roadmap') roadmaps(@Query() q: Record<string, any>) {
|
||||
return this.service.collection('monthly-roadmap', q);
|
||||
}
|
||||
@Post('monthly-roadmap') roadmap(
|
||||
@Req() req: any,
|
||||
@Headers('idempotency-key') key: string,
|
||||
@Body() body: unknown,
|
||||
) {
|
||||
return this.service.roadmap(this.actor(req), this.key(key), body);
|
||||
}
|
||||
@Get('reports') reports(@Query() q: Record<string, any>) {
|
||||
return this.service.collection('reports', q);
|
||||
}
|
||||
@Post('reports') report(
|
||||
@Req() req: any,
|
||||
@Headers('idempotency-key') key: string,
|
||||
@Body() body: unknown,
|
||||
) {
|
||||
return this.service.report(this.actor(req), this.key(key), body);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,303 @@
|
||||
import passport from 'passport';
|
||||
import { Strategy, ExtractJwt } from 'passport-jwt';
|
||||
import { PrismaClient } from '@prisma/client';
|
||||
import { Test } from '@nestjs/testing';
|
||||
import { INestApplication } from '@nestjs/common';
|
||||
import { randomUUID } from 'crypto';
|
||||
import request from 'supertest';
|
||||
import { PrismaService } from '../../prisma/prisma.service';
|
||||
import { CorporateController } from './corporate.controller';
|
||||
import { CorporateService } from './corporate.service';
|
||||
import { ApiKeysService } from '../api-keys.service';
|
||||
|
||||
const integration = process.env.CORPORATE_TEST_DATABASE_URL
|
||||
? describe
|
||||
: describe.skip;
|
||||
integration('corporate API / disposable PostgreSQL', () => {
|
||||
let app: INestApplication, db: PrismaService;
|
||||
const key = () => randomUUID();
|
||||
const post = (path: string, body: any, actor = 'executor', op = key()) =>
|
||||
request(app.getHttpServer())
|
||||
.post('/admin/hermes/' + path)
|
||||
.set('x-api-key', actor)
|
||||
.set('Idempotency-Key', op)
|
||||
.send(body);
|
||||
const input = {
|
||||
title: 'كيك ۱۲۳',
|
||||
description: 'integration fixture',
|
||||
department: 'CONTENT_SEO',
|
||||
};
|
||||
beforeAll(async () => {
|
||||
// Explicit disposable loopback opt-in only; never consumes runtime DATABASE_URL.
|
||||
const url = new URL(process.env.CORPORATE_TEST_DATABASE_URL!);
|
||||
if (url.hostname !== '127.0.0.1' || url.pathname !== '/corporate_test')
|
||||
throw new Error('Disposable loopback corporate_test DB required');
|
||||
passport.use(
|
||||
'jwt',
|
||||
new Strategy(
|
||||
{
|
||||
jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
|
||||
secretOrKey: 'test-only-not-runtime',
|
||||
},
|
||||
(_payload, done) => done(null, false),
|
||||
),
|
||||
);
|
||||
db = new PrismaClient({
|
||||
datasources: { db: { url: process.env.CORPORATE_TEST_DATABASE_URL } },
|
||||
}) as PrismaService;
|
||||
const module = await Test.createTestingModule({
|
||||
controllers: [CorporateController],
|
||||
providers: [
|
||||
CorporateService,
|
||||
{ provide: PrismaService, useValue: db },
|
||||
{
|
||||
provide: ApiKeysService,
|
||||
useValue: {
|
||||
validateKey: async (id: string) => ({
|
||||
id,
|
||||
isApiKey: true,
|
||||
role: 'Admin',
|
||||
scopes: id === 'unscoped' ? [] : ['admin'],
|
||||
}),
|
||||
},
|
||||
},
|
||||
],
|
||||
}).compile();
|
||||
app = module.createNestApplication();
|
||||
await app.listen(0, '127.0.0.1');
|
||||
});
|
||||
afterAll(async () => {
|
||||
if (db)
|
||||
await db.$executeRawUnsafe(
|
||||
'TRUNCATE corporate_operations, corporate_reports, corporate_effects, corporate_reviews, corporate_evidence, corporate_events, corporate_tasks, corporate_goals, corporate_roadmaps, corporate_sources, corporate_research CASCADE',
|
||||
);
|
||||
await app?.close();
|
||||
await db?.$disconnect();
|
||||
passport.unuse('jwt');
|
||||
});
|
||||
beforeEach(async () => {
|
||||
await db.$executeRawUnsafe(
|
||||
'TRUNCATE corporate_operations, corporate_reports, corporate_effects, corporate_reviews, corporate_evidence, corporate_events, corporate_tasks, corporate_goals, corporate_roadmaps, corporate_sources, corporate_research CASCADE',
|
||||
);
|
||||
});
|
||||
it('auth, UI list contract, normalized search, immutable idempotent replay', async () => {
|
||||
await request(app.getHttpServer()).get('/admin/hermes/tasks').expect(401);
|
||||
await post('tasks', input, 'unscoped').expect(403);
|
||||
const op = key(),
|
||||
a = await post('tasks', input, 'executor', op).expect(201);
|
||||
const b = await post('tasks', input, 'executor', op).expect(201);
|
||||
expect(b.body.id).toBe(a.body.id);
|
||||
await post('tasks', { ...input, title: 'changed' }, 'executor', op).expect(
|
||||
409,
|
||||
);
|
||||
const list = await request(app.getHttpServer())
|
||||
.get('/admin/hermes/tasks?search=کیک%20123&limit=1')
|
||||
.set('x-api-key', 'executor')
|
||||
.expect(200);
|
||||
expect(list.body.meta).toEqual({
|
||||
total: 1,
|
||||
page: 1,
|
||||
limit: 1,
|
||||
totalPages: 1,
|
||||
hasNextPage: false,
|
||||
hasPrevPage: false,
|
||||
});
|
||||
expect(list.body.data[0].priority).toBe('CEO_EXPEDITE');
|
||||
await request(app.getHttpServer())
|
||||
.get('/admin/hermes/tasks?limit=101')
|
||||
.set('x-api-key', 'executor')
|
||||
.expect(400);
|
||||
await request(app.getHttpServer())
|
||||
.get('/admin/hermes/tasks?sortBy=password')
|
||||
.set('x-api-key', 'executor')
|
||||
.expect(400);
|
||||
});
|
||||
it('claims exclusively, expires/reclaims, fences stale executor, requires independent QA', async () => {
|
||||
const task = (await post('tasks', input).expect(201)).body;
|
||||
const claims = await Promise.all([
|
||||
post('claims', {}, 'executor'),
|
||||
post('claims', {}, 'competitor'),
|
||||
]);
|
||||
expect(claims.filter((x) => x.body.task !== null)).toHaveLength(1);
|
||||
const claimed = claims.find((x) => x.body.task !== null)!.body.task;
|
||||
const oldActor = claimed.assignedAgent.replace('apikey:', '');
|
||||
await db.$executeRaw`UPDATE corporate_tasks SET "leasedUntil"=clock_timestamp()-interval '1 second' WHERE id=${task.id}::uuid`;
|
||||
const renewed = (await post('claims', {}, 'new-executor').expect(201)).body
|
||||
.task;
|
||||
expect(renewed.claimToken).not.toBe(claimed.claimToken);
|
||||
const evidence = {
|
||||
claimToken: claimed.claimToken,
|
||||
artifactUri: 'urn:sha256:' + 'a'.repeat(64),
|
||||
sha256: 'a'.repeat(64),
|
||||
summary: 'receipt',
|
||||
tool: 'jest',
|
||||
result: 'passed',
|
||||
};
|
||||
await post(`tasks/${task.id}/evidence`, evidence, oldActor).expect(409);
|
||||
const e = (
|
||||
await post(
|
||||
`tasks/${task.id}/evidence`,
|
||||
{ ...evidence, claimToken: renewed.claimToken },
|
||||
'new-executor',
|
||||
).expect(201)
|
||||
).body;
|
||||
const review = {
|
||||
evidenceId: e.id,
|
||||
passed: true,
|
||||
findings: 'verified',
|
||||
verification: {
|
||||
artifactUri: e.artifactUri,
|
||||
sha256: e.sha256,
|
||||
method: 'digest readback',
|
||||
result: 'match',
|
||||
},
|
||||
};
|
||||
await post(`tasks/${task.id}/reviews`, review, 'new-executor').expect(409);
|
||||
await post(`tasks/${task.id}/reviews`, review, 'reviewer').expect(201);
|
||||
const detail = await request(app.getHttpServer())
|
||||
.get('/admin/hermes/tasks/' + task.id)
|
||||
.set('x-api-key', 'reviewer')
|
||||
.expect(200);
|
||||
expect(detail.body.status).toBe('DONE');
|
||||
expect(detail.body.logs.map((x: any) => x.step)).toContain('QA_PASSED');
|
||||
await post(`tasks/${task.id}/effects`, {
|
||||
metric: 'engagement',
|
||||
availability: 'UNAVAILABLE',
|
||||
observed: 0,
|
||||
source: 'provider unavailable',
|
||||
observedAt: new Date().toISOString(),
|
||||
}).expect(400);
|
||||
});
|
||||
it('skips a held row lock and gives CEO priority before lower priorities', async () => {
|
||||
const urgent = (await post('tasks', input).expect(201)).body;
|
||||
const low = (await post('tasks', { ...input, priority: 'LOW' }).expect(201))
|
||||
.body;
|
||||
let release!: () => void, locked!: () => void;
|
||||
const ready = new Promise<void>((r) => (locked = r)),
|
||||
hold = new Promise<void>((r) => (release = r));
|
||||
const locking = db.$transaction(async (tx) => {
|
||||
await tx.$queryRaw`SELECT id FROM corporate_tasks WHERE id=${urgent.id}::uuid FOR UPDATE`;
|
||||
locked();
|
||||
await hold;
|
||||
});
|
||||
await ready;
|
||||
try {
|
||||
const claim = (await post('claims', {}).expect(201)).body.task;
|
||||
expect(claim.id).toBe(low.id);
|
||||
} finally {
|
||||
release();
|
||||
await locking;
|
||||
}
|
||||
const next = (await post('claims', {}, 'other').expect(201)).body.task;
|
||||
expect(next.id).toBe(urgent.id);
|
||||
});
|
||||
it('serializes simultaneous duplicate mutations into one durable record', async () => {
|
||||
const op = key();
|
||||
const responses = await Promise.all([
|
||||
post('tasks', input, 'executor', op),
|
||||
post('tasks', input, 'executor', op),
|
||||
]);
|
||||
expect(responses.map((r) => r.status)).toEqual([201, 201]);
|
||||
expect(responses[0].body.id).toBe(responses[1].body.id);
|
||||
expect(await db.corporateTask.count()).toBe(1);
|
||||
});
|
||||
it('gates parents on children, persists provenance, roadmap/goals and reports', async () => {
|
||||
const parent = (await post('tasks', input).expect(201)).body;
|
||||
const child = (
|
||||
await post('tasks', { ...input, parentId: parent.id }).expect(201)
|
||||
).body;
|
||||
const claim = (await post('claims', {}).expect(201)).body.task;
|
||||
expect(claim.id).toBe(child.id);
|
||||
const e = (
|
||||
await post(`tasks/${child.id}/evidence`, {
|
||||
claimToken: claim.claimToken,
|
||||
artifactUri: 'urn:sha256:' + 'b'.repeat(64),
|
||||
sha256: 'b'.repeat(64),
|
||||
summary: 'child artifact',
|
||||
tool: 'jest',
|
||||
result: 'receipt',
|
||||
}).expect(201)
|
||||
).body;
|
||||
await post(
|
||||
`tasks/${child.id}/reviews`,
|
||||
{
|
||||
evidenceId: e.id,
|
||||
passed: false,
|
||||
findings: 'needs correction',
|
||||
verification: {
|
||||
artifactUri: e.artifactUri,
|
||||
sha256: e.sha256,
|
||||
method: 'readback',
|
||||
result: 'failed',
|
||||
},
|
||||
},
|
||||
'reviewer',
|
||||
).expect(201);
|
||||
expect(
|
||||
(await db.corporateTask.findUniqueOrThrow({ where: { id: parent.id } }))
|
||||
.status,
|
||||
).toBe('BLOCKED');
|
||||
expect((await post('claims', {}).expect(201)).body.task.id).toBe(child.id);
|
||||
const research = (
|
||||
await post('market-insights', {
|
||||
title: 'fixture research',
|
||||
category: 'TREND',
|
||||
source: 'study receipt',
|
||||
opportunity: 'investigate',
|
||||
impact: 'LOW',
|
||||
recommendedAction: 'measure',
|
||||
cadence: 'MONTHLY',
|
||||
provenance: {
|
||||
method: 'test fixture',
|
||||
collector: 'integration',
|
||||
context: 'disposable',
|
||||
},
|
||||
sources: [
|
||||
{
|
||||
url: 'https://pubmed.ncbi.nlm.nih.gov/',
|
||||
title: 'fixture',
|
||||
excerpt: 'test-only',
|
||||
retrievedAt: '2026-01-01T00:00:00Z',
|
||||
sha256: 'a'.repeat(64),
|
||||
},
|
||||
],
|
||||
}).expect(201)
|
||||
).body;
|
||||
const roadmap = (
|
||||
await post('monthly-roadmap', {
|
||||
researchId: research.id,
|
||||
cycleName: 'test',
|
||||
month: '2026-10',
|
||||
seasonalTheme: 'evidence pending seasonal analysis',
|
||||
strategicGoals: ['measure'],
|
||||
plannedArticlesCount: 31,
|
||||
plannedRefreshesCount: 0,
|
||||
plannedCatalogEnrichments: 0,
|
||||
goals: [
|
||||
{
|
||||
title: 'goal',
|
||||
department: 'CONTENT_SEO',
|
||||
acceptanceCriteria: 'QA',
|
||||
metric: 'engagement',
|
||||
},
|
||||
],
|
||||
}).expect(201)
|
||||
).body;
|
||||
expect(roadmap.goals).toHaveLength(1);
|
||||
await post('tasks', { ...input, goalId: roadmap.goals[0].id }).expect(201);
|
||||
for (const path of ['market-insights', 'monthly-roadmap']) {
|
||||
const r = await request(app.getHttpServer())
|
||||
.get('/admin/hermes/' + path)
|
||||
.set('x-api-key', 'executor')
|
||||
.expect(200);
|
||||
expect(r.body.meta.total).toBe(1);
|
||||
}
|
||||
const report = (
|
||||
await post('reports', {
|
||||
day: new Date().toISOString().slice(0, 10),
|
||||
summary: 'test fixture daily report',
|
||||
}).expect(201)
|
||||
).body;
|
||||
expect(report.snapshot.tasks).toHaveLength(3);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,600 @@
|
||||
import {
|
||||
Injectable,
|
||||
BadRequestException,
|
||||
ConflictException,
|
||||
NotFoundException,
|
||||
} from '@nestjs/common';
|
||||
import { Prisma, CorporatePriority } from '@prisma/client';
|
||||
import { createHash, randomUUID } from 'crypto';
|
||||
import { PrismaService } from '../../prisma/prisma.service';
|
||||
import {
|
||||
canonical,
|
||||
choice,
|
||||
departments,
|
||||
evidenceInput,
|
||||
meta,
|
||||
normalizeSearch,
|
||||
object,
|
||||
pagination,
|
||||
priorities,
|
||||
statuses,
|
||||
taskInput,
|
||||
text,
|
||||
uuid,
|
||||
} from './corporate-policy';
|
||||
type Tx = Prisma.TransactionClient;
|
||||
@Injectable()
|
||||
export class CorporateService {
|
||||
constructor(private readonly db: PrismaService) {}
|
||||
private async operation(
|
||||
actor: string,
|
||||
op: string,
|
||||
key: string,
|
||||
body: unknown,
|
||||
fn: (tx: Tx) => Promise<any>,
|
||||
) {
|
||||
text(key, 200);
|
||||
const scoped = createHash('sha256')
|
||||
.update(canonical([actor, op, key]))
|
||||
.digest('hex');
|
||||
const hash = createHash('sha256').update(canonical(body)).digest('hex');
|
||||
return this.db.$transaction(
|
||||
async (tx) => {
|
||||
await tx.$executeRaw`SELECT pg_advisory_xact_lock(hashtextextended(${scoped}, 0))`;
|
||||
const prior = await tx.corporateOperation.findUnique({
|
||||
where: { key: scoped },
|
||||
});
|
||||
if (prior) {
|
||||
if (prior.payloadHash !== hash)
|
||||
throw new ConflictException('Idempotency key payload mismatch');
|
||||
return prior.response;
|
||||
}
|
||||
const result = await fn(tx);
|
||||
const response = JSON.parse(JSON.stringify(result));
|
||||
await tx.corporateOperation.create({
|
||||
data: { key: scoped, payloadHash: hash, response },
|
||||
});
|
||||
return response;
|
||||
},
|
||||
{ maxWait: 10000, timeout: 20000 },
|
||||
);
|
||||
}
|
||||
private event(
|
||||
tx: Tx,
|
||||
taskId: string,
|
||||
actor: string,
|
||||
step: string,
|
||||
content: string,
|
||||
speaker = 'SYSTEM',
|
||||
payload?: any,
|
||||
) {
|
||||
return tx.corporateEvent.create({
|
||||
data: { taskId, speaker, speakerName: actor, step, content, payload },
|
||||
});
|
||||
}
|
||||
private async lock(tx: Tx, id: string) {
|
||||
uuid(id);
|
||||
const rows = await tx.$queryRaw<
|
||||
{ id: string }[]
|
||||
>`SELECT id FROM corporate_tasks WHERE id=${id}::uuid FOR UPDATE`;
|
||||
if (!rows.length) throw new NotFoundException('Task not found');
|
||||
return tx.corporateTask.findUniqueOrThrow({ where: { id } });
|
||||
}
|
||||
private async fenced(tx: Tx, id: string, token: string, actor: string) {
|
||||
const t = await this.lock(tx, id);
|
||||
const rows = await tx.$queryRaw<
|
||||
{ id: string }[]
|
||||
>`SELECT id FROM corporate_tasks WHERE id=${id}::uuid AND "claimToken"=${token}::uuid AND "assignedAgent"=${actor} AND "leasedUntil">clock_timestamp() AND status='IN_PROGRESS'`;
|
||||
if (!rows.length) throw new ConflictException('Stale lease or owner');
|
||||
return t;
|
||||
}
|
||||
async tasks(q: Record<string, any>) {
|
||||
const p = pagination(q),
|
||||
where: Prisma.CorporateTaskWhereInput = {};
|
||||
if (q.department) where.department = choice(q.department, departments);
|
||||
if (q.priority)
|
||||
where.priority = choice(q.priority, priorities) as CorporatePriority;
|
||||
if (q.status) where.status = choice(q.status, statuses) as any;
|
||||
if (q.search) {
|
||||
const search = normalizeSearch(text(q.search, 300));
|
||||
where.OR = [
|
||||
{ normalizedTitle: { contains: search } },
|
||||
{ normalizedCode: { contains: search } },
|
||||
];
|
||||
}
|
||||
if (q.goalId) where.goalId = uuid(q.goalId);
|
||||
return this.db.$transaction(
|
||||
async (tx) => {
|
||||
const total = await tx.corporateTask.count({ where });
|
||||
const data = await tx.corporateTask.findMany({
|
||||
where,
|
||||
skip: p.skip,
|
||||
take: p.limit,
|
||||
orderBy: [{ [p.sortBy]: p.sortOrder }, { id: 'asc' }],
|
||||
});
|
||||
return { data, meta: meta(total, p.page, p.limit) };
|
||||
},
|
||||
{ isolationLevel: Prisma.TransactionIsolationLevel.RepeatableRead },
|
||||
);
|
||||
}
|
||||
async detail(id: string) {
|
||||
uuid(id);
|
||||
const task = await this.db.corporateTask.findUnique({
|
||||
where: { id },
|
||||
include: {
|
||||
logs: { orderBy: { timestamp: 'asc' } },
|
||||
evidence: true,
|
||||
reviews: true,
|
||||
effects: true,
|
||||
children: true,
|
||||
},
|
||||
});
|
||||
if (!task) throw new NotFoundException('Task not found');
|
||||
return task;
|
||||
}
|
||||
create(actor: string, key: string, input: unknown) {
|
||||
const b = taskInput(input);
|
||||
return this.operation(actor, 'create-task', key, b, async (tx) => {
|
||||
if (b.parentId) {
|
||||
const parent = await this.lock(tx, b.parentId);
|
||||
if (!['TODO', 'IN_PROGRESS', 'BLOCKED'].includes(parent.status))
|
||||
throw new ConflictException('Parent no longer accepts children');
|
||||
}
|
||||
const code = 'TSK-' + randomUUID();
|
||||
const task = await tx.corporateTask.create({
|
||||
data: {
|
||||
...b,
|
||||
priority: b.priority as CorporatePriority,
|
||||
taskCode: code,
|
||||
normalizedCode: normalizeSearch(code),
|
||||
normalizedTitle: normalizeSearch(b.title),
|
||||
createdBy: actor,
|
||||
},
|
||||
});
|
||||
await this.event(tx, task.id, actor, 'CREATED', b.description, 'CEO');
|
||||
return task;
|
||||
});
|
||||
}
|
||||
claim(actor: string, key: string, input: unknown) {
|
||||
const b = object(input, ['department', 'leaseSeconds']);
|
||||
const department =
|
||||
b.department === undefined ? null : choice(b.department, departments);
|
||||
const seconds = Number(b.leaseSeconds ?? 300);
|
||||
if (!Number.isInteger(seconds) || seconds < 30 || seconds > 900)
|
||||
throw new BadRequestException('Lease must be 30..900 seconds');
|
||||
return this.operation(
|
||||
actor,
|
||||
'claim',
|
||||
key,
|
||||
{ department, seconds },
|
||||
async (tx) => {
|
||||
const candidates = await tx.$queryRaw<
|
||||
{ id: string }[]
|
||||
>`SELECT t.id FROM corporate_tasks t
|
||||
WHERE (t.status='TODO' OR (t.status='BLOCKED' AND EXISTS (SELECT 1 FROM corporate_tasks c WHERE c."parentId"=t.id)) OR (t.status='IN_PROGRESS' AND t."leasedUntil"<=clock_timestamp()))
|
||||
AND (${department}::text IS NULL OR t.department=${department})
|
||||
AND NOT EXISTS (SELECT 1 FROM corporate_tasks c WHERE c."parentId"=t.id AND c.status<>'DONE')
|
||||
ORDER BY t.priority ASC,t."updatedAt" ASC,t.id ASC FOR UPDATE OF t SKIP LOCKED LIMIT 1`;
|
||||
if (!candidates.length) return { task: null };
|
||||
const id = candidates[0].id,
|
||||
token = randomUUID();
|
||||
await tx.$executeRaw`UPDATE corporate_tasks SET status='IN_PROGRESS', "assignedAgent"=${actor}, "claimToken"=${token}::uuid, "leasedUntil"=clock_timestamp()+make_interval(secs=>${seconds}::int), "executionCount"="executionCount"+1,"updatedAt"=clock_timestamp() WHERE id=${id}::uuid`;
|
||||
await this.event(tx, id, actor, 'CLAIMED', 'Manual lease acquired');
|
||||
return {
|
||||
task: await tx.corporateTask.findUniqueOrThrow({ where: { id } }),
|
||||
};
|
||||
},
|
||||
);
|
||||
}
|
||||
submitEvidence(actor: string, key: string, id: string, input: unknown) {
|
||||
const b = evidenceInput(input);
|
||||
return this.operation(actor, 'evidence:' + id, key, b, async (tx) => {
|
||||
await this.fenced(tx, id, b.claimToken, actor);
|
||||
const e = await tx.corporateEvidence.create({
|
||||
data: { ...b, taskId: id, executor: actor },
|
||||
});
|
||||
await tx.corporateTask.update({
|
||||
where: { id },
|
||||
data: { status: 'TEST', leasedUntil: null },
|
||||
});
|
||||
await this.event(
|
||||
tx,
|
||||
id,
|
||||
actor,
|
||||
'EVIDENCE_SUBMITTED',
|
||||
b.summary,
|
||||
'AGENT',
|
||||
{ evidenceId: e.id },
|
||||
);
|
||||
return e;
|
||||
});
|
||||
}
|
||||
review(actor: string, key: string, id: string, input: unknown) {
|
||||
const b = object(input, [
|
||||
'evidenceId',
|
||||
'passed',
|
||||
'findings',
|
||||
'verification',
|
||||
]);
|
||||
const evidenceId = uuid(b.evidenceId),
|
||||
findings = text(b.findings);
|
||||
if (typeof b.passed !== 'boolean')
|
||||
throw new BadRequestException('passed must be boolean');
|
||||
const v = object(b.verification, [
|
||||
'artifactUri',
|
||||
'sha256',
|
||||
'method',
|
||||
'result',
|
||||
]);
|
||||
const verification = {
|
||||
artifactUri: text(v.artifactUri, 2000),
|
||||
sha256: text(v.sha256, 64),
|
||||
method: text(v.method, 1000),
|
||||
result: text(v.result),
|
||||
};
|
||||
return this.operation(actor, 'review:' + id, key, b, async (tx) => {
|
||||
uuid(id);
|
||||
const relation = await tx.corporateTask.findUnique({
|
||||
where: { id },
|
||||
select: { parentId: true },
|
||||
});
|
||||
if (relation?.parentId) await this.lock(tx, relation.parentId);
|
||||
const task = await this.lock(tx, id);
|
||||
const evidence = await tx.corporateEvidence.findUnique({
|
||||
where: { id: evidenceId },
|
||||
});
|
||||
if (
|
||||
task.status !== 'TEST' ||
|
||||
!evidence ||
|
||||
evidence.taskId !== id ||
|
||||
evidence.claimToken !== task.claimToken
|
||||
)
|
||||
throw new ConflictException('Current execution evidence required');
|
||||
if (evidence.executor === actor)
|
||||
throw new ConflictException('Independent reviewer required');
|
||||
if (
|
||||
verification.sha256 !== evidence.sha256 ||
|
||||
verification.artifactUri !== evidence.artifactUri
|
||||
)
|
||||
throw new ConflictException('QA must verify exact artifact');
|
||||
if (
|
||||
b.passed &&
|
||||
(await tx.corporateTask.count({
|
||||
where: { parentId: id, status: { not: 'DONE' } },
|
||||
}))
|
||||
)
|
||||
throw new ConflictException('Unfinished children');
|
||||
const r = await tx.corporateReview.create({
|
||||
data: {
|
||||
taskId: id,
|
||||
evidenceId,
|
||||
reviewer: actor,
|
||||
passed: b.passed,
|
||||
findings,
|
||||
verification,
|
||||
},
|
||||
});
|
||||
await tx.corporateTask.update({
|
||||
where: { id },
|
||||
data: {
|
||||
status: b.passed ? 'DONE' : 'TODO',
|
||||
claimToken: null,
|
||||
leasedUntil: null,
|
||||
qaCount: { increment: 1 },
|
||||
rejectionCount: { increment: b.passed ? 0 : 1 },
|
||||
},
|
||||
});
|
||||
if (!b.passed && task.parentId) {
|
||||
await tx.corporateTask.update({
|
||||
where: { id: task.parentId },
|
||||
data: { status: 'BLOCKED' },
|
||||
});
|
||||
await this.event(
|
||||
tx,
|
||||
task.parentId,
|
||||
actor,
|
||||
'CHILD_QA_REJECTED',
|
||||
'Parent blocked pending child correction',
|
||||
'QA',
|
||||
{ childId: id },
|
||||
);
|
||||
}
|
||||
await this.event(
|
||||
tx,
|
||||
id,
|
||||
actor,
|
||||
b.passed ? 'QA_PASSED' : 'QA_REJECTED',
|
||||
findings,
|
||||
'QA',
|
||||
{ reviewId: r.id },
|
||||
);
|
||||
return r;
|
||||
});
|
||||
}
|
||||
async collection(
|
||||
kind: 'market-insights' | 'monthly-roadmap' | 'reports',
|
||||
q: Record<string, any>,
|
||||
) {
|
||||
const p = pagination(q);
|
||||
return this.db.$transaction(
|
||||
async (tx) => {
|
||||
const model =
|
||||
kind === 'market-insights'
|
||||
? tx.corporateResearch
|
||||
: kind === 'monthly-roadmap'
|
||||
? tx.corporateRoadmap
|
||||
: tx.corporateReport;
|
||||
const where: any = {};
|
||||
if (kind === 'market-insights' && q.category)
|
||||
where.category = choice(q.category, [
|
||||
'TREND',
|
||||
'COMPETITOR',
|
||||
'NEW_CHANNEL',
|
||||
'CATALOG_GAP',
|
||||
]);
|
||||
if (kind === 'monthly-roadmap' && q.month)
|
||||
where.month = text(q.month, 40);
|
||||
const delegate = model as any;
|
||||
const total = await delegate.count({ where });
|
||||
const data = await delegate.findMany({
|
||||
where,
|
||||
skip: p.skip,
|
||||
take: p.limit,
|
||||
orderBy: [{ createdAt: 'desc' }, { id: 'asc' }],
|
||||
...(kind === 'market-insights'
|
||||
? { include: { sources: true } }
|
||||
: kind === 'monthly-roadmap'
|
||||
? { include: { goals: true } }
|
||||
: {}),
|
||||
});
|
||||
return { data, meta: meta(total, p.page, p.limit) };
|
||||
},
|
||||
{ isolationLevel: Prisma.TransactionIsolationLevel.RepeatableRead },
|
||||
);
|
||||
}
|
||||
research(actor: string, key: string, input: unknown) {
|
||||
const b = object(input, [
|
||||
'title',
|
||||
'category',
|
||||
'source',
|
||||
'opportunity',
|
||||
'impact',
|
||||
'recommendedAction',
|
||||
'cadence',
|
||||
'provenance',
|
||||
'sources',
|
||||
]);
|
||||
if (!Array.isArray(b.sources) || !b.sources.length || b.sources.length > 30)
|
||||
throw new BadRequestException('1..30 sources required');
|
||||
const sources = b.sources.map((raw) => {
|
||||
const s = object(raw, [
|
||||
'url',
|
||||
'title',
|
||||
'excerpt',
|
||||
'retrievedAt',
|
||||
'sha256',
|
||||
]);
|
||||
const url = text(s.url, 2000),
|
||||
sha256 = text(s.sha256, 64),
|
||||
retrievedAt = new Date(s.retrievedAt);
|
||||
if (
|
||||
!url.startsWith('https://') ||
|
||||
!/^[a-f0-9]{64}$/.test(sha256) ||
|
||||
!Number.isFinite(retrievedAt.getTime()) ||
|
||||
retrievedAt.getTime() > Date.now()
|
||||
)
|
||||
throw new BadRequestException('Invalid source');
|
||||
return {
|
||||
url,
|
||||
sha256,
|
||||
retrievedAt,
|
||||
title: text(s.title, 300),
|
||||
excerpt: text(s.excerpt),
|
||||
};
|
||||
});
|
||||
const provenance = object(b.provenance, ['method', 'collector', 'context']);
|
||||
const data = {
|
||||
title: text(b.title, 300),
|
||||
category: choice(b.category, [
|
||||
'TREND',
|
||||
'COMPETITOR',
|
||||
'NEW_CHANNEL',
|
||||
'CATALOG_GAP',
|
||||
]),
|
||||
source: text(b.source, 2000),
|
||||
opportunity: text(b.opportunity),
|
||||
impact: choice(b.impact, ['HIGH', 'MEDIUM', 'LOW']),
|
||||
recommendedAction: text(b.recommendedAction),
|
||||
cadence: choice(b.cadence, ['MONTHLY', 'EVENT']),
|
||||
provenance: {
|
||||
method: text(provenance.method),
|
||||
collector: text(provenance.collector, 300),
|
||||
context: text(provenance.context),
|
||||
},
|
||||
createdBy: actor,
|
||||
};
|
||||
return this.operation(actor, 'research', key, b, (tx) =>
|
||||
tx.corporateResearch.create({
|
||||
data: { ...data, sources: { create: sources } },
|
||||
include: { sources: true },
|
||||
}),
|
||||
);
|
||||
}
|
||||
roadmap(actor: string, key: string, input: unknown) {
|
||||
const b = object(input, [
|
||||
'researchId',
|
||||
'cycleName',
|
||||
'month',
|
||||
'seasonalTheme',
|
||||
'strategicGoals',
|
||||
'plannedArticlesCount',
|
||||
'plannedRefreshesCount',
|
||||
'plannedCatalogEnrichments',
|
||||
'isActive',
|
||||
'goals',
|
||||
]);
|
||||
if (
|
||||
!Array.isArray(b.strategicGoals) ||
|
||||
!b.strategicGoals.length ||
|
||||
b.strategicGoals.length > 30 ||
|
||||
!Array.isArray(b.goals) ||
|
||||
!b.goals.length ||
|
||||
b.goals.length > 100
|
||||
)
|
||||
throw new BadRequestException('Goals required');
|
||||
for (const k of [
|
||||
'plannedArticlesCount',
|
||||
'plannedRefreshesCount',
|
||||
'plannedCatalogEnrichments',
|
||||
])
|
||||
if (!Number.isInteger(b[k]) || b[k] < 0 || b[k] > 10000)
|
||||
throw new BadRequestException('Invalid counts');
|
||||
if (b.isActive !== undefined && typeof b.isActive !== 'boolean')
|
||||
throw new BadRequestException('Invalid active flag');
|
||||
const goals = b.goals.map((raw) => {
|
||||
const g = object(raw, [
|
||||
'title',
|
||||
'department',
|
||||
'acceptanceCriteria',
|
||||
'metric',
|
||||
'target',
|
||||
]);
|
||||
if (
|
||||
g.target !== undefined &&
|
||||
(typeof g.target !== 'number' || !Number.isFinite(g.target))
|
||||
)
|
||||
throw new BadRequestException('Invalid target');
|
||||
return {
|
||||
title: text(g.title, 300),
|
||||
department: choice(g.department, departments),
|
||||
acceptanceCriteria: text(g.acceptanceCriteria),
|
||||
metric: text(g.metric, 300),
|
||||
target: g.target,
|
||||
};
|
||||
});
|
||||
const data = {
|
||||
researchId: uuid(b.researchId),
|
||||
cycleName: text(b.cycleName, 300),
|
||||
month: text(b.month, 40),
|
||||
seasonalTheme: text(b.seasonalTheme),
|
||||
strategicGoals: b.strategicGoals.map((g) => text(g, 1000)),
|
||||
plannedArticlesCount: b.plannedArticlesCount,
|
||||
plannedRefreshesCount: b.plannedRefreshesCount,
|
||||
plannedCatalogEnrichments: b.plannedCatalogEnrichments,
|
||||
isActive: b.isActive ?? false,
|
||||
createdBy: actor,
|
||||
};
|
||||
return this.operation(actor, 'roadmap', key, b, async (tx) => {
|
||||
const research = await tx.corporateResearch.findUnique({
|
||||
where: { id: data.researchId },
|
||||
include: { sources: true },
|
||||
});
|
||||
if (!research || !research.sources.length)
|
||||
throw new ConflictException('Evidence-backed research required');
|
||||
const result = await tx.corporateRoadmap.create({
|
||||
data: { ...data, goals: { create: goals } },
|
||||
include: { goals: true },
|
||||
});
|
||||
await tx.corporateResearch.update({
|
||||
where: { id: research.id },
|
||||
data: { status: 'IN_BACKLOG' },
|
||||
});
|
||||
return result;
|
||||
});
|
||||
}
|
||||
effect(actor: string, key: string, id: string, input: unknown) {
|
||||
const b = object(input, [
|
||||
'metric',
|
||||
'availability',
|
||||
'baseline',
|
||||
'observed',
|
||||
'source',
|
||||
'observedAt',
|
||||
]);
|
||||
const availability = choice(b.availability, [
|
||||
'MEASURED',
|
||||
'UNAVAILABLE',
|
||||
'UNINSTRUMENTED',
|
||||
'BUSINESS_DISABLED',
|
||||
]);
|
||||
for (const k of ['baseline', 'observed'])
|
||||
if (
|
||||
b[k] !== undefined &&
|
||||
b[k] !== null &&
|
||||
(typeof b[k] !== 'number' || !Number.isFinite(b[k]))
|
||||
)
|
||||
throw new BadRequestException('Invalid metric');
|
||||
if (availability === 'MEASURED' && typeof b.observed !== 'number')
|
||||
throw new BadRequestException('Measured value required');
|
||||
if (
|
||||
availability !== 'MEASURED' &&
|
||||
(b.observed != null || b.baseline != null)
|
||||
)
|
||||
throw new BadRequestException('Unavailable is not zero');
|
||||
const observedAt = new Date(b.observedAt);
|
||||
if (
|
||||
!Number.isFinite(observedAt.getTime()) ||
|
||||
observedAt.getTime() > Date.now()
|
||||
)
|
||||
throw new BadRequestException('Invalid observation time');
|
||||
return this.operation(actor, 'effect:' + id, key, b, async (tx) => {
|
||||
const task = await this.lock(tx, id);
|
||||
if (task.status !== 'DONE')
|
||||
throw new ConflictException('Effects require completed QA');
|
||||
const e = await tx.corporateEffect.create({
|
||||
data: {
|
||||
taskId: id,
|
||||
metric: text(b.metric, 300),
|
||||
availability,
|
||||
baseline: b.baseline,
|
||||
observed: b.observed,
|
||||
source: text(b.source, 2000),
|
||||
observedAt,
|
||||
recordedBy: actor,
|
||||
},
|
||||
});
|
||||
await this.event(tx, id, actor, 'EFFECT_RECORDED', e.metric, 'SYSTEM', {
|
||||
effectId: e.id,
|
||||
});
|
||||
return e;
|
||||
});
|
||||
}
|
||||
report(actor: string, key: string, input: unknown) {
|
||||
const b = object(input, ['day', 'summary']);
|
||||
const day = text(b.day, 10),
|
||||
summary = text(b.summary);
|
||||
if (
|
||||
!/^\d{4}-\d{2}-\d{2}$/.test(day) ||
|
||||
!Number.isFinite(Date.parse(day + 'T00:00:00Z'))
|
||||
)
|
||||
throw new BadRequestException('ISO day required');
|
||||
return this.operation(actor, 'report', key, b, async (tx) => {
|
||||
const start = new Date(day + 'T00:00:00Z'),
|
||||
end = new Date(start.getTime() + 86400000);
|
||||
const tasks = await tx.corporateTask.findMany({
|
||||
where: { updatedAt: { gte: start, lt: end } },
|
||||
select: {
|
||||
id: true,
|
||||
taskCode: true,
|
||||
title: true,
|
||||
status: true,
|
||||
department: true,
|
||||
updatedAt: true,
|
||||
},
|
||||
});
|
||||
const events = await tx.corporateEvent.findMany({
|
||||
where: { timestamp: { gte: start, lt: end } },
|
||||
orderBy: { timestamp: 'asc' },
|
||||
});
|
||||
const effects = await tx.corporateEffect.findMany({
|
||||
where: { createdAt: { gte: start, lt: end } },
|
||||
});
|
||||
const snapshot = JSON.parse(
|
||||
JSON.stringify({ timezone: 'UTC', tasks, events, effects }),
|
||||
);
|
||||
return tx.corporateReport.create({
|
||||
data: { day, summary, snapshot, createdBy: actor },
|
||||
});
|
||||
});
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user