solid-logic 1.3.13 → 1.3.14

package/src/typeIndex/typeIndexLogic.ts

@@ -0,0 +1,170 @@
+import { NamedNode, st, sym } from "rdflib"
+import * as debug from '../util/debug'
+import solidNamespace from 'solid-namespace'
+import * as $rdf from 'rdflib'
+import { newThing } from "../util/uri"
+import { AuthenticationContext } from "../types"
+import { solidLogicSingleton } from "../logic/solidLogicSingleton"
+
+export const ns = solidNamespace($rdf)
+
+/**
+ * Resolves with the same context, outputting
+ * output: index.public, index.private
+ *
+ * @see https://github.com/solid/solid/blob/main/proposals/data-discovery.md#discoverability
+ */
+export async function loadIndex (
+context: AuthenticationContext,
+isPublic: boolean
+): Promise<AuthenticationContext> {
+const indexes = await solidLogicSingleton.loadIndexes(
+    context.me as NamedNode,
+    (isPublic ? context.publicProfile || null : null),
+    (isPublic ? null : context.preferencesFile || null),
+    // async (err: Error) => widgets.complain(context, err.message)
+    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
+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
+}
+
+/**
+ * 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)
+return context
+}
+
+/**
+ * Load or create ONE type index
+ * Find one or make one or fail
+ * Many reasons for failing including script not having permission etc
+ *
+ * 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 makeIndexIfNecessary (context, isPublic) {
+        const relevant = isPublic ? context.publicProfile : context.preferencesFile
+        const visibility = isPublic ? 'public' : 'private'
+
+        async function putIndex (newIndex) {
+            try {
+                await solidLogicSingleton.createEmptyRdfDoc(newIndex, 'Blank initial Type index')
+                return context
+            } catch (e) {
+                const msg = `Error creating new index ${e}`
+                // widgets.complain(context, msg)
+                debug.warn(msg)
+            }
+        } // 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
+        }
+
+        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}`)
+        }
+        }
+    } // makeIndexIfNecessary
+
+    try {
+        await loadIndex(context, isPublic)
+        if (context.index) {
+        debug.log(
+            `ensureOneTypeIndex: Type index exists already ${isPublic
+            ? context.index.public[0]
+            : context.index.private[0]
+            }`
+        )
+        }
+        return context
+    } catch (error) {
+        await makeIndexIfNecessary(context, isPublic)
+        // widgets.complain(context, 'calling loadIndex:' + error)
+    }
+}
+
+/**
+ * Register a new app in a type index
+ * used in chat in bookmark.js (solid-ui)
+ */
+export async function registerInTypeIndex (
+context: AuthenticationContext,
+instance: NamedNode,
+theClass: NamedNode,
+isPublic: boolean
+): Promise<AuthenticationContext> {
+    await ensureOneTypeIndex(context, isPublic)
+    if (!context.index) {
+        throw new Error('registerInTypeIndex: No type index found')
+    }
+    const indexes = isPublic ? context.index.public : context.index.private
+    if (!indexes.length) {
+        throw new Error('registerInTypeIndex: What no type index?')
+    }
+    const index = indexes[0]
+    const registration = newThing(index)
+    const ins = [
+        // See https://github.com/solid/solid/blob/main/proposals/data-discovery.md
+        st(registration, ns.rdf('type'), ns.solid('TypeRegistration'), index),
+        st(registration, ns.solid('forClass'), theClass, index),
+        st(registration, ns.solid('instance'), instance, index)
+    ]
+    try {
+        await solidLogicSingleton.updatePromise([], ins)
+    } catch (e) {
+        debug.log(e)
+        alert(e)
+    }
+    return context
+}

package/src/types.ts

@@ -0,0 +1,43 @@
+import { Session } from "@inrupt/solid-client-authn-browser"
+import { NamedNode } from "rdflib"
+
+export type AppDetails = {
+    noun: string
+    appPathSegment: string
+}
+
+export type AuthenticationContext = {
+    containers?: Array<NamedNode>
+    div?: HTMLElement
+    dom?: HTMLDocument
+    index?: { [key: string]: Array<NamedNode> }
+    instances?: Array<NamedNode>
+    me?: NamedNode | null
+    noun?: string
+    preferencesFile?: NamedNode
+    preferencesFileError?: string
+    publicProfile?: NamedNode
+    statusArea?: HTMLElement
+}
+
+export interface AuthnLogic {
+    authSession: Session //this needs to be deprecated in the future. Is only here to allow imports like panes.UI.authn.authSession prior to moving authn from ui to logic
+    currentUser: () => NamedNode | null
+    checkUser: <T>(setUserCallback?: (me: NamedNode | null) => T) => Promise<NamedNode | T | null>
+    saveUser: (webId: NamedNode | string | null,
+        context?: AuthenticationContext) => NamedNode | null
+}
+
+export interface SolidNamespace {
+    [key: string]: (term: string) => NamedNode
+}
+
+interface NewPaneOptions {
+    me?: NamedNode;
+    newInstance?: NamedNode;
+    newBase: string;
+}
+
+interface CreatedPaneOptions {
+newInstance: NamedNode;
+}

package/src/util/UtilityLogic.ts

@@ -1,22 +1,10 @@
-import { LiveStore, NamedNode, Node, st, term, sym, Statement } from "rdflib";
-import { SolidNamespace } from "../index";
-import { ProfileLogic } from "../profile/ProfileLogic";
-import { newThing } from "../uri";
+import { NamedNode, Statement, sym, LiveStore } from "rdflib";
+import { SolidNamespace } from "../types";
 
 export const ACL_LINK = sym(
   "http://www.iana.org/assignments/link-relations/acl"
 );
 
-interface NewPaneOptions {
-  me?: NamedNode;
-  newInstance?: NamedNode;
-  newBase: string;
-}
-
-interface CreatedPaneOptions {
-  newInstance: NamedNode;
-}
-
 /**
  * Utility-related logic
  */

package/test/aclLogic.test.ts

@@ -0,0 +1,15 @@
+import { sym } from 'rdflib'
+import { setACLUserPublic } from '../src/acl/aclLogic' 
+
+describe('setACLUserPublic', () => {
+    it('exists', () => {
+        expect(setACLUserPublic).toBeInstanceOf(Function)
+    })
+    it.skip('runs', async () => {
+        expect(await setACLUserPublic(
+        'https://test.test#',
+        sym('https://test.test#'),
+        {}
+        )).toEqual({})
+    })
+})

package/test/authUtil.test.ts

@@ -0,0 +1,23 @@
+/**
+* @jest-environment jsdom
+* 
+*/
+import * as authUtil from '../src/authn/authUtil'
+
+describe('offlineTestID', () => {
+    it('exists', () => {
+        expect(authUtil.offlineTestID).toBeInstanceOf(Function)
+    })
+    it('runs', () => {
+        expect(authUtil.offlineTestID()).toEqual(null)
+    })
+})
+
+describe('appContext', () => {
+    it('exists', () => {
+        expect(authUtil.appContext).toBeInstanceOf(Function)
+    })
+    it('runs', () => {
+        expect(authUtil.appContext()).toEqual({"viewingNoAuthPage": false,})
+    })
+})

package/{src/chat/integration.test.ts → test/chatLogic.test.ts}

@@ -1,13 +1,12 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { ChatLogic } from "./ChatLogic";
+import { ChatLogic } from "../src/chat/ChatLogic";
 import solidNamespace from "solid-namespace";
-
 import * as rdf from "rdflib";
-import { ProfileLogic } from "../profile/ProfileLogic";
-import fetchMock from "jest-fetch-mock";
+import { ProfileLogic } from "../src/profile/ProfileLogic";
 import { UpdateManager } from "rdflib";
+import { SolidNamespace } from "../src/types";
 
-const ns = solidNamespace(rdf);
+const ns: SolidNamespace = solidNamespace(rdf);
 
 const alice = rdf.sym("https://alice.example/profile/card#me");
 const bob = rdf.sym("https://bob.example/profile/card#me");
@@ -125,11 +124,10 @@ describe("Chat logic", () => {
       });
       it("sent an invitation to invitee inbox", () => {
         const request = getRequestTo("POST", "https://bob.example/inbox");
-        expect(request.body).toBe(`
+        expect(request.body).toContain(`
 <> a <http://www.w3.org/ns/pim/meeting#LongChatInvite> ;
-<http://www.w3.org/1999/02/22-rdf-syntax-ns#seeAlso> <https://alice.example/IndividualChats/bob.example/index.ttl#this> . 
-  `);
-      });
+<http://www.w3.org/1999/02/22-rdf-syntax-ns#seeAlso> <https://alice.example/IndividualChats/bob.example/index.ttl#this> .
+  `);});
       it("added the new chat to private type index", () => {
         const request = getRequestTo(
           "PATCH",

package/test/helpers/setup.ts

@@ -0,0 +1,13 @@
+import { error, log, trace, warn } from '../../src/util/debug'
+import fetchMock from "jest-fetch-mock";
+
+fetchMock.enableMocks();
+// We don't want to output debug messages to console as part of the tests
+jest.mock('../../src/util/debug')
+
+export function silenceDebugMessages () {
+  (log as any).mockImplementation(() => null)
+  ;(warn as any).mockImplementation(() => null)
+  ;(error as any).mockImplementation(() => null)
+  ;(trace as any).mockImplementation(() => null)
+}

package/{src/inbox/unit.test.ts → test/inboxLogic.test.ts}

@@ -1,14 +1,13 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { UtilityLogic } from "../util/UtilityLogic";
 import solidNamespace from "solid-namespace";
-
 import * as rdf from "rdflib";
-import { ProfileLogic } from "../profile/ProfileLogic";
-import fetchMock from "jest-fetch-mock";
 import { UpdateManager } from "rdflib";
-import { InboxLogic } from "./InboxLogic";
+import { ProfileLogic } from "../src/profile/ProfileLogic";
+import { UtilityLogic } from "../src/util/UtilityLogic";
+import { InboxLogic } from "../src/inbox/InboxLogic";
+import { SolidNamespace } from "../src/types";
 
-const ns = solidNamespace(rdf);
+const ns: SolidNamespace = solidNamespace(rdf);
 
 const alice = rdf.sym("https://alice.example/profile/card#me");
 const bob = rdf.sym("https://bob.example/profile/card#me");

package/test/logic.test.ts

@@ -0,0 +1,28 @@
+import { solidLogicSingleton } from "../src/index"
+import { silenceDebugMessages } from "./helpers/setup"
+
+silenceDebugMessages()
+
+describe('solidLogicSingleton (main global SolidLogic instance)', () => {
+  it('exists', () => {
+    expect(solidLogicSingleton).toBeInstanceOf(Object)
+  })
+})
+
+describe('solidLogicSingleton.store', () => {
+  it('exists', () => {
+    expect(solidLogicSingleton.store).toBeInstanceOf(Object)
+  })
+})
+
+describe('solidLogicSingleton.store.fetcher', () => {
+  it('exists', () => {
+    expect(solidLogicSingleton.store.fetcher).toBeInstanceOf(Object)
+  })
+})
+
+describe('solidLogicSingleton.store.updater', () => {
+  it('exists', () => {
+    expect(solidLogicSingleton.store.updater).toBeInstanceOf(Object)
+  })
+})

package/test/solidAuthLogic.test.ts

@@ -0,0 +1,49 @@
+/**
+* @jest-environment jsdom
+* 
+*/
+import { SolidAuthnLogic } from '../src/authn/SolidAuthnLogic'
+import { silenceDebugMessages } from './helpers/setup'
+import { authSession } from '../src/authSession/authSession'
+import { AuthenticationContext } from '../src/types'
+
+silenceDebugMessages()
+let solidAuthnLogic
+
+describe("SolidAuthnLogic", () => {
+  
+  beforeEach(() => {
+    solidAuthnLogic = new SolidAuthnLogic(authSession)
+  })
+
+  describe('checkUser', () => {
+    it('exists', () => {
+      expect(solidAuthnLogic.checkUser).toBeInstanceOf(Function)
+    })
+    it('runs', async () => {
+      expect(await solidAuthnLogic.checkUser()).toEqual(null)
+    })
+  })
+
+  describe('currentUser', () => {
+    it('exists', () => {
+      expect(solidAuthnLogic.currentUser).toBeInstanceOf(Function)
+    })
+    it('runs', async () => {
+      expect(await solidAuthnLogic.currentUser()).toEqual(null)
+    })
+  })
+
+  describe('saveUser', () => {
+    it('exists', () => {
+      expect(solidAuthnLogic.saveUser).toBeInstanceOf(Function)
+    })
+    it('runs', () => {
+      expect(solidAuthnLogic.saveUser(
+        '',
+        {} as AuthenticationContext
+      )).toEqual(null)
+    })
+  })
+
+})

package/test/typeIndexLogic.test.ts

@@ -0,0 +1,26 @@
+import { sym } from 'rdflib'
+import { AuthenticationContext } from '../src/types'
+import * as typeIndexLogic from '../src/typeIndex/typeIndexLogic'
+
+describe('loadTypeIndexes', () => {
+    it('exists', () => {
+        expect(typeIndexLogic.loadTypeIndexes).toBeInstanceOf(Function)
+    })
+    it('runs', () => {
+        expect(typeIndexLogic.loadTypeIndexes({})).toBeInstanceOf(Object)
+    })
+})
+
+describe('registerInTypeIndex', () => {
+    it('exists', () => {
+        expect(typeIndexLogic.registerInTypeIndex).toBeInstanceOf(Function)
+    })
+    it.skip('runs', async () => {
+        expect(await typeIndexLogic.registerInTypeIndex(
+        {} as AuthenticationContext,
+        sym('https://test.test#'),
+        sym('https://test.test#'),
+        false
+        )).toEqual(undefined)
+    })
+})

package/{src/util/unit.test.ts → test/utilityLogic.test.ts}

@@ -1,13 +1,12 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { UtilityLogic } from "./UtilityLogic";
+import { UtilityLogic } from "../src/util/UtilityLogic";
 import solidNamespace from "solid-namespace";
-
 import * as rdf from "rdflib";
-import { ProfileLogic } from "../profile/ProfileLogic";
 import fetchMock from "jest-fetch-mock";
 import { UpdateManager } from "rdflib";
+import { SolidNamespace } from "../src/types";
 
-const ns = solidNamespace(rdf);
+const ns: SolidNamespace = solidNamespace(rdf);
 
 const alice = rdf.sym("https://alice.example/profile/card#me");
 const bob = rdf.sym("https://bob.example/profile/card#me");

package/jest.setup.ts

@@ -1,2 +0,0 @@
-import fetchMock from "jest-fetch-mock";
-fetchMock.enableMocks();

package/lib/authn/NoAuthnLogic.d.ts

@@ -1,9 +0,0 @@
-import { AuthnLogic } from "./index";
-/**
- * Fallback, if no auth client has been provided to solid-logic
- */
-export declare class NoAuthnLogic implements AuthnLogic {
-    constructor();
-    currentUser(): null;
-}
-//# sourceMappingURL=NoAuthnLogic.d.ts.map

package/lib/authn/NoAuthnLogic.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NoAuthnLogic.d.ts","sourceRoot":"","sources":["../../src/authn/NoAuthnLogic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErC;;GAEG;AACH,qBAAa,YAAa,YAAW,UAAU;;IAO7C,WAAW,IAAI,IAAI;CAGpB"}

package/lib/authn/NoAuthnLogic.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NoAuthnLogic = void 0;
-/**
- * Fallback, if no auth client has been provided to solid-logic
- */
-var NoAuthnLogic = /** @class */ (function () {
-    function NoAuthnLogic() {
-        console.warn("no auth client passed to solid-logic, logic that relies on auth is not available");
-    }
-    NoAuthnLogic.prototype.currentUser = function () {
-        return null;
-    };
-    return NoAuthnLogic;
-}());
-exports.NoAuthnLogic = NoAuthnLogic;
-//# sourceMappingURL=NoAuthnLogic.js.map

package/lib/authn/NoAuthnLogic.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"NoAuthnLogic.js","sourceRoot":"","sources":["../../src/authn/NoAuthnLogic.ts"],"names":[],"mappings":";;;AAEA;;GAEG;AACH;IACE;QACE,OAAO,CAAC,IAAI,CACV,kFAAkF,CACnF,CAAC;IACJ,CAAC;IAED,kCAAW,GAAX;QACE,OAAO,IAAI,CAAC;IACd,CAAC;IACH,mBAAC;AAAD,CAAC,AAVD,IAUC;AAVY,oCAAY"}

package/lib/authn/index.d.ts

@@ -1,5 +0,0 @@
-import { NamedNode } from "rdflib";
-export interface AuthnLogic {
-    currentUser: () => NamedNode | null;
-}
-//# sourceMappingURL=index.d.ts.map

package/lib/authn/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/authn/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAEnC,MAAM,WAAW,UAAU;IACzB,WAAW,EAAE,MAAM,SAAS,GAAG,IAAI,CAAC;CACrC"}

package/lib/authn/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/authn/index.ts"],"names":[],"mappings":""}

package/lib/chat/integration.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=integration.test.d.ts.map

package/lib/chat/integration.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"integration.test.d.ts","sourceRoot":"","sources":["../../src/chat/integration.test.ts"],"names":[],"mappings":""}