Structure Tools

.vscode/launch.json

@@ -90,7 +90,7 @@
                 "history"
             ],
             "console": "integratedTerminal",
-            "internalConsoleOptions": "neverOpen"
+            "internalConsoleOptions": "neverOpen",
         },
         {
             "type": "node",
@@ -110,6 +110,12 @@
             ],
             "console": "integratedTerminal",
             "internalConsoleOptions": "neverOpen"
+        },
+        {
+            "type": "node",
+            "request": "attach",
+            "name": "Attach to Jest (Yarn)",
+            "port": 9229,
         }
     ]
 }

.vscode/settings.json

@@ -17,5 +17,6 @@
   "javascript.format.semicolons": "remove",
   "typescript.format.enable": false,
   "prettier.enable": false,
-  "editor.defaultFormatter": "standard.vscode-standard"
+  "editor.defaultFormatter": "standard.vscode-standard",
+  "bashBeautify.tabSize": 2
 }

db-migrations/0006-area-structure.js

@@ -0,0 +1,100 @@
+// For each document that has children, we want to tell its children to back-link to us.
+db.areas
+  .find({ children: { $exists: true, $type: "array" } })
+  .forEach((parentDoc) =>
+    db.areas.updateMany(
+      { _id: { $in: parentDoc.children } },
+      { $set: { parent: parentDoc._id } },
+    ),
+  );
+
+// Pre-fetch children for all documents to avoid querying in the loop
+const allChildren = db.areas.aggregate([
+  { $match: { parent: { $exists: true } } },
+  { $group: { _id: "$parent", children: { $push: "$_id" } } }
+]).toArray();
+
+// hold a reference to the children in memory
+const childrenMap = allChildren.reduce((map, item) => {
+  map[item._id] = item.children;
+  return map;
+}, {});
+
+// This stage will take a WHILE
+db.areas.find().forEach((doc) => {
+  // Perform a $graphLookup aggregation to get the full ancestor path for our target
+  const pathDocs = db.areas.aggregate([
+    {
+      $match: { _id: doc._id },
+    },
+    {
+      $graphLookup: {
+        from: "areas",
+        startWith: "$parent",
+        connectFromField: "parent",
+        connectToField: "_id",
+        as: "ancestorPath",
+        depthField: "depth",
+      },
+    },
+    {
+      $unwind: "$ancestorPath",
+    },
+    {
+      $sort: { "ancestorPath.depth": -1 },
+    },
+    {
+      $group: {
+        _id: "$_id",
+        ancestors: { $push: '$ancestorPath' }
+      },
+    },
+  ]).toArray();
+
+  const embeddedRelations = {
+    children: childrenMap[doc._id] || [],
+    // map out the ancestors of this doc (terminating at the current node for backward-compat reasons)
+    // We take out the relevant data we would like to be denormalized.
+    ancestors: [...(pathDocs[0]?.ancestors ?? []), doc].map(i => ({
+      _id: i._id,
+      name: i.area_name,
+      uuid: i.metadata.area_id
+    }))
+  };
+
+  if (embeddedRelations.ancestors.map(i => i.name).join(",") !== doc.pathTokens.join(",")) {
+    throw `Path tokens did not match (${embeddedRelations.ancestors.map(i => i.name)} != ${doc.pathTokens})`;
+  }
+
+  if (embeddedRelations.ancestors.map(i => i.uuid).join(',') !== doc.ancestors) {
+    throw `Ancestors did not match (${embeddedRelations.ancestors.map(i => i.uuid)} != ${doc.ancestors})`;
+  }
+
+
+  // Use bulkWrite for efficient updates
+  db.areas.updateOne(
+    { _id: doc._id },
+    { $set: { embeddedRelations } }
+  );
+});
+
+print("Removing old fields.");
+
+// Remove the unneeded values since all ops have run without raising an assertion issue
+db.areas.updateMany({}, {
+  $unset: { children: "", pathTokens: "", ancestors: "" },
+});
+
+printjson(db.areas.createIndex({ parent: 1 }))
+printjson(db.areas.createIndex({ 'embeddedRelations.children': 1 }))
+printjson(db.areas.createIndex({ 'embeddedRelations.ancestors._id': 1 }))
+printjson(db.areas.createIndex({ 'embeddedRelations.ancestors.uuid': 1 }))
+printjson(db.areas.createIndex({ 'embeddedRelations.ancestors.name': 1 }))
+
+printjson(db.areas.createIndex({ 'embeddedRelations.ancestors._id': 1, 'embeddedRelations.ancestors.name': 1 }))
+
+
+//  https://www.mongodb.com/docs/v6.2/reference/method/db.collection.createIndex/#create-an-index-on-a-multiple-fields
+//  > The order of fields in a compound index is important for supporting sort() operations using the index.
+// It is not clear to me if there is a $lookup speed implication based on the direction of the join.
+printjson(db.areas.createIndex({ parent: 1, _id: 1 }))

