@carbonorm/carbonnode 3.0.1 → 3.0.3

package/src/api/executors/HttpExecutor.ts

@@ -6,43 +6,140 @@ 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<
-    CustomAndRequiredFields extends { [key: string]: any },           // CustomAndRequiredFields
-    RestTableInterfaces extends  { [key: string]: any },            // RestTableInterfaces
-    RequestTableOverrides = { [key in keyof RestTableInterfaces]: any },   // RequestTableOverrides
-    ResponseDataType = any,                // ResponseDataType
-    RestShortTableNames extends string = ""    // RestShortTableNames
+    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 in keyof RestTableInterface]: any } = { [key in keyof RestTableInterface]: any }
 >
     extends Executor<
+        RequestMethod,
+        RestShortTableName,
+        RestTableInterface,
+        PrimaryKey,
         CustomAndRequiredFields,
-        RestTableInterfaces,
-        RequestTableOverrides,
-        ResponseDataType,
-        RestShortTableNames
+        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,
             axios,
             restURL,
             withCredentials,
-            tableName,
+            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];
 
         const operatingTableFullName = fullTableList[0];
@@ -75,17 +172,7 @@ 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<RestTableInterfaces, RequestTableOverrides>> | undefined | null;
-
-        if ('function' === typeof queryCallback) {
-
-            query = queryCallback(this.request); // obj or obj[]
-
-        } else {
-
-            query = queryCallback;
-
-        }
+        let query: RequestQueryBody<Modify<RestTableInterface, RequestTableOverrides>> | undefined | null;
 
         if (undefined === query || null === query) {
 
@@ -122,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,
@@ -130,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
@@ -250,7 +337,7 @@ export class HttpExecutor<
 
             let addBackPK: (() => void) | undefined;
 
-            let apiResponse: string | boolean | number | undefined;
+            let apiResponse: RestTableInterface[PrimaryKey] | string | boolean | number | undefined;
 
             let returnGetNextPageFunction = false;
 
@@ -353,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,
                     ...((() => {
@@ -381,7 +474,7 @@ export class HttpExecutor<
                             }
 
                             return [
-                                convertForRequestBody<RestTableInterfaces>(query as RestTableInterfaces, fullTableList, C6, (message) => toast.error(message, toastOptions)),
+                                convertForRequestBody<RestTableInterface>(query as RestTableInterface, fullTableList, C6, (message) => toast.error(message, toastOptions)),
                                 {
                                     withCredentials: withCredentials,
                                 }
@@ -390,7 +483,7 @@ export class HttpExecutor<
                         } else if (requestMethod === PUT) {
 
                             return [
-                                convertForRequestBody<RestTableInterfaces>(query as RestTableInterfaces, fullTableList, C6, (message) => toast.error(message, toastOptions)),
+                                convertForRequestBody<RestTableInterface>(query as RestTableInterface, fullTableList, C6, (message) => toast.error(message, toastOptions)),
                                 {
                                     withCredentials: withCredentials,
                                 }
@@ -399,7 +492,7 @@ export class HttpExecutor<
 
                             return [{
                                 withCredentials: withCredentials,
-                                data: convertForRequestBody<RestTableInterfaces>(query as RestTableInterfaces, fullTableList, C6, (message) => toast.error(message, toastOptions))
+                                data: convertForRequestBody<RestTableInterface>(query as RestTableInterface, fullTableList, C6, (message) => toast.error(message, toastOptions))
                             }]
 
                         } else {
@@ -427,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) {
@@ -454,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) {
@@ -468,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,26 +1,40 @@
-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<CustomAndRequiredFields extends object, RestTableInterfaces extends object, RequestTableOverrides extends object, ResponseDataType, RestShortTableNames extends string>
-    extends Executor<CustomAndRequiredFields, RestTableInterfaces, RequestTableOverrides, ResponseDataType, RestShortTableNames> {
-
-    public execute():  Promise<apiReturn<ResponseDataType>> {
+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 in keyof RestTableInterface]: any } = { [key in keyof RestTableInterface]: any }
+>
+    extends Executor<
+        RequestMethod,
+        RestShortTableName,
+        RestTableInterface,
+        PrimaryKey,
+        CustomAndRequiredFields,
+        RequestTableOverrides
+    > {
+
+    public execute() {
         switch (this.config.requestMethod) {
             case 'GET':
                 return (this.select(
-                    this.config.tableName as RestShortTableNames,
+                    this.config.restModel.TABLE_NAME,
                     undefined,
                     this.request
                 ) as Promise<any>).then(rows => ({rest: rows})) as any;
             case 'POST':
-                return this.insert(this.config.tableName as RestShortTableNames, this.request) as any;
+                return this.insert(this.config.restModel.TABLE_NAME, this.request) as any;
             case 'PUT':
-                return this.update(this.config.tableName as RestShortTableNames, undefined, this.request) as any;
+                return this.update(this.config.restModel.TABLE_NAME, undefined, this.request) as any;
             case 'DELETE':
-                return this.delete(this.config.tableName as RestShortTableNames, undefined, this.request) as any;
+                return this.delete(this.config.restModel.TABLE_NAME, undefined, this.request) as any;
         }
     }
 

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);
+    }
+});