@superbia/untrue 1.4.0 → 2.0.0

package/dist/Api.d.ts

@@ -0,0 +1,14 @@
+import { Client, EndpointRecord, Response, ResponseResult } from "@superbia/client";
+import { DocumentSchemaRecord } from "./SuperbiaContext";
+import { DocumentContext, Documents } from "./DocumentContext";
+import { RequestContext, Request } from "./RequestContext";
+export default class Api<K extends DocumentSchemaRecord, M extends EndpointRecord, N extends EndpointRecord = {}, O extends string = "id"> {
+    readonly client: Client<M, N>;
+    readonly documents: DocumentContext<K, M>;
+    readonly requests: RequestContext<M, O>;
+    constructor(client: Client<M, N>, idKey?: string);
+    useDocuments<W>(selector: (documents: Documents<K>) => W): W;
+    useRequest<Y extends ResponseResult, W, X extends any[] = any[]>(key: string, selector: (request: Request<Y, O>) => W, requester?: (...args: X) => Promise<Response<Y>>): [W, (...args: X) => Promise<void>];
+    useLoad<Y extends ResponseResult, W, X extends any[]>(key: string, selector: (request: Request<Y, O>) => W, loader: (...args: X) => Promise<Response<Y>>): [W, (...args: X) => Promise<void>];
+    useRequestKey(params?: any[]): string;
+}

package/dist/Api.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const untrue_1 = require("untrue");
+const uuid_1 = require("uuid");
+const DocumentContext_1 = require("./DocumentContext");
+const RequestContext_1 = require("./RequestContext");
+class Api {
+    constructor(client, idKey = "id") {
+        this.client = client;
+        this.documents = new DocumentContext_1.DocumentContext(client, idKey);
+        this.requests = new RequestContext_1.RequestContext(client, idKey);
+    }
+    useDocuments(selector) {
+        return untrue_1.Hook.useContext(this.documents, () => selector(this.documents.data));
+    }
+    useRequest(key, selector, requester) {
+        const value = untrue_1.Hook.useContext(this.requests, () => {
+            var _a;
+            let request = ((_a = this.requests.data[key]) !== null && _a !== void 0 ? _a : null);
+            if (request === null) {
+                request = {
+                    loading: false,
+                    done: false,
+                    result: null,
+                    error: null,
+                };
+            }
+            return selector(request);
+        });
+        const request = async (...args) => {
+            if (requester === undefined) {
+                throw new Error("Requester not defined in useRequest.");
+            }
+            this.requests.data[key] = {
+                loading: true,
+                done: false,
+                result: null,
+                error: null,
+            };
+            this.requests.update();
+            try {
+                const response = await requester(...args);
+                const result = response.result();
+                const parsedResult = this.requests.parseResult(result);
+                this.requests.data[key] = {
+                    loading: false,
+                    done: true,
+                    result: parsedResult,
+                    error: null,
+                };
+                this.requests.update();
+            }
+            catch (error) {
+                this.requests.data[key] = {
+                    loading: false,
+                    done: false,
+                    result: null,
+                    error,
+                };
+                this.requests.update();
+            }
+        };
+        return [value, request];
+    }
+    useLoad(key, selector, loader) {
+        const value = untrue_1.Hook.useContext(this.requests, () => {
+            const request = this.requests.data[key];
+            return selector(request);
+        });
+        const load = async (...args) => {
+            const request = this.requests.data[key];
+            const tmpResult = request.result;
+            let tmpPagination;
+            let endpointName;
+            this.client.once("request", (endpoints) => {
+                endpointName = Object.keys(endpoints)[0];
+                tmpPagination = tmpResult[endpointName];
+                tmpPagination.loading = true;
+                tmpPagination.error = null;
+                this.requests.update();
+            });
+            endpointName = endpointName;
+            tmpPagination = tmpPagination;
+            try {
+                const response = await loader(...args);
+                const result = response.result();
+                const parsedResult = this.requests.parseResult(result);
+                const endpointResult = parsedResult[endpointName];
+                tmpPagination.loading = false;
+                tmpPagination.error = null;
+                tmpPagination.result.hasNextPage = endpointResult.result.hasNextPage;
+                tmpPagination.result.nextPageCursor =
+                    endpointResult.result.nextPageCursor;
+                tmpPagination.result.nodes.push(...endpointResult.result.nodes);
+                this.requests.update();
+            }
+            catch (error) {
+                tmpPagination.loading = false;
+                tmpPagination.error = error;
+                this.requests.update();
+            }
+        };
+        return [value, load];
+    }
+    useRequestKey(params) {
+        return untrue_1.Hook.useMemo(() => (0, uuid_1.v4)(), params);
+    }
+}
+exports.default = Api;

