2019-12-14 17:23:31 +01:00
|
|
|
/*
|
|
|
|
This file is part of GNU Taler
|
|
|
|
(C) 2018-2019 GNUnet e.V.
|
|
|
|
|
|
|
|
GNU Taler is free software; you can redistribute it and/or modify it under the
|
|
|
|
terms of the GNU General Public License as published by the Free Software
|
|
|
|
Foundation; either version 3, or (at your option) any later version.
|
|
|
|
|
|
|
|
GNU Taler is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
|
|
|
|
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License along with
|
|
|
|
GNU Taler; see the file COPYING. If not, see <http://www.gnu.org/licenses/>
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Type-safe codecs for converting from/to JSON.
|
|
|
|
*/
|
|
|
|
|
2020-08-03 09:30:48 +02:00
|
|
|
/* eslint-disable @typescript-eslint/ban-types */
|
2020-07-23 14:05:17 +02:00
|
|
|
|
2019-12-14 17:23:31 +01:00
|
|
|
/**
|
|
|
|
* Error thrown when decoding fails.
|
|
|
|
*/
|
|
|
|
export class DecodingError extends Error {
|
|
|
|
constructor(message: string) {
|
|
|
|
super(message);
|
|
|
|
Object.setPrototypeOf(this, DecodingError.prototype);
|
|
|
|
this.name = "DecodingError";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Context information to show nicer error messages when decoding fails.
|
|
|
|
*/
|
2019-12-19 20:42:49 +01:00
|
|
|
export interface Context {
|
2019-12-14 17:23:31 +01:00
|
|
|
readonly path?: string[];
|
|
|
|
}
|
|
|
|
|
2019-12-19 20:42:49 +01:00
|
|
|
export function renderContext(c?: Context): string {
|
2019-12-14 17:23:31 +01:00
|
|
|
const p = c?.path;
|
|
|
|
if (p) {
|
|
|
|
return p.join(".");
|
|
|
|
} else {
|
|
|
|
return "(unknown)";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
function joinContext(c: Context | undefined, part: string): Context {
|
|
|
|
const path = c?.path ?? [];
|
|
|
|
return {
|
|
|
|
path: path.concat([part]),
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* A codec converts untyped JSON to a typed object.
|
|
|
|
*/
|
|
|
|
export interface Codec<V> {
|
|
|
|
/**
|
|
|
|
* Decode untyped JSON to an object of type [[V]].
|
|
|
|
*/
|
|
|
|
readonly decode: (x: any, c?: Context) => V;
|
|
|
|
}
|
|
|
|
|
|
|
|
type SingletonRecord<K extends keyof any, V> = { [Y in K]: V };
|
|
|
|
|
|
|
|
interface Prop {
|
|
|
|
name: string;
|
|
|
|
codec: Codec<any>;
|
|
|
|
}
|
|
|
|
|
2019-12-14 17:55:31 +01:00
|
|
|
interface Alternative {
|
|
|
|
tagValue: any;
|
|
|
|
codec: Codec<any>;
|
|
|
|
}
|
|
|
|
|
2019-12-16 12:53:22 +01:00
|
|
|
class ObjectCodecBuilder<OutputType, PartialOutputType> {
|
2019-12-14 17:23:31 +01:00
|
|
|
private propList: Prop[] = [];
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Define a property for the object.
|
|
|
|
*/
|
2019-12-16 12:53:22 +01:00
|
|
|
property<K extends keyof OutputType & string, V extends OutputType[K]>(
|
2019-12-14 17:23:31 +01:00
|
|
|
x: K,
|
|
|
|
codec: Codec<V>,
|
2019-12-16 12:53:22 +01:00
|
|
|
): ObjectCodecBuilder<OutputType, PartialOutputType & SingletonRecord<K, V>> {
|
2019-12-19 20:42:49 +01:00
|
|
|
if (!codec) {
|
|
|
|
throw Error("inner codec must be defined");
|
|
|
|
}
|
2019-12-14 17:23:31 +01:00
|
|
|
this.propList.push({ name: x, codec: codec });
|
|
|
|
return this as any;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return the built codec.
|
|
|
|
*
|
|
|
|
* @param objectDisplayName name of the object that this codec operates on,
|
|
|
|
* used in error messages.
|
|
|
|
*/
|
2019-12-16 12:53:22 +01:00
|
|
|
build(objectDisplayName: string): Codec<PartialOutputType> {
|
2019-12-14 17:23:31 +01:00
|
|
|
const propList = this.propList;
|
|
|
|
return {
|
2019-12-16 12:53:22 +01:00
|
|
|
decode(x: any, c?: Context): PartialOutputType {
|
2019-12-14 17:23:31 +01:00
|
|
|
if (!c) {
|
|
|
|
c = {
|
|
|
|
path: [`(${objectDisplayName})`],
|
|
|
|
};
|
|
|
|
}
|
2019-12-25 19:24:23 +01:00
|
|
|
if (typeof x !== "object") {
|
|
|
|
throw new DecodingError(
|
|
|
|
`expected object for ${objectDisplayName} at ${renderContext(
|
|
|
|
c,
|
2020-03-30 12:39:32 +02:00
|
|
|
)} but got ${typeof x}`,
|
|
|
|
);
|
2019-12-25 19:24:23 +01:00
|
|
|
}
|
2019-12-14 17:23:31 +01:00
|
|
|
const obj: any = {};
|
|
|
|
for (const prop of propList) {
|
|
|
|
const propRawVal = x[prop.name];
|
|
|
|
const propVal = prop.codec.decode(
|
|
|
|
propRawVal,
|
|
|
|
joinContext(c, prop.name),
|
|
|
|
);
|
|
|
|
obj[prop.name] = propVal;
|
|
|
|
}
|
2019-12-16 12:53:22 +01:00
|
|
|
return obj as PartialOutputType;
|
2019-12-14 17:23:31 +01:00
|
|
|
},
|
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-12-16 12:53:22 +01:00
|
|
|
class UnionCodecBuilder<
|
|
|
|
TargetType,
|
|
|
|
TagPropertyLabel extends keyof TargetType,
|
|
|
|
CommonBaseType,
|
|
|
|
PartialTargetType
|
|
|
|
> {
|
2019-12-14 17:55:31 +01:00
|
|
|
private alternatives = new Map<any, Alternative>();
|
|
|
|
|
2019-12-16 12:53:22 +01:00
|
|
|
constructor(
|
|
|
|
private discriminator: TagPropertyLabel,
|
|
|
|
private baseCodec?: Codec<CommonBaseType>,
|
|
|
|
) {}
|
2019-12-14 17:55:31 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Define a property for the object.
|
|
|
|
*/
|
|
|
|
alternative<V>(
|
2019-12-16 12:53:22 +01:00
|
|
|
tagValue: TargetType[TagPropertyLabel],
|
2019-12-14 17:55:31 +01:00
|
|
|
codec: Codec<V>,
|
2019-12-16 12:53:22 +01:00
|
|
|
): UnionCodecBuilder<
|
|
|
|
TargetType,
|
|
|
|
TagPropertyLabel,
|
|
|
|
CommonBaseType,
|
|
|
|
PartialTargetType | V
|
|
|
|
> {
|
2019-12-19 20:42:49 +01:00
|
|
|
if (!codec) {
|
|
|
|
throw Error("inner codec must be defined");
|
|
|
|
}
|
2019-12-14 17:55:31 +01:00
|
|
|
this.alternatives.set(tagValue, { codec, tagValue });
|
|
|
|
return this as any;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return the built codec.
|
|
|
|
*
|
|
|
|
* @param objectDisplayName name of the object that this codec operates on,
|
|
|
|
* used in error messages.
|
|
|
|
*/
|
2019-12-16 12:53:22 +01:00
|
|
|
build<R extends PartialTargetType & CommonBaseType = never>(
|
|
|
|
objectDisplayName: string,
|
|
|
|
): Codec<R> {
|
2019-12-14 17:55:31 +01:00
|
|
|
const alternatives = this.alternatives;
|
|
|
|
const discriminator = this.discriminator;
|
2019-12-14 19:09:01 +01:00
|
|
|
const baseCodec = this.baseCodec;
|
2019-12-14 17:55:31 +01:00
|
|
|
return {
|
|
|
|
decode(x: any, c?: Context): R {
|
2020-07-27 10:06:32 +02:00
|
|
|
if (!c) {
|
|
|
|
c = {
|
|
|
|
path: [`(${objectDisplayName})`],
|
|
|
|
};
|
|
|
|
}
|
2019-12-14 17:55:31 +01:00
|
|
|
const d = x[discriminator];
|
|
|
|
if (d === undefined) {
|
2019-12-14 19:09:01 +01:00
|
|
|
throw new DecodingError(
|
|
|
|
`expected tag for ${objectDisplayName} at ${renderContext(
|
|
|
|
c,
|
|
|
|
)}.${discriminator}`,
|
|
|
|
);
|
2019-12-14 17:55:31 +01:00
|
|
|
}
|
|
|
|
const alt = alternatives.get(d);
|
|
|
|
if (!alt) {
|
2019-12-14 19:09:01 +01:00
|
|
|
throw new DecodingError(
|
|
|
|
`unknown tag for ${objectDisplayName} ${d} at ${renderContext(
|
|
|
|
c,
|
|
|
|
)}.${discriminator}`,
|
|
|
|
);
|
2019-12-14 17:55:31 +01:00
|
|
|
}
|
2019-12-14 19:09:01 +01:00
|
|
|
const altDecoded = alt.codec.decode(x);
|
|
|
|
if (baseCodec) {
|
|
|
|
const baseDecoded = baseCodec.decode(x, c);
|
|
|
|
return { ...baseDecoded, ...altDecoded };
|
|
|
|
} else {
|
|
|
|
return altDecoded;
|
|
|
|
}
|
|
|
|
},
|
2019-12-14 17:55:31 +01:00
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-12-16 12:53:22 +01:00
|
|
|
export class UnionCodecPreBuilder<T> {
|
|
|
|
discriminateOn<D extends keyof T, B = {}>(
|
|
|
|
discriminator: D,
|
|
|
|
baseCodec?: Codec<B>,
|
|
|
|
): UnionCodecBuilder<T, D, B, never> {
|
|
|
|
return new UnionCodecBuilder<T, D, B, never>(discriminator, baseCodec);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-12-14 17:23:31 +01:00
|
|
|
/**
|
2019-12-16 12:53:22 +01:00
|
|
|
* Return a builder for a codec that decodes an object with properties.
|
2019-12-14 17:23:31 +01:00
|
|
|
*/
|
2020-08-12 12:32:58 +02:00
|
|
|
export function buildCodecForObject<T>(): ObjectCodecBuilder<T, {}> {
|
2019-12-16 12:53:22 +01:00
|
|
|
return new ObjectCodecBuilder<T, {}>();
|
|
|
|
}
|
|
|
|
|
2020-08-12 12:32:58 +02:00
|
|
|
export function buildCodecForUnion<T>(): UnionCodecPreBuilder<T> {
|
2019-12-16 12:53:22 +01:00
|
|
|
return new UnionCodecPreBuilder<T>();
|
|
|
|
}
|
2019-12-14 17:23:31 +01:00
|
|
|
|
2019-12-14 17:55:31 +01:00
|
|
|
/**
|
2019-12-16 12:53:22 +01:00
|
|
|
* Return a codec for a mapping from a string to values described by the inner codec.
|
2019-12-14 17:55:31 +01:00
|
|
|
*/
|
2020-08-12 12:32:58 +02:00
|
|
|
export function codecForMap<T>(
|
2019-12-16 12:53:22 +01:00
|
|
|
innerCodec: Codec<T>,
|
|
|
|
): Codec<{ [x: string]: T }> {
|
2019-12-19 20:42:49 +01:00
|
|
|
if (!innerCodec) {
|
|
|
|
throw Error("inner codec must be defined");
|
|
|
|
}
|
2019-12-14 17:55:31 +01:00
|
|
|
return {
|
2019-12-16 12:53:22 +01:00
|
|
|
decode(x: any, c?: Context): { [x: string]: T } {
|
|
|
|
const map: { [x: string]: T } = {};
|
|
|
|
if (typeof x !== "object") {
|
|
|
|
throw new DecodingError(`expected object at ${renderContext(c)}`);
|
2019-12-14 17:55:31 +01:00
|
|
|
}
|
2019-12-16 12:53:22 +01:00
|
|
|
for (const i in x) {
|
|
|
|
map[i] = innerCodec.decode(x[i], joinContext(c, `[${i}]`));
|
|
|
|
}
|
|
|
|
return map;
|
2019-12-14 19:09:01 +01:00
|
|
|
},
|
|
|
|
};
|
|
|
|
}
|
2019-12-14 17:55:31 +01:00
|
|
|
|
2019-12-14 17:23:31 +01:00
|
|
|
/**
|
|
|
|
* Return a codec for a list, containing values described by the inner codec.
|
|
|
|
*/
|
2020-08-12 12:32:58 +02:00
|
|
|
export function codecForList<T>(innerCodec: Codec<T>): Codec<T[]> {
|
2019-12-19 20:42:49 +01:00
|
|
|
if (!innerCodec) {
|
|
|
|
throw Error("inner codec must be defined");
|
|
|
|
}
|
2019-12-14 17:23:31 +01:00
|
|
|
return {
|
|
|
|
decode(x: any, c?: Context): T[] {
|
|
|
|
const arr: T[] = [];
|
|
|
|
if (!Array.isArray(x)) {
|
|
|
|
throw new DecodingError(`expected array at ${renderContext(c)}`);
|
|
|
|
}
|
|
|
|
for (const i in x) {
|
|
|
|
arr.push(innerCodec.decode(x[i], joinContext(c, `[${i}]`)));
|
|
|
|
}
|
|
|
|
return arr;
|
|
|
|
},
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2019-12-16 12:53:22 +01:00
|
|
|
* Return a codec for a value that must be a number.
|
2019-12-14 17:23:31 +01:00
|
|
|
*/
|
2020-08-12 12:32:58 +02:00
|
|
|
export function codecForNumber(): Codec<number> {
|
|
|
|
return {
|
|
|
|
decode(x: any, c?: Context): number {
|
|
|
|
if (typeof x === "number") {
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
throw new DecodingError(
|
|
|
|
`expected number at ${renderContext(c)} but got ${typeof x}`,
|
|
|
|
);
|
|
|
|
},
|
|
|
|
};
|
|
|
|
}
|
2019-12-19 20:42:49 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Return a codec for a value that must be a number.
|
|
|
|
*/
|
2020-09-01 16:26:08 +02:00
|
|
|
export function codecForBoolean(): Codec<boolean> {
|
|
|
|
return {
|
|
|
|
decode(x: any, c?: Context): boolean {
|
|
|
|
if (typeof x === "boolean") {
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
throw new DecodingError(
|
|
|
|
`expected boolean at ${renderContext(c)} but got ${typeof x}`,
|
|
|
|
);
|
|
|
|
},
|
2020-09-04 08:34:11 +02:00
|
|
|
};
|
|
|
|
}
|
2019-12-14 17:23:31 +01:00
|
|
|
|
2019-12-16 12:53:22 +01:00
|
|
|
/**
|
|
|
|
* Return a codec for a value that must be a string.
|
|
|
|
*/
|
2020-08-12 12:32:58 +02:00
|
|
|
export function codecForString(): Codec<string> {
|
|
|
|
return {
|
|
|
|
decode(x: any, c?: Context): string {
|
|
|
|
if (typeof x === "string") {
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
throw new DecodingError(
|
|
|
|
`expected string at ${renderContext(c)} but got ${typeof x}`,
|
|
|
|
);
|
|
|
|
},
|
|
|
|
};
|
|
|
|
}
|
2019-12-19 20:42:49 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Codec that allows any value.
|
|
|
|
*/
|
2020-08-12 12:32:58 +02:00
|
|
|
export function codecForAny(): Codec<any> {
|
|
|
|
return {
|
|
|
|
decode(x: any, c?: Context): any {
|
|
|
|
return x;
|
|
|
|
},
|
|
|
|
};
|
|
|
|
}
|
2019-12-14 18:00:03 +01:00
|
|
|
|
2019-12-14 17:23:31 +01:00
|
|
|
/**
|
2019-12-16 12:53:22 +01:00
|
|
|
* Return a codec for a value that must be a string.
|
2019-12-14 17:23:31 +01:00
|
|
|
*/
|
2020-08-12 12:32:58 +02:00
|
|
|
export function codecForConstString<V extends string>(s: V): Codec<V> {
|
2019-12-16 12:53:22 +01:00
|
|
|
return {
|
|
|
|
decode(x: any, c?: Context): V {
|
|
|
|
if (x === s) {
|
|
|
|
return x;
|
|
|
|
}
|
2020-11-03 13:46:44 +01:00
|
|
|
if (typeof x !== "string") {
|
|
|
|
throw new DecodingError(
|
|
|
|
`expected string constant "${s}" at ${renderContext(
|
|
|
|
c,
|
|
|
|
)} but got ${typeof x}`,
|
|
|
|
);
|
|
|
|
}
|
2019-12-16 12:53:22 +01:00
|
|
|
throw new DecodingError(
|
2020-03-30 12:39:32 +02:00
|
|
|
`expected string constant "${s}" at ${renderContext(
|
|
|
|
c,
|
2020-11-03 13:46:44 +01:00
|
|
|
)} but got string value "${x}"`,
|
2019-12-16 12:53:22 +01:00
|
|
|
);
|
|
|
|
},
|
|
|
|
};
|
2019-12-14 17:23:31 +01:00
|
|
|
}
|
2019-12-14 17:55:31 +01:00
|
|
|
|
2020-07-23 14:05:17 +02:00
|
|
|
/**
|
|
|
|
* Return a codec for a boolean true constant.
|
|
|
|
*/
|
2020-08-12 12:32:58 +02:00
|
|
|
export function codecForConstTrue(): Codec<true> {
|
2020-07-23 14:05:17 +02:00
|
|
|
return {
|
|
|
|
decode(x: any, c?: Context): true {
|
|
|
|
if (x === true) {
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
throw new DecodingError(
|
2020-08-03 09:30:48 +02:00
|
|
|
`expected boolean true at ${renderContext(c)} but got ${typeof x}`,
|
2020-07-23 14:05:17 +02:00
|
|
|
);
|
|
|
|
},
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return a codec for a boolean true constant.
|
|
|
|
*/
|
2020-08-12 12:32:58 +02:00
|
|
|
export function codecForConstFalse(): Codec<false> {
|
2020-07-23 14:05:17 +02:00
|
|
|
return {
|
|
|
|
decode(x: any, c?: Context): false {
|
|
|
|
if (x === false) {
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
throw new DecodingError(
|
2020-08-03 09:30:48 +02:00
|
|
|
`expected boolean false at ${renderContext(c)} but got ${typeof x}`,
|
2020-07-23 14:05:17 +02:00
|
|
|
);
|
|
|
|
},
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return a codec for a value that must be a constant number.
|
|
|
|
*/
|
2020-08-12 12:32:58 +02:00
|
|
|
export function codecForConstNumber<V extends number>(n: V): Codec<V> {
|
2020-07-23 14:05:17 +02:00
|
|
|
return {
|
|
|
|
decode(x: any, c?: Context): V {
|
|
|
|
if (x === n) {
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
throw new DecodingError(
|
|
|
|
`expected number constant "${n}" at ${renderContext(
|
|
|
|
c,
|
|
|
|
)} but got ${typeof x}`,
|
|
|
|
);
|
|
|
|
},
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2020-08-12 12:32:58 +02:00
|
|
|
export function codecOptional<V>(innerCodec: Codec<V>): Codec<V | undefined> {
|
2019-12-19 20:42:49 +01:00
|
|
|
return {
|
|
|
|
decode(x: any, c?: Context): V | undefined {
|
|
|
|
if (x === undefined || x === null) {
|
|
|
|
return undefined;
|
|
|
|
}
|
|
|
|
return innerCodec.decode(x, c);
|
2020-03-30 12:39:32 +02:00
|
|
|
},
|
|
|
|
};
|
2020-04-07 10:07:32 +02:00
|
|
|
}
|