solid-logic 3.0.9-ea192f01 → 3.0.9-ed64096

package/package.json

@@ -1,11 +1,17 @@
 {
   "name": "solid-logic",
   "type": "module",
-  "version": "3.0.9-ea192f01",
+  "version": "3.0.9-ed64096",
   "description": "Core business logic of SolidOS",
-  "main": "lib/index.js",
+  "main": "dist/solid-logic.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
-    "clean": "rm -rf lib src/versionInfo.ts",
+    "clean": "rm -rf dist src/versionInfo.ts",
     "build": "npm run clean && npm run build-types && npm run build-version && rollup -c",
     "build-version": "./timestamp.sh > src/versionInfo.ts  && eslint 'src/versionInfo.ts' --fix",
     "build-types": "tsc --emitDeclarationOnly",

package/babel.config.js

@@ -1,6 +0,0 @@
-export default {
-  presets: [
-    ["@babel/preset-env", { targets: { node: "current" } }],
-    "@babel/preset-typescript"
-  ]
-};

package/eslint.config.js

@@ -1,28 +0,0 @@
-import tsParser from '@typescript-eslint/parser';
-import tseslint from '@typescript-eslint/eslint-plugin';
-import importPlugin from 'eslint-plugin-import';
-
-export default [
-  {
-    files: ['src/**/*.ts', 'test/**/*.test.ts'],
-    ignores: ['lib/**', 'node_modules/**'],
-    languageOptions: {
-      parser: tsParser,
-      parserOptions: {
-        project: ['./tsconfig.json', './tsconfig.test.json'],
-        sourceType: 'module',
-      },
-    },
-    plugins: {
-      '@typescript-eslint': tseslint,
-      import: importPlugin,
-    },
-    rules: {
-      'semi': ['error', 'never'],
-      'quotes': ['error', 'single'],
-      'no-unused-vars': 'off', // handled by TS
-      '@typescript-eslint/no-unused-vars': ['warn'],
-      '@typescript-eslint/no-explicit-any': 'warn',
-    },
-  },
-];

package/jest.config.js

@@ -1,17 +0,0 @@
-/** @type {import("jest").Config} */
-export default {
-  // verbose: true, // Uncomment for detailed test output
-  collectCoverage: true,
-  coverageDirectory: "coverage",
-  testEnvironment: "jsdom",
-  testEnvironmentOptions: {
-    customExportConditions: ["node"],
-  },
-  testPathIgnorePatterns: ["/node_modules/", "/lib/"],
-  transform: {
-    "^.+\\.[tj]sx?$": ["babel-jest", { configFile: "./babel.config.js" }],
-  },
-  setupFilesAfterEnv: ["./test/helpers/setup.ts"],
-  testMatch: ["**/__tests__/**/*.ts?(x)", "**/?(*.)+(spec|test).ts?(x)"],
-  roots: ["<rootDir>/src", "<rootDir>/test"],
-};

package/rollup.config.js

@@ -1,29 +0,0 @@
-import resolve from '@rollup/plugin-node-resolve'
-import commonjs from '@rollup/plugin-commonjs'
-import typescript from '@rollup/plugin-typescript'
-import { terser } from 'rollup-plugin-terser'
-import fs from 'fs'
-import json from '@rollup/plugin-json'
-
-const license = fs.readFileSync('./LICENSE', 'utf8')
-
-export default {
-  input: 'src/index.ts',
-  output: {
-    file: 'lib/solid-logic.js',
-    format: 'esm',
-    banner: `/*!\n${license}\n*/`,
-    sourcemap: true
-  },
-  plugins: [
-    resolve({ preferBuiltins: true }), // best practice to be true, chooses node.js buildins
-    commonjs(),
-    typescript({
-      declaration: false, // this is false so it does not generate types for the versionInfo file
-      declarationMap: false
-    }),
-    json(),
-    terser()
-  ],
-  inlineDynamicImports: true // dissables multiple chunk creation, why we use rollup in the first place
-}

package/src/acl/aclLogic.ts

@@ -1,156 +0,0 @@
-import { graph, NamedNode, Namespace, serialize, sym } from 'rdflib'
-import { AclLogic } from '../types'
-import { ns as namespace } from '../util/ns'
-
-
-export const ACL_LINK = sym(
-    'http://www.iana.org/assignments/link-relations/acl'
-)
-
-export function createAclLogic(store): AclLogic {
-
-    const ns = namespace
-    
-    async function findAclDocUrl(url: NamedNode) {
-        await store.fetcher.load(url)
-        const docNode = store.any(url, ACL_LINK)
-        if (!docNode) {
-            throw new Error(`No ACL link discovered for ${url}`)
-        }
-        return docNode.value
-    }
-    /**
-     * Simple Access Control
-     *
-     * This function sets up a simple default ACL for a resource, with
-     * RWC for the owner, and a specified access (default none) for the public.
-     * In all cases owner has read write control.
-     * Parameter lists modes allowed to public
-     *
-     * @param options
-     * @param options.public eg ['Read', 'Write']
-     *
-     * @returns Resolves with aclDoc uri on successful write
-     */
-    function setACLUserPublic ( 
-    docURI: string,
-    me: NamedNode,
-    options: {
-        defaultForNew?: boolean,
-        public?: []
-    }
-    ): Promise<NamedNode> {
-    const aclDoc = store.any(
-        store.sym(docURI),
-        ACL_LINK
-    )
-
-    return Promise.resolve()
-        .then(() => {
-        if (aclDoc) {
-            return aclDoc as NamedNode
-        }
-
-        return fetchACLRel(docURI).catch(err => {
-            throw new Error(`Error fetching rel=ACL header for ${docURI}: ${err}`)
-        })
-        })
-        .then(aclDoc => {
-        const aclText = genACLText(docURI, me, aclDoc.uri, options)
-        if (!store.fetcher) {
-            throw new Error('Cannot PUT this, store has no fetcher')
-        }
-        return store.fetcher
-            .webOperation('PUT', aclDoc.uri, {
-            data: aclText,
-            contentType: 'text/turtle'
-            })
-            .then(result => {
-            if (!result.ok) {
-                throw new Error('Error writing ACL text: ' + result.error)
-            }
-
-            return aclDoc
-            })
-        })
-    }
-
-    /**
-     * @param docURI
-     * @returns
-     */
-    function fetchACLRel (docURI: string): Promise<NamedNode> {
-        const fetcher = store.fetcher
-        if (!fetcher) {
-            throw new Error('Cannot fetch ACL rel, store has no fetcher')
-        }
-
-        return fetcher.load(docURI).then(result => {
-            if (!result.ok) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                throw new Error('fetchACLRel: While loading:' + (result as any).error)
-            }
-
-            const aclDoc = store.any(
-            store.sym(docURI),
-            ACL_LINK
-            )
-
-            if (!aclDoc) {
-            throw new Error('fetchACLRel: No Link rel=ACL header for ' + docURI)
-            }
-
-            return aclDoc as NamedNode
-        })
-    }
-
-    /**
-     * @param docURI
-     * @param me
-     * @param aclURI
-     * @param options
-     *
-     * @returns Serialized ACL
-     */
-    function genACLText (
-    docURI: string,
-    me: NamedNode,
-    aclURI: string,
-    options: {
-            defaultForNew?: boolean,
-            public?: []
-        } = {}
-    ): string | undefined {
-        const optPublic = options.public || []
-        const g = graph()
-        const auth = Namespace('http://www.w3.org/ns/auth/acl#')
-        let a = g.sym(`${aclURI}#a1`)
-        const acl = g.sym(aclURI)
-        const doc = g.sym(docURI)
-        g.add(a, ns.rdf('type'), auth('Authorization'), acl)
-        g.add(a, auth('accessTo'), doc, acl)
-        if (options.defaultForNew) {
-            g.add(a, auth('default'), doc, acl)
-        }
-        g.add(a, auth('agent'), me, acl)
-        g.add(a, auth('mode'), auth('Read'), acl)
-        g.add(a, auth('mode'), auth('Write'), acl)
-        g.add(a, auth('mode'), auth('Control'), acl)
-
-        if (optPublic.length) {
-            a = g.sym(`${aclURI}#a2`)
-            g.add(a, ns.rdf('type'), auth('Authorization'), acl)
-            g.add(a, auth('accessTo'), doc, acl)
-            g.add(a, auth('agentClass'), ns.foaf('Agent'), acl)
-            for (let p = 0; p < optPublic.length; p++) {
-            g.add(a, auth('mode'), auth(optPublic[p]), acl) // Like 'Read' etc
-            }
-        }
-        return serialize(acl, g, aclURI)
-    }
-    return {
-        findAclDocUrl,
-        setACLUserPublic,
-        genACLText
-    }
-}

