drf-react-by-schema 0.3.0 → 0.3.1

package/dist/api.d.ts

@@ -0,0 +1,84 @@
+import { AxiosResponse } from 'axios';
+import { serverEndPointType } from './context/DRFReactBySchemaContext';
+import { 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;
+}
+/**
+ *
+ * @param param0
+ * @returns Id when succesfully updated, false otherwise
+ */
+export declare const updateData: ({ path, serverEndPoint, data, id }: TargetApiParams) => Promise<false | Id | AxiosResponse<any, any>>;
+export declare const partialUpdateData: ({ path, serverEndPoint, data, id }: TargetApiParams) => Promise<Id | AxiosResponse<any, any>>;
+export declare const createData: ({ path, serverEndPoint, data }: Omit<TargetApiParams, 'id'>) => Promise<false | AxiosResponse<any, any>>;
+export declare const deleteData: (path: string, serverEndPoint: serverEndPointType | null, id: Id) => Promise<boolean>;
+export declare const createOrUpdateData: ({ path, serverEndPoint, data, id }: TargetApiParamsOptionalId) => Promise<false | Id | AxiosResponse<any, any>>;
+export declare const updateDataBySchema: ({ model, modelObjectId, serverEndPoint, data, schema, path }: {
+    model: string;
+    modelObjectId: Id;
+    serverEndPoint: serverEndPointType | null;
+    data: Item;
+    schema: SchemaType;
+    path?: string | null | undefined;
+}) => Promise<false | Id | AxiosResponse<any, any>>;
+export declare const addExistingRelatedModel: ({ model, serverEndPoint, id, data }: {
+    model: string;
+    serverEndPoint: serverEndPointType | null;
+    id: Id;
+    data: Item;
+}) => Promise<Id | AxiosResponse<any, any>>;
+export declare const getAutoComplete: ({ model, serverEndPoint }: {
+    model: string;
+    serverEndPoint: serverEndPointType | null;
+}) => Promise<false | Item[]>;
+export declare const getJSONSchema: ({ model, serverEndPoint, id }: {
+    model: string;
+    serverEndPoint: serverEndPointType | null;
+    id?: Id | undefined;
+}) => Promise<any>;
+export declare const createOrUpdateJSONSchema: ({ model, serverEndPoint, id, formData }: {
+    model: string;
+    serverEndPoint: serverEndPointType | null;
+    id?: Id | undefined;
+    formData: Item;
+}) => Promise<any>;
+export declare const loginByPayload: (payload: Item, serverEndPoint: serverEndPointType | null) => Promise<boolean>;
+export declare const setAuthToken: (token: string | null) => void;
+export declare const isLoggedIn: (serverEndPoint: serverEndPointType | null) => Promise<false | Item[]>;
+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 declare const getGenericModelList: ({ model, serverEndPoint, id, relatedModel, relatedModelId, columnFields, hiddenFields, creatableFields, isInBatches, loadedSchema }: getGenericModelListProps) => Promise<false | DataSchemaColumnsType>;
+export declare const getGenericModel: ({ model, serverEndPoint, id, relatedModel, relatedModelId }: {
+    model: string;
+    serverEndPoint: serverEndPointType | null;
+    id?: Id | undefined;
+    relatedModel?: string | undefined;
+    relatedModelId?: string | undefined;
+}) => Promise<false | ItemSchemaColumnsType>;
+export {};

package/dist/api.js

