@carbonorm/carbonnode 3.0.2 → 3.0.4

package/src/api/executors/HttpExecutor.ts

@@ -5,32 +5,131 @@ import isTest from "../../variables/isTest";
 import isVerbose from "../../variables/isVerbose";
 import convertForRequestBody from "../convertForRequestBody";
 import {eFetchDependencies} from "../types/dynamicFetching";
-import {Modify} from "../types/modifyTypes";
-import {apiReturn, DELETE, GET, iCacheAPI, iConstraint, iGetC6RestResponse, POST, PUT, RequestQueryBody} from "../types/ormInterfaces";
-import {removePrefixIfExists, TestRestfulResponse} from "../utils/apiHelpers";
+import {
+    apiReturn,
+    DELETE, DetermineResponseDataType,
+    GET,
+    iCacheAPI,
+    iConstraint,
+    iGetC6RestResponse,
+    iRestMethods,
+    POST,
+    PUT, RequestQueryBody
+} from "../types/ormInterfaces";
+import {removeInvalidKeys, removePrefixIfExists, TestRestfulResponse} from "../utils/apiHelpers";
 import {apiRequestCache, checkCache, userCustomClearCache} from "../utils/cacheManager";
 import {sortAndSerializeQueryObject} from "../utils/sortAndSerializeQueryObject";
 import {Executor} from "./Executor";
-import {toastOptions, toastOptionsDevs } from "variables/toastOptions";
+import {toastOptions, toastOptionsDevs} from "variables/toastOptions";
 
 export class HttpExecutor<
+    RequestMethod extends iRestMethods,
     RestShortTableName extends string = any,
     RestTableInterface extends { [key: string]: any } = any,
     PrimaryKey extends Extract<keyof RestTableInterface, string> = Extract<keyof RestTableInterface, string>,
     CustomAndRequiredFields extends { [key: string]: any } = any,
-    RequestTableOverrides extends { [key: string]: any; } = { [key in keyof RestTableInterface]: any },
-    ResponseDataType = any
+    RequestTableOverrides extends { [key in keyof RestTableInterface]: any } = { [key in keyof RestTableInterface]: any }
 >
     extends Executor<
+        RequestMethod,
         RestShortTableName,
         RestTableInterface,
         PrimaryKey,
         CustomAndRequiredFields,
