solid-logic 1.3.17-f7bdc345 → 2.0.0-30dbc72f

package/src/chat/ChatLogic.ts

@@ -1,244 +0,0 @@
-import { NamedNode, Node, st, term, LiveStore } from "rdflib";
-import { ProfileLogic } from "../profile/ProfileLogic";
-import { SolidNamespace } from "../types";
-import { newThing } from "../util/uri";
-import { determineChatContainer } from "./determineChatContainer";
-
-const CHAT_LOCATION_IN_CONTAINER = "index.ttl#this";
-
-interface NewPaneOptions {
-  me?: NamedNode;
-  newInstance?: NamedNode;
-  newBase: string;
-}
-
-interface CreatedPaneOptions {
-  newInstance: NamedNode;
-}
-
-/**
- * Chat-related logic
- */
-export class ChatLogic {
-  store: LiveStore;
-  ns: SolidNamespace;
-  profile: ProfileLogic;
-
-  constructor(store: LiveStore, ns: SolidNamespace, profile: ProfileLogic) {
-    this.store = store;
-    this.ns = ns;
-    this.profile = profile;
-  }
-
-  async setAcl(
-    chatContainer: NamedNode,
-    me: NamedNode,
-    invitee: NamedNode
-  ): Promise<void> {
-    // Some servers don't present a Link http response header
-    // if the container doesn't exist yet, so refetch the container
-    // now that it has been created:
-    await this.store.fetcher?.load(chatContainer);
-
-    // FIXME: check the Why value on this quad:
-    const chatAclDoc = this.store.any(
-      chatContainer,
-      new NamedNode("http://www.iana.org/assignments/link-relations/acl")
-    );
-    if (!chatAclDoc) {
-      throw new Error("Chat ACL doc not found!");
-    }
-
-    const aclBody = `
-@prefix acl: <http://www.w3.org/ns/auth/acl#>.
-<#owner>
-    a acl:Authorization;
-    acl:agent <${me.value}>;
-    acl:accessTo <.>;
-    acl:default <.>;
-    acl:mode
-        acl:Read, acl:Write, acl:Control.
-<#invitee>
-    a acl:Authorization;
-    acl:agent <${invitee.value}>;
-    acl:accessTo <.>;
-    acl:default <.>;
-    acl:mode
-        acl:Read, acl:Append.
-`;
-    await this.store.fetcher?.webOperation("PUT", chatAclDoc.value, {
-      data: aclBody,
-      contentType: "text/turtle",
-    });
-  }
-
-  private async addToPrivateTypeIndex(chatThing, me) {
-    // Add to private type index
-    const privateTypeIndex = this.store.any(
-      me,
-      this.ns.solid("privateTypeIndex")
-    ) as NamedNode | null;
-    if (!privateTypeIndex) {
-      throw new Error("Private type index not found!");
-    }
-    await this.store.fetcher?.load(privateTypeIndex);
-    const reg = newThing(privateTypeIndex);
-    const ins = [
-      st(
-        reg,
-        this.ns.rdf("type"),
-        this.ns.solid("TypeRegistration"),
-        privateTypeIndex.doc()
-      ),
-      st(
-        reg,
-        this.ns.solid("forClass"),
-        this.ns.meeting("LongChat"),
-        privateTypeIndex.doc()
-      ),
-      st(reg, this.ns.solid("instance"), chatThing, privateTypeIndex.doc()),
-    ];
-    await new Promise((resolve, reject) => {
-      this.store.updater?.update([], ins, function (_uri, ok, errm) {
-        if (!ok) {
-          reject(new Error(errm));
-        } else {
-          resolve(null);
-        }
-      });
-    });
-  }
-
-  private async findChat(invitee: NamedNode) {
-    const me = await this.profile.loadMe();
-    const podRoot = await this.profile.getPodRoot(me);
-    const chatContainer = determineChatContainer(invitee, podRoot);
-    let exists = true;
-    try {
-      await this.store.fetcher?.load(
-        new NamedNode(chatContainer.value + "index.ttl#this")
-      );
-    } catch (e) {
-      exists = false;
-    }
-    return { me, chatContainer, exists };
-  }
-
-  private async createChatThing(
-    chatContainer: NamedNode,
-    me: NamedNode
-  ): Promise<NamedNode> {
-    const created = await this.mintNew({
-      me,
-      newBase: chatContainer.value,
-    });
-    return created.newInstance;
-  }
-
-  private mintNew(newPaneOptions: NewPaneOptions): Promise<CreatedPaneOptions> {
-    const kb = this.store;
-    const updater = kb.updater;
-    if (newPaneOptions.me && !newPaneOptions.me.uri) {
-      throw new Error("chat mintNew:  Invalid userid " + newPaneOptions.me);
-    }
-
-    const newInstance = (newPaneOptions.newInstance =
-      newPaneOptions.newInstance ||
-      kb.sym(newPaneOptions.newBase + CHAT_LOCATION_IN_CONTAINER));
-    const newChatDoc = newInstance.doc();
-
-    kb.add(
-      newInstance,
-      this.ns.rdf("type"),
-      this.ns.meeting("LongChat"),
-      newChatDoc
-    );
-    kb.add(newInstance, this.ns.dc("title"), "Chat channel", newChatDoc);
-    kb.add(
-      newInstance,
-      this.ns.dc("created"),
-      term<Node>(new Date(Date.now())),
-      newChatDoc
-    );
-    if (newPaneOptions.me) {
-      kb.add(newInstance, this.ns.dc("author"), newPaneOptions.me, newChatDoc);
-    }
-
-    return new Promise(function (resolve, reject) {
-      updater?.put(
-        newChatDoc,
-        kb.statementsMatching(undefined, undefined, undefined, newChatDoc),
-        "text/turtle",
-        function (uri2, ok, message) {
-          if (ok) {
-            resolve({
-              ...newPaneOptions,
-              newInstance,
-            });
-          } else {
-            reject(
-              new Error(
-                "FAILED to save new chat channel at: " + uri2 + " : " + message
-              )
-            );
-          }
-        }
-      );
-    });
-  }
-
-  /**
-   * Find (and optionally create) an individual chat between the current user and the given invitee
-   * @param invitee - The person to chat with
-   * @param createIfMissing - Whether the chat should be created, if missing
-   * @returns null if missing, or a node referring to an already existing chat, or the newly created chat
-   */
-  async getChat(
-    invitee: NamedNode,
-    createIfMissing = true
-  ): Promise<NamedNode | null> {
-    const { me, chatContainer, exists } = await this.findChat(invitee);
-    if (exists) {
-      return new NamedNode(chatContainer.value + CHAT_LOCATION_IN_CONTAINER);
-    }
-
-    if (createIfMissing) {
-      const chatThing = await this.createChatThing(chatContainer, me);
-      await this.sendInvite(invitee, chatThing);
-      await this.setAcl(chatContainer, me, invitee);
-      await this.addToPrivateTypeIndex(chatThing, me);
-      return chatThing;
-    }
-    return null;
-  }
-
-  private async sendInvite(invitee: NamedNode, chatThing: NamedNode) {
-    await this.store.fetcher?.load(invitee.doc());
-    const inviteeInbox = this.store.any(
-      invitee,
-      this.ns.ldp("inbox"),
-      undefined,
-      invitee.doc()
-    );
-    if (!inviteeInbox) {
-      throw new Error(`Invitee inbox not found! ${invitee.value}`);
-    }
-    const inviteBody = `
-<> a <http://www.w3.org/ns/pim/meeting#LongChatInvite> ;
-${this.ns.rdf("seeAlso")} <${chatThing.value}> .
-  `;
-
-    const inviteResponse = await this.store.fetcher?.webOperation(
-      "POST",
-      inviteeInbox.value,
-      {
-        data: inviteBody,
-        contentType: "text/turtle",
-      }
-    );
-    const locationStr = inviteResponse?.headers.get("location");
-    if (!locationStr) {
-      throw new Error(`Invite sending returned a ${inviteResponse?.status}`);
-    }
-  }
-}

