solid-logic 1.3.17-8a332867 → 1.3.17-a849582e

package/src/discovery/discoveryLogic.ts

@@ -1,58 +1,38 @@
-import { NamedNode, Namespace, LiveStore, sym, st } from "rdflib";
-// import * as debug from '../util/debug'
-// import { getContainerMembers } from '../util/UtilityLogic'
-import { solidLogicSingleton } from "../logic/solidLogicSingleton"
-import { newThing } from "../util/uri"
-const {  authn } = solidLogicSingleton
-const { currentUser } = authn
-
-type TypeIndexScope = { label: string, index: NamedNode, agent: NamedNode } ;
-type ScopedApp = { instance: NamedNode, scope: TypeIndexScope }
+import { NamedNode, LiveStore, sym, st } from 'rdflib'
+import * as $rdf from 'rdflib'
+import { newThing } from "../util/utils"
+import solidNamespace from 'solid-namespace'
+import { authn } from '../logic/solidLogicSingleton'
 
-const ns = {
-  dct:     Namespace('http://purl.org/dc/terms/'),
-  ldp:     Namespace('http://www.w3.org/ns/ldp#'),
-  meeting: Namespace('http://www.w3.org/ns/pim/meeting#'),
-  rdf:     Namespace('http://www.w3.org/1999/02/22-rdf-syntax-ns#'),
-  schema:  Namespace('http://schema.org/'),
-  solid:   Namespace('http://www.w3.org/ns/solid/terms#'),
-  space:   Namespace('http://www.w3.org/ns/pim/space#'),
-  stat:    Namespace('http://www.w3.org/ns/posix/stat#'),
-  vcard:   Namespace('http://www.w3.org/2006/vcard/ns#'),
-  wf:      Namespace('http://www.w3.org/2005/01/wf/flow#'),
-  xsd:     Namespace('http://www.w3.org/2001/XMLSchema#')
+const ns = solidNamespace($rdf)
 
-}
+type TypeIndexScope = { label: string, index: NamedNode, agent: NamedNode }
+type ScopedApp = { instance: NamedNode, scope: TypeIndexScope }
 
-/** Create a resource if it really does not exist
- *  Be absolutely sure something does not exist before creating a new empty file
+/**
+ * Create a resource if it really does not exist
+ * Be absolutely sure something does not exist before creating a new empty file
  * as otherwise existing could  be deleted.
  * @param doc {NamedNode} - The resource
  */
 export async function loadOrCreateIfNotExists (store: LiveStore, doc: NamedNode) {
     let response
-    // console.log('@@ loadOrCreateIfNotExists doc ', doc)
     try {
       response = await store.fetcher.load(doc)
     } catch (err) {
         if (err.response.status === 404) {
-          // console.log('createIfNotExists doc does NOT exist, will create: ' + doc)
           try {
             store.fetcher.webOperation('PUT', doc, {data: '', contentType: 'text/turtle'})
           } catch (err) {
             const msg = 'createIfNotExists: PUT FAILED: ' + doc + ': ' + err
-            // console.log(msg)
             throw new Error(msg)
           }
           delete store.fetcher.requested[doc.uri] // delete cached 404 error
-          // console.log('createIfNotExists doc created ok ' + doc)
         } else {
           const msg =  'createIfNotExists doc load error NOT 404:  ' + doc + ': ' + err
-          // console.log(msg)
           throw new Error(msg) // @@ add nested errors
         }
     }
-    // console.log('createIfNotExists doc exists, all good ' + doc)
     return response
 }
 