package/src/authSession/authSession.ts

@@ -1,13 +0,0 @@
-import {
-  Session,
-  getClientAuthenticationWithDependencies
-} from '@inrupt/solid-client-authn-browser'
-
-export const authSession = new Session(
-    {
-      clientAuthentication: getClientAuthenticationWithDependencies({})
-    },
-    'mySession'
-  )
-
-  

package/src/authn/SolidAuthnLogic.ts

@@ -1,126 +0,0 @@
-import { namedNode, NamedNode, sym } from 'rdflib'
-import { appContext, offlineTestID } from './authUtil'
-import * as debug from '../util/debug'
-import { Session } from '@inrupt/solid-client-authn-browser'
-import { AuthenticationContext, AuthnLogic } from '../types'
-
-export class SolidAuthnLogic implements AuthnLogic {
-  private session: Session
-
-  constructor(solidAuthSession: Session) {
-    this.session = solidAuthSession
-  }
-
-  // we created authSession getter because we want to access it as authn.authSession externally
-  get authSession():Session { return this.session }
-
-  currentUser(): NamedNode | null {
-    const app = appContext()
-    if (app.viewingNoAuthPage) {
-      return sym(app.webId)
-    }
-    if (this && this.session && this.session.info && this.session.info.webId && this.session.info.isLoggedIn) {
-      return sym(this.session.info.webId)
-    }
-    return offlineTestID() // null unless testing
-  }
-
-  /**
-   * Retrieves currently logged in webId from either
-   * defaultTestUser or SolidAuth
-   * Also activates a session after login
-   * @param [setUserCallback] Optional callback
-   * @returns Resolves with webId uri, if no callback provided
-   */
-  async checkUser<T> (
-    setUserCallback?: (me: NamedNode | null) => T
-  ): Promise<NamedNode | T | null> {
-    // Save hash for "restorePreviousSession"
-    const preLoginRedirectHash = new URL(window.location.href).hash
-    if (preLoginRedirectHash) {
-      window.localStorage.setItem('preLoginRedirectHash', preLoginRedirectHash)
-    }
-    this.session.onSessionRestore((url) => {
-      if (document.location.toString() !== url) history.replaceState(null, '', url)
-    })
-
-    /**
-     * Handle a successful authentication redirect
-     */
-    const redirectUrl = new URL(window.location.href)
-    redirectUrl.hash = ''
-    await this.session
-      .handleIncomingRedirect({
-        restorePreviousSession: true,
-        url: redirectUrl.href
-      })
-
-    // Check to see if a hash was stored in local storage
-    const postLoginRedirectHash = window.localStorage.getItem('preLoginRedirectHash')
-    if (postLoginRedirectHash) {
-      const curUrl = new URL(window.location.href)
-      if (curUrl.hash !== postLoginRedirectHash) {
-        if (history.pushState) {
-          // debug.log('Setting window.location.has using pushState')
-          history.pushState(null, document.title, postLoginRedirectHash)
-        } else {
-          // debug.warn('Setting window.location.has using location.hash')
-          location.hash = postLoginRedirectHash
-        }
-        curUrl.hash = postLoginRedirectHash
-      }
-      // See https://stackoverflow.com/questions/3870057/how-can-i-update-window-location-hash-without-jumping-the-document
-      // window.location.href = curUrl.toString()// @@ See https://developer.mozilla.org/en-US/docs/Web/API/Window/location
-      window.localStorage.setItem('preLoginRedirectHash', '')
-    }
-
-    // Check to see if already logged in / have the WebID
-    let me = offlineTestID()
-    if (me) {
-      return Promise.resolve(setUserCallback ? setUserCallback(me) : me)
-    }
-
-    const webId = this.webIdFromSession(this.session.info)
-    if (webId) {
-      me = this.saveUser(webId)
-    }
-
-    if (me) {
-      debug.log(`(Logged in as ${me} by authentication)`)
-    }
-
-    return Promise.resolve(setUserCallback ? setUserCallback(me) : me)
-  }
-
-  /**
-   * Saves `webId` in `context.me`
-   * @param webId
-   * @param context
-   *
-   * @returns Returns the WebID, after setting it
-   */
-  saveUser (
-    webId: NamedNode | string | null,
-    context?: AuthenticationContext
-  ): NamedNode | null {
-    let webIdUri: string
-    if (webId) {
-      webIdUri = (typeof webId === 'string') ? webId : webId.uri
-      const me = namedNode(webIdUri)
-      if (context) {
-        context.me = me
-      }
-      return me
-    }
-    return null
-  }
-
-  /**
-   * @returns {Promise<string|null>} Resolves with WebID URI or null
-   */
-  webIdFromSession (session?: { webId?: string, isLoggedIn: boolean }): string | null {
-    const webId = session?.webId && session.isLoggedIn ? session.webId : null
-    return webId
-  }
-
-}

