eudiplo documentation
  1. Miscellaneous
  2. Variables

Index

src/registrar/generated/sdk.gen.ts

accessCertificateControllerAccessCertificates
Default value : < ThrowOnError extends boolean = false, >( options: Options< AccessCertificateControllerAccessCertificatesData, ThrowOnError >, ) => { return (options.client ?? _heyApiClient).get< AccessCertificateControllerAccessCertificatesResponses, unknown, ThrowOnError >({ url: '/relying-parties/{rp}/access-certificates', ...options, }); }

Get all access certificates by a relying party
accessCertificateControllerDelete
Default value : < ThrowOnError extends boolean = false, >( options: Options<AccessCertificateControllerDeleteData, ThrowOnError>, ) => { return (options.client ?? _heyApiClient).delete< AccessCertificateControllerDeleteResponses, unknown, ThrowOnError >({ security: [ { scheme: 'bearer', type: 'http', }, ], url: '/relying-parties/{rp}/access-certificates/{id}', ...options, }); }

Delete a certificate by id
accessCertificateControllerFindOne
Default value : < ThrowOnError extends boolean = false, >( options: Options<AccessCertificateControllerFindOneData, ThrowOnError>, ) => { return (options.client ?? _heyApiClient).get< AccessCertificateControllerFindOneResponses, unknown, ThrowOnError >({ url: '/relying-parties/{rp}/access-certificates/{id}', ...options, }); }

Get a certificate by id
accessCertificateControllerFindOneParsed
Default value : < ThrowOnError extends boolean = false, >( options: Options< AccessCertificateControllerFindOneParsedData, ThrowOnError >, ) => { return (options.client ?? _heyApiClient).get< AccessCertificateControllerFindOneParsedResponses, unknown, ThrowOnError >({ url: '/relying-parties/{rp}/access-certificates/{id}/parsed', ...options, }); }

Get a certificate by id and parse it via openssl Subject is not RFC 4514 conform
accessCertificateControllerRegister
Default value : < ThrowOnError extends boolean = false, >( options: Options<AccessCertificateControllerRegisterData, ThrowOnError>, ) => { return (options.client ?? _heyApiClient).post< AccessCertificateControllerRegisterResponses, unknown, ThrowOnError >({ security: [ { scheme: 'bearer', type: 'http', }, ], url: '/relying-parties/{rp}/access-certificates', ...options, headers: { 'Content-Type': 'application/json', ...options.headers, }, }); }

Add a new access certificate
cryptoControllerOwnCert
Default value : <ThrowOnError extends boolean = false>( options?: Options<CryptoControllerOwnCertData, ThrowOnError>, ) => { return (options?.client ?? _heyApiClient).get< CryptoControllerOwnCertResponses, unknown, ThrowOnError >({ url: '/ca', ...options, }); }

Returns the certificate of the RP registrar.
cryptoControllerOwnCertParsed
Default value : < ThrowOnError extends boolean = false, >( options?: Options<CryptoControllerOwnCertParsedData, ThrowOnError>, ) => { return (options?.client ?? _heyApiClient).get< CryptoControllerOwnCertParsedResponses, unknown, ThrowOnError >({ url: '/ca/parsed', ...options, }); }

Returns the certificate of the RP registrar.
healthControllerCheck
Default value : <ThrowOnError extends boolean = false>( options?: Options<HealthControllerCheckData, ThrowOnError>, ) => { return (options?.client ?? _heyApiClient).get< HealthControllerCheckResponses, HealthControllerCheckErrors, ThrowOnError >({ url: '/health', ...options, }); }
oid4VpControllerGetValidPid
Default value : < ThrowOnError extends boolean = false, >( options: Options<Oid4VpControllerGetValidPidData, ThrowOnError>, ) => { return (options.client ?? _heyApiClient).get< Oid4VpControllerGetValidPidResponses, unknown, ThrowOnError >({ url: '/oid4vp', ...options, }); }

Get a valid openid4vp request uri
oid4VpControllerGetValidRequest
Default value : < ThrowOnError extends boolean = false, >( options: Options<Oid4VpControllerGetValidRequestData, ThrowOnError>, ) => { return (options.client ?? _heyApiClient).get< Oid4VpControllerGetValidRequestResponses, unknown, ThrowOnError >({ url: '/oid4vp/{version}/{request}/{querylanguage}', ...options, }); }

Get an oid4vp authorization request as signed JWT
oid4VpControllerGetValidRequestWithQuery
Default value : < ThrowOnError extends boolean = false, >( options: Options< Oid4VpControllerGetValidRequestWithQueryData, ThrowOnError >, ) => { return (options.client ?? _heyApiClient).get< Oid4VpControllerGetValidRequestWithQueryResponses, unknown, ThrowOnError >({ url: '/oid4vp/{version}/{request}', ...options, }); }

