solid-logic 1.3.17-2bf19bb6 → 1.3.17-2d62034f

package/src/discovery/discoveryLogic.ts

@@ -1,90 +0,0 @@
-import { NamedNode, Namespace, LiveStore } from "rdflib";
-
-type TypeIndex = {  label: string, index: NamedNode, agent: NamedNode } ;
-
-const ns ={
-  solid: Namespace('http://www.w3.org/ns/solid/terms#'),
-  space: Namespace('http://www.w3.org/ns/pim/space#')
-}
-
-export async function loadProfile(store: LiveStore, user) {
-  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): Promise <NamedNode | undefined > {
-  const profile = await loadProfile(store as LiveStore, user)
-  const preferencesFile = store.any(user, ns.space('preferencesFile'), undefined, profile)
-  if (!preferencesFile) {
-    // throw new Error(`USer ${user} has no pointer in profile to preferences file.`)
-    return undefined
-  }
-  try {
-    store.fetcher.load(preferencesFile as NamedNode)
-  } catch (err) { // Mabeb 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<TypeIndex>> {
-  if (!user) throw new Error(`loadTypeIndexesFor: No user given`)
-  const profile = await loadProfile(store, user)
-  const publicTypeIndex = store.any(user, ns.solid('publicTypeIndex'), undefined, profile)
-  if (publicTypeIndex) {
-    try {
-      await store.fetcher.load(publicTypeIndex as NamedNode)
-    } catch {
-      // never mind
-    }
-  }
-  const  pub = publicTypeIndex ? [ { label: 'public', index: publicTypeIndex as NamedNode, agent: user } ] : []
-
-  const preferencesFile = await loadPreferences(store, user)
-  if (preferencesFile) { // watch out - can be in either as spec was not clear
-    const privateTypeIndexes = store.each(user, ns.solid('privateTypeIndex'), undefined, preferencesFile as NamedNode)
-      .concat(store.each(user, ns.solid('privateTypeIndex'), undefined, profile))
-    const priv = privateTypeIndexes.length > 0 ? [ { label: 'priSo @@@@@vate', index: privateTypeIndexes[0] as NamedNode, agent: user } ] : []
-    return pub.concat(priv)
-  }
-  return pub
-}
-
-export async function loadCommunityTypeIndexes (store:LiveStore, user:NamedNode): Promise<TypeIndex[][]> {
-  const preferencesFile = await loadPreferences(store, user)
-  if (preferencesFile) {
-    const communities = store.each(user, ns.solid('community'), undefined, preferencesFile as NamedNode)
-    const communityTypeIndexesPromise = communities.map(async community => await loadTypeIndexesFor(store, community as NamedNode))
-    const result1 = Promise.all(communityTypeIndexesPromise)
-    // const result2 = Promise.all(result1)
-    // const flat = result2.flat()
-    return result1
-    // const communityTypeIndexes = await Promise.all(communityTypeIndexesPromise)
-      /*
-    let result = [] as TypeIndex[]
-    for(const community of communities) {
-      result = result.concat(await loadTypeIndexesFor(store, community as NamedNode)) as TypeIndex[] // @@ how oto make functional with async?
-    }
-    */
-    // return communityTypeIndexesPromise.resolve()
-  }
-  return []
-}
-
-export async function loadAllTypeIndexes (store:LiveStore, user:NamedNode) {
-  return (await loadTypeIndexesFor(store, user)).concat((await loadCommunityTypeIndexes(store, user)).flat())
-}
-
-/*
-export async function getAppInstances (store:LiveStore, klass: NamedNode) {
-
-}
-*/

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.util.underlyingFetch.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.util.underlyingFetch.fetch(archiveUrl, options);
-    if (uploaded.status.toString()[0] === '2') {
-      await this.store.fetcher?._fetch(url, {
-        method: 'DELETE'
-      });
-    }
-  }
-}

package/src/profile/ProfileLogic.ts

@@ -1,44 +0,0 @@
-import { NamedNode, LiveStore } from "rdflib";
-import { AuthnLogic, SolidNamespace } from "../types";
-
-export class ProfileLogic {
-  store: LiveStore;
-  ns: SolidNamespace;
-  authn: AuthnLogic;
-
-  constructor(store: LiveStore, ns: SolidNamespace, authn: AuthnLogic) {
-    this.store = store;
-    this.ns = ns;
-    this.authn = authn;
-  }
-
-  async loadMe(): Promise<NamedNode> {
-    const me = this.authn.currentUser();
-    if (me === null) {
-      throw new Error("Current user not found! Not logged in?");
-    }
-    await this.store.fetcher?.load(me.doc());
-    return me;
-  }
-
-  getPodRoot(user: NamedNode): NamedNode {
-    const podRoot = this.findStorage(user);
-    if (!podRoot) {
-      throw new Error("User pod root not found!");
-    }
-    return podRoot as NamedNode;
-  }
-
-  async getMainInbox(user: NamedNode): Promise<NamedNode> {
-    await this.store.fetcher?.load(user);
-    const mainInbox = this.store.any(user, this.ns.ldp("inbox"), undefined, user.doc());
-    if (!mainInbox) {
-      throw new Error("User main inbox not found!");
-    }
-    return mainInbox as NamedNode;
-  }
-
-  private findStorage(me: NamedNode) {
-    return this.store.any(me, this.ns.space("storage"), undefined, me.doc());
-  }
-}

package/src/util/UtilityLogic.ts

