implement addProject method for MapeoManager class

drizzle/client/0000_absent_russian.sql → drizzle/client/0000_steady_jackpot.sql

@@ -4,7 +4,8 @@ CREATE TABLE `project_backlink` (
 --> statement-breakpoint
 CREATE TABLE `projectKeys` (
 	`projectId` text PRIMARY KEY NOT NULL,
-	`keysCipher` blob NOT NULL
+	`keysCipher` blob NOT NULL,
+	`projectInfo` text DEFAULT '{}' NOT NULL
 );
 --> statement-breakpoint
 CREATE TABLE `project` (

drizzle/client/meta/0000_snapshot.json

@@ -1,7 +1,7 @@
 {
   "version": "5",
   "dialect": "sqlite",
-  "id": "adc33ec5-2e25-4d2b-91dc-f05686cb135a",
+  "id": "a4afa0b6-5fd1-4c8d-bc09-7e3f3fc1928f",
   "prevId": "00000000-0000-0000-0000-000000000000",
   "tables": {
     "project_backlink": {
@@ -36,6 +36,14 @@
           "primaryKey": false,
           "notNull": true,
           "autoincrement": false
+        },
+        "projectInfo": {
+          "name": "projectInfo",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'{}'"
         }
       },
       "indexes": {},

drizzle/client/meta/_journal.json

@@ -5,8 +5,8 @@
     {
       "idx": 0,
       "version": "5",
-      "when": 1692809392300,
-      "tag": "0000_absent_russian",
+      "when": 1693337118674,
+      "tag": "0000_steady_jackpot",
       "breakpoints": true
     }
   ]

src/mapeo-manager.js

@@ -47,6 +47,37 @@ export class MapeoManager {
     this.#activeProjects = new Map()
   }
 
+  /**
+   * @param {Buffer} keysCipher
+   * @param {string} projectId
+   * @returns {ProjectKeys}
+   */
+  #decodeProjectKeysCipher(keysCipher, projectId) {
+    return ProjectKeys.decode(
+      this.#keyManager.decryptLocalMessage(keysCipher, projectId)
+    )
+  }
+
+  /**
+   * @param {Object} opts
+   * @param {string} opts.projectId
+   * @param {ProjectKeys} opts.projectKeys
+   * @param {import('./generated/rpc.js').Invite_ProjectInfo} [opts.projectInfo]
+   */
+  #saveToProjectKeysTable({ projectId, projectKeys, projectInfo }) {
+    this.#db
+      .insert(projectKeysTable)
+      .values({
+        projectId,
+        keysCipher: this.#keyManager.encryptLocalMessage(
+          Buffer.from(ProjectKeys.encode(projectKeys).finish().buffer),
+          projectId
+        ),
+        projectInfo,
+      })
+      .run()
+  }
+
   /**
    * Create a new project.
    * @param {import('type-fest').Simplify<Partial<Pick<ProjectValue, 'name'>>>} [settings]
@@ -66,7 +97,7 @@ export class MapeoManager {
       data: randomBytes(32),
     }
 
-    // 3. Save keys to client db in projectKeys table
+    // 3. Save keys to client db  projectKeys table
     /** @type {ProjectKeys} */
     const keys = {
       projectKey: projectKeypair.publicKey,
@@ -77,16 +108,7 @@ export class MapeoManager {
     // TODO: Update to use @mapeo/crypto when ready (https://github.com/digidem/mapeo-core-next/issues/171)
     const projectId = projectKeypair.publicKey.toString('hex')
 
-    this.#db
-      .insert(projectKeysTable)
-      .values({
-        projectId,
-        keysCipher: this.#keyManager.encryptLocalMessage(
-          Buffer.from(ProjectKeys.encode(keys).finish().buffer),
-          projectId
-        ),
-      })
-      .run()
+    this.#saveToProjectKeysTable({ projectId, projectKeys: keys })
 
     // 4. Create MapeoProject instance
     const project = new MapeoProject({
@@ -115,24 +137,27 @@ export class MapeoManager {
    * @returns {Promise<MapeoProject>}
    */
   async getProject(projectId) {
-    const existing = this.#activeProjects.get(projectId)
+    // 1. Check for existing active project
+    const activeProject = this.#activeProjects.get(projectId)
 
-    if (existing) return existing
+    if (activeProject) return activeProject
 
-    const result = this.#db
+    // 2. Create project instance
+    const projectKeysTableResult = this.#db
       .select({
         keysCipher: projectKeysTable.keysCipher,
       })
       .from(projectKeysTable)
       .where(eq(projectKeysTable.projectId, projectId))
       .get()
 
-    if (!result) {
+    if (!projectKeysTableResult) {
       throw new Error(`NotFound: project ID ${projectId} not found`)
     }
 
-    const projectKeys = ProjectKeys.decode(
-      this.#keyManager.decryptLocalMessage(result.keysCipher, projectId)
+    const projectKeys = this.#decodeProjectKeysCipher(
+      projectKeysTableResult.keysCipher,
+      projectId
     )
 
     const project = new MapeoProject({
@@ -143,14 +168,28 @@ export class MapeoManager {
       sharedIndexWriter: this.#projectSettingsIndexWriter,
     })
 
+    // 3. Keep track of project instance as we know it's a properly existing project
+    this.#activeProjects.set(projectId, project)
+
     return project
   }
 
   /**
-   * @returns {Promise<Array<Pick<ProjectValue, 'name'> & { projectId: string, createdAt: string, updatedAt: string }>>}
+   * @returns {Promise<Array<Pick<ProjectValue, 'name'> & { projectId: string, createdAt?: string, updatedAt?: string }>>}
    */
   async listProjects() {
-    return this.#db
+    // 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
+    const allProjectKeysResult = this.#db
+      .select({
+        projectId: projectKeysTable.projectId,
+        projectInfo: projectKeysTable.projectInfo,
+      })
+      .from(projectKeysTable)
+      .all()
+
+    const allProjectsResult = this.#db
       .select({
         projectId: projectTable.docId,
         createdAt: projectTable.createdAt,
@@ -159,6 +198,67 @@ export class MapeoManager {
       })
       .from(projectTable)
       .all()
-      .map((value) => deNullify(value))
+
+    /** @type {Array<Pick<ProjectValue, 'name'> & { projectId: string, createdAt?: string, updatedAt?: string }>} */
+    const result = []
+
+    for (const { projectId, projectInfo } of allProjectKeysResult) {
+      const existingProject = allProjectsResult.find(
+        (p) => p.projectId === projectId
+      )
+
+      result.push(
+        deNullify({
+          projectId,
+          createdAt: existingProject?.createdAt,
+          updatedAt: existingProject?.updatedAt,
+          name: existingProject?.name || projectInfo.name,
+        })
+      )
+    }
+
+    return result
+  }
+
+  /**
+   * @param {import('./generated/rpc.js').Invite} invite
+   * @returns {Promise<string>}
+   */
+  async addProject({ projectKey, encryptionKeys, projectInfo }) {
+    const projectId = projectKey.toString('hex')
+
+    // 1. Check for an active project
+    const activeProject = this.#activeProjects.get(projectId)
+
+    if (activeProject) {
+      throw new Error(`Project with ID ${projectId} already exists`)
+    }
+
+    // 2. Check if the project exists in the project keys table
+    // If it does, that means the project has already been either created or added before
+    const projectExists = this.#db
+      .select()
+      .from(projectKeysTable)
+      .where(eq(projectKeysTable.projectId, projectId))
+      .get()
+
+    if (projectExists) {
+      throw new Error(`Project with ID ${projectId} already exists`)
+    }
+
+    // TODO: Relies on completion of https://github.com/digidem/mapeo-core-next/issues/233
+    // 3. Sync auth + config cores
+
+    // 4. Update the project keys table
+    this.#saveToProjectKeysTable({
+      projectId,
+      projectKeys: {
+        projectKey,
+        encryptionKeys,
+      },
+      projectInfo,
+    })
+
+    return projectId
   }
 }

src/schema/client.js

@@ -4,11 +4,26 @@
 import { blob, sqliteTable, text } from 'drizzle-orm/sqlite-core'
 import { dereferencedDocSchemas as schemas } from '@mapeo/schema'
 import { jsonSchemaToDrizzleColumns as toColumns } from './schema-to-drizzle.js'
-import { backlinkTable } from './utils.js'
+import { backlinkTable, customJson } from './utils.js'
+
+const projectInfoColumn =
+  /** @type {ReturnType<typeof import('drizzle-orm/sqlite-core').customType<{data: import('../generated/rpc.js').Invite_ProjectInfo }>>} */ (
+    customJson
+  )
+
+/** @type {import('../generated/rpc.js').Invite_ProjectInfo} */
+const PROJECT_INFO_DEFAULT_VALUE = {}
 
 export const projectTable = sqliteTable('project', toColumns(schemas.project))
 export const projectBacklinkTable = backlinkTable(projectTable)
 export const projectKeysTable = sqliteTable('projectKeys', {
   projectId: text('projectId').notNull().primaryKey(),
   keysCipher: blob('keysCipher', { mode: 'buffer' }).notNull(),
+  projectInfo: projectInfoColumn('projectInfo')
+    .default(
+      // TODO: There's a bug in Drizzle where the default value does not get transformed by the custom type
+      // @ts-expect-error
+      JSON.stringify(PROJECT_INFO_DEFAULT_VALUE)
+    )
+    .notNull(),
 })

src/schema/schema-to-drizzle.js

@@ -1,4 +1,5 @@
-import { text, integer, real, customType } from 'drizzle-orm/sqlite-core'
+import { text, integer, real } from 'drizzle-orm/sqlite-core'
+import { customJson } from './utils.js'
 
 /**
 @typedef {import('@mapeo/schema').MapeoDoc} MapeoDoc
@@ -7,19 +8,6 @@ import { text, integer, real, customType } from 'drizzle-orm/sqlite-core'
 @typedef {import('../types.js').MapeoDocMap} MapeoDocMap
  */
 
-const customJson = customType({
-  dataType() {
-    return 'text'
-  },
-  fromDriver(value) {
-    // @ts-ignore
-    return JSON.parse(value)
-  },
-  toDriver(value) {
-    return JSON.stringify(value)
-  },
-})
-
 /**
 Convert a JSONSchema definition to a Drizzle Columns Map (the parameter for
 `sqliteTable()`).

src/schema/utils.js

@@ -1,4 +1,9 @@
-import { text, getTableConfig, sqliteTable } from 'drizzle-orm/sqlite-core'
+import {
+  text,
+  getTableConfig,
+  sqliteTable,
+  customType,
+} from 'drizzle-orm/sqlite-core'
 
 /**
  * @template {string} [TName=string]
@@ -30,3 +35,16 @@ export function backlinkTable(tableSchema) {
 export function getBacklinkTableName(tableName) {
   return tableName + BACKLINK_TABLE_POSTFIX
 }
+
+export const customJson = customType({
+  dataType() {
+    return 'text'
+  },
+  fromDriver(value) {
+    // @ts-ignore
+    return JSON.parse(value)
+  },
+  toDriver(value) {
+    return JSON.stringify(value)
+  },
+})

test-e2e/manager-basic.js

@@ -1,4 +1,5 @@
 import { test } from 'brittle'
+import { randomBytes } from 'crypto'
 import { KeyManager } from '@mapeo/crypto'
 import { MapeoManager } from '../src/mapeo-manager.js'
 
@@ -13,17 +14,51 @@ test('Managing multiple projects', async (t) => {
     'no projects exist when manager is initially created'
   )
 
-  const createdProjectIds = [
-    await manager.createProject(),
-    await manager.createProject(),
-    await manager.createProject(),
-  ]
+  const createdProjectId = await manager.createProject({
+    name: 'created project',
+  })
 
-  const allProjects = await manager.listProjects()
+  const addedProjectId = await manager.addProject({
+    projectKey: KeyManager.generateProjectKeypair().publicKey,
+    encryptionKeys: { auth: randomBytes(32) },
+    projectInfo: { name: 'added project' },
+  })
 
-  t.is(allProjects.length, createdProjectIds.length)
-  t.ok(
-    allProjects.every((p) => createdProjectIds.includes(p.projectId)),
-    'all created projects are listed'
+  const listedProjects = await manager.listProjects()
+
+  t.is(listedProjects.length, 2)
+
+  const createdProject = listedProjects.find(
+    ({ projectId }) => projectId === createdProjectId
+  )
+  t.ok(createdProject, 'created project is listed')
+  t.is(createdProject?.name, 'created project')
+
+  const addedProject = listedProjects.find(
+    ({ projectId }) => projectId === addedProjectId
   )
+  t.ok(addedProject, 'added project is listed')
+  t.is(addedProject?.name, 'added project')
+})
+
+test('Manager cannot add project that already exists', async (t) => {
+  const manager = new MapeoManager({ rootKey: KeyManager.generateRootKey() })
+
+  const existingProjectId = await manager.createProject()
+
+  const existingProjectsCountBefore = (await manager.listProjects()).length
+
+  t.exception(
+    manager.addProject({
+      projectKey: Buffer.from(existingProjectId, 'hex'),
+      encryptionKeys: {
+        auth: randomBytes(32),
+      },
+    }),
+    'attempting to add project that already exists throws'
+  )
+
+  const existingProjectsCountAfter = (await manager.listProjects()).length
+
+  t.is(existingProjectsCountBefore, existingProjectsCountAfter)
 })