package/src/authn/authUtil.ts

@@ -1,70 +0,0 @@
-import { NamedNode, sym } from 'rdflib'
-import * as debug from '../util/debug'
-
-/**
- * find a user or app's context as set in window.SolidAppContext
- * this is a const, not a function, because we have problems to jest mock it otherwise
- * see: https://github.com/facebook/jest/issues/936#issuecomment-545080082 for more
- * @return {any} - an appContext object
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const appContext = ():any => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let { SolidAppContext }: any = window
-    SolidAppContext ||= {}
-    SolidAppContext.viewingNoAuthPage = false
-    if (SolidAppContext.noAuth && window.document) {
-        const currentPage = window.document.location.href
-        if (currentPage.startsWith(SolidAppContext.noAuth)) {
-        SolidAppContext.viewingNoAuthPage = true
-        const params = new URLSearchParams(window.document.location.search)
-        if (params) {
-            let viewedPage = SolidAppContext.viewedPage = params.get('uri') || null
-            if (viewedPage) {
-            viewedPage = decodeURI(viewedPage)
-            if (!viewedPage.startsWith(SolidAppContext.noAuth)) {
-                const ary = viewedPage.split(/\//)
-                SolidAppContext.idp = ary[0] + '//' + ary[2]
-                SolidAppContext.viewingNoAuthPage = false
-            }
-            }
-        }
-        }
-    }
-    return SolidAppContext
-}
-
-/**
- * Returns `sym($SolidTestEnvironment.username)` if
- * `$SolidTestEnvironment.username` is defined as a global
- * or 
- * returns testID defined in the HTML page
- * @returns {NamedNode|null}
- */
-export function offlineTestID (): NamedNode | null {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any 
-    const { $SolidTestEnvironment }: any = window
-    if (
-      typeof $SolidTestEnvironment !== 'undefined' &&
-      $SolidTestEnvironment.username
-    ) {
-      // Test setup
-      debug.log('Assuming the user is ' + $SolidTestEnvironment.username)
-      return sym($SolidTestEnvironment.username)
-    }
-    // hack that makes SolidOS work in offline mode by adding the webId directly in html
-    // example usage: https://github.com/solidos/mashlib/blob/29b8b53c46bf02e0e219f0bacd51b0e9951001dd/test/contact/local.html#L37
-    if (
-      typeof document !== 'undefined' &&
-      document.location &&
-      ('' + document.location).slice(0, 16) === 'http://localhost'
-    ) {
-      const div = document.getElementById('appTarget')
-      if (!div) return null
-      const id = div.getAttribute('testID')
-      if (!id) return null
-      debug.log('Assuming user is ' + id)
-      return sym(id)
-    }
-    return null
-}