@carbonorm/carbonnode 1.6.10 → 1.6.12

package/src/api/restRequest.ts

@@ -121,7 +121,7 @@ export type iAPI<RestTableInterfaces extends { [key: string]: any }> = RestTable
     dataInsertMultipleRows?: RestTableInterfaces[],
     cacheResults?: boolean, // aka ignoreCache
     // todo - this should really only be used for get requests - add this to the Get interface or throw error (im actually inclined to ts ignore the function and add to iGetC6 atm; back later)
-    fetchDependencies?: number | eFetchDependencies | Promise<apiReturn<iGetC6RestResponse<any>>>[],
+    fetchDependencies?: number | eFetchDependencies | apiReturn<iGetC6RestResponse<any>>[],
     debug?: boolean,
     success?: string | ((r: AxiosResponse) => (string | void)),
     error?: string | ((r: AxiosResponse) => (string | void)),
@@ -779,111 +779,114 @@ export default function restApi<
 
                 // returning the promise with this then is important for tests. todo - we could make that optional.
                 // https://rapidapi.com/guides/axios-async-await
-                return axiosActiveRequest.then(async (response) => {
+                return axiosActiveRequest.then(async (response): Promise<AxiosResponse<ResponseDataType, any>> => {
 
-                    if (typeof response.data === 'string') {
+                        if (typeof response.data === 'string') {
 
-                        if (isTest) {
+                            if (isTest) {
 
-                            console.trace()
+                                console.trace()
 
-                            throw new Error('The response data was a string this typically indicated html was sent. Make sure all cookies (' + JSON.stringify(response.config.headers) + ') needed are present! (' + response.data + ')')
+                                throw new Error('The response data was a string this typically indicated html was sent. Make sure all cookies (' + JSON.stringify(response.config.headers) + ') needed are present! (' + response.data + ')')
 
-                        }
-
-                        return Promise.reject(response);
+                            }
 
-                    }
+                            return Promise.reject(response);
 
-                    if (cachingConfirmed) {
+                        }
 
-                        const cacheIndex = apiRequestCache.findIndex(cache => cache.requestArgumentsSerialized === querySerialized);
+                        if (cachingConfirmed) {
 
-                        apiRequestCache[cacheIndex].final = false === returnGetNextPageFunction
+                            const cacheIndex = apiRequestCache.findIndex(cache => cache.requestArgumentsSerialized === querySerialized);
 
-                        // only cache get method requests
-                        apiRequestCache[cacheIndex].response = response
+                            apiRequestCache[cacheIndex].final = false === returnGetNextPageFunction
 
-                    }
+                            // only cache get method requests
+                            apiRequestCache[cacheIndex].response = response
 
-                    apiResponse = TestRestfulResponse(response, request?.success, request?.error ?? "An unexpected API error occurred!")
+                        }
 
-                    if (false === apiResponse) {
+                        apiResponse = TestRestfulResponse(response, request?.success, request?.error ?? "An unexpected API error occurred!")
 
-                        if (request.debug && isLocal) {
+                        if (false === apiResponse) {
 
-                            toast.warning("DEVS: TestRestfulResponse returned false for (" + operatingTable + ").", toastOptionsDevs);
+                            if (request.debug && isLocal) {
 
-                        }
-
-                        return response;
+                                toast.warning("DEVS: TestRestfulResponse returned false for (" + operatingTable + ").", toastOptionsDevs);
 
-                    }
+                            }
 
-                    responseCallback(response, request, apiResponse)
+                            return response;
 
-                    if (C6.GET === requestMethod) {
+                        }
 
-                        const responseData = response.data as iGetC6RestResponse<any>;
+                        responseCallback(response, request, apiResponse)
 
-                        returnGetNextPageFunction = 1 !== query?.[C6.PAGINATION]?.[C6.LIMIT] &&
-                            query?.[C6.PAGINATION]?.[C6.LIMIT] === responseData.rest.length
+                        if (C6.GET === requestMethod) {
 
-                        if (false === isTest || true === isVerbose) {
+                            const responseData = response.data as iGetC6RestResponse<any>;
 
-                            console.groupCollapsed('%c API: Response (' + requestMethod + ' ' + tableName + ') returned length (' + responseData.rest?.length + ') of possible (' + query?.[C6.PAGINATION]?.[C6.LIMIT] + ') limit!', 'color: #0c0')
+                            returnGetNextPageFunction = 1 !== query?.[C6.PAGINATION]?.[C6.LIMIT] &&
+                                query?.[C6.PAGINATION]?.[C6.LIMIT] === responseData.rest.length
 
-                            console.log('%c ' + requestMethod + ' ' + tableName, 'color: #0c0')
+                            if (false === isTest || true === isVerbose) {
 
-                            console.log('%c Request Data (note you may see the success and/or error prompt):', 'color: #0c0', request)
+                                console.groupCollapsed('%c API: Response (' + requestMethod + ' ' + tableName + ') returned length (' + responseData.rest?.length + ') of possible (' + query?.[C6.PAGINATION]?.[C6.LIMIT] + ') limit!', 'color: #0c0')
 
-                            console.log('%c Response Data:', 'color: #0c0', responseData.rest)
+                                console.log('%c ' + requestMethod + ' ' + tableName, 'color: #0c0')
 
-                            console.log('%c Will return get next page function:' + (1 !== query?.[C6.PAGINATION]?.[C6.LIMIT] ? '' : ' (Will not return with explicit limit 1 set)'), 'color: #0c0', true === returnGetNextPageFunction)
+                                console.log('%c Request Data (note you may see the success and/or error prompt):', 'color: #0c0', request)
 
-                            console.trace();
+                                console.log('%c Response Data:', 'color: #0c0', responseData.rest)
 
-                            console.groupEnd()
+                                console.log('%c Will return get next page function:' + (1 !== query?.[C6.PAGINATION]?.[C6.LIMIT] ? '' : ' (Will not return with explicit limit 1 set)'), 'color: #0c0', true === returnGetNextPageFunction)
 
-                        }
+                                console.trace();
 
-                        if (false === returnGetNextPageFunction
-                            && true === request.debug
-                            && isLocal) {
+                                console.groupEnd()
 
-                            toast.success("DEVS: Response returned length (" + responseData.rest?.length + ") less than limit (" + query?.[C6.PAGINATION]?.[C6.LIMIT] + ").", toastOptionsDevs);
+                            }
 
-                        }
+                            if (false === returnGetNextPageFunction
+                                && true === request.debug
+                                && isLocal) {
 
-                        if ((request.fetchDependencies ??= eFetchDependencies.NONE)
-                            && 'number' === typeof request.fetchDependencies) {
+                                toast.success("DEVS: Response returned length (" + responseData.rest?.length + ") less than limit (" + query?.[C6.PAGINATION]?.[C6.LIMIT] + ").", toastOptionsDevs);
 
-                            console.groupCollapsed('%c API: Fetch Dependencies segment (' + requestMethod + ' ' + tableName + ')', 'color: #33ccff')
+                            }
 
-                            const fetchDependencies = async (fetchData: {
-                                [key: string]: iConstraint[]
-                            }, fetchDependencies: number) => Object.keys(
-                                fetchData
-                            ).map((column) => {
+                            request.fetchDependencies ??= eFetchDependencies.NONE;
 
-                                console.log('fetchDependencies', responseData.rest, column)
+                            if (request.fetchDependencies
+                                && 'number' === typeof request.fetchDependencies) {
 
-                                // check if the column is in the response
-                                // todo - this may need [0][x]
-                                if (!(column in responseData.rest)
-                                    && !(0 in responseData.rest
-                                        && column in responseData.rest[0])) {
+                                const fetchDependencies = request.fetchDependencies as number;
 
-                                    console.warn('The column (' + column + ') was not found in the response data. We will not fetch.', responseData)
+                                console.groupCollapsed('%c API: Fetch Dependencies segment (' + requestMethod + ' ' + tableName + ')', 'color: #33ccff')
 
-                                    return false;
+                                // noinspection JSBitwiseOperatorUsage
+                                let dependencies: { [key: string]: iConstraint[] } = {
+                                    ...fetchDependencies & eFetchDependencies.REFERENCED ? C6.TABLES[operatingTable].TABLE_REFERENCED_BY : {},
+                                    ...fetchDependencies & eFetchDependencies.REFERENCES ? C6.TABLES[operatingTable].TABLE_REFERENCES : {}
+                                };
 
-                                }
+                                let fetchReferences: {
+                                    [externalTable: string]: {
+                                        [column: string]: string[]
+                                    }
+                                } = {}
 
+                                let apiRequestPromises: Array<apiReturn<iGetC6RestResponse<any>>> = []
 
-                                return fetchData[column].map(async (constraint) => {
+                                Object.keys(
+                                    dependencies
+                                ).forEach(column => dependencies[column].forEach((constraint) => {
+                                    fetchReferences[constraint.TABLE] ??= {};
+                                    fetchReferences[constraint.TABLE][constraint.COLUMN] = []
+                                    fetchReferences[constraint.TABLE][constraint.COLUMN].push(responseData.rest[column] ?? responseData.rest.map((row) => row[column]))
+                                }));
 
-                                    const constraintTableName = constraint.TABLE
+                                for (const table in fetchReferences) {
 
                                     if (fetchDependencies & eFetchDependencies.C6ENTITY
                                         && tableName === "carbon_carbons") {
@@ -891,101 +894,88 @@ export default function restApi<
                                         // todo - let's assume this handles a single row for now, handle multiple rows could improve performance
                                         // this more or less implies
                                         // todo - rethink the table ref entity system - when tables are renamed? no hooks exist in mysql
-                                        const referencesTable = (responseData.rest[0]['entity_tag'] ?? '').split('/').pop()
+                                        const tagFilter = (tag: string) => tag.split('/').pop() ?? ''
+
+                                        // since were already filtering on column, we can assume the first row constraint is the same as the rest
+                                        const referencesTable: string = tagFilter(responseData.rest[0]['entity_tag'] ?? '')
 
-                                        if (!constraintTableName.endsWith(referencesTable)) {
+                                        // todo - allow c6 requests with multiple table endpoints to be fetched
+                                        //  const referencesTables: string[] = !(0 in responseData.rest) ? [tagFilter(responseData.rest['entity_tag'] ?? '')] : responseData.rest.map(row => tagFilter(row['entity_tag'] ?? '')).filter(n => n)
+                                        if (!table.endsWith(referencesTable)) {
 
-                                            console.log('%c C6ENTITY: The constraintTableName (' + constraintTableName + ') did not end with referencesTable (' + referencesTable + ')', 'color: #c00')
+                                            console.log('%c C6ENTITY: The constraintTableName (' + table + ') did not end with referencesTable (' + referencesTable + ')', 'color: #c00')
 
-                                            return false;
+                                            continue;
 
                                         }
 
-                                        console.log('%c C6ENTITY: The constraintTableName (' + constraintTableName + ') ended with referencesTable (' + referencesTable + ')', 'color: #0c0')
+                                        console.log('%c C6ENTITY: The constraintTableName (' + table + ') ended with referencesTable (' + referencesTable + ')', 'color: #0c0')
 
                                     }
 
-                                    console.log(column, constraintTableName)
-
-                                    const fetchTable = await C6.IMPORT(constraint.TABLE)
+                                    const fetchTable = await C6.IMPORT(table)
 
                                     const RestApi = fetchTable.default
 
-                                    console.log('Fetch Dependencies will select (' + constraintTableName + ') using GET request')
+                                    console.log('Fetch Dependencies will select (' + table + ') using GET request')
 
                                     // todo - filter out ids that exist in state?!?
 
                                     // this is a dynamic call to the rest api, any generated table may resolve with (RestApi)
-                                    return RestApi.Get({
-                                        [C6.WHERE]: {
-                                            // todo - using value to avoid joins.... but. maybe this should be a parameterizable option -- think race conditions; its safer to join
-                                            [constraint.COLUMN]: responseData.rest[column] ?? [C6.IN,  responseData.rest.map((row) => row[column])]
-                                        },
-                                        fetchDependencies: fetchDependencies & eFetchDependencies.RECURSIVE
-                                        || (fetchDependencies & eFetchDependencies.C6ENTITY
-                                            && constraintTableName === "carbon_carbons")
-                                            ? fetchDependencies
-                                            : eFetchDependencies.NONE
-                                    })
-
-                                });
+                                    // todo - using value to avoid joins.... but. maybe this should be a parameterizable option -- think race conditions; its safer to join
+                                    apiRequestPromises.push(RestApi.Get({
+                                            [C6.WHERE]: {
+                                                0: Object.keys(fetchReferences[table]).reduce((sum, column) => {
 
-                            });
+                                                    fetchReferences[table][column] = fetchReferences[table][column].flat(Infinity)
 
-                            let dependencies: any[] = [];
+                                                    if (0 === fetchReferences[table][column].length) {
 
-                            // noinspection JSBitwiseOperatorUsage
-                            if (request.fetchDependencies & eFetchDependencies.REFERENCED) {
+                                                        console.warn('The column (' + column + ') was not found in the response data. We will not fetch.', responseData)
 
-                                const referencedBy = C6.TABLES[operatingTable].TABLE_REFERENCED_BY;
+                                                        return false;
 
-                                console.log('REFERENCED BY (CHILDREN)', referencedBy)
+                                                    }
 
-                                if (Object.keys(referencedBy).length > 0) {
+                                                    sum[column] = fetchReferences[table][column].length === 1 ? fetchReferences[table][column][0] : [
+                                                        [C6.IN, fetchReferences[table][column]]
+                                                    ]
 
-                                    dependencies = await fetchDependencies(referencedBy, request.fetchDependencies)
+                                                    return sum
+                                                }, {})
+                                            },
+                                            fetchDependencies: fetchDependencies & eFetchDependencies.RECURSIVE
+                                            || (fetchDependencies & eFetchDependencies.C6ENTITY
+                                                && table === "carbon_carbons")
+                                                ? fetchDependencies
+                                                : eFetchDependencies.NONE
+                                        }
+                                    ));
 
                                 }
 
-                            }
-
-                            if (request.fetchDependencies & eFetchDependencies.REFERENCES) {
+                                 await Promise.all(apiRequestPromises)
 
-                                const references = C6.TABLES[operatingTable].TABLE_REFERENCES;
+                                request.fetchDependencies = apiRequestPromises
 
-                                console.log('REFERENCES (PARENTS)', references)
+                                console.trace();
 
-                                if (Object.keys(references).length > 0) {
+                                console.groupEnd()
 
-                                    dependencies.push(await fetchDependencies(references, request.fetchDependencies))
-
-                                }
                             }
 
-                            dependencies = dependencies.flat(Infinity)
-
-                            request.fetchDependencies = dependencies;
-
-                            await Promise.all(dependencies)
-
-                            console.trace();
-
-                            console.groupEnd()
 
                         }
 
+                        if (request.debug && isLocal) {
 
-                    }
-
-                    if (request.debug && isLocal) {
-
-                        toast.success("DEVS: (" + requestMethod + ") request complete.", toastOptionsDevs);
+                            toast.success("DEVS: (" + requestMethod + ") request complete.", toastOptionsDevs);
 
-                    }
+                        }
 
-                    return response;
+                        return response;
 
-                });
+                    });
 
             } catch (error) {