Replace type casts with orThrow

Casting is code smell

Author: steida

packages/common/src/Buffer.ts

@@ -116,10 +116,10 @@ export const createBuffer = (
   let value = arrayLike
     ? new globalThis.Uint8Array(arrayLike)
     : new globalThis.Uint8Array(512);
-  let length = (arrayLike ? arrayLike.length : 0) as NonNegativeInt;
+  let length = NonNegativeInt.orThrow(arrayLike ? arrayLike.length : 0);
 
   const buffer: Buffer = {
-    getCapacity: () => value.length as NonNegativeInt,
+    getCapacity: () => NonNegativeInt.orThrow(value.length),
 
     getLength: () => length,
 
@@ -132,7 +132,7 @@ export const createBuffer = (
         value.set(oldValue);
       }
       value.set(arg, length);
-      length = (length + arg.length) as NonNegativeInt;
+      length = NonNegativeInt.orThrow(length + arg.length);
     },
 
     shift: () => {
@@ -142,7 +142,7 @@ export const createBuffer = (
       const first = value[0];
       value = value.subarray(1);
       length--;
-      return first as NonNegativeInt;
+      return NonNegativeInt.orThrow(first);
     },
 
     shiftN: (n) => {
@@ -151,7 +151,7 @@ export const createBuffer = (
       }
       const subarray = value.subarray(0, n);
       value = value.subarray(n);
-      length = (length - n) as NonNegativeInt;
+      length = NonNegativeInt.orThrow(length - n);
       return subarray;
     },
 
@@ -165,7 +165,7 @@ export const createBuffer = (
     },
 
     reset: () => {
-      length = 0 as NonNegativeInt;
+      length = NonNegativeInt.orThrow(0);
     },
 
     unwrap: () => value.subarray(0, length),

packages/common/src/Crypto.ts

@@ -176,20 +176,20 @@ export const createSymmetricCrypto = (
  * https://bford.info/pub/sec/purb.pdf
  */
 export const padmePaddedLength = (length: NonNegativeInt): NonNegativeInt => {
-  if (length <= 0) return 0 as NonNegativeInt;
+  if (length <= 0) return NonNegativeInt.orThrow(0);
   const e = 31 - Math.clz32(length >>> 0);
   const s = 32 - Math.clz32(e >>> 0);
   const z = Math.max(0, e - s);
   const mask = (1 << z) - 1;
-  return ((length + mask) & ~mask) as NonNegativeInt;
+  return NonNegativeInt.orThrow((length + mask) & ~mask);
 };
 
 /**
  * Returns the PADMÉ padding length for a given input length. Uses
  * {@link padmePaddedLength}.
  */
 export const padmePaddingLength = (length: NonNegativeInt): NonNegativeInt => {
-  return (padmePaddedLength(length) - length) as NonNegativeInt;
+  return NonNegativeInt.orThrow(padmePaddedLength(length) - length);
 };
 
 /**

packages/common/src/Evolu/Owner.ts

@@ -73,7 +73,7 @@ export const ownerIdToOwnerIdBytes = (ownerId: OwnerId): OwnerIdBytes =>
 export const ownerIdBytesToOwnerId = (ownerIdBytes: OwnerIdBytes): OwnerId =>
   idBytesToId(ownerIdBytes as IdBytes) as OwnerId;
 
-export const ownerWriteKeyLength = 16 as NonNegativeInt;
+export const ownerWriteKeyLength = NonNegativeInt.orThrow(16);
 
 export const OwnerEncryptionKey = brand("OwnerEncryptionKey", EncryptionKey);
 export type OwnerEncryptionKey = typeof OwnerEncryptionKey.Type;

packages/common/src/Evolu/Protocol.ts

@@ -325,7 +325,7 @@ export const defaultProtocolMessageRangesMaxSize =
 export type ProtocolMessage = Uint8Array & Brand<"ProtocolMessage">;
 
 /** Evolu Protocol version. */
-export const protocolVersion = 0 as NonNegativeInt;
+export const protocolVersion = NonNegativeInt.orThrow(0);
 
 export const MessageType = {
   /** Request message from initiator (client) to non-initiator (relay). */
@@ -525,7 +525,7 @@ export const createProtocolMessageForSync =
 
     splitRange(deps)(
       ownerIdBytes,
-      0 as NonNegativeInt,
+      NonNegativeInt.orThrow(0),
       size,
       InfiniteUpperBound,
       buffer,
@@ -628,7 +628,7 @@ export const createProtocolMessageBuffer = (
   const isWithinSizeLimits = () => getSize() <= totalMaxSize;
 
   const getSize = () =>
-    (getHeaderAndMessagesSize() + getRangesSize()) as PositiveInt;
+    PositiveInt.orThrow(getHeaderAndMessagesSize() + getRangesSize());
 
   const getHeaderAndMessagesSize = () =>
     buffers.header.getLength() +
@@ -726,7 +726,10 @@ export const createProtocolMessageBuffer = (
         buffers.ranges.timestamps.addInfinite();
       }
 
-      encodeNonNegativeInt(buffers.ranges.types, range.type as NonNegativeInt);
+      encodeNonNegativeInt(
+        buffers.ranges.types,
+        NonNegativeInt.orThrow(range.type),
+      );
 
       switch (range.type) {
         case RangeType.Skip:
@@ -781,7 +784,7 @@ export interface TimestampsBuffer {
 }
 
 export const createTimestampsBuffer = (): TimestampsBuffer => {
-  let count = 0 as NonNegativeInt;
+  let count = NonNegativeInt.orThrow(0);
   const countBuffer = createBuffer();
 
   const syncCount = () => {
@@ -848,9 +851,9 @@ const createRunLengthEncoder = <T>(
   encodeValue: (buffer: Buffer, value: T) => void,
 ): RunLengthEncoder<T> => {
   const buffer = createBuffer();
-  let previousLength = 0 as NonNegativeInt;
+  let previousLength = NonNegativeInt.orThrow(0);
   let previousValue = null as T | null;
-  let runLength = 0 as NonNegativeInt;
+  let runLength = NonNegativeInt.orThrow(0);
 
   return {
     add: (value) => {
@@ -859,7 +862,7 @@ const createRunLengthEncoder = <T>(
         buffer.truncate(previousLength);
       } else {
         previousValue = value;
-        runLength = 1 as NonNegativeInt;
+        runLength = NonNegativeInt.orThrow(1);
       }
       previousLength = buffer.getLength();
       encodeValue(buffer, value);
@@ -1255,7 +1258,7 @@ const sync =
     if (storageSize == null) return err(ProtocolErrorCode.SyncError);
 
     let prevUpperBound: RangeUpperBound | null = null;
-    let prevIndex = 0 as NonNegativeInt;
+    let prevIndex = NonNegativeInt.orThrow(0);
 
     let skip = false;
     let nonSkipRangeAdded = false;
@@ -1458,7 +1461,7 @@ const splitRange =
     upperBound: RangeUpperBound,
     buffer: ProtocolMessageBuffer,
   ): void => {
-    const itemCount = (upper - lower) as NonNegativeInt;
+    const itemCount = NonNegativeInt.orThrow(upper - lower);
     const buckets = computeBalancedBuckets(itemCount);
 
     if (!buckets.ok) {
@@ -1470,7 +1473,7 @@ const splitRange =
 
       deps.storage.iterate(
         ownerId,
-        0 as NonNegativeInt,
+        NonNegativeInt.orThrow(0),
         itemCount,
         (timestamp) => {
           range.timestamps.add(timestampBytesToTimestamp(timestamp));
@@ -1486,7 +1489,10 @@ const splitRange =
     const fingerprintRangesBuckets =
       lower === 0
         ? buckets.value
-        : [lower, ...buckets.value.map((b) => (b + lower) as NonNegativeInt)];
+        : [
+            lower,
+            ...buckets.value.map((b) => NonNegativeInt.orThrow(b + lower)),
+          ];
 
     const fingerprintRanges = deps.storage.fingerprintRanges(
       ownerId,
@@ -1510,7 +1516,7 @@ const decodeRanges = (buffer: Buffer): ReadonlyArray<Range> => {
   const rangesCount = decodeNonNegativeInt(buffer);
   if (rangesCount === 0) return [];
 
-  const timestampsCount = (rangesCount - 1) as NonNegativeInt;
+  const timestampsCount = NonNegativeInt.orThrow(rangesCount - 1);
   const timestamps = decodeTimestamps(buffer, timestampsCount);
   const rangeTypes: Array<RangeType> = [];
 
@@ -1845,7 +1851,7 @@ export const decodeNonNegativeInt = (buffer: Buffer): NonNegativeInt => {
 };
 
 export const encodeLength = (buffer: Buffer, value: ArrayLike<any>): void => {
-  encodeNonNegativeInt(buffer, value.length as NonNegativeInt);
+  encodeNonNegativeInt(buffer, NonNegativeInt.orThrow(value.length));
 };
 
 export const decodeLength = decodeNonNegativeInt;
@@ -1867,7 +1873,7 @@ export const encodeNodeId = (buffer: Buffer, nodeId: NodeId): void => {
 };
 
 export const decodeNodeId = (buffer: Buffer): NodeId => {
-  const bytes = buffer.shiftN(8 as NonNegativeInt);
+  const bytes = buffer.shiftN(NonNegativeInt.orThrow(8));
   return bytesToHex(bytes) as NodeId;
 };
 
@@ -1879,26 +1885,26 @@ export const ProtocolValueType = {
   // 0-19 small ints
 
   // SQLite types
-  String: 20 as NonNegativeInt,
-  Number: 21 as NonNegativeInt,
-  Null: 22 as NonNegativeInt,
-  Bytes: 23 as NonNegativeInt,
+  String: NonNegativeInt.orThrow(20),
+  Number: NonNegativeInt.orThrow(21),
+  Null: NonNegativeInt.orThrow(22),
+  Bytes: NonNegativeInt.orThrow(23),
   // We can add more types for other DBs or anything else later.
 
   // Optimized types
-  NonNegativeInt: 30 as NonNegativeInt,
+  NonNegativeInt: NonNegativeInt.orThrow(30),
 
   // String optimizations
-  EmptyString: 31 as NonNegativeInt, // 1 byte vs 2 bytes (50% reduction)
-  Base64Url: 32 as NonNegativeInt,
-  Id: 33 as NonNegativeInt,
-  Json: 34 as NonNegativeInt,
+  EmptyString: NonNegativeInt.orThrow(31), // 1 byte vs 2 bytes (50% reduction)
+  Base64Url: NonNegativeInt.orThrow(32),
+  Id: NonNegativeInt.orThrow(33),
+  Json: NonNegativeInt.orThrow(34),
 
   // new Date().toISOString()   - 24 bytes
   // encoded with fixed length  - 8 bytes
   // encode as NonNegativeInt   - 6 bytes (additional 25% reduction)
-  DateIsoWithNonNegativeTime: 35 as NonNegativeInt,
-  DateIsoWithNegativeTime: 36 as NonNegativeInt, // 9 bytes
+  DateIsoWithNonNegativeTime: NonNegativeInt.orThrow(35),
+  DateIsoWithNegativeTime: NonNegativeInt.orThrow(36), // 9 bytes
 
   // TODO: Operations (from 40)
   // Increment, Decrement, Patch, whatever.

packages/common/src/Evolu/Storage.ts

@@ -183,7 +183,7 @@ export interface StorageQuotaError extends BaseOwnerError {
  */
 export type Fingerprint = Uint8Array & Brand<"Fingerprint">;
 
-export const fingerprintSize = 12 as NonNegativeInt;
+export const fingerprintSize = NonNegativeInt.orThrow(12);
 
 /** A fingerprint of an empty range. */
 export const zeroFingerprint = new Uint8Array(fingerprintSize) as Fingerprint;
@@ -425,7 +425,7 @@ export const createBaseSqliteStorage =
         }
 
         for (let i = 0; i < result.value.rows.length; i++) {
-          const index = (begin + 1 + i) as NonNegativeInt;
+          const index = NonNegativeInt.orThrow(begin + 1 + i);
           if (!callback(result.value.rows[i].t, index)) return;
         }
       },
@@ -1153,7 +1153,7 @@ const randomSkiplistLevel = (deps: RandomDep): PositiveInt => {
   ) {
     level += 1;
   }
-  return level as PositiveInt;
+  return PositiveInt.orThrow(level);
 };
 
 /**
@@ -1294,7 +1294,7 @@ const findLowerBound =
     if (!count.ok) return count;
 
     // `decrement` converts a count to an index.
-    return ok(decrement(count.value) as NonNegativeInt);
+    return ok(NonNegativeInt.orThrow(decrement(count.value)));
   };
 
 const getTimestampCount =

packages/common/src/Number.ts

@@ -59,15 +59,15 @@ export const computeBalancedBuckets = (
   numberOfItems: NonNegativeInt,
 
   /** Default: 16 */
-  numberOfBuckets = 16 as PositiveInt,
+  numberOfBuckets = PositiveInt.orThrow(16),
 
   /** Default: 2 */
-  minNumberOfItemsPerBucket = 2 as PositiveInt,
+  minNumberOfItemsPerBucket = PositiveInt.orThrow(2),
 ): Result<NonEmptyReadonlyArray<PositiveInt>, PositiveInt> => {
   const minRequiredItems = numberOfBuckets * minNumberOfItemsPerBucket;
 
   if (numberOfItems < minRequiredItems)
-    return err(minRequiredItems as PositiveInt);
+    return err(PositiveInt.orThrow(minRequiredItems));
 
   const indexes: Array<PositiveInt> = [];
   const itemsPerBucket = Math.floor(numberOfItems / numberOfBuckets);
@@ -78,7 +78,7 @@ export const computeBalancedBuckets = (
     const hasExtraItem = i < extraItems;
     const itemsInThisBucket = itemsPerBucket + (hasExtraItem ? 1 : 0);
     bucketBoundary += itemsInThisBucket;
-    indexes.push(bucketBoundary as PositiveInt);
+    indexes.push(PositiveInt.orThrow(bucketBoundary));
   }
 
   assertNonEmptyReadonlyArray(indexes);

packages/common/src/Skiplist.ts

@@ -25,7 +25,7 @@ export const createSkiplistLevel =
         while (deps.random.next() <= probability && level < maxLevel) {
           level += 1;
         }
-        return level as PositiveInt;
+        return PositiveInt.orThrow(level);
       },
     };
   };

packages/common/src/Task.ts

@@ -577,7 +577,7 @@ export const retry = <T, E>(
       }
 
       // Wait before retry
-      const delayResult = await wait(delay as NonNegativeInt)(context);
+      const delayResult = await wait(NonNegativeInt.orThrow(delay))(context);
       if (!delayResult.ok) {
         // If delay was aborted, return AbortError (will be handled by toTask)
         return delayResult;
@@ -770,7 +770,7 @@ export interface Mutex extends Disposable {
  * ```
  */
 export const createMutex = (): Mutex => {
-  const mutex = createSemaphore(1 as PositiveInt);
+  const mutex = createSemaphore(PositiveInt.orThrow(1));
 
   return {
     withLock: mutex.withPermit,

packages/common/src/Time.ts

@@ -207,5 +207,5 @@ export const durationToNonNegativeInt = (
     total += value * units[unit as keyof typeof units];
   }
 
-  return total as NonNegativeInt;
+  return NonNegativeInt.orThrow(total);
 };