@ventlio/tanstack-query 0.2.63-beta.6.2 → 0.2.63-beta.7

package/dist/index.mjs

@@ -139,7 +139,7 @@ class QueryModel {
         }
         return updatedRecord;
     }
-    delete(id, path) {
+    remove(id, path) {
         const oldData = this.findAll(path) ?? [];
         const modelConfig = this.getModelConfig();
         if (!modelConfig?.idColumn) {
@@ -187,11 +187,88 @@ const useKeyTrackerModel = (keyTracker) => {
     return { refetchQuery, getQueryKey };
 };
 
-const useQueryModel = (keyTracker) => {
+const useQueryModel = (keyTracker, exact = true) => {
     const queryClient = useQueryClient();
     const { getQueryKey } = useKeyTrackerModel(keyTracker);
     const queryKey = getQueryKey();
-    return new QueryModel(queryKey, queryClient);
+    const findAll = (path) => {
+        const data = queryClient.getQueryData(queryKey, { exact });
+        if (!data) {
+            return [];
+        }
+        if (!path) {
+            return Array.isArray(data) ? data : [data];
+        }
+        return result(data, path, []);
+    };
+    const findMany = (selector, path) => {
+        const data = findAll(path) ?? [];
+        return data.filter(selector);
+    };
+    const find = (id, path) => {
+        const modelConfig = getModelConfig();
+        if (!modelConfig?.idColumn) {
+            return undefined;
+        }
+        const data = findAll(path) ?? [];
+        return data.find((record) => record[modelConfig.idColumn] === id);
+    };
+    const getModelConfig = () => {
+        const { options } = queryClient.getQueryData(['config']) ?? {};
+        const { modelConfig } = options ?? {};
+        return modelConfig;
+    };
+    const update = (id, data, path) => {
+        const oldData = findAll(path) ?? [];
+        const modelConfig = getModelConfig();
+        if (!modelConfig?.idColumn) {
+            return undefined;
+        }
+        const idColumn = modelConfig.idColumn;
+        let updatedRecord = undefined;
+        const newData = oldData.map((record) => {
+            let dataRecord = record;
+            if (dataRecord[idColumn] === id) {
+                dataRecord = { ...dataRecord, ...data };
+                updatedRecord = dataRecord;
+            }
+            return dataRecord;
+        });
+        if (!path) {
+            queryClient.setQueryData(queryKey, newData);
+        }
+        else {
+            const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
+            queryClient.setQueryData(queryKey, set(queryData, path, newData));
+        }
+        return updatedRecord;
+    };
+    const remove = (id, path) => {
+        const oldData = findAll(path) ?? [];
+        const modelConfig = getModelConfig();
+        if (!modelConfig?.idColumn) {
+            return false;
+        }
+        const idColumn = modelConfig.idColumn;
+        let updated = false;
+        const newData = oldData.filter((record) => {
+            const dataRecord = record;
+            if (dataRecord[idColumn] === id) {
+                updated = true;
+                return false;
+            }
+            return true;
+        });
+        if (!path) {
+            queryClient.setQueryData(queryKey, newData);
+        }
+        else {
+            const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
+            queryClient.setQueryData(queryKey, set(queryData, path, newData));
+        }
+        return updated;
+    };
+    return { find, findAll, findMany, remove, update };
 };
 
 const useRefetchQuery = async (queryKey) => {

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/model/Model.d.ts

@@ -9,6 +9,6 @@ export declare class QueryModel<T> implements QueryModelBuilder<T> {
     findMany(selector: (record: T) => boolean, path?: string): T[];
     find(id: string | number, path?: string): T | undefined;
     update(id: string | number, data: Partial<T>, path?: string): T | undefined;
-    delete(id: number | string, path?: string): boolean;
+    remove(id: number | string, path?: string): boolean;
     private getModelConfig;
 }

package/dist/model/Model.js

@@ -57,7 +57,7 @@ class QueryModel {
         }
         return updatedRecord;
     }
-    delete(id, path) {
+    remove(id, path) {
         const oldData = this.findAll(path) ?? [];
         const modelConfig = this.getModelConfig();
         if (!modelConfig?.idColumn) {

package/dist/model/model.interface.d.ts

@@ -3,5 +3,5 @@ export interface QueryModelBuilder<T> {
     findMany: (selector: (record: T) => boolean, path?: string) => T[];
     find: (id: number | string, path?: string) => T | undefined;
     update: (id: number | string, data: Partial<T>, path?: string) => T | undefined;
-    delete: (id: number, path?: string) => boolean;
+    remove: (id: number, path?: string) => boolean;
 }

package/dist/model/useQueryModel.d.ts

@@ -1,2 +1,2 @@
-import { QueryModel } from './Model';
-export declare const useQueryModel: <T>(keyTracker: string) => QueryModel<T>;
+import type { QueryModelBuilder } from './model.interface';
+export declare const useQueryModel: <T>(keyTracker: string, exact?: boolean) => QueryModelBuilder<T>;

package/dist/model/useQueryModel.js

@@ -1,12 +1,90 @@
 import { useQueryClient } from '@tanstack/react-query';
-import { QueryModel } from './Model.js';
+import result from 'lodash.result';
+import set from 'lodash.set';
 import { useKeyTrackerModel } from './useKeyTrackerModel.js';
 
-const useQueryModel = (keyTracker) => {
+const useQueryModel = (keyTracker, exact = true) => {
     const queryClient = useQueryClient();
     const { getQueryKey } = useKeyTrackerModel(keyTracker);
     const queryKey = getQueryKey();
-    return new QueryModel(queryKey, queryClient);
+    const findAll = (path) => {
+        const data = queryClient.getQueryData(queryKey, { exact });
+        if (!data) {
+            return [];
+        }
+        if (!path) {
+            return Array.isArray(data) ? data : [data];
+        }
+        return result(data, path, []);
+    };
+    const findMany = (selector, path) => {
+        const data = findAll(path) ?? [];
+        return data.filter(selector);
+    };
+    const find = (id, path) => {
+        const modelConfig = getModelConfig();
+        if (!modelConfig?.idColumn) {
+            return undefined;
+        }
+        const data = findAll(path) ?? [];
+        return data.find((record) => record[modelConfig.idColumn] === id);
+    };
+    const getModelConfig = () => {
+        const { options } = queryClient.getQueryData(['config']) ?? {};
+        const { modelConfig } = options ?? {};
+        return modelConfig;
+    };
+    const update = (id, data, path) => {
+        const oldData = findAll(path) ?? [];
+        const modelConfig = getModelConfig();
+        if (!modelConfig?.idColumn) {
+            return undefined;
+        }
+        const idColumn = modelConfig.idColumn;
+        let updatedRecord = undefined;
+        const newData = oldData.map((record) => {
+            let dataRecord = record;
+            if (dataRecord[idColumn] === id) {
+                dataRecord = { ...dataRecord, ...data };
+                updatedRecord = dataRecord;
+            }
+            return dataRecord;
+        });
+        if (!path) {
+            queryClient.setQueryData(queryKey, newData);
+        }
+        else {
+            const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
+            queryClient.setQueryData(queryKey, set(queryData, path, newData));
+        }
+        return updatedRecord;
+    };
+    const remove = (id, path) => {
+        const oldData = findAll(path) ?? [];
+        const modelConfig = getModelConfig();
+        if (!modelConfig?.idColumn) {
+            return false;
+        }
+        const idColumn = modelConfig.idColumn;
+        let updated = false;
+        const newData = oldData.filter((record) => {
+            const dataRecord = record;
+            if (dataRecord[idColumn] === id) {
+                updated = true;
+                return false;
+            }
+            return true;
+        });
+        if (!path) {
+            queryClient.setQueryData(queryKey, newData);
+        }
+        else {
+            const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
+            queryClient.setQueryData(queryKey, set(queryData, path, newData));
+        }
+        return updated;
+    };
+    return { find, findAll, findMany, remove, update };
 };
 
 export { useQueryModel };

package/dist/model/useQueryModel.js.map

@@ -1 +1 @@
-{"version":3,"file":"useQueryModel.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;"}
+{"version":3,"file":"useQueryModel.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ventlio/tanstack-query",
-  "version": "0.2.63-beta.6.2",
+  "version": "0.2.63-beta.7",
   "license": "MIT",
   "main": "dist/index.js",
   "contributors": [

package/src/model/Model.ts

@@ -71,7 +71,7 @@ export class QueryModel<T> implements QueryModelBuilder<T> {
     return updatedRecord;
   }
 
-  delete(id: number | string, path?: string): boolean {
+  remove(id: number | string, path?: string): boolean {
     const oldData = this.findAll(path) ?? [];
     const modelConfig = this.getModelConfig();
 

package/src/model/model.interface.ts

@@ -3,5 +3,5 @@ export interface QueryModelBuilder<T> {
   findMany: (selector: (record: T) => boolean, path?: string) => T[];
   find: (id: number | string, path?: string) => T | undefined;
   update: (id: number | string, data: Partial<T>, path?: string) => T | undefined;
-  delete: (id: number, path?: string) => boolean;
+  remove: (id: number, path?: string) => boolean;
 }

package/src/model/useQueryModel.ts

@@ -1,10 +1,108 @@
 import { useQueryClient } from '@tanstack/react-query';
-import { QueryModel } from './Model';
+import result from 'lodash.result';
+import set from 'lodash.set';
+import type { TanstackQueryConfig } from '../types';
+import type { QueryModelBuilder } from './model.interface';
 import { useKeyTrackerModel } from './useKeyTrackerModel';
 
-export const useQueryModel = <T>(keyTracker: string): QueryModel<T> => {
+export const useQueryModel = <T>(keyTracker: string, exact: boolean = true): QueryModelBuilder<T> => {
   const queryClient = useQueryClient();
   const { getQueryKey } = useKeyTrackerModel(keyTracker);
   const queryKey = getQueryKey() as any[];
-  return new QueryModel<T>(queryKey, queryClient);
+
+  const findAll = (path?: string): T[] | undefined => {
+    const data = queryClient.getQueryData(queryKey, { exact });
+
+    if (!data) {
+      return [];
+    }
+
+    if (!path) {
+      return Array.isArray(data) ? data : [data];
+    }
+
+    return result<T[]>(data, path, []);
+  };
+
+  const findMany = (selector: (record: T) => boolean, path?: string): T[] => {
+    const data = findAll(path) ?? [];
+    return data.filter(selector);
+  };
+
+  const find = (id: string | number, path?: string): T | undefined => {
+    const modelConfig = getModelConfig();
+
+    if (!modelConfig?.idColumn) {
+      return undefined;
+    }
+    const data = findAll(path) ?? [];
+
+    return data.find((record) => (record as Record<string, any>)[modelConfig.idColumn] === id);
+  };
+
+  const getModelConfig = () => {
+    const { options } = queryClient.getQueryData<TanstackQueryConfig>(['config']) ?? {};
+    const { modelConfig } = options ?? {};
+
+    return modelConfig;
+  };
+
+  const update = (id: string | number, data: Partial<T>, path?: string): T | undefined => {
+    const oldData = findAll(path) ?? [];
+    const modelConfig = getModelConfig();
+
+    if (!modelConfig?.idColumn) {
+      return undefined;
+    }
+    const idColumn = modelConfig.idColumn;
+
+    let updatedRecord: T | undefined = undefined;
+    const newData = oldData.map((record) => {
+      let dataRecord = record as Record<string, any>;
+
+      if (dataRecord[idColumn] === id) {
+        dataRecord = { ...dataRecord, ...data };
+        updatedRecord = dataRecord as T;
+      }
+
+      return dataRecord;
+    });
+
+    if (!path) {
+      queryClient.setQueryData(queryKey, newData);
+    } else {
+      const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
+      queryClient.setQueryData(queryKey, set(queryData, path, newData));
+    }
+    return updatedRecord;
+  };
+
+  const remove = (id: number | string, path?: string): boolean => {
+    const oldData = findAll(path) ?? [];
+    const modelConfig = getModelConfig();
+
+    if (!modelConfig?.idColumn) {
+      return false;
+    }
+    const idColumn = modelConfig.idColumn;
+    let updated = false;
+    const newData = oldData.filter((record) => {
+      const dataRecord = record as Record<string, any>;
+      if (dataRecord[idColumn] === id) {
+        updated = true;
+        return false;
+      }
+      return true;
+    });
+
+    if (!path) {
+      queryClient.setQueryData(queryKey, newData);
+    } else {
+      const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
+      queryClient.setQueryData(queryKey, set(queryData, path, newData));
+    }
+    return updated;
+  };
+
+  return { find, findAll, findMany, remove, update };
 };