@comapeo/core 4.4.0 → 5.0.0

package/src/intl/parse-bcp-47.js

@@ -0,0 +1,91 @@
+import { parse as simpleParseBcp47 } from 'bcp-47'
+import { bcp47Normalize } from 'bcp-47-normalize'
+import { iso6391To6393, iso6393 } from './iso639.js'
+import { iso31661 } from 'iso-3166'
+import { iso31661Alpha3ToAlpha2 } from 'iso-3166'
+import { unM49 as unM49Array } from 'un-m49'
+
+/**
+ * Map of UN M.49 country codes to their corresponding ISO 3166-1 alpha-2 country codes.
+ */
+const unM49ToIso31661Alpha2 = new Map()
+
+for (const region of unM49Array) {
+  if (!region.iso3166) continue
+  const alpha2 = iso31661Alpha3ToAlpha2[region.iso3166]
+  if (!alpha2) continue
+  unM49ToIso31661Alpha2.set(region.code, alpha2)
+}
+
+/**
+ * Normalizes the region subtag of the IETF language tag validating that the
+ * subtag is a valid UN M.49 geographical region code or a valid ISO 3166-1
+ * alpha-2 country code, and using the ISO 3166-1 alpha-2 country code if one
+ * exists for countries represented by UN M.49 codes.
+ *
+ * @param {string} subtag - A region subtag from an IETF BCP 47 language tag.
+ * @returns {string | null} - The normalized region subtag, or null if the input is not valid.
+ */
+function normalizeRegionSubtag(subtag) {
+  if (!unM49.has(subtag) && !iso31661Alpha2.has(subtag)) {
+    return null
+  }
+  if (unM49ToIso31661Alpha2.has(subtag)) {
+    subtag = unM49ToIso31661Alpha2.get(subtag)
+  }
+  return subtag.toUpperCase()
+}
+
+/**
+ * Set of all valid UN M.49 geographical region codes.
+ */
+const unM49 = new Set(unM49Array.map((region) => region.code))
+
+/**
+ * Set of all valid ISO 3166-1 alpha-2 country codes.
+ */
+const iso31661Alpha2 = new Set(iso31661.map((country) => country.alpha2))
+
+/**
+ * Normalize a primary language subtag to ISO 639-3 if possible.
+ * @param {string} subtag - The primary language subtag to normalize.
+ * @returns {string | null} - The normalized ISO 639-3 language code, or null if the input is not valid.
+ */
+function normalizePrimaryLanguageSubtag(subtag) {
+  if (subtag.length === 2) {
+    return iso6391To6393.get(subtag) || null
+  } else if (subtag.length === 3) {
+    return iso6393.has(subtag) ? subtag : null
+  }
+  // Only support ISO 639-1 and ISO 639-3 codes as primary language subtags
+  return null
+}
+
+/**
+ * A stricter parsing of BCP 47 language tags than the one provided by the
+ * `bcp-47` package, which does not check if the subtags are valid, and does not
+ * normalize the subtag. Primary language subtags other than ISO 639-1 or ISO
+ * 639-3 are ignored (parses as null). Subtags other than primary language and
+ * region are ignored. ISO 639-1 codes are converted to their ISO 639-3
+ * equivalent. UN M.49 region codes are converted to their ISO 3166-1 alpha-2
+ * equivalent if one exists.
+ *
+ * Will throw an error if the input is not a valid BCP 47 language tag, but will
+ * return language: null without throwing if the primary language subtag does
+ * not match our stricter criteria of requiring an ISO 639-1 or ISO 639-3
+ * subtag.
+ *
+ * @param {string} languageTag - A BCP 47 language tag.
+ * @returns {{language: string | null | undefined, region: string | null | undefined}} - The parsed and normalized language and region subtags, or null if the input is not valid.
+ */
+export function parseBcp47(languageTag) {
+  const normalized = bcp47Normalize(languageTag)
+  const { language, region } = simpleParseBcp47(normalized)
+  if (!language) {
+    throw new Error(`Invalid BCP 47 language tag: ${languageTag}`)
+  }
+  return {
+    language: normalizePrimaryLanguageSubtag(language),
+    region: region && normalizeRegionSubtag(region),
+  }
+}

package/src/invite/invite-api.js

@@ -126,6 +126,7 @@ export class InviteApi extends TypedEmitter {
       projectName,
       projectColor,
       projectDescription,
+      sendStats,
     } = inviteRpcMessage
     const invite = { ...inviteRpcMessage, receivedAt: Date.now() }
 
