ldn-inbox-server 1.3.0 → 1.3.2

package/README.md

@@ -33,13 +33,13 @@ curl -X POST -H 'Content-Type: application/ld+json' --data-binary '@examples/off
 Start an inbox handler with a demo handler (that creates an `Accept` message in the `./outbox`).
 
 ```
-npx ldn-inbox-server handle @inbox -hn ./handler/demo_notification_handler.js
+npx ldn-inbox-server handler @inbox -hn ./handler/accept_notification_handler.js
 ```
 
-Send the notifications in the outbox:
+Start an outbox handler that send the notifications that are available outbox:
 
 ```
-npx ldn-inbox-server handle @outbox -hn ./handler/send_notification_handler.js
+npx ldn-inbox-server handler @outbox -hn ./handler/send_notification_handler.js
 ```
 
 ## Environment
@@ -62,7 +62,7 @@ npx ldn-inbox-server handle @outbox -hn ./handler/send_notification_handler.js
 Server extensions are possible by providing custom inbox and notification handlers. E.g.
 
 ```
-npx ldn-inbox-server handle-inbox -hn handler/demo_notification_handler.js
+npx ldn-inbox-server handler @inbox -hn handler/my_handler.js
 ```
 
 Or, in JavaScript:
@@ -81,12 +81,12 @@ async function main() {
         'batch_size': 5,
         'glob': '^.*\\.jsonld$',
         'config': './config/inbox_config.json',
-        'notification_handler': 'handler/demo_notification_handler.js' 
+        'notification_handler': 'handler/my_handler.js' 
     });
 }
 ```
 
-with `worker.js` :
+with `my_handler.js` :
 
 ```
 async function handle({path,options}) {
@@ -109,10 +109,54 @@ A handler can be started on any directory. E.g. a workflow might be:
 - processed LDN messages will end up in the "outbox" box
 - invalid processing will be saved into the "error" box  
 
-## Multi handler
+## Handlers
+
+### Accept handler
+
+A handler that creates for an incoming notification an `Accept` notification in the `@outbox`.
+
+### Evenlog handler
+
+A handler that updates an event log with the incoming notification. 
+
+Requires a configuration file with property `notification_handler.eventlog`:
+
+- `log`: the path to the event log (starting from the `public` directory)
+- `dir`: the path to a container to store the events (starting from the `public` directory)
+
+The `log` and `dir` path may contain a `@artifact(:strip)?@` directive to fill in the
+path of the current artifact. The `:strip` filter is used to strip an artifact path of a file extension. E.g. `path/artifact.html` becomes `path/artifact` when using a `:strip`.
+
+### Multi handler
 
 A `handler/multi_notification_handler.js` is available to start multiple handler for each notification messages. The handlers to start are specified in a configuraton file that can be passed via the `config` parameter of an `handle_inbox`. In the commmand line tool `bin/ldn-inbox-server` the default location of such config file is `config/inbox_config.json` when processing an `@inbox`, and `config/outbox_config.json` when processing an `@outbox`.
 
+### Offer memento handler
+
+A handler to `Offer` an event log to a memento server.
+
+Requires a configuration file with property `notification_handler.offer_memento`:
+
+- `actor`: the LDN+AS2 `actor` to use in a notification
+- `target`: the LDN+AS2 `target` to use in a notification
+
+### Send handler
+
+A hanlder to send notification that live in the `@outbox` via the LDN protocol to the LDN `target`.
+
+### Valid artifact
+
+A handler that validates the incoming notification and checks if the `object` or `context` contains an artifact that is part of the `public` resources. See 'Artifact support' below.
+
+## Artifact support 
+
+This code base contains Event Notifications support for Data Node artifacts. See the examples
+in `public/artifacts-example`. Move this directory tp `public/artifacts` to get a running example.
+
+- Each artifact requires at least a `.meta` file with the `X-Artifact` header set to `true` to be recognized by the software as an artifact
+- Each artifact should update the `Link-Template` header in the `.meta` file
+- The config files in `config/inbox_config.json` and `config/outbox_config.json` define the location of the possible event logs for the artifact
+  
 ## See also
 
 - [mellon-server](https://www.npmjs.com/package/mellon-server)

package/bin/ldn-inbox-server.js

@@ -23,7 +23,6 @@ const HAS_PUBLIC = process.env.LDN_SERVER_HAS_PUBLIC_INBOX ?? 0;
 
 program
   .name('lnd-inbox-server')
-  .version('1.2.2')
   .description('A demonstration Event Notifications Inbox server');
 
 program
@@ -43,6 +42,7 @@ program
 
 program
   .command('handler')
+  .option('--base <url>','base url',INBOX_BASE_URL)
   .option('--inbox <inbox>','inbox',INBOX_PATH)
   .option('--outbox <outbox>','outbox',OUTBOX_PATH)
   .option('--public <public>','public',PUBLIC_PATH)

package/bin/post-notification.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const { program } = require('commander');
+const { sendNotification, getLogger } = require('../lib/util.js');
+require('dotenv').config();
+
+const logger = getLogger();
+
+const INBOX_URL = process.env.LDN_SERVER_INBOX_URL ?? 'inbox/';
+const INBOX_BASE_URL = process.env.LDN_SERVER_BASEURL ?? 'http://localhost:8000';
+
+program
+  .name('post-notification')
+  .description('A LDN notification sender')
+  .argument('<url>','notification')
+  .argument('<file>','notification')
+  .action( async(url,file) => {
+     const to = url === '@me' ? `${INBOX_BASE_URL}/${INBOX_URL}` : url;
+     const json = JSON.parse(fs.readFileSync(file, { encoding: 'utf-8'}));
+     await sendNotification(to,json);  
+  });
+
+program.parse();

package/config/inbox_config.json

@@ -1,10 +1,31 @@
 {
     "notification_handler": {
+        "eventlog": {
+            "log": "@artifact:strip@.jsonld",
+            "dir": "@artifact:strip@"
+        },
         "multi": {
             "handlers": [
-                "handler/demo_notification_handler.js" ,
-                "handler/eventlog_notification_handler.js"
+                "handler/type_filter_notification_handler.js",
+                "handler/valid_artifact_notification_handler.js" ,
+                "handler/eventlog_notification_handler.js",
+                "handler/offer_memento_notification_handler.js"
             ]
+        },
+        "offer_memento": {
+            "actor": {
+                "id": "http://localhost:8000/profile/card#me" ,
+                "inbox": "http://localhost:8000/inbox/" ,
+                "type": "Service"
+            },
+            "target": {
+                "id": "http://localhost:8001/profile/card#me" ,
+                "inbox": "http://localhost:8001/inbox/" ,
+                "type": "Service"
+            }
+        },
+        "type_filter": {
+            "anyOf": [ "Offer" ]
         }
     }
 }

package/config/outbox_config.json

@@ -1,7 +1,12 @@
 {
     "notification_handler": {
+        "eventlog": {
+            "log": "@artifact:strip@.jsonld",
+            "dir": "@artifact:strip@"
+        },
         "multi": {
             "handlers": [
+                "handler/valid_artifact_notification_handler.js" ,
                 "handler/send_notification_handler.js",
                 "handler/eventlog_notification_handler.js"
             ]

package/examples/offer.jsonld

@@ -7,11 +7,11 @@
     "type": "Offer",
     "actor": {
        "id": "https://acme.org.xyz/profile/card#us",
-       "inbox": "https://acme.org.xyz/inbox/",
+       "inbox": "http://localhost:8000/inbox/",
        "type": "Organization"
     },
     "object": {
-       "id": "http://acme.org.xyz/artifacts/alice/data-set-2022-01-19.zip",
+       "id": "http://localhost:8000/artifacts/artifact1.html",
        "type": [ "Document" , "schema:Dataset" ]
     },
     "target": {

package/handler/{demo_notification_handler.js → accept_notification_handler.js}

@@ -1,12 +1,18 @@
 const fs = require('fs');
 const md5 = require('md5');
+const { parseAsJSON } = require('../lib/util');
 const logger = require('../lib/util.js').getLogger();
 
+/**
+ * Demonstration notification handler, that creates an 'Accept'
+ * notification for each incoming notification message and stores
+ * it in the outbox container.
+ */
 async function handle({path,options}) {
     logger.info(`parsing notification ${path}`);
     
     try {
-        const json = JSON.parse(fs.readFileSync(path, { encoding: 'utf-8'}));
+        const json = parseAsJSON(path);
         
         const id = json['id'];
         const object = json['object'];

package/handler/eventlog_notification_handler.js

@@ -2,37 +2,112 @@ const fs = require('fs');
 const md5 = require('md5');
 const fsPath = require('path');
 const lockfile = require('proper-lockfile');
+const { parseAsJSON } = require('../lib/util');
 const logger = require('../lib/util.js').getLogger();
 
-const EVENT_DIR = 'events';
-const EVENT_LOG = 'events.jsonld';
-
+/**
+ * Demonstration event log handler
+ */
 async function handle({path,options}) {
     logger.info(`parsing notification ${path}`);
-    
+
+    const config = parseAsJSON(options['config']);
+
+    if (! config) {
+        logger.error('no configuration found for eventlog_notification_handler');
+        return { path, options, success: false };
+    }
+
+    const thisConfig = config['notification_handler']?.['eventlog'];
+
+    if (! thisConfig || !thisConfig['log'] || !thisConfig['dir']) {
+        logger.error('no log/dir entry for notification_handler.eventlog configuration'); 
+        return { path, options, success: false };
+    }
+
+    const base = options['base'] ? options['base'] : 
+                    options['host'] && options['port'] ? 
+                        `http://${options['host']}:${options['port']}` :
+                            'http://localhost:8000';
+
+    let eventLog = thisConfig['log'];
+    let eventDir = thisConfig['dir'];
+
+    let artifactPath = undefined;
+
+    if (options['artifact']) {
+        artifactPath = options['artifact']['id'].substring(base.length+1);
+        logger.info(artifactPath);
+    }
+
+    if (eventLog.match(/@artifact(:[a-zA-Z]+)?@/)) {
+        if (options['artifact']) {
+            if (eventLog.match(/@artifact:strip@/)) {
+                eventLog = eventLog.replaceAll(/@artifact(:[a-zA-Z]+)?@/g,artifactPath.replaceAll(/\.\w+$/g,''));
+            }
+            else {
+                eventLog = eventLog.replaceAll(/@artifact(:[a-zA-Z]+)?@/g,artifactPath);
+            }
+        }
+        else {
+            logger.error(`requested to parse ${eventLog} but no artifact information available`);
+            return { path, options, success: false };
+        }
+    } 
+
+    if (eventDir.match(/@artifact(:[a-zA-Z]+)?@/)) {
+        if (options['artifact']) {
+            if (eventDir.match(/@artifact:strip@/)) {
+                eventDir = eventDir.replaceAll(/@artifact(:[a-zA-Z]+)?@/g,artifactPath.replaceAll(/\.\w+$/g,''));
+            }
+            else {
+                eventDir = eventDir.replaceAll(/@artifact(:[a-zA-Z]+)?@/g,artifactPath);
+            }
+        }
+        else {
+            logger.error(`requested to parse ${eventDir} but no artifact information available`);
+            return { path, options, success: false };
+        }
+    } 
+
     try {
-        const json = fs.readFileSync(path, { encoding: 'utf-8'});
+        const json = fs.readFileSync(path, { encoding: 'utf-8' });
       
         const fileName = path.split('/').pop();
-        const logDir = fsPath.join(options['public'],EVENT_DIR,'log');
 
-        if (! fs.existsSync(logDir)) {
-            logger.info(`creating ${logDir}`);
-            fs.mkdirSync(logDir, { recursive : true });
+        if (! fs.existsSync(`${options['public']}/${eventDir}`)) {
+            logger.info(`creating ${options['public']}/${eventDir}`);
+            fs.mkdirSync(`${options['public']}/${eventDir}`, { recursive : true });
         }
-  
-        const outboxFile = fsPath.join(logDir,fileName);
 
-        fs.writeFileSync(outboxFile, json);
+        const eventFile = `${options['public']}/${eventDir}/${fileName}`;
+
+        fs.writeFileSync(eventFile, json);
 
         // Updating metadata file
-        const metaFile = outboxFile + '.meta';
+        const metaFile = `${options['public']}/${eventLog}.meta`;
 
         fs.writeFileSync(metaFile, JSON.stringify({
             'Content-Type': 'application/ld+json',
             'Last-Modified': nowISO()
         },null,4));
 
+        // Store the path in the options .. yeah yeah we know ugly but it works for now
+     
+        const eventPath = `${eventDir}/${fileName}`;
+        const eventId = `${base}/${eventPath}`;
+        const eventLogId = `${base}/${eventLog}`;
+
+        options['eventlog'] = {
+            'id': eventLogId ,
+            'file': `${options['public']}/${eventLog}` ,
+            'dir': `${options['public']}/${eventDir}` ,
+            'item': {
+                'id' : eventId ,
+                'file' : eventFile 
+            }
+        };
+
         await updateEventLog({path,options});
 
         return { path, options, success: true };
@@ -51,11 +126,8 @@ async function updateEventLog({path,options}) {
         const notification = fs.readFileSync(path, { encoding: 'utf-8'});
         const notification_checksum = md5(notification);
 
-        const baseUrl = process.env.LDN_SERVER_BASEURL ?? "";
-        const fileName = path.split('/').pop();
-        const entry = `${baseUrl}/${EVENT_DIR}/log/${fileName}`;
-
-        const eventLog = fsPath.join(options['public'],EVENT_DIR,EVENT_LOG);
+        const entry = options['eventlog']['item']['id'];
+        const eventLog = options['eventlog']['file'];
 
         let json;
         
@@ -70,7 +142,7 @@ async function updateEventLog({path,options}) {
             };
         }
      
-        if (json['member'].findIndex( (e) => e === entry) >= 0) {
+        if (json['member'].findIndex( (e) => e['id'] === entry) >= 0) {
             logger.info(`${entry} already in ${eventLog}`);
         }
         else {

package/handler/multi_notification_handler.js

@@ -1,6 +1,10 @@
 const { dynamic_handler , parseAsJSON } = require('../lib/util');
 const logger = require('../lib/util.js').getLogger();
 
+/**
+ * Demonstration notification handler that start multiple notification handlers.
+ * Requires a config file that specifies which handlers to start. 
+ */
 async function handle({path,options}) {
     let success = false;
 

package/handler/offer_memento_notification_handler.js

@@ -0,0 +1,68 @@
+const fs = require('fs');
+const md5 = require('md5');
+const { parseAsJSON } = require('../lib/util.js');
+const logger = require('../lib/util.js').getLogger();
+
+/**
+ * Demonstration notification handler, that creates an 'Offer'
+ * notification for each incoming notificaation to request the
+ * archivation of the event log.
+ */
+async function handle({path,options}) {
+    logger.info(`parsing notification ${path}`);
+
+    const config = parseAsJSON(options['config']);
+
+    if (! config) {
+        logger.error('no configuration found for offer_memento_notification_handler');
+        return { path, options, success: false };
+    }
+   
+    const thisConfig = config['notification_handler']?.['offer_memento'];
+
+    if (! thisConfig || !thisConfig['actor'] || !thisConfig['target']) {
+        logger.error('no actor/target entry for notification_handler.eventlog configuration'); 
+        return { path, options, success: false };
+    }
+
+    if (!options['artifact']) {
+        logger.info(`no artifact found (ignonring this request)`);
+        return { path, options, success: true };
+    }
+
+    if (!options['eventlog']) {
+        logger.info(`no artifact found (ignonring this request)`);
+        return { path, options, success: true };
+    }
+
+    try {
+        const data = JSON.stringify({
+            '@context': [ 
+                "https://www.w3.org/ns/activitystreams" ,
+                {"schema": "https://schema.org/"}
+            ], 
+            type: 'Offer',
+            actor: thisConfig['actor'],
+            object: {
+                id: options['eventlog']['id'],
+                type: [ "Document", "schema:Dataset" ]
+            },
+            target: thisConfig['target']
+        },null,4);
+
+        const outboxFile = options['outbox'] + '/' + md5(data) + '.jsonld';
+
+        logger.info(`storing Offer to ${outboxFile}`);
+
+        fs.writeFileSync(outboxFile,data);
+
+        return { path, options, success: true };
+    }
+    catch(e) {
+        logger.error(`failed to process ${path}`);
+        logger.debug(e);
+        return { path, options, success: false };
+    }
+}
+
+module.exports = { handle };

package/handler/send_notification_handler.js

@@ -1,11 +1,13 @@
-const fs = require('fs');
 const logger = require('../lib/util.js').getLogger();
-const { sendNotification } = require('../lib/util.js');
+const { sendNotification , parseAsJSON } = require('../lib/util.js');
 
+/**
+ * Demonstration notification handler that sends a notification to a
+ * target inbox. 
+ */
 async function handle({path,options}) {
     try {
-        const json = fs.readFileSync(path, { encoding: 'utf-8'});
-        const data = JSON.parse(json);
+        const data = parseAsJSON(path);
         const type = data['type'];
         let inbox;
 

package/handler/type_filter_notification_handler.js

@@ -0,0 +1,65 @@
+const fs = require('fs');
+const { parseAsJSON } = require('../lib/util');
+const logger = require('../lib/util.js').getLogger();
+
+/**
+ * Demonstration notification handler, that checks if the notification
+ * matches a configurable list
+ */
+async function handle({path,options}) {
+    logger.info(`parsing notification ${path}`);
+    
+    const config = parseAsJSON(options['config']);
+
+    if (! config) {
+        logger.error('no configuration found for eventlog_notification_handler');
+        return { path, options, success: false };
+    }
+
+    const thisConfig = config['notification_handler']?.['type_filter'];
+
+    if (! thisConfig) {
+        logger.error('no notification_handler.type_filer configuration'); 
+        return { path, options, success: false };
+    }
+
+    if (! (thisConfig['anyOf'] && Array.isArray(thisConfig['anyOf']))) {
+        logger.error('no anyOf entry in notification_handler.type_filer should be an array'); 
+        return { path, options, success: false };
+    }
+
+    try {
+        const json = parseAsJSON(path);
+        
+        const type = json['type'];
+
+        const typeArray = Array.isArray(type) ? type : [type];
+
+        let isOk = true ;
+
+        for (let i = 0 ; i < typeArray.length ; i++) {
+            if (thisConfig['anyOf'].includes(typeArray[i])) {
+                // We are ok
+            }
+            else {
+                logger.error(`${typeArray[i]} does not pass type_filter check`);
+                isOk = false;
+                break;
+            }       
+        }
+
+        if (isOk) {
+            return { path, options, success: true };
+        }
+        else {
+            return { path, options, success: false };
+        }
+    }
+    catch(e) {
+        logger.error(`failed to process ${path}`);
+        logger.debug(e);
+        return { path, options, success: false };
+    }
+}
+
+module.exports = { handle };

package/handler/valid_artifact_notification_handler.js

@@ -0,0 +1,55 @@
+const { ldPropertyAsId , parseArtifact, parseAsJSON } = require('../lib/util.js');
+const logger = require('../lib/util.js').getLogger();
+
+/**
+ * Demonstration notification handler, that checks if the notification
+ * message contains an artifact that is known to the data node
+ */
+async function handle({path,options}) {
+    logger.info(`parsing notification ${path}`);
+    
+    try {
+        const json = parseAsJSON(path);
+        
+        let artifact = undefined;
+
+        if (ldPropertyAsId(json['context'])) {
+            artifact = ldPropertyAsId(json['context']);
+        }
+        else if (ldPropertyAsId(json['object'])) {
+            artifact = ldPropertyAsId(json['object']);
+        }
+        else {
+            logger.error(`failed to find valid context or object`);
+            return { path, options, success: false };
+        }
+
+        if (!artifact) {
+            logger.error(`failed to find artifact`);
+            return { path, options, success: false };
+        }
+
+        const artifactPath = parseArtifact(artifact,options);
+
+        if (artifactPath) {
+            // Storing the artifact path to the options. 
+            // Maybe bad practice..but it is a workflow attribute like in Nifi :P
+            options['artifact'] = {
+                'id': artifact ,
+                'path': artifactPath
+            };
+            return { path, options, success: true };
+        }
+        else {
+            logger.error(`artifact ${artifact} is not known here...`);
+            return { path, options, success: false };
+        }
+    }
+    catch(e) {
+        logger.error(`failed to process ${path}`);
+        logger.debug(e);
+        return { path, options, success: false };
+    }
+}
+
+module.exports = { handle };

package/lib/util.js

@@ -67,7 +67,7 @@ async function sendNotification(url,json,options) {
             'Accept': 'application/json',
             'Content-Type': 'application/json'
         },
-        body: JSON.stringify(json)
+        body: JSON.stringify(json,null,4)
     });
 
     if (! response.ok) {
@@ -135,6 +135,60 @@ function parseAsJSON(path) {
     }
 }
 
+function ldPropertyAsId(object_or_string) {
+    if (!object_or_string) {
+        return null;
+    }
+
+    if (typeof object_or_string === 'string' || object_or_string instanceof String) {
+        return object_or_string;
+    }
+    else if (typeof object_or_string === 'object' && object_or_string['id']) {
+        return object_or_string['id'];
+    }
+    else if (typeof object_or_string === 'object' && object_or_string['@id']) {
+        return object_or_string['@id'];
+    }
+    else {
+        return null;
+    }
+}
+
+function parseArtifact(url,options) {
+    logger.debug(`isArtifact(${url})?`);
+    const base = options['base'] ? options['base'] : 
+                    options['host'] && options['port'] ? 
+                        `http://${options['host']}:${options['port']}` :
+                            'http://localhost:8000';
+
+    const public = options['public'];
+
+    const filePath = url.substring(base.length + 1);
+
+    const metaPath = `${public}/${filePath}.meta`;
+
+    logger.debug(`searching ${metaPath}`);
+    
+    if (! fs.existsSync(metaPath)) {
+        logger.debug(`no such file ${metaPath}`);
+        return null;
+    }
+
+    const json = parseAsJSON(metaPath);
+
+    if (json === null)  {
+        logger.debug(`no json at ${metaPath}`);
+        return null;
+    }
+
+    if (json['X-Artifact']) {
+        return `${public}/${filePath}`;
+    }
+    else {
+        return null;
+    }
+}
+
 module.exports = { 
     getLogger , 
     backOff_fetch , 
@@ -142,5 +196,7 @@ module.exports = {
     moveTo ,
     sendNotification ,
     dynamic_handler ,
-    parseAsJSON 
+    parseAsJSON ,
+    parseArtifact ,
+    ldPropertyAsId
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ldn-inbox-server",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "A demonstration Event Notifications Inbox server",
   "main": "lib/index.js",
   "author": "Patrick Hochstenbach <Patrick.Hochstenbach@UGent.be>",
@@ -8,12 +8,12 @@
   "scripts": {
     "server": "npx ldn-inbox-server start-server",
     "demo-post": "curl -X POST -H 'Content-Type: application/ld+json' --data-binary '@examples/offer.jsonld' http://localhost:8000/inbox/",
-    "handle-inbox": "npx ldn-inbox-server handler @inbox -hn ./handler/demo_notification_handler.js",
+    "handle-inbox": "npx ldn-inbox-server handler @inbox -hn ./handler/accept_notification_handler.js",
     "handle-outbox": "npx ldn-inbox-server handler @outbox -hn ./handler/send_notification_handler.js",
     "handle-eventlog": "npx ldn-inbox-server handler @inbox -hn handler/eventlog_notification_handler.js",
     "handle-inbox-multi": "npx ldn-inbox-server handler @inbox -hn ./handler/multi_notification_handler.js",
     "handle-outbox-multi": "npx ldn-inbox-server handler @outbox -hn ./handler/multi_notification_handler.js",
-    "clean": "rm error/* inbox/* outbox/* public/events/* public/events/log/*"
+    "clean": "rm -rf error/* inbox/* outbox/* public/events/* public/events/log/* public/artifacts/artifact1 public/artifacts/artifact2 public/artifacts/*.jsonld*"
   },
   "bin": "./bin/ldn-inbox-server.js",
   "keywords": [
@@ -31,6 +31,7 @@
     "node-fetch": "1.7.3",
     "piscina": "^4.4.0",
     "proper-lockfile": "^4.1.2",
+    "upath": "^2.0.1",
     "uuid": "^9.0.1"
   }
 }

package/public/artifacts-example/artifact1.html

@@ -0,0 +1,17 @@
+<html>
+    <head>
+        <link
+        rel="stylesheet"
+        href="https://cdn.jsdelivr.net/npm/@picocss/pico@2/css/pico.min.css"
+        />
+        <title>Artifact 1</title>
+    </head>
+    <body>
+        <main class="container">
+            <h1>Artifact 1</h1>
+            <p>
+                <a href="artifact1.jsonld">Event Log</a>
+            </p>
+        </main>
+    </body>
+</html>

package/public/artifacts-example/artifact1.html.meta

@@ -0,0 +1,6 @@
+{
+    "Content-Type": "text/html",
+    "X-Artifact": true,
+    "Link-Template": "\"https://{YOUR-SERVER}/artifacts/artifact1.jsonld\"; rel=\"eventlog\"",
+    "Link": "</inbox/> ; rel=\"http://www.w3.org/ns/ldp#inbox\""
+}

package/public/artifacts-example/artifact2.html

@@ -0,0 +1,17 @@
+<html>
+    <head>
+        <link
+        rel="stylesheet"
+        href="https://cdn.jsdelivr.net/npm/@picocss/pico@2/css/pico.min.css"
+        />
+        <title>Artifact 2</title>
+    </head>
+    <body>
+        <main class="container">
+            <h1>Artifact 2</h1>
+            <p>
+                <a href="artifact1.jsonld">Event Log</a>
+            </p>
+        </main>
+    </body>
+</html>

package/public/artifacts-example/artifact2.html.meta

@@ -0,0 +1,6 @@
+{
+    "Content-Type": "text/html",
+    "X-Artifact": true,
+    "Link-Template": "\"https://{YOUR-SERVER}/artifacts/artifact2.jsonld\"; rel=\"eventlog\"",
+    "Link": "</inbox/> ; rel=\"http://www.w3.org/ns/ldp#inbox\""
+}

package/public/index.html.meta

@@ -0,0 +1,3 @@
+{
+    "Content-Type": "text/html"
+}