@comapeo/core 5.4.1 → 6.0.0

package/src/sync/sync-api.js

@@ -8,10 +8,11 @@ import {
   NAMESPACES,
   PRESYNC_NAMESPACES,
 } from '../constants.js'
-import { ExhaustivenessError, assert, keyToId, noop } from '../utils.js'
+import { keyToId, noop } from '../utils.js'
 import { getOwn } from '../lib/get-own.js'
 import { wsCoreReplicator } from '../lib/ws-core-replicator.js'
 import { NO_ROLE_ID } from '../roles.js'
+import { AutoStopTimeoutError, ExhaustivenessError } from '../errors.js'
 /** @import { CoreOwnership as CoreOwnershipDoc } from '@comapeo/schema' */
 /** @import * as http from 'node:http' */
 /** @import { CoreOwnership } from '../core-ownership.js' */
@@ -229,7 +230,7 @@ export class SyncApi extends TypedEmitter {
           remoteDeviceSyncState,
         }
       default:
-        throw new ExhaustivenessError(this.#previousSyncEnabledState)
+        throw new ExhaustivenessError({ value: this.#previousSyncEnabledState })
     }
   }
 
@@ -619,7 +620,7 @@ export class SyncApi extends TypedEmitter {
               coreOwnershipDocId
             )
             await this.#validateRoleAndAddCoresForPeer(coreOwnershipDoc)
-          } catch (_) {
+          } catch {
             // Ignore, we'll add these when the role is added
           }
         })()
@@ -655,10 +656,9 @@ export class SyncApi extends TypedEmitter {
  */
 function assertAutostopDataSyncAfterIsValid(ms) {
   if (ms === null) return
-  assert(
-    ms > 0 && ms <= 2 ** 31 - 1 && Number.isSafeInteger(ms),
-    'auto-stop timeout must be Infinity or a positive integer between 0 and the largest 32-bit signed integer'
-  )
+  if (!(ms > 0 && ms <= 2 ** 31 - 1 && Number.isSafeInteger(ms))) {
+    throw new AutoStopTimeoutError()
+  }
 }
 
 /**
@@ -701,7 +701,7 @@ function isInitiallySyncedWithPeer(state, peerId) {
         break
       }
       default:
-        throw new ExhaustivenessError(remoteDeviceSyncState.status)
+        throw new ExhaustivenessError({ value: remoteDeviceSyncState.status })
     }
   }
   return true
@@ -740,7 +740,7 @@ function getRemoteDevicesSyncState(namespaceSyncState, peerSyncControllers) {
           isSyncEnabled = true
           break
         default:
-          throw new ExhaustivenessError(peerNamespaceState.status)
+          throw new ExhaustivenessError({ value: peerNamespaceState.status })
       }
 
       if (!Object.hasOwn(result, peerId)) {

package/src/translation-api.js

@@ -39,8 +39,8 @@ export default class TranslationApi {
       .then((docs) => {
         docs.map((doc) => this.index(doc))
       })
-      .catch((err) => {
-        console.error(`error loading Translation cache: ${err}`)
+      .catch((e) => {
+        console.error(`error loading Translation cache: ${e}`)
       })
   }
 

package/src/utils.js

@@ -3,13 +3,23 @@ import { keyToPublicId } from '@mapeo/crypto'
 import { createHash } from 'node:crypto'
 import stableStringify from 'json-stable-stringify'
 import { omit } from './lib/omit.js'
+import {
+  UnsupportedAttachmentTypeError,
+  TimeoutError,
+  ensureKnownError,
+  InvalidMapShareError,
+} from './errors.js'
+import pTimeout, { TimeoutError as pTimeoutError } from 'p-timeout'
 
 /** @import { MapShareExtension } from './generated/extensions.js' */
 /** @import {Attachment, BlobId} from "./types.js" */
 
 const PROJECT_INVITE_ID_SALT = Buffer.from('mapeo project invite id', 'ascii')
 
-export const MAX_BOUNDS = [-180, -85.051129, 180, 85.051129]
+// Slightly larger than spherical mercator bounds for a square map - rounds up
+// from 85.051129 to allow for floating point errors in the bounds of some maps
+// in userspace.
+export const MAX_BOUNDS = [-180, -85.05113, 180, 85.05113]
 
 /**
  *
@@ -24,33 +34,11 @@ export function keyToId(key) {
   return key.toString('hex')
 }
 
-export class ExhaustivenessError extends Error {
-  /** @param {never} value */
-  constructor(value) {
-    super(`Exhaustiveness check failed. ${value} should be impossible`)
-    this.name = 'ExhaustivenessError'
-  }
-}
-
 /**
  * @returns {void}
  */
 export function noop() {}
 