@@ -0,0 +1,613 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGenericModel = exports.getGenericModelList = exports.isLoggedIn = exports.setAuthToken = exports.loginByPayload = exports.createOrUpdateJSONSchema = exports.getJSONSchema = exports.getAutoComplete = exports.addExistingRelatedModel = exports.updateDataBySchema = exports.createOrUpdateData = exports.deleteData = exports.createData = exports.partialUpdateData = exports.updateData = void 0;
+const axios_1 = __importDefault(require("axios"));
+const moment_1 = __importDefault(require("moment"));
+const utils_1 = require("./utils");
+;
+;
+const getOptions = (path, serverEndPoint) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    if (!serverEndPoint) {
+        console.log('Não há definição de API (serverEndPoint!');
+        return false;
+    }
+    const url = `${serverEndPoint.api}/${path}`;
+    try {
+        const { data } = yield axios_1.default.options(url);
+        return data;
+    }
+    catch (e) {
+        if (e.isAxiosError) {
+            const err = e;
+            if (((_a = err.response) === null || _a === void 0 ? void 0 : _a.status) === 401) {
+                const isRefreshed = yield refreshToken(serverEndPoint);
+                if (!isRefreshed) {
+                    console.log('Token expirou! Deve-se fazer login de novo');
+                    return false;
+                }
+                try {
+                    const { data } = yield axios_1.default.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 = (path, serverEndPoint) => __awaiter(void 0, void 0, void 0, function* () {
+    const options = yield getOptions(path, serverEndPoint);
+    if (!options || !options.actions || !options.actions.POST) {
+        return false;
+    }
+    // Special default value of "currentUser":
+    let usuaria = false;
+    const postActions = options.actions.POST;
+    for (const [key, field] of Object.entries(postActions)) {
+        if (field.model_default === 'currentUser') {
+            if (!usuaria) {
+                usuaria = yield (0, exports.isLoggedIn)(serverEndPoint);
+            }
+            if (usuaria) {
+                options.actions.POST[key].model_default = {
+                    id: usuaria.id,
+                    label: usuaria.first_name
+                };
+            }
+        }
+    }
+    return options.actions.POST;
+});
+const getData = (path, serverEndPoint, route = 'api') => __awaiter(void 0, void 0, void 0, function* () {
+    var _b;
+    if (!serverEndPoint) {
+        return false;
+    }
+    const url = `${serverEndPoint[route]}/${path}`;
+    try {
+        const { data } = yield axios_1.default.get(url);
+        return data;
+    }
+    catch (e) {
+        if (e.isAxiosError) {
+            const err = e;
+            if (((_b = err.response) === null || _b === void 0 ? void 0 : _b.status) === 401) {
+                const isRefreshed = yield refreshToken(serverEndPoint);
+                if (!isRefreshed) {
+                    console.log('Token expirou! Deve-se fazer login de novo');
+                    return false;
+                }
+                try {
+                    const { data } = yield axios_1.default.get(url);
+                    return data;
+                }
+                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
+ */
+const updateData = ({ path, serverEndPoint, data, id }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _c, _d, _e;
+    if (!serverEndPoint) {
+        return { errors: 'Não há definição de API (serverEndPoint!' };
+    }
+    const url = `${serverEndPoint.api}/${path}/${id}/`;
+    try {
+        yield axios_1.default.put(url, data);
+    }
+    catch (e) {
+        if (e.isAxiosError) {
+            const err = e;
+            if (((_c = err.response) === null || _c === void 0 ? void 0 : _c.status) === 401) {
+                const isRefreshed = yield refreshToken(serverEndPoint);
+                if (!isRefreshed) {
+                    console.log('Token expirou! Deve-se fazer login de novo');
+                    return false;
+                }
+                try {
+                    yield axios_1.default.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, (_d = err.response) === null || _d === void 0 ? void 0 : _d.data);
+            return { errors: (_e = err.response) === null || _e === void 0 ? void 0 : _e.data };
+        }
+    }
+    return id;
+});
+exports.updateData = updateData;
+const partialUpdateData = ({ path, serverEndPoint, data, id }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _f, _g, _h, _j, _k;
+    if (!serverEndPoint) {
+        return { errors: 'Não há definição de API (serverEndPoint!' };
+    }
+    const url = `${serverEndPoint.api}/${path}/${id}/`;
+    try {
+        yield axios_1.default.patch(url, data);
+        // DEBUG console.log({ path, data, id });
+    }
+    catch (e) {
+        if (e.isAxiosError) {
+            const err = e;
+            if (((_f = err.response) === null || _f === void 0 ? void 0 : _f.status) === 401) {
+                const isRefreshed = yield refreshToken(serverEndPoint);
+                if (!isRefreshed) {
+                    console.log('Token expirou! Deve-se fazer login de novo');
+                    return { errors: (_g = err.response) === null || _g === void 0 ? void 0 : _g.data };
+                }
+                try {
+                    yield axios_1.default.patch(url, data);
+                }
+                catch (e) {
+                    console.log(`Error partial updating data at ${url}`, data, e);
+                    return { errors: (_h = err.response) === null || _h === void 0 ? void 0 : _h.data };
+                }
+                return id;
+            }
+            console.log(`Error partial updating data at ${url}`, data, (_j = err.response) === null || _j === void 0 ? void 0 : _j.data);
+            return { errors: (_k = err.response) === null || _k === void 0 ? void 0 : _k.data };
+        }
+    }
+    return id;
+});
+exports.partialUpdateData = partialUpdateData;
+const createData = ({ path, serverEndPoint, data }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _l, _m, _o;
+    if (!serverEndPoint) {
+        return { errors: 'Não há definição de API (serverEndPoint!' };
+    }
+    const url = `${serverEndPoint.api}/${path}/`;
+    let ret = {};
+    try {
+        ret = yield axios_1.default.post(url, data);
+    }
+    catch (e) {
+        if (e.isAxiosError) {
+            const err = e;
+            if (((_l = err.response) === null || _l === void 0 ? void 0 : _l.status) === 401) {
+                const isRefreshed = yield refreshToken(serverEndPoint);
+                if (!isRefreshed) {
+                    console.log('Token expirou! Deve-se fazer login de novo');
+                    return false;
+                }
+                try {
+                    ret = yield axios_1.default.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, (_m = err.response) === null || _m === void 0 ? void 0 : _m.data);
+            return { errors: (_o = err.response) === null || _o === void 0 ? void 0 : _o.data };
+        }
+    }
+    return ret;
+});
+exports.createData = createData;
+const deleteData = (path, serverEndPoint, id) => __awaiter(void 0, void 0, void 0, function* () {
+    var _p;
+    if (!serverEndPoint) {
+        console.log('Não há definição de API (serverEndPoint!');
+        return false;
+    }
+    const url = `${serverEndPoint.api}/${path}/${id}`;
+    try {
+        yield axios_1.default.delete(url);
+    }
+    catch (e) {
+        if (e.isAxiosError) {
+            const err = e;
+            if (((_p = err.response) === null || _p === void 0 ? void 0 : _p.status) === 401) {
+                const isRefreshed = yield refreshToken(serverEndPoint);
+                if (!isRefreshed) {
+                    console.log('Token expirou! Deve-se fazer login de novo');
+                    return false;
+                }
+                try {
+                    yield axios_1.default.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;
+});
+exports.deleteData = deleteData;
+const createOrUpdateData = ({ path, serverEndPoint, data, id }) => __awaiter(void 0, void 0, void 0, function* () {
+    if ((0, utils_1.isTmpId)(id)) {
+        id = null;
+    }
+    if (id) {
+        const responseUpdate = yield (0, exports.updateData)({ path, serverEndPoint, data, id });
+        return responseUpdate;
+    }
+    const responseCreate = yield (0, exports.createData)({ path, serverEndPoint, data });
+    if (!responseCreate || Object.prototype.hasOwnProperty.call(responseCreate, 'errors')) {
+        return responseCreate;
+    }
+    const responseUpdate = yield (0, exports.updateData)({ path, serverEndPoint, data, id: responseCreate.data.id });
+    return responseUpdate;
+});
+exports.createOrUpdateData = createOrUpdateData;
+const prepareDataBySchema = ({ data, schema, parentIsField = false }) => {
+    // console.log('Entered prepareDataBySchema', schema);
+    const dbData = {};
+    for (const [key, field] of Object.entries(schema)) {
+        // console.log(key, field, data);
+        if (!(key in data) || (key === 'id' && (0, utils_1.isTmpId)(data[key]))) {
+            continue;
+        }
+        if (!data[key]) {
+            dbData[key] = (0, utils_1.emptyByType)(field, true);
+            continue;
+        }
+        // console.log({ key, data: data[key] });
+        // OneToMany or ManyToMany relations:
+        if (field.type === 'field' && field.child) {
+            const dataArr = data[key];
+            dbData[key] = dataArr.map(row => {
+                var _a;
+                return ((_a = field.child) === null || _a === void 0 ? void 0 : _a.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] = ((0, utils_1.isTmpId)(data[key].id))
+                ? prepareDataBySchema({
+                    data: data[key],
+                    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 = (0, moment_1.default)(data[key]);
+            dbData[key] = date.format('YYYY-MM-DD');
+            continue;
+        }
+        // DateTime:
+        if (field.type === 'datetime') {
+            const date = (0, moment_1.default)(data[key]);
+            dbData[key] = date.format('YYYY-MM-DDTHH:mm');
+            continue;
+        }
+        // Default:
+        dbData[key] = data[key];
+    }
+    return dbData;
+};
+const updateDataBySchema = ({ model, modelObjectId, serverEndPoint, data, schema, path = null }) => __awaiter(void 0, void 0, void 0, function* () {
+    // console.log({
+    //     model,
+    //     modelObjectId,
+    //     data,
+    //     schema
+    // });
+    const dbData = prepareDataBySchema({ data, schema });
+    if (!path) {
+        path = model;
+    }
+    // DEBUG console.log({ model, modelObjectId, path, data, dbData });
+    const response = yield (0, exports.createOrUpdateData)({
+        path,
+        serverEndPoint,
+        data: dbData,
+        id: modelObjectId
+    });
+    if (typeof response !== 'object' && parseInt(response)) {
+        return response;
+    }
+    console.log('ERRO MAIN', response);
+    return response;
+});
+exports.updateDataBySchema = updateDataBySchema;
+const addExistingRelatedModel = ({ model, serverEndPoint, id, data }) => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield (0, exports.partialUpdateData)({ path: model, serverEndPoint, data, id });
+    // DEBUG console.log({ model, id, data, response });
+    return response;
+});
+exports.addExistingRelatedModel = addExistingRelatedModel;
+const getDataGridColumns = (schema, columnFields = [], hiddenFields = [], creatableFields = []) => {
+    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;
+    });
+};
+const getAutoComplete = ({ model, serverEndPoint }) => __awaiter(void 0, void 0, void 0, function* () {
+    const data = yield getData(model, serverEndPoint, 'autocomplete');
+    return data;
+});
+exports.getAutoComplete = getAutoComplete;
+const getJSONSchema = ({ model, serverEndPoint, id = 'create' }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _q;
+    if (!serverEndPoint) {
+        console.log('Não há definição de API (serverEndPoint!');
+        return false;
+    }
+    const url = `${serverEndPoint.JSONSchema}/${model}/${id}/`;
+    try {
+        const { data } = yield axios_1.default.get(url);
+        return data;
+    }
+    catch (e) {
+        if (e.isAxiosError) {
+            const err = e;
+            if (((_q = err.response) === null || _q === void 0 ? void 0 : _q.status) === 401) {
+                const isRefreshed = yield refreshToken(serverEndPoint);
+                if (!isRefreshed) {
+                    console.log('Token expirou! Deve-se fazer login de novo');
+                    return false;
+                }
+                try {
+                    const { data } = yield axios_1.default.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;
+        }
+    }
+});
+exports.getJSONSchema = getJSONSchema;
+const createOrUpdateJSONSchema = ({ model, serverEndPoint, id = 'create', formData }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _r;
+    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')
+            ? yield axios_1.default.post(url, formData)
+            : yield axios_1.default.patch(url, formData);
+        return data;
+    }
+    catch (e) {
+        if (e.isAxiosError) {
+            const err = e;
+            if (((_r = err.response) === null || _r === void 0 ? void 0 : _r.status) === 401) {
+                const isRefreshed = yield 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')
+                        ? yield axios_1.default.post(url, formData)
+                        : yield axios_1.default.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!' };
+        }
+    }
+});
+exports.createOrUpdateJSONSchema = createOrUpdateJSONSchema;
+const loginByPayload = (payload, serverEndPoint) => __awaiter(void 0, void 0, void 0, function* () {
+    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 } = yield axios_1.default.post(url, payload);
+        localStorage.setItem('refreshToken', data.refresh);
+        (0, exports.setAuthToken)(data.access);
+        return true;
+    }
+    catch (e) {
+        console.log('Erro no loginByPayload!', e);
+        (0, exports.setAuthToken)(null);
+        return false;
+    }
+});
+exports.loginByPayload = loginByPayload;
+const setAuthToken = (token) => {
+    if (token) {
+        localStorage.setItem('token', token);
+        axios_1.default.defaults.headers.common.Authorization = `Bearer ${token}`;
+        return;
+    }
+    localStorage.removeItem('token');
+    localStorage.removeItem('refreshToken');
+    delete axios_1.default.defaults.headers.common.Authorization;
+};
+exports.setAuthToken = setAuthToken;
+const refreshToken = (serverEndPoint) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!serverEndPoint) {
+        console.log('Não há definição de API (serverEndPoint!');
+        return false;
+    }
+    const refreshToken = localStorage.getItem('refreshToken');
+    // console.log('entrou refreshToken', refreshToken);
+    (0, exports.setAuthToken)(null);
+    if (!refreshToken) {
+        return false;
+    }
+    try {
+        const { data } = yield axios_1.default.post(`${serverEndPoint.refreshToken}`, {
+            refresh: refreshToken
+        });
+        (0, exports.setAuthToken)(data.access);
+        return true;
+    }
+    catch (e) {
+        console.log('Failed refreshing token', e);
+        return false;
+    }
+});
+const isLoggedIn = (serverEndPoint) => __awaiter(void 0, void 0, void 0, function* () {
+    const token = localStorage.getItem('token');
+    (0, exports.setAuthToken)(token);
+    if (!token) {
+        return false;
+    }
+    const usuaria = yield getData('minhaconta', serverEndPoint);
+    if (!usuaria) {
+        console.log('Erro ao recuperar dados de usuária!');
+        return false;
+    }
+    return usuaria;
+});
+exports.isLoggedIn = isLoggedIn;
+;
+const getGenericModelList = ({ model, serverEndPoint, id = '', relatedModel = '', relatedModelId = '', columnFields, hiddenFields = ['id'], creatableFields = [], isInBatches = false, loadedSchema }) => __awaiter(void 0, void 0, void 0, function* () {
+    let path = `${model}/${id}`;
+    let schemaPath = model;
+    let schema = loadedSchema;
+    let columns;
+    if (!(0, utils_1.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 = yield getSchema(schemaPath, serverEndPoint);
+        if (!schema) {
+            return false;
+        }
+        columns = getDataGridColumns(schema, columnFields, hiddenFields, creatableFields);
+        if (!columns) {
+            return false;
+        }
+    }
+    let data = [];
+    if (!id || (id && !relatedModelId)) {
+        if (isInBatches) {
+            path += (loadedSchema)
+                ? '?is_last_batch=1'
+                : '?is_first_batch=1';
+        }
+        const ret = yield getData(path, serverEndPoint);
+        if (ret === false) {
+            return false;
+        }
+        data = ret.map(row => {
+            const newRow = {};
+            for (const [key, field] of Object.entries(schema)) {
+                if (!(key in row)) {
+                    continue;
+                }
+                if (field.type === 'choice') {
+                    newRow[key] = row[key]
+                        ? {
+                            value: row[key],
+                            display_name: (0, utils_1.getChoiceByValue)(row[key], field.choices)
+                        }
+                        : (0, utils_1.emptyByType)(field);
+                    continue;
+                }
+                newRow[key] = (row[key])
+                    ? row[key]
+                    : (0, utils_1.emptyByType)(field);
+            }
+            return newRow;
+        });
+    }
+    if (loadedSchema) {
+        // DEBUG console.log({ path, data });
+        return { data };
+    }
+    // DEBUG  console.log({ path, data, columns, schema });
+    return { data, columns, schema };
+});
+exports.getGenericModelList = getGenericModelList;
+const getGenericModel = ({ model, serverEndPoint, id = '', relatedModel = '', relatedModelId = '' }) => __awaiter(void 0, void 0, void 0, function* () {
+    let path = `${model}/${id}`;
+    let schemaPath = model;
+    if (id && relatedModel) {
+        path += `/${relatedModel}/${relatedModelId}`;
+        schemaPath += `/${id}/${relatedModel}`;
+    }
+    const schema = yield getSchema(schemaPath, serverEndPoint);
+    if (!schema) {
+        return false;
+    }
+    const data = (!id || (id && relatedModel && !relatedModelId))
+        ? {}
+        : yield getData(path, serverEndPoint);
+    // console.log({ schema, data }); // DEBUG
+    return { schema, data };
+});
+exports.getGenericModel = getGenericModel;