chore(stack): upgrade @byteslice/result 0.2 → 0.5

.changeset/byteslice-result-0-5.md

@@ -0,0 +1,5 @@
+---
+'@cipherstash/stack': minor
+---
+
+Upgrade `@byteslice/result` to 0.5.0. Its `FailureOption` no longer accepts a bare `{ type }` shape — a failure must be an `Error` or carry an `error: Error`. `EncryptionError` now includes a required `error: Error` holding the originating error, and all failures are built through the new `toEncryptionError(type, error, code?)` factory (which coerces any caught value to a real `Error`). The existing `type` / `message` / `code` fields are unchanged, so code that reads `result.failure.type` / `.message` / `.code` keeps working.

packages/stack/package.json

@@ -242,7 +242,7 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@byteslice/result": "0.2.0",
+		"@byteslice/result": "0.5.0",
 		"@cipherstash/auth": "catalog:repo",
 		"@cipherstash/protect-ffi": "0.28.0",
 		"evlog": "1.11.0",

packages/stack/src/encryption/helpers/validation.ts

@@ -1,5 +1,9 @@
 import type { Result } from '@byteslice/result'
-import { type EncryptionError, EncryptionErrorTypes } from '@/errors'
+import {
+  type EncryptionError,
+  EncryptionErrorTypes,
+  toEncryptionError,
+} from '@/errors'
 import type { FfiIndexTypeName } from '@/types'
 
 /**
@@ -16,18 +20,18 @@ export function validateNumericValue(
 ): Result<never, EncryptionError> | undefined {
   if (typeof value === 'number' && Number.isNaN(value)) {
     return {
-      failure: {
-        type: EncryptionErrorTypes.EncryptionError,
-        message: '[encryption]: Cannot encrypt NaN value',
-      },
+      failure: toEncryptionError(
+        EncryptionErrorTypes.EncryptionError,
+        new Error('[encryption]: Cannot encrypt NaN value'),
+      ),
     }
   }
   if (typeof value === 'number' && !Number.isFinite(value)) {
     return {
-      failure: {
-        type: EncryptionErrorTypes.EncryptionError,
-        message: '[encryption]: Cannot encrypt Infinity value',
-      },
+      failure: toEncryptionError(
+        EncryptionErrorTypes.EncryptionError,
+        new Error('[encryption]: Cannot encrypt Infinity value'),
+      ),
     }
   }
   return undefined
@@ -64,10 +68,12 @@ export function validateValueIndexCompatibility(
 ): Result<never, EncryptionError> | undefined {
   if (typeof value === 'number' && indexType === 'match') {
     return {
-      failure: {
-        type: EncryptionErrorTypes.EncryptionError,
-        message: `[encryption]: Cannot use 'match' index with numeric value on column "${columnName}". The 'freeTextSearch' index only supports string values. Configure the column with 'orderAndRange()' or 'equality()' for numeric queries.`,
-      },
+      failure: toEncryptionError(
+        EncryptionErrorTypes.EncryptionError,
+        new Error(
+          `[encryption]: Cannot use 'match' index with numeric value on column "${columnName}". The 'freeTextSearch' index only supports string values. Configure the column with 'orderAndRange()' or 'equality()' for numeric queries.`,
+        ),
+      ),
     }
   }
   return undefined

packages/stack/src/encryption/index.ts

@@ -1,7 +1,11 @@
 import { type Result, withResult } from '@byteslice/result'
 import { newClient } from '@cipherstash/protect-ffi'
 import { validate as uuidValidate } from 'uuid'
-import { type EncryptionError, EncryptionErrorTypes } from '@/errors'
+import {
+  type EncryptionError,
+  EncryptionErrorTypes,
+  toEncryptionError,
+} from '@/errors'
 // `LockContext` is imported type-only so the TSDoc {@link} references in the
 // comments below resolve; it is erased at compile time.
 import type { LockContext } from '@/identity'
@@ -172,10 +176,8 @@ export class EncryptionClient {
         logger.debug('Successfully initialized the Encryption client.')
         return this
       },
-      (error: unknown) => ({
-        type: EncryptionErrorTypes.ClientInitError,
-        message: (error as Error).message,
-      }),
+      (error: unknown) =>
+        toEncryptionError(EncryptionErrorTypes.ClientInitError, error),
     )
   }
 

packages/stack/src/encryption/operations/batch-encrypt-query.ts

@@ -11,7 +11,11 @@ import {
 } from '@cipherstash/protect-ffi'
 import { formatEncryptedResult } from '@/encryption/helpers'
 import { getErrorCode } from '@/encryption/helpers/error-code'
-import { type EncryptionError, EncryptionErrorTypes } from '@/errors'
+import {
+  type EncryptionError,
+  EncryptionErrorTypes,
+  toEncryptionError,
+} from '@/errors'
 import {
   type Context,
   type LockContextInput,
@@ -162,11 +166,11 @@ export class BatchEncryptQueryOperation extends EncryptionOperation<
       },
       (error: unknown) => {
         log.set({ errorCode: getErrorCode(error) ?? 'unknown' })
-        return {
-          type: EncryptionErrorTypes.EncryptionError,
-          message: (error as Error).message,
-          code: getErrorCode(error),
-        }
+        return toEncryptionError(
+          EncryptionErrorTypes.EncryptionError,
+          error,
+          getErrorCode(error),
+        )
       },
     )
     log.emit()
@@ -230,11 +234,11 @@ export class BatchEncryptQueryOperationWithLockContext extends EncryptionOperati
       },
       (error: unknown) => {
         log.set({ errorCode: getErrorCode(error) ?? 'unknown' })
-        return {
-          type: EncryptionErrorTypes.EncryptionError,
-          message: (error as Error).message,
-          code: getErrorCode(error),
-        }
+        return toEncryptionError(
+          EncryptionErrorTypes.EncryptionError,
+          error,
+          getErrorCode(error),
+        )
       },
     )
     log.emit()

packages/stack/src/encryption/operations/bulk-decrypt-models.ts

@@ -1,6 +1,10 @@
 import { type Result, withResult } from '@byteslice/result'
 import { getErrorCode } from '@/encryption/helpers/error-code'
-import { type EncryptionError, EncryptionErrorTypes } from '@/errors'
+import {
+  type EncryptionError,
+  EncryptionErrorTypes,
+  toEncryptionError,
+} from '@/errors'
 import { type LockContextInput, resolveLockContext } from '@/identity'
 import type { Client, Decrypted } from '@/types'
 import { createRequestLogger } from '@/utils/logger'
@@ -49,11 +53,11 @@ export class BulkDecryptModelsOperation<
       },
       (error: unknown) => {
         log.set({ errorCode: getErrorCode(error) ?? 'unknown' })
-        return {
-          type: EncryptionErrorTypes.DecryptionError,
-          message: (error as Error).message,
-          code: getErrorCode(error),
-        }
+        return toEncryptionError(
+          EncryptionErrorTypes.DecryptionError,
+          error,
+          getErrorCode(error),
+        )
       },
     )
     log.emit()
@@ -119,11 +123,11 @@ export class BulkDecryptModelsOperationWithLockContext<
       },
       (error: unknown) => {
         log.set({ errorCode: getErrorCode(error) ?? 'unknown' })
-        return {
-          type: EncryptionErrorTypes.DecryptionError,
-          message: (error as Error).message,
-          code: getErrorCode(error),
-        }
+        return toEncryptionError(
+          EncryptionErrorTypes.DecryptionError,
+          error,
+          getErrorCode(error),
+        )
       },
     )
     log.emit()

packages/stack/src/encryption/operations/bulk-decrypt.ts

@@ -5,7 +5,11 @@ import {
   decryptBulkFallible,
 } from '@cipherstash/protect-ffi'
 import { getErrorCode } from '@/encryption/helpers/error-code'
-import { type EncryptionError, EncryptionErrorTypes } from '@/errors'
+import {
+  type EncryptionError,
+  EncryptionErrorTypes,
+  toEncryptionError,
+} from '@/errors'
 import {
   type Context,
   type LockContextInput,
@@ -104,11 +108,11 @@ export class BulkDecryptOperation extends EncryptionOperation<BulkDecryptedData>
       },
       (error: unknown) => {
         log.set({ errorCode: getErrorCode(error) ?? 'unknown' })
-        return {
-          type: EncryptionErrorTypes.DecryptionError,
-          message: (error as Error).message,
-          code: getErrorCode(error),
-        }
+        return toEncryptionError(
+          EncryptionErrorTypes.DecryptionError,
+          error,
+          getErrorCode(error),
+        )
       },
     )
     log.emit()
@@ -177,11 +181,11 @@ export class BulkDecryptOperationWithLockContext extends EncryptionOperation<Bul
       },
       (error: unknown) => {
         log.set({ errorCode: getErrorCode(error) ?? 'unknown' })
-        return {
-          type: EncryptionErrorTypes.DecryptionError,
-          message: (error as Error).message,
-          code: getErrorCode(error),
-        }
+        return toEncryptionError(
+          EncryptionErrorTypes.DecryptionError,
+          error,
+          getErrorCode(error),
+        )
       },
     )
     log.emit()

packages/stack/src/encryption/operations/bulk-encrypt-models.ts

@@ -1,6 +1,10 @@
 import { type Result, withResult } from '@byteslice/result'
 import { getErrorCode } from '@/encryption/helpers/error-code'
-import { type EncryptionError, EncryptionErrorTypes } from '@/errors'
+import {
+  type EncryptionError,
+  EncryptionErrorTypes,
+  toEncryptionError,
+} from '@/errors'
 import { type LockContextInput, resolveLockContext } from '@/identity'
 import type { BuildableTable, Client } from '@/types'
 import { createRequestLogger } from '@/utils/logger'
@@ -61,11 +65,11 @@ export class BulkEncryptModelsOperation<
       },
       (error: unknown) => {
         log.set({ errorCode: getErrorCode(error) ?? 'unknown' })
-        return {
-          type: EncryptionErrorTypes.EncryptionError,
-          message: (error as Error).message,
-          code: getErrorCode(error),
-        }
+        return toEncryptionError(
+          EncryptionErrorTypes.EncryptionError,
+          error,
+          getErrorCode(error),
+        )
       },
     )
     log.emit()
@@ -135,11 +139,11 @@ export class BulkEncryptModelsOperationWithLockContext<
       },
       (error: unknown) => {
         log.set({ errorCode: getErrorCode(error) ?? 'unknown' })
-        return {
-          type: EncryptionErrorTypes.EncryptionError,
-          message: (error as Error).message,
-          code: getErrorCode(error),
-        }
+        return toEncryptionError(
+          EncryptionErrorTypes.EncryptionError,
+          error,
+          getErrorCode(error),
+        )
       },
     )
     log.emit()

packages/stack/src/encryption/operations/bulk-encrypt.ts

@@ -1,7 +1,11 @@
 import { type Result, withResult } from '@byteslice/result'
 import { encryptBulk, type JsPlaintext } from '@cipherstash/protect-ffi'
 import { getErrorCode } from '@/encryption/helpers/error-code'
-import { type EncryptionError, EncryptionErrorTypes } from '@/errors'
+import {
+  type EncryptionError,
+  EncryptionErrorTypes,
+  toEncryptionError,
+} from '@/errors'
 import {
   type Context,
   type LockContextInput,
@@ -124,11 +128,11 @@ export class BulkEncryptOperation extends EncryptionOperation<BulkEncryptedData>
       },
       (error: unknown) => {
         log.set({ errorCode: getErrorCode(error) ?? 'unknown' })
-        return {
-          type: EncryptionErrorTypes.EncryptionError,
-          message: (error as Error).message,
-          code: getErrorCode(error),
-        }
+        return toEncryptionError(
+          EncryptionErrorTypes.EncryptionError,
+          error,
+          getErrorCode(error),
+        )
       },
     )
     log.emit()
@@ -209,11 +213,11 @@ export class BulkEncryptOperationWithLockContext extends EncryptionOperation<Bul
       },
       (error: unknown) => {
         log.set({ errorCode: getErrorCode(error) ?? 'unknown' })
-        return {
-          type: EncryptionErrorTypes.EncryptionError,
-          message: (error as Error).message,
-          code: getErrorCode(error),
-        }
+        return toEncryptionError(
+          EncryptionErrorTypes.EncryptionError,
+          error,
+          getErrorCode(error),
+        )
       },
     )
     log.emit()

packages/stack/src/encryption/operations/decrypt-model.ts

@@ -1,6 +1,10 @@
 import { type Result, withResult } from '@byteslice/result'
 import { getErrorCode } from '@/encryption/helpers/error-code'
-import { type EncryptionError, EncryptionErrorTypes } from '@/errors'
+import {
+  type EncryptionError,
+  EncryptionErrorTypes,
+  toEncryptionError,
+} from '@/errors'
 import { type LockContextInput, resolveLockContext } from '@/identity'
 import type { Client, Decrypted } from '@/types'
 import { createRequestLogger } from '@/utils/logger'
@@ -48,11 +52,11 @@ export class DecryptModelOperation<
       },
       (error: unknown) => {
         log.set({ errorCode: getErrorCode(error) ?? 'unknown' })
-        return {
-          type: EncryptionErrorTypes.DecryptionError,
-          message: (error as Error).message,
-          code: getErrorCode(error),
-        }
+        return toEncryptionError(
+          EncryptionErrorTypes.DecryptionError,
+          error,
+          getErrorCode(error),
+        )
       },
     )
     log.emit()
@@ -117,11 +121,11 @@ export class DecryptModelOperationWithLockContext<
       },
       (error: unknown) => {
         log.set({ errorCode: getErrorCode(error) ?? 'unknown' })
-        return {
-          type: EncryptionErrorTypes.DecryptionError,
-          message: (error as Error).message,
-          code: getErrorCode(error),
-        }
+        return toEncryptionError(
+          EncryptionErrorTypes.DecryptionError,
+          error,
+          getErrorCode(error),
+        )
       },
     )
     log.emit()