package/src/chat/determineChatContainer.ts

@@ -1,14 +0,0 @@
-import { NamedNode } from "rdflib";
-
-export function determineChatContainer(
-  invitee: NamedNode,
-  podRoot: NamedNode
-): NamedNode {
-  // Create chat
-  // See https://gitter.im/solid/chat-app?at=5f3c800f855be416a23ae74a
-  const chatContainerStr = new URL(
-    `IndividualChats/${new URL(invitee.value).host}/`,
-    podRoot.value
-  ).toString();
-  return new NamedNode(chatContainerStr);
-}

package/src/discovery/discoveryLogic.ts

@@ -1,269 +0,0 @@
-import { NamedNode, LiveStore, sym, st } from 'rdflib'
-import * as $rdf from 'rdflib'
-import { solidLogicSingleton } from "../logic/solidLogicSingleton"
-import { newThing } from "../util/uri"
-import solidNamespace from 'solid-namespace'
-
-const { authn } = solidLogicSingleton
-const { currentUser } = authn
-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
- * as otherwise existing could  be deleted.
- * @param doc {NamedNode} - The resource
- */
-export async function loadOrCreateIfNotExists (store: LiveStore, doc: NamedNode) {
-    let response
-    try {
-      response = await store.fetcher.load(doc)
-    } catch (err) {
-        if (err.response.status === 404) {
-          try {
-            store.fetcher.webOperation('PUT', doc, {data: '', contentType: 'text/turtle'})
-          } catch (err) {
-            const msg = 'createIfNotExists: PUT FAILED: ' + doc + ': ' + err
-            throw new Error(msg)
-          }
-          delete store.fetcher.requested[doc.uri] // delete cached 404 error
-        } else {
-          const msg =  'createIfNotExists doc load error NOT 404:  ' + doc + ': ' + err
-          throw new Error(msg) // @@ add nested errors
-        }
-    }
-    return response
-}
-
-export function suggestPreferencesFile (me:NamedNode) {
-  const stripped = me.uri.replace('/profile/', '/').replace('/public/', '/')
-  // const stripped = me.uri.replace(\/[p|P]rofile/\g, '/').replace(\/[p|P]ublic/\g, '/')
-  const folderURI = stripped.split('/').slice(0,-1).join('/') + '/Settings/'
-  const fileURI = folderURI + 'Preferences.ttl'
-  return sym(fileURI)
-}
-
-export function suggestPublicTypeIndex (me:NamedNode) {
-  return sym(me.doc().dir()?.uri + 'publicTypeIndex.ttl')
-}
-// Note this one is based off the pref file not the profile
-
-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
-*/
-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)
-
-  if (result) return result as NamedNode
-  if (!store.updater.editable(doc)) {
-    return null
-  }
-  try {
-    await store.updater.update([], [ st(subject, predicate, object, doc)])
-  } catch (err) {
-    console.warn(`followOrCreateLink: Error making link in ${doc} to ${object}: ${err}`)
-    return null
-  }
-
-  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}`)
-  }
-  return object
-}
-
-export async function loadProfile (store: LiveStore, user: NamedNode) {
-  if (!user) {
-    throw new Error(`loadProfile: no user given.`)
-  }
-  try {
-    await store.fetcher.load(user.doc())
-  } 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 > {
-  await loadProfile(store as LiveStore, user)
-
-  const possiblePreferencesFile = suggestPreferencesFile(user)
-
-  const preferencesFile = await followOrCreateLink(store, user,  ns.space('preferencesFile') as NamedNode, possiblePreferencesFile, user.doc())
-
-  if (!preferencesFile) {
-    const message = `User ${user} has no pointer in profile to preferences file.`
-    console.warn(message)
-    return undefined
-  }
-  try {
-    await store.fetcher.load(preferencesFile as NamedNode)
-  } catch (err) { // Maybe a permission propblem or origin problem
-    return undefined
-  }
-  return preferencesFile as NamedNode
-}
-
-export async function loadTypeIndexesFor (store: LiveStore, user:NamedNode): Promise<Array<TypeIndexScope>> {
-  if (!user) throw new Error(`loadTypeIndexesFor: No user given`)
-  const profile = await loadProfile(store, user)
-
-  const suggestion = suggestPublicTypeIndex(user)
-
-  const publicTypeIndex = await followOrCreateLink(store, user, ns.solid('publicTypeIndex') as NamedNode, suggestion, profile)
-
-  const  publicScopes = publicTypeIndex ? [ { label: 'public', index: publicTypeIndex as NamedNode, agent: user } ] : []
-
-  let preferencesFile
-  try {
-    preferencesFile = await loadPreferences(store, user)
-  } catch (err) {
-    preferencesFile = null
-  }
-
-  let privateScopes
-  if (preferencesFile) { // watch out - can be in either as spec was not clear.  Legacy is profile.
-    // If there is a legacy one linked from the profile, use that.
-    // Otherwiae use or make one linked from Preferences
-    const suggestedPrivateTypeIndex = suggestPrivateTypeIndex(preferencesFile)
-
-    const privateTypeIndex = store.any(user, ns.solid('privateTypeIndex'), undefined, profile) ||
-
-    await followOrCreateLink(store, user, ns.solid('privateTypeIndex') as NamedNode, suggestedPrivateTypeIndex, preferencesFile);
-
-    privateScopes = privateTypeIndex ? [ { label: 'private', index: privateTypeIndex as NamedNode, agent: user } ] : []
-  } else {
-    privateScopes = []
-  }
-  const scopes =  publicScopes.concat(privateScopes)
-  if (scopes.length === 0) return scopes
-  const files = scopes.map(scope => scope.index)
-  try {
-    await store.fetcher.load(files)
-  } catch (err) {
-    console.warn('Problems loading type index: ', err)
-  }
-  return scopes
-}
-
-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).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)
-    }
-    return result
-  }
-  return [] // No communities
-}
-
-export async function loadAllTypeIndexes (store:LiveStore, user:NamedNode) {
-  return (await loadTypeIndexesFor(store, user)).concat((await loadCommunityTypeIndexes(store, user)).flat())
-}
-
-// 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)
-  const uris2 = Array.from(set)
-  const arr2 = uris2.map(u => new NamedNode(u))
-  return arr2 // Array.from(new Set(arr.map(x => x.uri))).map(u => sym(u))
-}
-
-export async function getScopedAppsFromIndex (store, scope, theClass: NamedNode | null) {
-  const index = scope.index
-  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)
-
- 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)
-    instances = instances.concat(contents)
-  }
-  return instances.map(instance => { return {instance, scope}})
-}
-
-export async function getScopedAppInstances (store:LiveStore, klass: NamedNode, user: NamedNode):Promise<ScopedApp[]> {
-  const scopes = await loadAllTypeIndexes(store, user)
-  let scopedApps = []
-  for (const scope of scopes) {
-    const scopedApps0 = await getScopedAppsFromIndex(store, scope, klass) as any
-    scopedApps = scopedApps.concat(scopedApps0)
-  }
-  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()
-  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
- */
-export async function registerInstanceInTypeIndex (
-  store:LiveStore,
-  instance: NamedNode,
-  index: NamedNode,
-  theClass: NamedNode,
-  // agent: NamedNode
-): Promise<NamedNode | null> {
-    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 store.updater.update([], ins)
-    } catch (err) {
-        const msg = `Unable to register ${instance} in index ${index}: ${err}`
-        console.warn(msg)
-        return null
-    }
-    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

@@ -1,66 +0,0 @@
-import { NamedNode, LiveStore } from "rdflib";
-import { ProfileLogic } from "../profile/ProfileLogic";
-import { SolidNamespace } from "../types";
-import { UtilityLogic } from "../util/UtilityLogic";
-
-/**
- * Inbox-related logic
- */
-export class InboxLogic {
-  store: LiveStore;
-  ns: SolidNamespace;
-  profile: ProfileLogic;
-  util: UtilityLogic;
-
-  constructor(store: LiveStore, ns: SolidNamespace, profile: ProfileLogic, util: UtilityLogic) {
-    this.store = store;
-    this.ns = ns;
-    this.profile = profile;
-    this.util = util;
-  }
-
-  async getNewMessages(
-    user?: NamedNode
-  ): Promise<string[]> {
-    if (!user) {
-      user = await this.profile.loadMe();
-    }
-    const inbox = await this.profile.getMainInbox(user);
-    const urls = await this.util.getContainerMembers(inbox.value);
-    return urls.filter(url => !this.util.isContainer(url));
-  }
-  async createInboxFor(peerWebId: string, nick: string) {
-    const myWebId: NamedNode = (await this.profile.loadMe());
-    const podRoot: NamedNode = await this.profile.getPodRoot(myWebId);
-    const ourInbox = `${podRoot.value}p2p-inboxes/${encodeURIComponent(nick)}/`;
-    await this.util.createContainer(ourInbox);
-    const aclDocUrl = await this.util.findAclDocUrl(ourInbox);
-    await this.util.setSinglePeerAccess({
-      ownerWebId: myWebId.value,
-      peerWebId,
-      accessToModes: 'acl:Append',
-      target: ourInbox
-    });
-    return ourInbox;
-  }
-  async markAsRead(url: string, date: Date) {
-    const downloaded = await this.store.fetcher._fetch(url);
-    if (downloaded.status !== 200) {
-      throw new Error(`Not OK! ${url}`);
-    }
-    const archiveUrl = this.util.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 this.store.fetcher._fetch(archiveUrl, options);
-    if (uploaded.status.toString()[0] === '2') {
-      await this.store.fetcher?._fetch(url, {
-        method: 'DELETE'
-      });
-    }
-  }
-}