solid-logic 1.3.14-fd51b121 → 1.3.15-b1f4b69f

package/src/logic/SolidLogic.ts

@@ -9,7 +9,12 @@ import { AuthnLogic, SolidNamespace } from "../types";
 import * as debug from "../util/debug";
 import { UtilityLogic } from "../util/UtilityLogic";
 import { CrossOriginForbiddenError, FetchError, NotFoundError, SameOriginForbiddenError, UnauthorizedError } from "./CustomError";
-
+/*
+** It is important to distinquish `fetch`, a function provided by the browser
+** and `Fetcher`, a helper object for the rdflib Store which turns it
+** into a `ConnectedStore` or a `LiveStore`.  A Fetcher object is
+** available at store.fetcher, and `fetch` function at `store.fetcher._fetch`,
+*/
 
 const ns: SolidNamespace = solidNamespace(rdf);
 
@@ -25,60 +30,64 @@ export class SolidLogic {
 
     store: LiveStore;
     me: string | undefined;
-    fetcher: { fetch: (url: string, options?: any) => any };
+    underlyingFetch: { fetch: (url: string, options?: any) => any };
 
     chat: ChatLogic;
     profile: ProfileLogic;
     authn: AuthnLogic;
     util: UtilityLogic;
 
-    constructor(fetcher: { fetch: (url: any, requestInit: any) => any }, session: Session) {
+    constructor(specialFetch: { fetch: (url: any, requestInit: any) => any }, session: Session) {
+  // would xpect to be able to do it this way: but get TypeError:  Failed to execute 'fetch' on 'Window': Illegal invocation status: 999
+        // this.store = new rdf.LiveStore({})
+        // this.store.fetcher._fetch = fetch
+        console.log("SolidLogic: Unique instance created.  There should only be one of these.")
         this.store = rdf.graph() as LiveStore; // Make a Quad store
-        rdf.fetcher(this.store, fetcher); // Attach a web I/O module, store.fetcher
+        rdf.fetcher(this.store, { fetch: specialFetch.fetch}); // Attach a web I/O module, store.fetcher
         this.store.updater = new rdf.UpdateManager(this.store); // Add real-time live updates store.updater
+
         this.store.features = [] // disable automatic node merging on store load
         this.cache = {
         profileDocument: {},
         preferencesFile: {},
         };
-        this.fetcher = fetcher;
+        this.underlyingFetch = { fetch: fetch }; // Note global one not the one passed
         this.authn = new SolidAuthnLogic(session);
         debug.log('SolidAuthnLogic initialized')
         this.profile = new ProfileLogic(this.store, ns, this.authn);
         this.chat = new ChatLogic(this.store, ns, this.profile);
-        this.util = new UtilityLogic(this.store, ns, this.fetcher);
+        this.util = new UtilityLogic(this.store, ns, this.underlyingFetch);
     }
 
     findAclDocUrl(url: string) {
         return this.util.findAclDocUrl(url);
     }
 
-    loadDoc(doc: NamedNode): Promise<void> {
-        return this.util.loadDoc(doc);
-    }
-
     async loadProfile(me: NamedNode): Promise<NamedNode> {
-        // console.log('loadProfile', me)
+        /*
+      // console.log('loadProfile cache ', this.cache)
         if (this.cache.profileDocument[me.value]) {
         return this.cache.profileDocument[me.value];
-        }
-        let profileDocument;
+      }    @@ just use the cache in the store
+        */
+        console.log('loadProfile  me ', me)
+        const profileDocument = me.doc()
         try {
-        profileDocument = me.doc();
-        await this.loadDoc(profileDocument);
-        return profileDocument;
+          await this.store.fetcher.load(profileDocument);
+          return profileDocument;
         } catch (err) {
-        const message = `Logged in but cannot load profile ${profileDocument} : ${err}`;
+        const message = `Cannot load profile ${profileDocument} : ${err}`;
         throw new Error(message);
         }
     }
 
     async loadPreferences(me: NamedNode): Promise<NamedNode> {
-        // console.log('loadPreferences', me)
+        console.log('loadPreferences cache ', this.cache)
         if (this.cache.preferencesFile[me.value]) {
         return this.cache.preferencesFile[me.value];
         }
-        const preferencesFile = this.store.any(me, ns.space("preferencesFile"));
+        await this.loadProfile(me) // Load pointer to pref file
+        const preferencesFile = this.store.any(me, ns.space('preferencesFile'), null, me.doc());
 
         // console.log('this.store.any()', this.store.any())
         /**
@@ -100,9 +109,6 @@ export class SolidLogic {
         );
         }
 
-        if (!this.store.fetcher) {
-        throw new Error("Cannot load doc, have no fetcher");
-        }
         // //// Load preference file
         try {
         await this.store.fetcher.load(preferencesFile as NamedNode, {
@@ -152,9 +158,6 @@ export class SolidLogic {
     }
 
     load(doc: NamedNode | NamedNode[] | string) {
-        if (!this.store.fetcher) {
-        throw new Error("Cannot load doc(s), have no fetcher");
-        }
         return this.store.fetcher.load(doc);
     }
 
@@ -210,9 +213,6 @@ export class SolidLogic {
     }
 
     async createEmptyRdfDoc(doc: NamedNode, comment: string) {
-        if (!this.store.fetcher) {
-        throw new Error("Cannot create empty rdf doc, have no fetcher");
-        }
         await this.store.fetcher.webOperation("PUT", doc.uri, {
         data: `# ${new Date()} ${comment}
     `,
@@ -226,9 +226,6 @@ export class SolidLogic {
         ins: Array<Statement> = []
     ): Promise<void> {
         return new Promise((resolve, reject) => {
-        if (!this.store.updater) {
-            throw new Error("Cannot updatePromise, have no updater");
-        }
         this.store.updater.update(del, ins, function (_uri, ok, errorBody) {
             if (!ok) {
             reject(new Error(errorBody));
@@ -260,6 +257,6 @@ export class SolidLogic {
     }
 
     async fetch(url: string, options?: any) {
-        return this.fetcher.fetch(url, options);
+        return this.underlyingFetch.fetch(url, options);
     }
 }

package/src/typeIndex/typeIndexLogic.ts

@@ -5,13 +5,23 @@ import * as $rdf from 'rdflib'
 import { newThing } from "../util/uri"
 import { AuthenticationContext } from "../types"
 import { solidLogicSingleton } from "../logic/solidLogicSingleton"
-
+// import { ensureLoadedPreferences } from '../logic/logic'
+import { loadPreferences, loadProfile } from '../discovery/discoveryLogic'
 export const ns = solidNamespace($rdf)
 
+const store = solidLogicSingleton.store
+
+async function ensureLoadedPreferences (context:AuthenticationContext) {
+  if (!context.me) throw new Error('@@ ensureLoadedPreferences: no user specified')
+  context.publicProfile = await loadProfile(store, context.me)
+  context.preferencesFile = await loadPreferences(store, context.me)
+  return context
+}
+
 /**
  * Resolves with the same context, outputting
  * output: index.public, index.private
- *
+ *  @@ This is a very bizare function
  * @see https://github.com/solid/solid/blob/main/proposals/data-discovery.md#discoverability
  */
 export async function loadIndex (
@@ -26,32 +36,46 @@ const indexes = await solidLogicSingleton.loadIndexes(
     async (err: Error) => debug.error(err.message) as undefined
 )
 context.index = context.index || {}
-context.index.private = indexes.private || context.index.private
-context.index.public = indexes.public || context.index.public
+context.index.private = context.index.private || [] // otherwise concat will wrongly add 'undefined' as a private index
+context.index.private = indexes.private.concat(context.index.private)
+context.index.public = context.index.public || [] // otherwise concat will wrongly add 'undefined' as a public index
+context.index.public = indexes.public.concat(context.index.public)
 return context
 }
 
 export async function loadTypeIndexes (context: AuthenticationContext) {
-const indexes = await solidLogicSingleton.loadIndexes(
-    context.me as NamedNode,
-    context.publicProfile || null,
-    context.preferencesFile || null,
-    // async (err: Error) => widgets.complain(context, err.message)
-    async (err: Error) => debug.warn(err.message) as undefined
-)
-context.index = context.index || {}
-context.index.private = indexes.private || context.index.private
-context.index.public = indexes.public || context.index.public
-return context
+    try {
+        await loadPreferences(solidLogicSingleton.store, context.me)
+    } catch (error) {
+        debug.warn(error.message) as undefined
+    }
+    try {
+        const indexes = await solidLogicSingleton.loadIndexes(
+            context.me as NamedNode,
+            context.publicProfile || null,
+            context.preferencesFile || null,
+            // async (err: Error) => widgets.complain(context, err.message)
+            // async (err: Error) => debug.warn(err.message) as undefined
+        )
+        context.index = context.index || {}
+        context.index.private = indexes.private || context.index.private
+        context.index.public = indexes.public || context.index.public
+        return context
+    } catch (error) {
+        async (error: Error) => debug.warn(error.message) as undefined
+    }
 }
 
 /**
  * Resolves with the same context, outputting
  * @see https://github.com/solid/solid/blob/main/proposals/data-discovery.md#discoverability
  */
-export async function ensureTypeIndexes (context: AuthenticationContext): Promise<AuthenticationContext> {
-await ensureOneTypeIndex(context, true)
-await ensureOneTypeIndex(context, false)
+export async function ensureTypeIndexes (context: AuthenticationContext, agent?: NamedNode): Promise<AuthenticationContext> {
+if (!context.me) {
+  throw new Error(`ensureTypeIndexes: @@ no user`)
+}
+await ensureOneTypeIndex(context, true, agent)
+await ensureOneTypeIndex(context, false, agent)
 return context
 }
 
@@ -63,9 +87,10 @@ return context
  * Adds its output to the context
  * @see https://github.com/solid/solid/blob/main/proposals/data-discovery.md#discoverability
  */
-async function ensureOneTypeIndex (context: AuthenticationContext, isPublic: boolean): Promise<AuthenticationContext | void> {
+async function ensureOneTypeIndex (context: AuthenticationContext, isPublic: boolean, agent?: NamedNode): Promise<AuthenticationContext | void> {
     async function makeIndexIfNecessary (context, isPublic) {
         const relevant = isPublic ? context.publicProfile : context.preferencesFile
+        if (!relevant) alert ('@@@@ relevent null')
         const visibility = isPublic ? 'public' : 'private'
 
         async function putIndex (newIndex) {
@@ -79,58 +104,65 @@ async function ensureOneTypeIndex (context: AuthenticationContext, isPublic: boo
             }
         } // putIndex
 
+
         context.index = context.index || {}
         context.index[visibility] = context.index[visibility] || []
         let newIndex
         if (context.index[visibility].length === 0) {
-        newIndex = sym(`${relevant.dir().uri + visibility}TypeIndex.ttl`)
-        debug.log(`Linking to new fresh type index ${newIndex}`)
-        if (!confirm(`OK to create a new empty index file at ${newIndex}, overwriting anything that is now there?`)) {
-            throw new Error('cancelled by user')
-        }
-        debug.log(`Linking to new fresh type index ${newIndex}`)
-        const addMe = [
-            st(context.me, ns.solid(`${visibility}TypeIndex`), newIndex, relevant)
-        ]
-        try {
-            await solidLogicSingleton.updatePromise([], addMe)
-        } catch (err) {
-            const msg = `Error saving type index link saving back ${newIndex}: ${err}`
-            //widgets.complain(context, msg)
-            debug.warn(msg)
-            return context
-        }
+            if (!store.updater.editable(relevant)) {
+              debug.log(`Not adding new type index as ${relevant} is not editable`)
+              return
+            }
+            newIndex = sym(`${relevant.dir().uri + visibility}TypeIndex.ttl`)
+            debug.log(`Linking to new fresh type index ${newIndex}`)
+            if (!confirm(`OK to create a new empty index file at ${newIndex}, overwriting anything that is now there?`)) {
+                throw new Error('cancelled by user')
+            }
+            debug.log(`Linking to new fresh type index ${newIndex}`)
+            const addMe = [
+                st(context.me, ns.solid(`${visibility}TypeIndex`), newIndex, relevant)
+            ]
+            try {
+                await solidLogicSingleton.updatePromise([], addMe)
+            } catch (err) {
+                const msg = `Error saving type index link saving back ${newIndex}: ${err}`
+                //widgets.complain(context, msg)
+                debug.warn(msg)
+                return context
+            }
 
-        debug.log(`Creating new fresh type index file${newIndex}`)
-        await putIndex(newIndex)
-        context.index[visibility].push(newIndex) // @@ wait
+            debug.log(`Creating new fresh type index file${newIndex}`)
+            await putIndex(newIndex)
+            context.index[visibility].push(newIndex) // @@ wait
         } else {
         // officially exists
-        const ixs = context.index[visibility]
-        try {
-            await solidLogicSingleton.load(ixs)
-        } catch (err) {
-            const msg = `ensureOneTypeIndex: loading indexes ${err}`
-            debug.warn(msg)
-            // widgets.complain(context, `ensureOneTypeIndex: loading indexes ${err}`)
-        }
+          const ixs = context.index[visibility]
+          try {
+              await solidLogicSingleton.load(ixs)
+          } catch (err) {
+              const msg = `ensureOneTypeIndex: loading indexes ${err}`
+              debug.warn(msg)
+              // widgets.complain(context, `ensureOneTypeIndex: loading indexes ${err}`)
+          }
         }
     } // makeIndexIfNecessary
 
+    const context2 = await ensureLoadedPreferences(context)
+    if (!context2.publicProfile) throw new Error(`@@ type index: no publicProfile`)
+    if (!context2.preferencesFile) throw new Error(`@@ type index: no preferencesFile for profile  ${context2.publicProfile}`)
+    const relevant = isPublic ? context2.publicProfile : context2.preferencesFile
+
     try {
-        await loadIndex(context, isPublic)
-        if (context.index) {
-        debug.log(
-            `ensureOneTypeIndex: Type index exists already ${isPublic
-            ? context.index.public[0]
-            : context.index.private[0]
-            }`
-        )
+        await loadIndex(context2, isPublic)
+        const pp = isPublic ? 'public' : 'private'
+        if (context2.index && context2.index[pp]&& context2.index[pp].length > 0) {
+          debug.log(`ensureOneTypeIndex: Type index exists already ${context2.index[pp]}`)
+          return context2
         }
-        return context
+        await makeIndexIfNecessary(context2, isPublic)
     } catch (error) {
-        await makeIndexIfNecessary(context, isPublic)
-        // widgets.complain(context, 'calling loadIndex:' + error)
+        await makeIndexIfNecessary(context2, isPublic)
+        // widgets.complain(context2, 'calling loadIndex:' + error)
     }
 }
 
@@ -142,9 +174,10 @@ export async function registerInTypeIndex (
 context: AuthenticationContext,
 instance: NamedNode,
 theClass: NamedNode,
-isPublic: boolean
+isPublic: boolean,
+agent?: NamedNode // Defaults to current user
 ): Promise<AuthenticationContext> {
-    await ensureOneTypeIndex(context, isPublic)
+    await ensureOneTypeIndex(context, isPublic, agent)
     if (!context.index) {
         throw new Error('registerInTypeIndex: No type index found')
     }
@@ -167,4 +200,4 @@ isPublic: boolean
         alert(e)
     }
     return context
-}
+}

package/src/util/UtilityLogic.ts

@@ -11,12 +11,12 @@ export const ACL_LINK = sym(
 export class UtilityLogic {
   store: LiveStore;
   ns: SolidNamespace;
-  fetcher: { fetch: (url: string, options?: any) => any };
+  underlyingFetch: { fetch: (url: string, options?: any) => any };
 
-  constructor(store: LiveStore, ns: SolidNamespace, fetcher: { fetch: (url: string, options?: any) => any }) {
+  constructor(store: LiveStore, ns: SolidNamespace, underlyingFetch: { fetch: (url: string, options?: any) => any }) {
     this.store = store;
     this.ns = ns;
-    this.fetcher = fetcher;
+    this.underlyingFetch = underlyingFetch;
   }
 
   async findAclDocUrl(url: string) {
@@ -65,7 +65,7 @@ export class UtilityLogic {
       ].join('\n')
     }
     const aclDocUrl = await this.findAclDocUrl(options.target);
-    return this.fetcher.fetch(aclDocUrl, {
+    return this.underlyingFetch.fetch(aclDocUrl, {
       method: 'PUT',
       body: str,
       headers: [
@@ -83,7 +83,7 @@ export class UtilityLogic {
       throw new Error("Cannot load doc, have no fetcher");
     }
     await this.store.fetcher.load(doc, {
-      withCredentials: false,
+      withCredentials: false, // @@ BUT this won't work when logged in an accessing private stuff!
       cache: "reload",
     });
     // console.log('loaded', profileDocument, this.store)
@@ -98,7 +98,7 @@ export class UtilityLogic {
       throw new Error(`Not a container URL ${url}`);
     }
     // Copied from https://github.com/solid/solid-crud-tests/blob/v3.1.0/test/surface/create-container.test.ts#L56-L64
-    const result = await this.fetcher.fetch(url, {
+    const result = await this.underlyingFetch.fetch(url, {
       method: "PUT",
       headers: {
         "Content-Type": "text/turtle",
@@ -134,13 +134,13 @@ export class UtilityLogic {
     try {
       if (this.isContainer(url)) {
         const aclDocUrl = await this.findAclDocUrl(url);
-        await this.fetcher.fetch(aclDocUrl, { method: "DELETE" });
+        await this.underlyingFetch.fetch(aclDocUrl, { method: "DELETE" });
         const containerMembers = await this.getContainerMembers(url);
         await Promise.all(
           containerMembers.map((url) => this.recursiveDelete(url))
         );
       }
-      return this.fetcher.fetch(url, { method: "DELETE" });
+      return this.underlyingFetch.fetch(url, { method: "DELETE" });
     } catch (e) {
       // console.log(`Please manually remove ${url} from your system under test.`, e);
     }

package/test/chatLogic.test.ts

@@ -20,7 +20,7 @@ describe("Chat logic", () => {
       status: 404,
     });
     store = rdf.graph();
-    store.fetcher = rdf.fetcher(store, { fetch: fetchMock });
+    store.fetcher = rdf.fetcher(store, { fetch: fetchMock, timeout: 5 });
     store.updater = new UpdateManager(store);
     const authn = {
       currentUser: () => {

package/test/typeIndexLogic.test.ts

@@ -2,6 +2,20 @@ import { sym } from 'rdflib'
 import { AuthenticationContext } from '../src/types'
 import * as typeIndexLogic from '../src/typeIndex/typeIndexLogic'
 
+it('loadIndex', async () => {
+    const context = {
+        index: {}
+    }
+
+    const result = await typeIndexLogic.loadIndex(context, true)
+    expect(result).toEqual({
+        index: {
+        private: [],
+        public: []
+        },
+    })
+    })
+
 describe('loadTypeIndexes', () => {
     it('exists', () => {
         expect(typeIndexLogic.loadTypeIndexes).toBeInstanceOf(Function)
@@ -15,12 +29,13 @@ describe('registerInTypeIndex', () => {
     it('exists', () => {
         expect(typeIndexLogic.registerInTypeIndex).toBeInstanceOf(Function)
     })
-    it.skip('runs', async () => {
-        expect(await typeIndexLogic.registerInTypeIndex(
+    it('throws error', async () => {
+        expect(typeIndexLogic.registerInTypeIndex(
         {} as AuthenticationContext,
         sym('https://test.test#'),
         sym('https://test.test#'),
         false
-        )).toEqual(undefined)
+        )).rejects
+        .toThrow('@@ ensureLoadedPreferences: no user specified')
     })
 })