-        RequestTableOverrides,
-        ResponseDataType
+        RequestTableOverrides
     > {
 
-    public async execute() : Promise<apiReturn<ResponseDataType>> {
+    public putState(
+        response: AxiosResponse<DetermineResponseDataType<RequestMethod, RestTableInterface>>,
+        request: RequestQueryBody<
+            RequestMethod,
+            RestTableInterface,
+            CustomAndRequiredFields,
+            RequestTableOverrides
+        >,
+        callback: () => void
+    ) {
+        this.config.reactBootstrap?.updateRestfulObjectArrays<RestTableInterface>({
+            callback,
+            dataOrCallback: [
+                removeInvalidKeys<RestTableInterface>({
+                    ...request,
+                    ...response?.data?.rest,
+                }, this.config.C6.TABLES)
+            ],
+            stateKey: this.config.restModel.TABLE_NAME,
+            uniqueObjectId: this.config.restModel.PRIMARY_SHORT
+        })
+    }
+
+    public postState(
+        response: AxiosResponse<DetermineResponseDataType<RequestMethod, RestTableInterface>>,
+        request: RequestQueryBody<
+            RequestMethod,
+            RestTableInterface,
+            CustomAndRequiredFields,
+            RequestTableOverrides
+        >,
+        callback: () => void
+    ) {
+
+        if (1 !== this.config.restModel.PRIMARY_SHORT.length) {
+
+            console.error("C6 received unexpected result's given the primary key length");
+
+        } else {
+
+            const pk = this.config.restModel.PRIMARY_SHORT[0];
+
+            // TODO - should overrides be handled differently? Why override: (react/php), driver missmatches, aux data..
+            // @ts-ignore - this is technically a correct error, but we allow it anyway...
+            request[pk] = response.data?.created as RestTableInterface[PrimaryKey]
+
+        }
+
+        this.config.reactBootstrap?.updateRestfulObjectArrays<RestTableInterface>({
+            callback,
+            dataOrCallback: undefined !== request.dataInsertMultipleRows
+                ? request.dataInsertMultipleRows.map((request, index) => {
+                    return removeInvalidKeys<RestTableInterface>({
+                        ...request,
+                        ...(index === 0 ? response?.data?.rest : {}),
+                    }, this.config.C6.TABLES)
+                })
+                : [
+                    removeInvalidKeys<RestTableInterface>({
+                        ...request,
+                        ...response?.data?.rest,
+                    }, this.config.C6.TABLES)
+                ],
+            stateKey: this.config.restModel.TABLE_NAME,
+            uniqueObjectId: this.config.restModel.PRIMARY_SHORT as (keyof RestTableInterface)[]
+        })
+    }
+
+    public deleteState(
+        _response: AxiosResponse<DetermineResponseDataType<RequestMethod, RestTableInterface>>,
+        request: RequestQueryBody<
+            RequestMethod,
+            RestTableInterface,
+            CustomAndRequiredFields,
+            RequestTableOverrides
+        >,
+        callback: () => void
+    ) {
+        this.config.reactBootstrap?.deleteRestfulObjectArrays<RestTableInterface>({
+            callback,
+            dataOrCallback: [
+                request as unknown as RestTableInterface,
+            ],
+            stateKey: this.config.restModel.TABLE_NAME,
+            uniqueObjectId: this.config.restModel.PRIMARY_SHORT as (keyof RestTableInterface)[]
+        })
+    }
+
+    public async execute(): Promise<apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>> {
+
+        type ResponseDataType = DetermineResponseDataType<RequestMethod, RestTableInterface>;
 
         const {
             C6,
@@ -38,13 +137,20 @@ export class HttpExecutor<
             restURL,
             withCredentials,
             restModel,
+            reactBootstrap,
             requestMethod,
-            queryCallback,
-            responseCallback,
             skipPrimaryCheck,
             clearCache,
         } = this.config
 
+
+        await this.runLifecycleHooks<"beforeProcessing">(
+            "beforeProcessing", {
+                config: this.config,
+                request: this.request,
+            });
+
+
         const tableName = restModel.TABLE_NAME;
 
         const fullTableList = Array.isArray(tableName) ? tableName : [tableName];
@@ -79,27 +185,9 @@ export class HttpExecutor<
 
         // an undefined query would indicate queryCallback returned undefined,
         // thus the request shouldn't fire as is in custom cache
-        let query: RequestQueryBody<Modify<RestTableInterface, RequestTableOverrides>> | undefined | null;
-
-        if ('function' === typeof queryCallback) {
-
-            query = queryCallback(this.request); // obj or obj[]
-
-        } else {
-
-            query = queryCallback;
-
-        }
-
-        if (undefined === query || null === query) {
+        if (undefined === this.request || null === this.request) {
 
-            if (this.request.debug && isLocal) {
-
-                toast.warning("DEV: queryCallback returned undefined, signaling in Custom Cache. (returning null)", toastOptionsDevs)
-
-            }
-
-            console.groupCollapsed('%c API: (' + requestMethod + ') Request Query for (' + tableName + ') undefined, returning null (will not fire ajax)!', 'color: #c00')
+            console.groupCollapsed('%c API: (' + requestMethod + ') Request Query for (' + tableName + ') undefined, returning null (will not fire)!', 'color: #c00')
 
             console.log('%c Returning (undefined|null) for a query would indicate a custom cache hit (outside API.tsx), thus the request should not fire.', 'color: #c00')
 
@@ -111,6 +199,8 @@ export class HttpExecutor<
 
         }
 
+        let query = this.request;
+
         if (C6.GET === requestMethod) {
 
             if (undefined === query[C6.PAGINATION]) {
@@ -126,7 +216,7 @@ export class HttpExecutor<
         }
 
         // this could return itself with a new page number, or undefined if the end is reached
-        const apiRequest = async (): Promise<apiReturn<ResponseDataType>> => {
+        const apiRequest = async (): Promise<apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>> => {
 
             const {
                 debug,
@@ -134,7 +224,7 @@ export class HttpExecutor<
                 dataInsertMultipleRows,
                 success,
                 fetchDependencies = eFetchDependencies.NONE,
-                error =  "An unexpected API error occurred!"
+                error = "An unexpected API error occurred!"
             } = this.request
 
             if (C6.GET === requestMethod
@@ -168,7 +258,12 @@ export class HttpExecutor<
 
                     if (undefined === query || null === query) {
 
-                        query = {}
+                        query = {} as RequestQueryBody<
+                            RequestMethod,
+                            RestTableInterface,
+                            CustomAndRequiredFields,
+                            RequestTableOverrides
+                        >
 
                     }
 
@@ -329,8 +424,13 @@ export class HttpExecutor<
                 const removedPkValue = query[primaryKey];
 
                 addBackPK = () => {
-                    query ??= {}
-                    query[primaryKey] = removedPkValue
+                    query ??= {} as RequestQueryBody<
+                        RequestMethod,
+                        RestTableInterface,
+                        CustomAndRequiredFields,
+                        RequestTableOverrides
+                    >;
+                    query[primaryKey] = removedPkValue;
                 }
 
                 delete query[primaryKey]
@@ -357,64 +457,64 @@ export class HttpExecutor<
 
                 console.groupEnd()
 
+                this.runLifecycleHooks<"beforeExecution">(
+                    "beforeExecution", {
+                        config: this.config,
+                        request: this.request
+                    })
+
                 const axiosActiveRequest: AxiosPromise<ResponseDataType> = axios![requestMethod.toLowerCase()]<ResponseDataType>(
                     restRequestUri,
-                    ...((() => {
-
-                        // @link - https://axios-http.com/docs/instance
-                        // How configuration vs data is passed is variable, use documentation above for reference
-                        if (requestMethod === GET) {
-
-                            return [{
-                                withCredentials: withCredentials,
-                                params: query
-                            }]
-
-                        } else if (requestMethod === POST) {
-
-                            if (undefined !== dataInsertMultipleRows) {
-
-                                return [
-                                    dataInsertMultipleRows.map(data =>
-                                        convertForRequestBody<typeof data>(data, fullTableList, C6, (message) => toast.error(message, toastOptions))),
-                                    {
-                                        withCredentials: withCredentials,
-                                    }
-                                ]
-
-                            }
-
-                            return [
-                                convertForRequestBody<RestTableInterface>(query as RestTableInterface, fullTableList, C6, (message) => toast.error(message, toastOptions)),
-                                {
-                                    withCredentials: withCredentials,
+                    ...(() => {
+                        const convert = (data: any) =>
+                            convertForRequestBody<
+                                RequestMethod,
+                                RestTableInterface,
+                                CustomAndRequiredFields,
+                                RequestTableOverrides
+                            >(
+                                data,
+                                fullTableList,
+                                C6,
+                                (message) => toast.error(message, toastOptions)
+                            );
+
+                        const baseConfig = {
+                            withCredentials: withCredentials,
+                        };
+
+                        switch (requestMethod) {
+                            case GET:
+                                return [{
+                                    ...baseConfig,
+                                    params: query
+                                }];
+
+                            case POST:
+                                if (dataInsertMultipleRows !== undefined) {
+                                    return [
+                                        dataInsertMultipleRows.map(convert),
+                                        baseConfig
+                                    ];
                                 }
-                            ]
+                                return [convert(query), baseConfig];
 
-                        } else if (requestMethod === PUT) {
-
-                            return [
-                                convertForRequestBody<RestTableInterface>(query as RestTableInterface, fullTableList, C6, (message) => toast.error(message, toastOptions)),
-                                {
-                                    withCredentials: withCredentials,
-                                }
-                            ]
-                        } else if (requestMethod === DELETE) {
-
-                            return [{
-                                withCredentials: withCredentials,
-                                data: convertForRequestBody<RestTableInterface>(query as RestTableInterface, fullTableList, C6, (message) => toast.error(message, toastOptions))
-                            }]
-
-                        } else {
+                            case PUT:
+                                return [convert(query), baseConfig];
 
-                            throw new Error('The request method (' + requestMethod + ') was not recognized.')
+                            case DELETE:
+                                return [{
+                                    ...baseConfig,
+                                    data: convert(query)
+                                }];
 
+                            default:
+                                throw new Error(`The request method (${requestMethod}) was not recognized.`);
                         }
-
-                    })())
+                    })()
                 );
 
+
                 if (cachingConfirmed) {
 
                     // push to cache so we do not repeat the request
@@ -431,8 +531,9 @@ export class HttpExecutor<
 
                 // 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): Promise<AxiosResponse<ResponseDataType, any>> => {
+                return axiosActiveRequest.then(async (response: AxiosResponse<ResponseDataType, any>): Promise<AxiosResponse<ResponseDataType, any>> => {
 
+                        // noinspection SuspiciousTypeOfGuard
                         if (typeof response.data === 'string') {
 
                             if (isTest) {
@@ -458,6 +559,14 @@ export class HttpExecutor<
 
                         }
 
+                        this.runLifecycleHooks<"afterExecution">(
+                            "afterExecution", {
+                                config: this.config,
+                                request: this.request,
+                                response
+                            })
+
+                        // todo - this feels dumb now, but i digress
                         apiResponse = TestRestfulResponse(response, success, error)
 
                         if (false === apiResponse) {
@@ -472,11 +581,36 @@ export class HttpExecutor<
 
                         }
 
-                        // stateful operations are done in the response callback - its leverages rest generated functions
-                        if (responseCallback) {
-
-                            responseCallback(response, this.request, apiResponse)
 
+                        const callback = () => this.runLifecycleHooks<"afterCommit">(
+                            "afterCommit", {
+                                config: this.config,
+                                request: this.request,
+                                response
+                            });
+
+                        if (undefined !== reactBootstrap && response) {
+                            switch (requestMethod) {
+                                case GET:
+                                    reactBootstrap.updateRestfulObjectArrays<RestTableInterface>({
+                                        dataOrCallback: Array.isArray(response.data.rest) ? response.data.rest : [response.data.rest],
+                                        stateKey: this.config.restModel.TABLE_NAME,
+                                        uniqueObjectId: this.config.restModel.PRIMARY_SHORT as (keyof RestTableInterface)[],
+                                        callback
+                                    })
+                                    break;
+                                case POST:
+                                    this.postState(response, this.request, callback);
+                                    break;
+                                case PUT:
+                                    this.putState(response, this.request, callback);
+                                    break;
+                                case DELETE:
+                                    this.deleteState(response, this.request, callback);
+                                    break;
+                            }
+                        } else {
+                            callback();
                         }
 
                         if (C6.GET === requestMethod) {

package/src/api/executors/SqlExecutor.ts

@@ -1,27 +1,27 @@
-import {apiReturn} from "@carbonorm/carbonnode";
+import {iRestMethods} from "@carbonorm/carbonnode";
 import { PoolConnection, RowDataPacket } from 'mysql2/promise';
 import {buildSelectQuery} from "../builders/sqlBuilder";
 import {Executor} from "./Executor";
 
 
 export class SqlExecutor<
+    RequestMethod extends iRestMethods,
     RestShortTableName extends string = any,
     RestTableInterface extends { [key: string]: any } = any,
     PrimaryKey extends Extract<keyof RestTableInterface, string> = Extract<keyof RestTableInterface, string>,
     CustomAndRequiredFields extends { [key: string]: any } = any,
-    RequestTableOverrides extends { [key: string]: any; } = { [key in keyof RestTableInterface]: any },
-    ResponseDataType = any
+    RequestTableOverrides extends { [key in keyof RestTableInterface]: any } = { [key in keyof RestTableInterface]: any }
 >
     extends Executor<
+        RequestMethod,
         RestShortTableName,
         RestTableInterface,
         PrimaryKey,
         CustomAndRequiredFields,
-        RequestTableOverrides,
-        ResponseDataType
+        RequestTableOverrides
     > {
 
-    public execute():  Promise<apiReturn<ResponseDataType>> {
+    public execute() {
         switch (this.config.requestMethod) {
             case 'GET':
                 return (this.select(

package/src/api/restOrm.ts

@@ -0,0 +1,61 @@
+import restRequest from "./restRequest";
+import {iRest} from "./types/ormInterfaces";
+
+export function restOrm<
+    RestShortTableName extends string = any,
+    RestTableInterface extends { [key: string]: any } = any,
+    PrimaryKey extends Extract<keyof RestTableInterface, string> = Extract<keyof RestTableInterface, string>,
+    CustomAndRequiredFields extends { [key: string]: any } = any,
+    RequestTableOverrides extends { [key in keyof RestTableInterface]: any } = { [key in keyof RestTableInterface]: any }
+>(config: Omit<iRest<
+    RestShortTableName,
+    RestTableInterface,
+    PrimaryKey
+>, "requestMethod">) {
+    return {
+        Get: restRequest<
+            "GET",
+            RestShortTableName,
+            RestTableInterface,
+            PrimaryKey,
+            CustomAndRequiredFields,
+            RequestTableOverrides
+        >({
+            ...config,
+            requestMethod: "GET",
+        }),
+        Put: restRequest<
+            "PUT",
+            RestShortTableName,
+            RestTableInterface,
+            PrimaryKey,
+            CustomAndRequiredFields,
+            RequestTableOverrides
+        >({
+            ...config,
+            requestMethod: "PUT",
+        }),
+        Post: restRequest<
+            "POST",
+            RestShortTableName,
+            RestTableInterface,
+            PrimaryKey,
+            CustomAndRequiredFields,
+            RequestTableOverrides
+        >({
+                ...config,
+                requestMethod: "POST",
+            }),
+        Delete: restRequest<
+            "DELETE",
+            RestShortTableName,
+            RestTableInterface,
+            PrimaryKey,
+            CustomAndRequiredFields,
+            RequestTableOverrides
+        >({
+            ...config,
+            requestMethod: "DELETE",
+        }),
+    }
+}

package/src/api/restRequest.ts

@@ -1,41 +1,45 @@
 import isNode from '../variables/isNode';
-import {Modify} from "./types/modifyTypes";
-import {apiReturn, iAPI, iRest} from "./types/ormInterfaces";
+import {
+    apiReturn, DetermineResponseDataType,
+    iRest, iRestMethods, RequestQueryBody
+} from "./types/ormInterfaces";
 
 /**
  * Facade: routes API calls to SQL or HTTP executors based on runtime context.
  */
 export default function restRequest<
+    RequestMethod extends iRestMethods,
     RestShortTableName extends string = any,
     RestTableInterface extends { [key: string]: any } = any,
     PrimaryKey extends Extract<keyof RestTableInterface, string> = Extract<keyof RestTableInterface, string>,
     CustomAndRequiredFields extends { [key: string]: any } = any,
-    RequestTableOverrides extends { [key: string]: any } = { [key in keyof RestTableInterface]: any },
-    ResponseDataType = any
+    RequestTableOverrides extends { [key in keyof RestTableInterface]: any } = { [key in keyof RestTableInterface]: any }
 >(
     config: iRest<
         RestShortTableName,
         RestTableInterface,
-        PrimaryKey,
-        CustomAndRequiredFields,
-        RequestTableOverrides,
-        ResponseDataType
+        PrimaryKey
     >
 ) {
     return async (
-        request: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields = {} as iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields
-    ): Promise<apiReturn<ResponseDataType>> => {
+        request: RequestQueryBody<
+            RequestMethod,
+            RestTableInterface,
+            CustomAndRequiredFields,
+            RequestTableOverrides
+        >,
+    ): Promise<apiReturn<DetermineResponseDataType<RequestMethod, RestTableInterface>>> => {
 
         // SQL path if on Node with a provided pool
         if (isNode && config.mysqlPool) {
             const {SqlExecutor} = await import('./executors/SqlExecutor');
             const executor = new SqlExecutor<
+                RequestMethod,
                 RestShortTableName,
                 RestTableInterface,
                 PrimaryKey,
                 CustomAndRequiredFields,
-                RequestTableOverrides,
-                ResponseDataType
+                RequestTableOverrides
             >(config, request);
             return executor.execute();
         }
@@ -43,13 +47,14 @@ export default function restRequest<
         // HTTP path fallback
         const {HttpExecutor} = await import('./executors/HttpExecutor');
         const http = new HttpExecutor<
+            RequestMethod,
             RestShortTableName,
             RestTableInterface,
             PrimaryKey,
             CustomAndRequiredFields,
-            RequestTableOverrides,
-            ResponseDataType
+            RequestTableOverrides
         >(config, request);
         return http.execute();
     };
 }
+