add project settings functionality to MapeoProject

drizzle/client/0000_green_sir_ram.sql → drizzle/client/0000_medical_ser_duncan.sql

@@ -14,7 +14,7 @@ CREATE TABLE `project` (
 	`createdAt` text NOT NULL,
 	`updatedAt` text NOT NULL,
 	`links` text NOT NULL,
-	`name` text NOT NULL,
-	`defaultPresets` text NOT NULL,
+	`name` text,
+	`defaultPresets` text,
 	`forks` text NOT NULL
 );

drizzle/client/meta/0000_snapshot.json

@@ -1,7 +1,7 @@
 {
   "version": "5",
   "dialect": "sqlite",
-  "id": "9bca3bea-0cdd-4406-891f-9b75e68a94e7",
+  "id": "922e15d1-08b4-424d-bb86-b4d11cae3be4",
   "prevId": "00000000-0000-0000-0000-000000000000",
   "tables": {
     "project_backlink": {
@@ -92,14 +92,14 @@
           "name": "name",
           "type": "text",
           "primaryKey": false,
-          "notNull": true,
+          "notNull": false,
           "autoincrement": false
         },
         "defaultPresets": {
           "name": "defaultPresets",
           "type": "text",
           "primaryKey": false,
-          "notNull": true,
+          "notNull": false,
           "autoincrement": false
         },
         "forks": {

drizzle/client/meta/_journal.json

@@ -5,8 +5,8 @@
     {
       "idx": 0,
       "version": "5",
-      "when": 1692208651901,
-      "tag": "0000_green_sir_ram",
+      "when": 1692799838836,
+      "tag": "0000_medical_ser_duncan",
       "breakpoints": true
     }
   ]

package.json

@@ -96,7 +96,7 @@
     "@fastify/type-provider-typebox": "^3.3.0",
     "@hyperswarm/secret-stream": "^6.1.2",
     "@mapeo/crypto": "^1.0.0-alpha.4",
-    "@mapeo/schema": "^3.0.0-next.6",
+    "@mapeo/schema": "^3.0.0-next.8",
     "@mapeo/sqlite-indexer": "^1.0.0-alpha.5",
     "@sinclair/typebox": "^0.29.6",
     "b4a": "^1.6.3",

src/datastore/index.js

@@ -25,7 +25,7 @@ import pDefer from 'p-defer'
 
 const NAMESPACE_SCHEMAS = /** @type {const} */ ({
   data: ['observation'],
-  config: ['preset', 'field'],
+  config: ['preset', 'field', 'project'],
   auth: [],
 })
 

src/mapeo-project.js

@@ -1,17 +1,22 @@
 // @ts-check
+import { decodeBlockPrefix } from '@mapeo/schema'
 import { drizzle } from 'drizzle-orm/better-sqlite3'
 import { migrate } from 'drizzle-orm/better-sqlite3/migrator'
 
 import { CoreManager } from './core-manager/index.js'
 import { DataStore } from './datastore/index.js'
-import { DataType } from './datatype/index.js'
+import { DataType, kCreateWithDocId } from './datatype/index.js'
 import { IndexWriter } from './index-writer/index.js'
+import { projectTable } from './schema/client.js'
 import { fieldTable, observationTable, presetTable } from './schema/project.js'
 import RandomAccessFile from 'random-access-file'
 import RAM from 'random-access-memory'
 import Database from 'better-sqlite3'
 import path from 'path'
 import { RandomAccessFilePool } from './core-manager/random-access-file-pool.js'
+import { valueOf } from './utils.js'
+
+/** @typedef {Omit<import('@mapeo/schema').ProjectValue, 'schemaName'>} EditableProjectSettings */
 
 const PROJECT_SQLITE_FILE_NAME = 'project.db'
 const CORE_STORAGE_FOLDER_NAME = 'cores'
@@ -26,6 +31,7 @@ export class MapeoProject {
   #coreManager
   #dataStores
   #dataTypes
+  #projectId
 
   /**
    * @param {Object} opts
@@ -34,8 +40,18 @@ export class MapeoProject {
    * @param {Buffer} opts.projectKey 32-byte public key of the project creator core
    * @param {Buffer} [opts.projectSecretKey] 32-byte secret key of the project creator core
    * @param {Partial<Record<import('./core-manager/index.js').Namespace, Buffer>>} [opts.encryptionKeys] Encryption keys for each namespace
+   * @param {import('drizzle-orm/better-sqlite3').BetterSQLite3Database} opts.sharedDb
+   * @param {IndexWriter} opts.sharedIndexWriter
    */
-  constructor({ storagePath, ...coreManagerOpts }) {
+  constructor({
+    storagePath,
+    sharedDb,
+    sharedIndexWriter,
+    ...coreManagerOpts
+  }) {
+    // TODO: Update to use @mapeo/crypto when ready (https://github.com/digidem/mapeo-core-next/issues/171)
+    this.#projectId = coreManagerOpts.projectKey.toString('hex')
+
     ///////// 1. Setup database
 
     const dbPath =
@@ -86,7 +102,11 @@ export class MapeoProject {
       config: new DataStore({
         coreManager: this.#coreManager,
         namespace: 'config',
-        batch: (entries) => indexWriter.batch(entries),
+        batch: (entries) =>
+          this.#handleConfigEntries(entries, {
+            datastoreIndexWriter: indexWriter,
+            sharedIndexWriter,
+          }),
         storage: indexerStorage,
       }),
       data: new DataStore({
@@ -112,9 +132,47 @@ export class MapeoProject {
         table: fieldTable,
         db,
       }),
+      project: new DataType({
+        dataStore: this.#dataStores.config,
+        table: projectTable,
+        db: sharedDb,
+      }),
     }
   }
 
+  /**
+   * @param {import('multi-core-indexer').Entry[]} entries
+   * @param {{datastoreIndexWriter: IndexWriter, sharedIndexWriter: IndexWriter}} indexWriters
+   */
+  async #handleConfigEntries(
+    entries,
+    { datastoreIndexWriter, sharedIndexWriter }
+  ) {
+    /** @type {import('multi-core-indexer').Entry[]} */
+    const projectSettingsEntries = []
+    /** @type {import('multi-core-indexer').Entry[]} */
+    const otherEntries = []
+
+    for (const entry of entries) {
+      try {
+        const { schemaName } = decodeBlockPrefix(entry.block)
+
+        if (schemaName === 'project') {
+          projectSettingsEntries.push(entry)
+        } else {
+          otherEntries.push(entry)
+        }
+      } catch {
+        // Ignore errors thrown by values that can't be decoded for now
+      }
+    }
+
+    await Promise.all([
+      datastoreIndexWriter.batch(otherEntries),
+      sharedIndexWriter.batch(projectSettingsEntries),
+    ])
+  }
+
   get observation() {
     return this.#dataTypes.observation
   }
@@ -124,4 +182,58 @@ export class MapeoProject {
   get field() {
     return this.#dataTypes.field
   }
+
+  /**
+   * @param {Partial<EditableProjectSettings>} settings
+   * @returns {Promise<EditableProjectSettings>}
+   */
+  async $setProjectSettings(settings) {
+    const { project } = this.#dataTypes
+
+    // We only want to catch the error to the getByDocId call
+    // Using try/catch for this is a little verbose when dealing with TS types
+    const existing = await project.getByDocId(this.#projectId).catch(() => {
+      // project does not exist so return null
+      return null
+    })
+
+    if (existing) {
+      return extractEditableProjectSettings(
+        await project.update([existing.versionId, ...existing.forks], {
+          ...valueOf(existing),
+          ...settings,
+        })
+      )
+    }
+
+    return extractEditableProjectSettings(
+      await project[kCreateWithDocId](this.#projectId, {
+        ...settings,
+        schemaName: 'project',
+      })
+    )
+  }
+
+  /**
+   * @returns {Promise<EditableProjectSettings>}
+   */
+  async $getProjectSettings() {
+    try {
+      return extractEditableProjectSettings(
+        await this.#dataTypes.project.getByDocId(this.#projectId)
+      )
+    } catch {
+      return /** @type {EditableProjectSettings} */ ({})
+    }
+  }
+}
+
+/**
+ * @param {import("@mapeo/schema").Project & { forks: string[] }} projectDoc
+ * @returns {EditableProjectSettings}
+ */
+function extractEditableProjectSettings(projectDoc) {
+  // eslint-disable-next-line no-unused-vars
+  const { schemaName, ...result } = valueOf(projectDoc)
+  return result
 }