migrate-db.sh

@@ -6,8 +6,25 @@ then
   exit 1
 fi
 
+if [ ! -f $1 ]
+then
+  echo "Specified migration file ($1) not found"
+  exit 1
+fi
+
 . .env
 
 connStr="${MONGO_SCHEME}://${MONGO_INITDB_ROOT_USERNAME}:${MONGO_INITDB_ROOT_PASSWORD}@${MONGO_SERVICE}/${MONGO_DBNAME}?authSource=${MONGO_AUTHDB}&tls=${MONGO_TLS}&replicaSet=${MONGO_REPLICA_SET_NAME}"
 
-mongo "$connStr" $1
+# Determine whether `mongo` or `mongosh` is available
+if command -v mongosh &> /dev/null; then
+  mongoCmd="mongosh"
+  elif command -v mongo &> /dev/null; then
+  mongoCmd="mongo"
+else
+  echo "Neither mongosh nor mongo command found. Please install one of them."
+  exit 1
+fi
+
+# Execute the chosen command with the connection string and migration file
+"$mongoCmd" "$connStr" "$1"

package.json

@@ -74,6 +74,7 @@
     "lint": "yarn ts-standard",
     "fix": "yarn ts-standard --fix",
     "test": "cross-env NODE_OPTIONS=\"--experimental-vm-modules\" jest --runInBand",
+    "test:dbg": "cross-env NODE_OPTIONS=\"--experimental-vm-modules --inspect-brk\" jest --runInBand",
     "build": "tsc -p tsconfig.json",
     "build-release": "tsc  -p tsconfig.release.json",
     "clean": "tsc -b --clean && rm -rf build/*",

seed-db.sh

@@ -1,12 +1,12 @@
+#!/bin/bash
 # Rebuild your local database with a copy of OpenBeta staging database.
 #
-# To keep running time short, the script only downloads the remote 
+# To keep running time short, the script only downloads the remote
 # database dump file once.  Specify 'download' argument to force download.
 #
 # Syntax:
 #   ./seed-db.sh [download]
 #
-#!/bin/bash
 
 FILE_NAME="openbeta-stg-db.tar.gz"
 REMOTE_FILE="https://storage.googleapis.com/openbeta-dev-dbs/$FILE_NAME"
@@ -22,7 +22,11 @@ tar xzf $FILE_NAME
 
 . .env
 
-connStr="${MONGO_SCHEME}://${MONGO_INITDB_ROOT_USERNAME}:${MONGO_INITDB_ROOT_PASSWORD}@${MONGO_SERVICE}/${MONGO_DBNAME}?authSource=${MONGO_AUTHDB}&tls=${MONGO_TLS}&replicaSet=${MONGO_REPLICA_SET_NAME}"
+connStr="${MONGO_SCHEME}://${MONGO_INITDB_ROOT_USERNAME}:${MONGO_INITDB_ROOT_PASSWORD}@${MONGO_SERVICE}/${MONGO_DBNAME}?authSource=${MONGO_AUTHDB}&tls=${MONGO_TLS}"
+
+if [ -z "${MONGO_REPLICA_SET_NAME}" ]; then
+  connStr+="&replicaSet=${MONGO_REPLICA_SET_NAME}"
+fi
 
 mongorestore --uri "$connStr" -d=${MONGO_DBNAME} --gzip --drop ./db-dumps/staging/openbeta
 

shell.nix

@@ -0,0 +1,44 @@
+{
+  pkgs ? import <nixpkgs> {
+    config = {
+      allowUnfree = true;
+    };
+  },
+}:
+pkgs.mkShell {
+  buildInputs = with pkgs; [
+    mongodb-tools
+    yarn
+    mongodb-ce
+    mongodb-compass
+    mongosh
+    gsettings-desktop-schemas
+
+    deno
+  ];
+
+  # MONGOMS_DOWNLOAD_URL = "https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-ubuntu2404-8.0.1.tgz";
+  MONGOMS_DISTRO = "ubuntu-22.04";
+  MONGOMS_RUNTIME_DOWNLOAD = false;
+  MONGOMS_SYSTEM_BINARY = "${pkgs.mongodb-ce}/bin/mongod";
+  # you will need to keep this value in sync with the pre-built mongodb-ce
+  # (or you can use the mongodb package which will build from source and take a WHILE)
+  # https://github.com/NixOS/nixpkgs/blob/nixos-unstable/pkgs/by-name/mo/mongodb-ce/package.nix#L113
+  MONGOMS_VERSION = "7.0.14";
+
+  shellHook = ''
+
+    set -a
+    source .env
+    mongo_cnx="$MONGO_SCHEME://$MONGO_INITDB_ROOT_USERNAME:$MONGO_INITDB_ROOT_PASSWORD@$MONGO_SERVICE/$MONGO_DBNAME?authSource=$MONGO_AUTHDB&tls=$MONGO_TLS"
+
+    # mongotop alias
+    alias mto="mongotop --uri=$mongo_cnx"
+    # mongostat alias
+    alias mst="mongostat --uri=$mongo_cnx"
+    # Compass tooling
+    alias compass="mongodb-compass --theme=dark $mongo_cnx"
+
+    echo "🧗 Alle!"
+  '';
+}

