dcql 0.2.3 → 0.2.5

package/src/claims-query/claims-query-result.ts

@@ -1,104 +0,0 @@
-import * as v from 'valibot';
-import { InvalidClaimsQueryIdError } from '../e-vp-query.js';
-import type { Mdoc } from '../u-query.js';
-import { getIdMetadata } from '../u-query.js';
-import type { ClaimsQueryResult } from './v-claims-query-result.js';
-import { ClaimsQuery } from './v-claims-query.js';
-
-const getClaimParser = (input: {
-  value?: string | number | boolean;
-  values?: (string | number | boolean)[];
-}) => {
-  const { value, values } = input;
-  if (value) {
-    return v.literal(value);
-  }
-
-  if (values) {
-    return v.union(values.map(val => v.literal(val)));
-  }
-
-  return ClaimsQuery.vValue;
-};
-
-export const getNamespacesParser = (
-  claimsQueries: ReturnType<typeof getClaimsQueriesForClaimSet>
-) => {
-  const claimsForNamespace: Record<
-    string,
-    ReturnType<typeof getClaimsQueriesForClaimSet>
-  > = {};
-
-  for (const claimQuery of claimsQueries) {
-    if (claimsForNamespace[claimQuery.namespace]) {
-      claimsForNamespace[claimQuery.namespace]?.push({ ...claimQuery });
-    } else {
-      claimsForNamespace[claimQuery.namespace] = [{ ...claimQuery }];
-    }
-  }
-
-  const parsersForNamespaces = Object.entries(claimsForNamespace).map(
-    ([namespace, claims]) => {
-      const claimParsers = Object.fromEntries(
-        claims.map(claim => [
-          claim.claim_name,
-          claim.isOptional || claim.isRequiredIfPresent
-            ? v.optional(getClaimParser(claim))
-            : getClaimParser(claim),
-        ])
-      );
-      return [namespace, v.object(claimParsers)];
-    }
-  );
-
-  return v.object(Object.fromEntries(parsersForNamespaces));
-};
-
-export const queryClaimFromMdoc = (
-  claimsQuery: ClaimsQuery.Mdoc,
-  credential: Mdoc
-) => {
-  const claimParser = getClaimParser(claimsQuery);
-  const claimParsers =
-    claimParser.type === 'union' ? claimParser.options : [claimParser];
-
-  const namespace = credential.namespaces[claimsQuery.namespace];
-  const claimParseResult: ClaimsQueryResult.ParseResult[] = [];
-  for (const claimParser of claimParsers) {
-    const parseResult = v.safeParse(
-      claimParser,
-      namespace?.[claimsQuery.claim_name]
-    );
-
-    const { typed, ...result } = parseResult;
-    claimParseResult.push(result);
-  }
-
-  return claimParseResult;
-};
-
-export const getClaimsQueriesForClaimSet = (
-  claimsQueries: ClaimsQuery.Mdoc[],
-  claimSet?: string[]
-) => {
-  if (!claimSet) {
-    return claimsQueries.map(query => ({
-      ...query,
-      isOptional: false,
-      isRequiredIfPresent: false,
-    }));
-  }
-
-  return claimSet.map(credential_id => {
-    const { isOptional, isRequiredIfPresent, baseId } =
-      getIdMetadata(credential_id);
-
-    const query = claimsQueries.find(query => query.id === baseId);
-    if (!query) {
-      throw new InvalidClaimsQueryIdError({
-        message: `Claims-query with id '${baseId}' not found.`,
-      });
-    }
-    return { ...query, isOptional, isRequiredIfPresent };
-  });
-};

package/src/claims-query/v-claims-query-result.ts

