fix(new beacon): 🐛 capture, store and return a Beacon

Author: JasonWarrenUK

.cursor/rules/beacons.mdc

@@ -0,0 +1,6 @@
+---
+description: deno & neo4
+globs: 
+alwaysApply: false
+---
+Always refer to the documentation for the latest version of neo4j and deno

api/neo4j/find.ts

@@ -1,5 +1,5 @@
 import neo4j, { Driver } from "neo4j";
-import { creds as c } from "utils/creds/neo4j.ts";
+import { creds as c } from "../../utils/auth/neo4jCred.ts";
 
 export async function findUserById(
   id: number,

api/neo4j/get.ts

@@ -1,5 +1,5 @@
 import neo4j, { Driver } from "neo4j";
-import { creds as c } from "utils/creds/neo4j.ts";
+import { creds as c } from "../../utils/auth/neo4jCred.ts";
 
 export async function getNouns() {
   let driver: Driver | null = null;

api/neo4j/reset.ts

@@ -1,5 +1,5 @@
 import neo4j, { Driver } from "neo4j";
-import { creds as c } from "../../utils/creds/neo4j.ts";
+import { creds as c } from "../../utils/auth/neo4jCred.ts";
 
 export async function reset() {
   let driver: Driver, result;

api/neo4j/seed.ts

@@ -1,5 +1,5 @@
 import neo4j, { Driver } from "neo4j";
-import { creds } from "../../utils/creds/neo4j.ts";
+import { creds } from "../../utils/auth/neo4jCred.ts";
 
 const data = JSON.parse(
   await Deno.readTextFile("./data/seeds/facSeed.json"),

api/neo4j/writeBeacon.ts

@@ -1,130 +1,131 @@
 import * as dotenv from "dotenv";
 import neo4j, { Driver } from "neo4j";
-import type { Lantern, Beacon, Ash } from "types/beaconTypes.ts";
-import { creds as c } from "utils/creds/neo4j.ts";
+import type { Lantern, Ash, Ember, DBError } from "types/beaconTypes.ts";
+import type { Attempt } from "types/serverTypes.ts";
+import { creds as c } from "utils/auth/neo4jCred.ts";
 
 dotenv.load({ export: true });
 
-export async function writeBeacons(entries:Lantern[]) {
-  console.groupCollapsed(`====== FUNCTION writeBeacons(${entries.length} entries) ======`);
-  let i = 0;
-  for (const entry of entries) {
-    console.log(`Passing Beacon ${i}: "${entry.input}"`);
-    await writeBeacon(entry);
-    i++;
-  };
-  console.groupEnd();
-}
-
-export async function writeBeacon(entry:Lantern):Promise<Beacon | Ash> {
+export async function writeBeacon(entry:Lantern):Promise<Attempt> {
   console.groupCollapsed(`====== FUNCTION writeBeacon(${entry.input}) ======`);
-  let driver: Driver;
-  let newEntry: Beacon | Ash;
-  
+
+  let driver: Driver | undefined;
+  let attempt: Attempt;
+  let attemptError: DBError | undefined;
+
   try {
-    console.groupCollapsed(`--- Neo4j ---`);
     console.info("Initialising Driver...");
     driver = neo4j.driver(c.URI, neo4j.auth.basic(c.USER, c.PASSWORD));
-    console.info("Connecting to Aura...");
     await driver.getServerInfo();
-
-    console.info("Building Query Params...");
-    const verbProps = {
-      dbId: entry.id ?? "no id",
-      presetId: entry.presetId ?? "no preset id",
-      input: entry.input,
-      atoms: {
-        client: {
-          subject: entry.atoms.client.subject,
-          verb: entry.atoms.client.verb,
-          object: entry.atoms.client.object,
-          adverbial: entry.atoms.client.adverbial
-        },
-        server: {
-          subject: entry.atoms.server.subject,
-          verb: entry.atoms.server.verb,
-          object: entry.atoms.server.object,
-          adverbial: entry.atoms.server.adverbial
-        }
-      },
-      isPublic: entry.isPublic ?? false,
-      isArchived: entry.isArchived ?? false,
-      isSnoozed: entry.isSnoozed ?? false,
-      category: entry.category ?? "",
-      actions: entry.actions ?? []
-    };
+  
+    const userId = entry.authId ? entry.authId : "test-auth-id";
 
     console.info("Executing Cypher Query...");
     const result = await driver.executeQuery(
-      `MERGE (s:User {name:$sName})-[v:VERB {input: $vInput}]->(o:Concept {name:$oName})
-      SET v = $vProps
+      `MERGE (s:User {name:$sProps.name})-[v:VERB]->(o:Concept {name:$oProps.name})
+      SET v.dbId = randomUUID(),
+          v += $vProps
       RETURN s, v, o`,
       {
-        sName: entry.atoms.server.subject.head,
-        vInput: verbProps.input,
+        sProps: { name: entry.shards.subject.head },
+        oProps: { name: entry.shards.object.head },
         vProps: {
-          id: verbProps.id,
-          presetId: verbProps.presetId,
-          input: verbProps.input,
-          name: verbProps.atoms.server.verb.head,
-          atomsClientSubject: verbProps.atoms.client.subject,
-          atomsClientVerb: verbProps.atoms.client.verb,
-          atomsClientObject: verbProps.atoms.client.object,
-          atomsClientAdverbial: verbProps.atoms.client.adverbial,
-          atomsServerSubjectHead: verbProps.atoms.server.subject.head,
-          atomsServerSubjectArticle: verbProps.atoms.server.subject.article,
-          atomsServerSubjectQuantity: verbProps.atoms.server.subject.quantity,
-          atomsServerSubjectDescriptors: verbProps.atoms.server.subject.descriptors,
-          atomsServerSubjectPhrase: verbProps.atoms.server.subject.phrase,
-          atomsServerVerbHead: verbProps.atoms.server.verb.head,
-          atomsServerVerbPhrase: verbProps.atoms.server.verb.phrase,
-          atomsServerVerbDescriptors: verbProps.atoms.server.verb.descriptors,
-          atomsServerObjectHead: verbProps.atoms.server.object.head,
-          atomsServerObjectArticle: verbProps.atoms.server.object.article,
-          atomsServerObjectQuantity: verbProps.atoms.server.object.quantity,
-          atomsServerObjectDescriptors: verbProps.atoms.server.object.descriptors,
-          atomsServerObjectPhrase: verbProps.atoms.server.object.phrase,
-          isPublic: verbProps.isPublic,
-          isArchived: verbProps.isArchived,
-          isSnoozed: verbProps.isSnoozed,
-          category: verbProps.category,
-          actions: verbProps.actions
-        },
-        oName: entry.atoms.server.object.head
-      }, { database: "neo4j" }
+          authId: userId,
+          presetId: entry.presetId ?? "",
+          input: entry.input,
+          name: entry.shards.verb.head,
+          atoms_subject: entry.atoms.subject,
+          atoms_verb: entry.atoms.verb,
+          atoms_object: entry.atoms.object,
+          atoms_adverbial: entry.atoms.adverbial,
+          shards_subject_head: entry.shards.subject.head,
+          shards_subject_phrase: entry.shards.subject.phrase,
+          shards_subject_article: entry.shards.subject.article,
+          shards_subject_quantity: entry.shards.subject.quantity,
+          shards_subject_descriptors: entry.shards.subject.descriptors,
+          shards_verb_head: entry.shards.verb.head,
+          shards_verb_phrase: entry.shards.verb.phrase,
+          shards_verb_descriptors: entry.shards.verb.descriptors,
+          shards_object_head: entry.shards.object.head,
+          shards_object_phrase: entry.shards.object.phrase,
+          shards_object_article: entry.shards.object.article,
+          shards_object_quantity: entry.shards.object.quantity,
+          shards_object_descriptors: entry.shards.object.descriptors,
+          shards_adverbial: entry.shards.adverbial,
+          isPublic: entry.isPublic ?? false,
+          isArchived: entry.isArchived ?? false,
+          isSnoozed: entry.isSnoozed ?? false,
+          category: entry.category ?? "",
+          actions: [],
+          errorLogs: []
+        }
+      },
+      { database: "neo4j" }
     );
 
-    console.info(`Assembling Return Object...`);
-    newEntry = {
-      // ...entry,
-      // id: result.records[0].get("id")
-      subject: result.records[0].get("s"),
-      verb: result.records[0].get("v"),
-      object: result.records[0].get("o")
+    const record = result.records[0].get("v").properties;
+
+    console.groupCollapsed(`Ember`);
+    const ember: Ember = {
+      authId: record.authId,
+      dbId: record.dbId,
+      presetId: record.presetId,
+      input: record.input,
+      atoms: {
+        subject: record.atoms_subject,
+        verb: record.atoms_verb,
+        object: record.atoms_object,
+        adverbial: record.atoms_adverbial
+      },
+      category: record.category,
+      isPublic: record.isPublic,
+      isArchived: record.isArchived,
+      isSnoozed: record.isSnoozed,
+      actions: record.actions,
+      errorLogs: record.errorLogs
     };
+    console.info(`Ember assembled`);
+    console.log(ember);
+    console.groupEnd();
+
+    attempt = { record: ember };
   } catch (err) {
-    console.warn(`Connection error`);
-    // console.warn(err);
+    console.groupCollapsed(`--- Error ---`);
+
+    console.groupCollapsed(`Details`);
+    console.warn(err);
     const cause = err instanceof Error ? err.cause : "Cause Unknown";
+    console.info(`Error Cause:`);
     console.warn(cause);
+    console.groupEnd();
 
-    newEntry = {
-      ...entry,
-      errorLogs: [{ isError: true, errorCause: cause }]
-    };
-    
-    return newEntry as Ash;
+    console.groupCollapsed(`Ash`);
+    attemptError = { isError: true, errorCause: cause };
+    attempt = {
+      record: { ...entry, errorLogs: [attemptError] },
+      error: attemptError
+    }
+    console.log(attempt);
+    console.groupEnd();
+
+    console.groupEnd();
   } finally {
     console.info("Closing Driver...");
     driver?.close();
-    console.groupEnd();
   }
 
-  console.groupCollapsed(`--- Return ---`);
-  console.log(newEntry.shards.subject);
-  console.log(newEntry.shards.verb);
-  console.log(newEntry.shards.object);
   console.groupEnd();
-  
-  return newEntry;
+  console.info(`==================================================`);
+  return attempt;
+}
+
+export async function writeBeacons(entries:Lantern[]) {
+  console.groupCollapsed(`====== FUNCTION writeBeacons(${entries.length} entries) ======`);
+  let i = 0;
+  for (const entry of entries) {
+    console.log(`Passing Beacon ${i}: "${entry.input}"`);
+    await writeBeacon(entry);
+    i++;
+  };
+  console.groupEnd();
 }

docs/ENDPOINTS.md dev/ENDPOINTS.mddocs/ENDPOINTS.md renamed to dev/ENDPOINTS.md

@@ -78,9 +78,8 @@ These are the request formats for the endpoints that either (a) are working or (
 
 Some of these will need to be updated to include the session token.
 
-- [ ] tdHi: Add the blocked tasks from Notion to this file
-- [x] tdMd: Change the assignation of verb from `[ v:${verb.toUpperCase()} ]` to `[v:VERB { name:${verb} }]`
-- [ ] tdHi: Update endpoints to allow receipt of auth token
+- [ ] tdWait: Update endpoints to allow receipt of auth token
+
 - [ ] tdCheck: What's the type of driver??
 
 ### 2B. `"/edit/*"`
@@ -154,20 +153,22 @@ It's a `POST` endpoint because it's designed to take a JSON body.
 
 #### 2X2. `GET "/get/v"`
 
-- [ ] tdMd: Retrieve `verb.input` instead of `typeOf(verb)`
+- [ ] tdLo: Retrieve `verb.input` instead of `typeOf(verb)`
 
 ### 2D. `/write/*`
 
 #### 2D1. `POST "/write/newBeacon"`
 
-- [ ] tdHi: Correctly assign nested props to `beacon`
+- [ ] tdHi: Generate a unique `dbID` prop on new `Beacon`
+- [ ] tdHi: Correctly assign nested props to `Beacon`
+
 - [ ] tdWait: Use `authID` for matching subject node
-- [ ] tdIdea: Call `breaker(match.atoms)` instead of `breaker(match)` so that they are identical
-- [ ] tdLo: Move term extraction from `breaker(match)` to a subfunction
-- [ ] tdHi: Create a unique `dbId` prop when creating a node
-- [ ] tdWait: Return `ember.dbId` to the frontend when creating new statements
-- [ ] tdWait: Create a unique `dbId` prop `ember.dbId` to the frontend when creating new statements
-- [ ] tdIdea: enforce the noun tag on `match.atoms.subject`
+- [ ] tdHi: Return `Ember.dbId` to the frontend when creating new statements
+
+- [ ] tdLo: Move term extraction from `breaker(Match)` to a subfunction
+
+- [ ] tdIdea: enforce the noun tag on `Match.atoms.subject`
+- [ ] tdIdea: Call `breaker(Match.atoms)` instead of `breaker(Match)` so that they are identical
 
 This needs editing - I wrote it a few days ago, and at that point we were going to be passing userId from the client rather than generating it in the server.
 
@@ -213,13 +214,15 @@ I'll also need to incorporate the authentication token into the request.
 
 > WIP
 
+- [ ] tdHi: Set the `authId` prop when creating a node
+
 ### 2E. `/auth/*`
 
 #### 2E1. `POST "/auth/signin/magic-link"`
 
-- [ ] tdWait: Create an endpoint that both signs in and creates a new user
-- [ ] tdWait: Create a new user node when a new user signs up
-- [ ] tdWait: Assign the managerEmail to the user node on creation
+- [ ] tdHi: Create an endpoint that both signs in and creates a new user
+- [ ] tdHi: Create a new user node when a new user signs up
+- [ ] tdHi: Assign the managerEmail to the user node on creation
 
 ```ts
   reqMagicLink(/* leads to "/" */);
@@ -238,6 +241,8 @@ I'll also need to incorporate the authentication token into the request.
 
 #### 2E2. `GET "/auth/verify?token={token}"`
 
+- [ ] tdHi: Create an auth route to verify the session token
+
 Request is get with params
 
 ```ts
@@ -293,7 +298,7 @@ Request is `POST` with credentials included
 
 #### 2F1. `POST "/send/ping"`
 
-- [ ] tdHi: Pull the manager's email from the user node
+- [ ] tdWait: Pull the manager's email from the user node
 
 ```ts
 function sendPing(/* leads to "/" */): Promise<PingRes> {};

dev/SCRATCHPAD.md

@@ -0,0 +1,26 @@
+# Cypher Scratchpad
+
+```ts
+const verbProps = {
+  dbId: entry.id ?? "no id",
+  presetId: entry.presetId ?? "no preset id",
+  input: entry.input,
+  atoms: {
+    subject: entry.atoms.subject,
+    verb: entry.atoms.verb,
+    object: entry.atoms.object,
+    adverbial: entry.atoms.adverbial
+  },
+  shards: {
+    subject: entry.atoms.server.subject,
+    verb: entry.atoms.server.verb,
+    object: entry.atoms.server.object,
+    adverbial: entry.atoms.server.adverbial
+  },
+  isPublic: entry.isPublic ?? false,
+  isArchived: entry.isArchived ?? false,
+  isSnoozed: entry.isSnoozed ?? false,
+  category: entry.category ?? "",
+  actions: entry.actions ?? []
+}
+```

docs/TASKS.md dev/TASKS.mddocs/TASKS.md renamed to dev/TASKS.md

@@ -1,5 +1,5 @@
 import nlp from "npm:[email protected]";
-import { breaker } from "../language/breaker.ts";
+import { breaker } from "../utils/convert/breakInput.ts";
 
 const input = Deno.args.join(" ");