deprecated
oid4VpControllerResponse
Default value : <ThrowOnError extends boolean = false>( options?: Options<Oid4VpControllerResponseData, ThrowOnError>, ) => { return (options?.client ?? _heyApiClient).post< Oid4VpControllerResponseResponses, unknown, ThrowOnError >({ url: '/oid4vp/response', ...options, }); }

Response endpoint
oid4VpControllerSuccess
Default value : <ThrowOnError extends boolean = false>( options?: Options<Oid4VpControllerSuccessData, ThrowOnError>, ) => { return (options?.client ?? _heyApiClient).get< Oid4VpControllerSuccessResponses, unknown, ThrowOnError >({ url: '/oid4vp/success', ...options, }); }

Dummy success endpoint
registrationCertificateControllerAll
Default value : < ThrowOnError extends boolean = false, >( options: Options<RegistrationCertificateControllerAllData, ThrowOnError>, ) => { return (options.client ?? _heyApiClient).get< RegistrationCertificateControllerAllResponses, unknown, ThrowOnError >({ url: '/relying-parties/{rp}/registration-certificates', ...options, }); }

Get all registration certificates by a relying party
registrationCertificateControllerDelete
Default value : < ThrowOnError extends boolean = false, >( options: Options<RegistrationCertificateControllerDeleteData, ThrowOnError>, ) => { return (options.client ?? _heyApiClient).delete< RegistrationCertificateControllerDeleteResponses, unknown, ThrowOnError >({ security: [ { scheme: 'bearer', type: 'http', }, ], url: '/relying-parties/{rp}/registration-certificates/{id}', ...options, }); }

Delete a certificate by id
registrationCertificateControllerFindOne
Default value : < ThrowOnError extends boolean = false, >( options: Options< RegistrationCertificateControllerFindOneData, ThrowOnError >, ) => { return (options.client ?? _heyApiClient).get< RegistrationCertificateControllerFindOneResponses, RegistrationCertificateControllerFindOneErrors, ThrowOnError >({ url: '/relying-parties/{rp}/registration-certificates/{id}', ...options, }); }

Get a certificate by id
registrationCertificateControllerFindOneDecoded
Default value : < ThrowOnError extends boolean = false, >( options: Options< RegistrationCertificateControllerFindOneDecodedData, ThrowOnError >, ) => { return (options.client ?? _heyApiClient).get< RegistrationCertificateControllerFindOneDecodedResponses, unknown, ThrowOnError >({ url: '/relying-parties/{rp}/registration-certificates/{id}/jws-decoded', ...options, }); }

Get a certificate by id decoded as jws
registrationCertificateControllerRegister
Default value : < ThrowOnError extends boolean = false, >( options: Options< RegistrationCertificateControllerRegisterData, ThrowOnError >, ) => { return (options.client ?? _heyApiClient).post< RegistrationCertificateControllerRegisterResponses, unknown, ThrowOnError >({ security: [ { scheme: 'bearer', type: 'http', }, ], url: '/relying-parties/{rp}/registration-certificates', ...options, headers: { 'Content-Type': 'application/json', ...options.headers, }, }); }

Add a new registration certificate
relyingPartyControllerFindAll
Default value : < ThrowOnError extends boolean = false, >( options?: Options<RelyingPartyControllerFindAllData, ThrowOnError>, ) => { return (options?.client ?? _heyApiClient).get< RelyingPartyControllerFindAllResponses, unknown, ThrowOnError >({ url: '/relying-parties', ...options, }); }

Get all relying parties
relyingPartyControllerRegister
Default value : < ThrowOnError extends boolean = false, >( options: Options<RelyingPartyControllerRegisterData, ThrowOnError>, ) => { return (options.client ?? _heyApiClient).post< RelyingPartyControllerRegisterResponses, unknown, ThrowOnError >({ security: [ { scheme: 'bearer', type: 'http', }, ], url: '/relying-parties', ...options, headers: { 'Content-Type': 'application/json', ...options.headers, }, }); }

Register a new relying party
relyingPartyControllerRemove
Default value : < ThrowOnError extends boolean = false, >( options: Options<RelyingPartyControllerRemoveData, ThrowOnError>, ) => { return (options.client ?? _heyApiClient).delete< RelyingPartyControllerRemoveResponses, unknown, ThrowOnError >({ security: [ { scheme: 'bearer', type: 'http', }, ], url: '/relying-parties/{id}', ...options, }); }