@@ -1,42 +0,0 @@
-import * as v from 'valibot';
-import { ClaimsQuery } from './v-claims-query.js';
-
-export namespace ClaimsQueryResult {
-  export const vParseResult = v.union([
-    v.looseObject({
-      success: v.literal(true),
-      output: ClaimsQuery.vValue,
-    }),
-    v.looseObject({
-      success: v.literal(false),
-      output: v.unknown(),
-    }),
-  ]);
-  export type ParseResult = v.InferOutput<typeof vParseResult>;
-
-  export const vQueryResult = v.array(
-    v.union([v.literal('all'), v.array(vParseResult)])
-  );
-  export type QueryResult = v.InferOutput<typeof vQueryResult>;
-
-  export const vModelMdoc = v.object({
-    ...ClaimsQuery.vMdoc.entries,
-    claim_query_results: v.array(vQueryResult),
-    isOptional: v.boolean(),
-    isRequiredIfPresent: v.boolean(),
-  });
-  export type Mdoc = v.InferOutput<typeof vModelMdoc>;
-
-  export const vW3cSdJwtVc = v.object({
-    ...ClaimsQuery.vW3cSdJwtVc.entries,
-    claim_query_results: v.array(vQueryResult),
-    isOptional: v.boolean(),
-    isRequiredIfPresent: v.boolean(),
-  });
-  export type W3cSdJwtVc = v.InferOutput<typeof vModelMdoc>;
-
-  export const vModel = v.union([vModelMdoc, vW3cSdJwtVc]);
-  export type Input = v.InferInput<typeof vModel>;
-  export type Out = v.InferOutput<typeof vModel>;
-}
-export type ClaimsQueryResult = ClaimsQueryResult.Out;

package/src/claims-query/v-claims-query.ts

@@ -1,34 +0,0 @@
-import * as v from 'valibot';
-import { idRegex } from '../u-query.js';
-
-export namespace ClaimsQuery {
-  export const vValue = v.union([v.string(), v.number(), v.boolean()]);
-  export type ClaimValue = v.InferOutput<typeof vValue>;
-
-  export const vPath = v.union([
-    v.string(),
-    v.pipe(v.number(), v.integer(), v.minValue(0)),
-    v.literal('*'),
-  ]);
-  export type ClaimPath = v.InferOutput<typeof vPath>;
-
-  export const vW3cSdJwtVc = v.object({
-    id: v.optional(v.pipe(v.string(), v.regex(idRegex))),
-    path: v.optional(v.array(vPath)),
-    values: v.optional(v.array(vValue)),
-  });
-  export type W3cAndSdJwtVcInput = v.InferOutput<typeof vW3cSdJwtVc>;
-
-  export const vMdoc = v.object({
-    id: v.optional(v.pipe(v.string(), v.regex(idRegex))),
-    namespace: v.string(),
-    claim_name: v.string(),
-    values: v.optional(v.array(vValue)),
-  });
-  export type Mdoc = v.InferOutput<typeof vMdoc>;
-
-  export const vModel = v.union([vMdoc, vW3cSdJwtVc]);
-  export type Input = v.InferInput<typeof vModel>;
-  export type Out = v.InferOutput<typeof vModel>;
-}
-export type ClaimsQuery = ClaimsQuery.Out;

package/src/credential-query/credential-query-result.ts

