├── .npmignore
├── core
    ├── .npmignore
    ├── .gitignore
    ├── LICENSE
    ├── src
    │   ├── examineRequest.js
    │   ├── utils
    │   │   ├── utils.js
    │   │   ├── container.js
    │   │   ├── createServerlessPod.js
    │   │   └── rest-patch.js
    │   ├── handleRequest.js
    │   ├── examineRequestedItem.js
    │   ├── index.js
    │   ├── performRequestedMethod.js
    │   └── handleResponse.js
    ├── package.json
    └── README.md
├── file
    ├── .npmignore
    ├── .gitignore
    ├── tests
    │   ├── head.js
    │   ├── folders.js
    │   ├── jsonld.js
    │   ├── post.js
    │   ├── delete.js
    │   ├── rest-methods.js
    │   ├── patch.js
    │   ├── n3patch.js
    │   └── all.js
    ├── README.md
    ├── LICENSE
    ├── package.json
    └── src
    │   └── index.js
├── dropbox
    ├── .npmignore
    ├── .gitignore
    ├── README.md
    ├── package.json
    ├── examples
    │   └── dropbox-read.js
    └── src
    │   └── index.js
├── browser
    ├── .gitignore
    ├── examples
    │   ├── stand-alone.html
    │   ├── rdflib.html
    │   └── authn.html
    ├── webpack.config.js
    ├── package.json
    ├── README.md
    ├── src
    │   └── index.js
    └── dist
    │   └── solid-rest-browser.bundle.js
├── .gitignore
├── head.js
├── mem
    ├── package.json
    ├── README.md
    └── src
    │   └── index.js
├── server
    ├── package.json
    ├── LICENSE
    ├── index.js
    └── index.html
├── ssh
    └── README.md
├── README.md
└── tests
    ├── browser-test.html
    ├── shouldFail.js
    ├── shouldSucceed.js
    └── all.js


/.npmignore:
--------------------------------------------------------------------------------
1 | *~
2 | #*
3 | drafts
4 | node_modules
5 | 


--------------------------------------------------------------------------------
/core/.npmignore:
--------------------------------------------------------------------------------
1 | *~
2 | #*
3 | drafts
4 | node_modules
5 | 


--------------------------------------------------------------------------------
/file/.npmignore:
--------------------------------------------------------------------------------
1 | *~
2 | #*
3 | drafts
4 | node_modules
5 | 


--------------------------------------------------------------------------------
/dropbox/.npmignore:
--------------------------------------------------------------------------------
1 | *~
2 | #*
3 | drafts
4 | node_modules
5 | 


--------------------------------------------------------------------------------
/core/.gitignore:
--------------------------------------------------------------------------------
1 | *~
2 | #*
3 | *#
4 | .#*
5 | drafts
6 | node_modules
7 | test-folder
8 | 


--------------------------------------------------------------------------------
/file/.gitignore:
--------------------------------------------------------------------------------
 1 | *~
 2 | #*
 3 | *#
 4 | .#*
 5 | drafts
 6 | node_modules
 7 | dist
 8 | coverage
 9 | lib
10 | test-folder
11 | log.txt


--------------------------------------------------------------------------------
/browser/.gitignore:
--------------------------------------------------------------------------------
 1 | *~
 2 | #*
 3 | *#
 4 | .#*
 5 | drafts
 6 | node_modules
 7 | coverage
 8 | lib
 9 | test-folder
10 | log.txt
11 | myPod


--------------------------------------------------------------------------------
/dropbox/.gitignore:
--------------------------------------------------------------------------------
 1 | *~
 2 | #*
 3 | *#
 4 | .#*
 5 | drafts
 6 | node_modules
 7 | dist
 8 | coverage
 9 | lib
10 | test-folder
11 | log.txt


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | *~
 2 | #*
 3 | *#
 4 | .#*
 5 | drafts
 6 | node_modules
 7 | dist
 8 | coverage
 9 | lib
10 | test-folder
11 | log.txt
12 | myPod
13 | testall.sh


--------------------------------------------------------------------------------
/head.js:
--------------------------------------------------------------------------------
1 | const {SolidRestFile} = require('./file');
2 | const auth = new SolidRestFile();
3 | auth.fetch('./head.js',{method:'HEAD'}).then(response=>console.log( response ));
4 | 
5 | 


--------------------------------------------------------------------------------
/mem/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "solid-rest-mem",
 3 |   "version": "1.0.0",
 4 |   "description": "",
 5 |   "main": "src/index.js",
 6 |   "scripts": {
 7 |     "test": "echo \"Error: no test specified\" && exit 1"
 8 |   },
 9 |   "keywords": [],
10 |   "author": "",
11 |   "license": "MIT"
12 | }
13 | 


--------------------------------------------------------------------------------
/file/tests/head.js:
--------------------------------------------------------------------------------
 1 | const $rdf = global.$rdf = require('rdflib');
 2 | const {SolidRestFile} = require('../');
 3 | const client = new SolidRestFile();
 4 | const uri = `file://${process.cwd()}/head.js`;
 5 | (async()=>{
 6 |   let r = await client.fetch(uri,{method:'HEAD'});
 7 |   console.log(await r.text());
 8 | })();
 9 | 
10 | 


--------------------------------------------------------------------------------
/file/tests/folders.js:
--------------------------------------------------------------------------------
 1 | const $rdf = global.$rdf = require('rdflib');
 2 | const {SolidRestFile} = require('../');
 3 | const client = global.client = new SolidRestFile();
 4 | const rest = require('./rest-methods');
 5 | 
 6 | const folder =  "file://"+process.cwd()+"/ztest/"
 7 | 
 8 | async function main(){
 9 |   let r1 = await rest.PUT(folder+".acl");
10 |   let r2 = await rest.DELETE(folder);
11 |   let r3 = await rest.GET(folder);
12 |   console.log(r1.status,r2.status,r3.status);
13 | }
14 | main();
15 | 


--------------------------------------------------------------------------------
/server/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "solid-rest-server",
 3 |   "version": "1.0.0",
 4 |   "description": "A simple Solid server based on Solid-Rest",
 5 |   "main": "index.js",
 6 |   "scripts": {
 7 |     "start": "node index"
 8 |   },
 9 |   "keywords": ["Solid"],
10 |   "author": "Jeff Zucker",
11 |   "contributors": [
12 |      "Alain Bourgeois"
13 |   ],
14 |   "license": "MIT",
15 |   "dependencies": {
16 |     "@solid-rest/file": "^2.1.18",
17 |     "express": "^4.18.2",
18 |     "mashlib": "^1.8.10-alpha",
19 |     "solid-node-client": "^2.1.10"
20 |   }
21 | }
22 | 


--------------------------------------------------------------------------------
/file/tests/jsonld.js:
--------------------------------------------------------------------------------
 1 | const $rdf = global.$rdf = require('rdflib');
 2 | const {SolidRestFile} = require('../');
 3 | const client = new SolidRestFile();
 4 | const uri = "file://"+process.cwd()+"/test.ttl";
 5 | //const uri = "https://jeff-zucker.solidcommunity.net/public/test.ttl";
 6 | 
 7 | (async ()=>{
 8 |   let r = await client.fetch( uri, {
 9 |     method:'PUT',
10 |     body:'<#This> <#isA> <#Foo>.',
11 |     headers:{"content-type":"text/turtle"}
12 |   });
13 |   console.log( r.status );
14 |   r = await client.fetch( uri, {
15 |     method:'GET',
16 |     headers:{"accept":"application/ld+json"}
17 |   });
18 |   console.log( r.status );
19 |   console.log( await r.text() );
20 | })();
21 | 


--------------------------------------------------------------------------------
/browser/examples/stand-alone.html:
--------------------------------------------------------------------------------
 1 | <script src="https://cdn.jsdelivr.net/npm/browserfs@1.4.3/dist/browserfs.min.js"></script>
 2 | <script src="../dist/solid-rest-browser.bundle.js"></script>
 3 | 
 4 | <script type="module">
 5 |   async function test(){
 6 |     const solidRest = new SolidRestBrowser();
 7 |     await solidRest.configure();
 8 |     const uri = 'browser://IndexedDB/foo/bar/text.txt';
 9 |     const expected = 'Sample content.';
10 |     await solidRest.fetch( uri, {
11 |       method:'PUT', 
12 |       body: expected,
13 |       headers:{"content-type":"text/plain"},
14 |     })
15 |     let got = await solidRest.fetch(uri);
16 |     if(await got.text()===expected) alert ("Success!");
17 |     else alert("Failure!");
18 |   }
19 |   test();
20 | </script>
21 | 


