solid-logic 1.3.13-c2b08ef1 → 1.3.13-c448e6a9

package/src/authn/authUtil.ts

@@ -1,67 +0,0 @@
-import { NamedNode, sym } from "rdflib"
-import * as debug from '../util/debug'
-
-/**
- * find a user or app's context as set in window.SolidAppContext
- * this is a const, not a function, because we have problems to jest mock it otherwise
- * see: https://github.com/facebook/jest/issues/936#issuecomment-545080082 for more
- * @return {any} - an appContext object
- */
-export const appContext = ():any => {
-    let { SolidAppContext }: any = window
-    SolidAppContext ||= {}
-    SolidAppContext.viewingNoAuthPage = false
-    if (SolidAppContext.noAuth && window.document) {
-        const currentPage = window.document.location.href
-        if (currentPage.startsWith(SolidAppContext.noAuth)) {
-        SolidAppContext.viewingNoAuthPage = true
-        const params = new URLSearchParams(window.document.location.search)
-        if (params) {
-            let viewedPage = SolidAppContext.viewedPage = params.get('uri') || null
-            if (viewedPage) {
-            viewedPage = decodeURI(viewedPage)
-            if (!viewedPage.startsWith(SolidAppContext.noAuth)) {
-                const ary = viewedPage.split(/\//)
-                SolidAppContext.idp = ary[0] + '//' + ary[2]
-                SolidAppContext.viewingNoAuthPage = false
-            }
-            }
-        }
-        }
-    }
-    return SolidAppContext
-}
-
-/**
- * Returns `sym($SolidTestEnvironment.username)` if
- * `$SolidTestEnvironment.username` is defined as a global
- * or 
- * returns testID defined in the HTML page
- * @returns {NamedNode|null}
- */
-export function offlineTestID (): NamedNode | null {
-    const { $SolidTestEnvironment }: any = window
-    if (
-      typeof $SolidTestEnvironment !== 'undefined' &&
-      $SolidTestEnvironment.username
-    ) {
-      // Test setup
-      debug.log('Assuming the user is ' + $SolidTestEnvironment.username)
-      return sym($SolidTestEnvironment.username)
-    }
-    // hack that makes SolidOS work in offline mode by adding the webId directly in html
-    // example usage: https://github.com/solid/mashlib/blob/29b8b53c46bf02e0e219f0bacd51b0e9951001dd/test/contact/local.html#L37
-    if (
-      typeof document !== 'undefined' &&
-      document.location &&
-      ('' + document.location).slice(0, 16) === 'http://localhost'
-    ) {
-      const div = document.getElementById('appTarget')
-      if (!div) return null
-      const id = div.getAttribute('testID')
-      if (!id) return null
-      debug.log('Assuming user is ' + id)
-      return sym(id)
-    }
-    return null
-}

package/src/issuer/issuerLogic.ts

@@ -1,40 +0,0 @@
-const DEFAULT_ISSUERS = [
-  {
-    name: 'Solid Community',
-    uri: 'https://solidcommunity.net'
-  },
-  {
-    name: 'Solid Web',
-    uri: 'https://solidweb.org'
-  },
-  {
-    name: 'Inrupt.net',
-    uri: 'https://inrupt.net'
-  },
-  {
-    name: 'pod.Inrupt.com',
-    uri: 'https://broker.pod.inrupt.com'
-  }
-]
-
-/**
- * @returns - A list of suggested OIDC issuers
- */
-export function getSuggestedIssuers (): { name: string, uri: string }[] {
-    // Suggest a default list of OIDC issuers
-    const issuers = [...DEFAULT_ISSUERS]
-  
-    // Suggest the current host if not already included
-    const { host, origin } = new URL(location.href)
-    const hosts = issuers.map(({ uri }) => new URL(uri).host)
-    if (!hosts.includes(host) && !hosts.some(existing => isSubdomainOf(host, existing))) {
-      issuers.unshift({ name: host, uri: origin })
-    }
-  
-    return issuers
-  }
-  
-function isSubdomainOf (subdomain: string, domain: string): boolean {
-    const dot = subdomain.length - domain.length - 1
-    return dot > 0 && subdomain[dot] === '.' && subdomain.endsWith(domain)
-}

package/src/logic/CustomError.ts

@@ -1,25 +0,0 @@
-class CustomError extends Error {
-    constructor(message?: string) {
-        super(message);
-        // see: typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html
-        Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain
-        this.name = new.target.name; // stack traces display correctly now
-    }
-}
-    
-export class UnauthorizedError extends CustomError {}
-
-export class CrossOriginForbiddenError extends CustomError {}
-
-export class SameOriginForbiddenError extends CustomError {}
-
-export class NotFoundError extends CustomError {}
-
-export class FetchError extends CustomError {
-    status: number;
-
-    constructor(status: number, message?: string) {
-        super(message);
-        this.status = status;
-    }
-}

package/src/logic/SolidLogic.ts

@@ -1,264 +0,0 @@
-import { Session } from "@inrupt/solid-client-authn-browser";
-import * as rdf from "rdflib";
-import { NamedNode, Statement, LiveStore } from "rdflib";
-import solidNamespace from "solid-namespace";
-import { SolidAuthnLogic } from "../authn/SolidAuthnLogic";
-import { ChatLogic } from "../chat/ChatLogic";
-import { ProfileLogic } from "../profile/ProfileLogic";
-import { AuthnLogic, SolidNamespace } from "../types";
-import * as debug from "../util/debug";
-import { UtilityLogic } from "../util/UtilityLogic";
-import { CrossOriginForbiddenError, FetchError, NotFoundError, SameOriginForbiddenError, UnauthorizedError } from "./CustomError";
-
-
-const ns: SolidNamespace = solidNamespace(rdf);
-
-export class SolidLogic {
-    cache: {
-        profileDocument: {
-        [WebID: string]: NamedNode;
-        };
-        preferencesFile: {
-        [WebID: string]: NamedNode;
-        };
-    };
-
-    store: LiveStore;
-    me: string | undefined;
-    fetcher: { fetch: (url: string, options?: any) => any };
-
-    chat: ChatLogic;
-    profile: ProfileLogic;
-    authn: AuthnLogic;
-    util: UtilityLogic;
-
-    constructor(fetcher: { fetch: (url: any, requestInit: any) => any }, session: Session) {
-        this.store = rdf.graph() as LiveStore; // Make a Quad store
-        rdf.fetcher(this.store, fetcher); // Attach a web I/O module, store.fetcher
-        this.store.updater = new rdf.UpdateManager(this.store); // Add real-time live updates store.updater
-        this.cache = {
-        profileDocument: {},
-        preferencesFile: {},
-        };
-        this.fetcher = fetcher;
-        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);
-    }
-
-    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)
-        if (this.cache.profileDocument[me.value]) {
-        return this.cache.profileDocument[me.value];
-        }
-        let profileDocument;
-        try {
-        profileDocument = me.doc();
-        await this.loadDoc(profileDocument);
-        return profileDocument;
-        } catch (err) {
-        const message = `Logged in but cannot load profile ${profileDocument} : ${err}`;
-        throw new Error(message);
-        }
-    }
-
-    async loadPreferences(me: NamedNode): Promise<NamedNode> {
-        // console.log('loadPreferences', me)
-        if (this.cache.preferencesFile[me.value]) {
-        return this.cache.preferencesFile[me.value];
-        }
-        const preferencesFile = this.store.any(me, ns.space("preferencesFile"));
-
-        // console.log('this.store.any()', this.store.any())
-        /**
-         * Are we working cross-origin?
-         * Returns True if we are in a webapp at an origin, and the file origin is different
-         */
-        function differentOrigin(): boolean {
-        if (!preferencesFile) {
-            return true;
-        }
-        return (
-            `${window.location.origin}/` !== new URL(preferencesFile.value).origin
-        );
-        }
-
-        if (!preferencesFile) {
-        throw new Error(
-            `Can't find a preference file pointer in profile ${me.doc()}`
-        );
-        }
-
-        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, {
-            withCredentials: true,
-        });
-        } catch (err) {
-        // Really important to look at why
-        const status = err.status;
-        debug.log(`HTTP status ${status} for preference file ${preferencesFile}`);
-        if (status === 401) {
-            throw new UnauthorizedError();
-        }
-        if (status === 403) {
-            if (differentOrigin()) {
-            throw new CrossOriginForbiddenError();
-            }
-            throw new SameOriginForbiddenError();
-        }
-        if (status === 404) {
-            throw new NotFoundError(preferencesFile.value);
-        }
-        throw new FetchError(err.status, err.message);
-        }
-        return preferencesFile as NamedNode;
-    }
-
-    getTypeIndex(
-        me: NamedNode | string,
-        preferencesFile: NamedNode | string,
-        isPublic: boolean
-    ): NamedNode[] {
-        // console.log('getTypeIndex', this.store.each(me, undefined, undefined, preferencesFile), isPublic, preferencesFile)
-        return this.store.each(
-        me as NamedNode,
-        isPublic ? ns.solid("publicTypeIndex") : ns.solid("privateTypeIndex"),
-        undefined,
-        preferencesFile as NamedNode
-        ) as NamedNode[];
-    }
-
-    getRegistrations(instance, theClass) {
-        return this.store
-        .each(undefined, ns.solid("instance"), instance)
-        .filter((r) => {
-            return this.store.holds(r, ns.solid("forClass"), theClass);
-        });
-    }
-
-    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);
-    }
-
-    async loadIndexes(
-        me: NamedNode | string,
-        publicProfile: NamedNode | string | null,
-        preferencesFile: NamedNode | string | null,
-        onWarning = async (_err: Error) => {
-            return undefined;
-        }
-    ): Promise<{
-        private: any;
-        public: any;
-    }> {
-        let privateIndexes: any[] = [];
-        let publicIndexes: any[] = [];
-        if (publicProfile) {
-        publicIndexes = this.getTypeIndex(me, publicProfile, true);
-        try {
-            await this.load(publicIndexes as NamedNode[]);
-        } catch (err) {
-            onWarning(new Error(`loadIndex: loading public type index(es) ${err}`));
-        }
-        }
-        if (preferencesFile) {
-        privateIndexes = this.getTypeIndex(me, preferencesFile, false);
-        // console.log({ privateIndexes })
-        if (privateIndexes.length === 0) {
-            await onWarning(
-            new Error(
-                `Your preference file ${preferencesFile} does not point to a private type index.`
-            )
-            );
-        } else {
-            try {
-            await this.load(privateIndexes);
-            } catch (err) {
-            onWarning(
-                new Error(`loadIndex: loading private type index(es) ${err}`)
-            );
-            }
-        }
-        // } else {
-        //   debug.log(
-        //     'We know your preference file is not available, so we are not bothering with private type indexes.'
-        //   )
-        }
-
-        return {
-        private: privateIndexes,
-        public: publicIndexes,
-        };
-    }
-
-    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}
-    `,
-        contentType: "text/turtle",
-        });
-    }
-
-    // @@@@ use the one in rdflib.js when it is available and delete this
-    updatePromise(
-        del: Array<Statement>,
-        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));
-            } else {
-            resolve();
-            }
-        }); // callback
-        }); // promise
-    }
-
-    isContainer(url: string) {
-        return this.util.isContainer(url);
-    }
-
-    getContainerElements(containerNode: NamedNode): NamedNode[] {
-        return this.util.getContainerElements(containerNode);
-    }
-
-    getContainerMembers(containerUrl: string): Promise<string[]> {
-        return this.util.getContainerMembers(containerUrl);
-    }
-
-    async recursiveDelete(url: string) {
-        return this.util.recursiveDelete(url);
-    }
-
-    clearStore() {
-        return this.util.clearStore();
-    }
-
-    async fetch(url: string, options?: any) {
-        return this.fetcher.fetch(url, options);
-    }
-}

package/src/logic/solidLogicSingleton.ts

@@ -1,24 +0,0 @@
-import * as debug from "../util/debug"
-import authSession from "../authSession/authSession"
-import { SolidLogic } from "./SolidLogic"
-
-const fetcher = async (url, requestInit) => {
-    if (authSession.info.webId) {
-        return authSession.fetch(url, requestInit)
-    } else {
-        return window.fetch(url, requestInit)
-    }
-}
-
-const solidLogicSingleton = new SolidLogic({ fetch: fetcher }, authSession)
-
-// Make this directly accessible as it is what you need most of the time
-const authn = solidLogicSingleton.authn
-const store = solidLogicSingleton.store
-
-const chat = solidLogicSingleton.chat
-const profile = solidLogicSingleton.profile
-
-debug.log('Unique quadstore initialized.')
-
-export { solidLogicSingleton, authn, store, chat, profile }

package/src/typeIndex/typeIndexLogic.ts

@@ -1,170 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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 {
-    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/test/aclLogic.test.ts

@@ -1,15 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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/test/helpers/setup.ts

@@ -1,13 +0,0 @@
-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)
-}