@@ -161,6 +162,7 @@ export class InviteApi extends TypedEmitter {
               projectName,
               projectColor,
               projectDescription,
+              sendStats,
             })
           }),
         },

package/src/lib/drizzle-helpers.js

@@ -1,4 +1,6 @@
 import { sql } from 'drizzle-orm'
+import fs from 'node:fs'
+import path from 'node:path'
 import { assert } from '../utils.js'
 import { migrate as drizzleMigrate } from 'drizzle-orm/better-sqlite3/migrator'
 import { DRIZZLE_MIGRATIONS_TABLE } from '../constants.js'
@@ -20,33 +22,31 @@ const getNumberResult = (queryResult) => {
 }
 
 /**
- * Get the number of rows in a table using `SELECT COUNT(*)`.
- * Returns 0 if the table doesn't exist.
+ * Get the latest migration time, or 0 if no migrations have been run or the
+ * migrations table has not been created yet.
  *
  * @param {BetterSQLite3Database} db
- * @param {string} tableName
  * @returns {number}
  */
-const safeCountTableRows = (db, tableName) =>
+const safeGetLatestMigrationMillis = (db) =>
   db.transaction((tx) => {
     const existsQuery = sql`
       SELECT EXISTS (
         SELECT 1
         FROM sqlite_schema
         WHERE type IS 'table'
-        AND name IS ${tableName}
+        AND name IS ${DRIZZLE_MIGRATIONS_TABLE}
       ) AS result
     `
     const existsResult = tx.get(existsQuery)
     const exists = getNumberResult(existsResult)
     if (!exists) return 0
 
-    const countQuery = sql`
-      SELECT COUNT(*) AS result
-      FROM ${sql.identifier(tableName)}
-    `
-    const countResult = tx.get(countQuery)
-    return getNumberResult(countResult)
+    const latestMigrationQuery = sql`SELECT created_at as result FROM ${sql.identifier(
+      DRIZZLE_MIGRATIONS_TABLE
+    )} ORDER BY created_at DESC LIMIT 1`
+
+    return getNumberResult(tx.get(latestMigrationQuery))
   })
 
 /**
@@ -55,25 +55,77 @@ const safeCountTableRows = (db, tableName) =>
  */
 
 /**
- * Wrapper around Drizzle's migration function. Returns what happened during
- * migration; did a migration occur?
+ * Migrate db with optional JS migration functions for each migration step.
+ * Useful if some code needs to run for a particular migration step, to avoid
+ * running it unnecessarily for every new instance.
+ *
+ * Returns what happened during migration; did a migration occur?
  *
  * @param {BetterSQLite3Database} db
  * @param {object} options
  * @param {string} options.migrationsFolder
+ * @param {Record<string, (db: BetterSQLite3Database) => void>} [options.migrationFns]
  * @returns {MigrationResult}
  */
