@superbia/untrue 2.1.8 → 2.2.0

package/dist/Api.d.ts

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

package/dist/Api.js

@@ -5,7 +5,7 @@ const uuid_1 = require("uuid");
 const DocumentContext_1 = require("./DocumentContext");
 const RequestContext_1 = require("./RequestContext");
 class Api extends untrue_1.Context {
-    constructor(client, idKey = "id") {
+    constructor(client, idKey) {
         super();
         this.client = client;
         this.documents = new DocumentContext_1.DocumentContext(client, idKey);
@@ -85,8 +85,8 @@ class Api extends untrue_1.Context {
                 throw new Error('Request is in "error" state.');
             }
             const tmpResult = request.result;
-            let tmpPagination;
             let endpointName;
+            let tmpPagination;
             let rethrow = false;
             this.client.once("request", (endpoints) => {
                 const keys = Object.keys(endpoints);

package/dist/DocumentContext.d.ts

@@ -1,13 +1,15 @@
-import { Client, Result, ResponseResult, EndpointRecord } from "@superbia/client";
-import { ParsedResult, SuperbiaContext, DocumentSchema, DocumentSchemaRecord } from "./SuperbiaContext";
-export type Document<T extends DocumentSchema, O extends string = "id"> = {
-    [K in keyof T]: ParsedResult<T[K], O>;
+import { Client, Result, ResponseResult } from "@superbia/client";
+import { IdDocument, IdDocumentRecord, ParsedResult, SuperbiaContext } from "./SuperbiaContext";
+export type ApiDocument<O extends string, T extends IdDocument<O>> = {
+    [K in keyof T]: ParsedResult<O, T[K]>;
 };
-export type Documents<T extends DocumentSchemaRecord, O extends string = "id"> = Partial<{
-    [K in keyof T]: Record<string, Result<Document<T[K], O>>>;
+export type ApiDocuments<O extends string, T extends IdDocumentRecord<O>> = Partial<{
+    [K in keyof T]: Record<string, Result<ApiDocument<O, T[K]>>>;
 }>;
-export declare class DocumentContext<K extends DocumentSchemaRecord, M extends EndpointRecord, O extends string> extends SuperbiaContext {
-    data: Documents<K, O>;
-    constructor(client: Client<M, any>, idKey: string);
+export declare class DocumentContext<O extends string, K extends IdDocumentRecord<O>> extends SuperbiaContext {
+    data: ApiDocuments<O, K>;
+    private updateAfterResultLoop;
+    constructor(client: Client<any, any>, idKey: string);
     handleResult(result: ResponseResult): void;
+    private parseResultValue;
 }

package/dist/DocumentContext.js

@@ -6,6 +6,7 @@ class DocumentContext extends SuperbiaContext_1.SuperbiaContext {
     constructor(client, idKey) {
         super(idKey);
         this.data = {};
+        this.updateAfterResultLoop = false;
         const listener = (endpoints, emitter) => {
             emitter.on("result", (result) => {
                 this.handleResult(result);
@@ -15,25 +16,42 @@ class DocumentContext extends SuperbiaContext_1.SuperbiaContext {
         client.on("subscribe", listener);
     }
     handleResult(result) {
-        const data = {};
-        for (const tmpResult of Object.values(result)) {
-            this.parseResultValue(tmpResult, data);
+        const endpointResults = Object.values(result);
+        for (const endpointResult of endpointResults) {
+            this.parseResultValue(endpointResult);
         }
-        const types = Object.keys(data);
-        if (types.length === 0) {
-            return;
+        if (this.updateAfterResultLoop) {
+            this.update();
         }
-        const documents = this.data;
-        for (const type of types) {
-            if (!(type in documents)) {
-                documents[type] = {};
+        this.updateAfterResultLoop = false;
+    }
+    parseResultValue(value) {
+        if (value === null) {
+            return null;
+        }
+        if (Array.isArray(value)) {
+            return value.map((tmpValue) => this.parseResultValue(tmpValue));
+        }
+        if (typeof value === "object") {
+            const tmpValue = {};
+            for (const key in value) {
+                tmpValue[key] = this.parseResultValue(value[key]);
+            }
+            const isIdDocument = this.isIdDocument(value);
+            if (!isIdDocument) {
+                return tmpValue;
             }
-            const tmpDocuments = data[type];
-            for (const id in tmpDocuments) {
-                documents[type][id] = tmpDocuments[id];
+            const id = value[this.idKey];
+            const typename = value[this.typenameKey];
+            const documents = this.data;
+            if (!(typename in documents)) {
+                documents[typename] = {};
             }
+            documents[typename][id] = tmpValue;
+            this.updateAfterResultLoop = true;
+            return id;
         }
-        this.update();
+        return value;
     }
 }
 exports.DocumentContext = DocumentContext;

package/dist/RequestContext.d.ts

@@ -1,28 +1,29 @@
 import { Result, Pagination, EndpointRecord, ResponseResult } from "@superbia/client";
 import { ParsedResult, SuperbiaContext } from "./SuperbiaContext";
-export declare class PaginationResult<T extends Pagination<any>, O extends string = "id"> {
+export declare class PaginationResult<O extends string, T extends Pagination<any>> {
     loading: boolean;
-    result: ParsedResult<T, O>;
-    error: Error | null;
+    result: ParsedResult<O, T>;
+    error: any;
     constructor({ loading, result, error, }: {
         loading: boolean;
-        result: ParsedResult<T, O>;
-        error: Error | null;
+        result: ParsedResult<O, T>;
+        error: any;
     });
 }
-export type RequestResult<T extends ResponseResult, O extends string = "id"> = {
-    [K in keyof T]: T[K] extends Pagination<any> ? PaginationResult<T[K], O> : ParsedResult<T[K], O>;
+export type RequestResult<O extends string, T extends ResponseResult> = {
+    [K in keyof T]: T[K] extends Pagination<any> ? PaginationResult<O, T[K]> : ParsedResult<O, T[K]>;
 };
-export type Request<T extends ResponseResult> = {
+export type ApiRequest<T extends ResponseResult> = {
     loading: boolean;
     done: boolean;
     result: T | null;
-    error: Error | null;
+    error: any;
 };
-export type Requests<T extends EndpointRecord, O extends string = "id"> = Record<string, Request<Partial<RequestResult<{
+export type ApiRequests<O extends string, T extends EndpointRecord> = Record<string, ApiRequest<Partial<RequestResult<O, {
     [K in keyof T]: Result<T[K]["result"]>;
-}, O>>>>;
-export declare class RequestContext<M extends EndpointRecord, O extends string> extends SuperbiaContext {
-    data: Requests<M, O>;
+}>>>>;
+export declare class RequestContext<O extends string, M extends EndpointRecord> extends SuperbiaContext {
+    data: ApiRequests<O, M>;
     parseResult(result: ResponseResult): ResponseResult;
+    private parseResultValue;
 }

package/dist/RequestContext.js

@@ -23,7 +23,7 @@ class RequestContext extends SuperbiaContext_1.SuperbiaContext {
             if (endpointResult !== null &&
                 typeof endpointResult === "object" &&
                 this.typenameKey in endpointResult &&
-                endpointResult[this.typenameKey].endsWith("Pagination")) {
+                endpointResult[this.typenameKey] === "__pagination__") {
                 tmpEndpointResult = new PaginationResult({
                     loading: false,
                     result: this.parseResultValue(endpointResult),
@@ -37,5 +37,26 @@ class RequestContext extends SuperbiaContext_1.SuperbiaContext {
         }
         return tmpResult;
     }
+    parseResultValue(value) {
+        if (value === null) {
+            return null;
+        }
+        if (Array.isArray(value)) {
+            return value.map((tmpValue) => this.parseResultValue(tmpValue));
+        }
+        if (typeof value === "object") {
+            const isIdDocument = this.isIdDocument(value);
+            if (isIdDocument) {
+                const id = value[this.idKey];
+                return id;
+            }
+            const tmpValue = {};
+            for (const key in value) {
+                tmpValue[key] = this.parseResultValue(value[key]);
+            }
+            return tmpValue;
+        }
+        return value;
+    }
 }
 exports.RequestContext = RequestContext;

package/dist/SuperbiaContext.d.ts

@@ -1,17 +1,15 @@
 import { Context } from "untrue";
-type IdObject<O extends string> = {
+import { Document } from "@superbia/client";
+export type IdDocument<O extends string> = Document & {
     [K in O]: string;
 };
-export type ParsedResult<T, O extends string = "id"> = T extends string | number | boolean | null ? T : T extends IdObject<O> ? string : {
-    [K in keyof T]: ParsedResult<T[K], O>;
+export type IdDocumentRecord<O extends string> = Record<string, IdDocument<O>>;
+export type ParsedResult<O extends string, T> = T extends string | number | boolean | null ? T : T extends IdDocument<O> ? string : {
+    [K in keyof T]: ParsedResult<O, T[K]>;
 };
-export type DocumentSchema = Record<string, any>;
-export type DocumentSchemaRecord = Record<string, DocumentSchema>;
-export type DocumentData = Record<string, Record<string, DocumentSchema>>;
 export declare class SuperbiaContext extends Context {
     protected idKey: string;
     protected typenameKey: string;
     constructor(idKey: string);
-    parseResultValue(result: any, data?: DocumentData): any;
+    protected isIdDocument(value: Record<string, any>): boolean;
 }
-export {};

package/dist/SuperbiaContext.js

@@ -6,33 +6,13 @@ class SuperbiaContext extends untrue_1.Context {
     constructor(idKey) {
         super();
         this.idKey = idKey;
-        this.typenameKey = "_typename";
+        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 tmpResult = {};
-            for (const key in result) {
-                tmpResult[key] = this.parseResultValue(result[key], data);
-            }
-            const isDocument = this.idKey in result && this.typenameKey in result;
-            if (!isDocument) {
-                return tmpResult;
-            }
-            const id = result[this.idKey];
-            const typename = result[this.typenameKey];
-            if (!(typename in data)) {
-                data[typename] = {};
-            }
-            data[typename][id] = tmpResult;
-            return result[this.idKey];
-        }
-        return result;
+    isIdDocument(value) {
+        return (this.idKey in value &&
+            this.typenameKey in value &&
+            typeof value[this.idKey] === "string" &&
+            typeof value[this.typenameKey] === "string");
     }
 }
 exports.SuperbiaContext = SuperbiaContext;

package/dist/index.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superbia/untrue",
-  "version": "2.1.8",
+  "version": "2.2.0",
   "description": "Integrate Superbia and Untrue.",
   "repository": {
     "type": "git",
@@ -18,7 +18,7 @@
   ],
   "license": "MIT",
   "peerDependencies": {
-    "@superbia/client": "^2.1.3",
+    "@superbia/client": "^2.2.2",
     "untrue": "^5.15.2"
   },
   "dependencies": {