@@ -1,130 +0,0 @@
-import * as v from 'valibot';
-import {
-  getClaimsQueriesForClaimSet,
-  getNamespacesParser,
-  queryClaimFromMdoc,
-} from '../claims-query/claims-query-result.js';
-import type { ClaimsQueryResult } from '../claims-query/v-claims-query-result.js';
-import { InvalidCredentialQueryIdError } from '../e-vp-query.js';
-import type { Mdoc } from '../u-query.js';
-import { getIdMetadata } from '../u-query.js';
-import type { CredentialQueryResult } from './v-credential-query-result.js';
-import type { CredentialQuery } from './v-credential-query.js';
-
-const queryClaimsFromCredentials = (
-  credentialQuery: CredentialQuery,
-  credentials: Mdoc[]
-): ClaimsQueryResult.QueryResult[] => {
-  const claimQueryResults: ClaimsQueryResult.QueryResult[] = [];
-
-  if (!credentialQuery.claims) {
-    claimQueryResults.push(['all']);
-    return claimQueryResults;
-  }
-
-  if (credentialQuery.format !== 'mso_mdoc') {
-    throw new Error('Hello World');
-  }
-
-  for (const claimQuery of credentialQuery.claims) {
-    const claimQueryResultsForClaimSet: ClaimsQueryResult.QueryResult = [];
-    for (const credential of credentials) {
-      const res = queryClaimFromMdoc(claimQuery, credential);
-      claimQueryResultsForClaimSet.push(res);
-    }
-    claimQueryResults.push(claimQueryResultsForClaimSet);
-  }
-
-  return claimQueryResults;
-};
-
-const getCredentialQueriesForCredentialSet = (
-  credentialQueries: CredentialQuery[],
-  credentialSet?: string[]
-) => {
-  if (!credentialSet) {
-    return credentialQueries.map(query => ({ ...query, isOptional: false }));
-  }
-  return credentialSet.map(credential_id => {
-    const { isOptional, baseId } = getIdMetadata(credential_id);
-
-    const query = credentialQueries.find(
-      credentialQuery => (credentialQuery.id = baseId)
-    );
-    if (!query) {
-      throw new InvalidCredentialQueryIdError({
-        message: `Credential-query with id '${baseId}' not found.`,
-      });
-    }
-    return { ...query, isOptional };
-  });
-};
-
-export const queryCredentialSet = (
-  credentialQueries: CredentialQuery[],
-  credentials: Mdoc[],
-  credential_set?: [string, ...string[]]
-) => {
-  const credentialQueriesForCredentialSet =
-    getCredentialQueriesForCredentialSet(credentialQueries, credential_set);
-
-  const credentialQueryResults: CredentialQueryResult[] = [];
-
-  for (const credentialQuery of credentialQueriesForCredentialSet) {
-    if (credentialQuery.format !== 'mso_mdoc') {
-      throw new Error('asdfasdf');
-    }
-    const vDocType = credentialQuery.meta?.doctype_values
-      ? v.union(credentialQuery.meta.doctype_values.map(v.literal))
-      : v.unknown();
-
-    const claim_sets_results: CredentialQueryResult.QueryResult[] = [];
-
-    for (const claim_set of credentialQuery.claim_sets ?? [undefined]) {
-      const x2 = credentialQuery.claims
-        ? getClaimsQueriesForClaimSet(credentialQuery.claims, claim_set)
-        : undefined;
-      const credentialParser = v.object({
-        docType: vDocType,
-        namespaces: x2
-          ? getNamespacesParser(x2)
-          : v.record(v.string(), v.record(v.string(), v.unknown())),
-      });
-
-      const credentialQueryResult: CredentialQueryResult.QueryResult = [];
-      for (const credential of credentials) {
-        const parseResult = v.safeParse(credentialParser, credential);
-
-        const { typed, ...result } = parseResult;
-        if (result.success) {
-          credentialQueryResult.push({
-            areRequiredClaimsPresent: result.success,
-            ...result,
-          });
-        } else {
-          credentialQueryResult.push({
-            areRequiredClaimsPresent: result.success,
-            ...result,
-          });
-        }
-      }
-      claim_sets_results.push(credentialQueryResult);
-    }
-
-    const claimQueryResults = queryClaimsFromCredentials(
-      credentialQuery,
-      credentials
-    );
-
-    credentialQueryResults.push({
-      ...credentialQuery,
-      claim_sets_results,
-      claims: credentialQuery.claims?.map(claim => ({
-        ...claim,
-        claim_query_results: claimQueryResults,
-      })),
-    });
-  }
-
-  return credentialQueryResults;
-};

package/src/credential-query/v-credential-query-result.ts

