@comapeo/core 1.0.0

package/src/translation-api.js

@@ -0,0 +1,141 @@
+import { and, sql } from 'drizzle-orm'
+import { kCreateWithDocId, kSelect } from './datatype/index.js'
+import { hashObject } from './utils.js'
+import { NotFoundError } from './errors.js'
+/** @import { Translation, TranslationValue } from '@comapeo/schema' */
+/** @import { SetOptional } from 'type-fest' */
+
+export const ktranslatedLanguageCodeToSchemaNames = Symbol(
+  'translatedLanguageCodeToSchemaNames'
+)
+export default class TranslationApi {
+  /** @type {Map<
+   * TranslationValue['languageCode'],
+   * Set<import('@comapeo/schema/dist/types.js').SchemaName>>} */
+  #translatedLanguageCodeToSchemaNames = new Map()
+  #dataType
+  #table
+  #indexPromise
+
+  /**
+   * @param {Object} opts
+   * @param {import('./datatype/index.js').DataType<
+   *   import('./datastore/index.js').DataStore<'config'>,
+   *   typeof import('./schema/project.js').translationTable,
+   *   'translation',
+   *   Translation,
+   *   TranslationValue
+   * >}  opts.dataType
+   * @param {typeof import('./schema/project.js').translationTable} opts.table
+   */
+  constructor({ dataType, table }) {
+    this.#dataType = dataType
+    this.#table = table
+    this.#indexPromise = this.#dataType
+      .getMany()
+      .then((docs) => {
+        docs.map((doc) => this.index(doc))
+      })
+      .catch((err) => {
+        throw new Error(`error loading Translation cache: ${err}`)
+      })
+  }
+
+  /** @returns {Promise<void>} */
+  ready() {
+    return this.#indexPromise
+  }
+
+  /**
+   * @param {TranslationValue} value
+   */
+  async put(value) {
+    /* eslint-disable no-unused-vars */
+    const { message, ...identifiers } = value
+    const docId = hashObject(identifiers)
+    try {
+      const doc = await this.#dataType.getByDocId(docId)
+      return await this.#dataType.update(doc.versionId, value)
+    } catch (e) {
+      if (e instanceof NotFoundError) {
+        return await this.#dataType[kCreateWithDocId](docId, value)
+      } else {
+        throw new Error(`Error on translation ${e}`)
+      }
+    }
+  }
+
+  /** @typedef {SetOptional<TranslationValue['docRef'], 'versionId'>} DocRefWithOptionalVersionId */
+
+  /**
+   * @param {SetOptional<
+   * Omit<TranslationValue,'schemaName' | 'message' | 'docRef'>,
+   * 'propertyRef' | 'regionCode'> & {docRef: DocRefWithOptionalVersionId}} value
+   * @returns {Promise<import('@comapeo/schema').Translation[]>}
+   */
+  async get(value) {
+    await this.ready()
+
+    const docTypeIsTranslatedToLanguage =
+      this.#translatedLanguageCodeToSchemaNames
+        .get(value.languageCode)
+        ?.has(
+          /** @type {import('@comapeo/schema/dist/types.js').SchemaName} */ (
+            value.docRefType
+          )
+        )
+    if (!docTypeIsTranslatedToLanguage) return []
+
+    const filters = [
+      sql`docRefType = ${value.docRefType}`,
+      sql`languageCode = ${value.languageCode}`,
+      sql`json_extract(docRef, '$.docId') = ${value.docRef.docId}`,
+    ]
+
+    if (value.docRef?.versionId) {
+      filters.push(
+        sql`json_extract(docRef,'$.versionId') = ${value.docRef.versionId}`
+      )
+    }
+    if (value.propertyRef) {
+      filters.push(sql`propertyRef = ${value.propertyRef}`)
+    }
+    if (value.regionCode) {
+      filters.push(sql`regionCode = ${value.regionCode}`)
+    }
+
+    return (await this.#dataType[kSelect]())
+      .where(and.apply(null, filters))
+      .prepare()
+      .all()
+  }
+
+  /**
+   * @param {TranslationValue} doc
+   */
+  index(doc) {
+    let translatedSchemas = this.#translatedLanguageCodeToSchemaNames.get(
+      doc.languageCode
+    )
+    if (!translatedSchemas) {
+      translatedSchemas = new Set()
+      this.#translatedLanguageCodeToSchemaNames.set(
+        doc.languageCode,
+        translatedSchemas
+      )
+    }
+    translatedSchemas.add(
+      /** @type {import('@comapeo/schema/dist/types.js').SchemaName} */ (
+        doc.docRefType
+      )
+    )
+  }
+
+  // This should only be used by tests.
+  get [ktranslatedLanguageCodeToSchemaNames]() {
+    return this.#translatedLanguageCodeToSchemaNames
+  }
+  get dataType() {
+    return this.#dataType
+  }
+}