-/**
- * @param {unknown} condition
- * @param {string | Error} messageOrError
- * @returns {asserts condition}
- */
-export function assert(condition, messageOrError) {
-  if (condition) return
-  if (typeof messageOrError === 'string') {
-    throw new Error(messageOrError)
-  } else {
-    throw messageOrError
-  }
-}
-
 /**
  * Return a function that itself returns whether a value is part of the set.
  *
@@ -224,7 +212,7 @@ export function buildBlobId(attachment, requestedVariant) {
     attachment.type !== 'audio' &&
     attachment.type !== 'video'
   ) {
-    throw new Error(`Cannot fetch URL for attachment type "${attachment.type}"`)
+    throw new UnsupportedAttachmentTypeError(attachment.type)
   }
 
   if (attachment.type === 'photo') {
@@ -257,6 +245,23 @@ export function typedEntries(obj) {
   return /** @type {import('type-fest').Entries<T>} */ (Object.entries(obj))
 }
 
+/**
+ * @template T
+ * @param {Promise<T>} promise
+ * @param {Parameters<typeof pTimeout<T>>[1]} opts
+ * @returns {Promise<T>}
+ */
+export async function timeoutPromise(promise, opts) {
+  try {
+    return await pTimeout(promise, opts)
+  } catch (e) {
+    if (e instanceof pTimeoutError) {
+      throw new TimeoutError()
+    }
+    throw ensureKnownError(e)
+  }
+}
+
 /**
  * Validate map share extension messages to check that all their parameters make sense
  * Does not validate device ID or device name
@@ -267,7 +272,7 @@ export function typedEntries(obj) {
 export function validateMapShareExtension(mapShare) {
   const {
     mapShareUrls,
-    receiverDeviceId,
+    receiverDeviceKey,
     mapId,
     mapName,
     shareId,
@@ -279,51 +284,61 @@ export function validateMapShareExtension(mapShare) {
     mapShareCreatedAt,
   } = mapShare
 
-  if (!receiverDeviceId.length) {
-    throw new Error('Receiver Device ID must not be empty')
+  if (!receiverDeviceKey.length) {
+    throw new InvalidMapShareError('Receiver Device ID must not be empty')
+  }
+  if (!mapId.length) throw new InvalidMapShareError('Map ID must not be empty')
+  if (!shareId.length) {
+    throw new InvalidMapShareError('Share ID must not be empty')
+  }
+  if (!mapName.length) {
+    throw new InvalidMapShareError('Map Name must not be empty')
+  }
+  if (!mapShareUrls.length) {
+    throw new InvalidMapShareError('Map share URLs must not be empty')
   }
-  if (!mapId.length) throw new Error('Map ID must not be empty')
-  if (!shareId.length) throw new Error('Share ID must not be empty')
-  if (!mapName.length) throw new Error('Map Name must not be empty')
-  if (!mapShareUrls.length) throw new Error('Map share URLs must not be empty')
   if (!mapShareUrls.every((url) => URL.canParse(url))) {
-    throw new Error('Map share URLs must be valid URLs')
+    throw new InvalidMapShareError('Map share URLs must be valid URLs')
+  }
+  if (!mapCreatedAt) throw new InvalidMapShareError('mapCreatedAt must be set')
+  if (!mapShareCreatedAt) {
+    throw new InvalidMapShareError('mapShareCreatedAt must be set')
   }
-  if (!mapCreatedAt) throw new Error('mapCreatedAt must be set')
-  if (!mapShareCreatedAt) throw new Error('mapShareCreatedAt must be set')
   if (bounds.length !== 4) {
-    throw new Error('Bounds must be bounding box with 4 values')
+    throw new InvalidMapShareError('Bounds must be bounding box with 4 values')
   }
   if (bounds[0] < MAX_BOUNDS[0]) {
-    throw new Error(
+    throw new InvalidMapShareError(
       `Bounds at ${0} must be within max of spherical mercator projection ${MAX_BOUNDS}`
     )
   }
   if (bounds[1] < MAX_BOUNDS[1]) {
-    throw new Error(
+    throw new InvalidMapShareError(
       `Bounds at ${1} must be within max of spherical mercator projection ${MAX_BOUNDS}`
     )
   }
   if (bounds[2] > MAX_BOUNDS[2]) {
-    throw new Error(
+    throw new InvalidMapShareError(
       `Bounds at ${2} must be within max of spherical mercator projection ${MAX_BOUNDS}`
     )
   }
   if (bounds[3] > MAX_BOUNDS[3]) {
-    throw new Error(
+    throw new InvalidMapShareError(
       `Bounds at ${3} must be within max of spherical mercator projection ${MAX_BOUNDS}`
     )
   }
   if (maxzoom < minzoom) {
-    throw new Error('Max zoom must be greater than or equal to min zoom')
+    throw new InvalidMapShareError(
+      'Max zoom must be greater than or equal to min zoom'
+    )
   }
   if (maxzoom < 0 || maxzoom > 22) {
-    throw new Error('Max zoom must be between 0 and 22')
+    throw new InvalidMapShareError('Max zoom must be between 0 and 22')
   }
   if (minzoom < 0 || minzoom > 22) {
-    throw new Error('Min zoom must be between 0 and 22')
+    throw new InvalidMapShareError('Min zoom must be between 0 and 22')
   }
   if (estimatedSizeBytes <= 0) {
-    throw new Error('Map size bytes must greater than zero')
+    throw new InvalidMapShareError('Map size bytes must greater than zero')
   }
 }

package/dist/lib/error.d.ts

@@ -1,51 +0,0 @@
-/**
- * If the argument is an `Error` instance, return its `code` property if it is a string.
- * Otherwise, returns `undefined`.
- *
- * @param {unknown} maybeError
- * @returns {undefined | string}
- * @example
- * try {
- *   // do something
- * } catch (err) {
- *   console.error(getErrorCode(err))
- * }
- */
-export function getErrorCode(maybeError: unknown): undefined | string;
-/**
- * Get the error message from an object if possible.
- * Otherwise, stringify the argument.
- *
- * @param {unknown} maybeError
- * @returns {string}
- * @example
- * try {
- *   // do something
- * } catch (err) {
- *   console.error(getErrorMessage(err))
- * }
- */
-export function getErrorMessage(maybeError: unknown): string;
-/**
- * Create an `Error` with a `code` property.
- *
- * @example
- * const err = new ErrorWithCode('INVALID_DATA', 'data was invalid')
- * err.message
- * // => 'data was invalid'
- * err.code
- * // => 'INVALID_DATA'
- */
-export class ErrorWithCode extends Error {
-    /**
-     * @param {string} code
-     * @param {string} message
-     * @param {object} [options]
-     * @param {unknown} [options.cause]
-     */
-    constructor(code: string, message: string, options?: {
-        cause?: unknown;
-    } | undefined);
-    /** @readonly */ readonly code: string;
-}
-//# sourceMappingURL=error.d.ts.map