@@ -1,71 +0,0 @@
-import * as v from 'valibot';
-import { ClaimsQueryResult } from '../claims-query/v-claims-query-result.js';
-import { CredentialQuery } from './v-credential-query.js';
-
-export namespace CredentialQueryResult {
-  export const vParseResult = v.union([
-    v.object({
-      areRequiredClaimsPresent: v.literal(true),
-      output: v.record(v.string(), v.unknown()),
-    }),
-    v.object({
-      areRequiredClaimsPresent: v.literal(false),
-      output: v.unknown(),
-    }),
-  ]);
-  export type ParseResult = v.InferOutput<typeof vParseResult>;
-
-  export const vQueryResult = v.array(vParseResult);
-  export type QueryResult = v.InferOutput<typeof vQueryResult>;
-
-  export const vMdoc = v.object({
-    ...CredentialQuery.vMdoc.entries,
-    claims: v.optional(
-      v.pipe(
-        v.array(
-          v.omit(ClaimsQueryResult.vModelMdoc, [
-            'isOptional',
-            'isRequiredIfPresent',
-          ])
-        ),
-        v.nonEmpty()
-      )
-    ),
-    claim_sets_results: v.array(vQueryResult),
-    isOptional: v.boolean(),
-  });
-  export type Mdoc = v.InferInput<typeof vMdoc>;
-
-  const vW3cSdJwtVcBase = v.object({
-    claims: v.optional(
-      v.pipe(
-        v.array(
-          v.omit(ClaimsQueryResult.vW3cSdJwtVc, [
-            'isOptional',
-            'isRequiredIfPresent',
-          ])
-        ),
-        v.nonEmpty()
-      )
-    ),
-    claim_sets_results: v.array(vQueryResult),
-    isOptional: v.boolean(),
-  });
-
-  export const vSdJwtVc = v.object({
-    ...CredentialQuery.vSdJwtVc.entries,
-    ...vW3cSdJwtVcBase.entries,
-  });
-  export type SdJwtVc = v.InferOutput<typeof vSdJwtVc>;
-
-  export const vW3c = v.object({
-    ...CredentialQuery.vW3c.entries,
-    ...vW3cSdJwtVcBase.entries,
-  });
-  export type W3c = v.InferOutput<typeof vW3c>;
-
-  export const vModel = v.variant('format', [vMdoc, vSdJwtVc, vW3c]);
-  export type Input = v.InferInput<typeof vModel>;
-  export type Out = v.InferOutput<typeof vModel>;
-}
-export type CredentialQueryResult = CredentialQueryResult.Out;

package/src/credential-query/v-credential-query.ts

@@ -1,85 +0,0 @@
-import * as v from 'valibot';
-import { ClaimsQuery } from '../claims-query/v-claims-query.js';
-import { VpQueryUndefinedClaimSetIdError } from '../e-vp-query.js';
-import { claimSetIdRegex, getIdMetadata, idRegex } from '../u-query.js';
-
-export namespace CredentialQuery {
-  export const vMdoc = v.object({
-    id: v.pipe(v.string(), v.regex(idRegex)),
-    format: v.literal('mso_mdoc'),
-    meta: v.optional(
-      v.object({
-        doctype_values: v.optional(v.array(v.string())),
-      })
-    ),
-    claims: v.optional(v.pipe(v.array(ClaimsQuery.vMdoc), v.nonEmpty())),
-    claim_sets: v.optional(
-      v.pipe(
-        v.array(v.array(v.pipe(v.string(), v.regex(claimSetIdRegex)))),
-        v.nonEmpty()
-      )
-    ),
-  });
-  export type Mdoc = v.InferOutput<typeof vMdoc>;
-
-  const vW3cSdJwtVcBase = v.object({
-    id: v.pipe(v.string(), v.regex(idRegex)),
-    claims: v.optional(v.pipe(v.array(ClaimsQuery.vW3cSdJwtVc), v.nonEmpty())),
-    claim_sets: v.optional(
-      v.pipe(
-        v.array(v.array(v.pipe(v.string(), v.regex(claimSetIdRegex)))),
-        v.nonEmpty()
-      )
-    ),
-  });
-
-  export const vSdJwtVc = v.object({
-    ...vW3cSdJwtVcBase.entries,
-    format: v.literal('vc+sd-jwt'),
-    meta: v.optional(
-      v.object({
-        vct_values: v.optional(v.array(v.string())),
-      })
-    ),
-  });
-  export type SdJwtVc = v.InferOutput<typeof vSdJwtVc>;
-
-  export const vW3c = v.object({
-    ...vW3cSdJwtVcBase.entries,
-    format: v.picklist(['jwt_vc_json', 'jwt_vc_json-ld']),
-  });
-  export type W3c = v.InferOutput<typeof vW3c>;
-
-  export const vModel = v.variant('format', [vMdoc, vSdJwtVc, vW3c]);
-  export type Input = v.InferInput<typeof vModel>;
-  export type Out = v.InferInput<typeof vModel>;
-
-  export const validate = (credentialQuery: Out) => {
-    claimSetIdsAreDefined(credentialQuery);
-  };
-}
-export type CredentialQuery = CredentialQuery.Out;
-
-// --- validations --- //
-
-const claimSetIdsAreDefined = (credentialQuery: CredentialQuery) => {
-  if (!credentialQuery.claim_sets) return;
-  const claimIds = new Set(credentialQuery.claims?.map(c => c.id));
-
-  const undefinedClaims: string[] = [];
-  for (const claim_set of credentialQuery.claim_sets) {
-    for (const claim_id of claim_set) {
-      const { baseId } = getIdMetadata(claim_id);
-
-      if (!claimIds.has(baseId)) {
-        undefinedClaims.push(baseId);
-      }
-    }
-  }
-
-  if (undefinedClaims.length > 1) {
-    throw new VpQueryUndefinedClaimSetIdError({
-      message: `Credential set contains undefined credential id${undefinedClaims.length === 0 ? '' : '`s'} '${undefinedClaims.join(', ')}'`,
-    });
-  }
-};