--------------------------------------------------------------------------------
/file/README.md:
--------------------------------------------------------------------------------
 1 | # Solid-Rest-File
 2 | 
 3 | **Treat any file system as a serverless Solid pod**
 4 | 
 5 | This library treats a local file system as a serverless Solid Pod, accepting Solid requests (GET, PUT, etc.) and returning Solid responses (wac-allow headers, turtle representation of folders, etc.).
 6 | 
 7 | The library may be used stand-alone (see [tests](./tests/all.js) for examples), or as a plugin to [Solid-Node-Client](https://github.com/solid/solid-node-client) from where it can be integrated into almost any Solid library or app.  Simply import Solid-Node-Client and thereafter use file:// URLs almost anywhere that https:// URLs work.  See the Solid-Node-Client documentation for details.
 8 | 
 9 | &copy; 2021, Jeff Zucker, may be freely used with an MIT license.
10 | 
11 | 
12 | 
13 | 
14 | 
15 | 


--------------------------------------------------------------------------------
/ssh/README.md:
--------------------------------------------------------------------------------
 1 | # Solid-Rest-SSH
 2 | 
 3 | Treat any SSH host ass a Solid pod
 4 | 
 5 | **Warning** This library has not been upgraded to version 2.x yet, so is NOT usable at the moment.  If you have need for it before I upgrade, contact me on the Solid forum (@jeffz) or Gitter channel. (@jeff-zucker).
 6 | 
 7 | This library treats an SSH host as a serverless Solid Pod, accepting Solid requests (GET, PUT, etc.) and returning Solid responses (wac-allow headers, turtle representation of folders, etc.).
 8 | 
 9 | The library may be used stand-alone (see [tests](./tests/all.js) for examples), or as a plugin to [Solid-Node-Client](https://github.com/solid/solid-node-client) from where it can be integrated into almost any Solid library or app.  Simply import Solid-Node-Client and thereafter use file:// URLs almost anywhere that https:// URLs work.  See the Solid-Node-Client documentation for details.
10 | 
11 | &copy; 2021, Jeff Zucker, may be freely used with an MIT license.
12 | 


--------------------------------------------------------------------------------
/dropbox/README.md:
--------------------------------------------------------------------------------
 1 | # Solid-Rest-Dropbox
 2 | 
 3 | Treat your Dropbox storage as a Solid pod
 4 | 
 5 | **Warning** This library is in development and should be considered experimental at this time. If you run into problems, contact me on the Solid forum (@jeffz) or Gitter channel. (@jeff-zucker).
 6 | 
 7 | This library treats a Dropbox host as a serverless Solid Pod, accepting Solid requests (GET, PUT, etc.) and returning Solid responses (wac-allow headers, turtle representation of folders, etc.).
 8 | 
 9 | The library may be used stand-alone (see [tests](./tests/all.js) for examples).<!-- , or as a plugin to [Solid-Node-Client](https://github.com/solid/solid-node-client) from where it can be integrated into almost any Solid library or app.  Simply import Solid-Node-Client and thereafter use file:// URLs almost anywhere that https:// URLs work.  See the Solid-Node-Client documentation for details. -->
10 | 
11 | &copy; 2021, Jeff Zucker, may be freely used with an MIT license.
12 | 
13 | 


--------------------------------------------------------------------------------
/mem/README.md:
--------------------------------------------------------------------------------
 1 | # Solid-Rest-Mem
 2 | 
 3 | Treat virtual in-memory storage as a Solid pod
 4 | 
 5 | **Warning** This library has not been upgraded to version 2.x yet, so is NOT usable at the moment.  If you have need for it before I upgrade, contact me on the Solid forum (@jeffz) or Gitter channel. (@jeff-zucker).
 6 | 
 7 | This library treats a local file system as a serverless Solid Pod, accepting Solid requests (GET, PUT, etc.) and returning Solid responses (wac-allow headers, turtle representation of folders, etc.).
 8 | 
 9 | The library may be used stand-alone (see [tests](./tests/all.js) for examples), or as a plugin to [Solid-Node-Client](https://github.com/solid/solid-node-client) from where it can be integrated into almost any Solid library or app.  Simply import Solid-Node-Client and thereafter use file:// URLs almost anywhere that https:// URLs work.  See the Solid-Node-Client documentation for details.
10 | 
11 | &copy; 2021, Jeff Zucker, may be freely used with an MIT license.
12 | 
13 | 
14 | 
15 | 
16 | 
17 | 


--------------------------------------------------------------------------------
/file/tests/post.js:
--------------------------------------------------------------------------------
 1 | const base       = "file://"+process.cwd()+"/ztest/";
 2 | const folderName = "new-folder";
 3 | const fileName   = "foo.txt";
 4 | const folder     = base + folderName + "/";
 5 | const file       = base + folderName + "/" + fileName;
 6 | 
 7 | async function run(){
 8 |   let res = await postFolder(base,folderName);
 9 |   console.log(res.url)
10 |   res = await postFile(folder,fileName);
11 |   console.log(res.headers.get('url'))
12 | }
13 | async function main(){
14 |   await clean();
15 |   await PUT(base);
16 |   await run();
17 |   await clean();
18 | }
19 | async function clean(){
20 |   await DELETE(file);
21 |   await DELETE(folder);
22 |   await DELETE(base);
23 | }
24 | 
25 | //const {SolidNodeClient} = require('../');
26 | //const client = global.client = new SolidNodeClient();
27 | const {SolidRestFile} = require('../');
28 | const client = global.client = new SolidRestFile();
29 | const r = require('./rest-methods')
30 | const [PUT,DELETE]=[r.PUT,r.DELETE];
31 | const [postFile,postFolder]=[r.postFile,r.postFolder];
32 | main();
33 | 
34 | 


--------------------------------------------------------------------------------
/core/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 Jeff Zucker
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/file/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 Jeff Zucker
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/server/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 Jeff Zucker
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/dropbox/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "@solid-rest/dropbox",
 3 |   "author": "Jeff Zucker",
 4 |   "version": "1.0.6",
 5 |   "license": "MIT",
 6 |   "description": "Solid-Rest plugin for Dropbox",
 7 |   "main": "dist/cjs/index.js",
 8 |   "module": "dist/esm/index.js",
 9 |   "scripts": {
10 |     "build": "rm -rf dist && mkdir dist && mkdir dist/cjs && npm run build:cjs && npm run build:esm",
11 |     "build:cjs": "babel --plugins @babel/plugin-transform-modules-commonjs src --out-dir dist/cjs",
12 |     "build:esm": "babel src --out-dir dist/esm"
13 |   },
14 |   "repository": {
15 |     "type": "git",
16 |     "url": "git+https://github.com/solid/solid-rest.git"
17 |   },
18 |   "keywords": [
19 |     "solid",
20 |     "linked data",
21 |     "dropbox"
22 |   ],
23 |   "bugs": {
24 |     "url": "https://github.com/solid/solid-rest/issues"
25 |   },
26 |   "engines": {
27 |     "node": ">=10.12.0"
28 |   },
29 |   "homepage": "https://github.com/solid/solid-rest#readme",
30 |   "dependencies": {
31 |     "@solid-rest/core": "^2.0.1",
32 |     "dropbox": "^8.2.0"
33 |   },
34 |   "devDependencies": {
35 |     "@babel/cli": "^7.12.10",
36 |     "@babel/plugin-transform-modules-commonjs": "^7.12.1"
37 |   }
38 | }
39 | 


--------------------------------------------------------------------------------
/file/tests/delete.js:
--------------------------------------------------------------------------------
 1 | const $rdf = global.$rdf = require('rdflib');
 2 | const {SolidRestFile} = require('../');
 3 | const client = global.client = new SolidRestFile();
 4 | const rest = require('./rest-methods');
 5 | 
 6 | const base = "file://"+process.cwd()+"/ztest/"
 7 | const deep = "file://"+process.cwd()+"/ztest/deep/"
 8 | 
 9 | const files = [
10 |   base+"foo.txt",
11 |   deep+"foo.txt",
12 | ];
13 | const auxFiles = [
14 |   base+".acl",
15 |   base+".meta",
16 |   base+"foo.txt.acl",
17 |   base+"foo.txt.meta",
18 |   base+"foo.txt.meta.acl ",
19 |   deep+".acl",
20 |   deep+".meta",
21 |   deep+"foo.txt.acl",
22 |   deep+"foo.txt.meta",
23 |   deep+"foo.txt.meta.acl ",
24 | ];
25 | 
26 | async function main(resource){
27 |   for(let file of files.concat(auxFiles)){
28 |     await rest.PUT(file);
29 |   }
30 |   if( await rest.EXISTS(files[5]) ) console.log( "Folder & files created." );
31 |   for(let file of files){
32 |     if( !file.endsWith('.acl') && !file.endsWith('.meta') )
33 |       await rest.DELETE(file);
34 |   }
35 |   if( ! await rest.EXISTS(files[5]) ) console.log( "Files deleted." );
36 |   await rest.DELETE(base);
37 |   if( ! await rest.EXISTS(base) ) console.log( "Folder deleted." );
38 | }
39 | main();
40 | 
41 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Solid-Rest
 2 | 
 3 | Treat any storage backend as a Solid pod
 4 | 
 5 | ## Overview
 6 | 
 7 | Solid-Rest translates Solid requests into backend requests and backend responses into Solid responses.  This means that any storage system that has a Solid-Rest plugin may be treated as a pod.  Currently there are plugins for file and dropbox which means that any app that uses Solid-Rest can address file:// and dropbox:// URIs the same way as a Solid pod https:// URI and expect the same responses with some exceptions : permissions are not handled by Solid .acls, they  are based on the underlying file or cloud permissions; collaborative tools such as chat are not available.  These backends can now be addressed with most Solid libraries (e.g. rdflib) and apps (e.g. the databrowser). 
 8 | 
 9 | Plugins for ssh, in-memory storage, in-browser storage (indexedDB, localStorage, Native File API) are in development.
10 | 
11 | Although Solid-Rest can be used stand-alone, it is best used in conjunction with other libraries, especially [Solid-Node-Client](https://github.com/solid/solid-node-client), a nodejs client for Solid.
12 |   Solid-Node-Client comes preloaded with the Solid-Rest-File plugin, so it will be transparently included in anything using that library.
13 |   
14 | 


--------------------------------------------------------------------------------
/browser/webpack.config.js:
--------------------------------------------------------------------------------
 1 | const path = require('path')
 2 | 
 3 | // Configurations shared between all builds 
 4 | const common = {
 5 |     mode: 'production',
 6 |     entry: './src/index.js',
 7 |     output: {
 8 |         filename: 'solid-rest-browser.bundle.js',
 9 |         library: 'SolidRestBrowser',
10 |         libraryExport: 'default',
11 |     },
12 |     devtool: 'source-map',
13 | }
14 | 
15 | // Configurations specific to the window build
16 | const window = {
17 |     ...common,
18 |     name: 'window',
19 |     output: {
20 |         ...common.output,
21 |         path: path.resolve(__dirname, 'dist'),
22 |         libraryTarget: 'umd',
23 |     },
24 |     module: {
25 |         rules: [
26 |             {
27 |                 loader: 'babel-loader',
28 |                 exclude: /node_modules/,
29 |             },
30 |         ],
31 |     },
32 | }
33 | 
34 | // Configurations specific to the node build
35 | /*
36 | const node = {
37 |     ...common,
38 |     name: 'node',
39 |     output: {
40 |         ...common.output,
41 |         path: path.resolve(__dirname, 'dist', 'node'),
42 |         libraryTarget: 'commonjs2',
43 |     },
44 | }
45 | */
46 | const resolve = {resolve:{ fallback: { "path": false } }}
47 | module.exports = [
48 |     resolve,
49 |     window
50 | ]
51 | 


--------------------------------------------------------------------------------
/browser/examples/rdflib.html:
--------------------------------------------------------------------------------
 1 | <script src="https://cdn.jsdelivr.net/npm/browserfs@1.4.3/dist/browserfs.min.js"></script>
 2 | <script src="https://cdn.jsdelivr.net/npm/rdflib@2.2.14/dist/rdflib.min.js"></script>
 3 | <script src="../dist/solid-rest-browser.bundle.js"></script>
 4 | <script type="module">
 5 | 
 6 |   async function test(){
 7 | 
 8 |     // define the knowledge-base & updater as usual
 9 |     //
10 |     const kb = $rdf.graph();
11 |     const myUpdater = new $rdf.UpdateManager(kb)
12 | 
13 |     // define a custom fetcher using solid rest and the knowledge base
14 |     //
15 |     const solidRest = new SolidRestBrowser();
16 |     const myFetcher = await solidRest.configFetcher(kb);
17 | 
18 |     // from here on, myFetcher & myUpdater will
19 |     // support in-browser fetches
20 |     //
21 |     const uri = 'browser://HTML5FS/test.tll';
22 |     const why = $rdf.sym(uri);
23 |     const doc = $rdf.Namespace(uri+'#');
24 |     const expected = doc('turtleDoc');
25 |     kb.add( why, doc('isA'), expected,why );
26 |     await myFetcher.putBack(why);
27 |     kb.remove(why);
28 |     await myFetcher.load(why);
29 |     const got = kb.any(why,doc('isA'),null,why);
30 |     if(got && got.value===expected.value) alert ("Success!");
31 |     else alert(got.value);
32 |   }
33 |   test();
34 | 
35 | </script>
36 | 


--------------------------------------------------------------------------------
/dropbox/examples/dropbox-read.js:
--------------------------------------------------------------------------------
 1 | import {SolidRestDropbox} from '../';
 2 | import {credentials} from '/home/jeff/.solid-identities.js';
 3 | const client = new SolidRestDropbox();
 4 | 
 5 | const access_token = credentials.dropbox.access_token;
 6 | const testFolder = 'dropbox:///';
 7 | const testFile = 'dropbox:///x.txt';
 8 | 
 9 | async function main(){
10 |   await login({access_token:access_token});
11 |   await readFolder( testFolder );
12 |   await readFile( testFile );
13 | }
14 | main();
15 | 
16 | async function login(init){
17 |    console.log("logging in ...");
18 |    let response = await client.login(init);
19 |    console.log("got status : ",response.status,response.statusText,"\n");
20 | }
21 | async function readFile(file){
22 |    console.log("reading file ",file);
23 |    let response = await client.fetch(file);
24 |    console.log("got content : ",await response.text(),"\n");
25 |    console.log("got status : ",response.status,response.statusText,"\n");
26 | }
27 | async function readFolder(folder){
28 |    console.log("reading folder ",folder);
29 |    let response = await client.fetch(folder);
30 |    let content = await response.text();
31 |    console.log("got container turtle : ",content.length,"\n");
32 |    console.log("got status : ",response.status,response.statusText,"\n");
33 | }
34 | 
35 | 
36 |   
37 | 


--------------------------------------------------------------------------------
/core/src/examineRequest.js:
--------------------------------------------------------------------------------
 1 | import { Url as URL } from "url";
 2 | 
 3 | export function getRequest(uri, options) {
 4 |   const request = normalizeRequestKeys(options);
 5 |   request.headers = normalizeRequestKeys(request.headers);
 6 |   request.method = normalizeRequestMethod(request.method);
 7 |   request.slug = request.headers.slug || request.slug || "";
 8 |   request.body = request.body || "";
 9 | 
10 |   if (!validUrl(uri)) {
11 |     request.url = null;
12 |     request.malFormedUrl = true;
13 |   } else {
14 |     request.url = uri;
15 |     const url = new URL(uri);
16 |     request.protocol = url.protocol;
17 |   }
18 | 
19 |   if (request.url && request.url.endsWith('.dummy')) {
20 |     // rdflib does this !!!
21 |     request.headers["content-type"] = "text/turtle";
22 |     request.body = "";
23 |   }
24 | 
25 |   return request;
26 | }
27 | /* lowercase all request keys e.g. Method -> method
28 | *  lowercase all request.header keys e.g. Content-Type -> content-type
29 | */
30 | 
31 | function normalizeRequestKeys(opts) {
32 |   let newOpts = {};
33 | 
34 |   for (var o in opts) {
35 |     if (o === 'host') {
36 |       newOpts['hostname'] = opts[o]; // express requires this
37 |     } else newOpts[o.toLowerCase()] = opts[o];
38 |   }
39 | 
40 |   return newOpts;
41 | }
42 | 
43 | const validUrl = s => {
44 |   try {
45 |     new URL(s);
46 |     return true;
47 |   } catch (err) {
48 |     return false;
49 |   }
50 | };
51 | /* uppercase all request methods e.g. get -> GET
52 | *  default method = GET
53 | */
54 | 
55 | 
56 | function normalizeRequestMethod(method) {
57 |   return method ? method.toUpperCase() : 'GET';
58 | }
59 | 


--------------------------------------------------------------------------------
/core/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "@solid-rest/core",
 3 |   "version": "2.1.19",
 4 |   "author": "Jeff Zucker",
 5 |   "contributors": [
 6 |     "Alain Bourgeois",
 7 |     "Rahul Gupta"
 8 |   ],
 9 |   "license": "MIT",
10 |   "description": "treat any storage as a mini Solid server",
11 |   "main": "dist/cjs/index.js",
12 |   "module": "dist/esm/index.js",
13 |   "scripts": {
14 |     "build": "npm run build:clean && npm run build:cjs && npm run build:esm && npm run build:umd",
15 |     "build:clean": "rm -rf dist && mkdir dist && mkdir dist/cjs && mkdir dist/esm && mkdir dist/umd",
16 |     "build:cjs": "babel --plugins @babel/plugin-transform-modules-commonjs src --out-dir dist/cjs",
17 |     "build:umd": "babel --plugins @babel/plugin-transform-modules-umd src --out-dir dist/umd",
18 |     "build:esm": "babel src --out-dir dist/esm"
19 |   },
20 |   "repository": {
21 |     "type": "git",
22 |     "url": "git+https://github.com/jeff-zucker/solid-rest.git"
23 |   },
24 |   "keywords": [
25 |     "solid",
26 |     "linked data"
27 |   ],
28 |   "bugs": {
29 |     "url": "https://github.com/jeff-zucker/solid-rest/issues"
30 |   },
31 |   "engines": {
32 |     "node": ">=10.12.0"
33 |   },
34 |   "homepage": "https://github.com/jeff-zucker/solid-rest#readme",
35 |   "dependencies": {
36 |     "cross-fetch": "^4.0.0",
37 |     "uuid": "9.0.1"
38 |   },
39 |   "devDependencies": {
40 |     "@babel/cli": "^7.23.9",
41 |     "@babel/core": "^7.23.9",
42 |     "@babel/plugin-transform-modules-commonjs": "^7.23.3",
43 |     "@babel/plugin-transform-modules-umd": "^7.23.3",
44 |     "babel-preset-es2015": "6.24.1",
45 |     "babel-preset-stage-0": "6.24.1"
46 |   }
47 | }
48 | 


--------------------------------------------------------------------------------
/file/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "@solid-rest/file",
 3 |   "version": "2.1.20",
 4 |   "author": "Jeff Zucker",
 5 |   "license": "MIT",
 6 |   "description": "solid-rest plugin for filesystems",
 7 |   "main": "dist/cjs/index.js",
 8 |   "module": "dist/esm/index.js",
 9 |   "scripts": {
10 |     "build": "rm -rf dist && mkdir dist && mkdir dist/cjs && npm run build:cjs && npm run build:esm",
11 |     "build:cjs": "babel --plugins @babel/plugin-transform-modules-commonjs src --out-dir dist/cjs",
12 |     "build:esm": "babel src --out-dir dist/esm",
13 |     "test": "node tests/all"
14 |   },
15 |   "repository": {
16 |     "type": "git",
17 |     "url": "git+https://github.com/solid/solid-rest.git"
18 |   },
19 |   "keywords": [
20 |     "solid",
21 |     "linked data",
22 |     "file systems"
23 |   ],
24 |   "bugs": {
25 |     "url": "https://github.com/solid/solid-rest/issues"
26 |   },
27 |   "engines": {
28 |     "node": ">=16.0.0"
29 |   },
30 |   "homepage": "https://github.com/solid/solid-rest#readme",
31 |   "dependencies": {
32 |     "@solid-rest/core": "^2.1.19",
33 |     "concat-stream": "^2.0.0",
34 |     "fs-extra": "^9.0.1",
35 |     "mime-types": "^2.1.27",
36 |     "stream": "0.0.2"
37 |   },
38 |   "devDependencies": {
39 |     "@babel/cli": "^7.12.10",
40 |     "@babel/core": "^7.14.6",
41 |     "@babel/plugin-transform-modules-commonjs": "^7.12.1",
42 |     "@solid/eslint-config-base": "^0.1.8",
43 |     "@typescript-eslint/eslint-plugin": "^4.11.1",
44 |     "@typescript-eslint/parser": "^4.11.1",
45 |     "eslint": "^7.16.0",
46 |     "eslint-config-airbnb-base": "^14.2.1",
47 |     "eslint-config-prettier": "^7.1.0",
48 |     "eslint-plugin-import": "^2.22.1",
49 |     "eslint-plugin-jest": "^24.1.3",
50 |     "eslint-plugin-prettier": "^3.3.0",
51 |     "prettier": "^2.2.1",
52 |     "solid-node-client": "^2.1.0"
53 |   }
54 | }
55 | 


--------------------------------------------------------------------------------
/file/tests/rest-methods.js:
--------------------------------------------------------------------------------
 1 | /* =========================================================== */
 2 | /* REST METHODS                                                */
 3 | /* =========================================================== */
 4 | async function GET(url){
 5 |   return await global.client.fetch( url, {method:"GET"} )
 6 | }
 7 | async function HEAD(url){
 8 |   return await global.client.fetch( url, {method:"HEAD"} )
 9 | }
10 | async function EXISTS(url){
11 |   try {
12 |     let res = await global.client.fetch( url, {method:"HEAD"} );
13 |     return res.status==200 ?true :false;
14 |   }
15 |   catch(e){ return false; }
16 | }
17 | async function PUT(url,text,ctype){
18 |   ctype = ctype || 'text/turtle';
19 |   return await global.client.fetch( url, {method:"PUT",body:text,headers:{"content-type":ctype}} )
20 | }
21 | async function PATCH(url, patchContent, patchContentType){
22 |   return await global.client.fetch(url, {
23 |     method: 'PATCH',
24 |     body:patchContent,
25 |     headers:{
26 |       'Content-Type': patchContentType,
27 |       link: '<http://www.w3.org/ns/ldp#Resource>; rel="type"'
28 |     },
29 |     relative: true
30 |   })
31 | } 
32 | async function DELETE(url){
33 |   return await global.client.fetch( url, {method:"DELETE"} )
34 | }
35 | async function POST(parent,item,content,link){
36 |   return await global.client.fetch( parent,{
37 |     method:"POST",
38 |     headers:{slug:item,link:link,"content-type":"text/turtle"},
39 |     body:content
40 |   })
41 | }
42 | async function postFile(parent,file,content){
43 |   let link = '<http://www.w3.org/ns/ldp#Resource>; rel="type"'
44 |   return POST(parent,file,content,link)
45 | }
46 | async function postFolder(parent,folder){
47 |   let link ='<http://www.w3.org/ns/ldp#BasicContainer>; rel="type"'
48 |   return POST(parent,folder,'',link)
49 | }
50 | module.exports = { GET, HEAD, EXISTS, PUT, PATCH, DELETE, POST, postFile, postFolder }
51 | 


--------------------------------------------------------------------------------
/browser/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "@solid-rest/browser",
 3 |   "version": "2.0.0",
 4 |   "author": "Jeff Zucker",
 5 |   "license": "MIT",
 6 |   "description": "solid-rest plugin for browserFS",
 7 |   "main": "dist/cjs/index.js",
 8 |   "module": "dist/esm/index.js",
 9 |   "scripts": {
10 |     "build": "webpack",
11 |     "buildz": "rm -rf dist && mkdir dist && mkdir dist/cjs && npm run build:cjs && npm run build:esm && npm run build:umd",
12 |     "build:cjs": "babel --plugins @babel/plugin-transform-modules-commonjs src --out-dir dist/cjs",
13 |     "build:umd": "babel --plugins @babel/plugin-transform-modules-umd src --out-dir dist/umd",
14 |     "build:esm": "babel src --out-dir dist/esm",
15 |     "test": "node tests/all"
16 |   },
17 |   "repository": {
18 |     "type": "git",
19 |     "url": "git+https://github.com/solid/solid-rest.git"
20 |   },
21 |   "keywords": [
22 |     "solid",
23 |     "linked data",
24 |     "local first"
25 |   ],
26 |   "bugs": {
27 |     "url": "https://github.com/solid/solid-rest/issues"
28 |   },
29 |   "engines": {
30 |     "node": ">=10.12.0"
31 |   },
32 |   "homepage": "https://github.com/solid/solid-rest#readme",
33 |   "dependencies": {
34 |     "mime-types": "^2.1.34",
35 |     "path-browserify": "^1.0.1",
36 |     "uuid": "^8.3.2"
37 |   },
38 |   "devDependencies": {
39 |     "@babel/cli": "^7.12.10",
40 |     "@babel/core": "^7.14.6",
41 |     "@babel/plugin-transform-modules-commonjs": "^7.12.1",
42 |     "@babel/plugin-transform-modules-umd": "^7.12.1",
43 |     "@solid/eslint-config-base": "^0.1.8",
44 |     "@typescript-eslint/eslint-plugin": "^4.11.1",
45 |     "@typescript-eslint/parser": "^4.11.1",
46 |     "eslint": "^7.16.0",
47 |     "eslint-config-airbnb-base": "^14.2.1",
48 |     "eslint-config-prettier": "^7.1.0",
49 |     "eslint-plugin-import": "^2.22.1",
50 |     "eslint-plugin-jest": "^24.1.3",
51 |     "eslint-plugin-prettier": "^3.3.0",
52 |     "prettier": "^2.2.1",
53 |     "webpack": "^5.65.0",
54 |     "webpack-cli": "^4.9.1"
55 |   }
56 | }
57 | 


--------------------------------------------------------------------------------
/tests/browser-test.html:
--------------------------------------------------------------------------------
 1 | <script src="../bundles/browserfs.min.js"></script>
 2 | <script src="../src/browserFS.js"></script>  
 3 | <script src="../dist/browser/solid-rest.js"></script>
 4 | <div id="results"></div>
 5 | <script>
 6 | 
 7 | /* instantiate a rest object with a BrowserFS object
 8 | */
 9 | const rest = new SolidRest([new SolidBrowserFS()])
10 | 
11 | const base = "app://bfs/IndexedDB"
12 | const file = base + "/test-file.ttl"
13 | const text = "<> a <#test>."
14 | runRest( file, text )
15 | 
16 | async function runRest(file,text){
17 |   let response = await rest.fetch( file,{method:"PUT",body:text} )
18 |   response = await rest.fetch( file )
19 |   if(response.status==200 && await response.text()==text) show("OK!")
20 |   else show("FAIL!")
21 | }
22 | function show(msg){
23 |   let display = document.getElementById("results")
24 |   display.innerHTML = display.innerHTML + `<p>${msg}</p>`  
25 | }
26 | /* =========================================================== */
27 | /* REST METHODS                                                */
28 | /* =========================================================== */
29 | async function GET(url){
30 |   return await rest.fetch( url, {method:"GET"} )
31 | }
32 | async function HEAD(url){
33 |   return await rest.fetch( url, {method:"HEAD"} )
34 | }
35 | async function PUT(url,text){
36 |   return await rest.fetch( url, {method:"PUT",body:text,headers:{"content-type":"text/turtle"}} )
37 | }
38 | async function DELETE(url){
39 |   return await rest.fetch( url, {method:"DELETE"} )
40 | }
41 | async function POST(parent,item,content,link){
42 |   return await rest.fetch( parent,{
43 |     method:"POST",
44 |     headers:{slug:item,link:link,"content-type":"text/turtle"},
45 |     body:content
46 |   })
47 | }
48 | async function postFile(parent,file,content){
49 |   let link = '<http://www.w3.org/ns/ldp#Resource>; rel="type"'
50 |   return POST(parent,file,content,link)
51 | }
52 | async function postFolder(parent,folder){
53 |   let link ='<http://www.w3.org/ns/ldp#BasicContainer>; rel="type"'
54 |   return POST(parent,folder,'',link)
55 | }
56 | 
57 | </script>
58 | 
59 | 
60 | 


--------------------------------------------------------------------------------
/browser/examples/authn.html:
--------------------------------------------------------------------------------
 1 | <body>
 2 |     <button id="login">login to test</button>
 3 |     <h3>Testing rdflib load, putBack, and update on browser local storage with authenticated fetch ...</h3>
 4 | 
 5 | <!-- Import browserFS, rdflib, SolidRestBrowser, SolidClientAuthn
 6 | -->
 7 | <script src="https://cdn.jsdelivr.net/npm/browserfs@1.4.3/dist/browserfs.min.js"></script>
 8 | <script src="https://cdn.jsdelivr.net/npm/rdflib@2.2.14/dist/rdflib.min.js">
 9 | </script>
10 | <script src="https://cdn.jsdelivr.net/npm/@inrupt/solid-client-authn-browser@1/dist/solid-client-authn.bundle.js"></script>
11 | <script src="../dist/solid-rest-browser.bundle.js"></script>
12 | 
13 | 
14 | <script type="module">
15 | 
16 | const kb = $rdf.graph();
17 | const updater = new $rdf.UpdateManager(kb)
18 | let fetcher;  
19 | const solidRest = new SolidRestBrowser();
20 | 
21 | async function main(session){
22 |   fetcher = await solidRest.configFetcher(kb,{
23 |     fetch : solidClientAuthentication.getDefaultSession()
24 |   });
25 |   let fn = "/foo/bar/test.ttl";
26 |   await test("browser://LocalStorage"+fn);
27 |   await test("browser://IndexedDB"+fn);
28 |   await test("browser://HTML5FS"+fn);
29 |   await test("https://jeff-zucker.solidcommunity.net/private/test.ttl");
30 | }
31 | async function test(uri){
32 |   const why = $rdf.sym(uri);
33 |   const doc = $rdf.Namespace(uri+"#");
34 |   let ins1 = $rdf.st(doc('It'), doc('isA'), doc('TurtleDoc'), why)
35 |   let ins2 = $rdf.st(doc('This'), doc('isA'), doc('LocalStorageDoc'), why)
36 |   let del = []
37 |   kb.add(ins1);
38 |   await fetcher.putBack(why);
39 |   try { 
40 |     await kb.updater.update(del, ins2);
41 |   }
42 |   catch(e){ console.log(e) }
43 |   await fetcher.load(uri);
44 |   let results = kb.any( doc('This'),doc('isA'),null,why);
45 |   let msg = (results && results.value===doc("LocalStorageDoc").value) ?"ok" :"fail";
46 |   document.body.innerHTML += `
47 |     <p>Testing &lt;${uri}> : ${msg}</p>
48 |   `
49 | }
50 |     const idp = "https://solidcommunity.net";
51 |     const auth = solidClientAuthentication;
52 |     let session;
53 |     document.getElementById('login').onclick = ()=> { 
54 |         auth.login({
55 |             oidcIssuer: idp, 
56 |             redirectUrl: window.location.href,
57 |             clientName: "rdflib test"
58 |         });
59 |     }
60 |     async function handleRedirectAfterLogin() {
61 |         await auth.handleIncomingRedirect();
62 |         session = auth.getDefaultSession();
63 |         if (session.info.isLoggedIn)  main(session);
64 |     }
65 |     handleRedirectAfterLogin();
66 | </script>
67 | 


--------------------------------------------------------------------------------
/core/src/utils/utils.js:
--------------------------------------------------------------------------------
 1 | // import { contentType as contentTypeLookup } from 'mime-types';
 2 | import { v1 as uuidv1 } from 'uuid';
 3 | import * as pod from './createServerlessPod.js';
 4 | const linkExt = ['.acl', '.meta'];
 5 | const linksExt = linkExt.concat('.meta.acl');
 6 | 
 7 | 
 8 | async function createServerlessPod(base) {
 9 |   console.log(`Creating pod at <${base}>`);
10 |   base = base.replace(/\/$/, '');
11 |   base = base.replace(/^[^:]*:\/\//, '');
12 |   await this.perform('FULL_PUT', base + "/.acl", pod.acl_content);
13 |   await this.perform('FULL_PUT', base + "/profile/card", pod.profile_content);
14 |   await this.perform('FULL_PUT', base + "/settings/prefs.ttl", pod.prefs_content);
15 |   await this.perform('FULL_PUT', base + "/settings/privateTypeIndex.ttl", pod.private_content);
16 |   await this.perform('FULL_PUT', base + "/settings/publicTypeIndex.ttl", pod.public_content);
17 |   await this.perform('FULL_PUT', base + "/private/.meta", "");
18 |   await this.perform('FULL_PUT', base + "/.well-known/.meta", "");
19 |   await this.perform('FULL_PUT', base + "/public/.meta", "");
20 |   await this.perform('FULL_PUT', base + "/inbox/.meta", "");
21 | }
22 | 
23 | async function getContentType(path, type) {
24 |   let ext = this.getExtension(path);
25 |   if (!ext || ext === '.ttl' || ext === '.acl' || ext === '.meta' || type === "Container") {
26 |     return 'text/turtle';
27 |   } else {
28 | //    let ctype = contentTypeLookup(ext) || "";
29 |     let ctype = await this.perform('GET_CONTENT_TYPE',path) || "";
30 |     return ctype;
31 |   }
32 | }
33 | 
34 | function isAuxResource(o) {
35 |   return linkExt.find(ext => this.getExtension(o) === ext);
36 |   // return linkExt.find(ext => o.extension === ext);
37 | }
38 | 
39 | async function getAuxResources(pathname) {
40 |   if(pathname.endsWith('.acl')) return [];
41 |   if(pathname.endsWith('.meta')) return [];
42 |   let linksExists = linksExt.filter(async (ext) => await this.perform('ITEM_EXISTS', pathname + ext));
43 |   const links = linksExists.map(ext => pathname + ext);
44 |   return links || [];
45 | }
46 | 
47 | async function generateRandomSlug(pathname, slug = uuidv1()) {
48 |   let requestUrl = this.mungePath(pathname, slug);
49 |   if (this.item.isContainer && !this.request.url.endsWith(this.pathSep)) requestUrl = requestUrl + this.pathSep;
50 | 
51 |   if (await this.perform('ITEM_EXISTS', requestUrl)) {
52 |     slug = `${uuidv1()}-${slug}`;
53 |   }
54 | 
55 |   return this.mungePath(pathname, slug);
56 | }
57 | 
58 | export { createServerlessPod, getContentType, isAuxResource, getAuxResources, generateRandomSlug, linkExt, linksExt };
59 | 


--------------------------------------------------------------------------------
/server/index.js:
--------------------------------------------------------------------------------
 1 | const {SolidNodeClient} = require('solid-node-client');
 2 | const client = new SolidNodeClient();
 3 | const express = require('express');
 4 | const URL = require('url');
 5 | const path = require('path')
 6 | const bodyParser = require('body-parser');
 7 | 
 8 | const app = express();
 9 | app.use(bodyParser.text());
10 | 
11 | const port = process.argv[2] || null;
12 | let docRoot = process.argv[3] || null;
13 | docRootIndex = __dirname
14 | if(!(port && docRoot)) {
15 |   console.log("Syntax: npm run start port documentRoot.");
16 |   console.log("   e.g. npm run start 3000 /home/me.");
17 |   process.exit();
18 | }
19 | 
20 | app.all('*', async (req, res, next) => {
21 |   let filePath = "file://" + docRoot + req.path;
22 |   // if (req.path === '/') return res.redirect(301, 'http://localhost:3000/index.html')
23 |   if (req.path === '/index.html') {
24 |     // req.url = '/index.html'
25 |     filePath = "file://" + docRootIndex + req.path
26 |   } if (req.path.startsWith('/node_modules/mashlib/dist')) {
27 |     filePath = "file://" + docRootIndex + req.path
28 |   }
29 |   // return res.sendFile(path.dirname(require.resolve('./index.html'))+'/index.html')
30 |   try{
31 |     const solidRestRequest = mungeRestRequest(req);
32 |     const solidRestResponse = await client.fetch(filePath,solidRestRequest);
33 |     let content = solidRestResponse.body.toString();
34 |     res = mungeRestResponse(res,solidRestResponse);
35 |     res.send(content);
36 |   }
37 |   catch(e){console.log(e)}
38 |   next()
39 | });
40 | function mungeRestResponse(res,solidRestResponse){
41 |       res.status = solidRestResponse.status;
42 |   res.statusText = solidRestResponse.statusText;
43 |      res.headers = solidRestResponse.headers;
44 |          res.url = solidRestResponse.url;
45 |     res.location = solidRestResponse.location;
46 |     // https://expressjs.com/en/api.html#res.type
47 |     // TODO more types to be tested image, json ....
48 |     const type = res.headers.get('content-type')
49 |     if (type.includes('html')) {
50 |       res.type('html');
51 |     } else if (type.includes('text')) {
52 |       res.type('text');
53 |     } else if (type.includes('json')) {
54 |       res.type('json');
55 |     }
56 |   return res;
57 | }
58 | function mungeRestRequest(req){
59 |   return {
60 |      status : req.status,
61 |      method : req.method,
62 |     headers : req.headers,
63 |         url : 'file://' + docRoot + req.path,
64 |        slug : req.slug,
65 |        body : req.body,
66 |   }
67 | }
68 | 
69 | app.listen(port, () => {
70 |   console.log(`Server is listening at http://localhost:${port}`);
71 | });
72 | 


--------------------------------------------------------------------------------
/core/README.md:
--------------------------------------------------------------------------------
 1 | # Solid REST
 2 | 
 3 | ## treat any storage backend as a minimal Solid server
 4 | 
 5 | <!--
 6 | [![NPM](https://nodei.co/npm/solid-rest.png)](https://nodei.co/npm/solid-rest/)
 7 | -->
 8 | 
 9 | This package provides Solid access to local file systems and other storage spaces. It recieves standard Solid REST requests and returns the same kind of response a Solid server sends.  This means that libraries and apps can make a file:// or app:// request in the same way they make an https request without having to know anything about the backend and without needing a server on the backend.
10 | 
11 | ### Using with rdflib
12 | 
13 | Solid-Rest is included automatically in [rdflib]() when a script is run outside a browser.  This means that commands such as fetcher.load('file:///somepath/container/') will behave, for most purposes just like the same command against an https URI on a Solid server (in this case, create an in-memory parsed version of the container's turtle representation).  
14 | 
15 | ### Using with other libraries
16 | 
17 | Solid-Rest can be used with any other libraries capable of operating either outside a browser or in an express-wrapped browser.  For example, [solid-file-client]() uses solid-rest behind the scenes to support file transfers between local file systems and remote pods.
18 | 
19 | 
20 | ### Backends
21 | 
22 | **file://** - the local file system; works on command-line or in a browser within an electron process
23 | 
24 | **app://ls/** - an in-memory local storage; works on command-line or in a browser within an electron process
25 | 
26 | **app://bfs/** - any of the dozen or so storage mechanisms supported by [BrowserFS](https://github.com/jvilk/BrowserFS) - Dropbox, browser Local Storage, browser indexedDB, browser Native File Api, and more; works in a browser.
27 | 
28 | The file and in-memory storage are initialized automatically with the creation of the rest object.  The BrowserFS backends need to be initialized explicitly.  Please see tests/browser-test.html in the distribution for an example and details.
29 | 
30 | ### Plugins
31 | 
32 | The package supports plugins, so new backends may be added by supplying the storage system specific commands without having to reinvent the wheel of receiving REST requests and responding to them in a Solid manner.  The src/localStorage.js package contains documentation on writing plugins.  Contact me for more info.
33 | 
34 | <img src="https://github.com/jeff-zucker/solid-rest/blob/master/solid-rest.png" alt="diagram of solid-rest">
35 | 
36 | ### Acknowledgements
37 | 
38 | Thanks to [Otto-AA](https://github.com/Otto-AA) and [CxRes](https://github.com/CxRes) for advice and patches.
39 | 
40 | copyright &copy; 2019, 2020, [Jeff Zucker](https://github.com/jeff-zucker), may be freely distributed with the MIT license
41 | 


--------------------------------------------------------------------------------
/core/src/utils/container.js:
--------------------------------------------------------------------------------
 1 | // import libPath from 'path';
 2 | 
 3 | 
 4 | export default async function containerAsTurtle(pathname, contentsArray, typeWanted,self) {
 5 |   const pathSep = self.pathSep;
 6 |   function basename(path) {
 7 |     return path.substr(path.lastIndexOf(self.pathSep) + 1);
 8 |   }
 9 |   let filenames = contentsArray.filter(item => {
10 |     if (item.path && !item.path.endsWith('.acl') && !item.path.endsWith('.meta')) {
11 |       return item;
12 |     }
13 |   });
14 |   if (!pathname.endsWith(pathSep)) pathname += pathSep;
15 |   let str2 = "";
16 |   let str = `
17 | @prefix : <#>.
18 | @prefix ldp: <http://www.w3.org/ns/ldp#>.
19 | @prefix dct: <http://purl.org/dc/terms/>.
20 | @prefix stat: <http://www.w3.org/ns/posix/stat#>.
21 | @prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
22 | 
23 | <> a ldp:BasicContainer, ldp:Container`;
24 | 
25 |   if (filenames.length) {
26 |     str = str + ";\n ldp:contains\n"; // alain
27 | 
28 |     for (var i = 0; i < filenames.length; i++) {
29 |       let fn = filenames[i].path;
30 |       if (typeWanted) fn = "/" + typeWanted + fn;
31 |       fn = encodeURI(fn);
32 |       fn = basename(fn);  // contained resources are relative to folder
33 |       if (filenames[i].isContainer && !fn.endsWith("/")) fn = fn + "/";
34 |       str = str + `  <${fn}>,\n`;
35 |       let ftype = filenames[i].isContainer ? "Container" : "Resource";
36 |       let ctype,size,mtime,modified;
37 |       if(self && self.storage.getMetadata){
38 |         try {
39 |           let i = await self.storage.getMetadata(pathname+"/"+fn);
40 |           ctype = i.contentType
41 |           size = i.size;
42 |           mtime = i.mtime;
43 |           modified = i.modified;
44 |         }
45 |         catch(e){console.log(e)}
46 |       } else if (filenames[i].metadata) {
47 |         size = filenames[i].metadata.size
48 |         mtime = filenames[i].metadata.mtimeMs
49 |         modified = new Date(mtime).toISOString()
50 |       }
51 |       ctype = ctype || await self.getContentType(fn, ftype) || "";
52 |       // REMOVE CHARSET FROM CONTENT-TYPE
53 |       ctype = ctype.replace(/;.*/, '');
54 |       ftype = filenames[i].isContainer ? "ldp:Container; a ldp:BasicContainer; a ldp:Resource" : "ldp:Resource";
55 |       str2 = str2 + `<${fn}> a ${ftype}`;
56 |       if(ctype && !filenames[i].isContainer) // no media-type for Container
57 |         str2 = str2 + `, <http://www.w3.org/ns/iana/media-types/${ctype}#Resource>`; // str2 = str2 + `<${fn}> :type "${ctype}".\n`
58 |       if(size){
59 |         str2 = str2 + `;\n  stat:size ${size};\n  stat:mtime ${mtime};\n  dct:modified "${modified}"^^xsd:dateTime.\n`
60 |       }
61 |     }
62 | 
63 |     str = str.replace(/,\n$/, "");
64 |   }
65 | 
66 |   str = str + `.\n` + str2; // str = _makeStream(str);
67 | 
68 |   return str;
69 | }
70 | 


--------------------------------------------------------------------------------
/tests/shouldFail.js:
--------------------------------------------------------------------------------
 1 | import SolidRest from '../';
 2 | import SolidRestFile from '../plugins/solid-rest-file';
 3 | import SolidRestMem from '../plugins/solid-rest-mem';
 4 | 
 5 | let [tests,fails,passes,res] = [0,0,0]
 6 | let allfails = 0
 7 | 
 8 | let client = getRestClient('file');
 9 | 
10 | const cfg = {
11 |   base    : `file://${process.cwd()}/`,
12 |   folder1 : `test-folder`,
13 |   file1   : `test1.txt`,
14 |   folder2 : `file://${process.cwd()}/test-folder/subFolder/`,
15 |   file2   : `file://${process.cwd()}/test-folder/subFolder/test2.txt`,
16 |   text    : "hello world",
17 | }
18 | 
19 | async function test(){
20 | 
21 | console.log('not found');
22 |   res = await HEAD( 'file:///noshuchthing/' )
23 |   ok( "get 404 on container not found", res.status==404,res)
24 | 
25 |   res = await HEAD( 'file:///noshuchthing.txt' )
26 |   ok( "get 404 on resource not found", res.status==404,res)
27 | 
28 | }
29 | test();
30 | 
31 | function getRestClient(protocol,parser){
32 |   const plugin = protocol.startsWith('file') ? new SolidRestFile()
33 |                : protocol.startsWith('mem')  ? new SolidRestMem()
34 |                : protocol.startsWith('ssh')  ? new SolidRestSsh() : null;
35 |   return new SolidRest({
36 |     plugin : plugin,
37 |     parser : parser,
38 |   });
39 | }
40 | async function GET(url){
41 |   return await client.fetch( url, {method:"GET"} )
42 | }
43 | async function HEAD(url){
44 |   return await client.fetch( url, {method:"HEAD"} )
45 | }
46 | async function PUT(url,text){
47 |   return await client.fetch( url, {method:"PUT",body:text,headers:{"content-type":"text/plain"}} )
48 | }
49 | async function PATCH(url, patchContent, patchContentType){
50 |   return await client.fetch(url, {
51 |     method: 'PATCH',
52 |     body:patchContent,
53 |     headers:{
54 |       'Content-Type': patchContentType,
55 |       link: '<http://www.w3.org/ns/ldp#Resource>; rel="type"'
56 |     },
57 |     relative: true
58 |   })
59 | } 
60 | async function DELETE(url){
61 |   return await client.fetch( url, {method:"DELETE"} )
62 | }
63 | async function POST(parent,item,content,link,ctype){
64 |   return await client.fetch( parent,{
65 |     method:"POST",
66 |     headers:{slug:item,link:link,"content-type":ctype},
67 |     body:content
68 |   })
69 | }
70 | async function postFile(parent,file,content){
71 |   let link = '<http://www.w3.org/ns/ldp#Resource>; rel="type"'
72 |   return POST(parent,file,content,link,'text/plain')
73 | }
74 | async function postFolder(parent,folder){
75 |   let link ='<http://www.w3.org/ns/ldp#BasicContainer>; rel="type"'
76 |   return POST(parent,folder,'',link,"text/turtle")
77 | }
78 | 
79 | /* ============================================== */
80 | 
81 | function ok( label, success,res ){
82 |    tests = tests + 1;   
83 |    if(success) passes = passes + 1
84 |    else fails = fails+1
85 |    let msg = success ? "can " : "CAN NOT "
86 |    console.warn( "  " + msg + label)
87 |    if(!success && res ) console.warn(res.status,res.statusText)
88 |    return success
89 | }
90 | 


--------------------------------------------------------------------------------
/core/src/handleRequest.js:
--------------------------------------------------------------------------------
 1 | const methods = {
 2 |   DELETE: {
 3 |     mustExist: 1,
 4 |     requiresWrite: 1
 5 |   },
 6 |   POST: {
 7 |     mustExist: 1,
 8 |     requiresAppend: 1,
 9 |     requiresContentType: 1
10 |   },
11 |   GET: {
12 |     mustExist: 1,
13 |     requiresRead: 1
14 |   },
15 |   HEAD: {
16 |     mustExist: 1,
17 |     requiresRead: 1
18 |   },
19 |   OPTIONS: {
20 |     requiresRead: 1
21 |   },
22 |   PUT: {
23 |     requiresWrite: 1,
24 |     requiresContentType: 1
25 |   },
26 |   PATCH: {
27 |     requiresWrite: 1,
28 |     requiresContentType: 1
29 |   },
30 |   LOGIN: {
31 |   }
32 | };
33 | export async function handleRequest(uri, originalRequest) {
34 |   const request = this.requestObj = await this.getRequest(uri, originalRequest); //
35 |   const item = this.item = await this.getItem(uri, request); //
36 |   // Errors we find in the request
37 |   if (!request.url || !request.method) return 400;
38 |   if (request.slug.endsWith('/')) return 400;
39 |   if (request.originMismatch) return 403;
40 |   if (request.unsupportedAcceptFormat) return 405;
41 |   if (request.method === 'PATCH' && !this.patch) return 405;
42 |   if (request.method === 'POST' && !request.headers.link) return 400;
43 |   // Errors we find by comparing the request & the itemRequested
44 |   if(item.isContainer && !item.contentType) item.contentType="text/turtle";
45 |   if (item.folderFileConfusion) return 400; // can't have both /foo and /foo/
46 |   if (item.patchOnNonRdf) return 400;
47 | 
48 |   if (item.mode.write) item.mode.append = true;
49 | 
50 |   const method = methods[request.method];
51 |   if (item.isAuxResource) {
52 |     if (item.isAcl) method.requiresControl = true;
53 |     if (request.method === "POST") return 403;
54 |   }
55 |   if (!method) console.log(55,request.method);
56 |   if (!method) return 409;
57 |   if (method.mustExist && !item.exists) return 404;
58 |   if (method.requiresRead && !item.mode.read || method.requiresAppend && !item.mode.append || method.requiresWrite && !item.mode.write || method.requiresControl && !item.mode.control) return 401;
59 | 
60 |   if (method.requiresContentType && !request.headers['content-type']) {
61 | //    console.log(request.method, "No Content Type");
62 |     return 400;
63 |   }
64 | 
65 |   if (request.method === 'POST') {
66 |     this.item.pathname = await this.generateRandomSlug(this.item.pathname, request.slug);
67 |   } //
68 |   // Errors from carrying out the request
69 | 
70 | 
71 |   if (request.method === 'PUT' || request.method==='POST' || request.method === 'PATCH') {
72 |     // if (item.isContainer) return 405;
73 |     let okDir = await this.perform('CREATE_INTERMEDIATE_CONTAINERS');
74 |     if (!okDir) return 500;
75 |   }
76 | 
77 |   let response = await this.perform(request.method);
78 |   if (!response && request.method === 'DELETE' && item.isContainer){
79 |     let stillExists  = await this.perform('ITEM_EXISTS',this.item.pathname);
80 |     if( stillExists ){
81 |       return 409;
82 |     }
83 |   }
84 |   return response;
85 | } // ENDS
86 | 


--------------------------------------------------------------------------------
/core/src/utils/createServerlessPod.js:
--------------------------------------------------------------------------------
 1 | export const profile_content = `@prefix : <#>.
 2 | @prefix jef: <../>.
 3 | @prefix ldp: <http://www.w3.org/ns/ldp#>.
 4 | @prefix inbox: <../inbox/>.
 5 | @prefix pro: <./>.
 6 | @prefix ter: <http://www.w3.org/ns/solid/terms#>.
 7 | @prefix foaf: <http://xmlns.com/foaf/0.1/>.
 8 | @prefix pim: <http://www.w3.org/ns/pim/space#>.
 9 | @prefix n2: <http://>.
10 | @prefix n3: <https://>.
11 | @prefix vcard: <http://www.w3.org/2006/vcard/ns#>.
12 | @prefix sch: <http://schema.org/>.
13 | @prefix n1: <http://www.w3.org/ns/auth/acl#>.
14 | 
15 | pro:card a foaf:PersonalProfileDocument; foaf:maker :me; foaf:primaryTopic :me.
16 | 
17 | :me
18 |     a sch:Person, foaf:Person;
19 |     vcard:fn "Local Solid User";
20 |     vcard:role "software developer";
21 |     n1:trustedApp
22 |             [
23 |                 n1:mode n1:Append, n1:Control, n1:Read, n1:Write;
24 |                 n1:origin <http://example.org>
25 |             ];
26 |     ldp:inbox inbox:;
27 |     pim:preferencesFile <../settings/prefs.ttl>;
28 |     pim:storage jef:;
29 |     ter:account jef:;
30 |     ter:privateTypeIndex <../settings/privateTypeIndex.ttl>;
31 |     ter:publicTypeIndex <../settings/publicTypeIndex.ttl>;
32 |     foaf:name "Local Solid User".
33 | `;
34 | export const prefs_content = `@prefix : <#>.
35 | @prefix solid: <http://www.w3.org/ns/solid/terms#>.
36 | @prefix sp: <http://www.w3.org/ns/pim/space#>.
37 | @prefix dct: <http://purl.org/dc/terms/>.
38 | @prefix c: <../profile/card#>.
39 | @prefix mee: <http://www.w3.org/ns/pim/meeting#>.
40 | 
41 | <> a sp:ConfigurationFile; dct:title "Preferences file".
42 | 
43 | c:me
44 |     a solid:Developer, solid:PowerUser;
45 |     solid:privateTypeIndex <privateTypeIndex.ttl>;
46 |     solid:publicTypeIndex <publicTypeIndex.ttl>.
47 | `;
48 | export const public_content = `@prefix : <#>.
49 | @prefix solid: <https://www.w3.org/ns/solid/terms#>.
50 | @prefix terms: <http://purl.org/dc/terms/>.
51 | @prefix ter: <http://www.w3.org/ns/solid/terms#>.
52 | @prefix bookm: <http://www.w3.org/2002/01/bookmark#>.
53 | 
54 | <> a solid:ListedDocument, solid:TypeIndex; terms:references :Bookmark.
55 | 
56 | :Bookmark
57 |     a ter:TypeRegistration;
58 |     ter:forClass bookm:Bookmark;
59 |     ter:instance <../bookmarks.ttl>.
60 | `;
61 | export const private_content = `
62 | @prefix solid: <https://www.w3.org/ns/solid/terms#>.
63 | <>
64 |     a solid:TypeIndex ;
65 |     a solid:UnlistedDocument.
66 | `;
67 | export const acl_content = `@prefix acl: <http://www.w3.org/ns/auth/acl#>.
68 | @prefix foaf: <http://xmlns.com/foaf/0.1/>.
69 | 
70 | # The homepage is readable by the public
71 | <#public>
72 |     a acl:Authorization;
73 |     acl:agentClass foaf:Agent;
74 |     acl:accessTo <./>;
75 |     acl:mode acl:Read.
76 | 
77 | # The owner has full access to every resource in their pod.
78 | # Other agents have no access rights,
79 | # unless specifically authorized in other .acl resources.
80 | <#owner>
81 |     a acl:Authorization;
82 |     acl:agent <./profile/card#me>;
83 |     # Set the access to the root storage folder itself
84 |     acl:accessTo <./>;
85 |     # All resources will inherit this authorization, by default
86 |     acl:default <./>;
87 |     # The owner has all of the access modes allowed
88 |     acl:mode
89 |         acl:Read, acl:Write, acl:Control.
90 | `;
91 | /* ENDS */


--------------------------------------------------------------------------------
/core/src/examineRequestedItem.js:
--------------------------------------------------------------------------------
  1 | //import libPath from "path";
  2 | import Url from "url";
  3 | var pathHandler;
  4 | 
  5 | export async function getItem(uri, request) {
  6 |   let url, pname;
  7 |   pathHandler = await this.perform('GET_PATH_HANDLER',uri);
  8 | 
  9 |   if (uri.startsWith('file')) {
 10 |     url = Url.format(request.url);
 11 |     pname = Url.fileURLToPath(url);
 12 |   } else {
 13 |     url = decodeURIComponent(uri);
 14 |     pname = Url.parse(url).pathname;
 15 |   }
 16 | 
 17 |   const item = await this.perform('GET_ITEM_INFO', pname, request);
 18 |   item.mode = item.mode ? item.mode : {
 19 |     read: true,
 20 |     append: true,
 21 |     write: true
 22 |   };
 23 |   item.pathname = pname;
 24 | 
 25 |   if (request.method === 'DELETE' && item.isContainer) {
 26 |     let files = await this.perform('GET_FILES', item.pathname);
 27 |     if(!files.filter) item.containedFiles = 0;
 28 |     else {
 29 | // NO, if it has .acl it should be a containedFile
 30 | //      files = files.filter(file => !this.isAuxResource(file));
 31 |       item.containedFiles = files.length;
 32 |     }
 33 |   }
 34 | 
 35 |   this.getExtension = path => {
 36 |     path = path || this.item.pathname || "";
 37 |     if (typeof path === 'object') path = path.path;
 38 |     return path.startsWith('.') && !((path.match(/\./g) || []).length > 1) ? path : pathHandler.extname(path);
 39 |   };
 40 | 
 41 |   this.pathSep = pathHandler.sep;
 42 |   this.basename = pathHandler.extname;
 43 | 
 44 |   this.mungePath = (pathname, slug, options) => {
 45 |     pathname = pathHandler.join(pathname, slug);
 46 |     if (pathname.includes('\\')) pathname = pathname.replace(/\\/g, '/');
 47 |     return pathname;
 48 |   };
 49 | 
 50 |   pname = (request.method==="POST") ?this.mungePath(item.pathname,request.slug) :item.pathname;
 51 |   item.extension = this.getExtension(pname);
 52 |   item.contentType = await this.getContentType(item.pathname);
 53 |   item.patchOnNonTurtle = request.method === 'PATCH' && !item.contentType.match('text/turtle');
 54 |   item.isAcl = pname.match(/\.acl/); // TBD use LinkExt
 55 | 
 56 |   //item.isAuxResource = item.isAcl || this.extension === '.meta';
 57 |   item.isAuxResource = pname.match(/\.(acl|meta)$/) ?true :false;
 58 | 
 59 |   /*
 60 |     let conflict
 61 |     // item is container but file of same name exists
 62 |     if(item.pathname.endsWith('/')){
 63 |       let type = await this.perform('ITEM_TYPE',item.pathname.replace(/\/$/,''))
 64 |       item.folderFileConfusion = type && type==='Resource';
 65 |       return item;
 66 |     }
 67 |     conflict = await this.perform('ITEM_EXISTS',item.pathname+'/')
 68 |     if(!conflict){
 69 |       item.folderFileConfusion = false;
 70 |       return item;
 71 |     }
 72 |     item.folderFileConfusion = true;
 73 |   */
 74 | 
 75 |   return item;
 76 | }
 77 | /*
 78 | reqWithSlash
 79 |   if noSlash exists - fail
 80 |   else is container
 81 | reqNoSlash
 82 |   if method==get and withSlash exists - redirect
 83 |   else if withSlash exists - fail
 84 |   else is file
 85 | */
 86 | 
 87 | /*
 88 | item = {
 89 |   mode: { read: true, write: true, append: true, control: true },
 90 |   exists: true,
 91 |   isContainer: true,
 92 |   pathname: '/home/jeff/Dropbox/Web/solid/solid-rest/2.0.0/test-folder/',
 93 |   containedFiles: 0,
 94 |   extension: '',
 95 |   contentType: 'text/turtle',
 96 |   patchOnNonTurtle: false,
 97 |   isAcl: false,
 98 |   folderFileConfusion: false,
 99 |   isAuxResource: false
100 | }
101 | 
102 | */
103 | 


--------------------------------------------------------------------------------
/core/src/index.js:
--------------------------------------------------------------------------------
  1 | import { getRequest } from './examineRequest.js';
  2 | import { getItem } from './examineRequestedItem.js';
  3 | import { handleRequest } from './handleRequest.js';
  4 | import perform from './performRequestedMethod.js';
  5 | import { handleResponse } from './handleResponse.js';
  6 | import { createServerlessPod, getContentType, isAuxResource, getAuxResources, generateRandomSlug } from './utils/utils.js';
  7 | import containerAsTurtle from './utils/container.js';
  8 | import RestPatch from './utils/rest-patch.js';
  9 | export default class SolidRest {
 10 |   constructor(options) {
 11 |     options = options || {};
 12 | 
 13 |     if (!options.plugin) {
 14 |       console.log(`You must specify a plugin storage handler!`);
 15 |       process.exit(1);
 16 |     }
 17 | 
 18 |     this.storage = options.plugin;
 19 |     this.handleRequest = handleRequest.bind(this);
 20 |     this.handleResponse = handleResponse.bind(this);
 21 |     this.getItem = getItem.bind(this);
 22 |     this.getRequest = getRequest.bind(this);
 23 |     this.perform = perform.bind(this);
 24 |     this.isAuxResource = isAuxResource.bind(this);
 25 |     this.getAuxResources = getAuxResources.bind(this);
 26 |     this.getContentType = getContentType;
 27 |     this.generateRandomSlug = generateRandomSlug.bind(this);
 28 |     this.createServerlessPod = createServerlessPod.bind(this);
 29 |     if(this.storage.configFetcher) this.configFetcher = this.storage.configFetcher.bind(this.storage)
 30 |     if(this.storage.configure) this.configure = this.storage.configure.bind(this.storage)
 31 |     this.containerAsTurtle = containerAsTurtle.bind(this);
 32 |     let $rdf = options.parser ? options.parser : typeof window != "undefined" && window.$rdf ? window.$rdf : typeof global != "undefined" && global.$rdf ? global.$rdf : null;
 33 |     this.patch = options.patch = $rdf ? new RestPatch($rdf) : null;
 34 |   }
 35 | 
 36 |   async fetch(uri, options = {}) {
 37 |     let response = await this.handleRequest(uri, options);
 38 |     return await this.handleResponse(response, options);
 39 |   }
 40 | 
 41 |   async login(options) {
 42 |     options = {loginOptions:options,method:'login'};
 43 |     let response = await this.handleRequest('http://example.org/', options);
 44 |     return await this.handleResponse(response, options );
 45 |   }
 46 | 
 47 |   async itemExists(pathname) {
 48 |     return await this.perform('ITEM_EXISTS', pathname);
 49 |   }
 50 | 
 51 |   isPatchConflictError(response) {
 52 |     if (response === 400) return true;
 53 |   }
 54 | 
 55 |   isAccessError(response) {
 56 |     if (response === 401) return true;
 57 |   }
 58 | 
 59 | /* =========================================================== */
 60 | /* REST METHODS                                                */
 61 | /* =========================================================== */
 62 | async GET(url){
 63 |   return await this.fetch( url, {method:"GET"} )
 64 | }
 65 | async HEAD(url){
 66 |   return await this.fetch( url, {method:"HEAD"} )
 67 | }
 68 | async EXISTS(url){
 69 |   try {
 70 |     let res = await this.fetch( url, {method:"HEAD"} );
 71 |     return res.status==200 ?true :false;
 72 |   }
 73 |   catch(e){ return false; }
 74 | }
 75 | async PUT(url,text,ctype){
 76 |   ctype = ctype || 'text/turtle';
 77 |   return await this.fetch( url, {method:"PUT",body:text,headers:{"content-type":ctype}} )
 78 | }
 79 | async PATCH(url, patchContent, patchContentType){
 80 |   patchContentType = patchContent || "text/n3";
 81 |   return await this.fetch(url, {
 82 |     method: 'PATCH',
 83 |     body:patchContent,
 84 |     headers:{
 85 |       'Content-Type': patchContentType,
 86 |       link: '<http://www.w3.org/ns/ldp#Resource>; rel="type"'
 87 |     },
 88 |     relative: true
 89 |   })
 90 | } 
 91 | async DELETE(url){
 92 |   return await this.fetch( url, {method:"DELETE"} )
 93 | }
 94 | async POST(parent,item,content,link){
 95 |   return await this.fetch( parent,{
 96 |     method:"POST",
 97 |     headers:{slug:item,link:link,"content-type":"text/turtle"},
 98 |     body:content
 99 |   })
100 | }
101 | async postFile(parent,file,content){
102 |   let link = '<http://www.w3.org/ns/ldp#Resource>; rel="type"'
103 |   return POST(parent,file,content,link)
104 | }
105 | async postFolder(parent,folder){
106 |   let link ='<http://www.w3.org/ns/ldp#BasicContainer>; rel="type"'
107 |   return POST(parent,folder,'',link)
108 | }
109 | 
110 | } // THE END
111 | 


--------------------------------------------------------------------------------
/tests/shouldSucceed.js:
--------------------------------------------------------------------------------
  1 | import {SolidRestFile} from '../file';
  2 | let client = new SolidRestFile();
  3 | 
  4 | let [tests,fails,passes,res] = [0,0,0]
  5 | let allfails = 0
  6 | 
  7 | const cfg = {
  8 |   base    : `file://${process.cwd()}/`,
  9 |   folder1 : `test-folder`,
 10 |   file1   : `test1.txt`,
 11 |   folder2 : `file://${process.cwd()}/test-folder/subFolder/`,
 12 |   file2   : `file://${process.cwd()}/test-folder/subFolder/test2.txt`,
 13 |   text    : "hello world",
 14 | }
 15 | 
 16 | async function test(){
 17 | 
 18 | console.log('headers');
 19 |   res = await HEAD( cfg.base )
 20 |   ok( "get content-type header", res.status==200 && res.headers.get('content-type')==='text/turtle',res)
 21 |   ok("get wac-allow header",res.headers.get('wac-allow').match('write'), res)
 22 | 
 23 |   res = await postFolder( cfg.base, cfg.folder1 )
 24 |   cfg.folder1 = cfg.base+cfg.folder1+'/';
 25 |   ok("get location header",cfg.folder1.match(res.headers.get('location')), res)
 26 | 
 27 | console.log('post');
 28 |   ok("post container",res.status==200, res)
 29 | 
 30 |   res = await postFile( cfg.folder1, cfg.file1, cfg.text )
 31 |   ok( "post resource", res.status==200,res)
 32 |   cfg.file1 = cfg.folder1+'/'+cfg.file1;
 33 | 
 34 | 
 35 | console.log('get');
 36 |   res = await GET( cfg.folder1 )
 37 |   ok("get container",res.status==200, res)
 38 | 
 39 | 
 40 |   res = await GET( cfg.file1 )
 41 |   let content = await res.text();
 42 |   ok("get resource",res.status==200 && content===cfg.text, res)
 43 | 
 44 | console.log('put');
 45 |   res = await PUT( cfg.file2, cfg.text )
 46 |   ok( "put resource", res.status==200,res)
 47 | 
 48 | console.log('head');
 49 |   res = await HEAD( cfg.base )
 50 |   ok( "head container", res.status==200 && res.headers.get('content-type')==='text/turtle',res)
 51 | 
 52 |   res = await HEAD( cfg.file1 )
 53 |   ok( "head resource", res.status==200 && res.headers.get('content-type').startsWith('text/plain',res))
 54 | 
 55 | console.log('delete');
 56 |   res = await DELETE( cfg.file1 )
 57 |   res = await DELETE( cfg.file2 )
 58 |   ok( "delete resource", res.status==200,res)
 59 | 
 60 |   res = await DELETE( cfg.folder2 )
 61 |   res = await DELETE( cfg.folder1 )
 62 | 
 63 |   cfg.folder1 = cfg.base+cfg.folder1+'/';
 64 |   res = await GET( cfg.folder1 )
 65 |   ok( "delete container", res.status==404,res)
 66 | 
 67 | }
 68 | test();
 69 | 
 70 | function getRestClient(protocol,parser){
 71 |   const plugin = protocol.startsWith('file') ? new SolidRestFile()
 72 |                : protocol.startsWith('mem')  ? new SolidRestMem()
 73 |                : protocol.startsWith('ssh')  ? new SolidRestSsh() : null;
 74 |   return new SolidRest({
 75 |     plugin : plugin,
 76 |     parser : parser,
 77 |   });
 78 | }
 79 | async function GET(url){
 80 |   return await client.fetch( url, {method:"GET"} )
 81 | }
 82 | async function HEAD(url){
 83 |   return await client.fetch( url, {method:"HEAD"} )
 84 | }
 85 | async function PUT(url,text){
 86 |   return await client.fetch( url, {method:"PUT",body:text,headers:{"content-type":"text/plain"}} )
 87 | }
 88 | async function PATCH(url, patchContent, patchContentType){
 89 |   return await client.fetch(url, {
 90 |     method: 'PATCH',
 91 |     body:patchContent,
 92 |     headers:{
 93 |       'Content-Type': patchContentType,
 94 |       link: '<http://www.w3.org/ns/ldp#Resource>; rel="type"'
 95 |     },
 96 |     relative: true
 97 |   })
 98 | } 
 99 | async function DELETE(url){
100 |   return await client.fetch( url, {method:"DELETE"} )
101 | }
102 | async function POST(parent,item,content,link,ctype){
103 |   return await client.fetch( parent,{
104 |     method:"POST",
105 |     headers:{slug:item,link:link,"content-type":ctype},
106 |     body:content
107 |   })
108 | }
109 | async function postFile(parent,file,content){
110 |   let link = '<http://www.w3.org/ns/ldp#Resource>; rel="type"'
111 |   return POST(parent,file,content,link,'text/plain')
112 | }
113 | async function postFolder(parent,folder){
114 |   let link ='<http://www.w3.org/ns/ldp#BasicContainer>; rel="type"'
115 |   return POST(parent,folder,'',link,"text/turtle")
116 | }
117 | 
118 | /* ============================================== */
119 | 
120 | function ok( label, success,res ){
121 |    tests = tests + 1;   
122 |    if(success) passes = passes + 1
123 |    else fails = fails+1
124 |    let msg = success ? "can " : "CAN NOT "
125 |    console.warn( "  " + msg + label)
126 |    if(!success && res ) console.warn(res.status,res.statusText)
127 |    return success
128 | }
129 | 


--------------------------------------------------------------------------------
/server/index.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html id="docHTML">
  3 | <head>
  4 |   <meta content="text/html; charset=UTF-8" http-equiv="content-type">
  5 |     <link type="text/css" rel="stylesheet" href="./node_modules/mashlib/dist/mash.css" />
  6 |     <script type="text/javascript" src="./node_modules/mashlib/dist/mashlib.js"></script>
  7 |     <script type="module">
  8 | const port = 3000;
  9 | var host = `http://localhost:${port}`;
 10 | 
 11 | window.SolidAppContext = {
 12 |   noAuth : host,
 13 |   webId : host + "/profile/card#me",
 14 |   app : host,
 15 |   webid : host + "/profile/card#me",
 16 |   scroll : 130 // for eyeFocus, should be height of top banner
 17 | }
 18 | /*
 19 | window.$SolidTestEnvironment = {
 20 |   iconBase : "/common/icons/",
 21 |   originalIconBase : "/common/originalIcons/",
 22 | }
 23 | */
 24 | let go; // good advice :-)
 25 | document.addEventListener('DOMContentLoaded', function() {
 26 |     const $rdf = UI.rdf
 27 |     const dom = document
 28 |     $rdf.Fetcher.crossSiteProxyTemplate = self.origin + '/xss?uri={uri}';
 29 |     var uri = window.location.href;
 30 |     window.document.title = 'Data Kitchen: ' + uri;
 31 |     var kb = UI.store;
 32 |     var outliner = panes.getOutliner(dom)
 33 | 
 34 |     function go ( event ) {
 35 |       if( typeof event === "string" ) {
 36 |         uriField.value = event; // call to go() from electron menu;
 37 |       }
 38 |       let uri = $rdf.uri.join(uriField.value, window.location.href)
 39 |       console.log("User field " + uriField.value)
 40 |       console.log("User requests " + uri)
 41 | 
 42 |       const params = new URLSearchParams(location.search)
 43 |       params.set('uri', uri);
 44 |       window.history.replaceState({}, '', `${location.pathname}?${params}`);
 45 | 
 46 |       var subject = kb.sym(uri);
 47 |       // UI.widgets.makeDraggable(icon, subject) // beware many handlers piling up
 48 |       mungeLoginArea(UI.authn.authSession); // no login for no-atuh pages
 49 |       outliner.GotoSubject(subject, true, undefined, true, undefined);
 50 |     }
 51 |     const loginButtonArea = document.getElementById("loginButtonArea");
 52 |     const uriField = dom.getElementById('uriField')
 53 |     const goButton = dom.getElementById('goButton')
 54 |     const webIdArea = dom.getElementById('webId')
 55 |     const banner = dom.getElementById('inputArea')
 56 | 
 57 |     mungeLoginArea();
 58 |     if(window.ipcRenderer) window.ipcRenderer.init(go); // electron communication
 59 | 
 60 |     function mungeLoginArea(){
 61 |       loginButtonArea.innerHTML="";
 62 |       loginButtonArea.appendChild(UI.login.loginStatusBox(document, null, {}))
 63 |       if( uriField.value.startsWith(host) ){
 64 |         loginButtonArea.style.display="none";
 65 |         webIdArea.innerHTML = "Local Data-Kitchen User";
 66 |         banner.style.backgroundColor="#bbbbcc";
 67 |       }
 68 |       else {
 69 |         if(UI.authn.authSession && UI.authn.authSession.info.isLoggedIn){
 70 |            const logoutButton = loginButtonArea.querySelector('input');
 71 |            logoutButton.value = "Logout";
 72 |            let displayId = UI.authn.authSession.info.webId.replace(/https:\/\//,'').replace(/\/profile\/card#me/,'');
 73 |            webIdArea.innerHTML = displayId;
 74 |            banner.style.backgroundColor="#bbccbb";
 75 |         }
 76 |         else {
 77 |            banner.style.backgroundColor="#ccbbbb";
 78 |         }
 79 |         loginButtonArea.style.display="inline-block";
 80 |       }
 81 |     }
 82 | 
 83 |     uriField.addEventListener('keyup', function (e) {
 84 |       if (e.keyCode === 13) {
 85 |         go(e)
 86 |       }
 87 |     }, false)
 88 | 
 89 |     goButton.addEventListener('click', go, false);
 90 |     let initial = new URLSearchParams(self.location.search).get("uri") || host + "/";
 91 |     if (initial) {
 92 |       uriField.value = initial
 93 |       go()
 94 |     } else {
 95 |       console.log('ready for user input')
 96 |     }
 97 | 
 98 | if( UI.authn.authSession ) {
 99 |     UI.authn.authSession.onLogin(() => {
100 |       mungeLoginArea();
101 |       go()
102 |     })
103 |     UI.authn.authSession.onLogout(() => {
104 |       document.cookie = "nssidp.sid=;expires=Thu, 01 Jan 1970 00:00:00 GMT";
105 |       mungeLoginArea();
106 |       webIdArea.innerHTML = "Local Data-Kitchen User";
107 |       go()
108 |     })
109 |     UI.authn.authSession.onSessionRestore((url) => {
110 |       mungeLoginArea();
111 |       go()
112 |     })
113 | }
114 | });
115 | </script>
116 | </head>
117 | <body>
118 |   <table style="width:100%;" id="inputArea">
119 |     <tr>
120 |       <td style="text-align:right;">Visiting&nbsp;</td>
121 |       <td>
122 |         <div>
123 |           <input id="uriField" type="text" style="font-size:100%; min-width:25em; padding:0.5em;"/>
124 |           <input type="button" id="goButton" value="Go" />
125 |         </div>
126 |       </td>
127 |     </tr>
128 |     <tr>
129 |       <td style="text-align:right;">As&nbsp;</td>
130 |       <td><div style="margin-top:0.5em;margin-bottom:0.5em;"><span id="webId" style="font-weight:bold">Local Data-Kitchen User </span> <span id="loginButtonArea"></span>
131 | </div></td>
132 |     </tr>
133 |   </table>
134 |   <table style="width:100%;">
135 |     <tr>
136 |       <div class="TabulatorOutline" id="DummyUUID" role="main">
137 |           <table id="outline"></table>
138 |           <div id="GlobalDashboard"></div>
139 |       </div>
140 |     </tr>
141 |   </table>
142 | </body>
143 | </html>
144 | 


--------------------------------------------------------------------------------
/core/src/utils/rest-patch.js:
--------------------------------------------------------------------------------
  1 | let $rdf; //import crypto from 'crypto' TODO may be
  2 | 
  3 | const PATCH_NS = 'http://www.w3.org/ns/solid/terms#';
  4 | const PREFIXES = `PREFIX solid: <${PATCH_NS}>\n`;
  5 | const PATCH_PARSERS = {
  6 |   'application/sparql-update': parsePatchSparql,
  7 |   'text/n3': parsePatchN3
  8 | };
  9 | 
 10 | export default class RestPatch {
 11 | 
 12 |   constructor(passedRDF) {
 13 |     $rdf = passedRDF;
 14 |   }
 15 | 
 16 |   async patchContent(content, contentType, request) {
 17 |     const url = request.url;
 18 |     const resource = {
 19 |       contentType: contentType,
 20 |       url: url
 21 |     };
 22 |     const patch = {
 23 |       text: request.body.toString(),
 24 |       contentType: request.headers['content-type']
 25 |     };
 26 |     const parsePatch = PATCH_PARSERS[patch.contentType];
 27 |     if (!parsePatch) {
 28 |       return[415,`415 Unsupported patch content type: ${patch.contentType}`];
 29 |     }
 30 |     // Parse the patch document and verify permissions
 31 |     const patchUri = `${url}#patch`;
 32 |     try {
 33 |       const patchObject = await parsePatch(url, patchUri, patch.text);
 34 |       const graph = await this.readGraph(content, resource);
 35 |       /* rdf.sparqlUpdateParser accepts multiple INSERT statements
 36 |          but only applies the last one;  so gives a false 200;
 37 |          I trap it here with kldugy regex; TBD - better solution (Jeff)
 38 |       */
 39 |       let insertStmts = patch.text.match(/INSERT/g);
 40 |       if(insertStmts && insertStmts.length>1)
 41 |         return [400,"can not have multiple INSERT statements in a patch"];
 42 | 
 43 |       await this.applyPatch(patchObject, graph, url);
 44 |       const newContent = await this.writeGraph(graph, resource);
 45 |       return [200, newContent];
 46 |     } catch (e) {
 47 |       return [parseInt(e.message), e.message];
 48 |     }
 49 |   } 
 50 | 
 51 |   // PARSE ORIGINAL DOCUMENT
 52 |   //
 53 |   async readGraph(fileContents, resource) {
 54 |     const graph = $rdf.graph();
 55 |     if(!fileContents.length) return graph;
 56 |     try {
 57 |       $rdf.parse(fileContents, graph, resource.url, resource.contentType);
 58 |     } catch (err) {
 59 |      throw new Error(`500 : Patch: Target ${resource.contentType} file syntax error: ${err}`)  
 60 |     }
 61 |     return graph;
 62 |   } 
 63 | 
 64 |   // APPLY PATCH
 65 |   //
 66 |   async applyPatch(patchObject, graph, url) {
 67 |     return new Promise((resolve, reject) => graph.applyPatch(patchObject, graph.sym(url), err => {
 68 |       if (err) {
 69 |         const message = err.message || err; // returns string at the moment
 70 |         return reject(new Error(`409 : The patch could not be applied. ${message}`)) // is this correct : not tested
 71 |       }
 72 | 
 73 |       resolve(graph);
 74 |     }));
 75 |   } 
 76 | 
 77 |   // serialize graph to turtle
 78 |   async writeGraph(graph, resource) {
 79 |     const resourceSym = graph.sym(resource.url);
 80 |     try {
 81 |       const serialized = $rdf.serialize(resourceSym, graph, resource.url, resource.contentType)
 82 |       return serialized;
 83 |     }
 84 |     catch(e){console.log(e)}
 85 |   }
 86 |   // Creates a hash of the given text
 87 |   hash(text) {
 88 |     return crypto.createHash('md5').update(text).digest('hex');
 89 |   }
 90 | 
 91 | } // END OF CLASS RestPatch
 92 | 
 93 | // PARSE SPARQL
 94 | //
 95 |   async function parsePatchSparql(targetURI, patchURI, patchText) {
 96 |     const baseURI = patchURI.replace(/#.*/, '');
 97 |     try {
 98 |       return $rdf.sparqlUpdateParser(patchText, $rdf.graph(), baseURI);
 99 |     } catch (err) {
100 |      throw new Error(`400 : Patch document syntax error: ${err}`) 
101 |     }
102 |   }
103 | 
104 | // PARSE N3
105 | //
106 |   async function parsePatchN3(targetURI, patchURI, patchText) {
107 |     const patchGraph = $rdf.graph();
108 |     try {
109 |       $rdf.parse(patchText, patchGraph, patchURI, 'text/n3');
110 |     } catch (err) {
111 |       throw new Error(`400 : Patch document syntax error: ${err}`);
112 |     }
113 |     let firstResult;
114 |     try {
115 |       firstResult = await queryForFirstResult(patchGraph, `${PREFIXES}
116 |       SELECT ?insert ?delete ?where WHERE {
117 |         ?patch a solid:InsertDeletePatch.
118 |         OPTIONAL { ?patch solid:inserts ?insert. }
119 |         OPTIONAL { ?patch solid:deletes ?delete. }
120 |         OPTIONAL { ?patch solid:where   ?where.  }
121 |       }`);
122 |     } catch (err) {
123 |       try {
124 |         firstResult = await queryForFirstResult(patchGraph, `${PREFIXES}
125 |         SELECT ?insert ?delete ?where WHERE {
126 |           ?patch solid:patches <${targetURI}>.
127 |           OPTIONAL { ?patch solid:inserts ?insert. }
128 |           OPTIONAL { ?patch solid:deletes ?delete. }
129 |           OPTIONAL { ?patch solid:where   ?where.  }
130 |         }`);
131 |       } catch (err) {
132 |         throw new Error(`400 : No patch for ${targetURI} found. ${err}`) 
133 |       }
134 |     }
135 |     const {
136 |       '?insert': insert,
137 |       '?delete': deleted,
138 |       '?where': where
139 |     } = firstResult;
140 |     if (!insert && !deleted) {
141 |       return[400, 'Patch should at least contain inserts or deletes.']; 
142 | //      throw error(400, 'Patch should at least contain inserts or deletes.') 
143 |     }
144 |     return {
145 |       insert,
146 |       delete: deleted,
147 |       where
148 |     };
149 |   }
150 | 
151 | // EXECUTE FIRST SPARQL QUERY IN STORE & RETURN RESULTS
152 | //
153 |   function queryForFirstResult(store, sparql) {
154 |     return new Promise((resolve, reject) => {
155 |       const query = $rdf.SPARQLToQuery(sparql, false, store);
156 |       store.query(query,resolve,null,() => { return ['409 : No results.']});
157 |       // TODO check status
158 |     });
159 |   }
160 | 


--------------------------------------------------------------------------------
/core/src/performRequestedMethod.js:
--------------------------------------------------------------------------------
  1 | 
  2 | export default async function perform(method, pathname, content, ctype) {
  3 |   this.request = this.requestObj;
  4 |   method = method || this.request.method;
  5 |   this.item = this.item || {
  6 |     pathname: pathname
  7 |   };
  8 |   pathname = pathname || this.item.pathname;
  9 |   let res,fn;
 10 |   this.response = this.response || {
 11 |     headers: {}
 12 |   };
 13 | 
 14 |   switch (method) {
 15 |     case 'STORAGE_NAME':
 16 |       return this.storage.name;
 17 |       break;
 18 | 
 19 |     case 'ITEM_EXISTS':
 20 |       pathname = pathname.replace('file://', '');
 21 |       return await this.storage.itemExists(pathname);
 22 |       break;
 23 | 
 24 |     case 'LOGIN':
 25 |       return await this.storage.login(this.request.loginoptions);
 26 |       break;
 27 | 
 28 |     case 'ITEM_TYPE':
 29 |       // Container/Resource
 30 |       return await this.storage.itemType(pathname);
 31 |       break;
 32 | 
 33 |     case 'GET_CONTENT_TYPE':
 34 |       return await this.storage.getContentType(pathname)
 35 | //      return await this.storage.getContentType(pathname).bind(this.storage);
 36 |       break;
 37 | 
 38 |     case 'GET_PATH_HANDLER':
 39 |       return await this.storage.getPathHandler(pathname);
 40 |       break;
 41 | 
 42 |     case 'GET_ITEM_INFO':
 43 |       return await this.storage.getItemInfo(pathname,this.request);
 44 |       break;
 45 | 
 46 |     case 'GET_FILES':
 47 |       return await this.storage.getContainer(pathname);
 48 |       break;
 49 | 
 50 |     case 'DELETE':
 51 |       if (this.item.isContainer){
 52 |         await this.perform('DELETE_AUX_RESOURCES',pathname)
 53 |         return await this.storage.deleteContainer(pathname);
 54 |       }
 55 |       else {
 56 |         await this.perform('DELETE_AUX_RESOURCES',pathname)
 57 |         return await this.storage.deleteResource(pathname);
 58 |       }
 59 |       break;
 60 | 
 61 |     case 'DELETE_AUX_RESOURCES':
 62 |       const links = (await this.getAuxResources(pathname)) || [];
 63 |       try {
 64 |         links.map(async link => {
 65 |           res = await this.storage.deleteResource(link);
 66 |         });
 67 |         return true;
 68 |       } catch (e) {
 69 |         console.log(e);
 70 |         return false;
 71 |       }
 72 |       return 200;
 73 |       break;
 74 | 
 75 |     case 'CREATE_INTERMEDIATE_CONTAINERS':
 76 |       return await this.storage.makeContainers(pathname) || 1;
 77 |       break;
 78 | 
 79 |     case 'GET':
 80 |       if (this.item.isContainer) {
 81 |         let files = await this.storage.getContainer(pathname);
 82 | 
 83 |         if (files.headers) {
 84 |           return files;
 85 |         }
 86 | 
 87 |         return await this.containerAsTurtle(pathname, files, this.request.typewanted,this);
 88 |       } else {
 89 |         let thing = await this.storage.getResource(pathname);
 90 |         if (!thing) return false;
 91 | 
 92 |         if (thing.headers) {
 93 |           return thing;
 94 |         }
 95 | 
 96 |         this.response.body = thing;
 97 |         this.response.headers.status = 200;
 98 |         return true;
 99 |       }
100 | 
101 |       break;
102 | 
103 |     case 'OPTIONS':
104 |     case 'HEAD':
105 |       return true;
106 |       break;
107 | 
108 |     case 'PUT':
109 |       content = content || this.request.body;
110 |       ctype = ctype || this.item.contentType || ""; // console.log('content for put',content);
111 |       let x = await this.storage.putResource(pathname, content, ctype); // console.log('response from put',x);
112 | 
113 |       return x;
114 |       return await this.storage.putResource(pathname, content, ctype);
115 |       break;
116 | 
117 |     case 'FULL_PUT':
118 |       let success = await this.storage.makeContainers(pathname);
119 |       if (!success) return false;
120 |       if (typeof content === "undefined") content = this.request.body;
121 |       ctype = ctype || this.item.contentType || "";
122 |       return await this.storage.putResource(pathname, content, ctype);
123 |       break;
124 | 
125 |     case 'POST':
126 |       if (this.request.headers.link.match("Container")) {
127 | //        this.response.headers.location = pathname.replace(/.*\//,'') + '/';
128 |         this.response.headers.location = pathname + '/';
129 |         return await this.storage.postContainer(pathname, this.request);
130 |       } else {
131 | //        this.response.headers.location = pathname.replace(/.*\//,'');
132 |         this.response.headers.location = pathname;
133 | 
134 |         return await this.storage.putResource(pathname, this.request.body);
135 |       }
136 | 
137 |       break;
138 | 
139 |     case 'PATCH':
140 |       const contentType = this.item.contentType;
141 |       if(!contentType.match(/(text\/turtle|text\/n3|application\/ld\+json|application\/rdf\+xml)/)) return( {
142 |             status: 409,
143 |             body: "can not patch a file of type "+contentType
144 |       });
145 |       if(pathname.endsWith('/')) return( {
146 |             status: 409,
147 |             body: "can not patch a Container"
148 |       });
149 |       let exists=await this.storage.itemExists(pathname.replace('file://',''));
150 |       if( !exists ) await this.perform('FULL_PUT', pathname, "", ctype);
151 | ;
152 |       // 415 patchOnNonTurtle is handled already in handleRequest.js
153 |       let oldContent = await this.storage.getResource(pathname);
154 |       oldContent = oldContent && oldContent.body ? oldContent.body : oldContent;
155 | //      if (!oldContent) return false;
156 |       oldContent = typeof oldContent === 'string' ? oldContent : oldContent.toString();
157 |       let newContent,patchStatus;
158 |       try {
159 |         [patchStatus, newContent] = await this.patch.patchContent(oldContent, contentType, this.request);
160 |         if (patchStatus !== 200) {
161 |           return {
162 |             status: patchStatus,
163 |             body: newContent
164 |           };
165 |         }
166 |       } catch (e) {
167 |         if(!e.length) e = "";
168 |         return {
169 |           status: e,
170 |           statusText: e.toString()
171 |         };
172 |       }
173 | //      const status = await this.storage.makeContainers(pathname);
174 | 
175 | //      if (!status) return false;
176 | //      let putStatus = await this.storage.putResource(pathname, this.request.bod);
177 |       let putStatus = await this.storage.putResource(pathname, newContent);
178 |       putStatus = putStatus && putStatus.body ? putStatus.body : putStatus;
179 |       return putStatus;
180 |       break;
181 |   }
182 | } // ENDS
183 | 


--------------------------------------------------------------------------------
/mem/src/index.js:
--------------------------------------------------------------------------------
  1 | /* 
  2 |    constructor should define the pacakage's name 
  3 |    by default this will be added to the x-powered-by header of all responses
  4 | */
  5 | class SolidMemStorage {
  6 |   constructor() {
  7 |     this.prefix = "mem"
  8 |     this.name = "solid-rest-mem-1.0.0"
  9 |     localStorage.setItem( "/", " " );
 10 |   }
 11 | 
 12 | /*
 13 |    getObjectType(pathname,options)
 14 |      * trys to find pathname in storage
 15 |      * if found, sets exists to true
 16 |      * sets type to "Container" or "Resource" or undefined
 17 |      * returns an array [type,exists]
 18 | */
 19 | async getObjectType(pathname,options){
 20 |   let type = (pathname.match(/\/$/)) ? "Container" : "Resource";
 21 |   pathname = pathname.replace(/\/$/,'') // REMOVE TRAILING SLASH
 22 |   let exists = false
 23 |   let keys = Object.keys(localStorage)
 24 |   for(var k in keys) {
 25 |     let item = keys[k]
 26 |     if(type==="Container" && item.startsWith(pathname)){ exists=true; break }
 27 |     if(item === pathname){ exists=true; break }
 28 |   }
 29 |   let mode = {read:true,write:true,append:true}
 30 |   let item = {
 31 |     pathname : pathname,
 32 |     mode : mode,
 33 |     exists : exists,
 34 |     isContainer : type==="Containter",
 35 |   }
 36 |   return [type,exists,mode,item] 
 37 | }
 38 | 
 39 | /*
 40 |   getResource(pathname,options)
 41 |     * gets a resource
 42 |     * on success, returns [ 200, resourceContents, optionalHeader ]
 43 |     * on failure, returns [ 500, undefined, optionalHeader ]
 44 | */
 45 | async getResource(pathname,options){
 46 |   try { 
 47 |     let body = localStorage.getItem( pathname );
 48 |     return Promise.resolve( [ 200, body ] )
 49 |   }
 50 |   catch(e){ Promise.resolve( [500] ) }
 51 | }
 52 | 
 53 | /*
 54 |   getContainer(pathname,options)
 55 |     * returns an array of the container's contained resource names
 56 |     * OR returns a turtle representation of the container and contents
 57 | */
 58 | async getContainer(pathname,options) {
 59 |   const files = Object.keys(localStorage)
 60 |     .filter(path => path.startsWith(pathname) && path != pathname) // Only children
 61 |     .map(path => path.substr(pathname.length))
 62 |     .filter(path => !path.slice(0, -1).includes("/")) // Only include direct children
 63 |     return files
 64 | }
 65 | 
 66 | dump(pathname,options) {
 67 |   let keys = Object.keys(localStorage).filter(k=>{
 68 |     if(!k.match(/(setItem|getItem|removeItem)/)) return k
 69 |   }).map(m=>{
 70 |     console.log( m, localStorage.getItem(m) )
 71 |   })
 72 | }
 73 | clear() {
 74 |   let keys = Object.keys(localStorage).filter(k=>{
 75 |     if(!k.match(/(setItem|getItem|removeItem)/)) return k
 76 |   }).map(item=>{
 77 |     this.deleteResource(item)
 78 |   })
 79 | }
 80 | 
 81 | /*
 82 |    putResource(pathname,options)
 83 |      * creates a single Resource
 84 |      * on success : status = 201
 85 |      * on error : status = 500
 86 |      * returns [status,undefined,optionalHeader]
 87 | */
 88 | async putResource(pathname,options){
 89 |   options = options || {};
 90 |   options.body = options.body || "";
 91 |   try { 
 92 |     localStorage.setItem( pathname, options.body );
 93 |     return Promise.resolve( [201] )
 94 |   }
 95 |   catch(e){ console.log(e); return Promise.resolve( [500] ) }
 96 | }
 97 | 
 98 | /*
 99 |    postContainer(pathname,options)
100 |       * creates a single Container
101 |       * on success : status = 201
102 |       * on error : status = 500
103 |       * returns [status,undefined,optionalHeader]
104 | */
105 | async postContainer(pathname,options){
106 |   pathname = pathname + '/'     // because wasn't on slug
107 |   return this.putResource(pathname,options)
108 | }
109 | 
110 | /**
111 |  * deleteResource(pathname, options)
112 |     * on success, returns [200,undefined,optionalHeader]
113 |     * on failure, returns [500,undefined,optionalHeader]
114 |  */
115 | async deleteResource(pathname,options){
116 |   try {
117 |     localStorage.removeItem(pathname)
118 |     return Promise.resolve( [200] )
119 |   }
120 |   catch(e){ return Promise.resolve( [500] ) }    
121 | }
122 | 
123 | /**
124 |  * deleteContrainer(pathname, options)
125 |     * on success, returns [200,undefined,optionalHeader]
126 |     * on failure, returns [500,undefined,optionalHeader]
127 |  */
128 | async deleteContainer (pathname, options) {
129 |   return await this.deleteResource(pathname, options)
130 | }
131 | 
132 | async makeContainers(pathname,options){
133 |   const inexistentParents = []
134 | 
135 |   // Get all parents which need to be created
136 |   let curParent = getParent(pathname)
137 |   while (curParent && !(await this.getObjectType(curParent))[1]) {
138 |     inexistentParents.push(curParent)
139 |     curParent = getParent(curParent)
140 |   }
141 |   if (!curParent) // Should not happen, that we get to the root
142 |     return [500]
143 | 
144 |   // Create missing parents
145 |   while (inexistentParents.length) {
146 |     // postContainer expects an url without '/' at the end
147 |     await this.postContainer(inexistentParents.pop().slice(0, -1))
148 |   }
149 |   return [201]
150 | }
151 | }
152 | 
153 | /**
154 |  * return parent url with / at the end.
155 |  * If no parent exists return null
156 |  * @param {string} url 
157 |  * @returns {string|null}
158 |  */
159 | function getParent(url) {
160 |   while (url.endsWith('/'))
161 |     url = url.slice(0, -1)
162 |   if (!url.includes('/'))
163 |     return null
164 |   return url.substring(0, url.lastIndexOf('/')) + '/'
165 | }
166 | 
167 | /* 
168 |   OPTIONAL METHODS
169 | 
170 |   see solid-rest.js code for examples of the defaults
171 |   optionally provide your own to replace or augment the behavior
172 | 
173 |    text(stream)
174 |      * response method to pipe text body
175 |      * receives response body, returns piped string
176 |    json(string)
177 |      * response method to parse json body
178 |      * receives response body returns a json object
179 |    container2turtle(pathname,options,contentsArray)
180 |      * iterates over container's contents, creates a turtle representation
181 |      * returns [200, turtleContents, optionalHeader]
182 |    getHeaders(pathname,options)
183 |      * returns header fields to replace or augment default headers
184 | */
185 | 
186 | /*
187 |   if it should work in nodejs, export the object
188 | */
189 | if(typeof window==="undefined") {
190 |   alert = (msg) => console.log(msg)
191 |   localStorage = {
192 |      getItem    : (key) => { return localStorage[key] },
193 |      removeItem : (key) => { delete localStorage[key] },
194 |      setItem    : (key,val) => { localStorage[key]=val },
195 |   }
196 |   module.exports = SolidMemStorage
197 | }
198 | 


--------------------------------------------------------------------------------
/dropbox/src/index.js:
--------------------------------------------------------------------------------
  1 | import {Dropbox} from "dropbox";
  2 | //import SolidRest from "@solid-rest/core";
  3 | import SolidRest from "../../../core";
  4 | 
  5 | export class SolidRestDropbox {
  6 | 
  7 |   /**
  8 |    * Dropbox backend for Solid-Rest
  9 |    * @constructor
 10 |    * @return {prefix:"dropbox",name:"solid-rest-dropbox-version"}
 11 |    */
 12 |   constructor() {
 13 |     this.prefix = "dropbox"
 14 |     this.name = "solid-rest-dropbox-1.0.0"
 15 |     return new SolidRest({
 16 |       plugin: this
 17 |     });
 18 |   }
 19 | 
 20 |   /**
 21 |    * login to Dropbox.com
 22 |    * @param accessToken // get one in browser from Dropbox
 23 |    * @return true or error object
 24 |    */
 25 |   async login(options){
 26 |     try {
 27 |       this.dbx = new Dropbox({ accessToken: options.access_token });
 28 |       return true;
 29 |     }
 30 |     catch(e){ 
 31 |       console.log("Dropbox login error : ",e.status)
 32 |       return { headers: {
 33 |         status:e.status,
 34 |         statusText:e.error,
 35 |       }}; 
 36 |     }
 37 |   }
 38 |   
 39 |   /**
 40 |    * examine a requested item
 41 |    * @param filePath, request object
 42 |    * @return item object
 43 |    */
 44 |   async  getItemInfo(fn,request){
 45 |     try {
 46 |       fn = fn.replace( /^dropbox:\/\/\//,'')
 47 |       if( fn.endsWith('/') ) return( {
 48 |         path : fn,
 49 |         exists : true,
 50 |         name : fn,
 51 |         isContainer : true,
 52 |         mode : { read:1,write:0,append:0,control:0 }
 53 |       });
 54 |       let info = await this.dbx.filesGetMetadata({ path:fn });
 55 |       let item = {
 56 |         path : info.path_lower,
 57 |         name : info.name,
 58 |         exists : true,
 59 |         isContainer : info['.tag']==='folder' ? true : false,
 60 |         mode : { read:1,write:0,append:0,control:0 }
 61 |       };
 62 |       return( item )
 63 |     }
 64 |     catch(e){ 
 65 |       console.log("Dropbox getItemInfo error : ",e.status,e.statusText)
 66 |       return { headers: {
 67 |         status:e.status||500,
 68 |         statusText:e.error,
 69 |       }}; 
 70 |     }
 71 |   }
 72 | 
 73 |   /**
 74 |    * read a folder
 75 |    * @param filePath
 76 |    * @return on success : folder contents with fields path, name, isContainer
 77 |    * @return on failure : false
 78 |    */
 79 |   async getContainer(path) {
 80 |     try {
 81 |       path = path.replace( /^dropbox:\/\/\//,'')
 82 |       path = path==="/" ?"" :path;
 83 |       let container = [];
 84 |       let folder = await this.dbx.filesListFolder({path:path});
 85 |       for(var f of folder.result.entries){
 86 |         let info = await this.dbx.filesGetMetadata({
 87 |           path : f.path_lower,
 88 |         });
 89 |         container.push({
 90 |           path : f.path_lower,
 91 |           name : f.name,
 92 |           isContainer : f['.tag']==='folder' ? true : false,
 93 |         });
 94 |       }
 95 |       return container;
 96 |     }
 97 |     catch(e){ 
 98 |       console.log("Dropbox getContainer error : ",path,e.status)
 99 |       return { headers: {
100 |         status:e.status,
101 |         statusText:e.error,
102 |       }}; 
103 |     }
104 |   }
105 | 
106 |   /**
107 |    * read a file
108 |    * @param filePath
109 |    * @return on success : body | Response object
110 |    * @return on failure false  | Response object
111 |    */
112 |   async getResource(pathname){
113 |     if( pathname.endsWith('/') ) return getContainer(pathname);
114 |     try{
115 |        let bodyData = await this.dbx.filesDownload({path:pathname})
116 |        return bodyData.result.fileBinary;
117 |     }
118 |     catch(e){ 
119 |       console.log("Dropbox getResource error : ",e.status)
120 |       return { headers: {
121 |         status:e.status,
122 |         statusText:e.error,
123 |       }}; 
124 |     }
125 |   }
126 | 
127 |   /**
128 |    * write a file
129 |    * @param filePath
130 |    * @param content
131 |    * @param content-type
132 |    * @return on success : 200 if pre-existed, 201 otherwise
133 |    * @return on failure false
134 |    */
135 |   async putResource(pathname, content, ctype) {
136 |     try {
137 |       await this.dbx.filesUpload({
138 |         path:pathname,
139 |         content:content,
140 |       });
141 |     }
142 |     catch(e){ 
143 |       console.log("Dropbox putResource error : ",e.status)
144 |       return { headers: {
145 |         status:e.status,
146 |         statusText:e.error,
147 |       }}; 
148 |     }
149 |   }
150 | 
151 |   /**
152 |    * create folder
153 |    * @param filePath
154 |    * @return true on success, false on failure
155 |    */
156 |   async postContainer(fn) {
157 |     fn = fn.replace(/\/$/, '');
158 |     try {
159 |       await this.dbx.filesCreateFolderV2({path:fn});
160 |     }
161 |     catch(e){ 
162 |       console.log("Dropbox postContainer error : ",e.status)
163 |       return { headers: {
164 |         status:e.status,
165 |         statusText:e.error,
166 |       }}; 
167 |     }
168 |   }
169 | 
170 |   /**
171 |    * create parent and intermediate folders
172 |    * @param filePath
173 |    * @return true on success, false on failure
174 |    */
175 |   async makeContainers(pathname) {
176 |     const foldername = libPath.dirname(pathname);
177 | 
178 |     if (!fs.existsSync(foldername)) {
179 |       try {
180 |         fs.mkdirpSync(foldername);
181 |         return Promise.resolve(true);
182 |       } catch {
183 |         return Promise.resolve(false);
184 |       }
185 |     }
186 | 
187 |     return Promise.resolve(true);
188 |   }
189 | 
190 |   /**
191 |    * delete file
192 |    * @param filePath
193 |    * @return true on success, false on failure
194 |    */
195 |   async deleteResource(fn) {
196 |     try {
197 |         console.log('deleting ',fn);
198 |         //  await this.dbx.filesDelete({path:fn});
199 |     }
200 |     catch(e){ 
201 |       console.log("Dropbox deleteResource error : ",e.status)
202 |       return { headers: {
203 |         status:e.status,
204 |         statusText:e.error,
205 |       }}; 
206 |     }
207 |   }
208 | 
209 |   /**
210 |    * delete folder
211 |    * @param filePath
212 |    * @return true on success, false on failure
213 |    */
214 |   async deleteContainer(fn) {
215 |     try {
216 |       let files = await this.getContainer(fn);
217 |       if(files && files.length > 0){
218 |         console.log('Refusing to delete folder - not empty! ',fn);
219 |         return 409;
220 |       }
221 |       else {
222 |         console.log('deleting ',fn);
223 |         //  await this.dbx.filesDelete({path:fn});
224 |       }
225 |     }
226 |     catch(e){ 
227 |       console.log("Dropbox deleteResource error : ",e.status)
228 |       return { headers: {
229 |         status:e.status,
230 |         statusText:e.error,
231 |       }}; 
232 |     }
233 |   }
234 | 
235 | } 
236 | // THE END!
237 | 
238 | 
239 | 


--------------------------------------------------------------------------------
/file/tests/patch.js:
--------------------------------------------------------------------------------
  1 | const $rdf = global.$rdf = require('rdflib');
  2 | const {SolidRestFile} = require('../');
  3 | const libUrl = require('url');
  4 | 
  5 | const client = new SolidRestFile();
  6 | 
  7 | let [tests,fails,passes,res,allfails] = [0,0,0,0];
  8 | 
  9 | async function main(){
 10 |   await run("file:")
 11 |   //  await run("https:")
 12 |   if(allfails>0) process.exit(1)
 13 |   else process.exit(0)
 14 | }
 15 | main()
 16 | 
 17 | async function run(scheme){
 18 |   [tests,fails,passes] = [0,0,0]
 19 |   let cfg = await getConfig(scheme)
 20 |   let res,res2,res3;
 21 | 
 22 |   console.warn(`\nTesting ${cfg.base} ...`)
 23 | 
 24 |   const folder     = `${cfg.base}/noSuchFolder/`;
 25 |   const file       = `${folder}test.ttl`;
 26 |   const nonRdfFile = `${folder}test.txt`;
 27 |   const sparqlType = `application/sparql-update`;
 28 |   const ns = $rdf.Namespace(file+"#");
 29 | 
 30 | console.log("\nSPARQL update - expected to succeed");
 31 | 
 32 |   // PREP : START WITH ONLY NON-RDF FILE
 33 |   //
 34 |   res = await DELETE(file)
 35 |   res = await PUT(nonRdfFile,"some text","text/plain")
 36 | 
 37 |   // 200 SPARQL INSERT TO INEXISTANT RESOURCE, CREATES RESOURCE
 38 |   //
 39 |   res = await PATCH(file,"INSERT { <> a <#Test>. }",sparqlType);
 40 |   res2 = await matchRdfType( file, ns("Test") );
 41 |   ok("200 insert to inexistant resource creates resource",res.status==200 && res2, res2)
 42 | 
 43 |   // 200 SPARQL INSERT TO EXISTING RESOURCE, UPDATES RESOURCE
 44 |   //
 45 |   res = await PATCH(file,"INSERT { <> a <#BadTest>. }",sparqlType);
 46 |   res2 = await matchRdfType( file, ns("BadTest") );
 47 |   ok("200 insert to existing resource",res.status==200 && res2, res2)
 48 | 
 49 |   // 200 SPARQL DELETE EXISTING TRIPLE
 50 |   //
 51 |   res = await PATCH(file,"DELETE { <> a <#BadTest>. }",sparqlType);
 52 |   res2 = await matchRdfType( file, ns("BadTest") );
 53 |   ok("200 delete existing triple",res.status==200 && !res2, res2)
 54 | 
 55 | 
 56 |   // 200 SPARQL INSERT TRIPPLE & DELETE EXISTING TRIPLE
 57 |   //
 58 |   res = await PATCH(file,"INSERT { <> a <#GoodTest>. } DELETE { <> a <#Test>. }",sparqlType);
 59 |   res2 = await matchRdfType( file, ns("Test") );
 60 |   res3 = await matchRdfType( file, ns("GoodTest") );
 61 |   ok("200 insert new triple & delete existing triple",res.status==200 && !res2 && res3, res3)
 62 | 
 63 |   // 200 SPARQL DELETE EXISTING TRIPLE WITH WHERE CLAUSE
 64 |   //
 65 |   await PATCH(file,"INSERT { <> a <#Chutzpah>. }",sparqlType);
 66 |   res = await PATCH(file,"DELETE { <> a <#GoodTest>. }\nWHERE { <> a <#Chutzpah>. }",sparqlType);
 67 |   res2 = await matchRdfType( file, ns("GoodTest") );
 68 |   res3 = await matchRdfType( file, ns("Chutzpah") );
 69 |   ok("200 delete existing triple with where clause",res.status==200 && !res2 && res3)
 70 | 
 71 |   res = await PATCH(file,"INSERT { <> a <#A>; a <#B>. <> a <#C> }",sparqlType);
 72 |   ok("200 insert with multiple clauses and triples",
 73 |     res.status == 200 && 
 74 |     await matchRdfType( file, ns("A") ) &&
 75 |     await matchRdfType( file, ns("B") ) &&
 76 |     await matchRdfType( file, ns("C") ) 
 77 |   )
 78 | 
 79 | console.log("\nSPARQL update - expected to fail");
 80 | 
 81 |   // 400 SPARQL INSERT WITH BAD CONTENT
 82 |   //
 83 |   res = await PATCH(file, "ceci n'est pas sparql", sparqlType);
 84 |   ok("400 invalid patch content",res.status==400, res)
 85 | 
 86 |   // 400 SPARQL PATCH WITH MULTIPLE INSERT STATEMENTS
 87 |   //
 88 |   res = await PATCH(file,"INSERT { <> a <#G>. }\nINSERT { <> a <#H>. }",sparqlType);
 89 |   ok("400 can't have multiple INSERT statements in a patch",res.status==400, res)
 90 | 
 91 |   // 404 SPARQL DELETE INEXISTING FILE
 92 |   //
 93 |   res = await PATCH(file+"junk","DELETE { <> a <#BadTest>. }",sparqlType);
 94 |   ok("409 can't delete from a file that doesn't exist",res.status==409, res)
 95 | 
 96 |   // 409 SPARQL DELETE INEXISTING TRIPLE
 97 |   //
 98 |   res = await PATCH(file,"DELETE { <> a <#NoSuchThing>. }",sparqlType);
 99 |   ok("409 can't delete a triple that doesn't exist",res.status==409, res)
100 | 
101 |   // 409 SPARQL INSERT ON NON-RDF FILE
102 |   //
103 |   res = await PATCH(nonRdfFile,"INSERT { <> a <#Test>. }",sparqlType);
104 |   ok("409 can't patch patch a non-rdf file",res.status==409, res)
105 | 
106 |   // 409 SPARQL ATTEMPT TO PATCH A CONTAINER
107 |   //
108 |   res = await PATCH(folder,"INSERT { <> a <#Test>. }",sparqlType);
109 |   ok("409 can't patch a Container",res.status==409, res)
110 | 
111 |   // 415 SPARQL INSERT WITH BAD CONTENT-TYPE
112 |   //
113 |   res = await PATCH(file,"INSERT { <> a <#Test>. }",'fake-contentType');
114 |   ok("415 invalid patch content-type",res.status==415, res)
115 | 
116 |   // CLEANUP
117 |   //
118 |   await DELETE(file)
119 |   await DELETE(nonRdfFile)
120 |   await DELETE(folder);
121 | 
122 |   let total = 13;
123 |   let skipped = total - passes - fails;
124 |   console.warn(`${passes}/${total} tests passed, ${fails} failed, ${skipped} skipped\n`);
125 |   allfails = allfails + fails
126 | }
127 | // =========================================================== //
128 | // REST METHODS                                                //
129 | // =========================================================== //
130 | async function PATCH(url, patchContent, patchContentType){
131 |   return await client.fetch(url, {
132 |     method: 'PATCH',
133 |     body:patchContent,
134 |     headers:{
135 |       'Content-Type': patchContentType,
136 |       link: '<http://www.w3.org/ns/ldp#Resource>; rel="type"'
137 |     },
138 |     relative: true
139 |   })
140 | } 
141 | async function DELETE(url){
142 |   try {
143 |     return await client.fetch( url, {method:"DELETE"} )
144 |   }
145 |   catch(e){ return e }
146 | }
147 | async function PUT(url,content){
148 |   return await client.fetch( url, {method:"PUT",body:content,headers:{"content-type":"text/turtle"}} )
149 | }
150 | async function GET(url){
151 |   return await client.fetch( url )
152 | }
153 | 
154 | // ============================================== //
155 | 
156 | async function matchRdfType( subject, object ) {
157 |   const kb = $rdf.graph();
158 |   const fetcher = $rdf.fetcher(kb,{fetch:client.fetch.bind(client)});
159 |   const RDF = $rdf.Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#");
160 |   subject = $rdf.sym(subject);
161 |   await fetcher.load(subject);
162 |   let result = kb.match( subject, RDF("type"), object );
163 |   return result ?result.length :0;
164 | }
165 | 
166 | function ok( label, success,res ){
167 |    tests = tests + 1;   
168 |    if(success) passes = passes + 1
169 |    else fails = fails+1
170 |    let msg = success ? "ok " : "FAIL "
171 |    console.warn( "  " + msg + label)
172 |    if(!success && res ) console.warn(res.status,res.statusText)
173 |    return success
174 | }
175 | 
176 | async function testPatch (res, resPatch) {
177 |   let content = await res.text();
178 | //  if(!content) console.log("No body from PATCH",resPatch);
179 |   return resPatch.find(string => string === content)
180 | }
181 | 
182 | async function getConfig(scheme){
183 |   let host = scheme;
184 |   let base;
185 |   if(scheme==="mem:"){
186 |     base = "mem://" // = protocol 
187 |     host = scheme;
188 |   }
189 |   else if(scheme==="file:") {
190 |      host = scheme + "//";
191 |      base = libUrl.pathToFileURL(process.cwd()).href + "/test-folder";
192 |   }
193 |   else if(scheme==="https:") {
194 |     // let session = await client.login()
195 |     // let webId = session.WebID
196 |     let webId = "https://jeff-zucker.solidcommunity.net/profile/card#me"
197 |     if(! webId ) throw "Couldn't login!"
198 |     host = webId.replace("/profile/card#me",'')
199 |     base = webId.replace("/profile/card#me",'')+ "/public/test-folder";
200 |   }
201 |   host = host || base;
202 |   const cfg = { host, base, }
203 |   // console.log(cfg);
204 |   return cfg;
205 | }
206 | console.log = (...args) => {
207 |   for(let a of args){
208 |     if(a.match && a.match(/^@@@/)) continue;
209 |     console.warn(a)
210 |   }
211 | }
212 | 


--------------------------------------------------------------------------------
/file/tests/n3patch.js:
--------------------------------------------------------------------------------
  1 | const $rdf = global.$rdf = require('rdflib');
  2 | const {SolidRestFile} = require('../');
  3 | const libUrl = require('url');
  4 | 
  5 | const client = new SolidRestFile();
  6 | 
  7 | let [tests,fails,passes,res,allfails] = [0,0,0,0];
  8 | 
  9 | async function main(){
 10 |   await run("file:")
 11 |   //  await run("https:")
 12 |   if(allfails>0) process.exit(1)
 13 |   else process.exit(0)
 14 | }
 15 | main()
 16 | 
 17 | async function run(scheme){
 18 |   [tests,fails,passes] = [0,0,0]
 19 |   let cfg = await getConfig(scheme)
 20 |   let res,res2,res3;
 21 | 
 22 |   console.warn(`\nTesting ${cfg.base} ...`)
 23 | 
 24 |   const folder     = `${cfg.base}/noSuchFolder/`;
 25 |   const file       = `${folder}test.ttl`;
 26 |   const nonRdfFile = `${folder}test.txt`;
 27 |   const ex = $rdf.Namespace(file+'#');
 28 | 
 29 | console.warn("\nN3 update - expected to succeed");
 30 | 
 31 |   // PREP : START WITH ONLY NON-RDF FILE
 32 |   //
 33 |   res = await DELETE(file)
 34 |   res = await PUT(nonRdfFile,"some text","text/plain")
 35 | 
 36 |   // 200 N3 INSERT TO INEXISTANT RESOURCE, CREATES RESOURCE
 37 |   //
 38 |   res = await PATCH(file,`solid:inserts {ex:This a ex:Test.} .`);
 39 |   res2 = await matchRdfType( ex('This'), ex("Test") );
 40 |   ok("200 insert to inexistant resource creates resource",res.status==200 && res2, res2)
 41 | 
 42 |   // 200 N3 INSERT TO EXISTING RESOURCE, UPDATES RESOURCE
 43 |   //
 44 |   res = await PATCH(file,`solid:inserts {ex:This a ex:BadTest.} .`);
 45 |   res2 = await matchRdfType( ex('This'), ex("BadTest") );
 46 |   ok("200 insert to existing resource",res.status==200 && res2, res2)
 47 | 
 48 |   // 200 N3 DELETE EXISTING TRIPLE
 49 |   //
 50 |   res = await PATCH(file,"solid:deletes { ex:This a ex:BadTest. } .");
 51 |   res2 = await matchRdfType( ex('This'), ex("BadTest") );
 52 |   ok("200 delete existing triple",res.status==200 && !res2, res2)
 53 | 
 54 | 
 55 |   // 200 SPARQL INSERT TRIPPLE & DELETE EXISTING TRIPLE
 56 |   //
 57 |   res = await PATCH(file,"solid:inserts { ex:This a ex:GoodTest. }; solid:deletes { ex:This a ex:Test. }.");
 58 |   res2 = await matchRdfType( ex('This'), ex("Test") );
 59 |   res3 = await matchRdfType( ex('This'), ex("GoodTest") );
 60 |   ok("200 insert new triple & delete existing triple",res.status==200 && !res2 && res3, res3)
 61 | 
 62 |   // 200 SPARQL DELETE EXISTING TRIPLE WITH WHERE CLAUSE
 63 |   //
 64 |   await PATCH(file,"solid:inserts { ex:This a ex:Chutzpah. }.");
 65 |   res = await PATCH(file,"solid:deletes { ex:This a ex:GoodTest. };\nsolid:where { ex:This a ex:Chutzpah. }.");
 66 |   res2 = await matchRdfType( ex('This'), ex("GoodTest") );
 67 |   res3 = await matchRdfType( ex('This'), ex("Chutzpah") );
 68 |   ok("200 delete existing triple with where clause",res.status==200 && !res2 && res3)
 69 | 
 70 |   // 200 SPARQL INSERT WITH MULTIPLE CLAUSES AND TRIPLES
 71 |   //
 72 |   res = await PATCH(file,"solid:inserts { ex:This a ex:A, ex:B. ex:This a ex:C. }.");
 73 |   ok("200 insert with multiple clauses and triples",
 74 |     res.status == 200 && 
 75 |     await matchRdfType( ex('This'), ex("A") ) &&
 76 |     await matchRdfType( ex('This'), ex("B") ) &&
 77 |     await matchRdfType( ex('This'), ex("C") ) 
 78 |   )
 79 | 
 80 | console.log("\nN3 update - expected to fail");
 81 | 
 82 |   // 400 SPARQL solid:inserts WITH BAD CONTENT
 83 |   //
 84 |   res = await PATCH(file, "ceci n'est pas sparql");
 85 |   ok("400 invalid patch content",res.status==400, res)
 86 | 
 87 |   // 400 SPARQL PATCH WITH MULTIPLE solid:inserts STATEMENTS
 88 |   //
 89 |   res = await PATCH(file,"solid:inserts { ex:This a ex:G. }\nsolid:inserts { ex:This a ex:H. }.");
 90 |   ok("400 can't have multiple solid:inserts statements in a patch",res.status==400, res)
 91 | 
 92 |   // 404 SPARQL DELETE INEXISTING FILE
 93 |   //
 94 |   res = await PATCH(file+"junk","DELETE { ex('This') a <#BadTest>. }");
 95 |   ok("409 can't delete from a file that doesn't exist",res.status==409, res)
 96 | 
 97 |   // 409 SPARQL DELETE INEXISTING TRIPLE
 98 |   //
 99 |   res = await PATCH(file,"solid:deletes { ex:This a ex:NoSuchThing. }.");
100 |   ok("409 can't delete a triple that doesn't exist",res.status==409, res)
101 | 
102 |   // 409 SPARQL solid:inserts ON NON-RDF FILE
103 |   //
104 |   res = await PATCH(nonRdfFile,"solid:inserts { ex('This') a <#Test>. }");
105 |   ok("409 can't patch patch a non-rdf file",res.status==409, res)
106 | 
107 |   // 409 SPARQL ATTEMPT TO PATCH A CONTAINER
108 |   //
109 |   res = await PATCH(folder,"solid:inserts { ex('This') a <#Test>. }");
110 |   ok("409 can't patch a Container",res.status==409, res)
111 | 
112 |   // 415 SPARQL solid:inserts WITH BAD CONTENT-TYPE
113 |   //
114 |   res = await PATCH(file,"solid:inserts { ex('This') a <#Test>. }.",'fake-contentType');
115 |   ok("415 invalid patch content-type",res.status==415, res)
116 | 
117 |   // CLEANUP
118 |   //
119 |   await DELETE(file)
120 |   await DELETE(nonRdfFile)
121 |   await DELETE(folder);
122 | 
123 |   let total = 13;
124 |   let skipped = total - passes - fails;
125 |   console.warn(`${passes}/${total} tests passed, ${fails} failed, ${skipped} skipped\n`);
126 |   allfails = allfails + fails
127 | }
128 | // =========================================================== //
129 | // REST METHODS                                                //
130 | // =========================================================== //
131 | async function PATCH(url, patchContent,ctype){
132 |   patchContent = `
133 |     @prefix solid: <http://www.w3.org/ns/solid/terms#> .
134 |     @prefix ex: <${url+'#'}> .
135 |     <> a solid:InsertDeletePatch ;
136 |     ${patchContent}
137 |   `;
138 |   return await client.fetch(url, {
139 |     method: 'PATCH',
140 |     body:patchContent,
141 |     headers:{
142 |       'Content-Type': ctype || "text/n3",
143 |     },
144 |   })
145 | } 
146 | async function DELETE(url){
147 |   try {
148 |     return await client.fetch( url, {method:"DELETE"} )
149 |   }
150 |   catch(e){ return e }
151 | }
152 | async function PUT(url,content){
153 |   return await client.fetch( url, {method:"PUT",body:content,headers:{"content-type":"text/turtle"}} )
154 | }
155 | async function GET(url){
156 |   return await client.fetch( url )
157 | }
158 | 
159 | // ============================================== //
160 | 
161 | async function matchRdfType( subject, object ) {
162 |   const kb = $rdf.graph();
163 |   const fetcher = $rdf.fetcher(kb,{fetch:client.fetch.bind(client)});
164 |   const RDF = $rdf.Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#");
165 |   subject = $rdf.sym(subject);
166 |   await fetcher.load(subject);
167 |   let result = kb.match( subject, RDF("type"), object );
168 |   return result ?result.length :0;
169 | }
170 | 
171 | function ok( label, success,res ){
172 |    tests = tests + 1;   
173 |    if(success) passes = passes + 1
174 |    else fails = fails+1
175 |    let msg = success ? "ok " : "FAIL "
176 |    console.warn( "  " + msg + label)
177 |     if(!success && res ) console.warn(res.status,res.statusText)
178 |    return success
179 | }
180 | 
181 | async function testPatch (res, resPatch) {
182 |   let content = await res.text();
183 | //  if(!content) console.log("No body from PATCH",resPatch);
184 |   return resPatch.find(string => string === content)
185 | }
186 | 
187 | async function getConfig(scheme){
188 |   let host = scheme;
189 |   let base;
190 |   if(scheme==="mem:"){
191 |     base = "mem://" // = protocol 
192 |     host = scheme;
193 |   }
194 |   else if(scheme==="file:") {
195 |      host = scheme + "//";
196 |      base = libUrl.pathToFileURL(process.cwd()).href + "/test-folder";
197 |   }
198 |   else if(scheme==="https:") {
199 |     // let session = await client.login()
200 |     // let webId = session.WebID
201 |     let webId = "https://jeff-zucker.solidcommunity.net/profile/card#me"
202 |     if(! webId ) throw "Couldn't login!"
203 |     host = webId.replace("/profile/card#me",'')
204 |     base = webId.replace("/profile/card#me",'')+ "/public/test-folder";
205 |   }
206 |   host = host || base;
207 |   const cfg = { host, base, }
208 |   // console.log(cfg);
209 |   return cfg;
210 | }
211 | console.log = (...args) => {
212 |   for(let a of args){
213 |     if(a && a.match && a.match(/^@@@/)) continue;
214 |     console.warn(a)
215 |   }
216 | }
217 | 


--------------------------------------------------------------------------------
/browser/README.md:
--------------------------------------------------------------------------------
  1 | # Solid Rest Browser
  2 | 
  3 | Solid access to in-browser and cloud storage
  4 | 
  5 | This library supports using most Solid methods on data stored in the browser and cloud storage.  It is a shim between Solid and the [browserFS](https://github.com/jvilk/BrowserFS) library.  Out of the box, it supports Local Storage, IndexedDB, and the HTML5 File System API.  Users may also pass in their own browserFS configuration using any of the dozen or so browserFS supported file systems.
  6 | 
  7 | Once initialized, most Solid methods can be used with in-browser or cloud data simply by using URLs in the form `browser://LocalStorage/foo/bar.ttl`, where "LocalStorage" could be "IndexedDB", "HTML5FS" or other browserFS storage type.
  8 | 
  9 | In-browser URLs may be used directly with stand-alone Solid Rest fetches, or, more likely, as the fetch for rdflib, the solid-ui forms system, or other high-level libraries.
 10 | 
 11 | The library can be used for dual-fetches, for example to write both in-browser and to a pod.  This feature could be combined with syncing logic to create a local-first app.  See the example below.
 12 | 
 13 | ## Importing the prerequisites
 14 | 
 15 | Before loading Solid Rest you should import the browserFS library as well 
 16 | as any Solid libraries you need (e.g. solid-client-authn-browser, rdflib, 
 17 | etc.).  You can install these libraries locally or point to CDNs such as 
 18 | ```html
 19 | <script src="https://cdn.jsdelivr.net/npm/browserfs@1/dist/browserfs.min.js"></script>
 20 | <script src="https://cdn.jsdelivr.net/npm/rdflib@2/dist/rdflib.min.js"></script>
 21 | <script src="https://cdn.jsdelivr.net/npm/@inrupt/solid-client-authn-browser@1/dist/solid-client-authn.bundle.js"></script>
 22 | ```
 23 | Then you need to import Solid-Rest-Browser itself.  You can do this from a local install or from here:
 24 | ```html
 25 | <script src="https://solid.github.io/solid-rest/browser/dist/solid-rest-browser.bundle.js"></script>
 26 | ```
 27 |                      
 28 | ## Using Stand-alone
 29 | 
 30 | Once you have imported the Solid Rest Browser and BrowserFS libraries in script tags, you can create a new solid rest client and configure it, like this :
 31 | ```javascript
 32 |     const solidRest = new SolidRestBrowser();
 33 |     await solidRest.configure();
 34 | ```
 35 | Once you've done that, you can do Solid 'GET' and 'PUT' fetches that will read/write using in-browser storage :
 36 | ```javascript
 37 |     await solidRest.fetch( "browser://IndexedDB/foo/bar.txt", {
 38 |       method:"'PUT", 
 39 |       body: "Some text ccontent",
 40 |       headers:{"content-type":"text/plain"},
 41 |     })
 42 | ```
 43 | That statement will write the named file in the IndexedDB storage under the path "/foo/bar.txt".  Not very exciting on its own, but it means that apps which use Solid REST protocols will be able to use the storage.
 44 | 
 45 | See also a [complete working example of stand-alone usage](examples/stand-alone.html).
 46 | 
 47 | ## Using with rdflib, solid-ui, SolidOS, etc.
 48 | The library has a configFetcher method that modifies rdflib's fetcher object to handle both http and in-browser data.  The first parameter is the knowledge-base, rdflib's internal graph. ConfigFetcher is aynchronous, so must be called with await.  It returns a fetcher object that is the same as rdflib's fetcher, except that it handles "browser://" URIs on its own.
 49 | ```javascript
 50 |     // define the knowledge-base & updater as usual
 51 |     //
 52 |     const kb = $rdf.graph();
 53 |     const myUpdater = new $rdf.UpdateManager(kb)
 54 | 
 55 |     // define a custom fetcher using solid rest and the knowledge base
 56 |     //
 57 |     const solidRest = new SolidRestBrowser();
 58 |     const myFetcher = await solidRest.configFetcher(kb);
 59 | 
 60 |     // from here on, myFetcher & myUpdater will
 61 |     // support in-browser fetches
 62 |     //
 63 | ```
 64 | See also a [complete working example of rdflib no-auth usage](examples/rdflib.html).
 65 | 
 66 | In most cases, you'll want to interact with both the in-browser data and data from one or more pods.  If some of those pods require authentication, you'll need to supply an authenticated fetch such as [Inrupt's Solid Client Authn Browser](https://github.com/inrupt/solid-client-authn-js).  You can add this the same way as you would with standard rdflib, by supplying the Inrupt fetch on fetcher creation. If you've imported Inrupt's authentication library in a script tag, you can add it to rdflib's fetcher like this:
 67 | ```javascript
 68 |     const fetcher = await solidRest.configFetcher(kb,{
 69 |       fetch : solidClientAuthentication.getDefaultSession().fetch
 70 |     })
 71 | ```
 72 | This assumes that you have provided other code to handle the authentication, see [a hybrid in-browser and authenticated rdflib fetch](examples/authn.html) for a working example.
 73 | 
 74 | If you create a fetcher with the fetch option specified, you will end up with a hybrid fetcher. URLs in http: and https: schemes will use the supplied authenticated fetch, while URLs in the browser: scheme will use the in-browser fetch.   
 75 | 
 76 | If you are working with libraries further up the chain than rdflib (e.g. solid-ui, or mashlib) you can set the global window.solidFetch to equal your custom fetch : 
 77 | ```javascript
 78 |     const myFetcher = await solidRest.makeFetcher(kb,{
 79 |       fetch : solidClientAuthentication.getDefaultSession().fetch
 80 |     })
 81 |     window.solidFetch = myFetcher.fetch.bind(solidRest);
 82 | ```
 83 | This should make any fetch in mashlib and friends use Inrupt's client for http: fetches and solid rest for browser: fetches.
 84 | 
 85 | ## Supplying A Custom BrowserFS Configuration
 86 | 
 87 | By default, this library supports three storages at /IndexedDB, /LocalStorage, and /HTML5FS.  If you would like things mounted somewhere else or you want to add or substitute other BrowserFS backends, you can supply a BrowserFS configuration when you configure Solid Rest.
 88 | ```javascript
 89 |     const myFetcher = await solidRest.makeFetcher(kb,{
 90 |       browserFSconfiguration : {fs:"LocalStorage"}
 91 |       fetch : solidClientAuthentication.getDefaultSession().fetch
 92 |     })
 93 | ```
 94 | This example would remove the mountable file system and replace it with a single Local Storage.  URLs in the form `browser://foo/bar.txt` would be written in Local Storage as `/foo/bar.txt`.
 95 | 
 96 | You can use this configuration option to support any of the dozen or so browserFS backends or to create a mountable or mirrored file system. You can pass any valid browserFS configuration.
 97 | 
 98 | ## Dual Fetches - a basis for  Local-First
 99 | 
100 | A local-first system stores data in the browser and syncs it with remote Pod data.  To do this you'll need to create a custom fetch method.  
101 | 
102 | In the example below, we'll simply copy the file locally and then remotely with no syncing logic which you would have to supply.  We'll use a URL pattern like `browser://https://example.com/foo.ttl` which would store the data fist in the browser's storage under the key https://example.com/foo.ttl and remotely with that same address.  We have to add and remove the browser:// portion in order to let rdflib know to let your fetch handle the local part.
103 | ```javascript
104 |  async function myFetch(uri,options){
105 |     let inrupt = solidClientAuthentication.getDefaultSession();
106 |     let res;
107 |     try {
108 |       res = await solidRest.fetch(uri,options);
109 |       console.log(`Stored local <${uri}>.`);
110 |     }
111 |     catch(e){console.log(`Could not store local <${uri}> : ${e}`);}
112 |     if(options.method==='PUT'){
113 |       uri = uri.replace(/browser:\/\//,'');
114 |       try {
115 |         await inrupt.fetch(uri,options);
116 |         console.log(`Stored remote <${uri}>.`);
117 |       }
118 |       catch(e){console.log(`Could not store remote <${uri}> : ${e}`);}
119 |     }
120 |     return res;
121 |   }
122 |   const myFetcher = await solidRest.configFetcher(kb,{
123 |     browserFSconfiguration : {fs:"LocalStorage"}
124 |     fetch : myFetch
125 |   });
126 | ```
127 | This code would mean that any uses of myFetcher.load, myFetcher.putBack,
128 | and myUpdater.update would always read from the in-browser data and write 
129 | to both the in-browser and the external Pod storages. An app or library could add conflict resolution, syncing and other features to create a local first system using any library that supports Solid fetches. 
130 | 
131 | ## Other Details
132 | 
133 | When you create the SolidRestBrowser object, you can add a flag to turn debugging info on:
134 | ```javascript
135 |   const solidRest = new SolidRestBrowser({DEBUG:true});
136 | ```
137 | 
138 | 
139 | &copy; 2021, Jeff Zucker, all rights reserved;
140 | may be freely distributed under an MIT license
141 | 
142 | 
143 | 
144 | 
145 | 
146 | 
147 | 
148 | 
149 | 
150 | 
151 | 


--------------------------------------------------------------------------------
/core/src/handleResponse.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |           url : file:///foo/bar.txt
  3 |      location : /foo/bar.txt
  4 |  ldp:contains : bar.txt
  5 | */
  6 | //import libPath from 'path';
  7 | import { Response, Headers } from 'cross-fetch';
  8 | import { v4 as uuid } from 'uuid';
  9 | const statusText = {
 10 |   200: "OK",
 11 |   201: "Created",
 12 |   400: "Bad Request",
 13 |   401: "Unauthorized",
 14 |   403: "Forbidden",
 15 |   404: "Not Found",
 16 |   405: "Method Not Allowed",
 17 |   408: "Request Timeout",
 18 |   415: "Unsupported Media Type",
 19 |   418: "I'm a teapot",
 20 |   420: "Smoke 'em if you got 'em",
 21 |   500: "Server error"
 22 | };
 23 | export async function handleResponse(response, originalRequest) {
 24 |   let wrapHeaders = true; // {headers} instead of headers for Response
 25 |   let method = originalRequest.method || this.request.method || "GET";
 26 |   let finalResponse = {
 27 |     body: "",
 28 |     headers: {}
 29 |   }; // headers from response
 30 | 
 31 |   /* We parse the response depending on its type
 32 |      * number  : plugins may send a simple status code
 33 |      * boolean : or send true on success, false on failure
 34 |      * object  : or send a header and optional body
 35 |      * string  : or, for get requests, send the content
 36 |   */
 37 |   if (typeof response === 'number') {
 38 |     wrapHeaders = false;
 39 |     finalResponse.headers.status = response;
 40 |   } else if (typeof response === 'boolean') {
 41 |     let fr  = response ? 201 : 500;
 42 |     fr = fr===201 && method.match(/(GET|HEAD)/) ?200 :201;
 43 |     if( method.match(/OPTIONS/) ) fr = 204;
 44 |     finalResponse.headers.status = fr
 45 |   } else if (typeof response === 'string') {
 46 |       finalResponse.headers.status = 200;
 47 |       finalResponse.body = response;
 48 |   } else if (typeof response === 'object') {
 49 |     wrapHeaders = false;
 50 |     finalResponse = response;
 51 |     finalResponse.headers = finalResponse.headers || {};
 52 |     finalResponse.headers.status = finalResponse.status;
 53 |     finalResponse.headers.statusText = finalResponse.statusText;
 54 |   } // now we create headers
 55 |   // if the response already has some of them, those will replace our
 56 |   // constructed ones later
 57 | 
 58 |   if(method.match(/(PUT)/) && finalResponse.headers.status == 200){
 59 |     finalResponse.headers.status = 201
 60 |   }
 61 |   if(method.match(/(DELETE|GET|HEAD)/) && finalResponse.headers.status == 201){
 62 |     finalResponse.headers.status = 200 
 63 |   }
 64 | 
 65 |   let headers = {};
 66 |   const request = this.requestObj;
 67 |   const item = this.item;
 68 | 
 69 |   const pathname = item.pathname;
 70 | 
 71 |   // const fn = libPath.basename(pathname); 
 72 |   const fn = pathname.replace(/.*\//,'');
 73 | 
 74 |   headers['vary'] = 'accept,authorization,origin'
 75 | 
 76 |   headers['access-control-expose-headers'] =  'accept-patch,accept-post,accept-put,allow,content-range,etag,last-modified,link,location,updates-via,wac-allow,www-authenticate'
 77 | 
 78 |   headers['content-type'] = this.item.contentType; // CONTENT-TYPE	  
 79 | 
 80 |   const storageHeader = item.pathname === '/' ? ', <http://www.w3.org/ns/pim/space#Storage>; rel="type"' : ''
 81 |   headers.link = headers.link || (createLinkHeader(item) + storageHeader); // LINK
 82 | 
 83 |   headers.allow = createAllowHeader(item.pathname) // ALLOW
 84 | 
 85 |   headers['wac-allow'] = createWacHeader(this.item.mode); // WAC-ALLOW
 86 | 
 87 |   headers.date = headers.date || new Date(Date.now()).toISOString(); // DATE
 88 | 
 89 |   headers['x-powered-by'] = headers['x-powered-by'] || (await this.perform('STORAGE_NAME')); // LOCATION (we pre-populated this in performRequestedMethod.js) // X-POWERED-BY
 90 | 
 91 |   if (this.response && this.response.headers) headers.location = this.response.headers.location;
 92 | 
 93 |   //  NO, DON'T USE LOCATION headers.url = headers.location || pathname ;
 94 |   headers.url = pathname ;
 95 |   if(method==="POST"){
 96 |     headers.url = this.request.url;
 97 | /*
 98 |     // NO, DON'T ADD SLUG headers.url = this.request.url + this.request.slug;
 99 |     let cont = await this.perform('ITEM_TYPE',pathname);
100 |     if(cont==="Resource") {
101 |       headers.url = headers.url.replace(/\/$/,'');
102 |       headers.url = headers.url.replace(/\/[^\/]*$/,'');
103 |     }
104 |     if(!headers.url.endsWith('/')) headers.url=headers.url+"/";
105 | */
106 |   }
107 |   /* if (this.patch) {                        // ACCEPT-PATCH & MS-AUTHOR-VIA
108 |     headers['accept-patch'] = ['text/n3', 'application/sparql-update'];
109 |     headers['ms-author-via'] = ["SPARQL"];                   
110 |   } */
111 | 
112 | 
113 |   let body = finalResponse.body || this.response.body || ""; // Now we merge headers we created with response headers, prefering response
114 | 
115 |   Object.assign(headers, finalResponse.headers);
116 | //alert(finalResponse.headers.status)
117 |   headers.status = finalResponse.headers.status || this.response.headers.status || 500;
118 | 
119 |   let $rdf = typeof window != "undefined" && window.$rdf ? window.$rdf : typeof global != "undefined" && global.$rdf ? global.$rdf : null;
120 | 
121 | /*
122 |   async function serialize(uri,body,informat,outformat){
123 |     return new Promise( async (resolve,reject)=>{
124 |       let u = $rdf.sym(uri);
125 |       let kb = $rdf.graph();
126 |       await $rdf.parse(body, kb, uri, informat); 
127 |       $rdf.serialize(u, kb, uri,outformat,(err, str)=>{
128 |         if(err) return( reject(err) );
129 |         else return( resolve(str)  );
130 |       });
131 |     })
132 |   }
133 | 
134 |   let accept = this.request.headers.accept || "";
135 |   accept = accept && accept.match && accept.match(/ /) ?"" :accept;
136 |   if(this.patch && accept && accept.match){
137 |     if( accept.match(/(text\/turtle|application\/ld\+json)/) ){
138 |       body = await serialize(this.request.url,body.toString(),this.item.contentType,accept)
139 |     }
140 |     else {
141 |       headers.status = "405";
142 |       headers.statusText = `Unsupported content-type in accept header : ${accept}`;
143 |     }
144 |   }
145 | */
146 |   headers.statusText = headers.statusText || statusText[headers.status]; 
147 | 
148 |   headers = createAcceptHeader(request, headers) // ACCEPT
149 | 
150 |   headers.etag = `W/"${uuid()}"`;
151 |   headers['content-length'] = (typeof Buffer !='undefined') ?Buffer.byteLength(body,'utf8') :(typeof Blob!="undefined") ?(new Blob([body])).size :77;
152 | 
153 |   // TODO (?) last-modified
154 | 
155 |   // Now we create & return the Response object
156 |   for(var h of Object.keys(headers)){
157 |     if(! headers[h]) delete headers[h];
158 |   }
159 | 
160 |   if(!headers.url.match(/:/)) headers.url = (this.prefix||"file:") + "//"+headers.url;
161 | 
162 | //  headers.location = headers.location || headers.url.replace(/^....?:\/\//,'');
163 | 
164 | 
165 | //  if(!headers.location.match(/^file:/)) headers.location = "file://"+headers.location;
166 | 
167 | if(originalRequest.method==='HEAD') {
168 |   body = "";
169 |   for(let k of Object.keys(headers)){
170 |     body = body + `${k}:${headers[k]}\n`;
171 |   }
172 | }
173 | 
174 |   if (originalRequest.plainResponse) {
175 |     // from a server that wants to munge
176 |     return {
177 |       status:headers.status,
178 |       statusText:headers.statusText,
179 |       body: body,
180 |       headers: headers,
181 |       url:headers.url,
182 |       location:headers.location,
183 |     };
184 |   }
185 | wrapHeaders = true;
186 |   headers = wrapHeaders ? {
187 |     status:headers.status,
188 |     statusText:headers.statusText,
189 |     headers: headers,
190 |     location:headers.location,
191 |     url:headers.url
192 | 
193 |   } : headers;
194 |   let responseObject;
195 | 
196 |   
197 | 
198 |   try {
199 |     responseObject = new Response(body, headers,{url:headers.url});
200 |   } catch (e) {
201 |     console.log("Error " + e);
202 |   }
203 |   return responseObject;
204 | } // end of handleResponse method
205 | // Utility methods for creating headers
206 | 
207 | function createWacHeader(mode) {
208 |   if (!mode.read && !mode.write) return null;
209 |   if (mode.read && !mode.write) return `user="read",public="read"`;
210 |   if (!mode.read && mode.write) return `user="append write control",public=""`;
211 |   return `user="read write append control",public="read"`;
212 | }
213 | 
214 | function createAllowHeader(requestPath) {
215 |   // root/ root/.acl can't be deleted
216 |   let del = (requestPath === '/' || requestPath === '/.acl') ? '' : ',DELETE'
217 |   // no PATCH on Container
218 |   if (requestPath.endsWith('/')) return 'OPTIONS,HEAD,GET,POST,PUT' + del
219 |   // no POST on Document
220 |   else return 'OPTIONS,HEAD,GET,PATCH,PUT' + del
221 | }
222 | 
223 | function createAcceptHeader(request, headers) {
224 |   const status = headers.status
225 |   // no Accept header
226 |   if (request.method.match(/DELETE/) || status >= 500 || status.toString().match(/401|403/)) return headers
227 |   // Accept headers on container
228 |   if (request.url.endsWith('/')) {
229 |     if (status === 404) headers['accept-put'] = ['*/*'];
230 |     headers['accept-post'] = ['*/*'];
231 |   } else {
232 |     // Accept headers on document
233 |     headers['accept-put'] = ['*/*'];
234 |     headers['accept-patch'] = ['text/n3', 'application/sparql-update'];
235 |     headers['ms-author-via'] = ["SPARQL"];
236 |   }
237 |   return headers
238 | }
239 | 
240 | function createLinkHeader(item) {
241 |   let isContainer = item.isContainer;
242 |   let fn = item.pathname.replace(/\/$/,'');
243 |   fn = fn.replace(/.*\//,'');
244 |   let ext = item.extension;
245 |   if (ext === '.acl') // .acl not controlledBy or describedBy anything
246 |     return `<http://www.w3.org/ns/ldp#Resource>; rel="type"`;
247 |   else if (ext === '.meta') {
248 |     return `<${fn}.acl>; rel="acl"` // .meta controlledBy .meta.acl
249 |         + `, <http://www.w3.org/ns/ldp#Resource>; rel="type"`;
250 |   }
251 |   else if (isContainer) {
252 |     return  `<.meta>; rel="describedBy", <.acl>; rel="acl"` + `, <http://www.w3.org/ns/ldp#Container>; rel="type"` + `, <http://www.w3.org/ns/ldp#BasicContainer>; rel="type"` + `, <http://www.w3.org/ns/ldp#Resource>; rel="type"`;
253 |   }
254 |   else {
255 |     let link = `<${fn}.meta>; rel="describedBy", <${fn}.acl>; rel="acl"` + `, <http://www.w3.org/ns/ldp#Resource>; rel="type"`;
256 |     return link;
257 |   }  
258 | } // THE END!
259 | 


--------------------------------------------------------------------------------
/file/src/index.js:
--------------------------------------------------------------------------------
  1 | import libPath from "path";
  2 | import { Readable } from "stream";
  3 | import SolidRest from "../../../core/";
  4 | import fs from "fs-extra";
  5 | import mime from "mime-types"; // import concatStream from "concat-stream";
  6 | 
  7 | export class SolidRestFile {
  8 | 
  9 |   /**
 10 |    * file system backend for Solid-Rest
 11 |    * @constructor
 12 |    * @return {prefix:"file",name:"solid-rest-file-version"}
 13 |    */
 14 |   constructor() {
 15 |     this.prefix = "file";
 16 |     this.name = "solid-rest-file-2.1.4";
 17 |     return new SolidRest({
 18 |       plugin: this
 19 |     });
 20 |   }
 21 | 
 22 |   /**
 23 |    * check if file exists
 24 |    * @param filePath
 25 |    * @return {boolean}
 26 |    */
 27 |   async itemExists(path) {
 28 |     return fs.existsSync(path);
 29 |   }
 30 | 
 31 |   /**
 32 |    * check file's content-type
 33 |    * @param filePath
 34 |    * @return {string}
 35 |    */
 36 |   async getContentType(path) {
 37 |     return await mime.lookup(path);
 38 |   }
 39 | 
 40 |   /**
 41 |    * get path handler
 42 |    * @param filePath
 43 |    * @return {string}
 44 |    */
 45 |   async getPathHandler(path) {
 46 |     if (path.startsWith('file')) {
 47 |       return libPath;                                                   
 48 |     }
 49 |     else {                                                                
 50 |       return libPath.posix;
 51 |     }
 52 |   }
 53 | 
 54 |   /**
 55 |    * check if thing is Container or Resource
 56 |    * @param filePath
 57 |    * @return { type: "Container"|"Resource", metadata: stat } | {}
 58 |    */
 59 | 
 60 | 
 61 |   async itemType(path) {
 62 |     let stat;
 63 | 
 64 |     try {
 65 |       stat = await fs.lstatSync(path);
 66 |     } catch (err) {}
 67 | 
 68 |     if (!stat) return {};
 69 |     if (stat.isSymbolicLink()) {
 70 |        return { type: "Container", metadata: stat };
 71 |     };
 72 |     if (stat.isDirectory()) return { type: "Container", metadata: stat };
 73 |     if (stat.isFile()) return { type: "Resource", metadata: stat };
 74 |     return {};
 75 |   }
 76 |   /**
 77 |    * read a folder
 78 |    * @param filePath
 79 |    * @return on success : a possibly empty array of child fileNames (not paths)
 80 |    * @return on failure : false
 81 |    */
 82 | 
 83 | 
 84 |   async getContainer(pathname) {
 85 | //    if( !this.itemExists(pathname)) return 404;
 86 |     let files;
 87 |     let newFiles = [];
 88 | 
 89 |     try {
 90 |       files = await fs.readdirSync(pathname);
 91 |       for (var f in files) {
 92 |         if(files[f].startsWith('.')) continue;
 93 |         if(files[f].startsWith('#')) continue;
 94 |         if(!pathname.endsWith('/')) pathname = pathname + "/";
 95 |         newFiles.push(await this.getItemInfo(pathname + files[f]));
 96 |       }
 97 |     } catch (e) {
 98 | //      console.log(e);
 99 |       return(e);
100 |     }
101 | 
102 |     return newFiles;
103 |   }
104 |   /**
105 |    * examine a requested item
106 |    * @param filePath, request object
107 |    * @return item object
108 |    */
109 | 
110 | 
111 |   async getItemInfo(fn) {
112 |     fn = fn.replace(/^file:\/\//, '');
113 |     let mimetype = await mime.lookup(fn); // mimetype from ext
114 | 
115 |     const { type, metadata } = await this.itemType(fn); // Container/Resource and metadata
116 |     let itemType = type
117 | 
118 |     let exists = await this.itemExists(fn);
119 |     if (!type && fn.endsWith('/')) itemType = "Container";
120 |     let read = true, write = true;
121 |     if (exists) {
122 |       try {
123 |         fs.accessSync(fn, fs.constants.R_OK);
124 |       } catch (e) {
125 |         read = false;
126 |       }
127 | 
128 |       try {
129 |         fs.accessSync(fn, fs.constants.W_OK);
130 |       } catch (e) {
131 |         write = false;
132 |       }
133 |     }
134 | 
135 |     let mode = {
136 |       read: read,
137 |       write: write,
138 |       append: write,
139 |       control: write
140 |     };
141 |     let item = {
142 |       fileName: fn,
143 |       path: fn,
144 |       extension: mime.extension(fn),
145 |       mode: mode,
146 |       exists: exists,
147 |       isContainer: itemType === "Container" ? true : false,
148 |       mimetype: mimetype,
149 |       contentType: mimetype,
150 |       metadata: metadata
151 |     };
152 |     return Promise.resolve(item);
153 |   }
154 |   /**
155 |    * read a file
156 |    * @param filePath
157 |    * @return on success : body | Response object
158 |    * @return on failure false  | Response object
159 |    */
160 | 
161 | 
162 |   async getResource(pathname) {
163 |     let ctype, encoding, bodyData;
164 |     try {
165 |       ctype = mime.contentType(pathname) || "";
166 |       encoding = ctype.match(/text|application/) ? "utf8" : null;
167 |       bodyData = encoding ? await fs.readFile(pathname, encoding) : await fs.readFile(pathname);
168 |     } catch (e) {
169 |       console.log("Error" + e);
170 |       return false;
171 |     }
172 | 
173 |     return bodyData;
174 |   }
175 |   /**
176 |    * write a file
177 |    * @param filePath, content
178 |    * @return true | Response object on success
179 |    * @return false | Response object on failure
180 |    */
181 | 
182 | 
183 |   async putResource(pathname, content, ctype) {
184 |     let successCode = fs.existsSync(pathname) ?200 :201;
185 |     let failureCode = 500;
186 |     content = content || "";
187 |     return new Promise(async resolve => {
188 |       if(pathname.endsWith('/')) {
189 |         let res = await this.postContainer(pathname);      
190 |         resolve(res);
191 |         return res;
192 |       }
193 |       let writeIt = false;
194 |       if (typeof content === "undefined") content = "";
195 | 
196 |       if (typeof content === "string") {
197 |         writeIt = true;
198 |       } else if (content.stream) {
199 |         content = await content.stream();
200 |         content = await content.read();
201 |         writeIt = true;
202 |       } else if (content.text) {
203 |         content = await content.text();
204 |         writeIt = true;
205 |       }
206 | 
207 |       if (writeIt) {
208 |         try {
209 |           content = content || "";
210 |           await fs.writeFileSync(pathname, content);
211 |           return resolve(successCode);
212 |         } catch (e) {
213 |           console.log(e);
214 |           return resolve(failureCode);
215 |         }
216 |       }
217 | 
218 |       if (!content.pipe && typeof FileReader != "undefined") {
219 |         var fileReader = new FileReader();
220 | 
221 |         fileReader.onload = function () {
222 |           fs.writeFileSync(pathname, Buffer.from(new Uint8Array(this.result)));
223 |         };
224 | 
225 |         fileReader.onloadend = () => {
226 |           return resolve(successCode);
227 |         };
228 | 
229 |         fileReader.onerror = err => {
230 |           console.log(err);
231 |           return resolve(failureCode);
232 |         };
233 | 
234 |         fileReader.readAsArrayBuffer(content);
235 |       } else {
236 |         content = content || "";
237 |         content = this._makeStream(content);
238 |         content.pipe(fs.createWriteStream(pathname)).on('finish', () => {
239 |           return resolve(successCode);
240 |         }).on('error', err => {
241 |           console.log(err);
242 |           return resolve(failureCode);
243 |         });
244 |       }
245 |     });
246 |   }
247 |   /**
248 |    * delete file
249 |    * @param filePath
250 |    * @return true on success, false on failure
251 |    */
252 | 
253 | 
254 |   async deleteResource(fn) {
255 |     return new Promise(function (resolve) {
256 |      try {
257 |       fs.unlink(fn, function (err) {
258 |         if (err) resolve(false);else resolve(true);
259 |       });
260 |      } catch(e) { console.log(e); resolve(false) }
261 |     });
262 |   }
263 |   /**
264 |    * delete folder
265 |    * @param filePath
266 |    * @return true on success, false on failure
267 |    */
268 | 
269 | 
270 |   async deleteContainer(fn) {
271 |     return new Promise(async function (resolve) {
272 |      try {
273 |       await fs.rmdir(fn, function (err) {
274 |         if (err) {
275 |           resolve(false);
276 |         } else {
277 |           resolve(true);
278 |         }
279 |       });
280 |     } catch(e) { console.log(e); resolve(false) }
281 |     });
282 |   }
283 |   /**
284 |    * create folder
285 |    * @param filePath
286 |    * @return true on success, false on failure
287 |    */
288 | 
289 | 
290 |   async postContainer(fn) {
291 |     let successCode = fs.existsSync(fn) ?200 :201;
292 |     let failureCode = 500;
293 |     fn = fn.replace(/\/$/, '');
294 |     return new Promise(function (resolve) {
295 |       if (fs.existsSync(fn)) {
296 |         return resolve(successCode);
297 |       }
298 |       fs.mkdirp(fn, {}, err => {
299 |         if (err) {
300 |           return resolve(failureCode);
301 |         } else {
302 |           return resolve(successCode);
303 |         }
304 |       });
305 |     });
306 |   }
307 |   /**
308 |    * create parent and intermediate folders
309 |    * @param filePath
310 |    * @return true on success, false on failure
311 |    */
312 | 
313 | 
314 |   async makeContainers(pathname) {
315 |     const foldername = libPath.dirname(pathname);
316 | 
317 |     if (!fs.existsSync(foldername)) {
318 |       try {
319 |         fs.mkdirpSync(foldername);
320 |         return Promise.resolve(true);
321 |       } catch {
322 |         return Promise.resolve(false);
323 |       }
324 |     }
325 | 
326 |     return Promise.resolve(true);
327 |   }
328 |   /**
329 |    * creates a ReadableStream
330 |    * @param content as text or streamable object
331 |    * @return on success : a ReadableStream
332 |    * @return on failure : false
333 |    */
334 | 
335 | 
336 |   _makeStream(text) {
337 |     if (typeof text === 'object' && typeof text.stream === 'function') {
338 |       return text.stream();
339 |     }
340 | 
341 |     let s = new Readable();
342 |     s.push(text);
343 |     s.push(null);
344 |     return s;
345 |   }
346 | 
347 | } // end of SolidRestFile
348 | 
349 | /**
350 |  * return parent url with / at the end.
351 |  * If no parent exists return null
352 |  * @param {string} url 
353 |  * @returns {string|null}
354 | */
355 | 
356 | function getParent(url) {
357 |   while (url.endsWith('/')) url = url.slice(0, -1);
358 | 
359 |   if (!url.includes('/')) return null;
360 |   return url.substring(0, url.lastIndexOf('/')) + '/';
361 | } // ENDS
362 | 


--------------------------------------------------------------------------------
/browser/src/index.js:
--------------------------------------------------------------------------------
  1 | import {v4 as uuid} from 'uuid';
  2 | import SolidRest from '../../core/';
  3 | 
  4 | export default class SolidRestBrowser {
  5 | 
  6 |   /**
  7 |    * browser backend for Solid-Rest
  8 |    * @constructor
  9 |    * @param options 
 10 |    * @return {prefix:"browser",name:"solid-rest-browser-version"}
 11 |    */
 12 |   constructor(options) {
 13 |     options ||= {};
 14 |     this.DEBUG = options.DEBUG || false;
 15 |     this.prefix = "browser";
 16 |     this.name = "solid-rest-browser-2.0.0";
 17 |     this.ext = ".priv";
 18 |     this.currentItem = {};
 19 |     return new SolidRest({
 20 |       plugin: this
 21 |     });
 22 |   }
 23 | 
 24 |   getPathHandler(path) {
 25 |     return {
 26 |       sep: '/',
 27 |       join: (first,next)=>{
 28 |         return(first.replace(/\/$/,'')+'/'+second.replace(/^\//,''));
 29 |       },
 30 |       extname: (path)=>{
 31 |         return path.substr(path.lastIndexOf('.') + 1);
 32 |       },
 33 |       basename: (path)=>{
 34 |         return path.substr(path.lastIndexOf('/') + 1);
 35 |       },
 36 |     };
 37 |   }
 38 |   async configure(config){
 39 |     config ||= {
 40 |       fs: "MountableFileSystem",
 41 |       options: {
 42 |         '/LocalStorage':{ fs:"LocalStorage",options:{} },
 43 |         '/HTML5FS'     :{ fs:"HTML5FS",options:{size:10000} },
 44 |         '/IndexedDB'   :{ fs:"IndexedDB",options:{storeName:"IndexedDB"} }
 45 |       }
 46 |     }
 47 |     const self = this;
 48 |     return new Promise((resolve,reject)=>{
 49 |       BrowserFS.configure( config, async function(e,fs) {
 50 |         if(e) return reject(e);
 51 |         self.fs = BrowserFS.BFSRequire('fs');
 52 |         return resolve();
 53 |       })
 54 |     });
 55 |   }
 56 |   async hybridFetch(options){
 57 |     options ||= {};
 58 |     const scheme = {
 59 |       browser : this,
 60 |       http : options.fetch
 61 |     }
 62 |     return (uri,options)=>{
 63 |       const currentScheme = uri.replace(/:\/.*/,'').replace(/s$/,'');
 64 |       return scheme[currentScheme].fetch(uri,options);
 65 |     }
 66 |   }
 67 |   async configFetcher(kb,options){
 68 |     options ||= {};
 69 |     await this.configure(options.browserFSconfig);
 70 |     if(options.httpOnly)return $rdf.fetcher(kb,options);
 71 |     const scheme = {
 72 |       browser : this,
 73 |       http : options.fetch
 74 |     }
 75 |     const schemeFetch = (uri,options)=>{
 76 |       const currentScheme = uri.replace(/:\/.*/,'').replace(/s$/,'');
 77 |       return scheme[currentScheme].fetch(uri,options);
 78 |     }
 79 |     options.fetch = schemeFetch;
 80 |     return $rdf.fetcher(kb,options);  
 81 |   }
 82 | 
 83 |   /**
 84 |    * create parent and intermediate folders
 85 |    * @param filePath
 86 |    * @return true on success, false on failure
 87 |    */
 88 |   async makeContainers(pathname){
 89 |     const isContainer = pathname.endsWith('/');
 90 |     let inexistentParents = []
 91 |     // Get all parents which need to be created
 92 |     let curParent = this._getParent(pathname)
 93 |     while (curParent && !await this.exists(curParent)) {
 94 |       inexistentParents.push(curParent)
 95 |       curParent = this._getParent(curParent)
 96 |     }
 97 |     if (!curParent) // Should not happen, that we get to the root
 98 |       Promise.resolve(true);
 99 | 
100 |     if(isContainer) inexistentParents.push(pathname);
101 |     // Create missing parents
102 |     while (inexistentParents.length) {
103 |       let  container = inexistentParents.pop().slice(0, -1)
104 |       this.log("Creating container ",container)
105 |       try{
106 |         await this.createContainer(container);
107 |       }
108 |       catch(e){ console.warn(e); return Promise.resolve(true)}
109 |     }
110 |     return Promise.resolve(true);
111 |   }
112 |   async createContainer(path){
113 |     await this.fs.mkdir(path);
114 |     return await this.putMetadata(path+"/");
115 |   }
116 | 
117 |   _getParent(url) {
118 |     if(typeof url==='object')url=url.href;
119 |     while (url.endsWith('/')) url = url.slice(0, -1);
120 |     if (!url.includes('/')) return null;
121 |     return url.substring(0, url.lastIndexOf('/')) + '/';
122 |   }
123 | 
124 |   async getContentType(path,itemType){
125 |     if(itemType==="Container"||path.match(/\.(ttl|acl|meta)$/)||path.endsWith('/')) return "text/turtle"
126 |     try {
127 |       let r = await this.getResource(path+this.ext);
128 |       return (JSON.parse(r)).contentType;
129 |     }
130 |     catch(e){console.log(e);return null;}
131 |   }
132 |   async itemType(path) {
133 |     let st = await this.fs.statSync(path);
134 |     return st.isDirectory() ?"Container" :"Resource";
135 |   }
136 |   async exists(pathname){
137 |     return await this.fs.existsSync(pathname);
138 |   }
139 |   async itemExists(pathname){
140 |     return await this.fs.existsSync(pathname);
141 |   }
142 | 
143 |   async getItem(){
144 |     return this.currentItem;
145 |   }
146 | 
147 |   /**
148 |    * examine a requested item
149 |    * @param filePath, request object
150 |    * @return item object
151 |    */
152 |   async getItemInfo(path,request){
153 |     let mode = {
154 |       read: true,
155 |       write: true,
156 |       append: true,
157 |       control: true
158 |     };
159 |     if(request.method.match(/(PUT|POST|PATCH)/)){
160 |       await this.makeContainers(path);
161 |     }
162 |     let exists = await this.exists(path);
163 |     let itemType = exists ?await this.itemType(path) : null;
164 |     itemType ||= path.endsWith('/') ?"Container" :"Resource";
165 |     let ctype = exists ?await this.getContentType(path,itemType) :request.headers['content-type'];
166 |     this.currentItem = {
167 |       fileName: path,
168 |       path: path,
169 |       extension: "",
170 |       mode: mode,
171 |       exists,
172 |       isContainer: itemType === "Container" ? true : false,
173 |       mimetype: ctype,
174 |       contentType: ctype,
175 |     };
176 |     return(this.currentItem);
177 |    }
178 | 
179 |   /**
180 |    * read a file
181 |    * @param filePath
182 |    * @return on success : body | Response object
183 |    * @return on failure false  | Response object
184 |    */
185 |   async getResource(uri){
186 |     return new Promise((resolve,reject)=>{
187 |       this.fs.readFile(uri,'utf8',(err,content)=>{
188 |         if(err) return reject(err);
189 |         else return resolve(content);
190 |       })
191 |     });
192 |   }
193 | 
194 |   async getMetadata(path){
195 |     const r = await this.getResource(path+this.ext);
196 |     return JSON.parse(r);
197 |   }
198 | 
199 |   async putMetadata(path,content){
200 |     return new Promise( async (resolve,rect)=>{
201 |       const mtime = this.currentItem.mtime = Date.now();
202 |       const modified = this.currentItem.modified = (new Date).toUTCString();
203 |       const size = content ?this.currentItem.size =  (new Blob([content])).size :4096;
204 |       const contentType = this.currentItem.contentType;
205 |       const metadata= `{
206 |         "contentType" : "${contentType}",
207 |         "size" : "${size}",
208 |         "mtime" : "${mtime}",
209 |         "modified" : "${modified}"
210 |       }`;
211 |       return this.fs.writeFile(path+this.ext,metadata,'utf8',(err)=>{
212 |         if(err) return reject(err);
213 |         else {
214 |           return resolve(200);
215 |         }
216 |       })
217 |     })
218 |   }
219 | 
220 |   /**
221 |    * write a file
222 |    * @param filePath, content
223 |    * @return true | Response object on success
224 |    * @return false | Response object on failure
225 |    */
226 |   async putResource(uri,content){
227 |     if(uri.endsWith('/')) return this.makeContainers(uri);
228 |     this.log('Writing to '+uri);
229 | /*
230 |     const mtime = this.currentItem.mtime = Date.now();
231 |     const modified = this.currentItem.modified = (new Date).toUTCString();
232 |     const size = this.currentItem.size =  (new Blob([content])).size;
233 |     const contentType = this.currentItem.contentType;
234 |     const metadata = `{
235 |       "contentType" : "${contentType}",
236 |       "size" : "${size}",
237 |       "mtime" : "${mtime}",
238 |       "modified" : "${modified}"
239 |     }`;
240 | */
241 |     content ||= "";
242 |     return new Promise((resolve,reject)=>{
243 |       this.fs.writeFile(uri,content,'utf8',async (err)=>{
244 |         if(err) return reject(err);
245 |         else {
246 |           return resolve(await this.putMetadata(uri,content));
247 |         }
248 |       })
249 |     });
250 |   }
251 | 
252 |   /**
253 |    * create folder
254 |    * @param filePath
255 |    * @return true on success, false on failure
256 |    */
257 |   async postContainer(fn) {
258 |     let successCode = await this.fs.existsSync(fn) ?200 :201;
259 |     let failureCode = 500;
260 |     fn = fn.replace(/\/$/, '');
261 |     return new Promise(async function (resolve) {
262 |       if (await this.fs.existsSync(fn)) {
263 |         return resolve(successCode);
264 |       }
265 |       this.fs.mkdirp(fn, {}, err => {
266 |         if (err) {
267 |           return resolve(failureCode);
268 |         } else {
269 |           return resolve(successCode);
270 |         }
271 |       });
272 |     });
273 |   }
274 | 
275 |   /**
276 |    * delete file
277 |    * @param filePath
278 |    * @return true on success, false on failure
279 |    */
280 |   async deleteResource(fn) {
281 |     return new Promise(function (resolve) {
282 |      try {
283 |       fs.unlink(fn, function (err) {
284 |         if (err) resolve(false);else resolve(true);
285 |       });
286 |      } catch(e) { console.log(e); resolve(false) }
287 |     });
288 |   }
289 | 
290 |   /**
291 |    * delete folder
292 |    * @param filePath
293 |    * @return true on success, false on failure
294 |    */
295 |   async deleteContainer(fn) {
296 |     return new Promise(async function (resolve) {
297 |      try {
298 |       await fs.rmdir(fn, function (err) {
299 |         if (err) {
300 |           resolve(false);
301 |         } else {
302 |           resolve(true);
303 |         }
304 |       });
305 |     } catch(e) { console.log(e); resolve(false) }
306 |     });
307 |   }
308 | 
309 |   async getContainer(fn){
310 |     return new Promise( async (resolve, reject) => {
311 |       try {
312 |         this.fs.readdir(fn,async (err,folderArray)=>{
313 |           if(err) resolve(err)
314 |           else {
315 |             let newArray=[];
316 |             for(let f of folderArray){
317 |               if(!f.endsWith(this.ext)){
318 |                 newArray.push(await this.getItemInfo(fn+f,{method:'GET'}) );
319 |               }
320 |             }
321 | //console.log(22,newArray);
322 |             return resolve(newArray)
323 |           }
324 |         })
325 |       } catch(e) { resolve(e) }
326 |     })
327 |   }
328 | 
329 |   async dump(path) {
330 |     path ||= "/" 
331 |     path = path.replace(/^\/\//,'/');
332 |     if(path != '/') path = path + "/";
333 |     let top = await this.getContainer(path);
334 |     if(typeof top === 'string') return;;
335 |     for(let c of top){
336 |       let contains = await this.getContainer(c);
337 |       console.log(c,contains);
338 |     }
339 |   }
340 | 
341 |   log(...args){
342 |     if(this.DEBUG) console.log(args);
343 |   }
344 | 
345 | }
346 | 
347 | 


--------------------------------------------------------------------------------
/tests/all.js:
--------------------------------------------------------------------------------
  1 | const $rdf = require('rdflib');
  2 | const {SolidRestFile} = require('../file/');
  3 | const libUrl = require('url');
  4 | 
  5 | global.$rdf = $rdf;
  6 | const client = new SolidRestFile();
  7 | const kb = $rdf.graph();
  8 | const fetcher = $rdf.fetcher(kb,{fetch:client.fetch.bind(client)});
  9 | 
 10 | let [tests,fails,passes,res,allfails,slug,cSlug] = [0,0,0,0,'','']
 11 | 
 12 | 
 13 | async function main(){
 14 |   await run("file:")
 15 |   // await run("mem:")
 16 |   // await run("https:")
 17 |   if(allfails>0){
 18 |     process.exit(1)
 19 |   }
 20 |   else{
 21 |     process.exit(0)
 22 |   }
 23 | }
 24 | main()
 25 | 
 26 | async function getConfig(scheme){
 27 |   let host = scheme;
 28 |   if(scheme==="mem:"){
 29 |     scheme = "mem://" // = protocol 
 30 |     host = scheme;
 31 |   }
 32 |   else if(scheme==="file:") {
 33 |      host = scheme + "//";
 34 |      scheme = libUrl.pathToFileURL(process.cwd()).href
 35 |   }
 36 |   else if(scheme==="https:") {
 37 |    let session = await client.login()
 38 |    let webId = session.WebID
 39 |    if(! webId ) throw "Couldn't login!"
 40 |     host   = webId.replace("/profile/card#me",'')
 41 |     scheme = webId.replace("/profile/card#me",'')+"/public"
 42 |   }
 43 |   host = host || scheme;
 44 | 
 45 |   /*
 46 |    * we assume that test-folder exists and is empty
 47 |   */
 48 |   let  base   = scheme + "/test-folder4"
 49 |   let  c1name = "rest/"
 50 |   let  c2name = "deep-folder"
 51 |   let  r1name = "test1.ttl"
 52 |   let  r2name = "test2.ttl"
 53 |   let  meta = '.meta'
 54 |   let  folder1 = base +"/"+ c1name
 55 |   let  folder2 =  folder1 + c2name + "/"
 56 |   let  folder2meta = folder2 + meta
 57 |   let  deepR  =  folder2 +"test-file2.ttl"
 58 |   let  deepRacl = folder2 + "test-file2.ttl.acl"
 59 |   let  file1  = folder1 + r1name
 60 |   let  file2  = folder2 + r2name
 61 |   let  missingFolder = base + "/noSuchThing/norThis/"
 62 |   let  missingFolderPost = base + "/noSuchThingPost/"
 63 |   const patchSparql = `INSERT { :new <#temp> <#245>; <temp1> "n0:240" .}
 64 | 
 65 |   DELETE { <> a :test.}`
 66 |   const patchSparql1 = `INSERT { :new <#temp> <#245>; <temp1> "n0:240" .}
 67 |   DELETE { <> a :NONEXISTANT.}`
 68 | const patchN3_1 = (url) => `@prefix solid: <http://www.w3.org/ns/solid/terms#>.
 69 |   @prefix schem: <http://schema.org/>.
 70 |   @prefix : <#>.
 71 |   @prefix ex: <http://example.com#>.
 72 |   <> solid:patches <${url}>;
 73 |   solid:inserts { <> a :test; ex:temp :245. <#new> schem:temp1 :245; ex:temp1 :200 .}.`
 74 | const patchN3_2 = (url) => `@prefix solid: <http://www.w3.org/ns/solid/terms#>.
 75 |   @prefix schem: <http://schema.org/>.
 76 |   @prefix : <#>.
 77 |   @prefix ex: <http://example.com#>.
 78 |   <> solid:patches <${url}>;
 79 |   solid:deletes { <> a :test. }.`
 80 | const  patchN3_3 = (url) => `@prefix solid: <http://www.w3.org/ns/solid/terms#>.
 81 |   @prefix : <#>.
 82 |   @prefix ex: <http://example.com#>.
 83 |   <> solid:patches <${url}>;
 84 |   solid:deletes { <> a :test. };
 85 |   solid:where { ?a ex:temp1 :200. };
 86 |   solid:inserts { ?a ex:temp :321; ex:temp1 :250, :300. }.`
 87 | const resPatchSparql = [`@prefix : <#>.
 88 | 
 89 | <#new> <temp1> "n0:240"; <#temp> <#245>.
 90 | 
 91 | `,
 92 | 
 93 | `@prefix : <#>.
 94 | @prefix rest: <./>.
 95 | 
 96 | :new rest:temp1 "n0:240"; :temp :245 .
 97 | 
 98 | `]
 99 | const resPatchN3_1 = [`@prefix : <#>.
100 | @prefix ex: <http://example.com#>.
101 | @prefix schem: <http://schema.org/>.
102 | 
103 | <> a <#test>; ex:temp <#245>.
104 | 
105 | <#new> <temp1> "n0:240"; <#temp> <#245>; ex:temp1 <#200>; schem:temp1 <#245>.
106 | 
107 | `,
108 | `@prefix : <#>.
109 | @prefix rest: <./>.
110 | @prefix ex: <http://example.com#>.
111 | @prefix schem: <http://schema.org/>.
112 | 
113 | <> a :test; ex:temp :245 .
114 | 
115 | :new rest:temp1 "n0:240"; :temp :245; ex:temp1 :200; schem:temp1 :245 .
116 | 
117 | `]
118 | const resPatchN3_2 = [`@prefix : <#>.
119 | @prefix ex: <http://example.com#>.
120 | @prefix schem: <http://schema.org/>.
121 | 
122 | <> ex:temp <#245>.
123 | 
124 | <#new>
125 |     <temp1> "n0:240";
126 |     <#temp> <#245>;
127 |     ex:temp <#321>;
128 |     ex:temp1 <#200>, <#250>, <#300>;
129 |     schem:temp1 <#245>.
130 | `,
131 | `@prefix : <#>.
132 | @prefix rest: <./>.
133 | @prefix ex: <http://example.com#>.
134 | @prefix schem: <http://schema.org/>.
135 | 
136 | <> ex:temp :245 .
137 | 
138 | :new
139 |     rest:temp1 "n0:240";
140 |     :temp :245;
141 |     ex:temp :321;
142 |     ex:temp1 :200, :250, :300;
143 |     schem:temp1 :245.
144 | `]
145 |   let cfg =  {
146 |     host   : host,
147 |     base   : base,
148 |     dummy  : base + "/dummy.txt",
149 |     c1name : c1name,
150 |     c2name : c2name,
151 |     r1name : r1name,
152 |     r2name : r2name,
153 |     meta : meta,
154 |     folder1 : folder1,
155 |     folder2 : folder2,
156 |     folder2meta : folder2meta,
157 |     deepR  :  deepR,
158 |     deepRacl : deepRacl,
159 |     file1  : file1,
160 |     file2  : file2,
161 |     missingFolder : missingFolder,
162 |     text   : "<> a <#test>.",
163 |     patchN3_1 : patchN3_1(file1),
164 |     patchN3_2 : patchN3_2(file1),
165 |     patchN3_3 : patchN3_3(file1),
166 |     patchSparql: patchSparql,
167 |     patchSparql1: patchSparql1,
168 |     resPatchSparql: resPatchSparql,
169 |     resPatchN3_1 : resPatchN3_1,
170 |     resPatchN3_2 : resPatchN3_2
171 |   }
172 |   return(cfg)
173 | }
174 | 
175 | // if set to 0, skips those tests
176 | const check = {
177 |   headers:1,
178 |   patch:1,
179 | }
180 | async function run(scheme){
181 | 
182 | 
183 |   [tests,fails,passes] = [0,0,0]
184 |   let cfg = await getConfig(scheme)
185 |   let res
186 |   let res1
187 | 
188 |   if(scheme==="mem:")  cfg.base += "/"
189 |   try {res=await PUT(cfg.dummy)}catch(e){console.log(e)}
190 | 
191 |   console.warn(`\nTesting ${cfg.base} ...`)
192 | 
193 |   /// POST
194 |   res = await postFolder( cfg.base,cfg.c1name )
195 |   ok( "400 post container with trailing slash on slug", res.status==400,res)
196 | 
197 |   cfg.c1name = cfg.c1name.replace(/\/$/,'')
198 | 
199 |   res = await postFolder( cfg.base,cfg.c1name )
200 |   ok( "201 post container", res.status==201 || res.status==200,res)
201 | 
202 | if(check.headers){
203 |   let loc = res.headers.get('location')
204 |   ok( "post container returns location header",loc.match(`${cfg.c1name}/`))
205 | 
206 |   res = await postFolder( cfg.base,cfg.c1name )
207 |   cSlug = res.headers.get('location')
208 |   ok( "post container returns location header (new slug generated)",  cfg.folder1!=cSlug && cSlug.match('-'+cfg.c1name)) 
209 | 
210 |   res = await postFolder( cfg.missingFolder,cfg.c2name )
211 |   ok( "404 post container, parent not found", res.status==404,res)
212 | 
213 |   res = await postFile( cfg.folder1,cfg.r1name,cfg.text )
214 |   ok( "201 post resource", res.status==201,res)
215 | 
216 |   loc = res.headers.get('location')
217 |   ok( "post resource returns location header",  loc.endsWith(cfg.r1name), loc) 
218 | 
219 |   res = await GET(cfg.folder1);
220 |   const gotText = await res.text();
221 |   const regex = new RegExp('<'+cfg.r1name+'>');
222 |   ok( "contained resources use relative path", gotText.match(regex), gotText )
223 | 
224 | //  NSS allows this and returns 201
225 | //  res = await postFile( cfg.folder1,cfg.meta )
226 | //  ok( "405 post aux resource", res.status==405,res)
227 | 
228 |   res = await postFile( cfg.folder1,cfg.r1name,cfg.txt )
229 |   ok( "201 post resource, resource found", res.status==201, res )
230 |   slug = res.headers.get('location') || "";
231 |   ok( "post resource returns location (new slug generated)", slug !== cfg.r1name && slug.endsWith('-test1.ttl'),res)
232 | }
233 | 
234 |   res = await GET(cfg.folder1);
235 |   gotText = await res.text();
236 |   const tmpSlug = slug.replace(/.*\//,'');
237 |   regex = new RegExp('<'+tmpSlug+'>');
238 |   ok( "contained resources use relative path with slugs", gotText.match(regex), gotText )
239 | 
240 | 
241 | 
242 |   res = await postFile( cfg.missingFolder,cfg.file2 )
243 |   ok( "404 post resource, parent not found", res.status==404,res)
244 | 
245 |   // PUT
246 | 
247 |   res = await PUT( cfg.folder1 )
248 |   ok( "201 put container", res.status==201,res)
249 | 
250 |   res = await PUT( cfg.file1,cfg.text )
251 |   ok( "201 put resource", res.status==201,res)
252 | 
253 |   res = await PUT( cfg.file1,cfg.text )
254 |   ok( "201 put resource, resource found", res.status==201,res)
255 | 
256 |   res = await PUT( cfg.deepR,cfg.text )
257 |   ok("201 put resource, parent not found (recursive creation)",res.status==201, res)
258 | 
259 |   res = await PUT( cfg.folder2meta,cfg.text )
260 |   ok("201 put container acl",res.status==201, res)
261 | 
262 |   // HEAD
263 |   res = await HEAD( cfg.deepR )
264 |   ok("200 head",res.status==200 && res.headers.get("allow"),res )
265 | 
266 |   res = await HEAD( cfg.missingFolder )
267 |   ok("404 head resource, not found",res.status==404,res )
268 | 
269 |   // GET
270 |   res = await GET( cfg.missingFolder )
271 |   ok("404 get container, not found",res.status==404,res )
272 | 
273 |   res = await GET( cfg.file1 )
274 |   ok("200 get resource",res.status==200 && await res.text()===cfg.text, res)
275 | 
276 |   res = await GET( cfg.folder1 )
277 |   let type = res.headers.get("content-type")
278 |   ok("200 get container",res.status==200 && type==="text/turtle",res)
279 | 
280 | if( check.patch ){
281 |   // PATCH 
282 |   res = await PATCH( cfg.file1,cfg.patchSparql, 'fake-contentType')
283 |   ok("415 patch wrong patch contentType",res.status==415, res)
284 | 
285 |   res = await PATCH( cfg.file1,cfg.text, 'application/sparql-update' )
286 |   ok("400 patch erroneous patchContent",res.status==400, res)
287 | 
288 | /* JZ: I CAN NOT GET THIS TO FAIL in file:
289 |  res = await PATCH( cfg.file1,cfg.patchSparql1, 'application/sparql-update' )
290 |  ok("409 patch failed, cannot delete not existant triple",res.status==409, res)
291 | */
292 |   res = await PATCH( cfg.file1,cfg.patchSparql, 'application/sparql-update' )
293 |   res1 = await GET( cfg.file1 )
294 |   ok("200 patch sparql insert, delete to existing resource",res.status==200 && testPatch(res1, cfg.resPatchSparql), res1)
295 | 
296 | 
297 |   res = await PATCH( cfg.file1,cfg.patchN3_1, 'text/n3' )
298 |   res1 = await GET( cfg.file1 )
299 |   //console.warn(res1.statusText.toString())
300 |   ok("200 patch n3 insert",res.status==200 && testPatch(res1, cfg.resPatchN3_1), res1)
301 | 
302 |   res = await PATCH( cfg.file1,cfg.patchN3_3, 'text/n3' )
303 |   res1 = await GET( cfg.file1 )
304 |   ok("200 patch n3 delete, insert, where",res.status==200 && testPatch(res1, cfg.resPatchN3_2), res1)
305 | 
306 | }
307 |   // DELETE 
308 |   res = await DELETE( cfg.file1 )  // delete r1.name
309 |   ok("200 delete resource",res.status==200,res)
310 | 
311 |   res = await DELETE( cfg.folder1 )
312 |   ok("409 delete container, not empty",res.status==409,res)
313 | 
314 |   res = await DELETE( cfg.deepR )
315 |   ok("200 delete resource with acl", res.status===200, res)
316 | 
317 |   res = await DELETE( cfg.folder2meta)
318 |   ok("200 delete folder with meta", res.status===200, res)
319 | 
320 | if(check.headers && typeof slug !='undefined'){
321 |   res = await DELETE( cfg.host + slug )
322 | //  res = await DELETE( slug )
323 |   ok("200 delete resource",res.status==200,res)
324 | }
325 | 
326 |   // Cleaning
327 |   res = await DELETE( cfg.base+'/dummy.txt' )
328 |   res = await DELETE( cfg.base+'dummy.txt' )
329 | 
330 |   res = await DELETE( cfg.folder2 )
331 | 
332 |   res = await DELETE( cfg.folder1 )
333 | 
334 |   if(check.headers && typeof cSlug!='undefined'){
335 |     res = await DELETE( cfg.host + cSlug )
336 | //    res = await DELETE( cSlug )
337 |   }
338 | 
339 |   cfg.base = cfg.base.endsWith("/") ? cfg.base : cfg.base+"/"
340 |   res = await DELETE( cfg.base )
341 |   ok("200 delete container",res.status==200,res)
342 | 
343 |   let skipped = 33 - passes - fails;
344 |   console.warn(`${passes}/33 tests passed, ${fails} failed, ${skipped} skipped\n`)
345 |   allfails = allfails + fails
346 | }
347 | /* =========================================================== */
348 | /* REST METHODS                                                */
349 | /* =========================================================== */
350 | async function GET(url){
351 |   return await client.fetch( url, {method:"GET"} )
352 | }
353 | async function HEAD(url){
354 |   return await client.fetch( url, {method:"HEAD"} )
355 | }
356 | async function PUT(url,text){
357 |   return await client.fetch( url, {method:"PUT",body:text,headers:{"content-type":"text/turtle"}} )
358 | }
359 | async function PATCH(url, patchContent, patchContentType){
360 | // try {
361 |   return await client.fetch(url, {
362 |     method: 'PATCH',
363 |     body:patchContent,
364 |     headers:{
365 |       'Content-Type': patchContentType,
366 |       link: '<http://www.w3.org/ns/ldp#Resource>; rel="type"'
367 |     },
368 |     relative: true
369 |   })
370 | // } catch(e){}
371 | } 
372 | async function DELETE(url){
373 |   return await client.fetch( url, {method:"DELETE"} )
374 | }
375 | async function POST(parent,item,content,link){
376 |   return await client.fetch( parent,{
377 |     method:"POST",
378 |     headers:{slug:item,link:link,"content-type":"text/turtle"},
379 |     body:content
380 |   })
381 | }
382 | async function postFile(parent,file,content){
383 |   let link = '<http://www.w3.org/ns/ldp#Resource>; rel="type"'
384 |   return POST(parent,file,content,link)
385 | }
386 | async function postFolder(parent,folder){
387 |   let link ='<http://www.w3.org/ns/ldp#BasicContainer>; rel="type"'
388 |   return POST(parent,folder,'',link)
389 | }
390 | 
391 | /* ============================================== */
392 | 
393 | function ok( label, success,res ){
394 |    tests = tests + 1;   
395 |    if(success) passes = passes + 1
396 |    else fails = fails+1
397 |    let msg = success ? "ok " : "FAIL "
398 |    console.warn( "  " + msg + label)
399 |    if(!success && res ) console.warn(res.status,res.statusText)
400 |    return success
401 | }
402 | 
403 | async function testPatch (res, resPatch) {
404 |   let content = await res.text();
405 | //  if(!content) console.log("No body from PATCH",resPatch);
406 |   return resPatch.find(string => string === content)
407 | }
408 | 


--------------------------------------------------------------------------------
/file/tests/all.js:
--------------------------------------------------------------------------------
  1 | const $rdf = global.$rdf = require('rdflib');
  2 | const {SolidRestFile} = require('../');
  3 | const libUrl = require('url');
  4 | 
  5 | global.$rdf = $rdf;
  6 | const client = new SolidRestFile();
  7 | const kb = $rdf.graph();
  8 | const fetcher = $rdf.fetcher(kb,{fetch:client.fetch.bind(client)});
  9 | 
 10 | let [tests,fails,passes,res,allfails,slug,cSlug] = [0,0,0,0,'','']
 11 | 
 12 | 
 13 | async function main(){
 14 |   await run("file:")
 15 |   // await run("https:")
 16 |   // await run("mem:")
 17 |   if(allfails>0){
 18 |     process.exit(1)
 19 |   }
 20 |   else{
 21 |     process.exit(0)
 22 |   }
 23 | }
 24 | main()
 25 | 
 26 | async function getConfig(scheme){
 27 |   let host = scheme;
 28 |   if(scheme==="mem:"){
 29 |     scheme = "mem://" // = protocol 
 30 |     host = scheme;
 31 |   }
 32 |   else if(scheme==="file:") {
 33 |      host = scheme + "//";
 34 |      scheme = libUrl.pathToFileURL(process.cwd()).href
 35 |   }
 36 |   else if(scheme==="https:") {
 37 |    let session = await client.login()
 38 |    let webId = session.WebID
 39 |    if(! webId ) throw "Couldn't login!"
 40 |     host   = webId.replace("/profile/card#me",'')
 41 |     scheme = webId.replace("/profile/card#me",'')+"/public"
 42 |   }
 43 |   host = host || scheme;
 44 | 
 45 |   /*
 46 |    * we assume that test-folder exists and is empty
 47 |   */
 48 |   let  base   = scheme + "/test-folder4"
 49 |   let  root   = host + "/"
 50 |   let  rootAcl = host + "/.acl"
 51 |   let  c1name = "rest/"
 52 |   let  c2name = "deep-folder"
 53 |   let  r1name = "test1.ttl"
 54 |   let  r2name = "test2.ttl"
 55 |   let  meta = '.meta'
 56 |   let  folder1 = base +"/"+ c1name
 57 |   let  folder2 =  folder1 + c2name + "/"
 58 |   let  folder2meta = folder2 + meta
 59 |   let  deepR  =  folder2 +"test-file2.ttl"
 60 |   let  deepRacl = folder2 + "test-file2.ttl.acl"
 61 |   let  file1  = folder1 + r1name
 62 |   let  file2  = folder2 + r2name
 63 |   let  missingFolder = base + "/noSuchThing/norThis/"
 64 |   let  missingFolderPost = base + "/noSuchThingPost/"
 65 | 
 66 |   const patchSparql = `INSERT { :new <#temp> <#245>; <temp1> "n0:240" .}
 67 |   DELETE { <> a :test.}`
 68 |   const patchSparql1 = `INSERT { :new <#temp> <#245>; <temp1> "n0:240" .}
 69 |   DELETE { <> a :NONEXISTANT.}`
 70 | const patchN3_1 = (url) => `@prefix solid: <http://www.w3.org/ns/solid/terms#>.
 71 |   @prefix schem: <http://schema.org/>.
 72 |   @prefix : <#>.
 73 |   @prefix ex: <http://example.com#>.
 74 |   <> a solid:InsertDeletePatch ;
 75 |   solid:inserts { <> a :test; ex:temp :245. <#new> schem:temp1 :245; ex:temp1 :200 .}.`
 76 | const patchN3_2 = (url) => `@prefix solid: <http://www.w3.org/ns/solid/terms#>.
 77 |   @prefix schem: <http://schema.org/>.
 78 |   @prefix : <#>.
 79 |   @prefix ex: <http://example.com#>.
 80 |   <> a solid:InsertDeletePatch ;
 81 |   solid:deletes { <> a :test. }.`
 82 | const  patchN3_3 = (url) => `@prefix solid: <http://www.w3.org/ns/solid/terms#>.
 83 |   @prefix : <#>.
 84 |   @prefix ex: <http://example.com#>.
 85 |   <> a solid:InsertDeletePatch ;
 86 |   solid:deletes { <> a :test. };
 87 |   solid:where { ?a ex:temp1 :200. };
 88 |   solid:inserts { ?a ex:temp :321; ex:temp1 :250, :300. }.`
 89 | const resPatchSparql = [`@prefix : <#>.
 90 | 
 91 | <#new> <temp1> "n0:240"; <#temp> <#245>.
 92 | 
 93 | `,
 94 | 
 95 | `@prefix : <#>.
 96 | @prefix rest: <./>.
 97 | 
 98 | :new rest:temp1 "n0:240"; :temp :245 .
 99 | 
100 | `]
101 | const resPatchN3_1 = [`@prefix : <#>.
102 | @prefix ex: <http://example.com#>.
103 | @prefix schem: <http://schema.org/>.
104 | 
105 | <> a <#test>; ex:temp <#245>.
106 | 
107 | <#new> <temp1> "n0:240"; <#temp> <#245>; ex:temp1 <#200>; schem:temp1 <#245>.
108 | 
109 | `,
110 | `@prefix : <#>.
111 | @prefix rest: <./>.
112 | @prefix ex: <http://example.com#>.
113 | @prefix schem: <http://schema.org/>.
114 | 
115 | <> a :test; ex:temp :245 .
116 | 
117 | :new rest:temp1 "n0:240"; :temp :245; ex:temp1 :200; schem:temp1 :245 .
118 | 
119 | `]
120 | const resPatchN3_2 = [`@prefix : <#>.
121 | @prefix ex: <http://example.com#>.
122 | @prefix schem: <http://schema.org/>.
123 | 
124 | <> ex:temp <#245>.
125 | 
126 | <#new>
127 |     <temp1> "n0:240";
128 |     <#temp> <#245>;
129 |     ex:temp <#321>;
130 |     ex:temp1 <#200>, <#250>, <#300>;
131 |     schem:temp1 <#245>.
132 | `,
133 | `@prefix : <#>.
134 | @prefix rest: <./>.
135 | @prefix ex: <http://example.com#>.
136 | @prefix schem: <http://schema.org/>.
137 | 
138 | <> ex:temp :245 .
139 | 
140 | :new
141 |     rest:temp1 "n0:240";
142 |     :temp :245;
143 |     ex:temp :321;
144 |     ex:temp1 :200, :250, :300;
145 |     schem:temp1 :245.
146 | `]
147 |   let cfg =  {
148 |     host   : host,
149 |     base   : base,
150 |     root   : root,
151 |     rootAcl : rootAcl,
152 |     dummy  : base + "/dummy.txt",
153 |     c1name : c1name,
154 |     c2name : c2name,
155 |     r1name : r1name,
156 |     r2name : r2name,
157 |     meta : meta,
158 |     folder1 : folder1,
159 |     folder2 : folder2,
160 |     folder2meta : folder2meta,
161 |     deepR  :  deepR,
162 |     deepRacl : deepRacl,
163 |     file1  : file1,
164 |     file2  : file2,
165 |     missingFolder : missingFolder,
166 |     missingFolderPost : missingFolderPost,
167 |     text   : "<> a <#test>.",
168 |     patchN3_1 : patchN3_1(file1),
169 |     patchN3_2 : patchN3_2(file1),
170 |     patchN3_3 : patchN3_3(file1),
171 |     patchSparql: patchSparql,
172 |     patchSparql1: patchSparql1,
173 |     resPatchSparql: resPatchSparql,
174 |     resPatchN3_1 : resPatchN3_1,
175 |     resPatchN3_2 : resPatchN3_2
176 |   }
177 |   return(cfg)
178 | }
179 | 
180 | // if set to 0, skips those tests
181 | const check = {
182 |   headers:1,
183 |   patch:1,
184 | }
185 | async function run(scheme){
186 | 
187 | 
188 |   [tests,fails,passes] = [0,0,0]
189 |   let cfg = await getConfig(scheme)
190 |   let res, res1
191 |   let acceptPatch, acceptPost, acceptPut
192 |   let allow
193 | 
194 |   if(scheme==="mem:")  cfg.base += "/"
195 |   try {res=await PUT(cfg.dummy)}catch(e){console.log(e)}
196 | 
197 |   console.warn(`\nTesting ${cfg.base} ...`)
198 | 
199 |   /// POST
200 |   res = await postFolder( cfg.base,cfg.c1name )
201 |   ok( "400 post container with trailing slash on slug", res.status==400,res)
202 | 
203 |   cfg.c1name = cfg.c1name.replace(/\/$/,'')
204 | 
205 |   res = await postFolder( cfg.base,cfg.c1name )
206 |   ok( "201 post container", res.status==201 || res.status==200,res)
207 | 
208 | if(check.headers){
209 | 
210 |   // POST CONTAINER LOCATION is slug + "/"
211 |   let loc = res.headers.get('location')
212 |   ok( "post container returns location header",loc.match(`${cfg.c1name}/`));
213 | 
214 |   res = await postFolder( cfg.base,cfg.c1name )
215 |   cSlug = res.headers.get('location')
216 |   ok( "post container returns location header (new slug generated)",  cfg.folder1!=cSlug && cSlug.match('-'+cfg.c1name)) 
217 | 
218 | 
219 |   res = await postFolder( cfg.missingFolderPost,cfg.c2name )
220 |   ok( "404 post container, parent not found", res.status==404,res)
221 | 
222 |   res = await postFile( cfg.folder1,cfg.r1name,cfg.text )
223 |   ok( "201 post resource", res.status==201,res)
224 | 
225 | 
226 |   // POST RESOURCE LOCATION is same as slug
227 |   loc = res.headers.get('location')
228 |   ok( "post resource returns location header",  loc.endsWith(cfg.r1name), loc) 
229 | 
230 |   res = await GET(cfg.folder1);
231 |   const gotText = await res.text();
232 |   const regex = new RegExp('<'+cfg.r1name+'>');
233 |   ok( "contained resources use relative path", gotText.match(regex), gotText )
234 | 
235 | //  NSS allows this and returns 201
236 | //  res = await postFile( cfg.folder1,cfg.meta )
237 | //  ok( "405 post aux resource", res.status==405,res)
238 | 
239 |   res = await postFile( cfg.folder1,cfg.r1name,cfg.txt )
240 |   ok( "201 post resource, resource found", res.status==201, res )
241 |   slug = res.headers.get('location') || "";
242 |   ok( "post resource returns location (new slug generated)", slug !== cfg.r1name && slug.endsWith('-test1.ttl'),res)
243 | 
244 | }
245 | 
246 |   res = await GET(cfg.folder1);
247 |   const gotText = await res.text();
248 |   const tmpSlug = slug.replace(/.*\//,'');
249 |   const regex = new RegExp('<'+tmpSlug+'>');
250 |   ok( "contained resources use relative path with slug", gotText.match(regex), gotText )
251 | 
252 |   slug = cfg.host + slug;
253 | //  slug = cfg.folder1 + slug;
254 | 
255 |   res = await postFile( cfg.missingFolderPost, cfg.r1name )
256 |   ok( "404 post resource, parent not found", res.status==404,res)
257 | 
258 |   // PUT
259 | 
260 |   res = await PUT( cfg.folder1 )
261 |   ok( "201 put container", res.status==201,res)
262 | 
263 |   res = await PUT( cfg.file1,cfg.text )
264 |   ok( "201 put resource", res.status==201,res)
265 | 
266 |   res = await PUT( cfg.file1,cfg.text )
267 |   ok( "201 put resource, resource found", res.status==201,res)
268 | 
269 |   res = await PUT( cfg.deepR,cfg.text )
270 |   ok("201 put resource, parent not found (recursive creation)",res.status==201, res)
271 | 
272 |   res = await PUT( cfg.folder2meta,cfg.text )
273 |   ok("201 put container acl",res.status==201, res)
274 | 
275 | //res = await GET(cfg.folder1);
276 | //console.log(await res.text());
277 | 
278 |   // HEAD
279 |   res = await HEAD( cfg.deepR )
280 |   ok("200 head",res.status==200,res )
281 | 
282 |   res = await HEAD( cfg.deepR )
283 |   ok("200 head Document, no POST in Allow header",res.status==200
284 |     //  && !res.headers.get("allow").match('POST'),res )
285 |     && res.headers.get("allow").indexOf('POST')>1, res)
286 | 
287 |   res = await HEAD( cfg.missingFolder )
288 |   ok("404 head", res.status === 404,res )
289 | 
290 |   res = await HEAD( cfg.missingFolder )
291 |   ok("404 head Container, no PATCH in Allow header", res.status === 404
292 |     //    && !res.headers.get("allow").match('PATCH'),res )
293 |     && res.headers.get("allow").indexOf('PATCH')>1,res )
294 | 
295 |   res = await HEAD( cfg.root )
296 |   ok("200 head root Container, no DELETE in Allow header", res.status === 200
297 |     && !res.headers.get("allow").match('DELETE'),res )
298 | 
299 |   res = await HEAD( cfg.root )
300 |   ok("200 head root Container, pim Storage header", res.status === 200
301 |     && res.headers.get("Link").indexOf('pim/space#Storage')>1,res )
302 | 
303 |   res = await HEAD( cfg.folder1 )
304 |   ok("200 head non root Container, no pim Storage header", res.status === 200
305 |     && !res.headers.get("Link").includes('pim/space#Storage'),res )
306 | 
307 |   res = await HEAD( cfg.rootAcl )
308 |   ok("404 head root/.acl, no DELETE in Allow header", res.status === 404
309 |     && !res.headers.get("allow").match('DELETE'),res )
310 | 
311 |   // GET
312 |   res = await GET( cfg.missingFolder )
313 |   ok("404 get container, not found",res.status==404,res )
314 | 
315 |   res = await GET( cfg.missingFolder )
316 |   acceptPut = res.headers.get('Accept-Put')
317 |   acceptPost = res.headers.get('Accept-Post')
318 |   acceptPatch = res.headers.get('Accept-Patch')
319 |   ok("404 get container, notfound, accept headers",res.status==404 && acceptPut === '*/*' && acceptPost === '*/*' && acceptPatch === null,res)
320 | 
321 |   res = await GET( cfg.file1 )
322 |   ok("200 get resource",res.status==200 && await res.text()===cfg.text, res)
323 | 
324 |   res = await GET( cfg.file1 )
325 |   acceptPut = res.headers.get('Accept-Put')
326 |   acceptPost = res.headers.get('Accept-Post')
327 |   acceptPatch = res.headers.get('Accept-Patch')
328 |   ok("200 get resource, accept headers",res.status==200 && acceptPut === '*/*' && acceptPost === null && acceptPatch === 'text/n3,application/sparql-update',res)
329 | 
330 |   res = await GET( cfg.folder1 )
331 |   let type = res.headers.get("content-type")
332 |   ok("200 get container",res.status==200 && type==="text/turtle",res)
333 | 
334 |   res = await GET( cfg.folder1 )
335 |   acceptPut = res.headers.get('Accept-Put')
336 |   acceptPost = res.headers.get('Accept-Post')
337 |   acceptPatch = res.headers.get('Accept-Patch')
338 |   ok("200 get container, accept headers",res.status==200 && acceptPut === null && acceptPost === '*/*' && acceptPatch === null,res)
339 | 
340 | if( check.patch ){
341 |   // PATCH 
342 |   res = await PATCH( cfg.file1,cfg.patchSparql, 'fake-contentType')
343 |   ok("415 patch wrong patch contentType",res.status==415, res)
344 | 
345 |   res = await PATCH( cfg.file1,cfg.text, 'application/sparql-update' )
346 |   ok("400 patch erroneous patchContent",res.status==400, res)
347 | 
348 |   res = await PATCH( cfg.file1,cfg.patchSparql1, 'application/sparql-update' )
349 |   ok("409 patch failed, cannot delete not existant triple",res.status==409, res)
350 | 
351 |   res = await PATCH( cfg.file1,cfg.patchSparql, 'application/sparql-update' )
352 |   res1 = await GET( cfg.file1 )
353 |   ok("200 patch sparql insert, delete to existing resource",res.status==200 && testPatch(res1, cfg.resPatchSparql), res1)
354 | 
355 |   res = await PATCH( cfg.file1,cfg.patchN3_1, 'text/n3' )
356 |   res1 = await GET( cfg.file1 )
357 |   // console.warn(res1.statusText.toString())
358 |   ok("200 patch n3 insert",res.status==200 && testPatch(res1, cfg.resPatchN3_1), res1)
359 | 
360 |   res = await PATCH( cfg.file1,cfg.patchN3_3, 'text/n3' )
361 |   res1 = await GET( cfg.file1 )
362 |   ok("200 patch n3 delete, insert, where",res.status==200 && testPatch(res1, cfg.resPatchN3_2), res1)
363 | 
364 | }
365 |   // DELETE 
366 |   res = await DELETE( cfg.file1 )  // delete r1.name
367 |   acceptPut = res.headers.get('Accept-Put')
368 |   acceptPost = res.headers.get('Accept-Post')
369 |   acceptPatch = res.headers.get('Accept-Patch')
370 |   ok("200 delete resource, no accept headers",res.status==200
371 |     && acceptPatch===null && acceptPost=== null && acceptPut=== null,res)
372 | 
373 |   res = await DELETE( cfg.folder1 )
374 |   ok("409 delete container, not empty",res.status==409,res)
375 | 
376 |   res = await DELETE( cfg.deepR )
377 |   ok("200 delete resource with acl", res.status===200, res)
378 | 
379 |   res = await DELETE( cfg.folder2meta)
380 |   ok("200 delete folder with meta", res.status===200, res)
381 | 
382 | if(check.headers && typeof slug !='undefined'){
383 |   res = await DELETE( slug )
384 |   ok("200 delete resource",res.status==200,res)
385 | }
386 | 
387 |   // Cleaning
388 |   res = await DELETE( cfg.base+'/dummy.txt' )
389 |   res = await DELETE( cfg.base+'dummy.txt' )
390 | 
391 |   res = await DELETE( cfg.folder2 )
392 | 
393 |   res = await DELETE( cfg.folder1 )
394 | 
395 |   if(check.headers && typeof cSlug!='undefined'){
396 |     res = await DELETE( cfg.host + cSlug )
397 |     res = await DELETE( cfg.missingFolderPost + cfg.r1name )
398 |     res = await DELETE( cfg.missingFolderPost + cfg.c2name )
399 |     res = await DELETE( cfg.missingFolderPost )
400 |   }
401 | 
402 |   cfg.base = cfg.base.endsWith("/") ? cfg.base : cfg.base+"/"
403 |   res = await DELETE( cfg.base )
404 |   ok("200 delete container",res.status==200,res)
405 | 
406 |   /* let skipped = 34 - passes - fails;
407 |   console.warn(`${passes}/${tests} tests passed, ${fails} failed, ${skipped} skipped\n`) */
408 |   console.warn(`${passes}/${tests} tests passed, ${fails} failed\n`)
409 |   allfails = allfails + fails
410 | }
411 | /* =========================================================== */
412 | /* REST METHODS                                                */
413 | /* =========================================================== */
414 | async function GET(url){
415 |   return await client.fetch( url, {method:"GET"} )
416 | }
417 | async function HEAD(url){
418 |   return await client.fetch( url, {method:"HEAD"} )
419 | }
420 | async function PUT(url,text){
421 |   return await client.fetch( url, {method:"PUT",body:text,headers:{"content-type":"text/turtle"}} )
422 | }
423 | async function PATCH(url, patchContent, patchContentType){
424 | // try {
425 |   return await client.fetch(url, {
426 |     method: 'PATCH',
427 |     body:patchContent,
428 |     headers:{
429 |       'Content-Type': patchContentType,
430 |       link: '<http://www.w3.org/ns/ldp#Resource>; rel="type"'
431 |     },
432 |     relative: true
433 |   })
434 | // } catch(e){}
435 | } 
436 | async function DELETE(url){
437 |   return await client.fetch( url, {method:"DELETE"} )
438 | }
439 | async function POST(parent,item,content,link){
440 |   return await client.fetch( parent,{
441 |     method:"POST",
442 |     headers:{slug:item,link:link,"content-type":"text/turtle"},
443 |     body:content
444 |   })
445 | }
446 | async function postFile(parent,file,content){
447 |   let link = '<http://www.w3.org/ns/ldp#Resource>; rel="type"'
448 |   return POST(parent,file,content,link)
449 | }
450 | async function postFolder(parent,folder){
451 |   let link ='<http://www.w3.org/ns/ldp#BasicContainer>; rel="type"'
452 |   return POST(parent,folder,'',link)
453 | }
454 | 
455 | /* ============================================== */
456 | 
457 | function ok( label, success,res ){
458 |    tests = tests + 1;   
459 |    if(success) passes = passes + 1
460 |    else fails = fails+1
461 |    let msg = success ? "ok " : "FAIL "
462 |    console.warn( "  " + msg + label)
463 |    if(!success && res ) console.warn(res.status,res.statusText)
464 |    return success
465 | }
466 | 
467 | async function testPatch (res, resPatch) {
468 |   let content = await res.text();
469 | //  if(!content) console.log("No body from PATCH",resPatch);
470 |   return resPatch.find(string => string === content)
471 | }
472 | 
473 | console.log = (...args)=>{
474 |   for(let a of args){
475 |     if(!a || !a.toString().match(/^\@\@\@/) ) console.warn(a);
476 |   }
477 | }
478 | 


--------------------------------------------------------------------------------
/browser/dist/solid-rest-browser.bundle.js:
--------------------------------------------------------------------------------
1 | /*! For license information please see solid-rest-browser.bundle.js.LICENSE.txt */
2 | !function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e():"function"==typeof define&&define.amd?define([],e):"object"==typeof exports?exports.SolidRestBrowser=e():t.SolidRestBrowser=e()}(self,(function(){return(()=>{var t={639:function(t,e,r){var n;t=r.nmd(t),function(s){e&&e.nodeType,t&&t.nodeType;var o="object"==typeof r.g&&r.g;o.global!==o&&o.window!==o&&o.self;var i,a=2147483647,h=36,c=/^xn--/,u=/[^\x20-\x7E]/,l=/[\x2E\u3002\uFF0E\uFF61]/g,p={overflow:"Overflow: input needs wider integers to process","not-basic":"Illegal input >= 0x80 (not a basic code point)","invalid-input":"Invalid input"},f=Math.floor,d=String.fromCharCode;function m(t){throw RangeError(p[t])}function y(t,e){for(var r=t.length,n=[];r--;)n[r]=e(t[r]);return n}function w(t,e){var r=t.split("@"),n="";return r.length>1&&(n=r[0]+"@",t=r[1]),n+y((t=t.replace(l,".")).split("."),e).join(".")}function g(t){for(var e,r,n=[],s=0,o=t.length;s<o;)(e=t.charCodeAt(s++))>=55296&&e<=56319&&s<o?56320==(64512&(r=t.charCodeAt(s++)))?n.push(((1023&e)<<10)+(1023&r)+65536):(n.push(e),s--):n.push(e);return n}function b(t){return y(t,(function(t){var e="";return t>65535&&(e+=d((t-=65536)>>>10&1023|55296),t=56320|1023&t),e+d(t)})).join("")}function T(t,e){return t+22+75*(t<26)-((0!=e)<<5)}function x(t,e,r){var n=0;for(t=r?f(t/700):t>>1,t+=f(t/e);t>455;n+=h)t=f(t/35);return f(n+36*t/(t+38))}function E(t){var e,r,n,s,o,i,c,u,l,p,d,y=[],w=t.length,g=0,T=128,E=72;for((r=t.lastIndexOf("-"))<0&&(r=0),n=0;n<r;++n)t.charCodeAt(n)>=128&&m("not-basic"),y.push(t.charCodeAt(n));for(s=r>0?r+1:0;s<w;){for(o=g,i=1,c=h;s>=w&&m("invalid-input"),((u=(d=t.charCodeAt(s++))-48<10?d-22:d-65<26?d-65:d-97<26?d-97:h)>=h||u>f((a-g)/i))&&m("overflow"),g+=u*i,!(u<(l=c<=E?1:c>=E+26?26:c-E));c+=h)i>f(a/(p=h-l))&&m("overflow"),i*=p;E=x(g-o,e=y.length+1,0==o),f(g/e)>a-T&&m("overflow"),T+=f(g/e),g%=e,y.splice(g++,0,T)}return b(y)}function v(t){var e,r,n,s,o,i,c,u,l,p,y,w,b,E,v,O=[];for(w=(t=g(t)).length,e=128,r=0,o=72,i=0;i<w;++i)(y=t[i])<128&&O.push(d(y));for(n=s=O.length,s&&O.push("-");n<w;){for(c=a,i=0;i<w;++i)(y=t[i])>=e&&y<c&&(c=y);for(c-e>f((a-r)/(b=n+1))&&m("overflow"),r+=(c-e)*b,e=c,i=0;i<w;++i)if((y=t[i])<e&&++r>a&&m("overflow"),y==e){for(u=r,l=h;!(u<(p=l<=o?1:l>=o+26?26:l-o));l+=h)v=u-p,E=h-p,O.push(d(T(p+v%E,0))),u=f(v/E);O.push(d(T(u,0))),o=x(r,b,n==s),r=0,++n}++r,++e}return O.join("")}i={version:"1.3.2",ucs2:{decode:g,encode:b},decode:E,encode:v,toASCII:function(t){return w(t,(function(t){return u.test(t)?"xn--"+v(t):t}))},toUnicode:function(t){return w(t,(function(t){return c.test(t)?E(t.slice(4).toLowerCase()):t}))}},void 0===(n=function(){return i}.call(e,r,e,t))||(t.exports=n)}()},41:t=>{"use strict";function e(t,e){return Object.prototype.hasOwnProperty.call(t,e)}t.exports=function(t,r,n,s){r=r||"&",n=n||"=";var o={};if("string"!=typeof t||0===t.length)return o;var i=/\+/g;t=t.split(r);var a=1e3;s&&"number"==typeof s.maxKeys&&(a=s.maxKeys);var h=t.length;a>0&&h>a&&(h=a);for(var c=0;c<h;++c){var u,l,p,f,d=t[c].replace(i,"%20"),m=d.indexOf(n);m>=0?(u=d.substr(0,m),l=d.substr(m+1)):(u=d,l=""),p=decodeURIComponent(u),f=decodeURIComponent(l),e(o,p)?Array.isArray(o[p])?o[p].push(f):o[p]=[o[p],f]:o[p]=f}return o}},145:t=>{"use strict";var e=function(t){switch(typeof t){case"string":return t;case"boolean":return t?"true":"false";case"number":return isFinite(t)?t:"";default:return""}};t.exports=function(t,r,n,s){return r=r||"&",n=n||"=",null===t&&(t=void 0),"object"==typeof t?Object.keys(t).map((function(s){var o=encodeURIComponent(e(s))+n;return Array.isArray(t[s])?t[s].map((function(t){return o+encodeURIComponent(e(t))})).join(r):o+encodeURIComponent(e(t[s]))})).join(r):s?encodeURIComponent(e(s))+n+encodeURIComponent(e(t)):""}},486:(t,e,r)=>{"use strict";e.decode=e.parse=r(41),e.encode=e.stringify=r(145)},883:(t,e,r)=>{"use strict";var n=r(639),s=r(225);function o(){this.protocol=null,this.slashes=null,this.auth=null,this.host=null,this.port=null,this.hostname=null,this.hash=null,this.search=null,this.query=null,this.pathname=null,this.path=null,this.href=null}e.parse=b,e.resolve=function(t,e){return b(t,!1,!0).resolve(e)},e.resolveObject=function(t,e){return t?b(t,!1,!0).resolveObject(e):e},e.format=function(t){return s.isString(t)&&(t=b(t)),t instanceof o?t.format():o.prototype.format.call(t)},e.Url=o;var i=/^([a-z0-9.+-]+:)/i,a=/:[0-9]*$/,h=/^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,c=["{","}","|","\\","^","`"].concat(["<",">",'"',"`"," ","\r","\n","\t"]),u=["'"].concat(c),l=["%","/","?",";","#"].concat(u),p=["/","?","#"],f=/^[+a-z0-9A-Z_-]{0,63}$/,d=/^([+a-z0-9A-Z_-]{0,63})(.*)$/,m={javascript:!0,"javascript:":!0},y={javascript:!0,"javascript:":!0},w={http:!0,https:!0,ftp:!0,gopher:!0,file:!0,"http:":!0,"https:":!0,"ftp:":!0,"gopher:":!0,"file:":!0},g=r(486);function b(t,e,r){if(t&&s.isObject(t)&&t instanceof o)return t;var n=new o;return n.parse(t,e,r),n}o.prototype.parse=function(t,e,r){if(!s.isString(t))throw new TypeError("Parameter 'url' must be a string, not "+typeof t);var o=t.indexOf("?"),a=-1!==o&&o<t.indexOf("#")?"?":"#",c=t.split(a);c[0]=c[0].replace(/\\/g,"/");var b=t=c.join(a);if(b=b.trim(),!r&&1===t.split("#").length){var T=h.exec(b);if(T)return this.path=b,this.href=b,this.pathname=T[1],T[2]?(this.search=T[2],this.query=e?g.parse(this.search.substr(1)):this.search.substr(1)):e&&(this.search="",this.query={}),this}var x=i.exec(b);if(x){var E=(x=x[0]).toLowerCase();this.protocol=E,b=b.substr(x.length)}if(r||x||b.match(/^\/\/[^@\/]+@[^@\/]+/)){var v="//"===b.substr(0,2);!v||x&&y[x]||(b=b.substr(2),this.slashes=!0)}if(!y[x]&&(v||x&&!w[x])){for(var O,C,P=-1,A=0;A<p.length;A++)-1!==(R=b.indexOf(p[A]))&&(-1===P||R<P)&&(P=R);for(-1!==(C=-1===P?b.lastIndexOf("@"):b.lastIndexOf("@",P))&&(O=b.slice(0,C),b=b.slice(C+1),this.auth=decodeURIComponent(O)),P=-1,A=0;A<l.length;A++){var R;-1!==(R=b.indexOf(l[A]))&&(-1===P||R<P)&&(P=R)}-1===P&&(P=b.length),this.host=b.slice(0,P),b=b.slice(P),this.parseHost(),this.hostname=this.hostname||"";var I="["===this.hostname[0]&&"]"===this.hostname[this.hostname.length-1];if(!I)for(var S=this.hostname.split(/\./),U=(A=0,S.length);A<U;A++){var _=S[A];if(_&&!_.match(f)){for(var q="",L=0,j=_.length;L<j;L++)_.charCodeAt(L)>127?q+="x":q+=_[L];if(!q.match(f)){var D=S.slice(0,A),F=S.slice(A+1),$=_.match(d);$&&(D.push($[1]),F.unshift($[2])),F.length&&(b="/"+F.join(".")+b),this.hostname=D.join(".");break}}}this.hostname.length>255?this.hostname="":this.hostname=this.hostname.toLowerCase(),I||(this.hostname=n.toASCII(this.hostname));var B=this.port?":"+this.port:"",N=this.hostname||"";this.host=N+B,this.href+=this.host,I&&(this.hostname=this.hostname.substr(1,this.hostname.length-2),"/"!==b[0]&&(b="/"+b))}if(!m[E])for(A=0,U=u.length;A<U;A++){var k=u[A];if(-1!==b.indexOf(k)){var H=encodeURIComponent(k);H===k&&(H=escape(k)),b=b.split(k).join(H)}}var M=b.indexOf("#");-1!==M&&(this.hash=b.substr(M),b=b.slice(0,M));var G=b.indexOf("?");if(-1!==G?(this.search=b.substr(G),this.query=b.substr(G+1),e&&(this.query=g.parse(this.query)),b=b.slice(0,G)):e&&(this.search="",this.query={}),b&&(this.pathname=b),w[E]&&this.hostname&&!this.pathname&&(this.pathname="/"),this.pathname||this.search){B=this.pathname||"";var W=this.search||"";this.path=B+W}return this.href=this.format(),this},o.prototype.format=function(){var t=this.auth||"";t&&(t=(t=encodeURIComponent(t)).replace(/%3A/i,":"),t+="@");var e=this.protocol||"",r=this.pathname||"",n=this.hash||"",o=!1,i="";this.host?o=t+this.host:this.hostname&&(o=t+(-1===this.hostname.indexOf(":")?this.hostname:"["+this.hostname+"]"),this.port&&(o+=":"+this.port)),this.query&&s.isObject(this.query)&&Object.keys(this.query).length&&(i=g.stringify(this.query));var a=this.search||i&&"?"+i||"";return e&&":"!==e.substr(-1)&&(e+=":"),this.slashes||(!e||w[e])&&!1!==o?(o="//"+(o||""),r&&"/"!==r.charAt(0)&&(r="/"+r)):o||(o=""),n&&"#"!==n.charAt(0)&&(n="#"+n),a&&"?"!==a.charAt(0)&&(a="?"+a),e+o+(r=r.replace(/[?#]/g,(function(t){return encodeURIComponent(t)})))+(a=a.replace("#","%23"))+n},o.prototype.resolve=function(t){return this.resolveObject(b(t,!1,!0)).format()},o.prototype.resolveObject=function(t){if(s.isString(t)){var e=new o;e.parse(t,!1,!0),t=e}for(var r=new o,n=Object.keys(this),i=0;i<n.length;i++){var a=n[i];r[a]=this[a]}if(r.hash=t.hash,""===t.href)return r.href=r.format(),r;if(t.slashes&&!t.protocol){for(var h=Object.keys(t),c=0;c<h.length;c++){var u=h[c];"protocol"!==u&&(r[u]=t[u])}return w[r.protocol]&&r.hostname&&!r.pathname&&(r.path=r.pathname="/"),r.href=r.format(),r}if(t.protocol&&t.protocol!==r.protocol){if(!w[t.protocol]){for(var l=Object.keys(t),p=0;p<l.length;p++){var f=l[p];r[f]=t[f]}return r.href=r.format(),r}if(r.protocol=t.protocol,t.host||y[t.protocol])r.pathname=t.pathname;else{for(var d=(t.pathname||"").split("/");d.length&&!(t.host=d.shift()););t.host||(t.host=""),t.hostname||(t.hostname=""),""!==d[0]&&d.unshift(""),d.length<2&&d.unshift(""),r.pathname=d.join("/")}if(r.search=t.search,r.query=t.query,r.host=t.host||"",r.auth=t.auth,r.hostname=t.hostname||t.host,r.port=t.port,r.pathname||r.search){var m=r.pathname||"",g=r.search||"";r.path=m+g}return r.slashes=r.slashes||t.slashes,r.href=r.format(),r}var b=r.pathname&&"/"===r.pathname.charAt(0),T=t.host||t.pathname&&"/"===t.pathname.charAt(0),x=T||b||r.host&&t.pathname,E=x,v=r.pathname&&r.pathname.split("/")||[],O=(d=t.pathname&&t.pathname.split("/")||[],r.protocol&&!w[r.protocol]);if(O&&(r.hostname="",r.port=null,r.host&&(""===v[0]?v[0]=r.host:v.unshift(r.host)),r.host="",t.protocol&&(t.hostname=null,t.port=null,t.host&&(""===d[0]?d[0]=t.host:d.unshift(t.host)),t.host=null),x=x&&(""===d[0]||""===v[0])),T)r.host=t.host||""===t.host?t.host:r.host,r.hostname=t.hostname||""===t.hostname?t.hostname:r.hostname,r.search=t.search,r.query=t.query,v=d;else if(d.length)v||(v=[]),v.pop(),v=v.concat(d),r.search=t.search,r.query=t.query;else if(!s.isNullOrUndefined(t.search))return O&&(r.hostname=r.host=v.shift(),(I=!!(r.host&&r.host.indexOf("@")>0)&&r.host.split("@"))&&(r.auth=I.shift(),r.host=r.hostname=I.shift())),r.search=t.search,r.query=t.query,s.isNull(r.pathname)&&s.isNull(r.search)||(r.path=(r.pathname?r.pathname:"")+(r.search?r.search:"")),r.href=r.format(),r;if(!v.length)return r.pathname=null,r.search?r.path="/"+r.search:r.path=null,r.href=r.format(),r;for(var C=v.slice(-1)[0],P=(r.host||t.host||v.length>1)&&("."===C||".."===C)||""===C,A=0,R=v.length;R>=0;R--)"."===(C=v[R])?v.splice(R,1):".."===C?(v.splice(R,1),A++):A&&(v.splice(R,1),A--);if(!x&&!E)for(;A--;A)v.unshift("..");!x||""===v[0]||v[0]&&"/"===v[0].charAt(0)||v.unshift(""),P&&"/"!==v.join("/").substr(-1)&&v.push("");var I,S=""===v[0]||v[0]&&"/"===v[0].charAt(0);return O&&(r.hostname=r.host=S?"":v.length?v.shift():"",(I=!!(r.host&&r.host.indexOf("@")>0)&&r.host.split("@"))&&(r.auth=I.shift(),r.host=r.hostname=I.shift())),(x=x||r.host&&v.length)&&!S&&v.unshift(""),v.length?r.pathname=v.join("/"):(r.pathname=null,r.path=null),s.isNull(r.pathname)&&s.isNull(r.search)||(r.path=(r.pathname?r.pathname:"")+(r.search?r.search:"")),r.auth=t.auth||r.auth,r.slashes=r.slashes||t.slashes,r.href=r.format(),r},o.prototype.parseHost=function(){var t=this.host,e=a.exec(t);e&&(":"!==(e=e[0])&&(this.port=e.substr(1)),t=t.substr(0,t.length-e.length)),t&&(this.hostname=t)}},225:t=>{"use strict";t.exports={isString:function(t){return"string"==typeof t},isObject:function(t){return"object"==typeof t&&null!==t},isNull:function(t){return null===t},isNullOrUndefined:function(t){return null==t}}},33:function(t,e){var r=function(t){function e(){this.fetch=!1,this.DOMException=t.DOMException}return e.prototype=t,new e}("undefined"!=typeof self?self:this);!function(t){!function(e){var r="URLSearchParams"in t,n="Symbol"in t&&"iterator"in Symbol,s="FileReader"in t&&"Blob"in t&&function(){try{return new Blob,!0}catch(t){return!1}}(),o="FormData"in t,i="ArrayBuffer"in t;if(i)var a=["[object Int8Array]","[object Uint8Array]","[object Uint8ClampedArray]","[object Int16Array]","[object Uint16Array]","[object Int32Array]","[object Uint32Array]","[object Float32Array]","[object Float64Array]"],h=ArrayBuffer.isView||function(t){return t&&a.indexOf(Object.prototype.toString.call(t))>-1};function c(t){if("string"!=typeof t&&(t=String(t)),/[^a-z0-9\-#$%&'*+.^_`|~]/i.test(t))throw new TypeError("Invalid character in header field name");return t.toLowerCase()}function u(t){return"string"!=typeof t&&(t=String(t)),t}function l(t){var e={next:function(){var e=t.shift();return{done:void 0===e,value:e}}};return n&&(e[Symbol.iterator]=function(){return e}),e}function p(t){this.map={},t instanceof p?t.forEach((function(t,e){this.append(e,t)}),this):Array.isArray(t)?t.forEach((function(t){this.append(t[0],t[1])}),this):t&&Object.getOwnPropertyNames(t).forEach((function(e){this.append(e,t[e])}),this)}function f(t){if(t.bodyUsed)return Promise.reject(new TypeError("Already read"));t.bodyUsed=!0}function d(t){return new Promise((function(e,r){t.onload=function(){e(t.result)},t.onerror=function(){r(t.error)}}))}function m(t){var e=new FileReader,r=d(e);return e.readAsArrayBuffer(t),r}function y(t){if(t.slice)return t.slice(0);var e=new Uint8Array(t.byteLength);return e.set(new Uint8Array(t)),e.buffer}function w(){return this.bodyUsed=!1,this._initBody=function(t){var e;this._bodyInit=t,t?"string"==typeof t?this._bodyText=t:s&&Blob.prototype.isPrototypeOf(t)?this._bodyBlob=t:o&&FormData.prototype.isPrototypeOf(t)?this._bodyFormData=t:r&&URLSearchParams.prototype.isPrototypeOf(t)?this._bodyText=t.toString():i&&s&&(e=t)&&DataView.prototype.isPrototypeOf(e)?(this._bodyArrayBuffer=y(t.buffer),this._bodyInit=new Blob([this._bodyArrayBuffer])):i&&(ArrayBuffer.prototype.isPrototypeOf(t)||h(t))?this._bodyArrayBuffer=y(t):this._bodyText=t=Object.prototype.toString.call(t):this._bodyText="",this.headers.get("content-type")||("string"==typeof t?this.headers.set("content-type","text/plain;charset=UTF-8"):this._bodyBlob&&this._bodyBlob.type?this.headers.set("content-type",this._bodyBlob.type):r&&URLSearchParams.prototype.isPrototypeOf(t)&&this.headers.set("content-type","application/x-www-form-urlencoded;charset=UTF-8"))},s&&(this.blob=function(){var t=f(this);if(t)return t;if(this._bodyBlob)return Promise.resolve(this._bodyBlob);if(this._bodyArrayBuffer)return Promise.resolve(new Blob([this._bodyArrayBuffer]));if(this._bodyFormData)throw new Error("could not read FormData body as blob");return Promise.resolve(new Blob([this._bodyText]))},this.arrayBuffer=function(){return this._bodyArrayBuffer?f(this)||Promise.resolve(this._bodyArrayBuffer):this.blob().then(m)}),this.text=function(){var t,e,r,n=f(this);if(n)return n;if(this._bodyBlob)return t=this._bodyBlob,r=d(e=new FileReader),e.readAsText(t),r;if(this._bodyArrayBuffer)return Promise.resolve(function(t){for(var e=new Uint8Array(t),r=new Array(e.length),n=0;n<e.length;n++)r[n]=String.fromCharCode(e[n]);return r.join("")}(this._bodyArrayBuffer));if(this._bodyFormData)throw new Error("could not read FormData body as text");return Promise.resolve(this._bodyText)},o&&(this.formData=function(){return this.text().then(T)}),this.json=function(){return this.text().then(JSON.parse)},this}p.prototype.append=function(t,e){t=c(t),e=u(e);var r=this.map[t];this.map[t]=r?r+", "+e:e},p.prototype.delete=function(t){delete this.map[c(t)]},p.prototype.get=function(t){return t=c(t),this.has(t)?this.map[t]:null},p.prototype.has=function(t){return this.map.hasOwnProperty(c(t))},p.prototype.set=function(t,e){this.map[c(t)]=u(e)},p.prototype.forEach=function(t,e){for(var r in this.map)this.map.hasOwnProperty(r)&&t.call(e,this.map[r],r,this)},p.prototype.keys=function(){var t=[];return this.forEach((function(e,r){t.push(r)})),l(t)},p.prototype.values=function(){var t=[];return this.forEach((function(e){t.push(e)})),l(t)},p.prototype.entries=function(){var t=[];return this.forEach((function(e,r){t.push([r,e])})),l(t)},n&&(p.prototype[Symbol.iterator]=p.prototype.entries);var g=["DELETE","GET","HEAD","OPTIONS","POST","PUT"];function b(t,e){var r,n,s=(e=e||{}).body;if(t instanceof b){if(t.bodyUsed)throw new TypeError("Already read");this.url=t.url,this.credentials=t.credentials,e.headers||(this.headers=new p(t.headers)),this.method=t.method,this.mode=t.mode,this.signal=t.signal,s||null==t._bodyInit||(s=t._bodyInit,t.bodyUsed=!0)}else this.url=String(t);if(this.credentials=e.credentials||this.credentials||"same-origin",!e.headers&&this.headers||(this.headers=new p(e.headers)),this.method=(n=(r=e.method||this.method||"GET").toUpperCase(),g.indexOf(n)>-1?n:r),this.mode=e.mode||this.mode||null,this.signal=e.signal||this.signal,this.referrer=null,("GET"===this.method||"HEAD"===this.method)&&s)throw new TypeError("Body not allowed for GET or HEAD requests");this._initBody(s)}function T(t){var e=new FormData;return t.trim().split("&").forEach((function(t){if(t){var r=t.split("="),n=r.shift().replace(/\+/g," "),s=r.join("=").replace(/\+/g," ");e.append(decodeURIComponent(n),decodeURIComponent(s))}})),e}function x(t,e){e||(e={}),this.type="default",this.status=void 0===e.status?200:e.status,this.ok=this.status>=200&&this.status<300,this.statusText="statusText"in e?e.statusText:"OK",this.headers=new p(e.headers),this.url=e.url||"",this._initBody(t)}b.prototype.clone=function(){return new b(this,{body:this._bodyInit})},w.call(b.prototype),w.call(x.prototype),x.prototype.clone=function(){return new x(this._bodyInit,{status:this.status,statusText:this.statusText,headers:new p(this.headers),url:this.url})},x.error=function(){var t=new x(null,{status:0,statusText:""});return t.type="error",t};var E=[301,302,303,307,308];x.redirect=function(t,e){if(-1===E.indexOf(e))throw new RangeError("Invalid status code");return new x(null,{status:e,headers:{location:t}})},e.DOMException=t.DOMException;try{new e.DOMException}catch(t){e.DOMException=function(t,e){this.message=t,this.name=e;var r=Error(t);this.stack=r.stack},e.DOMException.prototype=Object.create(Error.prototype),e.DOMException.prototype.constructor=e.DOMException}function v(t,r){return new Promise((function(n,o){var i=new b(t,r);if(i.signal&&i.signal.aborted)return o(new e.DOMException("Aborted","AbortError"));var a=new XMLHttpRequest;function h(){a.abort()}a.onload=function(){var t,e,r={status:a.status,statusText:a.statusText,headers:(t=a.getAllResponseHeaders()||"",e=new p,t.replace(/\r?\n[\t ]+/g," ").split(/\r?\n/).forEach((function(t){var r=t.split(":"),n=r.shift().trim();if(n){var s=r.join(":").trim();e.append(n,s)}})),e)};r.url="responseURL"in a?a.responseURL:r.headers.get("X-Request-URL");var s="response"in a?a.response:a.responseText;n(new x(s,r))},a.onerror=function(){o(new TypeError("Network request failed"))},a.ontimeout=function(){o(new TypeError("Network request failed"))},a.onabort=function(){o(new e.DOMException("Aborted","AbortError"))},a.open(i.method,i.url,!0),"include"===i.credentials?a.withCredentials=!0:"omit"===i.credentials&&(a.withCredentials=!1),"responseType"in a&&s&&(a.responseType="blob"),i.headers.forEach((function(t,e){a.setRequestHeader(e,t)})),i.signal&&(i.signal.addEventListener("abort",h),a.onreadystatechange=function(){4===a.readyState&&i.signal.removeEventListener("abort",h)}),a.send(void 0===i._bodyInit?null:i._bodyInit)}))}v.polyfill=!0,t.fetch||(t.fetch=v,t.Headers=p,t.Request=b,t.Response=x),e.Headers=p,e.Request=b,e.Response=x,e.fetch=v}({})}(r),delete r.fetch.polyfill,(e=r.fetch).default=r.fetch,e.fetch=r.fetch,e.Headers=r.Headers,e.Request=r.Request,e.Response=r.Response,t.exports=e}},e={};function r(n){var s=e[n];if(void 0!==s)return s.exports;var o=e[n]={id:n,loaded:!1,exports:{}};return t[n].call(o.exports,o,o.exports,r),o.loaded=!0,o.exports}r.d=(t,e)=>{for(var n in e)r.o(e,n)&&!r.o(t,n)&&Object.defineProperty(t,n,{enumerable:!0,get:e[n]})},r.g=function(){if("object"==typeof globalThis)return globalThis;try{return this||new Function("return this")()}catch(t){if("object"==typeof window)return window}}(),r.o=(t,e)=>Object.prototype.hasOwnProperty.call(t,e),r.nmd=t=>(t.paths=[],t.children||(t.children=[]),t);var n={};return(()=>{"use strict";r.d(n,{default:()=>N});var t=r(883);function e(e,r){const n=s(r);var i;if(n.headers=s(n.headers),n.method=(i=n.method)?i.toUpperCase():"GET",n.slug=n.headers.slug||n.slug||"",n.body=n.body||"",o(e)){n.url=e;const r=new t.Url(e);n.protocol=r.protocol}else n.url=null,n.malFormedUrl=!0;return n.url&&n.url.endsWith(".dummy")&&(n.headers["content-type"]="text/turtle",n.body=""),n}function s(t){let e={};for(var r in t)"host"===r?e.hostname=t[r]:e[r.toLowerCase()]=t[r];return e}const o=e=>{try{return new t.Url(e),!0}catch(t){return!1}};var i;async function a(e,r){let n,s;i=await this.perform("GET_PATH_HANDLER",e),e.startsWith("file")?(n=t.format(r.url),s=t.fileURLToPath(n)):(n=decodeURIComponent(e),s=t.parse(n).pathname);const o=await this.perform("GET_ITEM_INFO",s,r);if(o.mode=o.mode?o.mode:{read:!0,append:!0,write:!0},o.pathname=s,"DELETE"===r.method&&o.isContainer){let t=await this.perform("GET_FILES",o.pathname);t.filter?o.containedFiles=t.length:o.containedFiles=0}return this.getExtension=t=>("object"==typeof(t=t||this.item.pathname||"")&&(t=t.path),!t.startsWith(".")||(t.match(/\./g)||[]).length>1?i.extname(t):t),this.pathSep=i.sep,this.basename=i.extname,this.mungePath=(t,e,r)=>((t=i.join(t,e)).includes("\\")&&(t=t.replace(/\\/g,"/")),t),s="POST"===r.method?this.mungePath(o.pathname,r.slug):o.pathname,o.extension=this.getExtension(s),o.contentType=await this.getContentType(o.pathname),o.patchOnNonTurtle="PATCH"===r.method&&!o.contentType.match("text/turtle"),o.isAcl=s.match(/\.acl/),o.isAuxResource=!!s.match(/\.(acl|meta)$/),o}const h={DELETE:{mustExist:1,requiresWrite:1},POST:{requiresAppend:1,requiresContentType:1},GET:{mustExist:1,requiresRead:1},HEAD:{mustExist:1,requiresRead:1},OPTIONS:{requiresRead:1},PUT:{requiresWrite:1,requiresContentType:1},PATCH:{requiresWrite:1,requiresContentType:1},LOGIN:{}};async function c(t,e){const r=this.requestObj=await this.getRequest(t,e),n=this.item=await this.getItem(t,r);if(!r.url||!r.method)return 400;if(r.slug.endsWith("/"))return 400;if(r.originMismatch)return 403;if(r.unsupportedAcceptFormat)return 405;if("PATCH"===r.method&&!this.patch)return 405;if("POST"===r.method&&!r.headers.link)return 400;if(n.isContainer&&!n.contentType&&(n.contentType="text/turtle"),n.folderFileConfusion)return 400;if(n.patchOnNonRdf)return 400;if(n.isAuxResource&&(n.isAcl&&(r.method.requiresControl=!0),"POST"===r.method))return 403;n.mode.write&&(n.mode.append=!0);const s=h[r.method];if(s||console.log(55,r.method),!s)return 409;if(s.mustExist&&!n.exists)return 404;if(s.requiresRead&&!n.mode.read||s.requiresAppend&&!n.mode.append||s.requiresWrite&&!n.mode.write||s.requiresControl&&!n.mode.control)return 401;if(s.requiresContentType&&!r.headers["content-type"])return 400;if(!("POST"===r.method&&(this.item.pathname=await this.generateRandomSlug(this.item.pathname,r.slug)),"PUT"!==r.method&&"POST"!==r.method&&"PATCH"!==r.method||await this.perform("CREATE_INTERMEDIATE_CONTAINERS")))return 500;let o=await this.perform(r.method);return!o&&"DELETE"===r.method&&n.isContainer&&await this.perform("ITEM_EXISTS",this.item.pathname)?409:o}async function u(t,e,r,n){let s;switch(this.request=this.requestObj,t=t||this.request.method,this.item=this.item||{pathname:e},e=e||this.item.pathname,this.response=this.response||{headers:{}},t){case"STORAGE_NAME":return this.storage.name;case"ITEM_EXISTS":return e=e.replace("file://",""),await this.storage.itemExists(e);case"LOGIN":return await this.storage.login(this.request.loginoptions);case"ITEM_TYPE":return await this.storage.itemType(e);case"GET_CONTENT_TYPE":return await this.storage.getContentType(e).bind(this.storage);case"GET_PATH_HANDLER":return await this.storage.getPathHandler(e);case"GET_ITEM_INFO":return await this.storage.getItemInfo(e,this.request);case"GET_FILES":return await this.storage.getContainer(e);case"DELETE":return this.item.isContainer?(await this.perform("DELETE_AUX_RESOURCES",e),await this.storage.deleteContainer(e)):(await this.perform("DELETE_AUX_RESOURCES",e),await this.storage.deleteResource(e));case"DELETE_AUX_RESOURCES":const t=await this.getAuxResources(e)||[];try{return t.map((async t=>{s=await this.storage.deleteResource(t)})),!0}catch(t){return console.log(t),!1}return 200;case"CREATE_INTERMEDIATE_CONTAINERS":return await this.storage.makeContainers(e)||1;case"GET":if(this.item.isContainer){let t=await this.storage.getContainer(e);return t.headers?t:await this.containerAsTurtle(e,t,this.request.typewanted,this)}{let t=await this.storage.getResource(e);return!!t&&(t.headers?t:(this.response.body=t,this.response.headers.status=200,!0))}case"OPTIONS":case"HEAD":return!0;case"PUT":return r=r||this.request.body,n=n||this.item.contentType||"",await this.storage.putResource(e,r,n);case"FULL_PUT":return!!await this.storage.makeContainers(e)&&(void 0===r&&(r=this.request.body),n=n||this.item.contentType||"",await this.storage.putResource(e,r,n));case"POST":return this.request.headers.link.match("Container")?(this.response.headers.location=e+"/",await this.storage.postContainer(e,this.request)):(this.response.headers.location=e,await this.storage.putResource(e,this.request.body));case"PATCH":const o=this.item.contentType;if(!o.match(/(text\/turtle|text\/n3|application\/ld\+json|application\/rdf\+xml)/))return{status:409,body:"can not patch a file of type "+o};if(e.endsWith("/"))return{status:409,body:"can not patch a Container"};await this.storage.itemExists(e.replace("file://",""))||await this.perform("FULL_PUT",e,"",n);let i,a,h=await this.storage.getResource(e);h=h&&h.body?h.body:h,h="string"==typeof h?h:h.toString();try{if([a,i]=await this.patch.patchContent(h,o,this.request),200!==a)return{status:a,body:i}}catch(t){return t.length||(t=""),{status:t,statusText:t.toString()}}let c=await this.storage.putResource(e,i);return c=c&&c.body?c.body:c,c}}var l=r(33),p="undefined"!=typeof crypto&&crypto.getRandomValues&&crypto.getRandomValues.bind(crypto)||"undefined"!=typeof msCrypto&&"function"==typeof msCrypto.getRandomValues&&msCrypto.getRandomValues.bind(msCrypto),f=new Uint8Array(16);function d(){if(!p)throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");return p(f)}const m=/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i,y=function(t){return"string"==typeof t&&m.test(t)};for(var w=[],g=0;g<256;++g)w.push((g+256).toString(16).substr(1));const b=function(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,r=(w[t[e+0]]+w[t[e+1]]+w[t[e+2]]+w[t[e+3]]+"-"+w[t[e+4]]+w[t[e+5]]+"-"+w[t[e+6]]+w[t[e+7]]+"-"+w[t[e+8]]+w[t[e+9]]+"-"+w[t[e+10]]+w[t[e+11]]+w[t[e+12]]+w[t[e+13]]+w[t[e+14]]+w[t[e+15]]).toLowerCase();if(!y(r))throw TypeError("Stringified UUID is invalid");return r},T={200:"OK",201:"Created",400:"Bad Request",401:"Unauthorized",403:"Forbidden",404:"Not Found",405:"Method Not Allowed",408:"Request Timeout",415:"Unsupported Media Type",418:"I'm a teapot",420:"Smoke 'em if you got 'em",500:"Server error"};async function x(t,e){let r=!0,n=e.method||this.request.method||"GET",s={body:"",headers:{}};if("number"==typeof t)r=!1,s.headers.status=t;else if("boolean"==typeof t){let e=t?201:500;e=201===e&&n.match(/(GET|HEAD)/)?200:201,n.match(/OPTIONS/)&&(e=204),s.headers.status=e}else"string"==typeof t?(s.headers.status=200,s.body=t):"object"==typeof t&&(r=!1,s=t,s.headers=s.headers||{},s.headers.status=s.status,s.headers.statusText=s.statusText);n.match(/(PUT)/)&&200==s.headers.status&&(s.headers.status=201),n.match(/(DELETE|GET|HEAD)/)&&201==s.headers.status&&(s.headers.status=200);let o={};this.requestObj;const i=this.item,a=i.pathname;var h,c;a.replace(/.*\//,""),o["content-type"]=this.item.contentType,o.link=o.link||function(t){let e=t.isContainer,r=t.pathname.replace(/\/$/,"");r=r.replace(/.*\//,"");let n=t.extension;return".acl"===n?'<http://www.w3.org/ns/ldp#Resource>; rel="type"':".meta"===n?`<${r}.acl>; rel="acl",<http://www.w3.org/ns/ldp#Resource>; rel="type"`:e?'<.meta>; rel="describedBy", <.acl>; rel="acl",<http://www.w3.org/ns/ldp#Container>; rel="type",<http://www.w3.org/ns/ldp#BasicContainer>; rel="type"<http://www.w3.org/ns/ldp#Resource>; rel="type"':`<${r}.meta>; rel="describedBy", <${r}.acl>; rel="acl",<http://www.w3.org/ns/ldp#Resource>; rel="type"`}(i),o.allow=(h=this.patch,"OPTIONS,HEAD"+((c=this.item.mode).read?",GET":"")+(c.write?",POST,PUT,DELETE":"")+(c.write&&h?",PATCH":"")),o["wac-allow"]=function(t){return t.read||t.write?t.read&&!t.write?'user="read",public="read"':!t.read&&t.write?'user="append write control",public=""':'user="read write append control",public="read"':null}(this.item.mode),o.date=o.date||new Date(Date.now()).toISOString(),o["x-powered-by"]=o["x-powered-by"]||await this.perform("STORAGE_NAME"),this.response&&this.response.headers&&(o.location=this.response.headers.location),o.url=a,"POST"===n&&(o.url=this.request.url),this.patch&&(o["accept-patch"]=["application/sparql-update"],o["ms-author-via"]=["SPARQL"]);let u=s.body||this.response.body||"";Object.assign(o,s.headers),o.status=s.headers.status||this.response.headers.status||500;let p,f=this.request.headers.accept;for(var m of(f=f&&f.match(/ /)?null:f,f&&(f.match(/(text\/turtle|application\/ld\+json)/)?u=await async function(t,e,r,n){return new Promise((async(s,o)=>{let i=$rdf.sym(t),a=$rdf.graph();await $rdf.parse(e,a,t,r),$rdf.serialize(i,a,t,n,((t,e)=>t?o(t):s(e)))}))}(this.request.url,u.toString(),this.item.contentType,f):(o.status="405",o.statusText=`Unsupported content-type in accept header : ${f}`)),o.statusText=o.statusText||T[o.status],o.etag=`W/"${function(t,e,r){var n=(t=t||{}).random||(t.rng||d)();if(n[6]=15&n[6]|64,n[8]=63&n[8]|128,e){r=r||0;for(var s=0;s<16;++s)e[r+s]=n[s];return e}return b(n)}()}"`,o["content-length"]="undefined"!=typeof Buffer?Buffer.byteLength(u,"utf8"):"undefined"!=typeof Blob?new Blob([u]).size:77,Object.keys(o)))o[m]||delete o[m];if(o.url.match(/:/)||(o.url=(this.prefix||"file:")+"//"+o.url),"HEAD"===e.method){u="";for(let t of Object.keys(o))u+=`${t}:${o[t]}\n`}if(e.plainResponse)return{status:o.status,statusText:o.statusText,body:u,headers:o,url:o.url,location:o.location};r=!0,o=r?{status:o.status,statusText:o.statusText,headers:o,location:o.location,url:o.url}:o;try{p=new l.Response(u,o,{url:o.url})}catch(t){console.log("Error "+t)}return p}var E,v,O=0,C=0;const P=function(t,e,r){var n=e&&r||0,s=e||new Array(16),o=(t=t||{}).node||E,i=void 0!==t.clockseq?t.clockseq:v;if(null==o||null==i){var a=t.random||(t.rng||d)();null==o&&(o=E=[1|a[0],a[1],a[2],a[3],a[4],a[5]]),null==i&&(i=v=16383&(a[6]<<8|a[7]))}var h=void 0!==t.msecs?t.msecs:Date.now(),c=void 0!==t.nsecs?t.nsecs:C+1,u=h-O+(c-C)/1e4;if(u<0&&void 0===t.clockseq&&(i=i+1&16383),(u<0||h>O)&&void 0===t.nsecs&&(c=0),c>=1e4)throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");O=h,C=c,v=i;var l=(1e4*(268435455&(h+=122192928e5))+c)%4294967296;s[n++]=l>>>24&255,s[n++]=l>>>16&255,s[n++]=l>>>8&255,s[n++]=255&l;var p=h/4294967296*1e4&268435455;s[n++]=p>>>8&255,s[n++]=255&p,s[n++]=p>>>24&15|16,s[n++]=p>>>16&255,s[n++]=i>>>8|128,s[n++]=255&i;for(var f=0;f<6;++f)s[n+f]=o[f];return e||b(s)},A=[".acl",".meta"],R=A.concat(".meta.acl");async function I(t){console.log(`Creating pod at <${t}>`),t=(t=t.replace(/\/$/,"")).replace(/^[^:]*:\/\//,""),await this.perform("FULL_PUT",t+"/.acl","@prefix acl: <http://www.w3.org/ns/auth/acl#>.\n@prefix foaf: <http://xmlns.com/foaf/0.1/>.\n\n# The homepage is readable by the public\n<#public>\n    a acl:Authorization;\n    acl:agentClass foaf:Agent;\n    acl:accessTo <./>;\n    acl:mode acl:Read.\n\n# The owner has full access to every resource in their pod.\n# Other agents have no access rights,\n# unless specifically authorized in other .acl resources.\n<#owner>\n    a acl:Authorization;\n    acl:agent <./profile/card#me>;\n    # Set the access to the root storage folder itself\n    acl:accessTo <./>;\n    # All resources will inherit this authorization, by default\n    acl:default <./>;\n    # The owner has all of the access modes allowed\n    acl:mode\n        acl:Read, acl:Write, acl:Control.\n"),await this.perform("FULL_PUT",t+"/profile/card",'@prefix : <#>.\n@prefix jef: <../>.\n@prefix ldp: <http://www.w3.org/ns/ldp#>.\n@prefix inbox: <../inbox/>.\n@prefix pro: <./>.\n@prefix ter: <http://www.w3.org/ns/solid/terms#>.\n@prefix foaf: <http://xmlns.com/foaf/0.1/>.\n@prefix pim: <http://www.w3.org/ns/pim/space#>.\n@prefix n2: <http://>.\n@prefix n3: <https://>.\n@prefix vcard: <http://www.w3.org/2006/vcard/ns#>.\n@prefix sch: <http://schema.org/>.\n@prefix n1: <http://www.w3.org/ns/auth/acl#>.\n\npro:card a foaf:PersonalProfileDocument; foaf:maker :me; foaf:primaryTopic :me.\n\n:me\n    a sch:Person, foaf:Person;\n    vcard:fn "Local Solid User";\n    vcard:role "software developer";\n    n1:trustedApp\n            [\n                n1:mode n1:Append, n1:Control, n1:Read, n1:Write;\n                n1:origin <http://example.org>\n            ];\n    ldp:inbox inbox:;\n    pim:preferencesFile <../settings/prefs.ttl>;\n    pim:storage jef:;\n    ter:account jef:;\n    ter:privateTypeIndex <../settings/privateTypeIndex.ttl>;\n    ter:publicTypeIndex <../settings/publicTypeIndex.ttl>;\n    foaf:name "Local Solid User".\n'),await this.perform("FULL_PUT",t+"/settings/prefs.ttl",'@prefix : <#>.\n@prefix solid: <http://www.w3.org/ns/solid/terms#>.\n@prefix sp: <http://www.w3.org/ns/pim/space#>.\n@prefix dct: <http://purl.org/dc/terms/>.\n@prefix c: <../profile/card#>.\n@prefix mee: <http://www.w3.org/ns/pim/meeting#>.\n\n<> a sp:ConfigurationFile; dct:title "Preferences file".\n\nc:me\n    a solid:Developer, solid:PowerUser;\n    solid:privateTypeIndex <privateTypeIndex.ttl>;\n    solid:publicTypeIndex <publicTypeIndex.ttl>.\n'),await this.perform("FULL_PUT",t+"/settings/privateTypeIndex.ttl","\n@prefix solid: <https://www.w3.org/ns/solid/terms#>.\n<>\n    a solid:TypeIndex ;\n    a solid:UnlistedDocument.\n"),await this.perform("FULL_PUT",t+"/settings/publicTypeIndex.ttl","@prefix : <#>.\n@prefix solid: <https://www.w3.org/ns/solid/terms#>.\n@prefix terms: <http://purl.org/dc/terms/>.\n@prefix ter: <http://www.w3.org/ns/solid/terms#>.\n@prefix bookm: <http://www.w3.org/2002/01/bookmark#>.\n\n<> a solid:ListedDocument, solid:TypeIndex; terms:references :Bookmark.\n\n:Bookmark\n    a ter:TypeRegistration;\n    ter:forClass bookm:Bookmark;\n    ter:instance <../bookmarks.ttl>.\n"),await this.perform("FULL_PUT",t+"/private/.meta",""),await this.perform("FULL_PUT",t+"/.well-known/.meta",""),await this.perform("FULL_PUT",t+"/public/.meta",""),await this.perform("FULL_PUT",t+"/inbox/.meta","")}function S(t){return A.find((e=>this.getExtension(t)===e))}async function U(t){return t.endsWith(".acl")||t.endsWith(".meta")?[]:R.filter((async e=>await this.perform("ITEM_EXISTS",t+e))).map((e=>t+e))||[]}async function _(t,e=P()){let r=this.mungePath(t,e);return this.item.isContainer&&!this.request.url.endsWith(this.pathSep)&&(r+=this.pathSep),await this.perform("ITEM_EXISTS",r)&&(e=`${P()}-${e}`),this.mungePath(t,e)}async function q(t,e,r,n){const s=n.pathSep;let o=e.filter((t=>{if(t.path&&!t.path.endsWith(".acl")&&!t.path.endsWith(".meta"))return t}));t.endsWith(s)||(t+=s);let i="",a="\n@prefix : <#>.\n@prefix ldp: <http://www.w3.org/ns/ldp#>.\n@prefix dct: <http://purl.org/dc/terms/>.\n@prefix stat: <http://www.w3.org/ns/posix/stat#>.\n@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.\n<> a ldp:BasicContainer, ldp:Container\n";if(o.length){a+="; ldp:contains\n";for(var h=0;h<o.length;h++){let e=o[h].path;r&&(e="/"+r+e),e=encodeURI(e),e=(c=e).substr(c.lastIndexOf(n.pathSep)+1),o[h].isContainer&&!e.endsWith("/")&&(e+="/"),a+=`  <${e}>,\n`;let s,u,l,p,f=o[h].isContainer?"Container":"Resource";if(n&&n.storage.getMetadata)try{let r=await n.storage.getMetadata(t+"/"+e);s=r.contentType,u=r.size,l=r.mtime,p=r.modified}catch(t){console.log(t)}s=s||await n.getContentType(e,f)||"",s=s.replace(/;.*/,""),f=o[h].isContainer?"ldp:Container; a ldp:BasicContainer; a ldp:Resource":"ldp:Resource",i+=`<${e}> a ${f}.\n`,s&&(i+=`<${e}> a <http://www.w3.org/ns/iana/media-types/${s}#Resource>.\n`),u&&(i+=`<${e}> stat:size ${u}; stat:mtime ${l}; dct:"${p}"^^xsd:dateTime.\n`)}a=a.replace(/,\n$/,"")}var c;return a=a+".\n"+i,a}let L;const j="PREFIX solid: <http://www.w3.org/ns/solid/terms#>\n",D={"application/sparql-update":async function(t,e,r){const n=e.replace(/#.*/,"");try{return L.sparqlUpdateParser(r,L.graph(),n)}catch(t){throw new Error(`400 : Patch document syntax error: ${t}`)}},"text/n3":async function(t,e,r){const n=L.graph();try{L.parse(r,n,e,"text/n3")}catch(t){throw new Error(`400 : Patch document syntax error: ${t}`)}let s;try{s=await $(n,`${j}\n      SELECT ?insert ?delete ?where WHERE {\n        ?patch a solid:InsertDeletePatch.\n        OPTIONAL { ?patch solid:inserts ?insert. }\n        OPTIONAL { ?patch solid:deletes ?delete. }\n        OPTIONAL { ?patch solid:where   ?where.  }\n      }`)}catch(e){try{s=await $(n,`${j}\n        SELECT ?insert ?delete ?where WHERE {\n          ?patch solid:patches <${t}>.\n          OPTIONAL { ?patch solid:inserts ?insert. }\n          OPTIONAL { ?patch solid:deletes ?delete. }\n          OPTIONAL { ?patch solid:where   ?where.  }\n        }`)}catch(e){throw new Error(`400 : No patch for ${t} found. ${e}`)}}const{"?insert":o,"?delete":i,"?where":a}=s;return o||i?{insert:o,delete:i,where:a}:[400,"Patch should at least contain inserts or deletes."]}};class F{constructor(t){L=t}async patchContent(t,e,r){const n=r.url,s={contentType:e,url:n},o={text:r.body.toString(),contentType:r.headers["content-type"]},i=D[o.contentType];if(!i)return[415,`415 Unsupported patch content type: ${o.contentType}`];const a=`${n}#patch`;try{const e=await i(n,a,o.text),r=await this.readGraph(t,s);let h=o.text.match(/INSERT/g);return h&&h.length>1?[400,"can not have multiple INSERT statements in a patch"]:(await this.applyPatch(e,r,n),[200,await this.writeGraph(r,s)])}catch(t){return[parseInt(t.message),t.message]}}async readGraph(t,e){const r=L.graph();if(!t.length)return r;try{L.parse(t,r,e.url,e.contentType)}catch(t){throw new Error(`500 : Patch: Target ${e.contentType} file syntax error: ${t}`)}return r}async applyPatch(t,e,r){return new Promise(((n,s)=>e.applyPatch(t,e.sym(r),(t=>{if(t){const e=t.message||t;return s(new Error(`409 : The patch could not be applied. ${e}`))}n(e)}))))}async writeGraph(t,e){const r=t.sym(e.url);console.log(44,e.contentType);try{return L.serialize(r,t,e.url,e.contentType)}catch(t){console.log(t)}}hash(t){return crypto.createHash("md5").update(t).digest("hex")}}function $(t,e){return new Promise(((r,n)=>{const s=L.SPARQLToQuery(e,!1,t);t.query(s,r,null,(()=>["409 : No results."]))}))}class B{constructor(t){(t=t||{}).plugin||(console.log("You must specify a plugin storage handler!"),process.exit(1)),this.storage=t.plugin,this.handleRequest=c.bind(this),this.handleResponse=x.bind(this),this.getItem=a.bind(this),this.getRequest=e.bind(this),this.perform=u.bind(this),this.isAuxResource=S.bind(this),this.getAuxResources=U.bind(this),this.getContentType=this.storage.getContentType.bind(this.storage),this.generateRandomSlug=_.bind(this),this.createServerlessPod=I.bind(this),this.storage.configFetcher&&(this.configFetcher=this.storage.configFetcher.bind(this.storage)),this.storage.configure&&(this.configure=this.storage.configure.bind(this.storage)),this.containerAsTurtle=q.bind(this);let n=t.parser?t.parser:"undefined"!=typeof window&&window.$rdf?window.$rdf:void 0!==r.g&&r.g.$rdf?r.g.$rdf:null;this.patch=t.patch=n?new F(n):null}async fetch(t,e={}){let r=await this.handleRequest(t,e);return await this.handleResponse(r,e)}async login(t){t={loginOptions:t,method:"login"};let e=await this.handleRequest("http://example.org/",t);return await this.handleResponse(e,t)}async itemExists(t){return await this.perform("ITEM_EXISTS",t)}isPatchConflictError(t){if(400===t)return!0}isAccessError(t){if(401===t)return!0}async GET(t){return await this.fetch(t,{method:"GET"})}async HEAD(t){return await this.fetch(t,{method:"HEAD"})}async EXISTS(t){try{return 200==(await this.fetch(t,{method:"HEAD"})).status}catch(t){return!1}}async PUT(t,e,r){return r=r||"text/turtle",await this.fetch(t,{method:"PUT",body:e,headers:{"content-type":r}})}async PATCH(t,e,r){return r=e||"text/n3",await this.fetch(t,{method:"PATCH",body:e,headers:{"Content-Type":r,link:'<http://www.w3.org/ns/ldp#Resource>; rel="type"'},relative:!0})}async DELETE(t){return await this.fetch(t,{method:"DELETE"})}async POST(t,e,r,n){return await this.fetch(t,{method:"POST",headers:{slug:e,link:n,"content-type":"text/turtle"},body:r})}async postFile(t,e,r){return POST(t,e,r,'<http://www.w3.org/ns/ldp#Resource>; rel="type"')}async postFolder(t,e){return POST(t,e,"",'<http://www.w3.org/ns/ldp#BasicContainer>; rel="type"')}}class N{constructor(t){return t||={},this.DEBUG=t.DEBUG||!1,this.prefix="browser",this.name="solid-rest-browser-2.0.0",this.ext=".priv",this.currentItem={},new B({plugin:this})}getPathHandler(t){return{sep:"/",join:(t,e)=>t.replace(/\/$/,"")+"/"+second.replace(/^\//,""),extname:t=>t.substr(t.lastIndexOf(".")+1),basename:t=>t.substr(t.lastIndexOf("/")+1)}}async configure(t){t||={fs:"MountableFileSystem",options:{"/LocalStorage":{fs:"LocalStorage",options:{}},"/HTML5FS":{fs:"HTML5FS",options:{size:1e4}},"/IndexedDB":{fs:"IndexedDB",options:{storeName:"IndexedDB"}}}};const e=this;return new Promise(((r,n)=>{BrowserFS.configure(t,(async function(t,s){return t?n(t):(e.fs=BrowserFS.BFSRequire("fs"),r())}))}))}async hybridFetch(t){t||={};const e={browser:this,http:t.fetch};return(t,r)=>{const n=t.replace(/:\/.*/,"").replace(/s$/,"");return e[n].fetch(t,r)}}async configFetcher(t,e){if(e||={},await this.configure(e.browserFSconfig),e.httpOnly)return $rdf.fetcher(t,e);const r={browser:this,http:e.fetch};return e.fetch=(t,e)=>{const n=t.replace(/:\/.*/,"").replace(/s$/,"");return r[n].fetch(t,e)},$rdf.fetcher(t,e)}async makeContainers(t){const e=t.endsWith("/");let r=[],n=this._getParent(t);for(;n&&!await this.exists(n);)r.push(n),n=this._getParent(n);for(n||Promise.resolve(!0),e&&r.push(t);r.length;){let t=r.pop().slice(0,-1);this.log("Creating container ",t);try{await this.createContainer(t)}catch(t){return console.warn(t),Promise.resolve(!0)}}return Promise.resolve(!0)}async createContainer(t){return await this.fs.mkdir(t),await this.putMetadata(t+"/")}_getParent(t){for("object"==typeof t&&(t=t.href);t.endsWith("/");)t=t.slice(0,-1);return t.includes("/")?t.substring(0,t.lastIndexOf("/"))+"/":null}async getContentType(t,e){if("Container"===e||t.match(/\.(ttl|acl|meta)$/)||t.endsWith("/"))return"text/turtle";try{let e=await this.getResource(t+this.ext);return JSON.parse(e).contentType}catch(t){return console.log(t),null}}async itemType(t){return(await this.fs.statSync(t)).isDirectory()?"Container":"Resource"}async exists(t){return await this.fs.existsSync(t)}async itemExists(t){return await this.fs.existsSync(t)}async getItem(){return this.currentItem}async getItemInfo(t,e){e.method.match(/(PUT|POST|PATCH)/)&&await this.makeContainers(t);let r=await this.exists(t),n=r?await this.itemType(t):null;n||=t.endsWith("/")?"Container":"Resource";let s=r?await this.getContentType(t,n):e.headers["content-type"];return this.currentItem={fileName:t,path:t,extension:"",mode:{read:!0,write:!0,append:!0,control:!0},exists:r,isContainer:"Container"===n,mimetype:s,contentType:s},this.currentItem}async getResource(t){return new Promise(((e,r)=>{this.fs.readFile(t,"utf8",((t,n)=>t?r(t):e(n)))}))}async getMetadata(t){const e=await this.getResource(t+this.ext);return JSON.parse(e)}async putMetadata(t,e){return new Promise((async(r,n)=>{const s=this.currentItem.mtime=Date.now(),o=this.currentItem.modified=(new Date).toUTCString(),i=e?this.currentItem.size=new Blob([e]).size:4096,a=`{\n        "contentType" : "${this.currentItem.contentType}",\n        "size" : "${i}",\n        "mtime" : "${s}",\n        "modified" : "${o}"\n      }`;return this.fs.writeFile(t+this.ext,a,"utf8",(t=>t?reject(t):r(200)))}))}async putResource(t,e){return t.endsWith("/")?this.makeContainers(t):(this.log("Writing to "+t),e||="",new Promise(((r,n)=>{this.fs.writeFile(t,e,"utf8",(async s=>s?n(s):r(await this.putMetadata(t,e))))})))}async postContainer(t){let e=await this.fs.existsSync(t)?200:201;return t=t.replace(/\/$/,""),new Promise((async function(r){if(await this.fs.existsSync(t))return r(e);this.fs.mkdirp(t,{},(t=>r(t?500:e)))}))}async deleteResource(t){return new Promise((function(e){try{fs.unlink(t,(function(t){e(!t)}))}catch(t){console.log(t),e(!1)}}))}async deleteContainer(t){return new Promise((async function(e){try{await fs.rmdir(t,(function(t){e(!t)}))}catch(t){console.log(t),e(!1)}}))}async getContainer(t){return new Promise((async(e,r)=>{try{this.fs.readdir(t,(async(r,n)=>{if(!r){let r=[];for(let e of n)e.endsWith(this.ext)||r.push(await this.getItemInfo(t+e,{method:"GET"}));return e(r)}e(r)}))}catch(t){e(t)}}))}async dump(t){t||="/","/"!=(t=t.replace(/^\/\//,"/"))&&(t+="/");let e=await this.getContainer(t);if("string"!=typeof e)for(let t of e){let e=await this.getContainer(t);console.log(t,e)}}log(...t){this.DEBUG&&console.log(t)}}})(),n.default})()}));
3 | //# sourceMappingURL=solid-rest-browser.bundle.js.map


--------------------------------------------------------------------------------