solid-logic 1.3.17-7b06fb45 → 1.3.17-7b8c254b

package/src/logic/solidLogic.ts

@@ -0,0 +1,75 @@
+import { Session } from "@inrupt/solid-client-authn-browser";
+import * as rdf from "rdflib";
+import { LiveStore, NamedNode, Statement } from "rdflib";
+import { createAclLogic } from "../acl/aclLogic";
+import { SolidAuthnLogic } from "../authn/SolidAuthnLogic";
+import { createChatLogic } from "../chat/chatLogic";
+import { createInboxLogic } from "../inbox/inboxLogic";
+import { createProfileLogic } from "../profile/profileLogic";
+import { createTypeIndexLogic } from "../typeIndex/typeIndexLogic";
+import { createContainerLogic } from "../util/containerLogic";
+import { createUtilityLogic } from "../util/utilityLogic";
+import { AuthnLogic, SolidLogic } from "../types";
+import * as debug from "../util/debug";
+/*
+** 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`,
+*/
+export function createSolidLogic(specialFetch: { fetch: (url: any, requestInit: any) => any }, session: Session): SolidLogic {
+
+    debug.log("SolidLogic: Unique instance created.  There should only be one of these.")
+    const store: LiveStore = rdf.graph() as LiveStore
+    rdf.fetcher(store, {fetch: specialFetch.fetch}); // Attach a web I/O module, store.fetcher
+    store.updater = new rdf.UpdateManager(store); // Add real-time live updates store.updater
+    store.features = [] // disable automatic node merging on store load
+
+    const authn: AuthnLogic = new SolidAuthnLogic(session)
+    
+    const acl = createAclLogic(store)
+    const containerLogic = createContainerLogic(store)
+    const utilityLogic = createUtilityLogic(store, acl, containerLogic)
+    const profile = createProfileLogic(store, authn, utilityLogic)
+    const chat = createChatLogic(store, profile)
+    const inbox = createInboxLogic(store, profile, utilityLogic, containerLogic, acl)
+    const typeIndex = createTypeIndexLogic(store, authn, profile, utilityLogic)
+    debug.log('SolidAuthnLogic initialized')
+
+    function load(doc: NamedNode | NamedNode[] | string) {
+        return store.fetcher.load(doc);
+    }
+
+    // @@@@ use the one in rdflib.js when it is available and delete this
+    function updatePromise(
+        del: Array<Statement>,
+        ins: Array<Statement> = []
+    ): Promise<void> {
+        return new Promise((resolve, reject) => {
+        store.updater.update(del, ins, function (_uri, ok, errorBody) {
+            if (!ok) {
+            reject(new Error(errorBody));
+            } else {
+            resolve();
+            }
+        }); // callback
+        }); // promise
+    }
+
+    function clearStore() {
+        store.statements.slice().forEach(store.remove.bind(store));
+    }
+
+    return {
+        store,
+        authn,
+        acl,
+        inbox,
+        chat,
+        profile,
+        typeIndex,
+        load,
+        updatePromise,
+        clearStore
+    }
+}

package/src/logic/solidLogicSingleton.ts

@@ -1,6 +1,6 @@
 import * as debug from "../util/debug"
 import { authSession } from "../authSession/authSession"
