drf-react-by-schema 0.3.0 → 0.4.0

package/src/api.ts

@@ -1,727 +0,0 @@
-import axios, { AxiosError, AxiosResponse } from 'axios';
-import moment from 'moment';
-import { serverEndPointType } from './context/DRFReactBySchemaContext';
-import {
-    isTmpId,
-    emptyByType,
-    getChoiceByValue,
-    Field,
-    Item,
-    SchemaType,
-    DataSchemaColumnsType,
-    ItemSchemaColumnsType
-} from './utils';
-
-type Id = string | number | null;
-
-/**
- * Interface for CRUD on API
- *
- * @interface TargetApiParams
- */
-interface TargetApiParams {
-    path:string;
-    serverEndPoint:serverEndPointType | null;
-    data:Item;
-    id:Id;
-};
-interface TargetApiParamsOptionalId {
-    path:string;
-    serverEndPoint:serverEndPointType | null;
-    data:Item;
-    id?:Id;
-};
-const getOptions = async (path:string, serverEndPoint:serverEndPointType | null) => {
-    if (!serverEndPoint) {
-        console.log('Não há definição de API (serverEndPoint!');
-        return false;
-    }
-    const url = `${serverEndPoint.api}/${path}`;
-    try {
-        const { data } = await axios.options(url);
-        return data;
-    } catch (e) {
-        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;
-        }
-    }
-};
-
-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: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(serverEndPoint);
-            }
-            if (usuaria) {
-                options.actions.POST[key].model_default = {
-                    id: usuaria.id,
-                    label: usuaria.first_name
-                };
-            }
-        }
-    }
-
-    return options.actions.POST as SchemaType;
-};
-
-const getData = async (
-    path:string,
-    serverEndPoint:serverEndPointType | null,
-    route:string = 'api'
-) => {
-    if (!serverEndPoint) {
-        return false;
-    }
-    const url = `${serverEndPoint[route as keyof serverEndPointType]}/${path}`;
-    try {
-        const { data } = await axios.get(url);
-        return data as Item[];
-    } catch (e) {
-        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);
-        return false;
-    }
-};
-
-/**
- * 
- * @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);
-    } catch (e) {
-        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);
-                } catch (e) {
-                    console.log(`Error updating data at ${url}`, data, e);
-                    return false;
-                }
-                return id;
-            }
-            console.log(`Error updating data at ${url}`, data, err.response?.data);
-            return ({ errors: err.response?.data } as unknown) as AxiosResponse;
-        }
-    }
-    return 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 });
-    } catch (e) {
-        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: err.response?.data } as unknown) as AxiosResponse;
-                }
-                try {
-                    await axios.patch(url, data);
-                } catch (e) {
-                    console.log(`Error partial updating data at ${url}`, data, e);
-                    return ({ errors: err.response?.data } as unknown) as AxiosResponse;
-                }
-                return id;
-            }
-            console.log(`Error partial updating data at ${url}`, data, err.response?.data);
-            return ({ errors: err.response?.data } as unknown) as AxiosResponse;
-        }
-    }
-    return id;
-};
-
-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}/`;
-    let ret = <AxiosResponse>{};
-    try {
-        ret = await axios.post(url, data);
-    } catch (e) {
-        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 {
-                    ret = await axios.post(url, data);
-                } catch (e) {
-                    console.log(`Error creating data at ${url}`, data, e);
-                    return false;
-                }
-                return ret;
-            }
-            console.log(`Error creating data at ${url}`, data, err.response?.data);
-            return ({ errors: err.response?.data } as unknown) as AxiosResponse;
-        }
-    }
-    return ret;
-};
-
-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);
-    } catch (e) {
-        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);
-                } catch (e) {
-                    console.log(`Error deleting data from ${url}`, e);
-                    return false;
-                }
-                return true;
-            }
-            console.log(`Error deleting data from ${url}`, e);
-            return false;
-        }
-    }
-    return true;
-};
-
-export const createOrUpdateData = async ({ path, serverEndPoint, data, id }: TargetApiParamsOptionalId) => {
-    if (isTmpId(id)) {
-        id = null;
-    }
-    if (id) {
-        const responseUpdate = await updateData({ path, serverEndPoint, data, id });
-        return responseUpdate;
-    }
-
-    const responseCreate = await createData({ path, serverEndPoint, data });
-    if (!responseCreate || Object.prototype.hasOwnProperty.call(responseCreate, 'errors')) {
-        return responseCreate;
-    }
-
-    const responseUpdate = await updateData({ path, serverEndPoint, data, id: responseCreate.data.id });
-    return responseUpdate;
-};
-
-const prepareDataBySchema = ({
-    data,
-    schema,
-    parentIsField = false
-}: {
-    data:Item,
-    schema:SchemaType,
-    parentIsField?:boolean
-}) => {
-    // console.log('Entered prepareDataBySchema', schema);
-    const dbData:Item = {};
-    for (const [key, field] of Object.entries(schema)) {
-        // console.log(key, field, data);
-        if (!(key in data) || (key === 'id' && isTmpId(data[key]))) {
-            continue;
-        }
-        if (!data[key]) {
-            dbData[key] = emptyByType(field, true);
-            continue;
-        }
-        // console.log({ key, data: data[key] });
-
-        // OneToMany or ManyToMany relations:
-        if (field.type === 'field' && field.child) {
-            const dataArr:Item[] = data[key];
-            dbData[key] = dataArr.map(row => {
-                return (field.child?.children)
-                    ? prepareDataBySchema({
-                        data: row,
-                        schema: field.child.children,
-                        parentIsField: true
-                    })
-                    : row;
-            });
-            continue;
-        }
-
-        // Nested Object:
-        if (field.type === 'nested object' && field.children && typeof data[key] === 'object') {
-            dbData[key] = (isTmpId(data[key].id))
-                ? prepareDataBySchema({
-                    data: data[key] as Item,
-                    schema: field.children
-                })
-                : data[key].id;
-            continue;
-        }
-
-        // Choices:
-        if (field.type === 'choice') {
-            dbData[key] = data[key].value;
-            continue;
-        }
-
-        // Date:
-        if (field.type === 'date') {
-            const date = moment(data[key]);
-            dbData[key] = date.format('YYYY-MM-DD');
-            continue;
-        }
-
-        // DateTime:
-        if (field.type === 'datetime') {
-            const date = moment(data[key]);
-            dbData[key] = date.format('YYYY-MM-DDTHH:mm');
-            continue;
-        }
-
-        // Default:
-        dbData[key] = data[key];
-    }
-    return dbData;
-};
-
-export const updateDataBySchema = async ({
-    model,
-    modelObjectId,
-    serverEndPoint,
-    data,
-    schema,
-    path = null
-}: {
-    model:string,
-    modelObjectId:Id,
-    serverEndPoint:serverEndPointType | null,
-    data:Item,
-    schema:SchemaType,
-    path?:string | null
-}) => {
-    // console.log({
-    //     model,
-    //     modelObjectId,
-    //     data,
-    //     schema
-    // });
-    const dbData:Item = prepareDataBySchema({ data, schema });
-
-    if (!path) {
-        path = model;
-    }
-    // DEBUG console.log({ model, modelObjectId, path, data, dbData });
-    const response = await createOrUpdateData({
-        path,
-        serverEndPoint,
-        data: dbData,
-        id: modelObjectId
-    });
-
-    if (typeof response !== 'object' && parseInt(response as string)) {
-        return response;
-    }
-
-    console.log('ERRO MAIN', response);
-    return response;
-};
-
-export const addExistingRelatedModel = async ({
-    model,
-    serverEndPoint,
-    id,
-    data
-}: {
-    model:string,
-    serverEndPoint:serverEndPointType | null,
-    id:Id,
-    data:Item
-}) => {
-    const response = await partialUpdateData({ path: model, serverEndPoint, data, id });
-    // DEBUG console.log({ model, id, data, response });
-    return response;
-};
-
-const getDataGridColumns = (
-    schema:SchemaType,
-    columnFields:string[] = [],
-    hiddenFields:string[] = [],
-    creatableFields:string[] = []
-) => {
-    if (!schema) {
-        return false;
-    }
-    columnFields = (!columnFields || columnFields.length === 0)
-        ? Object.keys(schema)
-        : columnFields.filter(field => {
-            return Object.prototype.hasOwnProperty.call(schema, field);
-        });
-
-    return columnFields.map(field => {
-        const column = {
-            field,
-            headerName: schema[field].label,
-            hide: (hiddenFields.includes(field)),
-            creatable: (creatableFields.includes(field)),
-            width: 100
-        };
-        return column;
-    });
-};
-
-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
-}) => {
-    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 ((<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;
-        }
-    }
-};
-
-export const createOrUpdateJSONSchema = async ({
-    model,
-    serverEndPoint,
-    id = 'create',
-    formData
-}: {
-    model:string,
-    serverEndPoint:serverEndPointType | null,
-    id?:Id,
-    formData:Item
-}) => {
-    if (!serverEndPoint) {
-        return { errors: 'Não há definição de API (serverEndPoint!' };
-    }
-    let url = `${serverEndPoint.JSONSchema}/${model}/`;
-    if (id !== 'create') {
-        url += `${id}/`;
-    }
-    try {
-        const { data } = (id === 'create')
-            ? await axios.post(url, formData)
-            : await axios.patch(url, formData);
-        return data;
-    } catch (e) {
-        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!' };
-        }
-    }
-};
-
-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);
-        setAuthToken(data.access);
-        return true;
-    } catch (e) {
-        console.log('Erro no loginByPayload!', e);
-        setAuthToken(null);
-        return false;
-    }
-};
-
-export const setAuthToken = (token:string | null) => {
-    if (token) {
-        localStorage.setItem('token', token);
-        axios.defaults.headers.common.Authorization = `Bearer ${token}`;
-        return;
-    }
-    localStorage.removeItem('token');
-    localStorage.removeItem('refreshToken');
-    delete axios.defaults.headers.common.Authorization;
-};
-
-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);
-    if (!refreshToken) {
-        return false;
-    }
-    try {
-        const { data } = await axios.post(`${serverEndPoint.refreshToken}`, {
-            refresh: refreshToken
-        });
-        setAuthToken(data.access);
-        return true;
-    } catch (e) {
-        console.log('Failed refreshing token', e);
-        return false;
-    }
-};
-
-export const isLoggedIn = async (serverEndPoint:serverEndPointType | null) => {
-    const token = localStorage.getItem('token');
-    setAuthToken(token);
-    if (!token) {
-        return false;
-    }
-    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 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 <DataSchemaColumnsType>{ data };
-    }
-    // DEBUG  console.log({ path, data, columns, schema });
-    return <DataSchemaColumnsType>{ data, columns, schema };
-};
-
-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 <ItemSchemaColumnsType>{ schema, data };
-};