dcql 0.2.2

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "dcql",
+  "description": "Digital Credentials Query Language (DCQL)",
+  "author": "Martin Auer",
+  "version": "0.2.2",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./dist/src/index.js"
+    }
+  },
+  "license": "MIT",
+  "dependencies": {
+    "valibot": "0.37.0"
+  },
+  "devDependencies": {
+    "@ausweis/eslint": "^0.2.34",
+    "@ausweis/prettier": "^0.2.34",
+    "@ausweis/typescript": "^0.2.34",
+    "@types/node": "^20.16.10",
+    "eslint": "^9.9.0",
+    "prettier": "^3.3.3",
+    "tsx": "^4.11.2",
+    "typescript": "^5.6.2"
+  },
+  "prettier": "@ausweis/prettier",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/auer-martin/vp-query"
+  },
+  "keywords": [
+    "Digital Credentials Query Language (DCQL)",
+    "Credentials Query Language",
+    "Verifiable Presentation Query Language",
+    "Verifiable Presentations",
+    "Presentation Definition",
+    "Credentials",
+    "SSI",
+    "OpenID",
+    "SIOP",
+    "Self Issued OpenId Provider",
+    "OpenId for Verifiable Presentations",
+    "SIOPv2",
+    "OID4VC",
+    "OID4VP",
+    "OpenID4VP",
+    "OpenID4VC",
+    "OIDC4VP"
+  ],
+  "scripts": {
+    "clean": "git clean -xdf .cache .turbo node_modules dist",
+    "build": "tsc",
+    "format": "prettier --check . --ignore-path ./../.gitignore",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit",
+    "test": "tsx --test"
+  }
+}

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

@@ -0,0 +1,104 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,130 @@
+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

@@ -0,0 +1,71 @@
+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

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1,116 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,6 @@
+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';