-import { SolidLogic } from "./SolidLogic"
+import { createSolidLogic } from "./solidLogic"
 
 const _fetch = async (url, requestInit) => {
     const omitCreds = requestInit && requestInit.credentials && requestInit.credentials == 'omit'
@@ -13,7 +13,7 @@ const _fetch = async (url, requestInit) => {
 }
 
 //this const makes solidLogicSingleton global accessible in mashlib
-const solidLogicSingleton = new SolidLogic({ fetch: _fetch }, authSession)
+const solidLogicSingleton = createSolidLogic({ fetch: _fetch }, authSession)
 
 debug.log('Unique quadstore initialized.')
 

package/src/profile/profileLogic.ts

@@ -1,20 +1,13 @@
 import { NamedNode } from "rdflib";
 import { CrossOriginForbiddenError, FetchError, NotEditableError, SameOriginForbiddenError, UnauthorizedError, WebOperationError } from "../logic/CustomError";
-import { AuthenticationContext } from "../types";
 import * as debug from "../util/debug";
-import { differentOrigin, suggestPreferencesFile } from "../util/utils";
-import { ns as namespace } from '../util/ns'
+import { ns as namespace } from '../util/ns';
+import { differentOrigin, suggestPreferencesFile } from "../util/utils"
+import { ProfileLogic } from "../types"
 
-export function createProfileLogic(store, authn, utilityLogic) {
+export function createProfileLogic(store, authn, utilityLogic): ProfileLogic {
     const ns = namespace
 
-    async function ensureLoadedPreferences (context: AuthenticationContext) {
-        if (!context.me) throw new Error('@@ ensureLoadedPreferences: no user specified')
-        context.publicProfile = await loadProfile(context.me)
-        context.preferencesFile = await silencedLoadPreferences(context.me)
-        return context
-    }
-
     /**
      * loads the preference without throwing errors - if it can create it it does so.
      * remark: it still throws error if it cannot load profile.
@@ -121,7 +114,6 @@ export function createProfileLogic(store, authn, utilityLogic) {
     }
 
     return {
-        ensureLoadedPreferences,
         loadMe,
         getPodRoot,
         getMainInbox,

package/src/typeIndex/typeIndexLogic.ts

@@ -1,273 +1,11 @@
-import * as rdf from "rdflib"
-import { NamedNode, st, Statement, sym } from 'rdflib'
-import { AuthenticationContext, ScopedApp, TypeIndexScope } from '../types'
+import { NamedNode, st, sym } from 'rdflib'
+import { ScopedApp, TypeIndexLogic, TypeIndexScope } from '../types'
 import * as debug from "../util/debug"
-import {ns as namespace } from '../util/ns'
+import { ns as namespace } from '../util/ns'
 import { newThing, uniqueNodes } from "../util/utils"
 
-export function createTypeIndexLogic(store, authn, profileLogic, utilityLogic) {
+export function createTypeIndexLogic(store, authn, profileLogic, utilityLogic): TypeIndexLogic {
     const ns = namespace
-    
-    function updatePromise(
-        del: Array<Statement>,
-        ins: Array<Statement> = []
-    ): Promise<void> {
-        return new Promise((resolve, reject) => {
-        store.updater.update(del, ins, function (_uri, ok, errorBody) {
-            if (!ok) {
-            reject(new Error(errorBody));
-            } else {
-            resolve();
-            }
-        }); // callback
-        }); // promise
-    }
-    /**
-     * Resolves with the same context, outputting
-     * @see https://github.com/solidos/solid/blob/main/proposals/data-discovery.md#discoverability
-     */
-    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
-    }
-
-    async function loadTypeIndexes(context: AuthenticationContext) {
-        try {
-            await profileLogic.silencedLoadPreferences(context.me as NamedNode)
-        } catch (error) {
-            debug.warn(error.message) as undefined
-        }
-        try {
-            const indexes = await 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
-        }
-    }
-
-    /**
-     * Register a new app in a type index
-     * used in chat in bookmark.js (solid-ui)
-     */
-    async function registerInTypeIndex(
-        context: AuthenticationContext,
-        instance: NamedNode,
-        theClass: NamedNode,
-        isPublic: boolean,
-        agent?: NamedNode // Defaults to current user
-    ): Promise<AuthenticationContext> {
-        await ensureOneTypeIndex(context, isPublic, agent)
-        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/solidos/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 updatePromise([], ins)
-        } catch (e) {
-            debug.log(e)
-            alert(e)
-        }
-        return context
-    }
-
-    /**
-     * Resolves with the same context, outputting
-     * output: index.public, index.private
-     *  @@ This is a very bizare function
-     * @see https://github.com/solidos/solid/blob/main/proposals/data-discovery.md#discoverability
-     */
-    async function loadIndex(
-        context: AuthenticationContext,
-        isPublic: boolean
-    ): Promise<AuthenticationContext> {
-        const indexes = await 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.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
-    }
-
-    /**
-     * 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/solidos/solid/blob/main/proposals/data-discovery.md#discoverability
-     */
-    async function ensureOneTypeIndex(context: AuthenticationContext, isPublic: boolean, agent?: NamedNode): Promise<AuthenticationContext | void> {
-
-        const context2 = await profileLogic.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(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
-            }
-            await makeIndexIfNecessary(context2, isPublic, store, ns)
-        } catch (error) {
-            await makeIndexIfNecessary(context2, isPublic, store, ns)
-            // widgets.complain(context2, 'calling loadIndex:' + error)
-        }
-    }
-
-    async function putIndex(newIndex, context) {
-        try {
-            await utilityLogic.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
-        
-    async function makeIndexIfNecessary(context, isPublic, store, ns) {
-        const relevant = isPublic ? context.publicProfile : context.preferencesFile
-        if (!relevant) alert('@@@@ relevent null')
-        const visibility = isPublic ? 'public' : 'private'
-
-        context.index = context.index || {}
-        context.index[visibility] = context.index[visibility] || []
-        let newIndex
-        if (context.index[visibility].length === 0) {
-            if (!store.updater.editable(relevant)) {
-                debug.log(`Not adding new type index as ${relevant} is not editable`)
-                return
-            }
-            newIndex = rdf.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 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)
-            context.index[visibility].push(newIndex) // @@ wait
-        } else {
-            // officially exists
-            const ixs = context.index[visibility]
-            try {
-                await store.fetcher.load(ixs)
-            } catch (err) {
-                const msg = `ensureOneTypeIndex: loading indexes ${err}`
-                debug.warn(msg)
-                // widgets.complain(context, `ensureOneTypeIndex: loading indexes ${err}`)
-            }
-        }
-    } // makeIndexIfNecessary
-
-    async function 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 = getTypeIndex(me, publicProfile, true);
-            try {
-                await store.fetcher.load(publicIndexes as NamedNode[]);
-            } catch (err) {
-                onWarning(new Error(`loadIndex: loading public type index(es) ${err}`));
-            }
-        }
-        if (preferencesFile) {
-            privateIndexes = 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 store.fetcher.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,
-        };
-    }
-
-    function getTypeIndex(
-        me: NamedNode | string,
-        preferencesFile: NamedNode | string,
-        isPublic: boolean
-    ): NamedNode[] {
-        // console.log('getTypeIndex', store.each(me, undefined, undefined, preferencesFile), isPublic, preferencesFile)
-        return store.each(
-            me as NamedNode,
-            isPublic ? ns.solid("publicTypeIndex") : ns.solid("privateTypeIndex"),
-            undefined,
-            preferencesFile as NamedNode
-        ) as NamedNode[];
-    }
 
     function getRegistrations(instance, theClass) {
         return store
@@ -385,7 +123,7 @@ export function createTypeIndexLogic(store, authn, profileLogic, utilityLogic) {
     * used in chat in bookmark.js (solid-ui)
     * Returns the registration object if successful else null
     */
-    async function registerInstanceInTypeIndex(
+    async function registerInTypeIndex(
         instance: NamedNode,
         index: NamedNode,
         theClass: NamedNode,
@@ -415,7 +153,7 @@ export function createTypeIndexLogic(store, authn, profileLogic, utilityLogic) {
         await store.updater.update(statements, [])
     }
 
-    async function getScopedAppsFromIndex(scope, theClass: NamedNode | null) {
+    async function getScopedAppsFromIndex(scope: TypeIndexScope, theClass: NamedNode | null): Promise<ScopedApp[]> {
         const index = scope.index
         const registrations = store.statementsMatching(null, ns.solid('instance'), null, index)
             .concat(store.statementsMatching(null, ns.solid('instanceContainer'), null, index))
@@ -441,15 +179,7 @@ export function createTypeIndexLogic(store, authn, profileLogic, utilityLogic) {
     }
     
     return {
-        ensureTypeIndexes,
-        loadTypeIndexes,
         registerInTypeIndex,
-        loadIndex,
-        ensureOneTypeIndex,
-        putIndex,
-        makeIndexIfNecessary,
-        loadIndexes,
-        getTypeIndex,
         getRegistrations,
         loadTypeIndexesFor,
         loadCommunityTypeIndexes,
@@ -458,7 +188,6 @@ export function createTypeIndexLogic(store, authn, profileLogic, utilityLogic) {
         getAppInstances,
         suggestPublicTypeIndex,
         suggestPrivateTypeIndex,
-        registerInstanceInTypeIndex,
         deleteTypeIndexRegistration,
         getScopedAppsFromIndex
     }

package/src/types.ts

@@ -1,5 +1,5 @@
 import { Session } from "@inrupt/solid-client-authn-browser"
-import { NamedNode } from "rdflib"
+import { LiveStore, NamedNode, Statement } from "rdflib"
 
 export type AppDetails = {
     noun: string
@@ -45,3 +45,78 @@ export interface CreatedPaneOptions {
 newInstance: NamedNode;
 }
 
+export interface ChatLogic {
+    setAcl: (chatContainer: NamedNode, me: NamedNode, invitee: NamedNode) => Promise<void>,
+    addToPrivateTypeIndex: (chatThing, me) => void | Promise<void>,
+    findChat: (invitee: NamedNode) => Promise<Chat>,
+    createChatThing: (chatContainer: NamedNode, me: NamedNode) => Promise<NamedNode>,
+    mintNew: (newPaneOptions: NewPaneOptions) => Promise<CreatedPaneOptions>,
+    getChat: (invitee: NamedNode, boolean) => Promise<NamedNode | null>,
+    sendInvite: (invitee: NamedNode, chatThing: NamedNode) => void
+}
+
+export interface Chat {
+    me: NamedNode,
+    chatContainer: NamedNode,
+    exists: boolean
+}
+
+export interface ProfileLogic {
+    silencedLoadPreferences: (user: NamedNode) => Promise<NamedNode | undefined>,
+    loadPreferences: (user: NamedNode) => Promise<NamedNode>,
+    loadProfile: (user: NamedNode) => Promise<NamedNode>,
+    loadMe: () => Promise<NamedNode>,
+    getPodRoot: (user: NamedNode) => NamedNode,
+    getMainInbox: (user: NamedNode) => Promise<NamedNode>,
+    findStorage: (me: NamedNode) => Node | null
+}
+
+export interface AclLogic {
+    findAclDocUrl: (url: NamedNode) => Promise<any>,
+    setACLUserPublic: (docURI: string, me: NamedNode,
+        options: {
+            defaultForNew?: boolean,
+            public?: []
+        }
+    ) => Promise<NamedNode>,
+    genACLText: (docURI: string, me: NamedNode, aclURI: string,
+        options: {
+            defaultForNew?: boolean,
+            public?: []
+        }
+    ) => string | undefined
+}
+
+export interface InboxLogic {
+    createInboxFor: (peerWebId: string, nick: string) => Promise<string>,
+    getNewMessages: (user?: NamedNode) => Promise<NamedNode[]>,
+    markAsRead: (url: string, date: Date) => void
+}
+
+export interface TypeIndexLogic {
+    getRegistrations: (instance, theClass) => Node[],
+    loadTypeIndexesFor: (user: NamedNode) => Promise<Array<TypeIndexScope>>,
+    loadCommunityTypeIndexes: (user: NamedNode) => Promise<TypeIndexScope[][]>,
+    loadAllTypeIndexes: (user: NamedNode) => Promise<Array<TypeIndexScope>>,
+    getScopedAppInstances: (klass: NamedNode, user: NamedNode) => Promise<ScopedApp[]>,
+    getAppInstances: (klass: NamedNode) => Promise<NamedNode[]>,
+    suggestPublicTypeIndex: (me: NamedNode) => NamedNode,
+    suggestPrivateTypeIndex: (preferencesFile: NamedNode) => NamedNode,
+    registerInTypeIndex: (instance: NamedNode, index: NamedNode, theClass: NamedNode) => Promise<NamedNode | null>,
+    deleteTypeIndexRegistration: (item: any) => Promise<void>
+    getScopedAppsFromIndex: (scope: TypeIndexScope, theClass: NamedNode | null) => Promise<ScopedApp[]>
+}
+
+export interface SolidLogic {
+    store: LiveStore,
+    authn: AuthnLogic,
+    acl: AclLogic,
+    profile: ProfileLogic,
+    inbox: InboxLogic,
+    typeIndex: TypeIndexLogic,
+    chat: ChatLogic,
+    load: (doc: NamedNode | NamedNode[] | string) => void,
+    updatePromise: (del: Array<Statement>, ins: Array<Statement>) => Promise<void>,
+    clearStore: () => void
+}
+

package/src/util/containerLogic.ts

@@ -6,44 +6,43 @@ import { NamedNode, Statement, sym } from "rdflib";
 export function createContainerLogic(store) {
 
     function getContainerElements(containerNode: NamedNode): NamedNode[] {
-            return store
-                .statementsMatching(
-                    containerNode,
-                    sym("http://www.w3.org/ns/ldp#contains"),
-                    undefined,
-                    containerNode.doc()
-                )
-                .map((st: Statement) => st.object as NamedNode);
+        return store
+            .statementsMatching(
+                containerNode,
+                sym("http://www.w3.org/ns/ldp#contains"),
+                undefined
+            )
+            .map((st: Statement) => st.object as NamedNode);
     }
 
-    function isContainer(url: string) {
-            return url.charAt(url.length - 1) === "/";
+    function isContainer(url: NamedNode) {
+        const nodeToString = url.value;
+        return nodeToString.charAt(nodeToString.length - 1) === "/";
     }
 
     async function createContainer(url: string) {
-            if (!isContainer(url)) {
-                throw new Error(`Not a container URL ${url}`);
-            }
-            // Copied from https://github.com/solidos/solid-crud-tests/blob/v3.1.0/test/surface/create-container.test.ts#L56-L64
-            const result = await store.fetcher._fetch(url, {
-                method: "PUT",
-                headers: {
-                    "Content-Type": "text/turtle",
-                    "If-None-Match": "*",
-                    Link: '<http://www.w3.org/ns/ldp#BasicContainer>; rel="type"', // See https://github.com/solidos/node-solid-server/issues/1465
-                },
-                body: " ", // work around https://github.com/michielbdejong/community-server/issues/4#issuecomment-776222863
-            });
-            if (result.status.toString()[0] !== '2') {
-                throw new Error(`Not OK: got ${result.status} response while creating container at ${url}`);
-            }
+        const stringToNode = sym(url);
+        if (!isContainer(stringToNode)) {
+            throw new Error(`Not a container URL ${url}`);
+        }
+        // Copied from https://github.com/solidos/solid-crud-tests/blob/v3.1.0/test/surface/create-container.test.ts#L56-L64
+        const result = await store.fetcher._fetch(url, {
+            method: "PUT",
+            headers: {
+                "Content-Type": "text/turtle",
+                "If-None-Match": "*",
+                Link: '<http://www.w3.org/ns/ldp#BasicContainer>; rel="type"', // See https://github.com/solidos/node-solid-server/issues/1465
+            },
+            body: " ", // work around https://github.com/michielbdejong/community-server/issues/4#issuecomment-776222863
+        });
+        if (result.status.toString()[0] !== '2') {
+            throw new Error(`Not OK: got ${result.status} response while creating container at ${url}`);
+        }
     }
 
-    async function getContainerMembers(containerUrl: string): Promise<string[]> {
-            const containerNode = store.sym(containerUrl);
-            await store.fetcher.load(containerNode);
-            const nodes = getContainerElements(containerNode);
-            return nodes.map(node => node.value);
+    async function getContainerMembers(containerUrl: NamedNode): Promise<NamedNode[]> {
+        await store.fetcher.load(containerUrl);
+        return getContainerElements(containerUrl);
     }
     return {
         isContainer,

package/src/util/utilityLogic.ts

@@ -1,21 +1,22 @@
-import { NamedNode, st } from "rdflib";
+import { NamedNode, st, sym } from "rdflib";
 import { CrossOriginForbiddenError, FetchError, NotEditableError, SameOriginForbiddenError, UnauthorizedError, WebOperationError } from "../logic/CustomError";
 import * as debug from '../util/debug';
 import { differentOrigin } from "./utils";
 
 export function createUtilityLogic(store, aclLogic, containerLogic) {
 
-  async function recursiveDelete(url: string) {
+  async function recursiveDelete(containerNode: NamedNode) {
       try {
-        if (containerLogic.isContainer(url)) {
-          const aclDocUrl = await aclLogic.findAclDocUrl(url);
+        if (containerLogic.isContainer(containerNode)) {
+          const aclDocUrl = await aclLogic.findAclDocUrl(containerNode)
           await store.fetcher._fetch(aclDocUrl, { method: "DELETE" });
-          const containerMembers = await containerLogic.getContainerMembers(url);
+          const containerMembers = await containerLogic.getContainerMembers(containerNode);
           await Promise.all(
             containerMembers.map((url) => recursiveDelete(url))
           );
         }
-        return store.fetcher._fetch(url, { method: "DELETE" });
+        const nodeToStringHere = containerNode.value;
+        return store.fetcher._fetch(nodeToStringHere, { method: "DELETE" });
       } catch (e) {
         // debug.log(`Please manually remove ${url} from your system under test.`, e);
       }
@@ -126,7 +127,7 @@ export function createUtilityLogic(store, aclLogic, containerLogic) {
         ''
       ].join('\n')
     }
-    const aclDocUrl = await aclLogic.findAclDocUrl(options.target);
+    const aclDocUrl = await aclLogic.findAclDocUrl(sym(options.target))
     return store.fetcher._fetch(aclDocUrl, {
       method: 'PUT',
       body: str,