package/dist/DocumentContext.d.ts

@@ -0,0 +1,15 @@
+import { Client, Result, EndpointRecord } from "@superbia/client";
+import { ParsedResult, SuperbiaContext, DocumentSchema, DocumentSchemaRecord } from "./SuperbiaContext";
+export type Document<T extends DocumentSchema> = {
+    [K in keyof T]: ParsedResult<T[K]>;
+};
+export type Documents<T extends DocumentSchemaRecord> = {
+    [K in keyof T]: Record<string, Result<Document<T[K]>>>;
+};
+export declare class DocumentContext<K extends DocumentSchemaRecord, M extends EndpointRecord> extends SuperbiaContext<M> {
+    data: Documents<K>;
+    constructor(client: Client<M, any>, idKey: string);
+    hydrate(data: any): void;
+    persist(): any;
+    private handleResult;
+}

package/dist/DocumentContext.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentContext = void 0;
+const SuperbiaContext_1 = require("./SuperbiaContext");
+class DocumentContext extends SuperbiaContext_1.SuperbiaContext {
+    constructor(client, idKey) {
+        super(client, idKey);
+        this.data = {};
+        const listener = (endpoints, emitter) => {
+            emitter.on("result", (result) => {
+                this.handleResult(result);
+            });
+        };
+        client.on("request", listener);
+        client.on("subscribe", listener);
+    }
+    hydrate(data) {
+        this.data = data;
+    }
+    persist() {
+        return this.data;
+    }
+    handleResult(result) {
+        const data = {};
+        for (const tmpResult of Object.values(result)) {
+            this.parseResultValue(tmpResult, data);
+        }
+        const types = Object.keys(data);
+        if (types.length === 0) {
+            return;
+        }
+        const documents = this.data;
+        for (const type of types) {
+            if (!(type in documents)) {
+                documents[type] = {};
+            }
+            const tmpDocuments = data[type];
+            for (const id in tmpDocuments) {
+                documents[type][id] = tmpDocuments[id];
+            }
+        }
+        this.update();
+    }
+}
+exports.DocumentContext = DocumentContext;

package/dist/RequestContext.d.ts

@@ -0,0 +1,24 @@
+import { Result, Pagination, EndpointRecord, ResponseResult } from "@superbia/client";
+import { ParsedResult, SuperbiaContext } from "./SuperbiaContext";
+export interface PaginationResult<T, O extends string> {
+    loading: boolean;
+    result: ParsedResult<T, O>;
+    error: Error | null;
+}
+export type Request<T extends ResponseResult, O extends string> = {
+    loading: boolean;
+    done: boolean;
+    result: {
+        [K in keyof T]: T[K] extends Pagination<any> ? PaginationResult<T[K], O> : ParsedResult<T[K], O>;
+    } | null;
+    error: Error | null;
+};
+export type Requests<T extends EndpointRecord, O extends string> = Record<string, Request<{
+    [K in keyof T]: Result<T[K]["result"]>;
+}, O>>;
+export declare class RequestContext<M extends EndpointRecord, O extends string> extends SuperbiaContext<M> {
+    data: Requests<M, O>;
+    hydrate(data: any): void;
+    persist(): any;
+    parseResult(result: ResponseResult): ResponseResult;
+}