src/utils.js

@@ -79,3 +79,14 @@ export function deNullify(obj) {
   }
   return /** @type {import('./types.js').NullableToOptional<T>} */ (objNoNulls)
 }
+
+/**
+ * @template {import('@mapeo/schema').MapeoDoc & { forks: string[] }} T
+ * @param {T} doc
+ * @returns {Omit<T, 'docId' | 'versionId' | 'links' | 'forks' | 'createdAt' | 'updatedAt'>}
+ */
+export function valueOf(doc) {
+  // eslint-disable-next-line no-unused-vars
+  const { docId, versionId, links, forks, createdAt, updatedAt, ...rest } = doc
+  return rest
+}

test-e2e/project-crud.js

@@ -1,7 +1,7 @@
 import { test } from 'brittle'
 import { randomBytes } from 'crypto'
-import { KeyManager } from '@mapeo/crypto'
-import { MapeoProject } from '../src/mapeo-project.js'
+import { valueOf } from '../src/utils.js'
+import { setupSharedResources, createProject } from './utils.js'
 
 /** @satisfies {Array<import('@mapeo/schema').MapeoValue>} */
 const fixtures = [
@@ -61,18 +61,25 @@ function getUpdateFixture(value) {
 }
 
 test('CRUD operations', async (t) => {
+  const shared = setupSharedResources()
   for (const value of fixtures) {
     const { schemaName } = value
     t.test(`create and read ${schemaName}`, async (t) => {
-      const project = await createProject()
+      const project = createProject({
+        sharedDb: shared.db,
+        sharedIndexWriter: shared.indexWriter,
+      })
       // @ts-ignore - TS can't figure this out, but we're not testing types here so ok to ignore
       const written = await project[schemaName].create(value)
       const read = await project[schemaName].getByDocId(written.docId)
       t.alike(valueOf(stripUndef(written)), value, 'expected value is written')
       t.alike(written, read, 'return create() matches return of getByDocId()')
     })
     t.test('update', async (t) => {
-      const project = await createProject()
+      const project = createProject({
+        sharedDb: shared.db,
+        sharedIndexWriter: shared.indexWriter,
+      })
       // @ts-ignore
       const written = await project[schemaName].create(value)
       const updateValue = getUpdateFixture(value)
@@ -96,7 +103,10 @@ test('CRUD operations', async (t) => {
       t.is(written.createdAt, updated.createdAt, 'createdAt does not change')
     })
     t.test('getMany', async (t) => {
-      const project = await createProject()
+      const project = createProject({
+        sharedDb: shared.db,
+        sharedIndexWriter: shared.indexWriter,
+      })
       const values = new Array(5).fill(null).map(() => {
         return getUpdateFixture(value)
       })
@@ -115,28 +125,6 @@ test('CRUD operations', async (t) => {
   }
 })
 
-/**
- * @template {import('@mapeo/schema').MapeoDoc & { forks: string[] }} T
- * @param {T} doc
- * @returns {Omit<T, 'docId' | 'versionId' | 'links' | 'forks' | 'createdAt' | 'updatedAt'>}
- */
-function valueOf(doc) {
-  // eslint-disable-next-line no-unused-vars
-  const { docId, versionId, links, forks, createdAt, updatedAt, ...rest } = doc
-  return rest
-}
-
-function createProject({
-  rootKey = randomBytes(16),
-  projectKey = randomBytes(32),
-} = {}) {
-  const keyManager = new KeyManager(rootKey)
-  return new MapeoProject({
-    keyManager,
-    projectKey,
-  })
-}
-
 /**
  * Remove undefined properties from an object, to allow deep comparison
  * @param {object} obj

test-e2e/project-settings.js

@@ -0,0 +1,33 @@
+import { test } from 'brittle'
+import { setupSharedResources, createProject } from './utils.js'
+
+test('Project settings create, read, and update operations', async (t) => {
+  const shared = setupSharedResources()
+
+  const project = createProject({
+    sharedDb: shared.db,
+    sharedIndexWriter: shared.indexWriter,
+  })
+
+  t.alike(
+    await project.$getProjectSettings(),
+    {},
+    'no settings when project initially created'
+  )
+
+  const expectedSettings = {
+    name: 'updated',
+  }
+
+  const updatedSettings = await project.$setProjectSettings(expectedSettings)
+
+  t.is(updatedSettings.name, expectedSettings.name, 'updatable fields change')
+
+  const settings = await project.$getProjectSettings()
+
+  t.alike(
+    updatedSettings,
+    settings,
+    'retrieved settings are equivalent to most recently updated'
+  )
+})