@@ -72,20 +52,18 @@ export function suggestPublicTypeIndex (me:NamedNode) {
 export function suggestPrivateTypeIndex (preferencesFile:NamedNode) {
   return sym(preferencesFile.doc().dir()?.uri + 'privateTypeIndex.ttl')
 }
+
 /* Follow link from this doc to another thing, or else make a new link
 **
-**  return: null no ld one and failed to make a new one
+** return: null no ld one and failed to make a new one
 */
 export async function followOrCreateLink (store: LiveStore, subject: NamedNode, predicate: NamedNode,
      object: NamedNode, doc:NamedNode):Promise<NamedNode | null> {
   await store.fetcher.load(doc)
   const result = store.any(subject, predicate, null, doc)
-  // console.log('@@ followOrCreateLink result ', result)
 
   if (result) return result as NamedNode
   if (!store.updater.editable(doc)) {
-    // console.log(`followOrCreateLink:  Can't modify ${doc} so can't make new link to ${object}.`)
-    // console.log('followOrCreateLink @@ connectedStatements', store.connectedStatements(subject))
     return null
   }
   try {
@@ -95,58 +73,48 @@ export async function followOrCreateLink (store: LiveStore, subject: NamedNode,
     return null
   }
 
-  // console.log(`Success making link in ${doc} to ${object}` )
-
   try {
     await loadOrCreateIfNotExists(store, object)
     // store.fetcher.webOperation('PUT', object, { data: '', contentType: 'text/turtle'})
   } catch (err) {
     console.warn(`followOrCreateLink: Error loading or saving new linked document: ${object}: ${err}`)
   }
-  // console.log(`followOrCreateLink: Success loading or saving new linked document: ${object}.`)
   return object
 }
 
 export async function loadProfile (store: LiveStore, user: NamedNode) {
-  // console.log(' @@  loadProfile: user', user)
   if (!user) {
     throw new Error(`loadProfile: no user given.`)
   }
-  // try {
+  try {
     await store.fetcher.load(user.doc())
-  // } catch (err) {
-  //  throw new Error(`Unable to load profile of user ${user}: ${err}`)
-  //}
+  } catch (err) {
+    throw new Error(`Unable to load profile of user ${user}: ${err}`)
+  }
   return user.doc()
 }
 
 export async function loadPreferences (store: LiveStore, user: NamedNode): Promise <NamedNode | undefined > {
-  // console.log('loadPreferences @@ user', user)
   await loadProfile(store as LiveStore, user)
 
   const possiblePreferencesFile = suggestPreferencesFile(user)
 
   const preferencesFile = await followOrCreateLink(store, user,  ns.space('preferencesFile') as NamedNode, possiblePreferencesFile, user.doc())
-  // const preferencesFile = store.any(user, ns.space('preferencesFile'), undefined, profile)
 
-  // console.log('loadPreferences @@ pref file', preferencesFile)
   if (!preferencesFile) {
     const message = `User ${user} has no pointer in profile to preferences file.`
     console.warn(message)
-    // throw new Error()
     return undefined
   }
   try {
     await store.fetcher.load(preferencesFile as NamedNode)
-  } catch (err) { // Mabeb a permission propblem or origin problem
+  } catch (err) { // Maybe a permission propblem or origin problem
     return undefined
-    // throw new Error(`Unable to load preferences file ${preferencesFile} of user <${user}>: ${err}`)
   }
   return preferencesFile as NamedNode
 }
 
 export async function loadTypeIndexesFor (store: LiveStore, user:NamedNode): Promise<Array<TypeIndexScope>> {
-  // console.log('@@ loadTypeIndexesFor user', user)
   if (!user) throw new Error(`loadTypeIndexesFor: No user given`)
   const profile = await loadProfile(store, user)
 
@@ -154,9 +122,6 @@ export async function loadTypeIndexesFor (store: LiveStore, user:NamedNode): Pro
 
   const publicTypeIndex = await followOrCreateLink(store, user, ns.solid('publicTypeIndex') as NamedNode, suggestion, profile)
 
-  // const publicTypeIndex = store.any(user, ns.solid('publicTypeIndex'), undefined, profile)
-  // console.log('@@ loadTypeIndexesFor publicTypeIndex', publicTypeIndex)
-
   const  publicScopes = publicTypeIndex ? [ { label: 'public', index: publicTypeIndex as NamedNode, agent: user } ] : []
 
   let preferencesFile
@@ -174,7 +139,7 @@ export async function loadTypeIndexesFor (store: LiveStore, user:NamedNode): Pro
 
     const privateTypeIndex = store.any(user, ns.solid('privateTypeIndex'), undefined, profile) ||
 
-        await followOrCreateLink(store, user, ns.solid('privateTypeIndex') as NamedNode, suggestedPrivateTypeIndex, preferencesFile);
+    await followOrCreateLink(store, user, ns.solid('privateTypeIndex') as NamedNode, suggestedPrivateTypeIndex, preferencesFile);
 
     privateScopes = privateTypeIndex ? [ { label: 'private', index: privateTypeIndex as NamedNode, agent: user } ] : []
   } else {
@@ -183,7 +148,6 @@ export async function loadTypeIndexesFor (store: LiveStore, user:NamedNode): Pro
   const scopes =  publicScopes.concat(privateScopes)
   if (scopes.length === 0) return scopes
   const files = scopes.map(scope => scope.index)
-  // console.log('@@ loadTypeIndexesFor files ', files)
   try {
     await store.fetcher.load(files)
   } catch (err) {
@@ -195,14 +159,13 @@ export async function loadTypeIndexesFor (store: LiveStore, user:NamedNode): Pro
 export async function loadCommunityTypeIndexes (store:LiveStore, user:NamedNode): Promise<TypeIndexScope[][]> {
   const preferencesFile = await loadPreferences(store, user)
   if (preferencesFile) { // For now, pick up communities as simple links from the preferences file.
-    const communities = store.each(user, ns.solid('community'), undefined, preferencesFile as NamedNode)
-    // console.log('loadCommunityTypeIndexes communities: ',communities)
+    const communities = store.each(user, ns.solid('community'), undefined, preferencesFile as NamedNode).concat(
+       store.each(user, ns.solid('community'), undefined, user.doc() as NamedNode)
+    )
     let result = []
     for (const org of communities) {
       result = result.concat(await loadTypeIndexesFor(store, org as NamedNode) as any)
     }
-    // const communityTypeIndexesPromises = communities.map(async community => await loadTypeIndexesFor(store, community as NamedNode))
-    // const result1 = Promise.all(communityTypeIndexesPromises)
     return result
   }
   return [] // No communities
@@ -213,7 +176,6 @@ export async function loadAllTypeIndexes (store:LiveStore, user:NamedNode) {
 }
 
 // Utility: remove duplicates from Array of NamedNodes
-
 export function uniqueNodes (arr: NamedNode[]): NamedNode[] {
   const uris = arr.map(x => x.uri)
   const set = new Set(uris)
@@ -222,45 +184,32 @@ export function uniqueNodes (arr: NamedNode[]): NamedNode[] {
   return arr2 // Array.from(new Set(arr.map(x => x.uri))).map(u => sym(u))
 }
 
-export async function getScopedAppsFromIndex (store, scope, theClass: NamedNode) {
-  // console.log(`getScopedAppsFromIndex agent ${scope.agent} index: ${scope.index}` )
+export async function getScopedAppsFromIndex (store, scope, theClass: NamedNode | null) {
   const index = scope.index
-  const registrations = store.each(undefined, ns.solid('forClass'), theClass, index)
-  // console.log('    registrations', registrations )
-
-  const directInstances = registrations.map(reg => store.each(reg as NamedNode, ns.solid('instance'), null, index)).flat()
-  // console.log('    directInstances', directInstances )
+  const registrations = store.statementsMatching(null, ns.solid('instance'), null, index)
+    .concat(store.statementsMatching(null, ns.solid('instanceContainer'), null, index))
+    .map(st => st.subject)
+  const relevant = theClass ? registrations.filter(reg => store.any(reg, ns.solid('forClass'), null, index).sameTerm(theClass))
+                            : registrations
+  const directInstances = relevant.map(reg => store.each(reg as NamedNode, ns.solid('instance'), null, index)).flat()
   let instances = uniqueNodes(directInstances)
 
-/*
-  let instanceContainers = []
-  for (const reg of registrations) {
-    const cont = store.any(reg as NamedNode, ns.solid('instanceContainer'), null, index)
-    if (cont) {
-      // console.log('   @@ getScopedAppsFromIndex got one: ', cont)
-      instanceContainers.push(cont)
-    }
-  }
-  */
- const instanceContainers = registrations.map(
+ const instanceContainers = relevant.map(
      reg => store.each(reg as NamedNode, ns.solid('instanceContainer'), null, index)).flat()
 
   //  instanceContainers may be deprocatable if no one has used them
-
   const containers = uniqueNodes(instanceContainers)
+  if (containers.length > 0) { console.log('@@ getScopedAppsFromIndex containers ', containers)}
   for (let i = 0; i < containers.length; i++) {
     const cont = containers[i]
     await store.fetcher.load(cont)
     const contents = store.each(cont, ns.ldp('contains'), null, cont)
-    // if (contents.length) console.log('getScopedAppsFromIndex @@ instanceContainer contents:', contents)
     instances = instances.concat(contents)
   }
   return instances.map(instance => { return {instance, scope}})
 }
 
-
 export async function getScopedAppInstances (store:LiveStore, klass: NamedNode, user: NamedNode):Promise<ScopedApp[]> {
-  // console.log('getScopedAppInstances @@ ' + user)
   const scopes = await loadAllTypeIndexes(store, user)
   let scopedApps = []
   for (const scope of scopes) {
@@ -269,16 +218,18 @@ export async function getScopedAppInstances (store:LiveStore, klass: NamedNode,
   }
   return scopedApps
 }
+
 // This is the function signature which used to be in solid-ui/logic
 // Recommended to use getScopedAppInstances instead as it provides more information.
 //
 export async function getAppInstances (store:LiveStore, klass: NamedNode): Promise<NamedNode[]> {
-  const user = currentUser()
+  const user = authn.currentUser()
   if (!user) throw new Error('getAppInstances: Must be logged in to find apps.')
   const scopedAppInstances = await getScopedAppInstances(store, klass, user)
   return scopedAppInstances.map(scoped => scoped.instance)
 }
-/**
+
+/*
  * Register a new app in a type index
  * used in chat in bookmark.js (solid-ui)
  * Returns the registration object if successful else null
@@ -298,7 +249,6 @@ export async function registerInstanceInTypeIndex (
         st(registration, ns.solid('instance'), instance, index)
     ]
     try {
-      console.log('patching index', ins)
         await store.updater.update([], ins)
     } catch (err) {
         const msg = `Unable to register ${instance} in index ${index}: ${err}`
@@ -307,4 +257,11 @@ export async function registerInstanceInTypeIndex (
     }
     return registration
 }
+
+export async function deleteTypeIndexRegistration (store: LiveStore, item) {
+  const reg = store.the(null, ns.solid('instance'), item.instance, item.scope.index) as NamedNode
+  if (!reg) throw new Error(`deleteTypeIndexRegistration: No registration found for ${item.instance}`)
+  const statements = store.statementsMatching(reg, null, null, item.scope.index)
+  await store.updater.update(statements, [])
+}
 // ENDS

package/src/inbox/inboxLogic.ts

@@ -0,0 +1,57 @@
+import { NamedNode } from "rdflib";
+import { getArchiveUrl } from "../util/utils";
+
+export function createInboxLogic(store, profileLogic, utilityLogic, containerLogic, aclLogic) {
+  
+    async function createInboxFor(peerWebId: string, nick: string) {
+      const myWebId: NamedNode = await profileLogic.loadMe();
+      const podRoot: NamedNode = await profileLogic.getPodRoot(myWebId);
+      const ourInbox = `${podRoot.value}p2p-inboxes/${encodeURIComponent(nick)}/`;
+      await containerLogic.createContainer(ourInbox);
+      const aclDocUrl = await aclLogic.findAclDocUrl(ourInbox);
+      await utilityLogic.setSinglePeerAccess({
+        ownerWebId: myWebId.value,
+        peerWebId,
+        accessToModes: 'acl:Append',
+        target: ourInbox
+      });
+      return ourInbox;
+  }
+
+  async function getNewMessages(
+      user?: NamedNode
+    ): Promise<string[]> {
+      if (!user) {
+        user = await profileLogic.loadMe();
+      }
+      const inbox = await profileLogic.getMainInbox(user);
+      const urls = await containerLogic.getContainerMembers(inbox.value);
+      return urls.filter(url => !containerLogic.isContainer(url));
+  }
+
+  async function markAsRead(url: string, date: Date) {
+    const downloaded = await store.fetcher._fetch(url);
+    if (downloaded.status !== 200) {
+      throw new Error(`Not OK! ${url}`);
+    }
+    const archiveUrl = getArchiveUrl(url, date);
+    const options = {
+      method: 'PUT',
+      body: await downloaded.text(),
+      headers: [
+        ['Content-Type', downloaded.headers.get('Content-Type') || 'application/octet-stream']
+      ]
+    };
+    const uploaded = await store.fetcher._fetch(archiveUrl, options);
+    if (uploaded.status.toString()[0] === '2') {
+      await store.fetcher._fetch(url, {
+        method: 'DELETE'
+      });
+    }
+  }
+  return {
+    createInboxFor,
+    getNewMessages,
+    markAsRead
+  }
+}

package/src/index.ts

@@ -1,51 +1,92 @@
 // Make these variables directly accessible as it is what you need most of the time
 // This also makes these variable globaly accesible in mashlib
-import { solidLogicSingleton } from './logic/solidLogicSingleton'
-const authn = solidLogicSingleton.authn
-const authSession = solidLogicSingleton.authn.authSession
-const store = solidLogicSingleton.store
+//import { solidLogicSingleton } from './logic/solidLogicSingleton'
+//const authn = solidLogicSingleton.authn
+//const authSession = solidLogicSingleton.authn.authSession
+//const store = solidLogicSingleton.store
 
-const chat = solidLogicSingleton.chat
-const profile = solidLogicSingleton.profile
+export {
+  ACL_LINK
+} from './acl/aclLogic'
 
 export {
+  findAclDocUrl,
   setACLUserPublic,
-  genACLText
-} from './acl/aclLogic'
+  genACLText,
+} from './logic/solidLogicSingleton'
 
 export {
   ensureTypeIndexes,
   loadTypeIndexes,
   registerInTypeIndex,
-  loadIndex
-} from './typeIndex/typeIndexLogic'
+  loadIndex,
+  ensureOneTypeIndex,
+  putIndex,
+  makeIndexIfNecessary,
+  loadIndexes,
+  getTypeIndex,
+  getRegistrations,
+  //NEW function for discovery
+  loadTypeIndexesFor,
+  loadCommunityTypeIndexes,
+  loadAllTypeIndexes,
+  getScopedAppInstances,
+  getAppInstances,
+  suggestPublicTypeIndex,
+  suggestPrivateTypeIndex,
+  registerInstanceInTypeIndex,
+  deleteTypeIndexRegistration,
+  getScopedAppsFromIndex
+} from './logic/solidLogicSingleton'
 
-// Generate by
-//  grep export src/discovery/discoveryLogic.ts | sed -e 's/export //g'  | sed -e 's/async //g'| sed -e 's/function //g' | sed -e 's/ .*/,/g' | sort
 export {
+  setAcl,
+  addToPrivateTypeIndex,
+  findChat,
+  createChatThing,
+  getChat,
+  sendInvite,
+  mintNew
+} from './logic/solidLogicSingleton'
+
+export { offlineTestID, appContext } from './authn/authUtil'
+export { createInboxFor, getNewMessages, markAsRead } from './logic/solidLogicSingleton'
+export {
+  recursiveDelete,
+  setSinglePeerAccess,
+  createEmptyRdfDoc,
+  //NEW function for discovery
   followOrCreateLink,
-  getAppInstances,
-  getScopedAppInstances,
-  getScopedAppsFromIndex,
-  loadAllTypeIndexes,
-  loadCommunityTypeIndexes,
   loadOrCreateIfNotExists,
+} from './logic/solidLogicSingleton'
+
+export {
+  ensureLoadedPreferences,
+  loadMe,
+  getPodRoot,
+  getMainInbox,
+  findStorage,
+   //NEW content from discovery
   loadPreferences,
   loadProfile,
-  loadTypeIndexesFor,
-  registerInstanceInTypeIndex,
-  suggestPreferencesFile,
-  suggestPrivateTypeIndex,
-  suggestPublicTypeIndex,
-  uniqueNodes
-} from './discovery/discoveryLogic'
+  //NEW function for discovery
+  silencedLoadPreferences
+} from './logic/solidLogicSingleton'
 
-export { SolidLogic } from './logic/SolidLogic'
-export { offlineTestID, appContext } from './authn/authUtil'
-export { ACL_LINK } from './util/UtilityLogic'
 export { getSuggestedIssuers } from './issuer/issuerLogic'
+
+export {
+    isContainer,
+    createContainer,
+    getContainerElements,
+    getContainerMembers
+} from './logic/solidLogicSingleton'
+
+export { authn, authSession, store } from './logic/solidLogicSingleton'
+
+//export { SolidLogic } from './logic/SolidLogic'
 export { AppDetails, SolidNamespace, AuthenticationContext } from './types'
 // solidLogicSingleton is exported entirely because it is used in solid-panes
-export { solidLogicSingleton } from './logic/solidLogicSingleton'
-export { UnauthorizedError, CrossOriginForbiddenError, SameOriginForbiddenError, NotFoundError, FetchError } from './logic/CustomError'
-export { authn, authSession, store, chat, profile }
+//export { solidLogicSingleton } from './logic/solidLogicSingleton'
+export { UnauthorizedError, CrossOriginForbiddenError, SameOriginForbiddenError, NotFoundError, FetchError, NotEditableError, WebOperationError } from './logic/CustomError'
+

package/src/logic/CustomError.ts

@@ -6,7 +6,7 @@ class CustomError extends Error {
         this.name = new.target.name; // stack traces display correctly now
     }
 }
-    
+
 export class UnauthorizedError extends CustomError {}
 
 export class CrossOriginForbiddenError extends CustomError {}
@@ -15,6 +15,10 @@ export class SameOriginForbiddenError extends CustomError {}
 
 export class NotFoundError extends CustomError {}
 
+export class NotEditableError extends CustomError { }
+
+export class WebOperationError extends CustomError {}
+
 export class FetchError extends CustomError {
     status: number;
 

package/src/logic/solidLogicSingleton.ts

@@ -1,20 +1,173 @@
-import * as debug from "../util/debug"
+import * as rdf from "rdflib"
+import { SolidAuthnLogic } from "../authn/SolidAuthnLogic"
 import { authSession } from "../authSession/authSession"
-import { SolidLogic } from "./SolidLogic"
+import { createContainerLogic } from "../util/containerLogic"
+import { createTypeIndexLogic } from "../typeIndex/typeIndexLogic"
+import * as debug from "../util/debug"
+import { createUtilityLogic } from "../util/utilityLogic"
+import { createProfileLogic } from "../profile/profileLogic"
+import { createInboxLogic } from "../inbox/inboxLogic"
+import { createChatLogic } from "../chat/chatLogic"
+import { createAclLogic } from "../acl/aclLogic"
 
 const _fetch = async (url, requestInit) => {
     const omitCreds = requestInit && requestInit.credentials && requestInit.credentials == 'omit'
     if (authSession.info.webId && !omitCreds) { // see https://github.com/solidos/solidos/issues/114
-        // In fact ftech should respect crentials omit itself
+        // In fact fetch should respect credentials omit itself
         return authSession.fetch(url, requestInit)
     } else {
         return window.fetch(url, requestInit)
     }
 }
 
-//this const makes solidLogicSingleton global accessible in mashlib
-const solidLogicSingleton = new SolidLogic({ fetch: _fetch }, authSession)
+debug.log("SolidLogicSingleton: Unique instance created.  There should only be one of these.")
+
+const store = rdf.graph() as rdf.LiveStore; // Make a Quad store
+rdf.fetcher(store, { fetch: _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
+
+debug.log('SolidAuthnLogic initialized')
+const authn = new SolidAuthnLogic(authSession)
+
+const aclLogic = createAclLogic(store)
+const {
+    findAclDocUrl,
+    setACLUserPublic,
+    genACLText
+} = aclLogic
+
+const containerLogic = createContainerLogic(store)
+const {
+    isContainer,
+    createContainer,
+    getContainerElements,
+    getContainerMembers
+} = containerLogic
 
-debug.log('Unique quadstore initialized.')
+const utilityLogic = createUtilityLogic(store, aclLogic, containerLogic)
+const {
+    recursiveDelete,
+    setSinglePeerAccess,
+    createEmptyRdfDoc,
+    followOrCreateLink,
+    loadOrCreateIfNotExists
+} = utilityLogic
+
+const profileLogic = createProfileLogic(store, authn, utilityLogic)
+const {
+    ensureLoadedPreferences,
+    loadMe,
+    getPodRoot,
+    getMainInbox,
+    findStorage,
+    loadPreferences,
+    loadProfile,
+    silencedLoadPreferences
+} = profileLogic
+
+const chatLogic = createChatLogic(store, profileLogic)
+const {
+    setAcl,
+    addToPrivateTypeIndex,
+    findChat,
+    createChatThing,
+    getChat,
+    sendInvite,
+    mintNew
+} = chatLogic
+
+const inboxLogic  = createInboxLogic(store, profileLogic, utilityLogic, containerLogic, aclLogic)
+const {
+    createInboxFor,
+    getNewMessages,
+    markAsRead
+} = inboxLogic
+
+const typeIndexLogic = createTypeIndexLogic(store, authn, profileLogic, utilityLogic)
+const {
+    ensureTypeIndexes,
+    loadTypeIndexes,
+    registerInTypeIndex,
+    loadIndex,
+    ensureOneTypeIndex,
+    putIndex,
+    makeIndexIfNecessary,
+    loadIndexes,
+    getTypeIndex,
+    getRegistrations,
+    loadTypeIndexesFor,
+    loadCommunityTypeIndexes,
+    loadAllTypeIndexes,
+    getScopedAppInstances,
+    getAppInstances,
+    suggestPublicTypeIndex,
+    suggestPrivateTypeIndex,
+    registerInstanceInTypeIndex,
+    deleteTypeIndexRegistration,
+    getScopedAppsFromIndex
+} = typeIndexLogic
+
+export {
+    store,
+    authn,
+    authSession,
+    //unilityLogic
+    recursiveDelete,
+    setSinglePeerAccess,
+    createEmptyRdfDoc,
+    followOrCreateLink,
+    loadOrCreateIfNotExists,
+    //containerLogic
+    isContainer,
+    createContainer,
+    getContainerElements,
+    getContainerMembers,
+    //typeIndexLogic
+    ensureTypeIndexes,
+    loadTypeIndexes,
+    registerInTypeIndex,
+    loadIndex,
+    ensureOneTypeIndex,
+    putIndex,
+    makeIndexIfNecessary,
+    loadIndexes,
+    getTypeIndex,
+    getRegistrations,
+    loadTypeIndexesFor,
+    loadCommunityTypeIndexes,
+    loadAllTypeIndexes,
+    getScopedAppInstances,
+    getAppInstances,
+    suggestPublicTypeIndex,
+    suggestPrivateTypeIndex,
+    registerInstanceInTypeIndex,
+    deleteTypeIndexRegistration,
+    getScopedAppsFromIndex,
+    //profileLogic
+    ensureLoadedPreferences,
+    loadMe,
+    getPodRoot,
+    getMainInbox,
+    findStorage,
+    loadPreferences,
+    loadProfile,
+    silencedLoadPreferences,
+    //inboxLogic
+    createInboxFor,
+    getNewMessages,
+    markAsRead,
+    //chatLogic
+    setAcl,
+    addToPrivateTypeIndex,
+    findChat,
+    createChatThing,
+    getChat,
+    sendInvite,
+    mintNew,
+    //aclLogic
+    findAclDocUrl,
+    setACLUserPublic,
+    genACLText
+}
 
-export { solidLogicSingleton }