package/src/e-base.ts

@@ -1,116 +0,0 @@
-function isObject(value: unknown): value is Record<string, unknown> {
-  return !!value && !Array.isArray(value) && typeof value === 'object';
-}
-
-class UnknownCauseError extends Error {
-  [key: string]: unknown;
-}
-
-export function getCauseFromUnknown(cause: unknown): Error | undefined {
-  if (cause instanceof Error) {
-    return cause;
-  }
-
-  const type = typeof cause;
-  if (type === 'undefined' || type === 'function' || cause === null) {
-    return undefined;
-  }
-
-  // Primitive types just get wrapped in an error
-  if (type !== 'object') {
-    return new Error(String(cause));
-  }
-
-  // If it's an object, we'll create a synthetic error
-  if (isObject(cause)) {
-    const err = new UnknownCauseError();
-    for (const key in cause) {
-      err[key] = cause[key];
-    }
-    return err;
-  }
-
-  return undefined;
-}
-
-export const isAusweisError = (cause: unknown): cause is VpQueryError => {
-  if (cause instanceof VpQueryError) {
-    return true;
-  }
-  if (cause instanceof Error && cause.name === 'AusweisError') {
-    // https://github.com/trpc/trpc/pull/4848
-    return true;
-  }
-
-  return false;
-};
-
-export function getAusweisErrorFromUnknown(cause: unknown): VpQueryError {
-  if (isAusweisError(cause)) {
-    return cause;
-  }
-
-  const ausweisError = new VpQueryError({
-    code: 'INTERNAL_SERVER_ERROR',
-    cause,
-  });
-
-  // Inherit stack from error
-  if (cause instanceof Error && cause.stack) {
-    ausweisError.stack = cause.stack;
-  }
-
-  return ausweisError;
-}
-
-type AUSWEIS_ERROR_CODE =
-  | 'PARSE_ERROR'
-  | 'INTERNAL_SERVER_ERROR'
-  | 'NOT_IMPLEMENTED'
-  | 'BAD_REQUEST';
-
-export class VpQueryError extends Error {
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore override doesn't work in all environments due to "This member cannot have an 'override' modifier because it is not declared in the base class 'Error'"
-  public override readonly cause?: Error;
-  public readonly code;
-
-  constructor(opts: {
-    message?: string;
-    code: AUSWEIS_ERROR_CODE;
-    cause?: unknown;
-  }) {
-    const cause = getCauseFromUnknown(opts.cause);
-    const message = opts.message ?? cause?.message ?? opts.code;
-
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore https://github.com/tc39/proposal-error-cause
-    super(message, { cause });
-
-    this.code = opts.code;
-    this.name = 'AusweisError';
-
-    if (!this.cause) {
-      // < ES2022 / < Node 16.9.0 compatability
-      this.cause = cause;
-    }
-  }
-}
-
-export const NOT_IMPLEMENTED = <Error extends typeof VpQueryError>(input: {
-  message?: string;
-  error?: Error;
-}) => {
-  const { message, error } = input;
-
-  throw new (error ?? VpQueryError)({
-    code: 'NOT_IMPLEMENTED',
-    message: `NOT IMPLEMENTED. ${message}`,
-  });
-};
-
-export class Base64Error extends VpQueryError {
-  constructor(opts: { message: string; cause?: unknown }) {
-    super({ code: 'BAD_REQUEST', ...opts });
-  }
-}