package/dist/RequestContext.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestContext = void 0;
+const SuperbiaContext_1 = require("./SuperbiaContext");
+class RequestContext extends SuperbiaContext_1.SuperbiaContext {
+    constructor() {
+        super(...arguments);
+        this.data = {};
+    }
+    hydrate(data) {
+        this.data = data;
+    }
+    persist() {
+        return this.data;
+    }
+    parseResult(result) {
+        const tmpResult = {};
+        for (const key in result) {
+            const endpointResult = result[key];
+            let tmpEndpointResult;
+            if (endpointResult !== null &&
+                typeof endpointResult === "object" &&
+                this.typenameKey in endpointResult &&
+                endpointResult[this.typenameKey].endsWith("Pagination")) {
+                tmpEndpointResult = {
+                    loading: false,
+                    result: this.parseResultValue(endpointResult),
+                    error: null,
+                };
+            }
+            else {
+                tmpEndpointResult = this.parseResultValue(endpointResult);
+            }
+            tmpResult[key] = tmpEndpointResult;
+        }
+        return tmpResult;
+    }
+}
+exports.RequestContext = RequestContext;

package/dist/SuperbiaContext.d.ts

@@ -0,0 +1,19 @@
+import { Context } from "untrue";
+import { Client, EndpointRecord } from "@superbia/client";
+type IdObject<U extends string> = {
+    [K in U]: string;
+};
+export type ParsedResult<T, U extends string = "id"> = T extends IdObject<U> ? string : T extends IdObject<U> | null ? string | null : T extends IdObject<U>[] ? string[] : T extends (IdObject<U> | null)[] ? (string | null)[] : T extends null ? null : T extends object ? {
+    [K in keyof T]: ParsedResult<T[K], U>;
+} : T;
+export type DocumentSchema = Record<string, any>;
+export type DocumentSchemaRecord = Record<string, DocumentSchema>;
+export type DocumentData = Record<string, Record<string, DocumentSchema>>;
+export declare class SuperbiaContext<M extends EndpointRecord> extends Context {
+    protected client: Client<M, any>;
+    protected idKey: string;
+    protected typenameKey: string;
+    constructor(client: Client<M, any>, idKey: string);
+    parseResultValue(result: any, data?: DocumentData): any;
+}
+export {};

package/dist/SuperbiaContext.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuperbiaContext = void 0;
+const untrue_1 = require("untrue");
+class SuperbiaContext extends untrue_1.Context {
+    constructor(client, idKey) {
+        super();
+        this.client = client;
+        this.idKey = idKey;
+        this.typenameKey = "_typename";
+    }
+    parseResultValue(result, data = {}) {
+        if (result === null) {
+            return null;
+        }
+        if (Array.isArray(result)) {
+            return result.map((element) => this.parseResultValue(element, data));
+        }
+        if (typeof result === "object") {
+            const newResult = {};
+            for (const key in result) {
+                newResult[key] = this.parseResultValue(result[key], data);
+            }
+            const isDocument = this.idKey in result && this.typenameKey in result;
+            if (!isDocument) {
+                return newResult;
+            }
+            const id = result[this.idKey];
+            const typename = result[this.typenameKey];
+            if (!(typename in data)) {
+                data[typename] = {};
+            }
+            data[typename][id] = newResult;
+            return result[this.idKey];
+        }
+        return result;
+    }
+}
+exports.SuperbiaContext = SuperbiaContext;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from "./Api";
+export { ParsedResult } from "./SuperbiaContext";
+export { Document, Documents } from "./DocumentContext";
+export { Request, Requests, PaginationResult } from "./RequestContext";

package/dist/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+var Api_1 = require("./Api");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(Api_1).default; } });

package/package.json

@@ -1,21 +1,30 @@
 {
   "name": "@superbia/untrue",
-  "version": "1.4.0",
+  "version": "2.0.0",
   "description": "Integrate Superbia and Untrue.",
   "repository": {
     "type": "git",
     "url": "https://github.com/iconshot/superbia-untrue.git"
   },
-  "main": "index.js",
+  "main": "dist/index.js",
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "npm run clean && tsc",
+    "prepare": "npm run build"
+  },
   "keywords": [
     "superbia",
     "untrue"
   ],
   "license": "MIT",
   "peerDependencies": {
-    "untrue": "^5.7.2"
+    "untrue": "^5.8.0",
+    "@superbia/client": "^2.0.8"
   },
   "dependencies": {
     "uuid": "^10.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.3"
   }
 }

