@openhps/rdf 0.1.8 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openhps/rdf",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Open Hybrid Positioning System",
   "author": "Maxim Van de Wynckel",
   "license": "Apache-2.0",

package/src/service/SPARQLDataDriver.ts

@@ -1,25 +1,15 @@
-import {
-    DataServiceOptions,
-    FilterQuery,
-    FindOptions,
-    Constructor,
-    MemoryQueryEvaluator,
-    DataServiceDriver,
-} from '@openhps/core';
-import { DataFactory, Store } from 'n3';
-import { IriString, RDFSerializer, UrlString } from '../rdf';
+import { FilterQuery, Constructor } from '@openhps/core';
+import { Store } from 'n3';
+import { IriString, UrlString } from '../rdf';
 import SparqlClient from 'sparql-http-client';
-import { rdf } from '../vocab';
-import { SPARQLGenerator } from './SPARQLGenerator';
+import { SPARQLDriverBase, SPARQLDriverOptions } from './SPARQLDriverBase';
 
-export class SPARQLDataDriver<T> extends DataServiceDriver<IriString, T> {
+export class SPARQLDataDriver<T> extends SPARQLDriverBase<T> {
     protected options: SPARQLDataDriverOptions;
     protected client: SparqlClient;
-    protected generator: SPARQLGenerator<T>;
 
     constructor(dataType?: Constructor<T>, options?: SPARQLDataDriverOptions) {
         super(dataType, options);
-        this.generator = new SPARQLGenerator(this.dataType, this.options.baseUri);
         this.once('build', this._onBuild.bind(this));
     }
 
@@ -36,30 +26,6 @@ export class SPARQLDataDriver<T> extends DataServiceDriver<IriString, T> {
         });
     }
 
