@coasys/hooks-helpers 0.8.2-prerelease

package/package.json

@@ -0,0 +1,24 @@
+{
+    "name": "@coasys/hooks-helpers",
+    "version": "0.8.2-prerelease",
+    "description": "",
+    "main": "./src/index.ts",
+    "module": "./src/index.ts",
+    "private": false,
+    "type": "module",
+    "files": [
+      "dist",
+      "src"
+    ],
+    "scripts": {
+      "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "keywords": [],
+    "author": "",
+    "license": "ISC",
+    "dependencies": {
+      "@coasys/ad4m": "*",
+      "@coasys/ad4m-connect": "*",
+      "uuid": "*"
+    }
+  }

package/src/cache.ts

@@ -0,0 +1,70 @@
+import { PerspectiveProxy } from "@coasys/ad4m";
+
+const cache: Map<string, any> = new Map();
+const subscribers: Map<string, Function[]> = new Map();
+
+export function getCache<T>(key: string) {
+  const match: T | undefined = cache.get(key);
+  return match;
+}
+
+export function setCache<T>(key: string, value: T) {
+  cache.set(key, value);
+  getSubscribers(key).forEach((cb) => cb());
+}
+
+export function subscribe(key: string, callback: Function) {
+  getSubscribers(key).push(callback);
+}
+
+export function unsubscribe(key: string, callback: Function) {
+  const subs = getSubscribers(key);
+  const index = subs.indexOf(callback);
+  if (index >= 0) {
+    subs.splice(index, 1);
+  }
+}
+
+export function getSubscribers(key: string) {
+  if (!subscribers.has(key)) subscribers.set(key, []);
+  return subscribers.get(key)!;
+}
+
+export function subscribeToPerspective(
+  perspective: PerspectiveProxy,
+  added: Function,
+  removed: Function
+) {
+  const addedKey = `perspective-${perspective.uuid}-added`;
+  const removedKey = `perspective-${perspective.uuid}-removed`;
+
+  if (!subscribers.has(addedKey)) {
+    console.log("subscribing!");
+    perspective.addListener("link-added", (link) => {
+      subscribers.get(addedKey).forEach((cb) => cb(link));
+      return null;
+    });
+  }
+
+  if (!subscribers.has(removedKey)) {
+    perspective.addListener("link-removed", (link) => {
+      subscribers.get(removedKey).forEach((cb) => cb(link));
+      return null;
+    });
+  }
+
+  subscribe(addedKey, added);
+  subscribe(removedKey, removed);
+}
+
+export function unsubscribeToPerspective(
+  perspective: PerspectiveProxy,
+  added: Function,
+  removed: Function
+) {
+  const addedKey = `perspective-${perspective.uuid}-added`;
+  const removedKey = `perspective-${perspective.uuid}-removed`;
+
+  unsubscribe(addedKey, added);
+  unsubscribe(removedKey, removed);
+}

package/src/factory/SubjectRepository.ts

@@ -0,0 +1,257 @@
+import {
+  PerspectiveProxy,
+  Link,
+  Subject,
+  Literal,
+  LinkQuery,
+} from "@coasys/ad4m";
+import { setProperties } from "./model";
+import { v4 as uuidv4 } from "uuid";
+
+export const SELF = "ad4m://self";
+
+export type ModelProps = {
+  perspective: PerspectiveProxy;
+  source?: string;
+};
+
+export class SubjectRepository<SubjectClass extends { [x: string]: any }> {
+  source = SELF;
+  subject: SubjectClass | string;
+  perspective: PerspectiveProxy;
+  tempSubject: any | string;
+
+  constructor(subject: { new (): SubjectClass } | string, props: ModelProps) {
+    this.perspective = props.perspective;
+    this.source = props.source || this.source;
+    this.subject = typeof subject === "string" ? subject : new subject();
+    this.tempSubject = subject;
+  }
+
+  get className(): string {
+    return typeof this.subject === "string"
+      ? this.subject
+      : this.subject.className;
+  }
+
+  async ensureSubject() {
+    if (typeof this.tempSubject === "string") return;
+    await this.perspective.ensureSDNASubjectClass(this.tempSubject);
+  }
+
+  async create(
+    data: SubjectClass,
+    id?: string,
+    source?: string
+  ): Promise<SubjectClass> {
+    await this.ensureSubject();
+    const base = id || Literal.from(uuidv4()).toUrl();
+
+    let newInstance = await this.perspective.createSubject(this.subject, base);
+
+    if (!newInstance) {
+      throw "Failed to create new instance of " + this.subject;
+    }
+
+    // Connect new instance to source
+    await this.perspective.add(
+      new Link({
+        source: source || this.source,
+        predicate: "ad4m://has_child",
+        target: base,
+      })
+    );
+
+    Object.keys(data).forEach((key) =>
+      data[key] === undefined || data[key] === null ? delete data[key] : {}
+    );
+
+    setProperties(newInstance, data);
+
+    // @ts-ignore
+    return this.getSubjectData(newInstance);
+  }
+
+  async update(id: string, data: QueryPartialEntity<SubjectClass>) {
+    await this.ensureSubject();
+
+    const instance = await this.get(id);
+
+    if (!instance) {
+      throw "Failed to find instance of " + this.subject + " with id " + id;
+    }
+
+    Object.keys(data).forEach((key) =>
+      data[key] === undefined ? delete data[key] : {}
+    );
+
+    // @ts-ignore
+    setProperties(instance, data);
+
+    return this.getSubjectData(instance);
+  }
+
+  async remove(id: string) {
+    if (this.perspective) {
+      const linksTo = await this.perspective.get(new LinkQuery({ target: id }));
+      const linksFrom = await this.perspective.get(
+        new LinkQuery({ source: id })
+      );
+      this.perspective.removeLinks([...linksFrom, ...linksTo]);
+    }
+  }
+
+  async get(id: string): Promise<SubjectClass | null> {
+    await this.ensureSubject();
+    if (id) {
+      const subjectProxy = await this.perspective.getSubjectProxy(
+        id,
+        this.subject
+      );
+
+      // @ts-ignore
+      return subjectProxy || null;
+    } else {
+      const all = await this.getAll();
+      return all[0] || null;
+    }
+  }
+
+  async getData(id: string): Promise<SubjectClass | string | null> {
+    await this.ensureSubject();
+    const entry = await this.get(id);
+    if (entry) {
+      // @ts-ignore
+      return await this.getSubjectData(entry);
+    }
+
+    return null;
+  }
+
+  private async getSubjectData(entry: any) {
+    let links = await this.perspective.get(
+      new LinkQuery({ source: entry.baseExpression })
+    );
+
+    const getters = Object.entries(Object.getOwnPropertyDescriptors(entry))
+      .filter(([key, descriptor]) => typeof descriptor.get === "function")
+      .map(([key]) => key);
+
+    const promises = getters.map((getter) => entry[getter]);
+    return Promise.all(promises).then((values) => {
+      return getters.reduce((acc, getter, index) => {
+        let value = values[index];
+        if (this.tempSubject.prototype?.__properties[getter]?.transform) {
+          value =
+            this.tempSubject.prototype.__properties[getter].transform(value);
+        }
+
+        return {
+          ...acc,
+          id: entry.baseExpression,
+          timestamp: links[0].timestamp,
+          author: links[0].author,
+          [getter]: value,
+        };
+      }, {});
+    });
+  }
+
+  async getAll(source?: string, query?: QueryOptions): Promise<SubjectClass[]> {
+    await this.ensureSubject();
+
+    const tempSource = source || this.source;
+
+    let res = [];
+
+    if (query) {
+      try {
+        const queryResponse = (
+          await this.perspective.infer(
+            `findall([Timestamp, Base], (subject_class("${this.className}", C), instance(C, Base), link("${tempSource}", Predicate, Base, Timestamp, Author)), AllData), length(AllData, DataLength), sort(AllData, SortedData).`
+          )
+        )[0];
+
+        if (queryResponse.SortedData >= query.size) {
+          const isOutofBound =
+            query.size * query.page > queryResponse.DataLength;
+
+          const newPageSize = isOutofBound
+            ? queryResponse.DataLength - query.size * (query.page - 1)
+            : query.size;
+
+          const mainQuery = `findall([Timestamp, Base], (subject_class("${this.className}", C), instance(C, Base), link("${tempSource}", Predicate, Base, Timestamp, Author)), AllData), sort(AllData, SortedData), reverse(SortedData, ReverseSortedData), paginate(ReverseSortedData, ${query.page}, ${newPageSize}, PageData).`;
+          res = await this.perspective.infer(mainQuery);
+
+          res = res[0].PageData.map((r) => ({
+            Base: r[1],
+            Timestamp: r[0],
+          }));
+        } else {
+          res = await this.perspective.infer(
+            `subject_class("${this.className}", C), instance(C, Base), triple("${tempSource}", Predicate, Base).`
+          );
+        }
+      } catch (e) {
+        console.log("Query failed", e);
+      }
+    } else {
+      res = await this.perspective.infer(
+        `subject_class("${this.className}", C), instance(C, Base), triple("${tempSource}", Predicate, Base).`
+      );
+    }
+
+    const results =
+      res &&
+      res.filter(
+        (obj, index, self) =>
+          index === self.findIndex((t) => t.Base === obj.Base)
+      );
+
+    if (!res) return [];
+
+    const data = await Promise.all(
+      results.map(async (result) => {
+        let subject = new Subject(
+          this.perspective!,
+          result.Base,
+          this.className
+        );
+
+        await subject.init();
+
+        return subject;
+      })
+    );
+
+    // @ts-ignore
+    return data;
+  }
+
+  async getAllData(
+    source?: string,
+    query?: QueryOptions
+  ): Promise<SubjectClass[]> {
+    await this.ensureSubject();
+
+    const subjects = await this.getAll(source, query);
+
+    const entries = await Promise.all(
+      subjects.map((e) => this.getSubjectData(e))
+    );
+
+    // @ts-ignore
+    return entries;
+  }
+}
+
+export type QueryPartialEntity<T> = {
+  [P in keyof T]?: T[P] | (() => string);
+};
+
+export type QueryOptions = {
+  page: number;
+  size: number;
+  infinite: boolean;
+  uniqueKey: string;
+};

package/src/factory/index.ts

@@ -0,0 +1 @@
+export * from "./SubjectRepository";

package/src/factory/model.ts

@@ -0,0 +1,57 @@
+type Target = String;
+
+export type PropertyValueMap = {
+  [property: string]: Target | Target[];
+};
+
+export function capitalize(str: string) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// e.g. "name" -> "setName"
+export function propertyNameToSetterName(property: string): string {
+  return `set${capitalize(property)}`;
+}
+
+export function pluralToSingular(plural: string): string {
+  if (plural.endsWith("ies")) {
+    return plural.slice(0, -3) + "y";
+  } else if (plural.endsWith("s")) {
+    return plural.slice(0, -1);
+  } else {
+    return plural;
+  }
+}
+
+// e.g. "comments" -> "addComment"
+export function collectionToAdderName(collection: string): string {
+  return `add${capitalize(collection)}`;
+}
+
+export function collectionToSetterName(collection: string): string {
+  return `setCollection${capitalize(collection)}`;
+}
+
+export function setProperties(subject: any, properties: PropertyValueMap) {
+  Object.keys(properties).forEach((key) => {
+    if (Array.isArray(properties[key])) {
+      // it's a collection
+      const adderName = collectionToAdderName(key);
+      const adderFunction = subject[adderName];
+      if (adderFunction) {
+        adderFunction(properties[key]);
+      } else {
+        throw "No adder function found for collection: " + key;
+      }
+    } else {
+      // it's a property
+      const setterName = propertyNameToSetterName(key);
+      const setterFunction = subject[setterName];
+      if (setterFunction) {
+        setterFunction(properties[key]);
+      } else {
+        throw "No setter function found for property: " + key;
+      }
+    }
+  });
+}

package/src/getProfile.ts

@@ -0,0 +1,26 @@
+import { Ad4mClient } from "@coasys/ad4m";
+// @ts-ignore
+import { getAd4mClient } from "@coasys/ad4m-connect/utils";
+import { LinkExpression } from "@coasys/ad4m";
+
+export interface Payload {
+  url: string;
+  perspectiveUuid: string;
+}
+
+export async function getProfile<T>(did: string, formatter?: (links: LinkExpression[]) => T): Promise<T | any> {
+  const cleanedDid = did.replace("did://", "");
+  const client: Ad4mClient = await getAd4mClient();
+
+  const agentPerspective = await client.agent.byDID(cleanedDid);
+
+  if (agentPerspective) {
+    const links = agentPerspective!.perspective!.links;
+
+    if (formatter) {
+      return formatter(links);
+    }
+
+    return agentPerspective
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './cache'
+export * from './getProfile'
+export * from './factory'