Removes a relying party and it's associated certificates. Only used to tidy up.
statusListControllerCrlFile
Default value : < ThrowOnError extends boolean = false, >( options?: Options<StatusListControllerCrlFileData, ThrowOnError>, ) => { return (options?.client ?? _heyApiClient).get< StatusListControllerCrlFileResponses, unknown, ThrowOnError >({ url: '/status-management/crl', ...options, }); }

Returns the crl.der file
statusListControllerGetList
Default value : < ThrowOnError extends boolean = false, >( options?: Options<StatusListControllerGetListData, ThrowOnError>, ) => { return (options?.client ?? _heyApiClient).get< StatusListControllerGetListResponses, unknown, ThrowOnError >({ url: '/status-management/status-list', ...options, }); }

Get the status list

src/auth/auth.module.ts

AUTH_VALIDATION_SCHEMA
Type : object
Default value : { OIDC: Joi.string().optional(), KEYCLOAK_INTERNAL_ISSUER_URL: Joi.when('OIDC', { then: Joi.string().required(), otherwise: Joi.string().optional(), }), KEYCLOAK_CLIENT_ID: Joi.when('OIDC', { then: Joi.string().required(), otherwise: Joi.string().optional(), }), JWT_SECRET: Joi.when('OIDC', { then: Joi.string().optional(), otherwise: Joi.string().required(), }), JWT_ISSUER: Joi.when('OIDC', { then: Joi.string().optional(), otherwise: Joi.string().optional().default('eudiplo-service'), }), JWT_EXPIRES_IN: Joi.when('OIDC', { then: Joi.string().optional(), otherwise: Joi.string().default('24h'), }), AUTH_CLIENT_SECRET: Joi.when('OIDC', { then: Joi.string().optional(), otherwise: Joi.string().required(), }), AUTH_CLIENT_ID: Joi.when('OIDC', { then: Joi.string().optional(), otherwise: Joi.string().required(), }), }

src/registrar/generated/core/params.ts

buildClientParams
Default value : ( args: ReadonlyArray<unknown>, fields: FieldsConfig, ) => { const params: Params = { body: {}, headers: {}, path: {}, query: {}, }; const map = buildKeyMap(fields); let config: FieldsConfig[number] | undefined; for (const [index, arg] of args.entries()) { if (fields[index]) { config = fields[index]; } if (!config) { continue; } if ('in' in config) { if (config.key) { const field = map.get(config.key)!; const name = field.map || config.key; (params[field.in] as Record<string, unknown>)[name] = arg; } else { params.body = arg; } } else { for (const [key, value] of Object.entries(arg ?? {})) { const field = map.get(key); if (field) { const name = field.map || key; (params[field.in] as Record<string, unknown>)[name] = value; } else { const extra = extraPrefixes.find(([prefix]) => key.startsWith(prefix), ); if (extra) { const [prefix, slot] = extra; (params[slot] as Record<string, unknown>)[ key.slice(prefix.length) ] = value; } else { for (const [slot, allowed] of Object.entries( config.allowExtra ?? {}, )) { if (allowed) { ( params[slot as Slot] as Record< string, unknown > )[key] = value; break; } } } } } } } stripEmptySlots(params); return params; }
buildKeyMap
Default value : (fields: FieldsConfig, map?: KeyMap): KeyMap => { if (!map) { map = new Map(); } for (const config of fields) { if ('in' in config) { if (config.key) { map.set(config.key, { in: config.in, map: config.map, }); } } else if (config.args) { buildKeyMap(config.args, map); } } return map; }
extraPrefixes
Default value : Object.entries(extraPrefixesMap)
extraPrefixesMap
Type : Record<string, Slot>
Default value : { $body_: 'body', $headers_: 'headers', $path_: 'path', $query_: 'query', }
stripEmptySlots
Default value : (params: Params) => { for (const [slot, value] of Object.entries(params)) { if (value && typeof value === 'object' && !Object.keys(value).length) { delete params[slot as Slot]; } } }

src/registrar/generated/client/utils.ts