-    findByUID(id: IriString): Promise<T> {
-        return new Promise((resolve, reject) => {
-            const identifierMember = RDFSerializer.getUriMetadata(this.dataType);
-            this.findOne({
-                [identifierMember.key]: id,
-            } as any)
-                .then(resolve)
-                .catch(reject);
-        });
-    }
-
-    findOne(query?: FilterQuery<T>, options: FindOptions = {}): Promise<T> {
-        return new Promise((resolve, reject) => {
-            this.findAll(query, {
-                limit: 1,
-                sort: options.sort,
-            })
-                .then((results) => {
-                    resolve(results[0]);
-                })
-                .catch(reject);
-        });
-    }
-
     protected findAllSerialized(query?: FilterQuery<T>): Promise<Store> {
         return new Promise((resolve, reject) => {
             this.client.query
@@ -77,60 +43,6 @@ export class SPARQLDataDriver<T> extends DataServiceDriver<IriString, T> {
         });
     }
 
-    findAll(query?: FilterQuery<T>, options: FindOptions = {}): Promise<T[]> {
-        return new Promise((resolve, reject) => {
-            this.findAllSerialized(query)
-                .then((store) => {
-                    if (store.size === 0) {
-                        return resolve([]);
-                    }
-                    const subjects = store
-                        .getSubjects(DataFactory.namedNode(rdf.type), null, null)
-                        .filter((subject) => subject.termType === 'NamedNode');
-                    let data: T[] = subjects.map((subject) =>
-                        RDFSerializer.deserializeFromStore(subject as any, store),
-                    );
-                    if (options.sort) {
-                        data = data
-                            .sort((a, b) =>
-                                options.sort
-                                    .map((s) => {
-                                        const res1 = MemoryQueryEvaluator.getValueFromPath(s[1] > 0 ? a : b, s[0])[1];
-                                        const res2 = MemoryQueryEvaluator.getValueFromPath(s[1] > 0 ? b : a, s[0])[1];
-                                        if (typeof res1 === 'number') {
-                                            return res1 - res2;
-                                        } else if (typeof res1 === 'string') {
-                                            return res1.localeCompare(res2);
-                                        } else {
-                                            return 0;
-                                        }
-                                    })
-                                    .reduce((a, b) => a + b),
-                            )
-                            .slice(0, options.limit);
-                    }
-                    resolve(data);
-                })
-                .catch(reject);
-        });
-    }
-
-    count(query?: FilterQuery<T>): Promise<number> {
-        return new Promise((resolve, reject) => {
-            this.findAllSerialized(query)
-                .then((store) => {
-                    if (store.size === 0) {
-                        return resolve(0);
-                    }
-                    const subjects = store
-                        .getSubjects(DataFactory.namedNode(rdf.type), null, null)
-                        .filter((subject) => subject.termType === 'NamedNode');
-                    resolve(subjects.length);
-                })
-                .catch(reject);
-        });
-    }
-
     insert(_: IriString, object: T): Promise<T> {
         return new Promise((resolve, reject) => {
             this.client.query
@@ -170,13 +82,12 @@ export class SPARQLDataDriver<T> extends DataServiceDriver<IriString, T> {
     }
 }
 
-export interface SPARQLDataDriverOptions extends DataServiceOptions {
+export interface SPARQLDataDriverOptions extends SPARQLDriverOptions {
     endpointUrl: UrlString;
     storeUrl?: UrlString;
     updateUrl?: UrlString;
     headers?: HeadersInit;
     user?: string;
     password?: string;
-    baseUri?: IriString;
     operation?: 'get' | 'postUrlencoded' | 'postDirect';
 }

package/src/service/SPARQLDriverBase.ts

@@ -0,0 +1,112 @@
+import {
+    DataServiceOptions,
+    FilterQuery,
+    FindOptions,
+    Constructor,
+    MemoryQueryEvaluator,
+    DataServiceDriver,
+} from '@openhps/core';
+import { DataFactory, Store } from 'n3';
+import { IriString, RDFSerializer } from '../rdf';
+import { rdf } from '../vocab';
+import { SPARQLGenerator } from './SPARQLGenerator';
+
+export abstract class SPARQLDriverBase<T> extends DataServiceDriver<IriString, T> {
+    protected options: SPARQLDriverOptions;
+    protected generator: SPARQLGenerator<T>;
+
+    constructor(dataType?: Constructor<T>, options?: SPARQLDriverOptions) {
+        super(dataType, options);
+        this.generator = new SPARQLGenerator(this.dataType, this.options.baseUri);
+    }
+
+    findByUID(id: IriString): Promise<T> {
+        return new Promise((resolve, reject) => {
+            const identifierMember = RDFSerializer.getUriMetadata(this.dataType);
+            this.findOne({
+                [identifierMember.key]: id,
+            } as any)
+                .then(resolve)
+                .catch(reject);
+        });
+    }
+
+    findOne(query?: FilterQuery<T>, options: FindOptions = {}): Promise<T> {
+        return new Promise((resolve, reject) => {
+            this.findAll(query, {
+                limit: 1,
+                sort: options.sort,
+            })
+                .then((results) => {
+                    resolve(results[0]);
+                })
+                .catch(reject);
+        });
+    }
+
+    protected abstract findAllSerialized(query?: FilterQuery<T>): Promise<Store>;
+
+    findAll(query?: FilterQuery<T>, options: FindOptions = {}): Promise<T[]> {
+        return new Promise((resolve, reject) => {
+            this.findAllSerialized(query)
+                .then((store) => {
+                    if (store.size === 0) {
+                        return resolve([]);
+                    }
+                    const subjects = store
+                        .getSubjects(DataFactory.namedNode(rdf.type), null, null)
+                        .filter((subject) => subject.termType === 'NamedNode');
+                    let data: T[] = subjects
+                        .map((subject) => RDFSerializer.deserializeFromStore(subject as any, store))
+                        .filter((data) => data.constructor.name === this.dataType.name) as T[];
+                    if (options.sort) {
+                        data = data
+                            .sort((a, b) =>
+                                options.sort
+                                    .map((s) => {
+                                        const res1 = MemoryQueryEvaluator.getValueFromPath(s[1] > 0 ? a : b, s[0])[1];
+                                        const res2 = MemoryQueryEvaluator.getValueFromPath(s[1] > 0 ? b : a, s[0])[1];
+                                        if (typeof res1 === 'number') {
+                                            return res1 - res2;
+                                        } else if (typeof res1 === 'string') {
+                                            return res1.localeCompare(res2);
+                                        } else {
+                                            return 0;
+                                        }
+                                    })
+                                    .reduce((a, b) => a + b),
+                            )
+                            .slice(0, options.limit);
+                    }
+                    resolve(data);
+                })
+                .catch(reject);
+        });
+    }
+
+    count(query?: FilterQuery<T>): Promise<number> {
+        return new Promise((resolve, reject) => {
+            this.findAllSerialized(query)
+                .then((store) => {
+                    if (store.size === 0) {
+                        return resolve(0);
+                    }
+                    const subjects = store
+                        .getSubjects(DataFactory.namedNode(rdf.type), null, null)
+                        .filter((subject) => subject.termType === 'NamedNode');
+                    resolve(subjects.length);
+                })
+                .catch(reject);
+        });
+    }
+
+    abstract insert(_: IriString, object: T): Promise<T>;
+
+    abstract delete(id: IriString): Promise<void>;
+
+    abstract deleteAll(query?: FilterQuery<T>): Promise<void>;
+}
+
+export interface SPARQLDriverOptions extends DataServiceOptions {
+    baseUri?: IriString;
+}

package/src/service/SPARQLGenerator.ts

@@ -491,7 +491,21 @@ export class SPARQLGenerator<T> {
                 // result = result && !Array.from(value).includes(subquery[selector]);
                 break;
             case '$elemMatch':
-                patterns.push(...this.createQuery(subquery[selector], dataType));
+                patterns.push({
+                    type: 'group',
+                    patterns: [
+                        {
+                            type: 'bgp',
+                            triples: [
+                                {
+                                    subject: DataFactory.variable('subject'),
+                                    predicate: DataFactory.namedNode(predicate),
+                                    object: DataFactory.namedNode(this.baseUri + 'dataobject_mvdewync'),
+                                },
+                            ],
+                        },
+                    ],
+                });
                 break;
         }
         return patterns;

package/src/service/index.ts

@@ -1,2 +1,3 @@
 export * from './SPARQLDataDriver';
 export * from './SPARQLGenerator';
+export * from './SPARQLDriverBase';