@carbonorm/carbonnode 1.6.6 → 1.6.8

package/src/api/restRequest.ts

@@ -107,21 +107,24 @@ type DeepPartialAny<T> = {
 
 export enum eFetchDependencies {
     NONE = 0,
-    REFERENCED = 1,
-    CHILDREN = 1,
-    REFERENCES = 2,
-    PARENTS = 2,
-    ALL = 3
+    REFERENCED = 0b1,
+    CHILDREN = 0b1,
+    REFERENCES = 0b10,
+    PARENTS = 0b10,
+    ALL = 0b11,
+    C6ENTITY = 0b100,
+    RECURSIVE = 0b1000,
 }
 
+// todo - I don't like that these essentially become reserved words.
 export type iAPI<RestTableInterfaces extends { [key: string]: any }> = RestTableInterfaces & {
     dataInsertMultipleRows?: RestTableInterfaces[],
     cacheResults?: boolean, // aka ignoreCache
-    fetchDependencies?: eFetchDependencies | Promise<apiReturn<iGetC6RestResponse<any>>>[],
+    // 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>>>[],
     debug?: boolean,
     success?: string | ((r: AxiosResponse) => (string | void)),
     error?: string | ((r: AxiosResponse) => (string | void)),
-    blocking?: boolean
 }
 
 interface iCacheAPI<ResponseDataType = any> {
@@ -401,7 +404,7 @@ export default function restApi<
 
     const operatingTableFullName = fullTableList[0];
 
-    const operatingTable = removePrefixIfExists(operatingTableFullName,C6.PREFIX);
+    const operatingTable = removePrefixIfExists(operatingTableFullName, C6.PREFIX);
 
     const tables = fullTableList.join(',')
 
@@ -852,13 +855,14 @@ export default function restApi<
 
                         }
 
-                        if (request.fetchDependencies ??= eFetchDependencies.NONE) {
+                        if ((request.fetchDependencies ??= eFetchDependencies.NONE)
+                            && 'number' === typeof request.fetchDependencies) {
 
                             console.groupCollapsed('%c API: fetchDependencies segment (' + requestMethod + ' ' + tableName + ')', 'color: #0c0')
 
                             const fetchDependencies = async (fetchData: {
                                 [key: string]: iConstraint[]
-                            }) => Object.keys(
+                            }, fetchDependencies: number) => Object.keys(
                                 fetchData
                             ).map((column) => {
 
@@ -876,22 +880,52 @@ export default function restApi<
 
                                 }
 
+
                                 return fetchData[column].map(async (constraint) => {
 
-                                    console.log(column, constraint.TABLE)
+                                    const constraintTableName = constraint.TABLE
+
+                                    if (fetchDependencies & eFetchDependencies.C6ENTITY
+                                        && tableName === "carbon_carbons") {
+
+                                        // 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 (!constraintTableName.endsWith(referencesTable)) {
+
+                                            console.log('%c C6ENTITY: The constraintTableName ('+constraintTableName+') did not end with referencesTable (' + referencesTable + ')', 'color: #c00')
+
+                                            return false;
+
+                                        }
+
+                                        console.log('%c C6ENTITY: The constraintTableName ('+constraintTableName+') ended with referencesTable (' + referencesTable + ')', 'color: #0c0')
+
+                                    }
+
+                                    console.log(column, constraintTableName)
 
                                     const fetchTable = await C6.IMPORT(constraint.TABLE)
 
                                     const RestApi = fetchTable.default
 
-                                    console.log(constraint, fetchTable)
+                                    console.log('Fetch Dependencies will select ('+constraintTableName+') using GET request')
 
+                                    // 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
-                                            [constraint.COLUMN]: responseData.rest[column]
-                                        }
-                                    });
+                                            // todo - using value to avoid joins.... but. maybe this should be a parameterizable option -- think race conditions; its safer to join
+                                            // todo - handle multiple rows returned
+                                            [constraint.COLUMN]: responseData.rest[column] ?? responseData.rest[0][column]
+                                        },
+                                        fetchDependencies: fetchDependencies & eFetchDependencies.RECURSIVE
+                                            || (fetchDependencies & eFetchDependencies.C6ENTITY
+                                                && constraintTableName === "carbon_carbons")
+                                                ? fetchDependencies
+                                                : eFetchDependencies.NONE
+                                    })
 
                                 });
 
@@ -899,43 +933,35 @@ export default function restApi<
 
                             let dependencies: any[] = [];
 
-                            // noinspection FallThroughInSwitchStatementJS
-                            switch (request.fetchDependencies) {
-                                // @ts-ignore
-                                case eFetchDependencies.ALL:
-
-                                    console.log('Fetching all dependencies.')
-
-                                case eFetchDependencies.CHILDREN: // todo - make this a binary flag with more expressive options
-                                // @ts-ignore
-                                case eFetchDependencies.REFERENCED:
+                            // noinspection JSBitwiseOperatorUsage
+                            if (request.fetchDependencies & eFetchDependencies.REFERENCED) {
 
-                                    const referencedBy = C6.TABLES[operatingTable].TABLE_REFERENCED_BY;
+                                const referencedBy = C6.TABLES[operatingTable].TABLE_REFERENCED_BY;
 
-                                    console.log('REFERENCED BY (CHILDREN)', referencedBy)
+                                console.log('REFERENCED BY (CHILDREN)', referencedBy)
 
-                                    dependencies = (await fetchDependencies(referencedBy)).flat(Infinity)
+                                if (Object.keys(referencedBy).length > 0) {
 
-                                    if (request.fetchDependencies !== eFetchDependencies.ALL) {
+                                    dependencies = await fetchDependencies(referencedBy, request.fetchDependencies)
 
-                                        break;
+                                }
 
-                                    }
+                            }
 
-                                case eFetchDependencies.PARENTS:
-                                case eFetchDependencies.REFERENCES:
+                            if (request.fetchDependencies & eFetchDependencies.REFERENCES) {
+                                const references = C6.TABLES[operatingTable].TABLE_REFERENCES;
 
-                                    const references = C6.TABLES[operatingTable].TABLE_REFERENCES;
+                                console.log('REFERENCES (PARENTS)', references)
 
-                                    console.log('REFERENCES (PARENTS)', references)
+                                if (Object.keys(references).length > 0) {
 
-                                    dependencies = [...dependencies, (await fetchDependencies(references)).flat(Infinity)]
+                                    dependencies.push(await fetchDependencies(references, request.fetchDependencies))
 
-                                    break;
-                                default:
-                                    throw new Error('The value of  fetchDependencies (' + request.fetchDependencies?.toString() + ') was not recognized.')
+                                }
                             }
 
+                            dependencies = dependencies.flat(Infinity)
+
                             request.fetchDependencies = dependencies;
 
                             await Promise.all(dependencies)