buildUrl
Default value : (options) => { const url = getUrl({ baseUrl: options.baseUrl as string, path: options.path, query: options.query, querySerializer: typeof options.querySerializer === 'function' ? options.querySerializer : createQuerySerializer(options.querySerializer), url: options.url, }); return url; }
createConfig
Default value : <T extends ClientOptions = ClientOptions>( override: Config<Omit<ClientOptions, keyof T> & T> = {}, ): Config<Omit<ClientOptions, keyof T> & T> => ({ ...jsonBodySerializer, headers: defaultHeaders, parseAs: 'auto', querySerializer: defaultQuerySerializer, ...override, })
createInterceptors
Default value : <Req, Res, Err, Options>() => ({ error: new Interceptors<ErrInterceptor<Err, Res, Req, Options>>(), request: new Interceptors<ReqInterceptor<Req, Options>>(), response: new Interceptors<ResInterceptor<Res, Req, Options>>(), })
createQuerySerializer
Default value : <T = unknown>({ allowReserved, array, object, }: QuerySerializerOptions = {}) => { const querySerializer = (queryParams: T) => { const search: string[] = []; if (queryParams && typeof queryParams === 'object') { for (const name in queryParams) { const value = queryParams[name]; if (value === undefined || value === null) { continue; } if (Array.isArray(value)) { const serializedArray = serializeArrayParam({ allowReserved, explode: true, name, style: 'form', value, ...array, }); if (serializedArray) search.push(serializedArray); } else if (typeof value === 'object') { const serializedObject = serializeObjectParam({ allowReserved, explode: true, name, style: 'deepObject', value: value as Record<string, unknown>, ...object, }); if (serializedObject) search.push(serializedObject); } else { const serializedPrimitive = serializePrimitiveParam({ allowReserved, name, value: value as string, }); if (serializedPrimitive) search.push(serializedPrimitive); } } } return search.join('&'); }; return querySerializer; }
defaultHeaders
Type : object
Default value : { 'Content-Type': 'application/json', }
defaultPathSerializer
Default value : ({ path, url: _url }: PathSerializer) => { let url = _url; const matches = _url.match(PATH_PARAM_RE); if (matches) { for (const match of matches) { let explode = false; let name = match.substring(1, match.length - 1); let style: ArraySeparatorStyle = 'simple'; if (name.endsWith('*')) { explode = true; name = name.substring(0, name.length - 1); } if (name.startsWith('.')) { name = name.substring(1); style = 'label'; } else if (name.startsWith(';')) { name = name.substring(1); style = 'matrix'; } const value = path[name]; if (value === undefined || value === null) { continue; } if (Array.isArray(value)) { url = url.replace( match, serializeArrayParam({ explode, name, style, value }), ); continue; } if (typeof value === 'object') { url = url.replace( match, serializeObjectParam({ explode, name, style, value: value as Record<string, unknown>, valueOnly: true, }), ); continue; } if (style === 'matrix') { url = url.replace( match, `;${serializePrimitiveParam({ name, value: value as string, })}`, ); continue; } const replaceValue = encodeURIComponent( style === 'label' ? `.${value as string}` : (value as string), ); url = url.replace(match, replaceValue); } } return url; }
defaultQuerySerializer
Default value : createQuerySerializer({ allowReserved: false, array: { explode: true, style: 'form', }, object: { explode: true, style: 'deepObject', }, })
getParseAs
Default value : ( contentType: string | null, ): Exclude<Config['parseAs'], 'auto'> => { if (!contentType) { // If no Content-Type header is provided, the best we can do is return the raw response body, // which is effectively the same as the 'stream' option. return 'stream'; } const cleanContent = contentType.split(';')[0]?.trim(); if (!cleanContent) { return; } if ( cleanContent.startsWith('application/json') || cleanContent.endsWith('+json') ) { return 'json'; } if (cleanContent === 'multipart/form-data') { return 'formData'; } if ( ['application/', 'audio/', 'image/', 'video/'].some((type) => cleanContent.startsWith(type), ) ) { return 'blob'; } if (cleanContent.startsWith('text/')) { return 'text'; } return; }

Infers parseAs value from provided Content-Type header.
getUrl
Default value : ({ baseUrl, path, query, querySerializer, url: _url, }: { baseUrl?: string; path?: Record<string, unknown>; query?: Record<string, unknown>; querySerializer: QuerySerializer; url: string; }) => { const pathUrl = _url.startsWith('/') ? _url : `/${_url}`; let url = (baseUrl ?? '') + pathUrl; if (path) { url = defaultPathSerializer({ path, url }); } let search = query ? querySerializer(query) : ''; if (search.startsWith('?')) { search = search.substring(1); } if (search) { url += `?${search}`; } return url; }
mergeConfigs
Default value : (a: Config, b: Config): Config => { const config = { ...a, ...b }; if (config.baseUrl?.endsWith('/')) { config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1); } config.headers = mergeHeaders(a.headers, b.headers); return config; }
mergeHeaders
Default value : ( ...headers: Array<Required<Config>['headers'] | undefined> ): Headers => { const mergedHeaders = new Headers(); for (const header of headers) { if (!header || typeof header !== 'object') { continue; } const iterator = header instanceof Headers ? header.entries() : Object.entries(header); for (const [key, value] of iterator) { if (value === null) { mergedHeaders.delete(key); } else if (Array.isArray(value)) { for (const v of value) { mergedHeaders.append(key, v as string); } } else if (value !== undefined) { // assume object headers are meant to be JSON stringified, i.e. their // content value in OpenAPI specification is 'application/json' mergedHeaders.set( key, typeof value === 'object' ? JSON.stringify(value) : (value as string), ); } } } return mergedHeaders; }
PATH_PARAM_RE
Default value : /\{[^{}]+\}/g
setAuthParams
Default value : async ({ security, ...options }: Pick<Required<RequestOptions>, 'security'> & Pick<RequestOptions, 'auth' | 'query'> & { headers: Headers; }) => { for (const auth of security) { const token = await getAuthToken(auth, options.auth); if (!token) { continue; } const name = auth.name ?? 'Authorization'; switch (auth.in) { case 'query': if (!options.query) { options.query = {}; } options.query[name] = token; break; case 'cookie': options.headers.append('Cookie', `${name}=${token}`); break; case 'header': default: options.headers.set(name, token); break; } return; } }

test/utils.ts

callbacks
Type : any
Default value : { hash: (data, alg) => crypto .createHash(alg.replace('-', '').toLowerCase()) .update(data) .digest(), generateRandom: (bytes) => crypto.randomBytes(bytes), /* clientAuthentication: clientAuthenticationNone({ clientId: 'some-random-client-id', }), */ verifyJwt: async (signer, { compact, payload }) => { let jwk: Jwk; let publicKey: CryptoKey; if (signer.method === 'jwk') { jwk = signer.publicJwk; publicKey = (await importJWK(jwk as JWK, signer.alg)) as CryptoKey; } else if (signer.method === 'x5c') { const headerB64 = compact.split('.')[0]; const header = JSON.parse( Buffer.from(headerB64, 'base64url').toString(), ); const certPem = `-----BEGIN CERTIFICATE-----\n${header.x5c}\n-----END CERTIFICATE-----`; publicKey = await importX509(certPem, signer.alg); jwk = (await exportJWK(publicKey)) as Jwk; } else { throw new Error('Signer method not supported'); } try { await jwtVerify(compact, publicKey, { currentDate: payload.exp ? new Date((payload.exp - 300) * 1000) : undefined, }); return { verified: true, signerJwk: jwk, }; // eslint-disable-next-line @typescript-eslint/no-unused-vars } catch (error) { return { verified: false, }; } }, getX509CertificateMetadata: ( certificate: string, ): { sanDnsNames: string[]; sanUriNames: string[]; } => { const cert1 = new crypto.X509Certificate( `-----BEGIN CERTIFICATE-----\n${certificate}\n-----END CERTIFICATE-----`, ); const sanDnsNames = cert1 .subjectAltName!.split(',') .map((name) => name.replace('DNS:', '').trim()); const sanUriNames = []; sanDnsNames.push('example.com'); return { sanDnsNames, sanUriNames, }; }, } as const satisfies Partial<CallbackContext>
getSignJwtCallback
Default value : (privateJwks: Jwk[]): SignJwtCallback => { return async (signer, { header, payload }) => { let jwk: Jwk; if (signer.method === 'jwk') { jwk = signer.publicJwk; } else { throw new Error('Signer method not supported'); } const jwkThumprint = await calculateJwkThumbprint(jwk as JWK, 'sha256'); // add cnf payload.cnf = { jkt: jwkThumprint, }; const privateJwk = await Promise.all( privateJwks.map(async (jwk) => (await calculateJwkThumbprint(jwk as JWK, 'sha256')) === jwkThumprint ? jwk : undefined, ), ).then((jwks) => jwks.find((jwk) => jwk !== undefined)); if (!privateJwk) { throw new Error( `No private key available for public jwk \n${JSON.stringify(jwk, null, 2)}`, ); } const josePrivateKey = await importJWK(privateJwk as JWK, signer.alg); const jwt = await new SignJWT(payload) .setProtectedHeader(header) .sign(josePrivateKey); return { jwt: jwt, signerJwk: jwk, }; }; }

src/registrar/generated/client.gen.ts

client
Default value : createClient(createConfig<ClientOptions>())

scripts/import.ts

clientId
Type : string
Default value : 'root'
clientSecret
Type : string
Default value : 'root'
url
Type : string
Default value : 'http://localhost:3000'

src/registrar/generated/client/client.ts

createClient
Default value : (config: Config = {}): Client => { let _config = mergeConfigs(createConfig(), config); const getConfig = (): Config => ({ ..._config }); const setConfig = (config: Config): Config => { _config = mergeConfigs(_config, config); return getConfig(); }; const interceptors = createInterceptors< Request, Response, unknown, RequestOptions >(); const request: Client['request'] = async (options) => { const opts = { ..._config, ...options, fetch: options.fetch ?? _config.fetch ?? globalThis.fetch, headers: mergeHeaders(_config.headers, options.headers), }; if (opts.security) { await setAuthParams({ ...opts, security: opts.security, }); } if (opts.requestValidator) { await opts.requestValidator(opts); } if (opts.body && opts.bodySerializer) { opts.body = opts.bodySerializer(opts.body); } // remove Content-Type header if body is empty to avoid sending invalid requests if (opts.body === undefined || opts.body === '') { opts.headers.delete('Content-Type'); } const url = buildUrl(opts); const requestInit: ReqInit = { redirect: 'follow', ...opts, }; let request = new Request(url, requestInit); for (const fn of interceptors.request._fns) { if (fn) { request = await fn(request, opts); } } // fetch must be assigned here, otherwise it would throw the error: // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation const _fetch = opts.fetch; let response = await _fetch(request); for (const fn of interceptors.response._fns) { if (fn) { response = await fn(response, request, opts); } } const result = { request, response, }; if (response.ok) { if ( response.status === 204 || response.headers.get('Content-Length') === '0' ) { return opts.responseStyle === 'data' ? {} : { data: {}, ...result, }; } const parseAs = (opts.parseAs === 'auto' ? getParseAs(response.headers.get('Content-Type')) : opts.parseAs) ?? 'json'; let data: any; switch (parseAs) { case 'arrayBuffer': case 'blob': case 'formData': case 'json': case 'text': data = await response[parseAs](); break; case 'stream': return opts.responseStyle === 'data' ? response.body : { data: response.body, ...result, }; } if (parseAs === 'json') { if (opts.responseValidator) { await opts.responseValidator(data); } if (opts.responseTransformer) { data = await opts.responseTransformer(data); } } return opts.responseStyle === 'data' ? data : { data, ...result, }; } const textError = await response.text(); let jsonError: unknown; try { jsonError = JSON.parse(textError); } catch { // noop } const error = jsonError ?? textError; let finalError = error; for (const fn of interceptors.error._fns) { if (fn) { finalError = (await fn( error, response, request, opts, )) as string; } } finalError = finalError || ({} as string); if (opts.throwOnError) { throw finalError; } // TODO: we probably want to return error and improve types return opts.responseStyle === 'data' ? undefined : { error: finalError, ...result, }; }; return { buildUrl, connect: (options) => request({ ...options, method: 'CONNECT' }), delete: (options) => request({ ...options, method: 'DELETE' }), get: (options) => request({ ...options, method: 'GET' }), getConfig, head: (options) => request({ ...options, method: 'HEAD' }), interceptors, options: (options) => request({ ...options, method: 'OPTIONS' }), patch: (options) => request({ ...options, method: 'PATCH' }), post: (options) => request({ ...options, method: 'POST' }), put: (options) => request({ ...options, method: 'PUT' }), request, setConfig, trace: (options) => request({ ...options, method: 'TRACE' }), }; }

src/crypto/key/crypto/crypto.module.ts

CRYPTO_VALIDATION_SCHEMA
Type : object
Default value : { CRYPTO_ALG: Joi.string().valid('ES256', 'Ed25519').default('ES256'), }

src/database/database.module.ts

DB_VALIDATION_SCHEMA
Type : object
Default value : { DB_TYPE: Joi.string().valid('sqlite', 'postgres').default('sqlite'), DB_HOST: Joi.string().when('DB_TYPE', { is: 'sqlite', then: Joi.optional(), otherwise: Joi.required(), }), DB_PORT: Joi.number().when('DB_TYPE', { is: 'sqlite', then: Joi.optional(), otherwise: Joi.required(), }), DB_USERNAME: Joi.string().when('DB_TYPE', { is: 'sqlite', then: Joi.optional(), otherwise: Joi.required(), }), DB_PASSWORD: Joi.string().when('DB_TYPE', { is: 'sqlite', then: Joi.optional(), otherwise: Joi.required(), }), DB_DATABASE: Joi.string().when('DB_TYPE', { is: 'sqlite', then: Joi.optional(), otherwise: Joi.required(), }), }

src/crypto/key/crypto/ed25519.ts

ED25519
Type : CryptoImplementation
Default value : { alg: 'EdDSA', async generateKeyPair() { const keyPair = await crypto.webcrypto.subtle.generateKey( { name: 'EdDSA', namedCurve: 'Ed25519', }, true, ['sign', 'verify'], ); const publicKey = await crypto.webcrypto.subtle.exportKey( 'jwk', keyPair.publicKey, ); const privateKey = await crypto.webcrypto.subtle.exportKey( 'jwk', keyPair.privateKey, ); return { publicKey, privateKey }; }, async getSigner(privateKeyJWK: object) { const privateKey = await crypto.webcrypto.subtle.importKey( 'jwk', privateKeyJWK, { name: 'EdDSA', namedCurve: 'Ed25519', }, false, ['sign'], ); return async (data: string) => { const signature = await crypto.webcrypto.subtle.sign( 'EdDSA', privateKey, new TextEncoder().encode(data), ); return Buffer.from(signature).toString('base64url'); }; }, async getVerifier(publicKeyJWK: object) { const publicKey = await crypto.webcrypto.subtle.importKey( 'jwk', publicKeyJWK, { name: 'EdDSA', namedCurve: 'Ed25519', }, false, ['verify'], ); return async (data: string, signatureBase64url: string) => { const signature = Buffer.from(signatureBase64url, 'base64url'); const isVerified = await crypto.webcrypto.subtle.verify( 'EdDSA', publicKey, signature, new TextEncoder().encode(data), ); return isVerified; }; }, }

src/registrar/generated/core/bodySerializer.ts

formDataBodySerializer
Type : object
Default value : { bodySerializer: < T extends Record<string, any> | Array<Record<string, any>>, >( body: T, ): FormData => { const data = new FormData(); Object.entries(body).forEach(([key, value]) => { if (value === undefined || value === null) { return; } if (Array.isArray(value)) { value.forEach((v) => serializeFormDataPair(data, key, v)); } else { serializeFormDataPair(data, key, value); } }); return data; }, }
jsonBodySerializer
Type : object
Default value : { bodySerializer: <T>(body: T): string => JSON.stringify(body, (_key, value) => typeof value === 'bigint' ? value.toString() : value, ), }
serializeFormDataPair
Default value : ( data: FormData, key: string, value: unknown, ): void => { if (typeof value === 'string' || value instanceof Blob) { data.append(key, value); } else { data.append(key, JSON.stringify(value)); } }
serializeUrlSearchParamsPair
Default value : ( data: URLSearchParams, key: string, value: unknown, ): void => { if (typeof value === 'string') { data.append(key, value); } else { data.append(key, JSON.stringify(value)); } }
urlSearchParamsBodySerializer
Type : object
Default value : { bodySerializer: < T extends Record<string, any> | Array<Record<string, any>>, >( body: T, ): string => { const data = new URLSearchParams(); Object.entries(body).forEach(([key, value]) => { if (value === undefined || value === null) { return; } if (Array.isArray(value)) { value.forEach((v) => serializeUrlSearchParamsPair(data, key, v), ); } else { serializeUrlSearchParamsPair(data, key, value); } }); return data.toString(); }, }

src/registrar/generated/core/auth.ts

getAuthToken
Default value : async ( auth: Auth, callback: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken, ): Promise<string | undefined> => { const token = typeof callback === 'function' ? await callback(auth) : callback; if (!token) { return; } if (auth.scheme === 'bearer') { return `Bearer ${token}`; } if (auth.scheme === 'basic') { return `Basic ${btoa(token)}`; } return token; }

src/auth/public.decorator.ts

IS_PUBLIC_KEY
Type : string
Default value : 'isPublic'
Public
Default value : () => SetMetadata(IS_PUBLIC_KEY, true)

src/issuer/issuer.module.ts

ISSUER_VALIDATION_SCHEMA
Type : object
Default value : { PUBLIC_URL: Joi.string(), }

src/crypto/key/key.module.ts

KEY_VALIDATION_SCHEMA
Type : object
Default value : { KM_TYPE: Joi.string().valid('file', 'vault').default('file'), // Vault-related config VAULT_URL: Joi.string().uri().when('KM_TYPE', { is: 'vault', then: Joi.required(), otherwise: Joi.optional(), }), VAULT_TOKEN: Joi.string().when('KM_TYPE', { is: 'vault', then: Joi.required(), otherwise: Joi.optional(), }), VAULT_KEY_ID: Joi.string().when('KM_TYPE', { is: 'vault', then: Joi.string().default('key-id'), otherwise: Joi.optional(), }), }

src/registrar/registrar.module.ts

REGISTRAR_VALIDATION_SCHEMA
Type : object
Default value : { REGISTRAR_URL: Joi.string(), OIDC_ISSUER_URL: Joi.string().when('REGISTRAR_URL', { is: Joi.exist(), then: Joi.required(), }), OIDC_CLIENT_ID: Joi.string().when('REGISTRAR_URL', { is: Joi.exist(), then: Joi.required(), }), OIDC_CLIENT_SECRET: Joi.string().when('REGISTRAR_URL', { is: Joi.exist(), then: Joi.required(), }), }

src/registrar/generated/core/pathSerializer.ts

separatorArrayExplode
Default value : (style: ArraySeparatorStyle) => { switch (style) { case 'label': return '.'; case 'matrix': return ';'; case 'simple': return ','; default: return '&'; } }
separatorArrayNoExplode
Default value : (style: ArraySeparatorStyle) => { switch (style) { case 'form': return ','; case 'pipeDelimited': return '|'; case 'spaceDelimited': return '%20'; default: return ','; } }
separatorObjectExplode
Default value : (style: ObjectSeparatorStyle) => { switch (style) { case 'label': return '.'; case 'matrix': return ';'; case 'simple': return ','; default: return '&'; } }
serializeArrayParam
Default value : ({ allowReserved, explode, name, style, value, }: SerializeOptions<ArraySeparatorStyle> & { value: unknown[]; }) => { if (!explode) { const joinedValues = ( allowReserved ? value : value.map((v) => encodeURIComponent(v as string)) ).join(separatorArrayNoExplode(style)); switch (style) { case 'label': return `.${joinedValues}`; case 'matrix': return `;${name}=${joinedValues}`; case 'simple': return joinedValues; default: return `${name}=${joinedValues}`; } } const separator = separatorArrayExplode(style); const joinedValues = value .map((v) => { if (style === 'label' || style === 'simple') { return allowReserved ? v : encodeURIComponent(v as string); } return serializePrimitiveParam({ allowReserved, name, value: v as string, }); }) .join(separator); return style === 'label' || style === 'matrix' ? separator + joinedValues : joinedValues; }
serializeObjectParam
Default value : ({ allowReserved, explode, name, style, value, valueOnly, }: SerializeOptions<ObjectSeparatorStyle> & { value: Record<string, unknown> | Date; valueOnly?: boolean; }) => { if (value instanceof Date) { return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`; } if (style !== 'deepObject' && !explode) { let values: string[] = []; Object.entries(value).forEach(([key, v]) => { values = [ ...values, key, allowReserved ? (v as string) : encodeURIComponent(v as string), ]; }); const joinedValues = values.join(','); switch (style) { case 'form': return `${name}=${joinedValues}`; case 'label': return `.${joinedValues}`; case 'matrix': return `;${name}=${joinedValues}`; default: return joinedValues; } } const separator = separatorObjectExplode(style); const joinedValues = Object.entries(value) .map(([key, v]) => serializePrimitiveParam({ allowReserved, name: style === 'deepObject' ? `${name}[${key}]` : key, value: v as string, }), ) .join(separator); return style === 'label' || style === 'matrix' ? separator + joinedValues : joinedValues; }
serializePrimitiveParam
Default value : ({ allowReserved, name, value, }: SerializePrimitiveParam) => { if (value === undefined || value === null) { return ''; } if (typeof value === 'object') { throw new Error( 'Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.', ); } return `${name}=${allowReserved ? value : encodeURIComponent(value)}`; }

src/utils/session-logger.decorator.ts

SESSION_LOGGER_KEY
Type : string
Default value : 'session-logger'
SessionLogger
Default value : ( sessionIdParam: string, flowType: 'OID4VCI' | 'OID4VP', ) => SetMetadata(SESSION_LOGGER_KEY, { sessionIdParam, flowType })

Decorator to mark methods that should have session-based logging

src/session/session.module.ts

SESSION_VALIDATION_SCHEMA
Type : object
Default value : { SESSION_TIDY_UP_INTERVAL: Joi.number().default(60 * 60), // default to every hour SESSION_TTL: Joi.number().default(24 * 60 * 60), // default to 24 hours }

src/auth/tenant-events.ts

TENANT_EVENTS
Type : object
Default value : { TENANT_INIT: 'tenant.init', TENANT_KEYS: 'tenant.keys', }

src/auth/token.decorator.ts

Token
Default value : createParamDecorator( (data: unknown, ctx: ExecutionContext) => { const request = ctx.switchToHttp().getRequest(); return request.user as TokenPayload; // Access the token payload on the request object }, )

results matching ""

    No results matching ""