package/src/e-vp-query.ts

@@ -1,31 +0,0 @@
-import { VpQueryError } from './e-base.js';
-
-export class VpQueryCredentialSetError extends VpQueryError {
-  constructor(opts: { message: string; cause?: unknown }) {
-    super({ code: 'BAD_REQUEST', ...opts });
-  }
-}
-
-export class VpQueryUndefinedClaimSetIdError extends VpQueryError {
-  constructor(opts: { message: string; cause?: unknown }) {
-    super({ code: 'BAD_REQUEST', ...opts });
-  }
-}
-
-export class VpQueryNonUniqueCredentialQueryIdsError extends VpQueryError {
-  constructor(opts: { message: string; cause?: unknown }) {
-    super({ code: 'BAD_REQUEST', ...opts });
-  }
-}
-
-export class InvalidClaimsQueryIdError extends VpQueryError {
-  constructor(opts: { message: string; cause?: unknown }) {
-    super({ code: 'BAD_REQUEST', ...opts });
-  }
-}
-
-export class InvalidCredentialQueryIdError extends VpQueryError {
-  constructor(opts: { message: string; cause?: unknown }) {
-    super({ code: 'BAD_REQUEST', ...opts });
-  }
-}

package/src/index.ts

@@ -1,6 +0,0 @@
-export { ClaimsQueryResult } from './claims-query/v-claims-query-result.js';
-export { ClaimsQuery } from './claims-query/v-claims-query.js';
-export { CredentialQueryResult } from './credential-query/v-credential-query-result.js';
-export { CredentialQuery } from './credential-query/v-credential-query.js';
-export { VpQueryResult } from './vp-query/v-vp-query-result.js';
-export { VpQuery } from './vp-query/v-vp-query.js';

package/src/u-query.ts

@@ -1,39 +0,0 @@
-import * as v from 'valibot';
-export const idRegex = /^[a-zA-Z0-9_-]+$/;
-
-export const claimSetIdRegex = /^[a-zA-Z0-9_\-?!]+$/;
-export const credentialSetIdRegex = /^[a-zA-Z0-9_\-?]+$/;
-
-export const vCredentialFormat = v.picklist([
-  'mso_mdoc',
-  'vc+sd-jwt',
-  'jwt_vc_json',
-  'jwt_vc_json-ld',
-]);
-
-export type NonEmpty<T extends unknown[]> = [T[number], ...T];
-
-export namespace Mdoc {
-  export type NameSpaces = Record<string, Record<string, unknown>>;
-  export interface Credential {
-    docType: string;
-    namespaces: NameSpaces;
-  }
-}
-export type Mdoc = Mdoc.Credential;
-
-export const getIdMetadata = (credentialId: string) => {
-  const isOptional = credentialId.endsWith('?');
-  const isRequiredIfPresent = credentialId.endsWith('?!');
-  const baseId = isOptional
-    ? credentialId.slice(0, -1)
-    : isRequiredIfPresent
-      ? credentialId.slice(0, -2)
-      : credentialId;
-
-  return {
-    isOptional,
-    isRequiredIfPresent,
-    baseId,
-  };
-};

package/src/vp-query/v-vp-query-result.ts

@@ -1,23 +0,0 @@
-import * as v from 'valibot';
-import { CredentialQueryResult } from '../credential-query/v-credential-query-result.js';
-import { VpQuery } from './v-vp-query.js';
-
-export namespace VpQueryResult {
-  export const vQueryResult = v.object({
-    areRequiredCredentialsPresent: v.boolean(),
-    credential_set_result: v.array(CredentialQueryResult.vModel),
-  });
-  export type QueryResult = v.InferOutput<typeof vQueryResult>;
-
-  export const vModel = v.object({
-    ...VpQuery.vModel.entries,
-    credential_sets: VpQuery.vModel.entries.credential_sets,
-
-    // The number of vp_query_results matches the number of credential_sets if provided or
-    // is 1 in case credential sets is not present. The indexes match.
-    credential_sets_results: v.array(vQueryResult),
-  });
-  export type Input = v.InferInput<typeof vModel>;
-  export type Out = v.InferOutput<typeof vModel>;
-}
-export type VpQueryResult = VpQueryResult.Out;