package/src/types.ts

@@ -0,0 +1,149 @@
+import type {
+  Simplify,
+  TupleToUnion,
+  ValueOf,
+  RequireAtLeastOne,
+  SetOptional,
+} from 'type-fest'
+import { SUPPORTED_BLOB_VARIANTS } from './blob-store/index.js'
+import { MapeoCommon, MapeoDoc, MapeoValue, decode } from '@comapeo/schema'
+import type BigSparseArray from 'big-sparse-array'
+import type Protomux from 'protomux'
+import type NoiseStream from '@hyperswarm/secret-stream'
+import { Duplex } from 'streamx'
+import RandomAccessStorage from 'random-access-storage'
+import { DefaultListener, ListenerSignature } from 'tiny-typed-emitter'
+import type { NAMESPACES } from './constants.js'
+
+export type Namespace = (typeof NAMESPACES)[number]
+
+type SupportedBlobVariants = typeof SUPPORTED_BLOB_VARIANTS
+export type BlobType = keyof SupportedBlobVariants
+export type BlobVariant<TBlobType extends BlobType> = TupleToUnion<
+  SupportedBlobVariants[TBlobType]
+>
+
+type BlobIdBase<T extends BlobType> = {
+  /** Type of blob */
+  type: T
+  /** Blob variant (some blob types have smaller previews and thumbnails available) */
+  variant: BlobVariant<T>
+  /** unique identifier for blob (e.g. hash of content) */
+  name: string
+  /** discovery key as hex string of hyperdrive where blob is stored */
+  driveId: string
+}
+
+// Ugly, but the only way I could figure out how to get what I wanted
+export type BlobId = Simplify<
+  ValueOf<{
+    [KeyType in BlobType]: BlobIdBase<KeyType>
+  }>
+>
+
+type ArrayAtLeastOne<T> = [T, ...T[]]
+
+export type BlobFilter = RequireAtLeastOne<{
+  [KeyType in BlobType]: ArrayAtLeastOne<BlobVariant<KeyType>>
+}>
+
+export type MapeoDocMap = {
+  [K in MapeoDoc['schemaName']]: Extract<MapeoDoc, { schemaName: K }>
+}
+
+export type MapeoValueMap = {
+  [K in MapeoValue['schemaName']]: Extract<MapeoValue, { schemaName: K }>
+}
+
+// TODO: Replace this with exports from @comapeo/schema
+export type CoreOwnershipWithSignatures = Extract<
+  ReturnType<typeof decode>,
+  { schemaName: 'coreOwnership' }
+>
+export type CoreOwnershipWithSignaturesValue = Omit<
+  CoreOwnershipWithSignatures,
+  Exclude<keyof MapeoCommon, 'schemaName'>
+>
+
+type NullToOptional<T> = SetOptional<T, NullKeys<T>>
+type RemoveNull<T> = {
+  [K in keyof T]: Exclude<T[K], null>
+}
+
+type NullKeys<Base> = NonNullable<
+  // Wrap in `NonNullable` to strip away the `undefined` type from the produced union.
+  {
+    // Map through all the keys of the given base type.
+    [Key in keyof Base]: null extends Base[Key] // Pick only keys with types extending the given `Condition` type.
+      ? // Retain this key since the condition passes.
+        Key
+      : // Discard this key since the condition fails.
+        never
+
+    // Convert the produced object into a union type of the keys which passed the conditional test.
+  }[keyof Base]
+>
+
+/**
+ * Replace an object's `Buffer` values with `string`s. Useful for serialization.
+ */
+export type MapBuffers<T> = {
+  [K in keyof T]: T[K] extends Buffer ? string : T[K]
+}
+
+/**
+ * Make any properties whose value include `null` optional, and remove `null`
+ * from the type. This converts the types returned from SQLite (which have all
+ * top-level optional props set to `null`) to the original types in
+ * @comapeo/schema
+ */
+export type NullableToOptional<T> = Simplify<RemoveNull<NullToOptional<T>>>
+export type KeyPair = {
+  publicKey: PublicKey
+  secretKey: SecretKey
+}
+
+/** 32 byte buffer */
+export type PublicKey = Buffer
+/** 32 byte buffer */
+export type SecretKey = Buffer
+export type IdentityKeyPair = KeyPair
+
+type HypercoreRemoteBitfieldPage = {
+  bitfield: Uint32Array
+}
+
+/**
+ * A subset of Hypercore's `RemoteBitfield` class that we use.
+ */
+export type HypercoreRemoteBitfield = {
+  _pages: BigSparseArray<HypercoreRemoteBitfieldPage>
+  get(index: number): boolean
+}
+
+/**
+ * A subset of Hypercore's `Peer` class that we use.
+ * TODO: Contribute these types upstream.
+ */
+export type HypercorePeer = {
+  protomux: Protomux
+  remotePublicKey: Buffer
+  remoteBitfield: HypercoreRemoteBitfield
+  onbitfield: (options: { start: number; bitfield: Buffer }) => void
+  onrange: (options: { drop: boolean; start: number; length: number }) => void
+}
+
+export { NoiseStream }
+type ProtocolStream = Omit<NoiseStream, 'userData'> & {
+  userData: Protomux
+}
+export type ReplicationStream = Duplex & { noiseStream: ProtocolStream }
+
+export type CoreStorage = (name: string) => RandomAccessStorage
+
+export type DefaultEmitterEvents<
+  L extends ListenerSignature<L> = DefaultListener
+> = {
+  newListener: (event: keyof L, listener: L[keyof L]) => void
+  removeListener: (event: keyof L, listener: L[keyof L]) => void
+}

package/src/utils.js

@@ -0,0 +1,210 @@
+import b4a from 'b4a'
+import sodium from 'sodium-universal'
+import { keyToPublicId } from '@mapeo/crypto'
+import { createHash } from 'node:crypto'
+import stableStringify from 'json-stable-stringify'
+
+const PROJECT_INVITE_ID_SALT = Buffer.from('mapeo project invite id', 'ascii')
+
+/**
+ * @param {String|Buffer} id
+ * @returns {Buffer | Uint8Array}
+ */
+export function idToKey(id) {
+  if (b4a.isBuffer(id)) {
+    return /** @type {Buffer} */ (id)
+  }
+
+  return b4a.from(/** @type {String} */ (id), 'hex')
+}
+
+/**
+ *
+ * @param {Buffer|String} key
+ * @returns {String}
+ */
+export function keyToId(key) {
+  if (typeof key === 'string') {
+    return key
+  }
+
+  return key.toString('hex')
+}
+
+/**
+ * @param {String} version
+ * @returns {{coreId: String, blockIndex: Number}}
+ */
+export function parseVersion(version) {
+  const [coreId, blockIndex] = version.split('@')
+  return {
+    coreId,
+    blockIndex: Number(blockIndex),
+  }
+}
+
+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} message
+ * @returns {asserts condition}
+ */
+export function assert(condition, message) {
+  if (!condition) throw new Error(message)
+}
+
+/**
+ * Return a function that itself returns whether a value is part of the set.
+ *
+ * Similar to binding `Set.prototype.has`, but (1) is shorter (2) refines the type.
+ *
+ * @template T
+ * @param {Readonly<Set<T>>} set
+ * @example
+ * const mySet = new Set([1, 2, 3])
+ * const isInMySet = setHas(mySet)
+ *
+ * console.log(isInMySet(2))
+ * // => true
+ */
+export function setHas(set) {
+  /**
+   * @param {unknown} value
+   * @returns {value is T}
+   */
+  return (value) => set.has(/** @type {*} */ (value))
+}
+
+/**
+ * @template T
+ * @param {undefined | T} value
+ * @returns {value is T}
+ */
+export function isDefined(value) {
+  return value !== undefined
+}
+
+/**
+ * When reading from SQLite, any optional properties are set to `null`. This
+ * converts `null` back to `undefined` to match the input types (e.g. the types
+ * defined in @comapeo/schema)
+ * @template {{}} T
+ * @param {T} obj
+ * @returns {import('./types.js').NullableToOptional<T>}
+ */
+
+export function deNullify(obj) {
+  /** @type {Record<string, any>} */
+  const objNoNulls = {}
+  for (const [key, value] of Object.entries(obj)) {
+    objNoNulls[key] = value === null ? undefined : value
+  }
+  return /** @type {import('./types.js').NullableToOptional<T>} */ (objNoNulls)
+}
+
+/**
+ * @template {import('@comapeo/schema').MapeoDoc & { forks?: string[] }} T
+ * @param {T} doc
+ * @returns {Omit<T, 'docId' | 'versionId' | 'originalVersionId' | 'links' | 'forks' | 'createdAt' | 'updatedAt' | 'deleted'>}
+ */
+export function valueOf(doc) {
+  /* eslint-disable no-unused-vars */
+  const {
+    docId,
+    versionId,
+    originalVersionId,
+    links,
+    forks,
+    createdAt,
+    updatedAt,
+    deleted,
+    ...rest
+  } = doc
+  /* eslint-enable no-unused-vars */
+  return rest
+}
+
+/**
+ * Create an internal ID from a project key
+ * @param {Buffer} projectKey
+ * @returns {string}
+ */
+export function projectKeyToId(projectKey) {
+  return projectKey.toString('hex')
+}
+
+/**
+ * Create a public ID from a project key
+ * @param {Buffer} projectKey
+ * @returns {string}
+ */
+export function projectKeyToPublicId(projectKey) {
+  return keyToPublicId(projectKey)
+}
+
+/**
+ * Generate an invite ID from a project key
+ * @param {Readonly<Buffer>} projectKey
+ * @returns {Buffer}
+ */
+export function projectKeyToProjectInviteId(projectKey) {
+  const result = Buffer.allocUnsafe(32)
+  sodium.crypto_generichash(result, PROJECT_INVITE_ID_SALT, projectKey)
+  return result
+}
+
+/**
+ * @param {string} projectId Project internal ID
+ * @returns {Buffer} 24-byte nonce (same length as sodium.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES)
+ */
+export function projectIdToNonce(projectId) {
+  return Buffer.from(projectId, 'hex').subarray(0, 24)
+}
+
+/**
+ * @param {import('@mapeo/crypto').KeyManager} keyManager
+ * @returns {string}
+ */
+export function getDeviceId(keyManager) {
+  return keyManager.getIdentityKeypair().publicKey.toString('hex')
+}
+
+/**
+ * Small helper to create a typed map
+ *
+ * @template {string} K
+ * @template {any} V
+ * @param {ReadonlyArray<K>} keys
+ * @param {V} value
+ * @returns {Record<K, V extends () => infer T ? T : V>} */
+export function createMap(keys, value) {
+  const map = /** @type {Record<K, V extends () => infer T ? T : V>} */ ({})
+  for (const key of keys) {
+    map[key] = typeof value === 'function' ? value() : value
+  }
+  return map
+}
+
+/**
+ * create a sha256 hash of an object using json-stable-stringify for deterministic results
+ * @param {Object} obj
+ * @returns {String} hash of the object
+ */
+export function hashObject(obj) {
+  return createHash('sha256')
+    .update(stableStringify(obj))
+    .digest()
+    .toString('hex')
+}

package/src/utils_types.d.ts

@@ -0,0 +1,14 @@
+import type { TypedEmitter } from 'tiny-typed-emitter'
+
+export type TypedEvents<T extends TypedEmitter<any>> = T extends TypedEmitter<
+  infer Result
+>
+  ? Result
+  : never
+
+export type TypedEventsFor<T extends TypedEmitter<any>> = keyof TypedEvents<T>
+
+export type TypedEventArgs<
+  Emitter extends TypedEmitter<any>,
+  Event extends TypedEventsFor<Emitter>
+> = Parameters<TypedEvents<Emitter>[Event]>