solid-logic 1.3.14 → 1.3.15-908cf936

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,44 @@ 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 = indexes.private.concat(context.index.private || []) // otherwise concat will wrongly add 'undefined' as a private index
+context.index.public = indexes.public.concat(context.index.public || []) // otherwise concat will wrongly add 'undefined' as a public index
 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 +85,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 +102,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 +172,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 +198,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')
     })
 })

package/renovate.json

@@ -1,5 +0,0 @@
-{
-  "extends": [
-    "config:base"
-  ]
-}