@carbonorm/carbonnode 1.6.11 → 1.6.13

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,7 +779,7 @@ 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') {
 
@@ -855,117 +855,109 @@ export default function restApi<
 
                         }
 
-                        if ((request.fetchDependencies ??= eFetchDependencies.NONE)
-                            && 'number' === typeof request.fetchDependencies) {
-
-                            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) => {
-
-                                console.log('fetchDependencies', responseData.rest, column)
+                        request.fetchDependencies ??= eFetchDependencies.NONE;
 
-                                // 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])) {
+                        if (request.fetchDependencies
+                            && 'number' === typeof request.fetchDependencies) {
 
-                                    console.warn('The column (' + column + ') was not found in the response data. We will not fetch.', responseData)
+                            const fetchDependencies = request.fetchDependencies as number;
 
-                                    return false;
+                            console.groupCollapsed('%c API: Fetch Dependencies segment (' + requestMethod + ' ' + tableName + ')', 'color: #33ccff')
 
+                            // 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[]
                                 }
+                            } = {}
 
-                                return fetchData[column].map(async (constraint) => {
+                            let apiRequestPromises: Array<apiReturn<iGetC6RestResponse<any>>> = []
 
-                                    const constraintTableName = constraint.TABLE
+                            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]))
+                            }));
 
-                                    if (fetchDependencies & eFetchDependencies.C6ENTITY
-                                        && tableName === "carbon_carbons") {
+                            for (const table in fetchReferences) {
 
-                                        // 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()
+                                if (fetchDependencies & eFetchDependencies.C6ENTITY
+                                    && tableName === "carbon_carbons") {
 
-                                        if (!constraintTableName.endsWith(referencesTable)) {
+                                    // this more or less implies
+                                    // todo - rethink the table ref entity system - when tables are renamed? no hooks exist in mysql
+                                    const tagFilter = (tag: string) => tag.split('/').pop() ?? ''
 
-                                            console.log('%c C6ENTITY: The constraintTableName (' + constraintTableName + ') did not end with referencesTable (' + referencesTable + ')', 'color: #c00')
+                                    // 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'] ?? '')
 
-                                            return false;
+                                    // 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 (' + table + ') did not end with referencesTable (' + referencesTable + ')', 'color: #c00')
 
-                                        console.log('%c C6ENTITY: The constraintTableName (' + constraintTableName + ') ended with referencesTable (' + referencesTable + ')', 'color: #0c0')
+                                        continue;
 
                                     }
 
-                                    console.log(column, constraintTableName)
-
-                                    const fetchTable = await C6.IMPORT(constraint.TABLE)
-
-                                    const RestApi = fetchTable.default
-
-                                    console.log('Fetch Dependencies will select (' + constraintTableName + ') 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 await 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
-                                    })
-
-                                });
+                                    console.log('%c C6ENTITY: The constraintTableName (' + table + ') ended with referencesTable (' + referencesTable + ')', 'color: #0c0')
 
-                            });
+                                }
 
-                            let dependencies: any[] = [];
+                                const fetchTable = await C6.IMPORT(table)
 
-                            // noinspection JSBitwiseOperatorUsage
-                            if (request.fetchDependencies & eFetchDependencies.REFERENCED) {
+                                const RestApi = fetchTable.default
 
-                                const referencedBy = C6.TABLES[operatingTable].TABLE_REFERENCED_BY;
+                                console.log('Fetch Dependencies will select (' + table + ') using GET request')
 
-                                console.log('REFERENCED BY (CHILDREN)', referencedBy)
+                                // todo - filter out ids that exist in state?!?
 
-                                if (Object.keys(referencedBy).length > 0) {
-
-                                    dependencies = await fetchDependencies(referencedBy, request.fetchDependencies)
+                                // this is a dynamic call to the rest api, any generated table may resolve with (RestApi)
+                                // 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)
 
-                            }
+                                                if (0 === fetchReferences[table][column].length) {
 
-                            if (request.fetchDependencies & eFetchDependencies.REFERENCES) {
+                                                    console.warn('The column (' + column + ') was not found in the response data. We will not fetch.', responseData)
 
-                                const references = C6.TABLES[operatingTable].TABLE_REFERENCES;
+                                                    return false;
 
-                                console.log('REFERENCES (PARENTS)', references)
+                                                }
 
-                                if (Object.keys(references).length > 0) {
+                                                sum[column] = fetchReferences[table][column].length === 1
+                                                    ? fetchReferences[table][column][0]
+                                                    : [
+                                                        C6.IN, fetchReferences[table][column]
+                                                    ]
 
-                                    dependencies.push(await fetchDependencies(references, request.fetchDependencies))
+                                                return sum
+                                            }, {})
+                                        },
+                                        fetchDependencies: fetchDependencies & eFetchDependencies.RECURSIVE
+                                        || (fetchDependencies & eFetchDependencies.C6ENTITY
+                                            && table === "carbon_carbons")
+                                            ? fetchDependencies
+                                            : eFetchDependencies.NONE
+                                    }
+                                ));
 
-                                }
                             }
 
-                            dependencies = dependencies.flat(Infinity)
-
-                            request.fetchDependencies = dependencies;
+                            await Promise.all(apiRequestPromises)
 
-                            await Promise.all(dependencies)
+                            request.fetchDependencies = apiRequestPromises
 
                             console.trace();