package/index.js

@@ -1,4 +0,0 @@
-export { default } from "./src/SuperbiaUntrue";
-
-export * from "./src/DocumentContext";
-export * from "./src/RequestContext";

package/src/DocumentContext.js

@@ -1,58 +0,0 @@
-import SuperbiaContext from "./SuperbiaContext";
-
-export class DocumentContext extends SuperbiaContext {
-  constructor(client, id) {
-    super(id);
-
-    this.documents = {};
-
-    const listener = (endpoints, emitter) => {
-      emitter.on("data", (data) => this.data(data));
-    };
-
-    client.on("request", listener);
-    client.on("subscribe", listener);
-  }
-
-  // default persistence
-
-  hydrate(documents) {
-    this.documents = documents;
-  }
-
-  persist() {
-    return this.documents;
-  }
-
-  getDocuments() {
-    return this.documents;
-  }
-
-  data(data) {
-    const newData = {};
-
-    Object.values(data).forEach((result) => {
-      this.parseResult(result, newData);
-    });
-
-    const types = Object.keys(newData);
-
-    if (types.length === 0) {
-      return;
-    }
-
-    for (const type of types) {
-      if (!(type in this.documents)) {
-        this.documents[type] = {};
-      }
-
-      const newDocuments = newData[type];
-
-      for (const id in newDocuments) {
-        this.documents[type][id] = newDocuments[id];
-      }
-    }
-
-    this.update();
-  }
-}

package/src/RequestContext.js

@@ -1,155 +0,0 @@
-import SuperbiaContext from "./SuperbiaContext";
-
-export class RequestContext extends SuperbiaContext {
-  constructor(client, id) {
-    super(id);
-
-    this.requests = {};
-
-    this.client = client;
-  }
-
-  // default persistence
-
-  hydrate(requests) {
-    this.requests = requests;
-  }
-
-  persist() {
-    return this.requests;
-  }
-
-  getRequests() {
-    return this.requests;
-  }
-
-  intercept() {
-    return {};
-  }
-
-  parseRequestResult(result) {
-    if (
-      result !== null &&
-      typeof result === "object" &&
-      this.keys.typename in result &&
-      result[this.keys.typename].endsWith("Pagination")
-    ) {
-      return { loading: false, error: null, data: this.parseResult(result) };
-    } else {
-      return this.parseResult(result);
-    }
-  }
-
-  async request(key, endpoints, payload = null) {
-    key = key !== null && key !== undefined ? key : Date.now().toString();
-
-    this.requests[key] = {
-      loading: true,
-      done: false,
-      error: null,
-      data: null,
-    };
-
-    const interceptors = this.intercept();
-
-    const endpointKeys = Object.keys(endpoints);
-
-    for (const endpointKey of endpointKeys) {
-      if (endpointKey in interceptors && "load" in interceptors[endpointKey]) {
-        interceptors[endpointKey].load(key, endpoints, payload);
-      }
-    }
-
-    this.update();
-
-    try {
-      const response = await this.client.request(endpoints);
-
-      const data = response.data();
-
-      const newData = {};
-
-      for (const key in data) {
-        newData[key] = this.parseRequestResult(data[key]);
-      }
-
-      this.requests[key] = {
-        loading: false,
-        done: true,
-        error: null,
-        data: newData,
-      };
-
-      for (const endpointKey of endpointKeys) {
-        if (
-          endpointKey in interceptors &&
-          "data" in interceptors[endpointKey]
-        ) {
-          interceptors[endpointKey].data(key, endpoints, payload, data);
-        }
-      }
-
-      this.update();
-    } catch (error) {
-      this.requests[key] = { loading: false, done: false, error, data: null };
-
-      for (const endpointKey of endpointKeys) {
-        if (
-          endpointKey in interceptors &&
-          "error" in interceptors[endpointKey]
-        ) {
-          interceptors[endpointKey].error(key, endpoints, payload, error);
-        }
-      }
-
-      this.update();
-    }
-  }
-
-  async load(key, endpoints, payload = null) {
-    const interceptors = this.intercept();
-
-    const endpointKey = Object.keys(endpoints)[0];
-
-    const result = this.requests[key].data[endpointKey];
-
-    result.loading = true;
-    result.error = null;
-
-    if (endpointKey in interceptors && "load" in interceptors[endpointKey]) {
-      interceptors[endpointKey].load(key, endpoints, payload);
-    }
-
-    this.update();
-
-    try {
-      const response = await this.client.request(endpoints);
-
-      const data = response.data();
-
-      const endpointResult = this.parseResult(data[endpointKey]);
-
-      result.loading = false;
-
-      result.data = {
-        ...endpointResult,
-        nodes: [...result.data.nodes, ...endpointResult.nodes],
-      };
-
-      if (endpointKey in interceptors && "data" in interceptors[endpointKey]) {
-        interceptors[endpointKey].data(key, endpoints, payload, data);
-      }
-
-      this.update();
-    } catch (error) {
-      result.loading = false;
-      result.error = error;
-
-      if (endpointKey in interceptors && "error" in interceptors[endpointKey]) {
-        interceptors[endpointKey].error(key, endpoints, payload, error);
-      }
-
-      this.update();
-    }
-  }
-}

package/src/SuperbiaContext.js

@@ -1,48 +0,0 @@
-import { Context } from "untrue";
-
-class SuperbiaContext extends Context {
-  constructor(id = "id") {
-    super();
-
-    this.keys = { id, typename: "_typename" };
-  }
-
-  parseResult(result, data = {}) {
-    if (result === null) {
-      return null;
-    }
-
-    if (Array.isArray(result)) {
-      return result.map((element) => this.parseResult(element, data));
-    }
-
-    if (typeof result === "object") {
-      const newResult = {};
-
-      for (const key in result) {
-        newResult[key] = this.parseResult(result[key], data);
-      }
-
-      const isDocument = this.keys.id in result && this.keys.typename in result;
-
-      if (!isDocument) {
-        return newResult;
-      }
-
-      const id = result[this.keys.id];
-      const typename = result[this.keys.typename];
-
-      if (!(typename in data)) {
-        data[typename] = {};
-      }
-
-      data[typename][id] = newResult;
-
-      return result[this.keys.id];
-    }
-
-    return result;
-  }
-}
-
-export default SuperbiaContext;

package/src/SuperbiaUntrue.js

@@ -1,55 +0,0 @@
-import $, { Component, Hook } from "untrue";
-
-import { v4 as uuid } from "uuid";
-
-export default class SuperbiaUntrue {
-  static useRequestKey(requestKeyExtractor = null) {
-    return Hook.useMemo(() => {
-      let key = null;
-
-      if (requestKeyExtractor !== null) {
-        if (typeof requestKeyExtractor === "function") {
-          key = requestKeyExtractor();
-        } else {
-          key = requestKeyExtractor;
-        }
-      }
-
-      if (key === null) {
-        key = uuid();
-      }
-
-      return key;
-    });
-  }
-
-  static wrapRequester(Child, requestKeyExtractor = null) {
-    return class RequestComponent extends Component {
-      constructor(props) {
-        super(props);
-
-        let key = null;
-
-        if (requestKeyExtractor !== null) {
-          if (typeof requestKeyExtractor === "function") {
-            key = requestKeyExtractor(props);
-          } else {
-            key = requestKeyExtractor;
-          }
-        }
-
-        if (key === null) {
-          key = uuid();
-        }
-
-        this.requestKey = key;
-      }
-
-      render() {
-        const { children, ...props } = this.props;
-
-        return $(Child, { ...props, requestKey: this.requestKey }, children);
-      }
-    };
-  }
-}