-export const migrate = (db, { migrationsFolder }) => {
-  const migrationsBefore = safeCountTableRows(db, DRIZZLE_MIGRATIONS_TABLE)
+export function migrate(db, { migrationsFolder, migrationFns = {} }) {
+  const journal = /** @type {unknown} */ (
+    JSON.parse(
+      fs.readFileSync(
+        path.join(migrationsFolder, 'meta/_journal.json'),
+        'utf-8'
+      )
+    )
+  )
+  // Drizzle _could_ decide to change the journal format in the future, but this
+  // assertion will ensure that tests fail if they do.
+  assertValidJournal(journal)
+
+  const prevMigrationMillis = safeGetLatestMigrationMillis(db)
+
   drizzleMigrate(db, {
     migrationsFolder,
     migrationsTable: DRIZZLE_MIGRATIONS_TABLE,
   })
-  const migrationsAfter = safeCountTableRows(db, DRIZZLE_MIGRATIONS_TABLE)
 
-  if (migrationsAfter === migrationsBefore) return 'no migration'
+  for (const entry of journal.entries) {
+    if (entry.when <= prevMigrationMillis) continue
+    const fn = migrationFns[entry.tag]
+    if (fn) fn(db)
+  }
+
+  const lastMigrationMillis = safeGetLatestMigrationMillis(db)
+
+  if (lastMigrationMillis === prevMigrationMillis) return 'no migration'
 
-  if (migrationsBefore === 0) return 'initialized database'
+  if (prevMigrationMillis === 0) return 'initialized database'
 
   return 'migrated'
 }
+
+/**
+ * Assert that the migration journal is the expected format.
+ * @param {unknown} journal
+ * @returns {asserts journal is { version: '5', entries: { tag: string, when: number }[] }}
+ */
+function assertValidJournal(journal) {
+  assert(journal && typeof journal === 'object', 'invalid journal')
+  assert(
+    'version' in journal && journal.version === '5',
+    'unexpected journal version'
+  )
+  assert(
+    'entries' in journal &&
+      Array.isArray(journal.entries) &&
+      journal.entries.every(
+        /** @param {unknown} m */
+        (m) =>
+          m &&
+          typeof m === 'object' &&
+          'tag' in m &&
+          typeof m.tag === 'string' &&
+          'when' in m &&
+          typeof m.when === 'number'
+      ),
+    'invalid entries in journal'
+  )
+}

package/src/mapeo-manager.js

@@ -4,7 +4,6 @@ import { KeyManager } from '@mapeo/crypto'
 import Database from 'better-sqlite3'
 import { eq } from 'drizzle-orm'
 import { drizzle } from 'drizzle-orm/better-sqlite3'
-import { migrate } from 'drizzle-orm/better-sqlite3/migrator'
 import Hypercore from 'hypercore'
 import { TypedEmitter } from 'tiny-typed-emitter'
 import pTimeout from 'p-timeout'
@@ -14,7 +13,7 @@ import { IndexWriter } from './index-writer/index.js'
 import {
   MapeoProject,
   kBlobStore,
-  kClearDataIfLeft,
+  kClearData,
   kProjectLeave,
   kSetIsArchiveDevice,
   kSetOwnDeviceInfo,
@@ -38,7 +37,6 @@ import {
   projectKeyToProjectInviteId,
   projectKeyToPublicId,
 } from './utils.js'
-import { UNIX_EPOCH_DATE } from './constants.js'
 import { openedNoiseSecretStream } from './lib/noise-secret-stream-helpers.js'
 import { omit } from './lib/omit.js'
 import { RandomAccessFilePool } from './core-manager/random-access-file-pool.js'
@@ -58,16 +56,20 @@ import {
 } from './sync/sync-api.js'
 import { NotFoundError } from './errors.js'
 import { WebSocket } from 'ws'
+import { excludeKeys } from 'filter-obj'
+import { migrate } from './lib/drizzle-helpers.js'
 
 /** @import NoiseSecretStream from '@hyperswarm/secret-stream' */
 /** @import { SetNonNullable } from 'type-fest' */
 /** @import { ProjectJoinDetails, } from './generated/rpc.js' */
 /** @import { CoreStorage, Namespace } from './types.js' */
 /** @import { DeviceInfoParam, ProjectInfo } from './schema/client.js' */
+/** @import { ProjectSettings, ProjectSettingsValue } from '@comapeo/schema' */
 
 /** @typedef {SetNonNullable<ProjectKeys, 'encryptionKeys'>} ValidatedProjectKeys */
-/** @typedef {Pick<ProjectJoinDetails, 'projectKey' | 'encryptionKeys'> & { projectName: string, projectColor?: string, projectDescription?: string }} ProjectToAddDetails */
-/** @typedef {{ projectId: string, createdAt?: string, updatedAt?: string, name?: string, projectColor?: string, projectDescription?: string }} ListedProject */
+/** @typedef {Pick<ProjectJoinDetails, 'projectKey' | 'encryptionKeys'> & { projectName: string, projectColor?: string, projectDescription?: string, sendStats?: boolean }} ProjectToAddDetails */
+/** @typedef {Pick<ProjectSettings, 'createdAt' | 'updatedAt' | 'name' | 'projectColor' | 'projectDescription' | 'sendStats'>} ListedProjectSettings */
+/** @typedef {ListedProjectSettings & { status: 'joined', projectId: string } | ProjectInfo & { status: 'joining' | 'left', projectId: string }} ListedProject */
 
 const CLIENT_SQLITE_FILE_NAME = 'client.db'
 
@@ -173,7 +175,12 @@ export class MapeoManager extends TypedEmitter {
     )
     sqlite.pragma('journal_mode=WAL')
     this.#db = drizzle(sqlite)
-    migrate(this.#db, { migrationsFolder: clientMigrationsFolder })
+    migrate(this.#db, {
+      migrationsFolder: clientMigrationsFolder,
+      migrationFns: {
+        '0004_glorious_shape': this.#migrateLeftProjects.bind(this),
+      },
+    })
 
     this.#localPeers = new LocalPeers({ logger })
     this.#localPeers.on('peers', (peers) => {
@@ -338,22 +345,55 @@ export class MapeoManager extends TypedEmitter {
   }
 
   /**
-   * @param {Object} opts
-   * @param {string} opts.projectId
-   * @param {string} opts.projectPublicId
-   * @param {Readonly<Buffer>} opts.projectInviteId
-   * @param {ProjectKeys} opts.projectKeys
-   * @param {Readonly<ProjectInfo>} [opts.projectInfo]
+   * The migration in file `0005_military_paper_doll.sql` adds a new
+   * `hasLeftProject` that is used to track if a user has left a project.
+   * Previously we did not have a way to track if a user had left a project,
+   * other than checking their own role within a project. However, we can also
+   * use the presence of an encryption key for the data cores as an indication
+   * of whether a user has left, because we delete this as part of the leave
+   * process, and we do not, prior to this migration, have any code which
+   * deletes that for other reasons.
    */
-  #saveToProjectKeysTable({
-    projectId,
-    projectPublicId,
-    projectInviteId,
-    projectKeys,
-    projectInfo,
-  }) {
+  #migrateLeftProjects() {
+    const existingProjectKeys = this.#db
+      .select({
+        projectId: projectKeysTable.projectId,
+        hasLeftProject: projectKeysTable.hasLeftProject,
+        keysCipher: projectKeysTable.keysCipher,
+      })
+      .from(projectKeysTable)
+      .all()
+    /** @type {{ projectId: string, hasLeftProject: boolean }[]} */
+    const toMigrate = []
+    for (const {
+      projectId,
+      hasLeftProject,
+      keysCipher,
+    } of existingProjectKeys) {
+      if (hasLeftProject) continue
+      const projectKeys = this.#decodeProjectKeysCipher(keysCipher, projectId)
+      if (projectKeys.encryptionKeys && !projectKeys.encryptionKeys.data) {
+        toMigrate.push({ projectId, hasLeftProject: true })
+      }
+    }
+    if (toMigrate.length === 0) return
+    this.#db.transaction((tx) => {
+      for (const { projectId, hasLeftProject } of toMigrate) {
+        tx.update(projectKeysTable)
+          .set({ hasLeftProject })
+          .where(eq(projectKeysTable.projectId, projectId))
+          .run()
+      }
+    })
+  }
+
+  /**
+   * Helper to encrypt project keys when saving to the projectKeys table
+   * @param {Omit<typeof projectKeysTable.$inferInsert, 'keysCipher'> & { projectKeys: ProjectKeys }} opts
+   */
+  #saveToProjectKeysTable({ projectKeys, ...values }) {
     const encoded = ProjectKeys.encode(projectKeys).finish()