src/__tests__/areas.ts

@@ -1,5 +1,5 @@
 import { ApolloServer } from 'apollo-server-express'
-import muuid from 'uuid-mongodb'
+import muuid, { MUUID } from 'uuid-mongodb'
 import { jest } from '@jest/globals'
 import MutableAreaDataSource from '../model/MutableAreaDataSource.js'
 import MutableOrganizationDataSource from '../model/MutableOrganizationDataSource.js'
@@ -107,4 +107,89 @@ describe('areas API', () => {
       expect(areaResult.organizations[0].orgId).toBe(muuidToString(alphaOrg.orgId))
     })
   })
+
+  describe('area structure API', () => {
+    const structureQuery = `
+        query structure($parent: ID!) {
+          structure(parent: $parent) {
+            parent
+            uuid
+            area_name
+            climbs
+          }
+        }
+    `
+
+    // Structure queries do not do write operations so we can build this once
+    beforeEach(async () => {
+      const maxDepth = 4
+      const maxBreadth = 3
+
+      // So for the purposes of this test we will do a simple tree
+      async function grow (from: MUUID, depth: number = 0): Promise<void> {
+        if (depth >= maxDepth) return
+        for (const idx of Array.from({ length: maxBreadth }, (_, i) => i + 1)) {
+          const newArea = await areas.addArea(user, `${depth}-${idx}`, from)
+          await grow(newArea.metadata.area_id, depth + 1)
+        }
+      }
+
+      await grow(usa.metadata.area_id)
+    })
+
+    it('retrieves the structure of a given area', async () => {
+      const response = await queryAPI({
+        query: structureQuery,
+        operationName: 'structure',
+        variables: { parent: usa.metadata.area_id },
+        userUuid,
+        app
+      })
+
+      expect(response.statusCode).toBe(200)
+    })
+
+    it('should allow no parent to be supplied and get a shallow result', async () => {
+      const response = await queryAPI({
+        query: `
+        query structure {
+          structure {
+            parent
+            uuid
+            area_name
+            climbs
+          }
+        }
+    `,
+        operationName: 'structure',
+        userUuid,
+        app
+      })
+
+      expect(response.statusCode).toBe(200)
+    })
+
+    it('should allow calling of the setAreaParent gql endpoint.', async () => {
+      const testArea = await areas.addArea(muuid.from(userUuid), 'A Rolling Stone', usa.metadata.area_id)
+
+      const response = await queryAPI({
+        query: `
+          mutation SetAreaParent($area: ID!, $newParent: ID!) {
+            setAreaParent(area: $area, newParent: $newParent) {
+              areaName
+              area_name
+            }
+          }
+        `,
+        operationName: 'SetAreaParent',
+        userUuid,
+        app,
+        // Move it to canada
+        variables: { area: testArea.metadata.area_id, newParent: ca.metadata.area_id }
+      })
+
+      console.log(response.body)
+      expect(response.statusCode).toBe(200)
+    })
+  })
 })

src/auth/local-dev/middleware.ts

@@ -5,6 +5,7 @@
 import muuid, { MUUID } from 'uuid-mongodb'
 import { AuthUserType } from '../../types.js'
 import { logger } from '../../logger.js'
+import type { ApolloServerPlugin } from 'apollo-server-plugin-base'
 
 export const localDevBypassAuthContext = (() => {
   const testUUID: MUUID = muuid.v4()
@@ -19,3 +20,15 @@ export const localDevBypassAuthContext = (() => {
     return { user }
   }
 })()
+
+export const loggerPlugin: ApolloServerPlugin = {
+  async requestDidStart (ctx) {
+    const startTime = process.uptime()
+    return {
+      async willSendResponse () {
+        ctx.logger.info(ctx.request.query)
+        ctx.logger.info(`query resolved in ${((process.uptime() - startTime) * 1000).toFixed(4)}ms`)
+      }
+    }
+  }
+}