@openhps/rdf 0.1.10 → 0.1.11

package/package.json

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

package/src/rdf/RDFSerializer.ts

@@ -8,7 +8,7 @@ import {
 } from '@openhps/core';
 import { InternalRDFSerializer } from './InternalRDFSerializer';
 import { InternalRDFDeserializer } from './InternalRDFDeserializer';
-import { IriString, Thing } from './types';
+import { IriString, Thing, Subject } from './types';
 import * as N3 from 'n3';
 import { WriterOptions as N3WriterOptions } from 'n3';
 import { namespaces } from '../namespaces';
@@ -112,6 +112,58 @@ export class RDFSerializer extends DataSerializer {
         return this.deserialize(thing);
     }
 
+    static serializeToSubjects<T>(data: T, baseUri?: IriString): Subject[] {
+        const quads: N3.Quad[] = RDFSerializer.serializeToQuads(data, baseUri);
+        const store = new N3.Store(quads);
+        const quadSubjects: N3.Quad_Subject[] = store.getSubjects(null, null, null);
+        /**
+         *
+         * @param quadSubject
+         */
+        function serializePredicates(quadSubject: N3.Quad_Subject) {
+            const quadPredicates: N3.Quad_Predicate[] = store.getPredicates(quadSubject, null, null);
+            return quadPredicates
+                .map((quadPredicate) => {
+                    const quadObjects: N3.Quad_Object[] = store.getObjects(quadSubject, quadPredicate, null);
+                    const literals: Record<string, string[]> = quadObjects
+                        .filter((obj) => obj instanceof N3.Literal)
+                        .filter((obj: N3.Literal) => obj.language === '')
+                        .map((obj: N3.Literal) => ({ [obj.datatype.value]: [obj.value] }))
+                        .reduce((a, b) => ({ ...a, ...b }), {});
+                    const langStrings: Record<string, string[]> = quadObjects
+                        .filter((obj) => obj instanceof N3.Literal)
+                        .filter((obj: N3.Literal) => obj.language !== '')
+                        .map((obj: N3.Literal) => ({ [obj.language]: [obj.value] }))
+                        .reduce((a, b) => ({ ...a, ...b }), {});
+                    const namedNodes: Array<string> = quadObjects
+                        .filter((obj) => obj instanceof N3.NamedNode)
+                        .map((obj) => obj.value);
+                    const blankNodes: Array<any | string> = quadObjects
+                        .filter((obj) => obj instanceof N3.BlankNode)
+                        .map((obj: N3.BlankNode) => serializePredicates(N3.DataFactory.blankNode(obj.value)));
+                    return {
+                        [quadPredicate.value]: {
+                            namedNodes,
+                            blankNodes,
+                            literals,
+                            langStrings,
+                        },
+                    };
+                })
+                .reduce((a, b) => ({ ...a, ...b }), {});
+        }
+        const subjects: Subject[] = quadSubjects
+            .filter((quadSubject) => quadSubject instanceof N3.NamedNode)
+            .map((quadSubject) => {
+                return {
+                    type: 'Subject',
+                    url: quadSubject.value,
+                    predicates: serializePredicates(quadSubject),
+                };
+            });
+        return subjects;
+    }
+
     static serializeToQuads<T>(data: T, baseUri?: IriString): N3.Quad[] {
         const thing =
             (data as any)['predicates'] !== undefined ? (data as unknown as Thing) : this.serialize(data, baseUri);

package/src/rdf/SerializableNamedNode.ts

@@ -1,6 +1,6 @@
 import { SerializableObject } from '@openhps/core';
 import * as N3 from 'n3';
-import { IriString, Thing } from './types';
+import { Thing } from './types';
 
 @SerializableObject({
     rdf: {
@@ -10,12 +10,8 @@ import { IriString, Thing } from './types';
             };
         },
         deserializer: (thing: Thing) => {
-            return new SerializableNamedNode(thing.value as IriString);
+            return new SerializableNamedNode(thing.value);
         },
     },
 })
-export class SerializableNamedNode extends N3.NamedNode {
-    constructor(uri: IriString) {
-        super(uri);
-    }
-}
+export class SerializableNamedNode extends N3.NamedNode {}

package/src/rdf/types.ts

@@ -8,6 +8,19 @@ export type Thing = {
     value: string;
     predicates?: Record<string, (Quad_Object | Thing)[]>;
 };
+export type Subject = {
+    type: 'Subject';
+    url: string;
+    predicates: Record<
+        IriString,
+        Partial<{
+            literals: Record<string, string[]>;
+            langStrings: Record<LocaleString, string[]>;
+            namedNodes: Array<string>;
+            blankNodes: Array<any | string>;
+        }>
+    >;
+};
 export type LocaleString = 'en';
 
 export interface RDFSerializerConfig extends DataSerializerConfig {