dcql 0.4.2 → 0.5.0-alpha-20250718124032

package/dist/index.mjs

@@ -113,6 +113,12 @@ import * as v2 from "valibot";
 // src/u-dcql.ts
 import * as v from "valibot";
 var idRegex = /^[a-zA-Z0-9_-]+$/;
+function asNonEmptyArrayOrUndefined(array8) {
+  return array8.length > 0 ? array8 : void 0;
+}
+function isNonEmptyArray(array8) {
+  return array8.length > 0;
+}
 var vNonEmptyArray = (item) => {
   return v.pipe(
     v.array(item),
@@ -646,17 +652,17 @@ var runClaimsQuery = (credentialQuery, ctx) => {
   if (!credentialQuery.claims) {
     return {
       success: true,
-      valid_claims: [],
-      failed_claims: [],
+      valid_claims: void 0,
+      failed_claims: void 0,
       valid_claim_sets: [
         {
           claim_set_index: void 0,
           output: {},
           success: true,
-          valid_claim_indexes: []
+          valid_claim_indexes: void 0
         }
       ],
-      failed_claim_sets: []
+      failed_claim_sets: void 0
     };
   }
   const failedClaims = [];
@@ -708,7 +714,7 @@ var runClaimsQuery = (credentialQuery, ctx) => {
         success: true,
         claim_set_index: claimSetIndex,
         output,
-        valid_claim_indexes: claims.map((claim) => claim.claim_index)
+        valid_claim_indexes: asNonEmptyArrayOrUndefined(claims.map((claim) => claim.claim_index))
       });
     } else {
       const issues = failedClaims.reduce((merged, claim) => deepMerge(claim.issues, merged), {});
@@ -717,24 +723,26 @@ var runClaimsQuery = (credentialQuery, ctx) => {
         issues,
         claim_set_index: claimSetIndex,
         failed_claim_indexes: claims.filter((claim) => !claim.success).map((claim) => claim.claim_index),
-        valid_claim_indexes: claims.filter((claim) => claim.success).map((claim) => claim.claim_index)
+        valid_claim_indexes: asNonEmptyArrayOrUndefined(
+          claims.filter((claim) => claim.success).map((claim) => claim.claim_index)
+        )
       });
     }
   }
-  if (validClaimSets.length === 0) {
+  if (isNonEmptyArray(validClaimSets)) {
     return {
-      success: false,
-      failed_claim_sets: failedClaimSets,
-      failed_claims: failedClaims.map(({ parser, ...rest }) => rest),
-      valid_claims: validClaims.map(({ parser, ...rest }) => rest)
+      success: true,
+      failed_claim_sets: asNonEmptyArrayOrUndefined(failedClaimSets),
+      valid_claim_sets: validClaimSets,
+      valid_claims: asNonEmptyArrayOrUndefined(validClaims.map(({ parser, ...rest }) => rest)),
+      failed_claims: asNonEmptyArrayOrUndefined(failedClaims.map(({ parser, ...rest }) => rest))
     };
   }
   return {
-    success: true,
+    success: false,
     failed_claim_sets: failedClaimSets,
-    valid_claim_sets: validClaimSets,
-    valid_claims: validClaims.map(({ parser, ...rest }) => rest),
-    failed_claims: failedClaims.map(({ parser, ...rest }) => rest)
+    failed_claims: failedClaims.map(({ parser, ...rest }) => rest),
+    valid_claims: asNonEmptyArrayOrUndefined(validClaims.map(({ parser, ...rest }) => rest))
   };
 };
 
@@ -839,7 +847,7 @@ var runTrustedAuthoritiesQuery = (credentialQuery, credential) => {
           trusted_authority_index: trustedAuthorityIndex,
           output: parseResult.output
         },
-        failed_trusted_authorities: failedTrustedAuthorities
+        failed_trusted_authorities: asNonEmptyArrayOrUndefined(failedTrustedAuthorities)
       };
     }
     const issues = v9.flatten(parseResult.issues);
@@ -859,12 +867,6 @@ var runTrustedAuthoritiesQuery = (credentialQuery, credential) => {
 // src/dcql-parser/dcql-credential-query-result.ts
 var runCredentialQuery = (credentialQuery, ctx) => {
   const { credentials, presentation } = ctx;
-  if (ctx.credentials.length === 0) {
-    throw new DcqlError({
-      message: "Credentials array provided to credential query has length of 0, unable to match credentials against credential query.",
-      code: "BAD_REQUEST"
-    });
-  }
   const validCredentials = [];
   const failedCredentials = [];
   for (const [credentialIndex, credential] of credentials.entries()) {
@@ -889,21 +891,20 @@ var runCredentialQuery = (credentialQuery, ctx) => {
       });
     }
   }
-  if (!validCredentials.length) {
+  if (isNonEmptyArray(validCredentials)) {
     return {
-      success: false,
+      success: true,
       credential_query_id: credentialQuery.id,
-      // We now for sure that there's at least one invalid credential if there's no valid one.
-      failed_credentials: failedCredentials,
-      valid_credentials: void 0
+      failed_credentials: asNonEmptyArrayOrUndefined(failedCredentials),
+      valid_credentials: validCredentials
     };
   }
   return {
-    success: true,
+    success: false,
     credential_query_id: credentialQuery.id,
-    failed_credentials: failedCredentials,
-    // We now for sure that there's at least one valid credential due to the length check
-    valid_credentials: validCredentials
+    // Can be undefined if no credentials were provided to the query
+    failed_credentials: asNonEmptyArrayOrUndefined(failedCredentials),
+    valid_credentials: void 0
   };
 };
 
