@byok-sdk/core 0.29.0 → 0.30.1

package/dist/index.js

@@ -1277,6 +1277,15 @@ async function hpkeOpenBase(input) {
   return hpkeAeadOpen(schedule, 0, input.aad, input.ciphertext);
 }
 
+// src/total-parse.ts
+function safeParseTotal(schema, value) {
+  try {
+    return schema.safeParse(value);
+  } catch {
+    return { success: false };
+  }
+}
+
 // src/sealed-provider-secret.ts
 var PROVIDER_SECRET_HPKE_SUITE = "hpke-base.dhkem-p256-hkdf-sha256.hkdf-sha256.aes-128-gcm";
 var PROVIDER_SECRET_HPKE_INFO = "byok-sdk.provider-secret.v1";
@@ -1363,7 +1372,7 @@ var SealingPublicJwkSchema = z.strictObject({
 });
 var SealingKeyIdSchema = z.string().regex(new RegExp(`^[A-Za-z0-9_-]{${SEALING_KEY_ID_LENGTH}}$`));
 function parseSealingPublicJwk(input) {
-  const result = SealingPublicJwkSchema.safeParse(input);
+  const result = safeParseTotal(SealingPublicJwkSchema, input);
   if (!result.success) {
     throw new ByokCoreError("sealed_secret_invalid", "Sealing public key must be a strict P-256 EC public JWK");
   }
@@ -1389,7 +1398,7 @@ var SealingKeyClaimV1Schema = z.strictObject({
   publicJwk: SealingPublicJwkSchema
 });
 function sealingKeyClaimCanonicalBytes(claim) {
-  const result = SealingKeyClaimV1Schema.safeParse(claim);
+  const result = safeParseTotal(SealingKeyClaimV1Schema, claim);
   if (!result.success) {
     throw new ByokCoreError("sealed_secret_invalid", "Sealing key claim is invalid");
   }
@@ -1486,11 +1495,11 @@ var ProviderProvisioningRequestV1Schema = z.strictObject({
   }
 });
 function parseProviderProvisioningRequest(input) {
-  const result = ProviderProvisioningRequestV1Schema.safeParse(input);
+  const result = safeParseTotal(ProviderProvisioningRequestV1Schema, input);
   if (!result.success) {
     throw new ByokCoreError(
       "provider_provisioning_request_invalid",
-      `Invalid provider provisioning request: ${result.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ")}`
+      `Invalid provider provisioning request: ${(result.error?.issues ?? [{ path: [], message: "is not readable" }]).map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ")}`
     );
   }
   return result.data;
@@ -1499,15 +1508,15 @@ function configJson(config) {
   return config;
 }
 async function providerProvisioningConfigDigest(config) {
-  const result = ProviderProvisioningConfigV1Schema.safeParse(config);
+  const result = safeParseTotal(ProviderProvisioningConfigV1Schema, config);
   if (!result.success) {
     throw new ByokCoreError("provider_provisioning_request_invalid", "Provider provisioning config is invalid");
   }
   return contentDigest(configJson(result.data));
 }
 function providerSecretAadBytes(header, keyId) {
-  const parsed = ProviderProvisioningHeaderV1Schema.safeParse(header);
-  if (!parsed.success || !SealingKeyIdSchema.safeParse(keyId).success) {
+  const parsed = safeParseTotal(ProviderProvisioningHeaderV1Schema, header);
+  if (!parsed.success || !safeParseTotal(SealingKeyIdSchema, keyId).success) {
     throw new ByokCoreError("provider_provisioning_request_invalid", "Provider provisioning AAD input is invalid");
   }
   const value = parsed.data;
@@ -1575,12 +1584,12 @@ function unpadProviderSecret(padded) {
 }
 var INFO_BYTES = () => new TextEncoder().encode(PROVIDER_SECRET_HPKE_INFO);
 async function sealProviderProvisioningRequest(input) {
-  const configResult = ProviderProvisioningConfigV1Schema.safeParse(input.config);
+  const configResult = safeParseTotal(ProviderProvisioningConfigV1Schema, input.config);
   if (!configResult.success) {
     throw new ByokCoreError("provider_provisioning_request_invalid", "Provider provisioning config is invalid");
   }
   const config = configResult.data;
-  const headerResult = ProviderProvisioningHeaderV1Schema.safeParse({
+  const headerResult = safeParseTotal(ProviderProvisioningHeaderV1Schema, {
     ...input.header,
     configDigest: await providerProvisioningConfigDigest(config)
   });