414 lines
12 KiB
JavaScript
414 lines
12 KiB
JavaScript
import pkg from '@jlinc/core';
|
|
const { JlincEvent, JlincAudit } = pkg;
|
|
import { getPool } from "../../../db/index.js";
|
|
import { entity } from "./entity.js";
|
|
import { putQueue } from "../../../common/queue.js";
|
|
import { cacheAgreementMarkdown } from "../../../util/cacheAgreement.js";
|
|
|
|
async function getEvent(client, userId, id, includeData, meta) {
|
|
const dataSql = includeData
|
|
? `
|
|
'data', (
|
|
SELECT ed.data
|
|
FROM event_data ed
|
|
WHERE ed.event_id = e.id
|
|
),
|
|
`
|
|
: ``;
|
|
let fields = [userId];
|
|
let count = fields.length + 1;
|
|
let whereAnd = ``
|
|
if (id) {
|
|
whereAnd += ` AND e.event_id_uuid = $${count++}`;
|
|
fields.push(id);
|
|
}
|
|
if (meta) {
|
|
let whereInVals = ``
|
|
for await (const [key, value] of Object.entries(meta)) {
|
|
if (whereInVals != ``)
|
|
whereInVals = ` AND `
|
|
whereInVals += `(em.key = $${count++} AND em.value = $${count++})`;
|
|
fields.push(key);
|
|
fields.push(value);
|
|
}
|
|
whereAnd += `
|
|
AND e.id IN (
|
|
SELECT em.event_id
|
|
FROM event_meta em
|
|
WHERE em.user_id = $1
|
|
AND ${whereInVals}
|
|
)
|
|
`
|
|
}
|
|
const sql = `
|
|
SELECT
|
|
JSON_BUILD_OBJECT(
|
|
'version', e.version,
|
|
'eventId', e.event_id_uuid,
|
|
'type', (
|
|
SELECT et.value
|
|
FROM event_type et
|
|
WHERE et.id = e.event_type_id
|
|
),
|
|
'senderId', e.sender_id,
|
|
'recipientId', e.recipient_id,
|
|
'created', e.created,
|
|
'agreementId', COALESCE((
|
|
SELECT a.agreement_id_uuid
|
|
FROM agreement a
|
|
WHERE a.id = e.agreement_id
|
|
AND a.user_id = $1
|
|
), '00000000-0000-0000-0000-000000000000'),
|
|
${dataSql}
|
|
'created', e.created
|
|
) AS record
|
|
FROM event e
|
|
WHERE e.user_id = $1
|
|
${whereAnd};
|
|
`
|
|
const res = await client.query(sql, fields);
|
|
if (res.rows.length > 0 && res.rows[0].record) {
|
|
const ret = res.rows[0].record;
|
|
if (ret.data) {
|
|
try {
|
|
ret.data = JSON.parse(ret.data);
|
|
} catch(e) {
|
|
// ignore
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
async function getSignatures(client, userId, id) {
|
|
const sql = `
|
|
SELECT
|
|
JSON_AGG(
|
|
JSON_BUILD_OBJECT(
|
|
'version', s.version,
|
|
'id', s.signer_id,
|
|
'signedOn', s.signed_on,
|
|
'type', s.type,
|
|
'jws', s.jws
|
|
)
|
|
) AS records
|
|
FROM signature s
|
|
INNER JOIN event e ON s.event_id = e.id
|
|
WHERE e.event_id_uuid = $1
|
|
AND e.user_id = $2;
|
|
`
|
|
const res = await client.query(sql, [
|
|
id,
|
|
userId,
|
|
]);
|
|
if (res.rows.length > 0 && res.rows[0].records) {
|
|
return res.rows[0].records;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
async function get(input, userId) {
|
|
let response = {
|
|
success: false,
|
|
error: 'Unknown error',
|
|
};
|
|
const client = await getPool();
|
|
try {
|
|
const existingEvent = await getEvent(client, userId, input.eventId, true, input.meta)
|
|
if (!existingEvent) {
|
|
response.error = 'event not found'
|
|
} else {
|
|
const data = {
|
|
event: existingEvent
|
|
}
|
|
if (input.includeSignatures) {
|
|
data.signatures = await getSignatures(client, userId, input.eventId)
|
|
}
|
|
response = {
|
|
message: `retrieved: ${existingEvent.eventId}`,
|
|
data,
|
|
}
|
|
}
|
|
} catch(e) {
|
|
console.error(e)
|
|
} finally {
|
|
await client.release();
|
|
}
|
|
return response;
|
|
}
|
|
|
|
async function save(client, userId, event, meta) {
|
|
await client.query(`BEGIN`);
|
|
const res = await client.query(`
|
|
INSERT INTO event (
|
|
user_id,
|
|
version,
|
|
event_id_uuid,
|
|
event_type_id,
|
|
agreement_id,
|
|
sender_id,
|
|
recipient_id,
|
|
created,
|
|
created_as_ts
|
|
) VALUES (
|
|
$1,
|
|
$2,
|
|
$3,
|
|
(
|
|
SELECT id
|
|
FROM event_type
|
|
WHERE value = $4
|
|
),
|
|
(
|
|
SELECT id
|
|
FROM agreement
|
|
WHERE agreement_id_uuid = $5
|
|
),
|
|
$6,
|
|
$7,
|
|
$8,
|
|
$9
|
|
) RETURNING id;
|
|
`, [
|
|
userId,
|
|
event.version,
|
|
event.eventId,
|
|
event.type,
|
|
event.agreementId,
|
|
event.senderId,
|
|
event.recipientId,
|
|
event.created,
|
|
new Date(event.created).toISOString(),
|
|
]);
|
|
await client.query(`
|
|
INSERT INTO event_data (
|
|
user_id,
|
|
event_id,
|
|
data
|
|
) VALUES (
|
|
$1,
|
|
$2,
|
|
$3
|
|
);
|
|
`, [
|
|
userId,
|
|
res.rows[0].id,
|
|
event.data,
|
|
]);
|
|
if (meta) {
|
|
for await (const [key, value] of Object.entries(meta)) {
|
|
await client.query(`
|
|
INSERT INTO event_meta (
|
|
user_id,
|
|
event_id,
|
|
key,
|
|
value
|
|
) VALUES (
|
|
$1,
|
|
$2,
|
|
$3,
|
|
$4
|
|
);
|
|
`, [
|
|
userId,
|
|
res.rows[0].id,
|
|
key,
|
|
value,
|
|
]);
|
|
}
|
|
}
|
|
await client.query('COMMIT');
|
|
}
|
|
|
|
async function saveSignatures(client, userId, eventId, signatures) {
|
|
await client.query(`BEGIN`);
|
|
for (const signature of signatures) {
|
|
await client.query(`
|
|
INSERT INTO signature (
|
|
user_id,
|
|
version,
|
|
signer_id,
|
|
signed_on,
|
|
type,
|
|
jws,
|
|
role_id,
|
|
agreement_id,
|
|
event_id,
|
|
signed_on_as_ts
|
|
) VALUES (
|
|
$1,
|
|
$2,
|
|
$3,
|
|
$4,
|
|
$5,
|
|
$6,
|
|
(
|
|
SELECT id
|
|
FROM role
|
|
WHERE value = $7
|
|
AND user_id = $1
|
|
),
|
|
$8,
|
|
(
|
|
SELECT id
|
|
FROM event
|
|
WHERE event_id_uuid = $9
|
|
AND user_id = $1
|
|
),
|
|
$10
|
|
) ON CONFLICT DO NOTHING;
|
|
`, [
|
|
userId,
|
|
signature.version,
|
|
signature.id,
|
|
signature.signedOn,
|
|
signature.type,
|
|
signature.jws,
|
|
signature.role,
|
|
null,
|
|
eventId,
|
|
new Date(signature.signedOn).toISOString(),
|
|
]);
|
|
}
|
|
await client.query('COMMIT');
|
|
}
|
|
|
|
async function create(input, userId, _client, _sender) {
|
|
let response = {
|
|
success: false,
|
|
error: 'Unknown error',
|
|
};
|
|
const client = _client || await getPool();
|
|
try {
|
|
input.senderId = _sender ? _sender.didDoc.id : (await entity.getEntity(client, userId, input.senderShortName)).didDoc.id
|
|
input.recipientId = (await entity.getEntity(client, userId, input.recipientShortName)).didDoc.id
|
|
delete input.senderShortName
|
|
delete input.recipientShortName
|
|
const event = await JlincEvent.create(input);
|
|
await save(client, userId, event, input.meta);
|
|
// Pull down any referenced agreement content now (request refs are URIs,
|
|
// permission refs are { reference, permitted }), so a get never has to.
|
|
for (const ref of (event.references || [])) {
|
|
const uri = typeof ref === "string" ? ref : ref?.reference;
|
|
await cacheAgreementMarkdown({ userId, agreementUuid: event.agreementId, uri }, client);
|
|
}
|
|
response = {
|
|
message: `created and saved: ${event.eventId}`,
|
|
data: event,
|
|
}
|
|
} catch(e) {
|
|
console.error(e)
|
|
} finally {
|
|
if (!_client)
|
|
await client.release();
|
|
}
|
|
return response;
|
|
}
|
|
|
|
async function process(input, userId, _client, _event, _sender, meta) {
|
|
let response = {
|
|
success: false,
|
|
error: 'Unknown error',
|
|
};
|
|
const client = _client || await getPool();
|
|
try {
|
|
const existingEvent = _event || await getEvent(client, userId, input.eventId, true)
|
|
if (!existingEvent) {
|
|
throw new Error('event does not exist')
|
|
}
|
|
const inputEntity = _sender || input.shortName ? await entity.getEntity(client, userId, input.shortName) : null;
|
|
const didDoc = inputEntity ? inputEntity.didDoc : input.didDoc;
|
|
const signingKey = inputEntity ? inputEntity.controlPrivateKeyB64U : input.signingKey;
|
|
const signingPublicKey = inputEntity ? inputEntity.didDoc.verificationMethod[0].key : input.signingPublicKey;
|
|
const signingInput = {
|
|
event: existingEvent,
|
|
didDoc,
|
|
signingKey,
|
|
signingPublicKey,
|
|
}
|
|
const eventData = await JlincEvent.sign(signingInput);
|
|
await saveSignatures(client, userId, existingEvent.eventId, eventData.signatures);
|
|
const audit = await JlincAudit.create(eventData);
|
|
const auditInput = {
|
|
audit,
|
|
didDoc,
|
|
signingKey,
|
|
signingPublicKey,
|
|
}
|
|
const auditData = await JlincAudit.sign(auditInput);
|
|
response = {
|
|
message: `signed and saved: ${eventData?.event?.eventId}`,
|
|
data: {
|
|
auditData,
|
|
},
|
|
}
|
|
if (input.archive) {
|
|
if (meta) {
|
|
response.data.auditData.meta = meta;
|
|
}
|
|
await putQueue(
|
|
client,
|
|
'audit',
|
|
`${input.archive.url}/api/v1/audit/put`,
|
|
{
|
|
'Authorization': `Bearer ${input.archive.key}`,
|
|
},
|
|
response.data.auditData,
|
|
)
|
|
}
|
|
} catch(e) {
|
|
console.error(e)
|
|
} finally {
|
|
if (!_client)
|
|
await client.release();
|
|
}
|
|
return response;
|
|
}
|
|
|
|
async function produce(input, userId) {
|
|
let response = {
|
|
success: false,
|
|
error: 'Unknown error',
|
|
};
|
|
const client = await getPool();
|
|
try {
|
|
const shortName = input.senderShortName;
|
|
const sender = (await entity.getEntity(client, userId, input.senderShortName))
|
|
const created = (await create(input, userId, client, sender)).data;
|
|
const processed = (await process(
|
|
{
|
|
eventId: created.eventId,
|
|
shortName,
|
|
archive: input.archive,
|
|
},
|
|
userId,
|
|
client,
|
|
created,
|
|
sender,
|
|
input.meta,
|
|
)).data;
|
|
response = {
|
|
message: `created and processed: ${created.eventId}`,
|
|
data: {
|
|
created,
|
|
processed,
|
|
},
|
|
}
|
|
} catch(e) {
|
|
console.error(e)
|
|
} finally {
|
|
await client.release();
|
|
}
|
|
return response;
|
|
}
|
|
|
|
export const event = {
|
|
getEvent,
|
|
getSignatures,
|
|
get,
|
|
create,
|
|
process,
|
|
produce,
|
|
}
|