package/dist/lib/error.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../src/lib/error.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;GAYG;AACH,yCATW,OAAO,GACL,SAAS,GAAG,MAAM,CAiB9B;AAED;;;;;;;;;;;;GAYG;AACH,4CATW,OAAO,GACL,MAAM,CAkBlB;AAtED;;;;;;;;;GASG;AACH;IACE;;;;;OAKG;IACH,kBALW,MAAM,WACN,MAAM;gBAEN,OAAO;mBAKjB;IADC,gBAAgB,CAAC,sBAAgB;CAEpC"}

package/src/lib/error.js

@@ -1,71 +0,0 @@
-/**
- * Create an `Error` with a `code` property.
- *
- * @example
- * const err = new ErrorWithCode('INVALID_DATA', 'data was invalid')
- * err.message
- * // => 'data was invalid'
- * err.code
- * // => 'INVALID_DATA'
- */
-export class ErrorWithCode extends Error {
-  /**
-   * @param {string} code
-   * @param {string} message
-   * @param {object} [options]
-   * @param {unknown} [options.cause]
-   */
-  constructor(code, message, options) {
-    super(message, options)
-    /** @readonly */ this.code = code
-  }
-}
-
-/**
- * If the argument is an `Error` instance, return its `code` property if it is a string.
- * Otherwise, returns `undefined`.
- *
- * @param {unknown} maybeError
- * @returns {undefined | string}
- * @example
- * try {
- *   // do something
- * } catch (err) {
- *   console.error(getErrorCode(err))
- * }
- */
-export function getErrorCode(maybeError) {
-  if (
-    maybeError instanceof Error &&
-    'code' in maybeError &&
-    typeof maybeError.code === 'string'
-  ) {
-    return maybeError.code
-  }
-  return undefined
-}
-
-/**
- * Get the error message from an object if possible.
- * Otherwise, stringify the argument.
- *
- * @param {unknown} maybeError
- * @returns {string}
- * @example
- * try {
- *   // do something
- * } catch (err) {
- *   console.error(getErrorMessage(err))
- * }
- */
-export function getErrorMessage(maybeError) {
-  if (maybeError && typeof maybeError === 'object' && 'message' in maybeError) {
-    try {
-      const { message } = maybeError
-      if (typeof message === 'string') return message
-    } catch (_err) {
-      // Ignored
-    }
-  }
-  return 'unknown error'
-}