@carbonorm/carbonnode 3.0.2 → 3.0.3

package/src/api/executors/HttpExecutor.ts

@@ -6,31 +6,117 @@ 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, iAPI,
+    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: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields,
+        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: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields,
+        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: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields,
+        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 +124,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];
@@ -81,16 +174,6 @@ export class HttpExecutor<
         // 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 (this.request.debug && isLocal) {
@@ -126,7 +209,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 +217,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
@@ -357,6 +440,12 @@ export class HttpExecutor<
 
                 console.groupEnd()
 
+                this.runLifecycleHooks<"beforeExecution">(
+                    "beforeExecution", {
+                        config: this.config,
+                        request: this.request
+                    })
+
                 const axiosActiveRequest: AxiosPromise<ResponseDataType> = axios![requestMethod.toLowerCase()]<ResponseDataType>(
                     restRequestUri,
                     ...((() => {
@@ -431,8 +520,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 +548,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 +570,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/rest/C6.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, test } from '@jest/globals';
+import { checkAllRequestsComplete } from '@carbonorm/carbonnode';
+import { act, waitFor } from '@testing-library/react';
+import { C6 } from "./C6";
+
+const fillString = () => Math.random().toString(36).substring(2, 12);
+const fillNumber = () => Math.floor(Math.random() * 1000000);
+
+const RESERVED_COLUMNS = ['created_at', 'updated_at', 'deleted_at'];
+
+function buildTestData(tableModel: any): Record<string, any> {
+    const data: Record<string, any> = {};
+    const validation = tableModel.TYPE_VALIDATION;
+
+    for (const col of Object.keys(validation)) {
+        const { MYSQL_TYPE, SKIP_COLUMN_IN_POST, MAX_LENGTH } = validation[col];
+
+        if (SKIP_COLUMN_IN_POST || RESERVED_COLUMNS.includes(col)) continue;
+
+        if (MYSQL_TYPE.startsWith('varchar') || MYSQL_TYPE === 'text') {
+            let str = fillString();
+            if (MAX_LENGTH) str = str.substring(0, MAX_LENGTH);
+            data[col] = str;
+        } else if (MYSQL_TYPE.includes('int') || MYSQL_TYPE === 'decimal') {
+            data[col] = fillNumber();
+        } else if (MYSQL_TYPE === 'json') {
+            data[col] = {};
+        } else if (MYSQL_TYPE === 'tinyint(1)') {
+            data[col] = 1;
+        } else {
+            data[col] = null;
+        }
+    }
+
+    return data;
+}
+
+describe('CarbonORM table API integration tests', () => {
+    for (const [shortName, tableModel] of Object.entries(C6.TABLES)) {
+        const primaryKeys: string[] = tableModel.PRIMARY_SHORT;
+
+        // Get restOrm binding
+        const restBinding = (C6 as any)[shortName[0].toUpperCase() + shortName.slice(1)];
+        if (!restBinding) continue;
+
+        test(`[${shortName}] GET → POST → GET → PUT → DELETE`, async () => {
+
+            const testData = buildTestData(tableModel);
+
+            await act(async () => {
+
+                // GET all
+                const all = await restBinding.Get({});
+                expect(all?.data?.rest).toBeDefined();
+
+                // POST one
+                const post = await restBinding.Post(testData);
+                expect(post?.data?.created).toBeDefined();
+
+                const postID = post?.data?.created;
+                const pkName = primaryKeys[0];
+                testData[pkName] = postID;
+
+                // GET single
+                const select = await restBinding.Get({
+                    [C6.WHERE]: {
+                        [tableModel[pkName.toUpperCase()]]: postID
+                    }
+                });
+
+                expect(select?.data?.rest?.[0]?.[pkName]).toEqual(postID);
+
+                // PUT update
+                const updated = await restBinding.Put(testData);
+                expect(updated?.data?.updated).toBeDefined();
+
+                // DELETE
+                const deleted = await restBinding.Delete({ [pkName]: postID });
+                expect(deleted?.data?.deleted).toBeDefined();
+
+                // Wait for all requests to settle
+                await waitFor(() => {
+                    expect(checkAllRequestsComplete()).toEqual(true);
+                 }, { timeout: 10000, interval: 1000 });
+            });
+        }, 100000);
+    }
+});