[IMP] Restructure store creation

This allows all layers of the library to execute actions via middleware.
The first implemented use case here consists of executing the actions
described in the `Exec-Action` header.

Author: Fletcher91

package.json

@@ -61,9 +61,9 @@
     "coverageThreshold": {
       "global": {
         "branches": 64,
-        "functions": 74,
-        "lines": 74,
-        "statements": 74
+        "functions": 76,
+        "lines": 76,
+        "statements": 75
       }
     },
     "setupTestFrameworkScriptFile": "./jest-plugins",

src/LinkedDataAPI.ts

@@ -6,6 +6,7 @@ import {
 
 import {
     DataProcessorOpts,
+    Dispatcher,
 } from "./types";
 import {
     DataTuple,
@@ -16,7 +17,7 @@ import {
     SomeNode,
 } from "./types";
 
-export interface LinkedDataAPI {
+export interface LinkedDataAPI extends Dispatcher {
     execActionByIRI(subject: NamedNode, dataTuple: DataTuple): Promise<LinkedActionResponse>;
 
     /**

src/LinkedRenderStore.ts

@@ -17,14 +17,14 @@ import { Schema } from "./Schema";
 import {
     ComponentRegistration,
     DataObject,
+    Dispatcher,
     EmptyRequestStatus,
     FetchOpts,
     FulfilledRequestStatus,
     LazyNNArgument,
     LinkedActionResponse,
     LinkedRenderStoreOptions,
     MiddlewareActionHandler,
-    MiddlewareFn,
     NamespaceMap,
     SomeNode,
     SubscriptionRegistration,
@@ -39,7 +39,7 @@ declare global {
     }
 }
 
-export class LinkedRenderStore<T> {
+export class LinkedRenderStore<T> implements Dispatcher {
     public static registerRenderer<T>(
         component: T,
         type: LazyNNArgument,
@@ -61,7 +61,7 @@ export class LinkedRenderStore<T> {
 
     private api: LinkedDataAPI;
     private mapping: ComponentStore<T>;
-    private middleware: MiddlewareActionHandler;
+    private _dispatch?: MiddlewareActionHandler;
     private schema: Schema;
     private store: RDFStore = new RDFStore();
     private subscriptions: SubscriptionRegistration[] = [];
@@ -74,16 +74,29 @@ export class LinkedRenderStore<T> {
         }
 
         this.api = opts.api || new DataProcessor({
-            requestNotifier: this.touch.bind(this),
+            dispatch: opts.dispatch,
             store: this.store,
         });
+        if (opts.dispatch) {
+            this.dispatch = opts.dispatch;
+        }
         this.defaultType = opts.defaultType || defaultNS.schema("Thing");
         this.namespaces = opts.namespaces || {...defaultNS};
         this.schema = opts.schema || new Schema(this.store);
         this.mapping = opts.mapping || new ComponentStore(this.schema);
-        // tslint:disable-next-line typedef
-        const actionMiddleware: MiddlewareFn<T> = () => () => this.execActionByIRI.bind(this);
-        this.middleware = this.applyMiddleware(...(opts.middleware || []), actionMiddleware);
+    }
+
+    public get dispatch(): MiddlewareActionHandler {
+        if (typeof this._dispatch === "undefined") {
+            throw new Error("Invariant: cannot call `dispatch` before initialization is complete");
+        }
+
+        return this._dispatch;
+    }
+
+    public set dispatch(value: MiddlewareActionHandler) {
+        this._dispatch = value;
+        this.api.dispatch = value;
     }
 
     /**
@@ -128,7 +141,7 @@ export class LinkedRenderStore<T> {
      * @param {Object} args The arguments to the function defined by the subject.
      */
     public async exec(subject: NamedNode, args?: DataObject): Promise<any> {
-        return this.middleware(subject, args);
+        return this.dispatch(subject, args);
     }
 
     /**
@@ -317,6 +330,14 @@ export class LinkedRenderStore<T> {
         this.subscriptions.push(registration);
     }
 
+    /** @internal */
+    public touch(iri: string | NamedNode, _err?: Error): boolean {
+        const resource = typeof iri === "string" ? namedNodeByIRI(iri) : iri;
+        this.store.addStatements([new Statement(resource, defaultNS.ll("nop"), Literal.fromValue(0))]);
+        this.broadcast();
+        return true;
+    }
+
     /**
      * Returns an entity from the cache directly.
      * This won't cause any network requests even if the entity can't be found.
@@ -329,18 +350,6 @@ export class LinkedRenderStore<T> {
         return this.store.statementsFor(iri);
     }
 
-    /**
-     * Binds and reduces an array of middleware function down to a handler.
-     * @param layers
-     */
-    private applyMiddleware(...layers: Array<MiddlewareFn<T>>): MiddlewareActionHandler {
-        const storeBound = layers.map((middleware) => middleware(this));
-
-        const dispatch: MiddlewareActionHandler = (a: NamedNode, _o: any): Promise<any> => Promise.resolve(a);
-
-        return storeBound.reduceRight((composed, f) => f(composed), dispatch);
-    }
-
     /**
      * Broadcasts buffered to all subscribers.
      * The actual broadcast might be executed asynchronously to prevent lag.
@@ -389,11 +398,4 @@ export class LinkedRenderStore<T> {
             }
         });
     }
-
-    private touch(iri: string | NamedNode, _err?: Error): boolean {
-        const resource = typeof iri === "string" ? namedNodeByIRI(iri) : iri;
-        this.store.addStatements([new Statement(resource, defaultNS.ll("nop"), Literal.fromValue(0))]);
-        this.broadcast();
-        return true;
-    }
 }

src/__tests__/utilities.spec.ts

@@ -10,8 +10,6 @@ import {
     allRDFPropertyStatements,
     allRDFValues,
     anyRDFValue,
-    fetchWithExtension,
-    getExtention,
     getPropBestLang,
     getPropBestLangRaw,
     isDifferentOrigin,

src/createStore.ts

@@ -0,0 +1,29 @@
+import { NamedNode } from "rdflib";
+
+import { LinkedRenderStore } from "./LinkedRenderStore";
+import { linkMiddleware } from "./linkMiddleware";
+import { LinkedRenderStoreOptions, MiddlewareActionHandler, MiddlewareFn } from "./types";
+
+function applyMiddleware<T>(lrs: LinkedRenderStore<T>, ...layers: Array<MiddlewareFn<T>>): MiddlewareActionHandler {
+    const storeBound = layers.map((middleware) => middleware(lrs));
+
+    const finish: MiddlewareActionHandler = (a: NamedNode, _o: any): Promise<any> => Promise.resolve(a);
+
+    return storeBound.reduceRight((composed, f) => f(composed), finish);
+}
+
+export function createStore<T>(storeOpts: LinkedRenderStoreOptions<T>,
+                               middleware = [],
+                               trailingMiddleware = []): LinkedRenderStore<T> {
+
+    const LRS = new LinkedRenderStore<T>(storeOpts);
+
+    LRS.dispatch = applyMiddleware<T>(
+        LRS,
+        ...middleware,
+        linkMiddleware(trailingMiddleware.length > 0),
+        ...trailingMiddleware,
+    );
+
+    return LRS;
+}

src/link-lib.ts

@@ -1,5 +1,7 @@
 import { LinkedRenderStore } from "./LinkedRenderStore";
 
+export { createStore } from "./createStore";
+export { linkMiddleware } from "./linkMiddleware";
 export { RDFStore } from "./RDFStore";
 export { Schema } from "./Schema";
 export * from "./testUtilities";

src/linkMiddleware.ts

@@ -0,0 +1,26 @@
+import { NamedNode } from "rdflib";
+
+import { LinkedRenderStore } from "./LinkedRenderStore";
+import { MiddlewareActionHandler, MiddlewareFn, MiddlewareWithBoundLRS } from "./types";
+import { defaultNS } from "./utilities/constants";
+
+/**
+ * Binds various uris to link actions.
+ *
+ * @param catchActions {boolean} Set to true to catch and pass left-over actions to execActionByIRI.
+ */
+export const linkMiddleware = <T>(catchActions = true): MiddlewareFn<T> =>
+    (lrs: LinkedRenderStore<T>): MiddlewareWithBoundLRS =>
+        (next: MiddlewareActionHandler): MiddlewareActionHandler =>
+            (action: NamedNode, args: any): Promise<any> => {
+
+    if (action.value.startsWith(defaultNS.ll("data/rdflib/").value)) {
+        return Promise.resolve(lrs.touch(args[0], args[1]));
+    }
+
+    if (catchActions) {
+        return lrs.execActionByIRI(action, args);
+    }
+
+    return next(action, args);
+};

src/processor/DataProcessor.ts

@@ -10,7 +10,6 @@ import {
     IndexedFormula,
     Literal,
     NamedNode,
-    RequestCallbackHandler,
     Serializer,
     Statement,
     uri as Uri,
@@ -25,6 +24,7 @@ import {
     FailedResponse,
     FulfilledRequestStatus,
     LinkedActionResponse,
+    MiddlewareActionHandler,
     ResponseAndFallbacks,
     ResponseTransformer,
 } from "../types";
@@ -145,11 +145,11 @@ export class DataProcessor implements LinkedDataAPI {
     public timeout: number = 30000;
 
     private _fetcher: Fetcher | undefined;
+    private _dispatch?: MiddlewareActionHandler;
     private readonly requestInitGenerator: RequestInitGenerator;
     private readonly mapping: { [k: string]: ResponseTransformer[] };
     private readonly requestMap: Map<NamedNode, Promise<Statement[]> | undefined>;
     private readonly statusMap: Map<NamedNode, EmptyRequestStatus | FulfilledRequestStatus>;
-    private readonly requestNotifier?: RequestCallbackHandler;
     private readonly store: RDFStore;
 
     private get fetcher(): Fetcher {
@@ -159,10 +159,13 @@ export class DataProcessor implements LinkedDataAPI {
                 timeout: this.timeout,
             });
             FETCHER_CALLBACKS.forEach((hook) => {
+                const hookIRI = defaultNS.ll(`data/rdflib/${hook}`);
                 this._fetcher!.addCallback(hook, this.invalidateCache.bind(this));
-                if (typeof this.requestNotifier === "function") {
-                    this._fetcher!.addCallback(hook, this.requestNotifier);
-                }
+                this._fetcher!.addCallback(hook, (iri: string | NamedNode, _err?: Error) => {
+                    this.dispatch(hookIRI, [typeof iri === "string" ? namedNodeByIRI(iri) : iri, _err]);
+
+                    return true;
+                });
             });
         }
         return this._fetcher;
@@ -176,17 +179,29 @@ export class DataProcessor implements LinkedDataAPI {
         this.accept = opts.accept || {
             default: "",
         };
+        this._dispatch = opts.dispatch;
         this.requestInitGenerator = opts.requestInitGenerator || new RequestInitGenerator();
         this.mapping = opts.mapping || {};
         this.requestMap = new Map();
         this.statusMap = new Map();
         this.store = opts.store;
-        this.requestNotifier = opts.requestNotifier;
         if (opts.fetcher) {
             this.fetcher = opts.fetcher;
         }
     }
 
+    public get dispatch(): MiddlewareActionHandler {
+        if (typeof this._dispatch === "undefined") {
+            throw new Error("Invariant: cannot call `dispatch` before initialization is complete");
+        }
+
+        return this._dispatch;
+    }
+
+    public set dispatch(value: MiddlewareActionHandler) {
+        this._dispatch = value;
+    }
+
     public async execActionByIRI(subject: NamedNode, dataTuple: DataTuple): Promise<LinkedActionResponse> {
 
         const [graph, blobs = []] = dataTuple;
@@ -273,7 +288,17 @@ export class DataProcessor implements LinkedDataAPI {
             opts,
         );
 
-        return this.fetcher.load(iri, options);
+        return this.fetcher.load(iri, options).then((res) => {
+            const actionsHeader = getHeader(res, "Exec-Action");
+            if (actionsHeader) {
+                const actions = actionsHeader.split(", ");
+                for (let i = 0; i < actions.length; i++) {
+                    this.dispatch(namedNodeByIRI(actions[i]), undefined);
+                }
+            }
+
+            return res;
+        });
     }
 
     /**

src/testUtilities.ts

@@ -1,12 +1,13 @@
 import { NamedNode } from "rdflib";
 
 import { ComponentStore } from "./ComponentStore";
+import { createStore } from "./createStore";
 import { LinkedDataAPI } from "./LinkedDataAPI";
 import { LinkedRenderStore } from "./LinkedRenderStore";
 import { DataProcessor } from "./processor/DataProcessor";
 import { RDFStore } from "./RDFStore";
 import { Schema } from "./Schema";
-import { LinkedRenderStoreOptions } from "./types";
+import { LinkedRenderStoreOptions, MiddlewareActionHandler } from "./types";
 
 export type BasicComponent = () => string | undefined;
 
@@ -20,6 +21,7 @@ export class ComponentStoreTestProxy<T> extends ComponentStore<T> {
 
 export interface ExplodedLRS<T> {
     api: LinkedDataAPI;
+    dispatch: MiddlewareActionHandler;
     processor: DataProcessor;
     lrs: LinkedRenderStore<T>;
     mapping: ComponentStoreTestProxy<T>;
@@ -42,7 +44,14 @@ export const getBasicStore = (opts: GetBasicStoreOpts  = {}): ExplodedLRS<BasicC
         schema,
         store,
     } as LinkedRenderStoreOptions<BasicComponent>;
-    const lrs = new LinkedRenderStore(conf);
+    const lrs = createStore(conf);
 
-    return {lrs, mapping, processor, schema, store} as ExplodedLRS<BasicComponent>;
+    return {
+        dispatch: lrs.dispatch,
+        lrs,
+        mapping,
+        processor,
+        schema,
+        store,
+    } as ExplodedLRS<BasicComponent>;
 };