drf-react-by-schema 0.1.0 → 0.2.1

package/src/api.ts

@@ -1,74 +1,83 @@
 import axios, { AxiosError, AxiosResponse } from 'axios';
+import { ServerResponse } from 'http';
+import { string } from 'yup';
+import { serverEndPointType } from './context/DRFReactBySchemaProvider';
 import {
     isTmpId,
     emptyByType,
     getChoiceByValue,
     Field,
     Item,
-    Schema
+    SchemaType,
+    GridEnrichedBySchemaColDef
 } from './utils';
 
 const moment = require('moment');
 
 type Id = string | number | null;
+
+/**
+ * Interface for CRUD on API
+ *
+ * @interface TargetApiParams
+ */
 interface TargetApiParams {
-    path:string,
-    data:Item,
-    id:Id
+    path:string;
+    serverEndPoint:serverEndPointType | null;
+    data:Item;
+    id:Id;
 };
 interface TargetApiParamsOptionalId {
-    path:string,
-    data:Item,
-    id?:Id
-};
-interface Constants {
-    API: Record<string, string>
+    path:string;
+    serverEndPoint:serverEndPointType | null;
+    data:Item;
+    id?:Id;
 };
-const CONSTANTS:Constants = {
-    API: {
-        api: '',
-        JSONSchema: '',
-        getToken: ''
+const getOptions = async (path:string, serverEndPoint:serverEndPointType | null) => {
+    if (!serverEndPoint) {
+        console.log('Não há definição de API (serverEndPoint!');
+        return false;
     }
-};
-const getOptions = async (path:string) => {
-    const url = `${CONSTANTS.API.api}/${path}`;
+    const url = `${serverEndPoint.api}/${path}`;
     try {
         const { data } = await axios.options(url);
         return data;
     } catch (e) {
-        if (e instanceof AxiosError && e.response?.status === 401) {
-            const isRefreshed = await refreshToken();
-            if (!isRefreshed) {
-                console.log('Token expirou! Deve-se fazer login de novo');
-                return false;
-            }
-            try {
-                const { data } = await axios.options(url);
-                return data;
-            } catch (e) {
-                console.log(`Error fetching options from ${url}`, e);
-                return false;
+        if ((<any>e).isAxiosError) {
+            const err = <AxiosError>e;
+            if (err.response?.status === 401) {
+                const isRefreshed = await refreshToken(serverEndPoint);
+                if (!isRefreshed) {
+                    console.log('Token expirou! Deve-se fazer login de novo');
+                    return false;
+                }
+                try {
+                    const { data } = await axios.options(url);
+                    return data;
+                } catch (e) {
+                    console.log(`Error fetching options from ${url}`, e);
+                    return false;
+                }
             }
+            console.log(`Error fetching options from ${url}`, e);
+            return false;
         }
-        console.log(`Error fetching options from ${url}`, e);
-        return false;
     }
 };
 
-const getSchema = async (path:string) => {
-    const options = await getOptions(path);
+const getSchema = async (path:string, serverEndPoint:serverEndPointType | null) => {
+    const options = await getOptions(path, serverEndPoint);
     if (!options || !options.actions || !options.actions.POST) {
         return false;
     }
 
     // Special default value of "currentUser":
-    let usuaria;
+    let usuaria:Item | boolean = false;
     const postActions:Record<string, Field> = options.actions.POST;
     for (const [key, field] of Object.entries(postActions)) {
         if (field.model_default === 'currentUser') {
             if (!usuaria) {
-                usuaria = await isLoggedIn();
+                usuaria = await isLoggedIn(serverEndPoint);
             }
             if (usuaria) {
                 options.actions.POST[key].model_default = {
@@ -79,30 +88,37 @@ const getSchema = async (path:string) => {
         }
     }
 
-    return options.actions.POST;
+    return options.actions.POST as SchemaType;
 };
 
 const getData = async (
     path:string,
+    serverEndPoint:serverEndPointType | null,
     route:string = 'api'
 ) => {
-    const url = `${CONSTANTS.API[route]}/${path}`;
+    if (!serverEndPoint) {
+        return false;
+    }
+    const url = `${serverEndPoint[route as keyof serverEndPointType]}/${path}`;
     try {
         const { data } = await axios.get(url);
-        return data;
+        return data as Item[];
     } catch (e) {
-        if (e instanceof AxiosError && e.response?.status === 401) {
-            const isRefreshed = await refreshToken();
-            if (!isRefreshed) {
-                console.log('Token expirou! Deve-se fazer login de novo');
-                return false;
-            }
-            try {
-                const { data } = await axios.get(url);
-                return data;
-            } catch (e) {
-                console.log(`Error fetching data from ${url}`, e);
-                return false;
+        if ((<any>e).isAxiosError) {
+            const err = <AxiosError>e;
+            if (err.response?.status === 401) {
+                const isRefreshed = await refreshToken(serverEndPoint);
+                if (!isRefreshed) {
+                    console.log('Token expirou! Deve-se fazer login de novo');
+                    return false;
+                }
+                try {
+                    const { data } = await axios.get(url);
+                    return data as Item[];
+                } catch (e) {
+                    console.log(`Error fetching data from ${url} after token refresh`, e);
+                    return false;
+                }
             }
         }
         console.log(`Error fetching data from ${url}`, e);
@@ -110,125 +126,152 @@ const getData = async (
     }
 };
 
-export const updateData = async ({ path, data, id }: TargetApiParams) => {
-    const url = `${CONSTANTS.API.api}/${path}/${id}/`;
+/**
+ * 
+ * @param param0 
+ * @returns Id when succesfully updated, false otherwise
+ */
+export const updateData = async ({ path, serverEndPoint, data, id }: TargetApiParams) => {
+    if (!serverEndPoint) {
+        return ({ errors: 'Não há definição de API (serverEndPoint!' } as unknown) as AxiosResponse;
+    }
+    const url = `${serverEndPoint.api}/${path}/${id}/`;
     try {
         await axios.put(url, data);
         return id;
     } catch (e) {
-        if (e instanceof AxiosError && e.response?.status === 401) {
-            const isRefreshed = await refreshToken();
-            if (!isRefreshed) {
-                console.log('Token expirou! Deve-se fazer login de novo');
-                return false;
-            }
-            try {
-                await axios.put(url, data);
-                return true;
-            } catch (e) {
-                console.log(`Error updating data at ${url}`, data, e);
-                return false;
+        if ((<any>e).isAxiosError) {
+            const err = <AxiosError>e;
+            if (err.response?.status === 401) {
+                const isRefreshed = await refreshToken(serverEndPoint);
+                if (!isRefreshed) {
+                    console.log('Token expirou! Deve-se fazer login de novo');
+                    return false;
+                }
+                try {
+                    await axios.put(url, data);
+                    return true;
+                } catch (e) {
+                    console.log(`Error updating data at ${url}`, data, e);
+                    return false;
+                }
             }
+            console.log(`Error updating data at ${url}`, data, err.response?.data);
+            return ({ errors: err.response?.data } as unknown) as AxiosResponse;
         }
-        const err = e as AxiosError;
-        console.log(`Error updating data at ${url}`, data, err.response?.data);
-        return ({ errors: err.response?.data } as unknown) as AxiosResponse;
     }
 };
 
-export const partialUpdateData = async ({ path, data, id }: TargetApiParams) => {
-    const url = `${CONSTANTS.API.api}/${path}/${id}/`;
+export const partialUpdateData = async ({ path, serverEndPoint, data, id }: TargetApiParams) => {
+    if (!serverEndPoint) {
+        return ({ errors: 'Não há definição de API (serverEndPoint!' } as unknown) as AxiosResponse;
+    }
+    const url = `${serverEndPoint.api}/${path}/${id}/`;
     try {
         await axios.patch(url, data);
         // DEBUG console.log({ path, data, id });
         return id;
     } catch (e) {
-        if (e instanceof AxiosError && e.response?.status === 401) {
-            const isRefreshed = await refreshToken();
-            if (!isRefreshed) {
-                console.log('Token expirou! Deve-se fazer login de novo');
-                return false;
-            }
-            try {
-                await axios.patch(url, data);
-                return true;
-            } catch (e) {
-                console.log(`Error partial updating data at ${url}`, data, e);
-                return false;
+        if ((<any>e).isAxiosError) {
+            const err = <AxiosError>e;
+            if (err.response?.status === 401) {
+                const isRefreshed = await refreshToken(serverEndPoint);
+                if (!isRefreshed) {
+                    console.log('Token expirou! Deve-se fazer login de novo');
+                    return false;
+                }
+                try {
+                    await axios.patch(url, data);
+                    return true;
+                } catch (e) {
+                    console.log(`Error partial updating data at ${url}`, data, e);
+                    return false;
+                }
             }
+            console.log(`Error partial updating data at ${url}`, data, err.response?.data);
+            return ({ errors: err.response?.data } as unknown) as AxiosResponse;
         }
-        const err = e as AxiosError;
-        console.log(`Error partial updating data at ${url}`, data, err.response?.data);
-        return ({ errors: err.response?.data } as unknown) as AxiosResponse;
     }
 };
 
-export const createData = async ({ path, data }: Omit<TargetApiParams, 'id'>) => {
-    const url = `${CONSTANTS.API.api}/${path}/`;
+export const createData = async ({ path, serverEndPoint, data }: Omit<TargetApiParams, 'id'>) => {
+    if (!serverEndPoint) {
+        return ({ errors: 'Não há definição de API (serverEndPoint!' } as unknown) as AxiosResponse;
+    }
+    const url = `${serverEndPoint.api}/${path}/`;
     try {
         const ret = await axios.post(url, data);
         return ret;
     } catch (e) {
-        if (e instanceof AxiosError && e.response?.status === 401) {
-            const isRefreshed = await refreshToken();
-            if (!isRefreshed) {
-                console.log('Token expirou! Deve-se fazer login de novo');
-                return false;
-            }
-            try {
-                const ret = await axios.post(url, data);
-                return ret;
-            } catch (e) {
-                console.log(`Error creating data at ${url}`, data, e);
-                return false;
+        if ((<any>e).isAxiosError) {
+            const err = <AxiosError>e;
+            if (err.response?.status === 401) {
+                const isRefreshed = await refreshToken(serverEndPoint);
+                if (!isRefreshed) {
+                    console.log('Token expirou! Deve-se fazer login de novo');
+                    return false;
+                }
+                try {
+                    const ret = await axios.post(url, data);
+                    return ret;
+                } catch (e) {
+                    console.log(`Error creating data at ${url}`, data, e);
+                    return false;
+                }
             }
+            console.log(`Error creating data at ${url}`, data, err.response?.data);
+            return ({ errors: err.response?.data } as unknown) as AxiosResponse;
         }
-        const err = e as AxiosError;
-        console.log(`Error creating data at ${url}`, data, err.response?.data);
-        return ({ errors: err.response?.data } as unknown) as AxiosResponse;
     }
 };
 
-export const deleteData = async (path:string, id:Id) => {
-    const url = `${CONSTANTS.API.api}/${path}/${id}`;
+export const deleteData = async (path:string, serverEndPoint:serverEndPointType | null, id:Id) => {
+    if (!serverEndPoint) {
+        console.log ('Não há definição de API (serverEndPoint!');
+        return false;
+    }
+    const url = `${serverEndPoint.api}/${path}/${id}`;
     try {
         await axios.delete(url);
         return true;
     } catch (e) {
-        if (e instanceof AxiosError && e.response?.status === 401) {
-            const isRefreshed = await refreshToken();
-            if (!isRefreshed) {
-                console.log('Token expirou! Deve-se fazer login de novo');
-                return false;
-            }
-            try {
-                await axios.delete(url);
-                return true;
-            } catch (e) {
-                console.log(`Error deleting data from ${url}`, e);
-                return false;
+        if ((<any>e).isAxiosError) {
+            const err = <AxiosError>e;
+            if (err.response?.status === 401) {
+                const isRefreshed = await refreshToken(serverEndPoint);
+                if (!isRefreshed) {
+                    console.log('Token expirou! Deve-se fazer login de novo');
+                    return false;
+                }
+                try {
+                    await axios.delete(url);
+                    return true;
+                } catch (e) {
+                    console.log(`Error deleting data from ${url}`, e);
+                    return false;
+                }
             }
+            console.log(`Error deleting data from ${url}`, e);
+            return false;
         }
-        console.log(`Error deleting data from ${url}`, e);
-        return false;
     }
 };
 
-export const createOrUpdateData = async ({ path, data, id }: TargetApiParamsOptionalId) => {
+export const createOrUpdateData = async ({ path, serverEndPoint, data, id }: TargetApiParamsOptionalId) => {
     if (isTmpId(id)) {
         id = null;
     }
     if (id) {
-        const responseUpdate = await updateData({ path, data, id });
+        const responseUpdate = await updateData({ path, serverEndPoint, data, id });
         return responseUpdate;
     }
 
-    const responseCreate = await createData({ path, data });
+    const responseCreate = await createData({ path, serverEndPoint, data });
     if (!responseCreate || Object.prototype.hasOwnProperty.call(responseCreate, 'errors')) {
         return responseCreate;
     }
 
-    const responseUpdate = await updateData({ path, data, id: responseCreate.data.id });
+    const responseUpdate = await updateData({ path, serverEndPoint, data, id: responseCreate.data.id });
     return responseUpdate;
 };
 
@@ -238,7 +281,7 @@ const prepareDataBySchema = ({
     parentIsField = false
 }: {
     data:Item,
-    schema:Schema,
+    schema:SchemaType,
     parentIsField?:boolean
 }) => {
     // console.log('Entered prepareDataBySchema', schema);
@@ -288,14 +331,14 @@ const prepareDataBySchema = ({
 
         // Date:
         if (field.type === 'date') {
-            const date = moment.moment(data[key]);
+            const date = moment(data[key]);
             dbData[key] = date.format('YYYY-MM-DD');
             continue;
         }
 
         // DateTime:
         if (field.type === 'datetime') {
-            const date = moment.moment(data[key]);
+            const date = moment(data[key]);
             dbData[key] = date.format('YYYY-MM-DDTHH:mm');
             continue;
         }
@@ -309,14 +352,16 @@ const prepareDataBySchema = ({
 export const updateDataBySchema = async ({
     model,
     modelObjectId,
+    serverEndPoint,
     data,
     schema,
     path = null
 }: {
     model:string,
     modelObjectId:Id,
+    serverEndPoint:serverEndPointType | null,
     data:Item,
-    schema:Schema,
+    schema:SchemaType,
     path:string | null
 }) => {
     // console.log({
@@ -333,6 +378,7 @@ export const updateDataBySchema = async ({
     // DEBUG console.log({ model, modelObjectId, path, data, dbData });
     const response = await createOrUpdateData({
         path,
+        serverEndPoint,
         data: dbData,
         id: modelObjectId
     });
@@ -347,20 +393,22 @@ export const updateDataBySchema = async ({
 
 export const addExistingRelatedModel = async ({
     model,
+    serverEndPoint,
     id,
     data
 }: {
     model:string,
+    serverEndPoint:serverEndPointType | null,
     id:Id,
     data:Item
 }) => {
-    const response = await partialUpdateData({ path: model, data, id });
+    const response = await partialUpdateData({ path: model, serverEndPoint, data, id });
     // DEBUG console.log({ model, id, data, response });
     return response;
 };
 
 const getDataGridColumns = (
-    schema:Schema,
+    schema:SchemaType,
     columnFields:string[] = [],
     hiddenFields:string[] = [],
     creatableFields:string[] = []
@@ -386,57 +434,72 @@ const getDataGridColumns = (
     });
 };
 
-export const getAutoComplete = async (model:string) => {
-    const data = await getData(model, 'autocomplete');
-    return data;
-};
-
-export const getAssessoriaRelatedObjects = async (id:Id) => {
-    const data = await getData(`assessoria/${id}/related_objects/`);
+export const getAutoComplete = async ({
+    model,
+    serverEndPoint
+}: {
+    model: string,
+    serverEndPoint:serverEndPointType | null
+}) => {
+    const data = await getData(model, serverEndPoint, 'autocomplete');
     return data;
 };
 
 export const getJSONSchema = async ({
     model,
+    serverEndPoint,
     id = 'create'
 }: {
     model:string,
+    serverEndPoint:serverEndPointType | null,
     id?:Id
 }) => {
-    const url = `${CONSTANTS.API.JSONSchema}/${model}/${id}/`;
+    if (!serverEndPoint) {
+        console.log('Não há definição de API (serverEndPoint!');
+        return false;
+    }
+    const url = `${serverEndPoint.JSONSchema}/${model}/${id}/`;
     try {
         const { data } = await axios.get(url);
         return data;
     } catch (e) {
-        if (e instanceof AxiosError && e.response?.status === 401) {
-            const isRefreshed = await refreshToken();
-            if (!isRefreshed) {
-                console.log('Token expirou! Deve-se fazer login de novo');
-                return false;
-            }
-            try {
-                const { data } = await axios.get(url);
-                return data;
-            } catch (e) {
-                console.log(`Error fetching JSONSchema data from ${url}`, e);
-                return false;
+        if ((<any>e).isAxiosError) {
+            const err = <AxiosError>e;
+            if (err.response?.status === 401) {
+                const isRefreshed = await refreshToken(serverEndPoint);
+                if (!isRefreshed) {
+                    console.log('Token expirou! Deve-se fazer login de novo');
+                    return false;
+                }
+                try {
+                    const { data } = await axios.get(url);
+                    return data;
+                } catch (e) {
+                    console.log(`Error fetching JSONSchema data from ${url}`, e);
+                    return false;
+                }
             }
+            console.log(`Error fetching JSONSchema data from ${url}`, e);
+            return false;
         }
-        console.log(`Error fetching JSONSchema data from ${url}`, e);
-        return false;
     }
 };
 
 export const createOrUpdateJSONSchema = async ({
     model,
+    serverEndPoint,
     id = 'create',
     formData
 }: {
     model:string,
+    serverEndPoint:serverEndPointType | null,
     id?:Id,
     formData:Item
 }) => {
-    let url = `${CONSTANTS.API.JSONSchema}/${model}/`;
+    if (!serverEndPoint) {
+        return { errors: 'Não há definição de API (serverEndPoint!' };
+    }
+    let url = `${serverEndPoint.JSONSchema}/${model}/`;
     if (id !== 'create') {
         url += `${id}/`;
     }
@@ -446,29 +509,40 @@ export const createOrUpdateJSONSchema = async ({
             : await axios.patch(url, formData);
         return data;
     } catch (e) {
-        if (e instanceof AxiosError && e.response?.status === 401) {
-            const isRefreshed = await refreshToken();
-            if (!isRefreshed) {
-                console.log('Token expirou! Deve-se fazer login de novo');
-                return { errors: 'Token expirou! Deve-se fazer login de novo!' };
-            }
-            try {
-                const { data } = (id === 'create')
-                    ? await axios.post(url, formData)
-                    : await axios.patch(url, formData);
-                return data;
-            } catch (e) {
-                console.log(`Error partially updating or creating JSONSchema data from ${url}`, e);
-                return { errors: 'Erro ao salvar alterações em item!' };
+        if ((<any>e).isAxiosError) {
+            const err = <AxiosError>e;
+            if (err.response?.status === 401) {
+                const isRefreshed = await refreshToken(serverEndPoint);
+                if (!isRefreshed) {
+                    console.log('Token expirou! Deve-se fazer login de novo');
+                    return { errors: 'Token expirou! Deve-se fazer login de novo!' };
+                }
+                try {
+                    const { data } = (id === 'create')
+                        ? await axios.post(url, formData)
+                        : await axios.patch(url, formData);
+                    return data;
+                } catch (e) {
+                    console.log(`Error partially updating or creating JSONSchema data from ${url}`, e);
+                    return { errors: 'Erro ao salvar alterações em item!' };
+                }
             }
+            console.log(`Error partially updating or creating JSONSchema data from ${url}`, e);
+            return { errors: 'Erro ao salvar alterações em item!' };
         }
-        console.log(`Error partially updating or creating JSONSchema data from ${url}`, e);
-        return { errors: 'Erro ao salvar alterações em item!' };
     }
 };
 
-export const loginByPayload = async (payload:Item) => {
-    const url = CONSTANTS.API.getToken;
+export const loginByPayload = async (payload:Item, serverEndPoint:serverEndPointType | null) => {
+    if (!serverEndPoint) {
+        console.log('Não há definição de API (serverEndPoint!');
+        return false;
+    }
+    const url = serverEndPoint.getToken;
+    if (!url) {
+        console.log('Erro no loginByPayload: faltou a configuração de url getToken!');
+        return false;
+    }
     try {
         const { data } = await axios.post(url, payload);
         localStorage.setItem('refreshToken', data.refresh);
@@ -492,7 +566,11 @@ export const setAuthToken = (token:string | null) => {
     delete axios.defaults.headers.common.Authorization;
 };
 
-const refreshToken = async () => {
+const refreshToken = async (serverEndPoint:serverEndPointType | null) => {
+    if (!serverEndPoint) {
+        console.log('Não há definição de API (serverEndPoint!');
+        return false;
+    }
     const refreshToken = localStorage.getItem('refreshToken');
     // console.log('entrou refreshToken', refreshToken);
     setAuthToken(null);
@@ -500,7 +578,7 @@ const refreshToken = async () => {
         return false;
     }
     try {
-        const { data } = await axios.post(`${CONSTANTS.API.refreshToken}`, {
+        const { data } = await axios.post(`${serverEndPoint.refreshToken}`, {
             refresh: refreshToken
         });
         setAuthToken(data.access);
@@ -511,16 +589,145 @@ const refreshToken = async () => {
     }
 };
 
-export const isLoggedIn = async () => {
+export const isLoggedIn = async (serverEndPoint:serverEndPointType | null) => {
     const token = localStorage.getItem('token');
     setAuthToken(token);
     if (!token) {
         return false;
     }
-    const usuaria = await getData('minhaconta');
+    const usuaria = await getData('minhaconta', serverEndPoint);
     if (!usuaria) {
         console.log('Erro ao recuperar dados de usuária!');
         return false;
     }
     return usuaria;
 };
+
+export interface getGenericModelListProps {
+    model:string;
+    serverEndPoint:serverEndPointType | null;
+    id?:Id;
+    relatedModel?:string;
+    relatedModelId?:Id;
+    columnFields:string[];
+    hiddenFields?:string[];
+    creatableFields?:string[];
+    isInBatches?:boolean;
+    loadedSchema?:SchemaType | boolean;
+};
+
+export interface DataSchemaColumnsType {
+    data: Item[];
+    schema?: SchemaType;
+    columns?: GridEnrichedBySchemaColDef[];
+}
+export const getGenericModelList = async ({
+    model,
+    serverEndPoint,
+    id = '',
+    relatedModel = '',
+    relatedModelId = '',
+    columnFields,
+    hiddenFields = ['id'],
+    creatableFields = [],
+    isInBatches = false,
+    loadedSchema
+}: getGenericModelListProps) => {
+    let path = `${model}/${id}`;
+    let schemaPath = model;
+    let schema = loadedSchema;
+    let columns;
+    if (!isTmpId(id) && relatedModel) {
+        path += `/${relatedModel}/${relatedModelId}`;
+        schemaPath += `/${id}/${relatedModel}`;
+    }
+
+    // Only get schema and columns if not in batches or in first batch:
+    if (!schema) {
+        schema = await getSchema(schemaPath, serverEndPoint);
+        if (!schema) {
+            return false;
+        }
+        columns = getDataGridColumns(
+            schema,
+            columnFields,
+            hiddenFields,
+            creatableFields
+        );
+        if (!columns) {
+            return false;
+        }
+    }
+
+    let data:Item[] = [];
+
+    if (!id || (id && !relatedModelId)) {
+        if (isInBatches) {
+            path += (loadedSchema)
+                ? '?is_last_batch=1'
+                : '?is_first_batch=1';
+        }
+        const ret = await getData(path, serverEndPoint);
+        if (ret === false) {
+            return false;
+        }
+
+        data = ret.map(row => {
+            const newRow:Item = {};
+            for (const [key, field] of Object.entries(schema as SchemaType)) {
+                if (!(key in row)) {
+                    continue;
+                }
+                if (field.type === 'choice') {
+                    newRow[key] = row[key]
+                        ? {
+                            value: row[key],
+                            display_name: getChoiceByValue(row[key], field.choices)
+                        }
+                        : emptyByType(field);
+                    continue;
+                }
+                newRow[key] = (row[key])
+                    ? row[key]
+                    : emptyByType(field);
+            }
+            return newRow;
+        });
+    }
+    if (loadedSchema) {
+        // DEBUG console.log({ path, data });
+        return { data } as DataSchemaColumnsType;
+    }
+    // DEBUG  console.log({ path, data, columns, schema });
+    return { data, columns, schema } as DataSchemaColumnsType;
+};
+
+export const getGenericModel = async ({
+    model,
+    serverEndPoint,
+    id = '',
+    relatedModel = '',
+    relatedModelId = ''
+}: {
+    model:string,
+    serverEndPoint:serverEndPointType | null,
+    id?:Id,
+    relatedModel?:string,
+    relatedModelId?:string
+}) => {
+    let path = `${model}/${id}`;
+    let schemaPath = model;
+    if (id && relatedModel) {
+        path += `/${relatedModel}/${relatedModelId}`;
+        schemaPath += `/${id}/${relatedModel}`;
+    }
+    const schema = await getSchema(schemaPath, serverEndPoint);
+    if (!schema) {
+        return false;
+    }
+    const data = (!id || (id && relatedModel && !relatedModelId))
+        ? {}
+        : await getData(path, serverEndPoint);
+    // console.log({ schema, data }); // DEBUG
+    return { schema, data };
+};