10899571717

Committed 17 Sep 2024 08:42AM UTC coverage: 74.24% (-0.3%) from 74.513%

Build # 10899571717

Build Type

push

github

Committed by

web-flow

Commit Message

feat: integrating error reporting protocol  (#289)

Signed-off-by: Francisco Javier Ribo Labrador <elribonazo@gmail.com>

Run Details

1508 of 2244 branches covered (67.2%)

Branch coverage included in aggregate %.

7 of 22 new or added lines in 4 files covered. (31.82%)

1 existing line in 1 file now uncovered.

3325 of 4266 relevant lines covered (77.94%)

27.86 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

56.89

/src/edge-agent/helpers/ProtocolHelpers.ts

/* eslint-disable @typescript-eslint/no-explicit-any */
import { AttachmentDescriptor, Message } from "../../domain";
import { AgentError } from "../../domain/models/Errors";
import { asArray, isArray, isEmpty, isNil, isObject, isString, notEmptyString, notNil } from "../../utils";
import { ProtocolType } from "../protocols/ProtocolTypes";
import { CredentialFormat } from "../protocols/issueCredential/CredentialFormat";
import {
  ProposeCredentialBody,
  OfferCredentialBody,
  IssueCredentialBody,
  CredentialBody,
  MediationGrantBody,
  PresentationBody,
  RequestPresentationBody,
  ProposePresentationBody,
  BasicMessageBody,
  ProblemReportBody,
} from "../protocols/types";

export const parseCredentialAttachments = (credentials: Map<string, any>) => {
  const initialValue = {
    formats: [] as CredentialFormat[],
    attachments: [] as AttachmentDescriptor[],
  };
  const credentialsArray = Array.from(credentials);

  return credentialsArray.reduce((acc, [key, credential]) => {
    const attachment = AttachmentDescriptor.build(credential);
    const format: CredentialFormat = {
      attach_id: attachment.id,
      format: key,
    };

    return {
      formats: [...acc.formats, format],
      attachments: [...acc.attachments, attachment],
    };
  },
    initialValue
  );
};

const parseCredentialFormat = (value: unknown): CredentialFormat => {
  if (!isObject(value) || isNil(value.attach_id) || isNil(value.format)) {
    throw new AgentError.InvalidCredentialFormats();
  }

  return {
    attach_id: value.attach_id,
    format: value.format,
  };
};

export const parseBasicMessageBody = (msg: Message): BasicMessageBody => {
  if (notEmptyString(msg.body.content)) {
    return {
      content: msg.body.content,
    };
  }

  throw new AgentError.InvalidBasicMessageBodyError("Invalid content");
};

export const parseProblemReportBody = (msg: Message): ProblemReportBody => {
  if (notEmptyString(msg.body.code) &&
    notEmptyString(msg.body.comment) &&
    notEmptyString(msg.body.escalate_to) &&
    isArray(msg.body.args) && isEmpty(msg.body.args)
  ) {
    const { code, comment, escalate_to, args } = msg.body;
    return { code, comment, escalate_to, args }
  }
  throw new AgentError.InvalidProblemReportBodyError()
}

export const parseCredentialBody = (msg: Message): CredentialBody => {
  if (Object.keys(msg.body).length === 0) {
    throw new AgentError.InvalidCredentialBodyError(
      "Invalid CredentialBody Error"
    );
  }

  if (notNil(msg.body.formats) && !isArray(msg.body.formats)) {
    throw new AgentError.InvalidCredentialFormats();
  }

  return {
    formats: asArray(msg.body.formats).map(x => parseCredentialFormat(x)),
    goalCode: msg.body.goalCode,
    comment: msg.body.comment,
  };
};

export const parseOfferCredentialMessage = (msg: Message): OfferCredentialBody => {
  if (msg.piuri !== ProtocolType.DidcommOfferCredential) {
    throw new AgentError.UnknownCredentialBodyError();
  }

  if (isNil(msg.body.credential_preview)) {
    throw new AgentError.InvalidOfferCredentialBodyError("Undefined credentialPreview");
  }

  const credentialBody = parseCredentialBody(msg);

  return {
    ...credentialBody,
    credential_preview: msg.body.credential_preview,
    replacementId: msg.body.replacementId,
    multipleAvailable: msg.body.multipleAvailable,
  };
};

export const parseIssueCredentialMessage = (msg: Message): IssueCredentialBody => {
  if (msg.piuri !== ProtocolType.DidcommIssueCredential) {
    throw new AgentError.UnknownCredentialBodyError();
  }

  if (notNil(msg.body.replacementId) && !isString(msg.body.replacementId)) {
    throw new AgentError.InvalidIssueCredentialBodyError(
      "Invalid replacementId, should be a string"
    );
  }

  const credentialBody = parseCredentialBody(msg);

  return {
    ...credentialBody,
    replacementId: msg.body.replacementId,
    moreAvailable: msg.body.moreAvailable,
  };
};

export const parseProposeCredentialMessage = (msg: Message): ProposeCredentialBody => {
  if (isNil(msg.body.credential_preview)) {
    throw new AgentError.InvalidProposeCredentialBodyError(
      "Undefined credentialPreview"
    );
  }

  const credentialBody = parseCredentialBody(msg);

  return {
    ...credentialBody,
    credential_preview: msg.body.credential_preview,
  };
};

export const parseMediationGrantMessage = (msg: Message): MediationGrantBody => {
  if (isNil(msg.body.routing_did)) {
    throw new AgentError.InvalidMediationGrantBodyError(
      "Undefined routingDid"
    );
  }

  return {
    routing_did: msg.body.routing_did,
  };
};

export const parsePresentationMessage = (msg: Message): PresentationBody => {
  if (notNil(msg.body.goalCode) && !isString(msg.body.goalCode)) {
    throw new AgentError.InvalidPresentationBodyError("Invalid goalCode");
  }
  if (notNil(msg.body.comment) && !isString(msg.body.comment)) {
    throw new AgentError.InvalidPresentationBodyError("Invalid comment");
  }
  return {
    comment: msg.body.comment,
    goalCode: msg.body.goalCode,
  };
};

const parseSomePresentationMessage = (msg: Message): RequestPresentationBody | ProposePresentationBody => {
  if (notNil(msg.body.goalCode) && !isString(msg.body.goalCode)) {
    throw new Error("Invalid goalCode");
  }

  if (notNil(msg.body.comment) && !isString(msg.body.comment)) {
    throw new Error("Invalid comment");
  }

  if (notNil(msg.body.willConfirm) && typeof msg.body.willConfirm !== "boolean") {
    throw new Error("Invalid willConfirm");
  }

  if (notNil(msg.body.proofTypes)) {
    const invalidProofType = !isArray(msg.body.proofTypes) || msg.body.proofTypes.some((x: any) => {
      if (notNil(x.schema) && !isString(x.schema)) {
        return true;
      }

      if (notNil(x.requiredFields) && (
        !isArray(x.requiredFields) ||
        x.requiredFields.some((f: any) => !isString(f))
      )) {
        return true;
      }

      if (notNil(x.trustIssuers) && (
        !isArray(x.trustIssuers) ||
        x.trustIssuers.some((f: any) => !isString(f)))
      ) {
        return true;
      }

      return false;
    });

    if (invalidProofType) {
      throw new Error("Invalid proofTypes");
    }
  }

  return {
    comment: msg.body.comment,
    goalCode: msg.body.goalCode,
    proofTypes: msg.body.proofTypes,
    willConfirm: notNil(msg.body.willConfirm) ? msg.body.willConfirm : false,
  };
};

export const parseProposePresentationMessage = (msg: Message): ProposePresentationBody => {
  try {
    return parseSomePresentationMessage(msg);
  }
  catch (e) {
    const err = e instanceof Error ? e.message : "Invalid propose presentation message";
    throw new AgentError.InvalidProposePresentationBodyError(err);
  }
};

export const parseRequestPresentationMessage = (msg: Message): RequestPresentationBody => {
  try {
    return parseSomePresentationMessage(msg);
  }
  catch (e) {
    const err = e instanceof Error ? e.message : "Invalid request presentation message";
    throw new AgentError.InvalidPresentationBodyError(err);
  }
};

1	/* eslint-disable @typescript-eslint/no-explicit-any */
2	import { AttachmentDescriptor, Message } from "../../domain";
3	import { AgentError } from "../../domain/models/Errors";
4	import { asArray, isArray, isEmpty, isNil, isObject, isString, notEmptyString, notNil } from "../../utils";
5	import { ProtocolType } from "../protocols/ProtocolTypes";
6	import { CredentialFormat } from "../protocols/issueCredential/CredentialFormat";
7	import {
8	ProposeCredentialBody,
9	OfferCredentialBody,
10	IssueCredentialBody,
11	CredentialBody,
12	MediationGrantBody,
13	PresentationBody,
14	RequestPresentationBody,
15	ProposePresentationBody,
16	BasicMessageBody,
17	ProblemReportBody,
18	} from "../protocols/types";
19
20	export const parseCredentialAttachments = (credentials: Map<string, any>) => {	27✔
21	const initialValue = {	3✔
22	formats: [] as CredentialFormat[],
23	attachments: [] as AttachmentDescriptor[],
24	};
25	const credentialsArray = Array.from(credentials);	3✔
26
27	return credentialsArray.reduce((acc, [key, credential]) => {	3✔
28	const attachment = AttachmentDescriptor.build(credential);	1✔
29	const format: CredentialFormat = {	1✔
30	attach_id: attachment.id,
31	format: key,
32	};
33
34	return {	1✔
35	formats: [...acc.formats, format],
36	attachments: [...acc.attachments, attachment],
37	};
38	},
39	initialValue
40	);
41	};
42
43	const parseCredentialFormat = (value: unknown): CredentialFormat => {	27✔
44	if (!isObject(value) \|\| isNil(value.attach_id) \|\| isNil(value.format)) {	7✔
45	throw new AgentError.InvalidCredentialFormats();	1✔
46	}
47
48	return {	6✔
49	attach_id: value.attach_id,
50	format: value.format,
51	};
52	};
53
54	export const parseBasicMessageBody = (msg: Message): BasicMessageBody => {	27✔
55	if (notEmptyString(msg.body.content)) {	×
56	return {	×
57	content: msg.body.content,
58	};
59	}
60
61	throw new AgentError.InvalidBasicMessageBodyError("Invalid content");	×
62	};
63
64	export const parseProblemReportBody = (msg: Message): ProblemReportBody => {	27✔
NEW 65	if (notEmptyString(msg.body.code) &&	×
66	notEmptyString(msg.body.comment) &&
67	notEmptyString(msg.body.escalate_to) &&
68	isArray(msg.body.args) && isEmpty(msg.body.args)
69	) {
NEW 70	const { code, comment, escalate_to, args } = msg.body;	×
NEW 71	return { code, comment, escalate_to, args }	×
72	}
NEW 73	throw new AgentError.InvalidProblemReportBodyError()	×
74	}
75
76	export const parseCredentialBody = (msg: Message): CredentialBody => {	27✔
77	if (Object.keys(msg.body).length === 0) {	9!
78	throw new AgentError.InvalidCredentialBodyError(	×
79	"Invalid CredentialBody Error"
80	);
81	}
82
83	if (notNil(msg.body.formats) && !isArray(msg.body.formats)) {	9!
84	throw new AgentError.InvalidCredentialFormats();	×
85	}
86
87	return {	9✔
88	formats: asArray(msg.body.formats).map(x => parseCredentialFormat(x)),	7✔
89	goalCode: msg.body.goalCode,
90	comment: msg.body.comment,
91	};
92	};
93
94	export const parseOfferCredentialMessage = (msg: Message): OfferCredentialBody => {	27✔
95	if (msg.piuri !== ProtocolType.DidcommOfferCredential) {	2!
96	throw new AgentError.UnknownCredentialBodyError();	×
97	}
98
99	if (isNil(msg.body.credential_preview)) {	2!
100	throw new AgentError.InvalidOfferCredentialBodyError("Undefined credentialPreview");	×
101	}
102
103	const credentialBody = parseCredentialBody(msg);	2✔
104
105	return {	2✔
106	...credentialBody,
107	credential_preview: msg.body.credential_preview,
108	replacementId: msg.body.replacementId,
109	multipleAvailable: msg.body.multipleAvailable,
110	};
111	};
112
113	export const parseIssueCredentialMessage = (msg: Message): IssueCredentialBody => {	27✔
114	if (msg.piuri !== ProtocolType.DidcommIssueCredential) {	4!
115	throw new AgentError.UnknownCredentialBodyError();	×
116	}
117
118	if (notNil(msg.body.replacementId) && !isString(msg.body.replacementId)) {	4!
119	throw new AgentError.InvalidIssueCredentialBodyError(	×
120	"Invalid replacementId, should be a string"
121	);
122	}
123
124	const credentialBody = parseCredentialBody(msg);	4✔
125
126	return {	3✔
127	...credentialBody,
128	replacementId: msg.body.replacementId,
129	moreAvailable: msg.body.moreAvailable,
130	};
131	};
132
133	export const parseProposeCredentialMessage = (msg: Message): ProposeCredentialBody => {	27✔
134	if (isNil(msg.body.credential_preview)) {	1!
135	throw new AgentError.InvalidProposeCredentialBodyError(	×
136	"Undefined credentialPreview"
137	);
138	}
139
140	const credentialBody = parseCredentialBody(msg);	1✔
141
142	return {	1✔
143	...credentialBody,
144	credential_preview: msg.body.credential_preview,
145	};
146	};
147
148	export const parseMediationGrantMessage = (msg: Message): MediationGrantBody => {	27✔
149	if (isNil(msg.body.routing_did)) {	×
150	throw new AgentError.InvalidMediationGrantBodyError(	×
151	"Undefined routingDid"
152	);
153	}
154
155	return {	×
156	routing_did: msg.body.routing_did,
157	};
158	};
159
160	export const parsePresentationMessage = (msg: Message): PresentationBody => {	27✔
161	if (notNil(msg.body.goalCode) && !isString(msg.body.goalCode)) {	2!
162	throw new AgentError.InvalidPresentationBodyError("Invalid goalCode");	×
163	}
164	if (notNil(msg.body.comment) && !isString(msg.body.comment)) {	2!
165	throw new AgentError.InvalidPresentationBodyError("Invalid comment");	×
166	}
167	return {	2✔
168	comment: msg.body.comment,
169	goalCode: msg.body.goalCode,
170	};
171	};
172
173	const parseSomePresentationMessage = (msg: Message): RequestPresentationBody \| ProposePresentationBody => {	27✔
174	if (notNil(msg.body.goalCode) && !isString(msg.body.goalCode)) {	7!
175	throw new Error("Invalid goalCode");	×
176	}
177
178	if (notNil(msg.body.comment) && !isString(msg.body.comment)) {	7!
179	throw new Error("Invalid comment");	×
180	}
181
182	if (notNil(msg.body.willConfirm) && typeof msg.body.willConfirm !== "boolean") {	7!
183	throw new Error("Invalid willConfirm");	×
184	}
185
186	if (notNil(msg.body.proofTypes)) {	7✔
187	const invalidProofType = !isArray(msg.body.proofTypes) \|\| msg.body.proofTypes.some((x: any) => {	6✔
188	if (notNil(x.schema) && !isString(x.schema)) {	6!
189	return true;	×
190	}
191
192	if (notNil(x.requiredFields) && (	6!
193	!isArray(x.requiredFields) \|\|
194	x.requiredFields.some((f: any) => !isString(f))	×
195	)) {
196	return true;	×
197	}
198
199	if (notNil(x.trustIssuers) && (	6!
200	!isArray(x.trustIssuers) \|\|
201	x.trustIssuers.some((f: any) => !isString(f)))	×
202	) {
203	return true;	×
204	}
205
206	return false;	6✔
207	});
208
209	if (invalidProofType) {	6!
210	throw new Error("Invalid proofTypes");	×
211	}
212	}
213
214	return {	7✔
215	comment: msg.body.comment,
216	goalCode: msg.body.goalCode,
217	proofTypes: msg.body.proofTypes,
218	willConfirm: notNil(msg.body.willConfirm) ? msg.body.willConfirm : false,	7✔
219	};
220	};
221
222	export const parseProposePresentationMessage = (msg: Message): ProposePresentationBody => {	27✔
223	try {	3✔
224	return parseSomePresentationMessage(msg);	3✔
225	}
226	catch (e) {
227	const err = e instanceof Error ? e.message : "Invalid propose presentation message";	×
228	throw new AgentError.InvalidProposePresentationBodyError(err);	×
229	}
230	};
231
232	export const parseRequestPresentationMessage = (msg: Message): RequestPresentationBody => {	27✔
233	try {	4✔
234	return parseSomePresentationMessage(msg);	4✔
235	}
236	catch (e) {
237	const err = e instanceof Error ? e.message : "Invalid request presentation message";	×
238	throw new AgentError.InvalidPresentationBodyError(err);	×
239	}
240	};

hyperledger / identus-edge-agent-sdk-ts / 10899571717

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous