@comapeo/core 4.3.0 → 5.0.0-next.3

package/src/schema/{schema-to-drizzle.js → json-schema-to-drizzle.js}

@@ -1,24 +1,24 @@
-import { text, integer, real } from 'drizzle-orm/sqlite-core'
+import { text, integer, real, sqliteTable } from 'drizzle-orm/sqlite-core'
 import { ExhaustivenessError } from '../utils.js'
-import { customJson } from './utils.js'
-/** @import { MapeoDoc } from '@comapeo/schema' */
-/** @import { MapeoDocMap } from '../types.js' */
 
 /**
-Convert a JSONSchema definition to a Drizzle Columns Map (the parameter for
-`sqliteTable()`).
-
-**NOTE**: The return of this function is _not_ type-checked (it is coerced with
-`as`, because it's not possible to type-check what this function is doing), but
-the return type _should_ be correct when using this function.
-@template {import('./types.js').JSONSchema7WithProps} TSchema
-NB: The inline typescript checker often marks this next line as an error, but this seems to be a bug with JSDoc parsing - running `tsc` does not show this as an error.
-@template {import('type-fest').Get<TSchema, 'properties.schemaName.const'>} TSchemaName
-@template {TSchemaName extends MapeoDoc['schemaName'] ? MapeoDocMap[TSchemaName] : any} TObjectType
-@param {TSchema} schema
-@returns {import('./types.js').SchemaToDrizzleColumns<TSchema, TObjectType>}
+ * @template {{ [ K in keyof TSchema['properties'] ]?: any }} TObjectType
+ * @template {import('./types.js').JSONSchema7Object} TSchema
+ * @template {string} TTableName
+ * @template {Record<string, import('drizzle-orm').ColumnBuilderBase>} TColumnsMap
+ * @template {keyof TSchema['properties']} TPrimaryKey
+ * @param {TTableName} tableName
+ * @param {TSchema} schema
+ * @param {object} [opts]
+ * @param {TColumnsMap} [opts.additionalColumns]
+ * @param {TPrimaryKey} [opts.primaryKey] - Column name to use as primary key, if not specified in schema
+ * @returns {import('./types.js').JsonSchemaToDrizzleSqliteTable<TObjectType, TSchema, TTableName, TColumnsMap, TPrimaryKey>}
  */
-export function jsonSchemaToDrizzleColumns(schema) {
+export function jsonSchemaToDrizzleSqliteTable(
+  tableName,
+  schema,
+  { additionalColumns, primaryKey } = {}
+) {
   if (schema.type !== 'object' || !schema.properties) {
     throw new Error('Cannot process JSONSchema as SQL table')
   }
@@ -46,14 +46,11 @@ export function jsonSchemaToDrizzleColumns(schema) {
           ? /** @type {[typeof value.const]} */ ([value.const])
           : undefined
         columns[key] = text(key, { enum: enumValue })
-        if (key === 'docId') {
-          columns[key] = columns[key].primaryKey()
-        }
         break
       }
       case 'array':
       case 'object':
-        columns[key] = customJson(key)
+        columns[key] = text(key, { mode: 'json' })
         break
       case 'null':
         // Skip handling this right now
@@ -69,10 +66,13 @@ export function jsonSchemaToDrizzleColumns(schema) {
         columns[key] = columns[key].default(defaultValue)
       }
     }
+    if (key === primaryKey) {
+      columns[key] = columns[key].primaryKey()
+    }
   }
-  // Not yet in @comapeo/schema
-  columns.forks = customJson('forks').notNull()
-  return /** @type {any} */ (columns)
+  return /** @type {any} */ (
+    sqliteTable(tableName, { ...columns, ...additionalColumns })
+  )
 }
 
 /**
@@ -85,7 +85,7 @@ function getDefault(value) {
 }
 
 /**
- * @param {import('./types.js').JSONSchema7WithProps} schema
+ * @param {import('./types.js').JSONSchema7Object} schema
  * @param {string} key
  * @returns {boolean}
  */

package/src/schema/project.js

@@ -3,47 +3,34 @@
 import { blob, sqliteTable, text } from 'drizzle-orm/sqlite-core'
 import { dereferencedDocSchemas as schemas } from '@comapeo/schema'
 import { NAMESPACES } from '../constants.js'
-import { jsonSchemaToDrizzleColumns as toColumns } from './schema-to-drizzle.js'
-import { backlinkTable } from './utils.js'
+import {
+  comapeoSchemaToDrizzleTable as toDrizzle,
+  backlinkTable,
+} from './comapeo-to-drizzle.js'
 
-export const translationTable = sqliteTable(
-  'translation',
-  toColumns(schemas.translation)
-)
-export const observationTable = sqliteTable(
-  'observation',
-  toColumns(schemas.observation)
-)
-export const trackTable = sqliteTable('track', toColumns(schemas.track))
-export const remoteDetectionAlertTable = sqliteTable(
-  'remoteDetectionAlert',
-  toColumns(schemas.remoteDetectionAlert)
-)
-export const presetTable = sqliteTable('preset', toColumns(schemas.preset))
-export const fieldTable = sqliteTable('field', toColumns(schemas.field))
-export const coreOwnershipTable = sqliteTable(
-  'coreOwnership',
-  toColumns(schemas.coreOwnership)
-)
-export const roleTable = sqliteTable('role', toColumns(schemas.role))
-export const deviceInfoTable = sqliteTable(
-  'deviceInfo',
-  toColumns(schemas.deviceInfo)
-)
-export const iconTable = sqliteTable('icon', toColumns(schemas.icon))
+export const translationTable = toDrizzle(schemas.translation)
+export const observationTable = toDrizzle(schemas.observation)
+export const trackTable = toDrizzle(schemas.track)
+export const remoteDetectionAlertTable = toDrizzle(schemas.remoteDetectionAlert)
+export const presetTable = toDrizzle(schemas.preset)
+export const fieldTable = toDrizzle(schemas.field)
+export const coreOwnershipTable = toDrizzle(schemas.coreOwnership)
+export const roleTable = toDrizzle(schemas.role)
+export const deviceInfoTable = toDrizzle(schemas.deviceInfo)
+export const iconTable = toDrizzle(schemas.icon)
 
-export const translationBacklinkTable = backlinkTable(translationTable)
-export const observationBacklinkTable = backlinkTable(observationTable)
-export const trackBacklinkTable = backlinkTable(trackTable)
+export const translationBacklinkTable = backlinkTable('translation')
+export const observationBacklinkTable = backlinkTable('observation')
+export const trackBacklinkTable = backlinkTable('track')
 export const remoteDetectionAlertBacklinkTable = backlinkTable(
-  remoteDetectionAlertTable
+  'remoteDetectionAlert'
 )
