solid-logic 1.3.17-9d25ceb7 → 1.3.17-a849582e

package/lib/util/uri.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.newThing = void 0;
-var rdflib_1 = require("rdflib");
-function newThing(doc) {
-    return (0, rdflib_1.sym)(doc.uri + "#" + "id" + ("" + Date.now()));
-}
-exports.newThing = newThing;
-//# sourceMappingURL=uri.js.map

package/lib/util/uri.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"uri.js","sourceRoot":"","sources":["../../src/util/uri.ts"],"names":[],"mappings":";;;AAAA,iCAAwC;AAExC,SAAgB,QAAQ,CAAC,GAAc;IACrC,OAAO,IAAA,YAAG,EAAC,GAAG,CAAC,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;AACvD,CAAC;AAFD,4BAEC"}

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/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/logic/SolidLogic.ts

@@ -1,262 +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";
-/*
-** 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`,
-*/
-
-const ns: SolidNamespace = solidNamespace(rdf);
-
-export class SolidLogic {
-    cache: {
-        profileDocument: {
-        [WebID: string]: NamedNode;
-        };
-        preferencesFile: {
-        [WebID: string]: NamedNode;
-        };
-    };
-
-    store: LiveStore;
-    me: string | undefined;
-    underlyingFetch: { fetch: (url: string, options?: any) => any };
-
-    chat: ChatLogic;
-    profile: ProfileLogic;
-    authn: AuthnLogic;
-    util: UtilityLogic;
-
-    constructor(specialFetch: { fetch: (url: any, requestInit: any) => any }, session: Session) {
-  // would xpect to be able to do it this way: but get TypeError:  Failed to execute 'fetch' on 'Window': Illegal invocation status: 999
-        // this.store = new rdf.LiveStore({})
-        // this.store.fetcher._fetch = fetch
-        console.log("SolidLogic: Unique instance created.  There should only be one of these.")
-        this.store = rdf.graph() as LiveStore; // Make a Quad store
-        rdf.fetcher(this.store, { fetch: specialFetch.fetch}); // Attach a web I/O module, store.fetcher
-        this.store.updater = new rdf.UpdateManager(this.store); // Add real-time live updates store.updater
-
-        this.store.features = [] // disable automatic node merging on store load
-        this.cache = {
-        profileDocument: {},
-        preferencesFile: {},
-        };
-        this.underlyingFetch = { fetch: fetch }; // Note global one not the one passed
-        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.underlyingFetch);
-    }
-
-    findAclDocUrl(url: string) {
-        return this.util.findAclDocUrl(url);
-    }
-
-    async loadProfile(me: NamedNode): Promise<NamedNode> {
-        /*
-      // console.log('loadProfile cache ', this.cache)
-        if (this.cache.profileDocument[me.value]) {
-        return this.cache.profileDocument[me.value];
-      }    @@ just use the cache in the store
-        */
-        console.log('loadProfile  me ', me)
-        const profileDocument = me.doc()
-        try {
-          await this.store.fetcher.load(profileDocument);
-          return profileDocument;
-        } catch (err) {
-        const message = `Cannot load profile ${profileDocument} : ${err}`;
-        throw new Error(message);
-        }
-    }
-
-    async loadPreferences(me: NamedNode): Promise<NamedNode> {
-        console.log('loadPreferences cache ', this.cache)
-        if (this.cache.preferencesFile[me.value]) {
-        return this.cache.preferencesFile[me.value];
-        }
-        await this.loadProfile(me) // Load pointer to pref file
-        const preferencesFile = this.store.any(me, ns.space('preferencesFile'), null, me.doc());
-
-        // 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()}`
-        );
-        }
-
-        // //// 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) {
-        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) {
-        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) => {
-        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.underlyingFetch.fetch(url, options);
-    }
-}

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());
-  }
-}