@@ -1,161 +0,0 @@
-import { NamedNode, Statement, sym, LiveStore } from "rdflib";
-import { SolidNamespace } from "../types";
-
-export const ACL_LINK = sym(
-  "http://www.iana.org/assignments/link-relations/acl"
-);
-
-/**
- * Utility-related logic
- */
-export class UtilityLogic {
-  store: LiveStore;
-  ns: SolidNamespace;
-  underlyingFetch: { fetch: (url: string, options?: any) => any };
-
-  constructor(store: LiveStore, ns: SolidNamespace, underlyingFetch: { fetch: (url: string, options?: any) => any }) {
-    this.store = store;
-    this.ns = ns;
-    this.underlyingFetch = underlyingFetch;
-  }
-
-  async findAclDocUrl(url: string) {
-    const doc = this.store.sym(url);
-    await this.store.fetcher?.load(doc);
-    const docNode = this.store.any(doc, ACL_LINK);
-    if (!docNode) {
-      throw new Error(`No ACL link discovered for ${url}`);
-    }
-    return docNode.value;
-  }
-
-  // Copied from https://github.com/solidos/web-access-control-tests/blob/v3.0.0/test/surface/delete.test.ts#L5
-  async setSinglePeerAccess(options: {
-    ownerWebId: string,
-    peerWebId: string,
-    accessToModes?: string,
-    defaultModes?: string,
-    target: string
-  }) {
-    let str = [
-      '@prefix acl: <http://www.w3.org/ns/auth/acl#>.',
-      '',
-      `<#alice> a acl:Authorization;\n  acl:agent <${options.ownerWebId}>;`,
-      `  acl:accessTo <${options.target}>;`,
-      `  acl:default <${options.target}>;`,
-      '  acl:mode acl:Read, acl:Write, acl:Control.',
-      ''
-    ].join('\n')
-    if (options.accessToModes) {
-      str += [
-        '<#bobAccessTo> a acl:Authorization;',
-        `  acl:agent <${options.peerWebId}>;`,
-        `  acl:accessTo <${options.target}>;`,
-        `  acl:mode ${options.accessToModes}.`,
-        ''
-      ].join('\n')
-    }
-    if (options.defaultModes) {
-      str += [
-        '<#bobDefault> a acl:Authorization;',
-        `  acl:agent <${options.peerWebId}>;`,
-        `  acl:default <${options.target}>;`,
-        `  acl:mode ${options.defaultModes}.`,
-        ''
-      ].join('\n')
-    }
-    const aclDocUrl = await this.findAclDocUrl(options.target);
-    return this.underlyingFetch.fetch(aclDocUrl, {
-      method: 'PUT',
-      body: str,
-      headers: [
-        [ 'Content-Type', 'text/turtle' ]
-      ]
-    });
-  }
-
-  async loadDoc(doc: NamedNode): Promise<void> {
-    // Load a document into the knowledge base (fetcher.store)
-    //   withCredentials: Web arch should let us just load by turning off creds helps CORS
-    //   reload: Gets around a specific old Chrome bug caching/origin/cors
-    // console.log('loading', profileDocument)
-    if (!this.store.fetcher) {
-      throw new Error("Cannot load doc, have no fetcher");
-    }
-    await this.store.fetcher.load(doc, {
-      withCredentials: false, // @@ BUT this won't work when logged in an accessing private stuff!
-      cache: "reload",
-    });
-    // console.log('loaded', profileDocument, this.store)
-  }
-
-  isContainer(url: string) {
-    return url.substr(-1) === "/";
-  }
-
-  async createContainer(url: string) {
-    if (!this.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 this.underlyingFetch.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}`);
-    }
-  }
-
-  getContainerElements(containerNode: NamedNode): NamedNode[] {
-    return this.store
-      .statementsMatching(
-        containerNode,
-        this.store.sym("http://www.w3.org/ns/ldp#contains"),
-        undefined,
-        containerNode.doc()
-      )
-      .map((st: Statement) => st.object as NamedNode);
-  }
-
-  async getContainerMembers(containerUrl: string): Promise<string[]> {
-    const containerNode = this.store.sym(containerUrl);
-    await this.store.fetcher?.load(containerNode);
-    const nodes = this.getContainerElements(containerNode);
-    return nodes.map(node => node.value);
-  }
-
-  async recursiveDelete(url: string) {
-    try {
-      if (this.isContainer(url)) {
-        const aclDocUrl = await this.findAclDocUrl(url);
-        await this.underlyingFetch.fetch(aclDocUrl, { method: "DELETE" });
-        const containerMembers = await this.getContainerMembers(url);
-        await Promise.all(
-          containerMembers.map((url) => this.recursiveDelete(url))
-        );
-      }
-      return this.underlyingFetch.fetch(url, { method: "DELETE" });
-    } catch (e) {
-      // console.log(`Please manually remove ${url} from your system under test.`, e);
-    }
-  }
-
-  clearStore() {
-    this.store.statements.slice().forEach(this.store.remove.bind(this.store));
-  }
-
-  getArchiveUrl(baseUrl: string, date: Date) {
-    const year = date.getUTCFullYear();
-    const month = ('0' + (date.getUTCMonth()+1)).slice(-2);
-    const day = ('0' + (date.getUTCDate())).slice(-2);
-    const parts = baseUrl.split('/');
-    const filename = parts[parts.length -1 ];
-    return new URL(`./archive/${year}/${month}/${day}/${filename}`, baseUrl).toString();
-  }
-}

package/src/util/uri.ts

@@ -1,5 +0,0 @@
-import { NamedNode, sym } from "rdflib";
-
-export function newThing(doc: NamedNode): NamedNode {
-  return sym(doc.uri + "#" + "id" + ("" + Date.now()));
-}