chore: reduce codesmells

Author: Thom

src/ComponentStore/ComponentStore.ts

@@ -93,51 +93,9 @@ export class ComponentStore<T> {
             return cached;
         }
 
-        for (let p = 0; p < fields.length; p++) {
-            for (let t = 0; t < oTypes.length; t++) {
-                const exact = this.lookup(fields[p], oTypes[t], topology);
-                if (exact !== undefined) {
-                    return this.lookupCache.add(exact, key);
-                }
-            }
-        }
-
-        const possibleClasses = this.registeredClasses(fields, topology);
-        if (possibleClasses.length === 0) {
-            if (topology === DEFAULT_TOPOLOGY.value) {
-                return this.lookupCache.add(null, key);
-            }
-            const foundComponent = this.getRenderComponent(
-                oTypes,
-                fields,
-                DEFAULT_TOPOLOGY.value,
-                defaultType,
-            );
-            if (!foundComponent) {
-                return this.lookupCache.add(null, key);
-            }
+        const match = this.findMatch(oTypes, fields, topology, defaultType);
 
-            return this.lookupCache.add(foundComponent, key);
-        }
-        for (let i = 0; i < fields.length; i++) {
-            const bestClass = this.bestClass(possibleClasses, oTypes);
-            const component = bestClass && this.lookup(
-                fields[i],
-                bestClass,
-                topology,
-            );
-            if (component) {
-                return this.lookupCache.add(component, key);
-            }
-        }
-        for (let i = 0; i < fields.length; i++) {
-            const component = this.lookup(fields[i], defaultType, topology);
-            if (component) {
-                return this.lookupCache.add(component, key);
-            }
-        }
-
-        return this.lookupCache.add(null, key);
+        return this.lookupCache.add(match, key);
     }
 
     /**
@@ -219,7 +177,90 @@ export class ComponentStore<T> {
         return components.find((c) => chain.indexOf(c) > 0);
     }
 
-    // interface ComponentMapping<T> { [type: string]: { [obj: string]: { [topology: string]: T } }; }
+    private classMatch(possibleClasses: Id[], types: Id[], fields: Id[], topology: Id): T | undefined {
+        for (let i = 0; i < fields.length; i++) {
+            const bestClass = this.bestClass(possibleClasses, types);
+            const component = bestClass && this.lookup(
+              fields[i],
+              bestClass,
+              topology,
+            );
+
+            if (component) {
+                return component;
+            }
+        }
+
+        return undefined;
+    }
+
+    private defaultMatch(fields: Id[], topology: Id, defaultType: Id): T | undefined {
+        for (let i = 0; i < fields.length; i++) {
+            const component = this.lookup(fields[i], defaultType, topology);
+            if (component) {
+                return component;
+            }
+        }
+
+        return undefined;
+    }
+
+    private exactMatch(types: Id[], fields: Id[], topology: Id): T | undefined {
+        for (let p = 0; p < fields.length; p++) {
+            for (let t = 0; t < types.length; t++) {
+                const exact = this.lookup(fields[p], types[t], topology);
+                if (exact !== undefined) {
+                    return exact;
+                }
+            }
+        }
+
+        return undefined;
+    }
+
+    private findMatch(types: Id[], fields: Id[], topology: Id, defaultType: Id): T | null {
+        let match: T | null | undefined = this.exactMatch(types, fields, topology);
+        if (match !== undefined) {
+            return match;
+        }
+
+        const possibleClasses = this.registeredClasses(fields, topology);
+
+        if (possibleClasses.length === 0) {
+            return this.noClassesMatch(types, fields, topology, defaultType);
+        }
+
+        match = this.classMatch(possibleClasses, types, fields, topology);
+        if (match !== undefined) {
+            return match;
+        }
+
+        match = this.defaultMatch(fields, topology, defaultType);
+        if (match !== undefined) {
+            return match;
+        }
+
+        return null;
+    }
+
+    private noClassesMatch(types: Id[], fields: Id[], topology: Id, defaultType: Id): T | null {
+        if (topology === DEFAULT_TOPOLOGY.value) {
+            return null;
+        }
+
+        const foundComponent = this.getRenderComponent(
+          types,
+          fields,
+          DEFAULT_TOPOLOGY.value,
+          defaultType,
+        );
+
+        if (foundComponent) {
+            return foundComponent;
+        }
+
+        return null;
+    }
 
     /**
      * Returns a list of classes which have registrations for a combination of {fields} and {topology}.

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;
+};