-    const nonce = projectIdToNonce(projectId)
+    const nonce = projectIdToNonce(values.projectId)
 
     const keysCipher = this.#keyManager.encryptLocalMessage(
       Buffer.from(encoded.buffer, encoded.byteOffset, encoded.byteLength),
@@ -363,15 +403,12 @@ export class MapeoManager extends TypedEmitter {
     this.#db
       .insert(projectKeysTable)
       .values({
-        projectId,
-        projectPublicId,
-        projectInviteId,
         keysCipher,
-        projectInfo,
+        ...values,
       })
       .onConflictDoUpdate({
         target: projectKeysTable.projectId,
-        set: { projectPublicId, projectInviteId, keysCipher, projectInfo },
+        set: { keysCipher, ...values },
       })
       .run()
   }
@@ -481,6 +518,7 @@ export class MapeoManager extends TypedEmitter {
       .select({
         projectId: projectKeysTable.projectId,
         keysCipher: projectKeysTable.keysCipher,
+        hasLeftProject: projectKeysTable.hasLeftProject,
       })
       .from(projectKeysTable)
       .where(eq(projectKeysTable.projectPublicId, projectPublicId))
@@ -498,6 +536,13 @@ export class MapeoManager extends TypedEmitter {
     )
 
     const project = await this.#createProjectInstance(projectKeys)
+    // The leaveProject action could fail before completing, which would mean
+    // that data would not be cleared. To be safe, attempt to clear data when
+    // trying to create a project instance if we have marked the project as
+    // "left".
+    if (projectKeysTableResult.hasLeftProject) {
+      await project[kClearData]()
+    }
 
     project.once('close', () => {
       this.#activeProjects.delete(projectPublicId)
@@ -526,15 +571,22 @@ export class MapeoManager extends TypedEmitter {
       getMediaBaseUrl: this.#getMediaBaseUrl.bind(this),
       isArchiveDevice,
       makeWebsocket: this.#makeWebsocket,
+      getFallbackProjectInfo: () => {
+        return this.#db
+          .select({ projectInfo: projectKeysTable.projectInfo })
+          .from(projectKeysTable)
+          .where(eq(projectKeysTable.projectId, projectId))
+          .get()?.projectInfo
+      },
     })
-    await project[kClearDataIfLeft]()
     return project
   }
 
   /**
+   * @param {{ includeLeft?: boolean }} [opts]
    * @returns {Promise<Array<ListedProject>>}
    */
-  async listProjects() {
+  async listProjects({ includeLeft = false } = {}) {
     // We use the project keys table as the source of truth for projects that exist
     // because we will always update this table when doing a create or add
     // whereas the project table will only have projects that have been created, or added + synced
@@ -543,21 +595,27 @@ export class MapeoManager extends TypedEmitter {
         projectId: projectKeysTable.projectId,
         projectPublicId: projectKeysTable.projectPublicId,
         projectInfo: projectKeysTable.projectInfo,
+        hasLeftProject: projectKeysTable.hasLeftProject,
       })
       .from(projectKeysTable)
       .all()
 
-    const allProjectsResult = this.#db
-      .select({
-        projectId: projectSettingsTable.docId,
-        createdAt: projectSettingsTable.createdAt,
-        updatedAt: projectSettingsTable.updatedAt,
-        name: projectSettingsTable.name,
-        projectColor: projectSettingsTable.projectColor,
-        projectDescription: projectSettingsTable.projectDescription,
-      })
-      .from(projectSettingsTable)
-      .all()
+    const allProjectSettingsResult =
+      /** @satisfies {Array<ListedProjectSettings>} */ (
+        this.#db
+          .select({
+            docId: projectSettingsTable.docId,
+            createdAt: projectSettingsTable.createdAt,
+            updatedAt: projectSettingsTable.updatedAt,
+            name: projectSettingsTable.name,
+            projectColor: projectSettingsTable.projectColor,
+            projectDescription: projectSettingsTable.projectDescription,
+            sendStats: projectSettingsTable.sendStats,
+          })
+          .from(projectSettingsTable)
+          .all()
+          .map((p) => deNullify(p))
+      )
 
     /** @type {Array<ListedProject>} */
     const result = []
@@ -566,26 +624,31 @@ export class MapeoManager extends TypedEmitter {
       projectId,
       projectPublicId,
       projectInfo,
+      hasLeftProject,
     } of allProjectKeysResult) {
-      const existingProject = allProjectsResult.find(
-        (p) => p.projectId === projectId
+      const projectSettings = allProjectSettingsResult.find(
+        (p) => p.docId === projectId
       )
 
-      if (!existingProject) continue
-
-      result.push(
-        deNullify({
+      if (hasLeftProject && includeLeft) {
+        result.push({
+          ...projectInfo,
           projectId: projectPublicId,
-          createdAt: ignoreUnixDate(existingProject?.createdAt),
-          updatedAt: ignoreUnixDate(existingProject?.updatedAt),
-          name: existingProject?.name || projectInfo.name,
-          projectColor:
-            existingProject?.projectColor || projectInfo.projectColor,
-          projectDescription:
-            existingProject?.projectDescription ||
-            projectInfo.projectDescription,
+          status: 'left',
         })
-      )
+      } else if (projectSettings) {
+        result.push({
+          ...excludeKeys(projectSettings, ['docId']),
+          projectId: projectPublicId,
+          status: 'joined',
+        })
+      } else if (!hasLeftProject) {
+        result.push({
+          ...projectInfo,
+          projectId: projectPublicId,
+          status: 'joining',
+        })
+      }
     }
 
     return result
@@ -607,6 +670,7 @@ export class MapeoManager extends TypedEmitter {
       projectName,
       projectColor,
       projectDescription,
+      sendStats = false,
     },
     { waitForSync = true } = {}
   ) => {
@@ -631,6 +695,7 @@ export class MapeoManager extends TypedEmitter {
       .get()
 
     if (projectExists) {
+      // TODO: Define behavior for adding a project that the user has left
       throw new Error(`Project with ID ${projectPublicId} already exists`)
     }
 
@@ -645,7 +710,12 @@ export class MapeoManager extends TypedEmitter {
         projectKey,
         encryptionKeys,
       },
-      projectInfo: { name: projectName, projectColor, projectDescription },
+      projectInfo: {
+        name: projectName,
+        projectColor,
+        projectDescription,
+        sendStats,
+      },
     })
 
     // Any errors from here we need to remove project from db because it has not
@@ -653,24 +723,6 @@ export class MapeoManager extends TypedEmitter {
     let project = null
     try {
       project = await this.getProject(projectPublicId)
-
-      /** @type {import('drizzle-orm').InferInsertModel<typeof projectSettingsTable>} */
-      const settingsDoc = {
-        schemaName: 'projectSettings',
-        docId: projectId,
-        versionId: 'unknown',
-        originalVersionId: 'unknown',
-        createdAt: UNIX_EPOCH_DATE,
-        updatedAt: UNIX_EPOCH_DATE,
-        deleted: false,
-        sendStats: false,
-        links: [],
-        forks: [],
-        name: projectName,
-        projectDescription,
-      }
-
-      await this.#db.insert(projectSettingsTable).values([settingsDoc])
       this.#activeProjects.set(projectPublicId, project)
     } catch (e) {
       // Only happens if getProject or the the DB insert fails
@@ -740,6 +792,9 @@ export class MapeoManager extends TypedEmitter {
     // in the config store - defining the name of the project.
     // TODO: Enforce adding a project name in the invite method
     const isConfigSynced = configState.want === 0 && configState.have > 0
+    if (isRoleSynced && ownRole.sync.config === 'blocked' && isAuthSynced) {
+      return true
+    }
     if (
       isRoleSynced &&
       isProjectSettingsSynced &&
@@ -751,6 +806,7 @@ export class MapeoManager extends TypedEmitter {
       this.#l.log(
         'Pending initial sync: role %s, projectSettings %o, auth %o, config %o',
         isRoleSynced,
+        isProjectSettingsSynced,
         isAuthSynced,
         isConfigSynced
       )
@@ -759,12 +815,15 @@ export class MapeoManager extends TypedEmitter {
       /** @param {import('./sync/sync-state.js').State} syncState */
       const onSyncState = (syncState) => {
         clearTimeout(timeoutId)
-        if (syncState.auth.dataToSync || syncState.config.dataToSync) {
+        if (
+          syncState.auth.dataToSync ||
+          (syncState.config.dataToSync && ownRole.sync.config === 'allowed')
+        ) {
           timeoutId = setTimeout(onTimeout, timeoutMs)
           return
         }
         project.$sync[kSyncState].off('state', onSyncState)
-        resolve(this.#waitForInitialSync(project, { timeoutMs }))
+        this.#waitForInitialSync(project, { timeoutMs }).then(resolve, reject)
       }
       const onTimeout = () => {
         project.$sync[kSyncState].off('state', onSyncState)
@@ -953,10 +1012,6 @@ export class MapeoManager extends TypedEmitter {
    * @param {string} projectPublicId
    */
   async leaveProject(projectPublicId) {
-    const project = await this.getProject(projectPublicId)
-
-    await project[kProjectLeave]()
-
     const row = this.#db
       .select({
         keysCipher: projectKeysTable.keysCipher,
@@ -990,6 +1045,7 @@ export class MapeoManager extends TypedEmitter {
         ...projectKeys,
         encryptionKeys: updatedEncryptionKeys,
       },
+      hasLeftProject: true,
     })
 
     this.#db
@@ -997,6 +1053,10 @@ export class MapeoManager extends TypedEmitter {
       .where(eq(projectSettingsTable.docId, projectId))
       .run()
 
+    const project = await this.getProject(projectPublicId)
+
+    await project[kProjectLeave]()
+
     this.#activeProjects.delete(projectPublicId)
   }
 
@@ -1041,13 +1101,3 @@ function validateProjectKeys(projectKeys) {
 function hasSavedDeviceInfo(partialDeviceInfo) {
   return Boolean(partialDeviceInfo.name)
 }
-
-/**
- * @param {string|undefined} date
- * @returns {string|null}
- */
-function ignoreUnixDate(date) {
-  if (date === UNIX_EPOCH_DATE) return null
-  if (date === undefined) return null
-  return date
-}