@@ -1094,7 +1095,7 @@ var DcqlClaimsResult;
     claim_set_index: v12.union([v12.number(), v12.undefined()]),
     // We use indexes because if there are no claim sets, the ids can be undefined
     // Can be empty array in case there are no claims
-    valid_claim_indexes: v12.array(v12.number()),
+    valid_claim_indexes: v12.optional(vNonEmptyArray(v12.number())),
     failed_claim_indexes: v12.optional(v12.undefined()),
     output: vClaimsOutput
   });
@@ -1103,20 +1104,20 @@ var DcqlClaimsResult;
     // Undefined in case of no claim set
     claim_set_index: v12.union([v12.number(), v12.undefined()]),
     // We use indexes because if there are no claim sets, the ids can be undefined
-    valid_claim_indexes: v12.array(v12.number()),
+    valid_claim_indexes: v12.optional(vNonEmptyArray(v12.number())),
     failed_claim_indexes: vNonEmptyArray(v12.number()),
     issues: v12.record(v12.string(), v12.unknown())
   });
   DcqlClaimsResult2.vClaimsSuccessResult = v12.object({
     success: v12.literal(true),
-    valid_claims: v12.array(DcqlClaimsResult2.vClaimsEntrySuccessResult),
-    failed_claims: v12.array(DcqlClaimsResult2.vClaimsEntryFailureResult),
+    valid_claims: v12.optional(vNonEmptyArray(DcqlClaimsResult2.vClaimsEntrySuccessResult)),
+    failed_claims: v12.optional(vNonEmptyArray(DcqlClaimsResult2.vClaimsEntryFailureResult)),
     valid_claim_sets: vNonEmptyArray(DcqlClaimsResult2.vClaimSetSuccessResult),
-    failed_claim_sets: v12.array(DcqlClaimsResult2.vClaimSetFailureResult)
+    failed_claim_sets: v12.optional(vNonEmptyArray(DcqlClaimsResult2.vClaimSetFailureResult))
   });
   DcqlClaimsResult2.vClaimsFailureResult = v12.object({
     success: v12.literal(false),
-    valid_claims: v12.array(DcqlClaimsResult2.vClaimsEntrySuccessResult),
+    valid_claims: v12.optional(vNonEmptyArray(DcqlClaimsResult2.vClaimsEntrySuccessResult)),
     failed_claims: vNonEmptyArray(DcqlClaimsResult2.vClaimsEntryFailureResult),
     valid_claim_sets: v12.optional(v12.undefined()),
     failed_claim_sets: vNonEmptyArray(DcqlClaimsResult2.vClaimSetFailureResult)
@@ -1169,7 +1170,7 @@ var DcqlTrustedAuthoritiesResult;
     v14.object({
       success: v14.literal(true),
       valid_trusted_authority: DcqlTrustedAuthoritiesResult2.vTrustedAuthorityEntrySuccessResult,
-      failed_trusted_authorities: v14.array(DcqlTrustedAuthoritiesResult2.vTrustedAuthorityEntryFailureResult)
+      failed_trusted_authorities: v14.optional(vNonEmptyArray(DcqlTrustedAuthoritiesResult2.vTrustedAuthorityEntryFailureResult))
     })
   ]);
   DcqlTrustedAuthoritiesResult2.vTrustedAuthorityFailureResult = v14.object({
@@ -1203,13 +1204,13 @@ var DcqlQueryResult;
       success: v15.literal(true),
       credential_query_id: vIdString,
       valid_credentials: vNonEmptyArray(DcqlQueryResult2.vCredentialQueryItemCredentialSuccessResult),
-      failed_credentials: v15.array(DcqlQueryResult2.vCredentialQueryItemCredentialFailureResult)
+      failed_credentials: v15.optional(vNonEmptyArray(DcqlQueryResult2.vCredentialQueryItemCredentialFailureResult))
     }),
     v15.object({
       success: v15.literal(false),
       credential_query_id: vIdString,
       valid_credentials: v15.optional(v15.undefined()),
-      failed_credentials: vNonEmptyArray(DcqlQueryResult2.vCredentialQueryItemCredentialFailureResult)
+      failed_credentials: v15.optional(vNonEmptyArray(DcqlQueryResult2.vCredentialQueryItemCredentialFailureResult))
     })
   ]);
   DcqlQueryResult2.vCredentialQueryResult = v15.record(vIdString, DcqlQueryResult2.vCredentialQueryItemResult);
@@ -1285,7 +1286,7 @@ var DcqlPresentationResult;
     const dqclQueryMatched = (
       // We require that all the submitted presentations match with the queries
       // So we must have success for all queries, and we don't allow failed_credentials
-      queriesResults.every((result) => result.success && result.failed_credentials.length === 0) && (credentialSetResults ? credentialSetResults.every((set) => !set.required || set.matching_options) : (
+      queriesResults.every((result) => result.success && !result.failed_credentials) && (credentialSetResults ? credentialSetResults.every((set) => !set.required || set.matching_options) : (
         // If not credential_sets are used, we require that at least every credential has a match
         dcqlQuery.credentials.every(
           (credentialQuery) => queriesResults.find((result) => result.credential_query_id === credentialQuery.id)?.success