chore: reduce codesmells

Author: Thom

src/datastrucures/DataSliceDSL.ts

@@ -1,9 +1,12 @@
 import rdfFactory, { SomeTerm } from "@ontologies/core";
+import { idToValue } from "../factoryHelpers";
 
 import { SomeNode } from "../types";
 
 import { DataRecord, DataSlice } from "./DataSlice";
 
+export type OptionalIdOrNode = string | SomeNode | undefined;
+
 export interface RecordBuilder {
   /** Sets the {value} of {field} on the current record */
   field(field: string | SomeNode, value: SomeTerm): this;
@@ -12,11 +15,19 @@ export interface RecordBuilder {
 }
 
 export interface SliceBuilder {
-  record(id?: string | SomeNode | undefined): RecordBuilder;
+  record(id?: OptionalIdOrNode): RecordBuilder;
 }
 
 export type SliceCreator = (slice: SliceBuilder) => void;
 
+const stringIdOrNewLocal = (id: OptionalIdOrNode): string => {
+  if (id === undefined) {
+    return rdfFactory.blankNode().value;
+  }
+
+  return typeof id === "string" ? id : id.value;
+};
+
 export const buildSlice = (creator: SliceCreator): DataSlice => {
   if (creator === undefined) {
     throw new Error("No creator passed");
@@ -25,14 +36,9 @@ export const buildSlice = (creator: SliceCreator): DataSlice => {
   const slice: DataSlice = {};
 
   const builder: SliceBuilder = {
-    record(id: string | SomeNode | undefined): RecordBuilder {
-      const stringId = id === undefined
-        ? rdfFactory.blankNode().value
-        : (typeof id === "string" ? id : id.value);
-
-      const termId = stringId.startsWith("_:")
-        ? rdfFactory.blankNode(stringId)
-        : rdfFactory.namedNode(stringId);
+    record(id: OptionalIdOrNode): RecordBuilder {
+      const stringId = stringIdOrNewLocal(id);
+      const termId = idToValue(stringId);
 
       const record: DataRecord = {
         _id: termId,

src/index.ts

@@ -19,6 +19,7 @@ export {
 export { transformers } from "./transformers/index";
 
 export {
+    OptionalIdOrNode,
     SliceCreator,
     RecordBuilder,
     buildSlice,
@@ -80,6 +81,11 @@ export {
 } from "./TypedRecord";
 export { RecordState } from "./store/RecordState";
 export { RecordStatus } from "./store/RecordStatus";
+export {
+    hasReferenceTo,
+    fieldReferences,
+    findAllReferencingIds,
+} from "./store/StructuredStore/references";
 export {
     idField,
     StructuredStore,

src/store/StructuredStore.ts

@@ -1,8 +1,8 @@
-import rdfFactory, { SomeTerm, TermType } from "@ontologies/core";
+import rdfFactory, { SomeTerm } from "@ontologies/core";
 import * as rdf from "@ontologies/rdf";
 import * as rdfs from "@ontologies/rdfs";
 
-import { DataRecord, FieldSet, Id } from "../datastrucures/DataSlice";
+import { DataRecord, DataSlice, FieldSet, Id } from "../datastrucures/DataSlice";
 import { DeepRecord, DeepRecordFieldValue } from "../datastrucures/DeepSlice";
 import { FieldId, FieldValue, MultimapTerm } from "../datastrucures/Fields";
 import { SomeNode } from "../types";
@@ -11,6 +11,7 @@ import { normalizeType } from "../utilities";
 import { RecordJournal } from "./RecordJournal";
 import { RecordState } from "./RecordState";
 import { RecordStatus } from "./RecordStatus";
+import { findAllReferencingIds } from "./StructuredStore/references";
 
 export const idField = "_id";
 const member = rdfs.member.value;
@@ -79,7 +80,7 @@ export class StructuredStore {
   public base: string;
 
   /** @private */
-  public data: Record<Id, DataRecord>;
+  public data: DataSlice;
 
   /** @private */
   public journal: RecordJournal;
@@ -94,7 +95,7 @@ export class StructuredStore {
    */
   constructor(
       base: string = "rdf:defaultGraph",
-      data: Record<Id, DataRecord> | undefined = {},
+      data: DataSlice | undefined = {},
       onChange: (docId: string) => void = (): void => undefined,
   ) {
     this.base = base;
@@ -249,36 +250,7 @@ export class StructuredStore {
    * Find all records which reference this given [recordId]
    */
   public references(recordId: Id): Id[] {
-    const references = [];
-    const data = this.data;
-
-    for (const rId in data) {
-      if (!data.hasOwnProperty(rId)) {
-        continue;
-      }
-
-      const record = data[rId];
-      for (const field in record) {
-        if (!record.hasOwnProperty(field) || field === idField) {
-          continue;
-        }
-
-        const values = record[field];
-        if (Array.isArray(values)) {
-          for (const value of values) {
-            if (value.termType !== TermType.Literal && value.value === recordId) {
-              references.push(rId);
-            }
-          }
-        } else {
-          if (values.termType !== TermType.Literal && values.value === recordId) {
-            references.push(rId);
-          }
-        }
-      }
-    }
-
-    return references;
+    return findAllReferencingIds(this.data, recordId);
   }
 
   /**

src/store/StructuredStore/references.ts

@@ -0,0 +1,53 @@
+import { TermType } from "@ontologies/core";
+
+import { DataRecord, DataSlice, Id } from "../../datastrucures/DataSlice";
+import { FieldValue } from "../../datastrucures/Fields";
+import { idField } from "../StructuredStore";
+
+export const fieldReferences = (values: FieldValue, referenced: Id): boolean => {
+  if (Array.isArray(values)) {
+    for (const value of values) {
+      if (value.termType !== TermType.Literal && value.value === referenced) {
+        return true;
+      }
+    }
+  } else {
+    if (values.termType !== TermType.Literal && values.value === referenced) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+export const hasReferenceTo = (record: DataRecord, referenced: Id): boolean => {
+  for (const field in record) {
+    if (!record.hasOwnProperty(field) || field === idField) {
+      continue;
+    }
+
+    const values = record[field];
+    if (fieldReferences(values, referenced)) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+export const findAllReferencingIds = (data: DataSlice, referenced: Id): Id[] => {
+  const found = [];
+
+  for (const id in data) {
+    if (!data.hasOwnProperty(id)) {
+      continue;
+    }
+
+    const record = data[id];
+    if (hasReferenceTo(record, referenced)) {
+      found.push(id);
+    }
+  }
+
+  return found;
+};