Experimental note body serialization

package.json

@@ -44,6 +44,7 @@
     }
   ],
   "devDependencies": {
+    "@ontologies/core": "^2.0.3",
     "@size-limit/preset-small-lib": "^7.0.8",
     "husky": "^7.0.4",
     "size-limit": "^7.0.8",
@@ -53,6 +54,8 @@
   },
   "dependencies": {
     "@inrupt/solid-client": "^1.21.0",
+    "@ontologies/rdf": "^2.0.0",
+    "@ontologies/schema": "^2.0.0",
     "@rdf-esm/namespace": "^0.5.5",
     "@scure/base": "^1.0.0",
     "@types/react": "^18.0.5",

src/collections.ts

@@ -0,0 +1,35 @@
+
+import {
+  SolidDataset, Thing,
+  getThing, buildThing, createThing, getUrl,
+} from '@inrupt/solid-client';
+import { first, rest, nil } from '@ontologies/rdf'
+
+type JSOToThingConverter = (obj: any, path: number[]) => Thing[]
+
+export function arrayToThings(slateArray: object[], jsoToThing: JSOToThingConverter, path: number[] = [0]): Thing[] {
+  const [el, ...restOfEls] = slateArray
+  const last = path[path.length - 1]
+  const [listElementThing, ...listElementSubThings] = jsoToThing(el, path)
+  const [nextListThing, ...nextListSubThings] = (restOfEls.length > 0) ? arrayToThings(restOfEls, jsoToThing, [...path.slice(0, path.length - 1), last + 1]) : []
+  const listThing = buildThing(createThing({ name: `li-${path.join("-")}` }))
+    .addUrl(first.value, listElementThing)
+    .addUrl(rest.value, nextListThing || nil.value)
+    .build()
+
+  return [listThing, listElementThing, ...listElementSubThings, nextListThing, ...nextListSubThings]
+}
+
+export type ThingToJSOConvertor = (thing: Thing, dataset: SolidDataset) => any
+
+export function thingsToArray(thing: Thing, dataset: SolidDataset, thingToSlateObject: ThingToJSOConvertor): object[] {
+  const restValue = getUrl(thing, rest.value)
+  const restThing = (restValue && (restValue !== nil.value)) && getThing(dataset, restValue)
+  const firstUrl = getUrl(thing, first.value)
+  const firstThing = firstUrl && getThing(dataset, firstUrl)
+  const firstElement = firstThing && thingToSlateObject(firstThing, dataset)
+  return firstElement ? [
+    firstElement,
+    ...(restThing ? thingsToArray(restThing, dataset, thingToSlateObject) : [])
+  ] : []
+}

src/index.ts

@@ -1,8 +1,9 @@
-export * from "./hooks"
+export * from "./collections"
 export * from "./garden"
+export * from "./hooks"
 export * from "./items"
-export * from "./spaces"
 export * from "./settings"
+export * from "./spaces"
 export * from "./types"
 export * from "./utils"
 export * from "./vocab"

src/note.ts

@@ -0,0 +1,97 @@
+import {
+  SolidDataset, Thing,
+  getThing, createThing,
+  addUrl,
+  setInteger, setDecimal, setStringNoLocale, setBoolean,
+  getStringNoLocale, getInteger, getBoolean, getUrl,
+} from '@inrupt/solid-client';
+import { createNS } from "@ontologies/core"
+
+import {arrayToThings, thingsToArray} from "./collections"
+
+const noteNSUrl = "https://mysilio.garden/ontologies/note#"
+const noteNS = createNS(noteNSUrl)
+
+function addKeyValToThing(thing: Thing, key: string, value: any, path: number[]): Thing[] {
+  if (Array.isArray(value)) {
+    const [arrayThing, ...restOfThings] = arrayToThings(value, createThingFromSlateJSOElement, [...path, 0])
+    if (arrayThing) {
+      return [
+        addUrl(thing, key, arrayThing),
+        arrayThing,
+        ...restOfThings
+      ]
+    } else {
+      // TODO: is this the right thing to do? arrayThing should never be falsy so maybe throw an error?
+      return []
+    }
+  } else {
+
+    switch (typeof value) {
+      case 'string':
+        return [setStringNoLocale(thing, key, value)]
+      case 'boolean':
+        return [setBoolean(thing, key, value)]
+      case 'number':
+        if (Number.isInteger(value)) {
+          return [setInteger(thing, key, value)]
+        } else {
+          return [setDecimal(thing, key, value)]
+        }
+      default:
+        return [thing]
+    }
+  }
+
+}
+
+export function createThingFromSlateJSOElement(o: any, path: number[]): Thing[] {
+  const thing = createThing({ name: (o.id ? `${o.id}` : `el-${path.join("-")}`) })
+  const otherThings = Object.keys(o).reduce((m: Thing[], k: string) => {
+    const [mThing, ...mRest] = m;
+    const [thing, ...restOfThings] = addKeyValToThing(mThing, noteNS(k).value, o[k], path)
+    return [thing, ...mRest, ...restOfThings]
+  }, [thing])
+  return [thing, ...otherThings]
+}
+
+function childrenArrayFromDataset(dataset: SolidDataset, childrenUrl: string) {
+  const thing = getThing(dataset, childrenUrl);
+
+  if (thing) {
+    return thingsToArray(thing, dataset, noteThingToSlateObject)
+  } else {
+    return []
+  }
+}
+
+const childrenPred = noteNS('children')
+export function noteThingToSlateObject(thing: Thing, dataset: SolidDataset) {
+  const obj: any = {}
+  for (const pred in thing.predicates) {
+    const [, key] = pred.split(noteNSUrl)
+    if (key) {
+      if (key === 'children') {
+        const children = getUrl(thing, childrenPred.value)
+        if (children) obj.children = childrenArrayFromDataset(dataset, children)
+      } else {
+        const literals = thing.predicates[pred].literals
+        // currently just uses the first literal it can find
+        if (literals) {
+          if (literals['http://www.w3.org/2001/XMLSchema#string']) {
+            const str = getStringNoLocale(thing, pred)
+            if (str || (str === "")) obj[key] = str
+          } else if (literals['http://www.w3.org/2001/XMLSchema#boolean']){
+            const bool = getBoolean(thing, pred)
+            if (bool === true || bool === false) obj[key] = bool
+          } else if (literals['http://www.w3.org/2001/XMLSchema#integer']){
+            const n = getInteger(thing, pred)
+            if (n) obj[key] = n
+          }
+        }
+      }
+    }
+  }
+
+  return obj
+}

test/blah.test.ts

@@ -1,7 +1,6 @@
-import { sum } from '../src';
 
 describe('blah', () => {
   it('works', () => {
-    expect(sum(1, 1)).toEqual(2);
+    expect(1 + 1).toEqual(2);
   });
 });

test/note.test.ts

@@ -0,0 +1,33 @@
+import {
+  Thing,
+  getThing, setThing, createSolidDataset, saveSolidDatasetAt
+} from '@inrupt/solid-client';
+
+import { arrayToThings, thingsToArray } from '../src/collections'
+import { createThingFromSlateJSOElement, noteThingToSlateObject } from '../src/note'
+
+const noteBody = [{ "children": [{ "text": "Hi everybody!" }], "type": "h1" }, { "type": "p", "id": 1651696062634, "children": [{ "text": "" }] }, { "children": [{ "text": "" }], "type": "h1" }, { "children": [{ "text": "thanks", "bold": true }, { "text": " for coming to the " }, { "text": "digital gardening party", "italic": true }, { "text": "." }], "type": "h2" }, { "children": [{ "text": "" }], "type": "h2" }, { "children": [{ "text": "I'm " }, { "type": "concept", "children": [{ "text": "[[Travis]]" }], "name": "Travis" }, { "text": "." }], "type": "h2" }, { "children": [{ "text": "" }], "type": "h2" }, { "children": [{ "text": "This is not a cat:" }], "type": "h2" }, { "children": [{ "text": "" }], "type": "h2" }, { "children": [{ "text": "" }], "type": "h2" }, { "type": "img", "children": [{ "text": "" }], "url": "https://travis.mysilio.me/public/itme/online/images/1cd18da0-6c9e-11eb-b09e-dd1bdda70e9f.jpg", "originalUrl": "https://travis.mysilio.me/public/itme/online/images/1cd18da0-6c9e-11eb-b09e-dd1bdda70e9f.original.jpg", "alt": "", "mime": "image/jpeg" }]
+
+describe('a JSON note body', () => {
+  it('can be serialized and deserialized to and from RDF', async () => {
+    const things: Thing[] = arrayToThings(noteBody, createThingFromSlateJSOElement)
+    const listUrl = things[0].url
+
+    let dataset = things.filter(x => !!x).reduce(setThing, createSolidDataset())
+
+    // need to save this to resolve the various local references in Thing objects
+    dataset = await saveSolidDatasetAt("https://example.com/note", dataset, {
+      fetch: jest.fn(() =>
+        Promise.resolve({
+          ok: true,
+          url: "https://example.com/note",
+          headers: new Headers(),
+        }),
+      ) as jest.Mock
+    })
+
+    const listThing = getThing(dataset, listUrl)
+    const newNoteBody = listThing && thingsToArray(listThing, dataset, noteThingToSlateObject)
+    expect(newNoteBody).toEqual(noteBody);
+  });
+});