-export const presetBacklinkTable = backlinkTable(presetTable)
-export const fieldBacklinkTable = backlinkTable(fieldTable)
-export const coreOwnershipBacklinkTable = backlinkTable(coreOwnershipTable)
-export const roleBacklinkTable = backlinkTable(roleTable)
-export const deviceInfoBacklinkTable = backlinkTable(deviceInfoTable)
-export const iconBacklinkTable = backlinkTable(iconTable)
+export const presetBacklinkTable = backlinkTable('preset')
+export const fieldBacklinkTable = backlinkTable('field')
+export const coreOwnershipBacklinkTable = backlinkTable('coreOwnership')
+export const roleBacklinkTable = backlinkTable('role')
+export const deviceInfoBacklinkTable = backlinkTable('deviceInfo')
+export const iconBacklinkTable = backlinkTable('icon')
 
 export const coresTable = sqliteTable('cores', {
   publicKey: blob('publicKey', { mode: 'buffer' }).notNull(),

package/src/schema/types.ts

@@ -3,101 +3,86 @@ import {
   JSONSchema7 as JSONSchema7Writable,
   JSONSchema7Type,
 } from 'json-schema'
+import type {
+  SQLiteBooleanBuilder,
+  SQLiteIntegerBuilder,
+  SQLiteRealBuilder,
+  SQLiteTableWithColumns,
+  SQLiteTextBuilder,
+  SQLiteTextJsonBuilder,
+} from 'drizzle-orm/sqlite-core'
+import type {
+  $Type,
+  BuildColumns,
+  ColumnBuilderBase,
+  HasDefault,
+  IsPrimaryKey,
+  NotNull,
+} from 'drizzle-orm'
 
-/** Convert optional properties to nullable */
-export type OptionalToNull<T extends {}> = {
-  [K in keyof T]-?: undefined extends T[K] ? T[K] | null : T[K]
-}
 /** Convert a readonly array/object to writeable */
 type Writable<T> = { -readonly [P in keyof T]: T[P] }
-/** Type returned by text(columnName, { enum: [] }) */
-type TextBuilder<
-  TName extends string,
-  TEnum extends readonly [string, ...string[]],
-  TNotNull extends boolean,
-  THasDefault extends boolean
-> = import('drizzle-orm/sqlite-core').SQLiteTextBuilder<{
-  name: TName
-  data: Writable<TEnum>[number]
-  driverParam: string
-  columnType: 'SQLiteText'
-  dataType: 'string'
-  enumValues: Writable<TEnum>
-  notNull: TNotNull
-  hasDefault: THasDefault
-}>
-
-/** Type returned by integer(columnName, { mode: 'boolean' }) */
-type BooleanBuilder<
-  TName extends string,
-  TNotNull extends boolean,
-  THasDefault extends boolean
-> = import('drizzle-orm/sqlite-core').SQLiteBooleanBuilder<{
-  name: TName
-  data: boolean
-  driverParam: number
-  columnType: 'SQLiteBoolean'
-  dataType: 'boolean'
-  notNull: TNotNull
-  hasDefault: THasDefault
-  enumValues: undefined
-}>
-
-/** Type returned by real(columnName) */
-type RealBuilder<
-  TName extends string,
-  TNotNull extends boolean,
-  THasDefault extends boolean
-> = import('drizzle-orm/sqlite-core').SQLiteRealBuilder<{
-  name: TName
-  data: number
-  driverParam: number
-  columnType: 'SQLiteReal'
-  dataType: 'number'
-  notNull: TNotNull
-  hasDefault: THasDefault
-  enumValues: undefined
-}>
-
-/** Type returned by integer(columnName) */
-type IntegerBuilder<
-  TName extends string,
-  TNotNull extends boolean,
-  THasDefault extends boolean
-> = import('drizzle-orm/sqlite-core').SQLiteIntegerBuilder<{
-  name: TName
-  data: number
-  driverParam: number
-  columnType: 'SQLiteInteger'
-  dataType: 'number'
-  notNull: TNotNull
-  hasDefault: THasDefault
-  enumValues: undefined
-}>
-
-/** Type returned by the `customJson` custom type */
-type JsonBuilder<
-  TName extends string,
-  TData extends unknown,
-  TNotNull extends boolean,
-  THasDefault extends boolean
-> = import('drizzle-orm/sqlite-core').SQLiteCustomColumnBuilder<{
-  name: TName
-  data: TData
-  dataType: 'custom'
-  driverParam: string
-  columnType: 'SQLiteCustomColumn'
-  notNull: TNotNull
-  hasDefault: THasDefault
-  enumValues: undefined
-}>
 
 export type JSONSchema7 = ReadonlyDeep<JSONSchema7Writable>
 type JsonSchema7Properties = { readonly [K: string]: JSONSchema7 }
-export type JSONSchema7WithProps = Omit<JSONSchema7, 'properties'> & {
+export type JSONSchema7Object = Omit<JSONSchema7, 'properties' | 'type'> & {
+  readonly type: 'object'
   readonly properties: JsonSchema7Properties
 }
 
+/**
+ * Create a Drizzle SQLite table definition from a JSONSchema object. All
+ * top-level properties map to SQLite columns, with `required` properties marked
+ * as `NOT NULL`, and JSONSchema `default` will map to SQLite defaults.
+ *
+ * Any properties that are of type `object` or `array` in the JSONSchema will be
+ * mapped to a text field, which drizzle will parse and stringify. Types for
+ * `object` and `array` properties will be derived from `TObjectType`.
+ */
+export type JsonSchemaToDrizzleSqliteTable<
+  /** Typescript type for the object defined in the JSONSchema */
+  TObjectType extends { [K in keyof TSchema['properties']]?: any },
+  /** The JSONSchema object schema */
+  TSchema extends JSONSchema7Object,
+  /** Name of the table to create */
+  TTableName extends string,
+  /** Additional columns to add to the table definition (e.g. not defined in JSONSchema ) */
+  TColumnsMap extends Record<string, ColumnBuilderBase> = {},
+  /** Name of the property to use as primary key */
+  TPrimaryKey extends keyof TSchema['properties'] | undefined = undefined
+> = SQLiteTableWithColumns<{
+  name: TTableName
+  schema: undefined
+  columns: BuildColumns<
+    TTableName,
+    JsonSchemaToDrizzleColumns<TObjectType, TSchema, TPrimaryKey> & TColumnsMap,
+    'sqlite'
+  >
+  dialect: 'sqlite'
+}>
+
+/**
+ * Convert a JSONSchema Object Schema to a Drizzle Columns map (e.g. parameter
+ * for `sqliteTable()`). All top-level properties map to SQLite columns, with
+ * `required` properties marked as `NOT NULL`, and JSONSchema `default` will map
+ * to SQLite defaults.
+ *
+ * Any properties that are of type `object` or `array` in the JSONSchema will be
+ * mapped to a text field, which drizzle will parse and stringify. Types for
+ * `object` and `array` properties will be derived from `TObjectType`.
+ */
+type JsonSchemaToDrizzleColumns<
+  TObjectType extends { [K in keyof TSchema['properties']]?: any },
+  TSchema extends JSONSchema7Object,
+  TPrimaryKey extends keyof TSchema['properties'] | undefined = undefined
+> = AddJSONSchemaDefaults<
+  TSchema,
+  AddJSONSchemaRequired<
+    TSchema,
+    SchemaToDrizzleColumnsBase<TSchema, TObjectType>
+  >
+>
+
 /** Get the type of a JSONSchema string: array of constants for an enum,
 otherwise string[]. Strangeness is to convert it into the format expected by
 drizzle, which results in the correct type for the field from SQLite */
@@ -111,13 +96,12 @@ type Enum<
   : [string, ...string[]]
 
 /** True if JSONSchema object has a default */
-type HasDefault<T extends JSONSchema7> = T['default'] extends JSONSchema7Type
-  ? true
-  : false
+type HasJSONSchemaDefault<T extends JSONSchema7> =
+  T['default'] extends JSONSchema7Type ? true : false
 
 /** True if JSONSchema value is required */
-type IsRequired<
-  T extends JSONSchema7WithProps,
+type IsJSONSchemaRequired<
+  T extends JSONSchema7Object,
   U extends string,
   V extends JSONSchema7['required'] = T['required']
 > = V extends readonly any[] ? Includes<V, U> : false
@@ -131,23 +115,78 @@ type IsRequired<
  * stringify. Types for parsed JSON will be derived from MapeoDoc types.
  */
 export type SchemaToDrizzleColumns<
-  T extends JSONSchema7WithProps,
+  TSchema extends JSONSchema7Object,
+  /** This is the type matching the JSONSchema */
+  TObjectType extends { [K in keyof TSchema['properties']]?: any },
+  TPrimaryKey extends keyof TSchema['properties'] | undefined = undefined
+> = AddPrimaryKey<
+  AddJSONSchemaDefaults<
+    TSchema,
+    AddJSONSchemaRequired<
+      TSchema,
+      SchemaToDrizzleColumnsBase<TSchema, TObjectType>
+    >
+  >,
+  TPrimaryKey
+>
+
+/**
+ * Add `HasDefault` to columns if the JSONSchema has a default for that property
+ */
+type AddJSONSchemaDefaults<
+  TJSONSchema extends JSONSchema7Object,
+  TColumns extends Record<string, ColumnBuilderBase>,
+  U extends JsonSchema7Properties = TJSONSchema['properties']
+> = {
+  [K in keyof TColumns]: K extends keyof U
+    ? HasJSONSchemaDefault<U[K]> extends true
+      ? HasDefault<TColumns[K]>
+      : TColumns[K]
+    : TColumns[K]
+}
+
+/**
+ * Mark columns as NotNull if they are required in the JSONSchema
+ */
+type AddJSONSchemaRequired<
+  TJSONSchema extends JSONSchema7Object,
+  TColumns extends Record<string, ColumnBuilderBase>
+> = {
+  [K in keyof TColumns]: K extends string
+    ? IsJSONSchemaRequired<TJSONSchema, K> extends true
+      ? NotNull<TColumns[K]>
+      : TColumns[K]
+    : TColumns[K]
+}
+
+type AddPrimaryKey<
+  TColumns extends Record<string, ColumnBuilderBase>,
+  TKey extends keyof TColumns | undefined
+> = TKey extends string
+  ? Omit<TColumns, TKey> & { [K in TKey]: IsPrimaryKey<TColumns[TKey]> }
+  : TColumns
+
+/**
+ * Map JSONSchema object properties to Drizzle column types.
+ */
+type SchemaToDrizzleColumnsBase<
+  TSchema extends JSONSchema7Object,
   TObjectType extends { [K in keyof U]?: any },
-  U extends JsonSchema7Properties = T['properties']
+  U extends JsonSchema7Properties = TSchema['properties']
 > = {
   [K in keyof U]: K extends string
     ? U[K]['type'] extends 'string'
-      ? TextBuilder<K, Enum<U[K]>, IsRequired<T, K>, HasDefault<U[K]>>
+      ? SQLiteTextBuilder<Enum<U[K]>>
       : U[K]['type'] extends 'boolean'
-      ? BooleanBuilder<K, IsRequired<T, K>, HasDefault<U[K]>>
+      ? SQLiteBooleanBuilder
       : U[K]['type'] extends 'number'
-      ? RealBuilder<K, IsRequired<T, K>, HasDefault<U[K]>>
+      ? SQLiteRealBuilder
       : U[K]['type'] extends 'integer'
-      ? IntegerBuilder<K, IsRequired<T, K>, HasDefault<U[K]>>
+      ? SQLiteIntegerBuilder
       : U[K]['type'] extends 'array' | 'object'
-      ? JsonBuilder<K, TObjectType[K], IsRequired<T, K>, HasDefault<U[K]>>
+      ? $Type<SQLiteTextJsonBuilder, TObjectType[K]>
       : never
     : never
-} & { forks: JsonBuilder<'forks', string[], true, false> }
+} & { forks: $Type<SQLiteTextJsonBuilder, string[]> }
 
 export type NonEmptyArray<T> = [T, ...T[]]

package/src/translation-api.js

@@ -1,9 +1,11 @@
-import { and, sql } from 'drizzle-orm'
+import { and, eq, inArray, sql } from 'drizzle-orm'
 import { kCreateWithDocId, kSelect } from './datatype/index.js'
 import { deNullify, hashObject } from './utils.js'
 import { nullIfNotFound } from './errors.js'
 import { omit } from './lib/omit.js'
-/** @import { Translation, TranslationValue } from '@comapeo/schema' */
+import { iso6391To6393, iso6393To6391 } from './intl/iso639.js'
+import { translationTable } from './schema/project.js'
+/** @import { MapeoDoc, Translation, TranslationValue } from '@comapeo/schema' */
 /** @import { SetOptional } from 'type-fest' */
 
 export const ktranslatedLanguageCodeToSchemaNames = Symbol(
@@ -14,6 +16,9 @@ export default class TranslationApi {
    * TranslationValue['languageCode'],
    * Set<import('@comapeo/schema/dist/types.js').SchemaName>>} */
   #translatedLanguageCodeToSchemaNames = new Map()
+  // A bug in previous versions meant that translations were stored with ISO
+  // 639-1 codes, so we need to handle backwards compatibility for that case.
+  #hasLegacyIso6391Translations = false
   #dataType
   #indexPromise
 
@@ -35,7 +40,7 @@ export default class TranslationApi {
         docs.map((doc) => this.index(doc))
       })
       .catch((err) => {
-        throw new Error(`error loading Translation cache: ${err}`)
+        console.error(`error loading Translation cache: ${err}`)
       })
   }
 
@@ -69,19 +74,48 @@ export default class TranslationApi {
   async get(value) {
     await this.ready()
 
-    const docTypeIsTranslatedToLanguage =
-      this.#translatedLanguageCodeToSchemaNames
-        .get(value.languageCode)
-        ?.has(
-          /** @type {import('@comapeo/schema/dist/types.js').SchemaName} */ (
-            value.docRefType
-          )
+    // Allow this API to accept both ISO 639-1 and ISO 639-3 codes for languageCode
+    const normalizedLanguageCode =
+      value.languageCode.length === 2
+        ? iso6391To6393.get(value.languageCode)
+        : value.languageCode
+    if (!normalizedLanguageCode) return [] // invalid language code
+
+    const languageCodesToQuery = [normalizedLanguageCode]
+
+    // A bug in previous versions meant that translations could be stored with
+    // ISO 639-1 codes, so we need to query for both in this case by looking up
+    // the ISO 639-1 code for the langauge, and then checking whether there are
+    // translations for that language (looking up in our in-memory index saves
+    // an extra sqlite query when unnecessary)
+    if (this.#hasLegacyIso6391Translations) {
+      const iso6391LanguageCode =
+        value.languageCode.length === 2
+          ? value.languageCode
+          : iso6393To6391.get(value.languageCode)
+      const isTranslationStoredWithIso6391Code =
+        iso6391LanguageCode &&
+        this.#isTranslated(
+          /** @type {MapeoDoc['schemaName']} */
+          (value.docRefType),
+          iso6391LanguageCode
         )
+      if (isTranslationStoredWithIso6391Code) {
+        languageCodesToQuery.push(iso6391LanguageCode)
+      }
+    }
+
+    const docTypeIsTranslatedToLanguage =
+      this.#isTranslated(
+        /** @type {MapeoDoc['schemaName']} */
+        (value.docRefType),
+        normalizedLanguageCode
+      ) || languageCodesToQuery.length > 1
     if (!docTypeIsTranslatedToLanguage) return []
 
     const filters = [
-      sql`docRefType = ${value.docRefType}`,
-      sql`languageCode = ${value.languageCode}`,
+      eq(translationTable.docRefType, value.docRefType),
+      inArray(translationTable.languageCode, languageCodesToQuery),
       sql`json_extract(docRef, '$.docId') = ${value.docRef.docId}`,
     ]
 
@@ -94,7 +128,9 @@ export default class TranslationApi {
       filters.push(sql`propertyRef = ${value.propertyRef}`)
     }
     if (value.regionCode) {
-      filters.push(sql`regionCode = ${value.regionCode}`)
+      // Use COLLATE NOCASE for case-insensitive matching because in previous
+      // versions we did not normalize regionCode to uppercase.
+      filters.push(sql`regionCode = ${value.regionCode} COLLATE NOCASE`)
     }
 
     return (await this.#dataType[kSelect]())
@@ -118,6 +154,9 @@ export default class TranslationApi {
         translatedSchemas
       )
     }
+    if (doc.languageCode.length === 2) {
+      this.#hasLegacyIso6391Translations = true
+    }
     translatedSchemas.add(
       /** @type {import('@comapeo/schema/dist/types.js').SchemaName} */ (
         doc.docRefType
@@ -125,6 +164,19 @@ export default class TranslationApi {
     )
   }
 
+  /**
+   * @param {MapeoDoc['schemaName']} docType
+   * @param {string} languageCode
+   * @returns {boolean}
+   */
+  #isTranslated(docType, languageCode) {
+    return (
+      this.#translatedLanguageCodeToSchemaNames
+        .get(languageCode)
+        ?.has(docType) || false
+    )
+  }
+
   // This should only be used by tests.
   get [ktranslatedLanguageCodeToSchemaNames]() {
     return this.#translatedLanguageCodeToSchemaNames

package/src/types.ts

@@ -74,25 +74,6 @@ export type CoreOwnershipWithSignaturesValue = Omit<
   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.
  */
@@ -106,7 +87,17 @@ export type MapBuffers<T> = {
  * top-level optional props set to `null`) to the original types in
  * @comapeo/schema
  */
-export type NullableToOptional<T> = Simplify<RemoveNull<NullToOptional<T>>>
+export type NullableToOptional<T> = Simplify<
+  {
+    [K in keyof T as null extends T[K] ? K : never]?: Exclude<T[K], null>
+  } & {
+    [K in keyof T as null extends T[K] ? never : K]: T[K]
+  }
+>
+export type OptionalToNullable<T> = Simplify<{
+  [K in keyof T]-?: T[K] | (undefined extends T[K] ? null : never)
+}>
+
 export type KeyPair = {
   publicKey: PublicKey
   secretKey: SecretKey

package/src/utils.js

@@ -87,7 +87,6 @@ export function isDefined(value) {
  * @param {T} obj
  * @returns {import('./types.js').NullableToOptional<T>}
  */
-
 export function deNullify(obj) {
   /** @type {Record<string, any>} */
   const objNoNulls = {}
@@ -98,9 +97,29 @@ export function deNullify(obj) {
 }
 
 /**
- * @template {import('@comapeo/schema').MapeoDoc & { forks?: string[] }} T
+ * __Mutating__
+ * 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 mutatingDeNullify(obj) {
+  for (const key of Object.keys(obj)) {
+    // @ts-expect-error
+    if (obj[key] === null) {
+      // @ts-expect-error
+      obj[key] = undefined
+    }
+  }
+  return /** @type {import('./types.js').NullableToOptional<T>} */ (obj)
+}
+
+/**
+ * @template {import('@comapeo/schema').MapeoDoc & { forks?: string[], createdBy?: string, updatedBy?: string }} T
  * @param {T} doc
- * @returns {Omit<T, 'docId' | 'versionId' | 'originalVersionId' | 'links' | 'forks' | 'createdAt' | 'updatedAt' | 'deleted'>}
+ * @returns {Omit<T, 'docId' | 'versionId' | 'originalVersionId' | 'links' | 'forks' | 'createdAt' | 'updatedAt' | 'createdBy' | 'updatedBy' | 'deleted' >}
  */
 export function valueOf(doc) {
   return omit(doc, [
@@ -111,6 +130,8 @@ export function valueOf(doc) {
     'forks',
     'createdAt',
     'updatedAt',
+    'createdBy',
+    'updatedBy',
     'deleted',
   ])
 }
@@ -219,3 +240,16 @@ export function buildBlobId(attachment, requestedVariant) {
     driveId: attachment.driveDiscoveryId,
   }
 }
+
+/**
+ * Get typed entries from an object. Use this only on objects that you are
+ * certain have no extra properties - TS does not check for extra properties on
+ * an object, which is why Object.entries is untyped by default.
+ *
+ * @template {Record<string, unknown>} T
+ * @param {T} obj - The object to get entries from (must _not_ have extra properties)
+ * @returns {import('type-fest').Entries<T>}
+ */
+export function typedEntries(obj) {
+  return /** @type {import('type-fest').Entries<T>} */ (Object.entries(obj))
+}