@carbonorm/carbonnode 3.0.2 → 3.0.3

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,42 @@
 import isNode from '../variables/isNode';
 import {Modify} from "./types/modifyTypes";
-import {apiReturn, iAPI, iRest} from "./types/ormInterfaces";
+import {
+    apiReturn, DetermineResponseDataType,
+    iAPI,
+    iRest, iRestMethods
+} 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>> => {
+    ): 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 +44,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();
     };
 }
+

package/src/api/types/ormInterfaces.ts

@@ -3,6 +3,7 @@ import {Pool} from "mysql2/promise";
 import {eFetchDependencies} from "./dynamicFetching";
 import {Modify} from "./modifyTypes";
 import {JoinType, OrderDirection, SQLComparisonOperator, SQLFunction} from "./mysqlTypes";
+import {CarbonReact} from "@carbonorm/carbonreact";
 
 export interface stringMap {
     [key: string]: string;
@@ -27,13 +28,80 @@ export interface iTypeValidation {
     SKIP_COLUMN_IN_POST: boolean
 }
 
-export type iRestReactiveLifecycle<T extends RequestGetPutDeleteBody> = {
-    beforeProcessing?: (args: { request: T[]; requestMeta?: any }) => void | Promise<void>;
-    beforeExecution?: (args: { request: T[]; requestMeta?: any }) => void | Promise<void>;
-    afterExecution?: (args: { response: T[]; request: T[]; responseMeta?: any }) => void | Promise<void>;
-    afterCommit?: (args: { response: T[]; request: T[]; responseMeta?: any }) => void | Promise<void>;
+
+// config, request, response
+export type iRestReactiveLifecycle<
+    RequestMethod extends iRestMethods,
+    RestShortTableName extends string = any,
+    RestTableInterface extends { [key: string]: any } = any,
+    PrimaryKey extends keyof RestTableInterface & string = any,
+    // TODO - do we ever use these last two ever? should we make usage just any?
+    CustomAndRequiredFields extends { [key: string]: any } = any,
+    RequestTableOverrides extends { [key: string]: any } = { [key in keyof RestTableInterface]: any }
+> = {
+    beforeProcessing?: {
+        [key: string]: (args: {
+            config: iRest<
+                RestShortTableName,
+                RestTableInterface,
+                PrimaryKey
+            >,
+            request: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields;
+        }) => void | Promise<void>
+    },
+    beforeExecution?:
+        {
+            [key: string]: (args: {
+                config: iRest<
+                    RestShortTableName,
+                    RestTableInterface,
+                    PrimaryKey
+                >,
+                request: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields
+            }) => void | Promise<void>
+        };
+    afterExecution?:
+        {
+            [key: string]: (args: {
+                config: iRest<
+                    RestShortTableName,
+                    RestTableInterface,
+                    PrimaryKey
+                >,
+                request: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields;
+                response: AxiosResponse<DetermineResponseDataType<RequestMethod, RestTableInterface>>;
+            }) => void | Promise<void>
+        };
+    afterCommit?: {
+        [key: string]: (args: {
+            config: iRest<
+                RestShortTableName,
+                RestTableInterface,
+                PrimaryKey
+            >,
+            request: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields;
+            response: AxiosResponse<DetermineResponseDataType<RequestMethod, RestTableInterface>>;
+        }) => void | Promise<void>
+    };
 };
 
+export type iRestHooks<
+    RestShortTableName extends string = any,
+    RestTableInterface extends { [key: string]: any } = any,
+    PrimaryKey extends keyof RestTableInterface & string = any,
+    CustomAndRequiredFields extends { [key: string]: any } = any,
+    RequestTableOverrides extends { [key: string]: any } = { [key in keyof RestTableInterface]: any }
+> = {
+    [Method in iRestMethods]: iRestReactiveLifecycle<
+        Method,
+        RestShortTableName,
+        RestTableInterface,
+        PrimaryKey,
+        CustomAndRequiredFields,
+        RequestTableOverrides
+    >
+}
+
 export interface iConstraint {
     TABLE: string,
     COLUMN: string,
@@ -64,7 +132,8 @@ export interface iC6RestfulModel<
     COLUMNS: tColumns<RestShortTableNames, RestTableInterfaces>;
     TYPE_VALIDATION: { [key: string]: iTypeValidation };
     REGEX_VALIDATION: RegExpMap;
-    LIFECYCLE_HOOKS: iRestReactiveLifecycle<RequestGetPutDeleteBody>[];
+    // TODO - I thon think theres a good way to infer the last two generics (overides)
+    LIFECYCLE_HOOKS: iRestHooks<RestShortTableNames, RestTableInterfaces, PK>;
     TABLE_REFERENCES: { [columnName: string]: iConstraint[] };
     TABLE_REFERENCED_BY: { [columnName: string]: iConstraint[] };
 }
@@ -278,13 +347,23 @@ export type apiReturn<Response> =
     | (Response extends iPutC6RestResponse | iDeleteC6RestResponse | iPostC6RestResponse ? null : (() => apiReturn<Response>))
 
 
+export type DetermineResponseDataType<
+    RequestMethod extends iRestMethods,
+    RestTableInterface extends { [key: string]: any }
+> = RequestMethod extends "POST"
+    ? iPostC6RestResponse<RestTableInterface>
+    : RequestMethod extends "GET"
+        ? iGetC6RestResponse<RestTableInterface>
+        : RequestMethod extends "PUT"
+            ? iPutC6RestResponse<RestTableInterface>
+            : RequestMethod extends "DELETE"
+                ? iDeleteC6RestResponse<RestTableInterface>
+                : any;
+
 export interface iRest<
     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 = { [key in keyof RestTableInterface]: any },
-    ResponseDataType = any
+    PrimaryKey extends keyof RestTableInterface & string = any
 > {
     C6: iC6Object,
     axios?: AxiosInstance,
@@ -292,18 +371,22 @@ export interface iRest<
     mysqlPool?: Pool;
     withCredentials?: boolean,
     restModel: iC6RestfulModel<RestShortTableName, RestTableInterface, PrimaryKey>,
+    reactBootstrap?: CarbonReact<any, any>,
     requestMethod: iRestMethods,
     clearCache?: () => void,
     skipPrimaryCheck?: boolean,
-    queryCallback: RequestQueryBody<Modify<RestTableInterface, RequestTableOverrides>> | ((request: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields) => (null | undefined | RequestQueryBody<Modify<RestTableInterface, RequestTableOverrides>>)),
-    responseCallback?: (response: AxiosResponse<ResponseDataType>,
-                        request: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields,
-                        success: (ResponseDataType extends iPutC6RestResponse | iDeleteC6RestResponse
-                                ? RequestQueryBody<Modify<RestTableInterface, RequestTableOverrides>>
-                                : string)
-                            | RestTableInterface[PrimaryKey]     // Rest PK
-                            | string | number | boolean                 // Toast and validations
-    ) => any // keep this set to any, it allows easy arrow functions and the results unused here
+    /*    queryCallback: RequestQueryBody<Modify<RestTableInterface, RequestTableOverrides>> | ((request: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields) => (null | undefined | RequestQueryBody<Modify<RestTableInterface, RequestTableOverrides>>)),
+        responseCallback?: (
+            response: AxiosResponse<DetermineResponseDataType<RequestMethod, RestTableInterface>>,
+            request: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields,
+            success: (
+                    // TODO - make sure this makes sense, or re-implement with the hooks model
+                    DetermineResponseDataType<RequestMethod, RestTableInterface> extends iPutC6RestResponse | iDeleteC6RestResponse
+                        ? RequestQueryBody<Modify<RestTableInterface, RequestTableOverrides>>
+                        : string)
+                | RestTableInterface[PrimaryKey]     // Rest PK
+                | string | number | boolean                 // Toast and validations
+        ) => (RestTableInterface | RestTableInterface[] | void) // keep this set to any, it allows easy arrow functions and the results unused here*/
 }
 
 

package/src/api/utils/apiHelpers.ts

@@ -5,6 +5,10 @@ import { AxiosResponse } from "axios";
 import {toastOptions} from "../../variables/toastOptions";
 import {iC6RestfulModel} from "../types/ormInterfaces";
 
+
+
+
+
 export function TestRestfulResponse(response: AxiosResponse | any, success: ((r: AxiosResponse) => (string | void)) | string | undefined, error: ((r: AxiosResponse) => (string | void)) | string | undefined): string | boolean | number {
 
     if (undefined === response.data?.['ERROR TYPE']

package/src/index.ts

@@ -7,6 +7,7 @@ export { default as axiosInstance } from "./api/axiosInstance";
 export * from "./api/axiosInstance";
 export { default as convertForRequestBody } from "./api/convertForRequestBody";
 export * from "./api/convertForRequestBody";
+export * from "./api/restOrm";
 export { default as restRequest } from "./api/restRequest";
 export * from "./api/restRequest";
 export { default as timeout } from "./api/timeout";

package/scripts/assets/handlebars/Table.test.ts.handlebars

@@ -1,126 +0,0 @@
-import {xdescribe, expect, test} from '@jest/globals';
-import {checkAllRequestsComplete} from "@carbonorm/carbonnode";
-import {act, waitFor} from '@testing-library/react';
-import {C6, i{{TABLE_NAME_SHORT_PASCAL_CASE}}, {{TABLE_NAME_SHORT}} } from "{{RELATIVE_OUTPUT_DIR}}/C6";
-import {{TABLE_NAME_SHORT_PASCAL_CASE}} from "./{{TABLE_NAME_SHORT_PASCAL_CASE}}";{{#if REACT_IMPORT}}
-{{{REACT_IMPORT}}};{{/if}}
-
-const randomString = Math.random().toString(36).substring(7);
-const randomInt = Math.floor(Math.random() * 1000000);
-const fillString = 'string' + randomString + randomInt;
-
-console.log('fillString', fillString);
-
-/**
-{{{TABLE_DEFINITION}}}
-**/
-
-const Test_Data: i{{TABLE_NAME_SHORT_PASCAL_CASE}} = {
-{{#each TYPE_VALIDATION}}{{#SKIP_COLUMN_IN_POST}}
-    {{COLUMN_NAME}}: {{#TYPESCRIPT_TYPE_IS_STRING}}fillString{{#MAX_LENGTH}}.substring(0, {{MAX_LENGTH}}){{/MAX_LENGTH}}{{/TYPESCRIPT_TYPE_IS_STRING}}{{#TYPESCRIPT_TYPE_IS_NUMBER}}randomInt{{/TYPESCRIPT_TYPE_IS_NUMBER}},
-{{/SKIP_COLUMN_IN_POST}}{{/each}}
-}
-
-export default Test_Data;
-
-xdescribe('REST {{TABLE_NAME_SHORT_PASCAL_CASE}} api', () => {
-
-    let testData = Test_Data;
-
-    test('GET POST PUT DELETE', async () => {
-
-        await act(async () => {
-
-            let selectAllResponse = await {{TABLE_NAME_SHORT_PASCAL_CASE}}.Get({})
-
-            if ('function' === typeof selectAllResponse) {
-                throw Error('selectAllResponse is a promise, this typically means this specific get request has already run during test setup.');
-            }
-
-            // We don't care if it is filled or not, just that the request can be made.
-            expect(selectAllResponse?.data?.rest).not.toBeUndefined();
-
-            const postResponse = await {{TABLE_NAME_SHORT_PASCAL_CASE}}.Post(testData);
-
-            console.log('postResponse', postResponse?.data)
-
-            expect(postResponse?.data?.created).not.toBeUndefined();
-
-            const primaryKey = {{TABLE_NAME_SHORT}}.PRIMARY_SHORT[0];
-
-            const postID = postResponse?.data?.created
-
-            const singleRowSelect = await {{TABLE_NAME_SHORT_PASCAL_CASE}}.Get({
-                [C6.WHERE]: {
-                    [{{TABLE_NAME_SHORT}}[primaryKey.toUpperCase()]]: postID,
-                }
-            })
-
-            if ('function' === typeof singleRowSelect) {
-                throw Error('singleRowSelect is a promise, this is unexpected.');
-            }
-
-            console.log('singleRowSelect', singleRowSelect?.data)
-
-            // Ensure the expected response datastructure is returned
-            expect(singleRowSelect?.data?.rest).not.toBeUndefined();
-
-            // Make sure the previously created post is now returned
-            expect(typeof singleRowSelect?.data?.rest).toEqual('object');
-
-            // todo - make this work correctly with multiple primary keys
-            const selectedPostId = singleRowSelect?.data?.rest[0][primaryKey]
-
-            expect(selectedPostId).toEqual(postID);
-
-            const multipleRowSelect = await {{TABLE_NAME_SHORT_PASCAL_CASE}}.Get({
-                [C6.WHERE]: {
-                    [{{TABLE_NAME_SHORT}}[primaryKey.toUpperCase()]]: [C6.IN, [0, postID]],
-                }
-            })
-
-            if ('function' === typeof multipleRowSelect) {
-                throw Error('singleRowSelect is a promise, this is unexpected.');
-            }
-
-            console.log('singleRowSelect', multipleRowSelect?.data)
-
-            // Ensure the expected response datastructure is returned
-            expect(multipleRowSelect?.data?.rest).not.toBeUndefined();
-
-            // Make sure the previously created post is now returned
-            expect(typeof multipleRowSelect?.data?.rest).toEqual('object');
-
-            testData[primaryKey] = postID
-
-            {{#each TYPE_VALIDATION}}
-            testData.{{COLUMN_NAME}} = {{#TYPESCRIPT_TYPE_IS_STRING}}fillString.substring(0, {{MAX_LENGTH}}){{/TYPESCRIPT_TYPE_IS_STRING}}{{#TYPESCRIPT_TYPE_IS_NUMBER}}randomInt{{/TYPESCRIPT_TYPE_IS_NUMBER}};
-            {{/each}}
-
-            {{#if REACT_IMPORT}}
-            // wait for the global state to be updated
-            expect({{{CARBON_REACT_INSTANCE}}}.state.{{TABLE_NAME_SHORT}}).not.toBeUndefined();
-            {{/if}}
-
-            const updateResponse = await {{TABLE_NAME_SHORT_PASCAL_CASE}}.Put(testData)
-
-            expect(updateResponse?.data?.updated).not.toBeUndefined();
-
-            const deleteResponse = await {{TABLE_NAME_SHORT_PASCAL_CASE}}.Delete({
-                [primaryKey]: postID
-            })
-
-            console.log('deleteResponse', deleteResponse?.data)
-
-            expect(deleteResponse?.data?.deleted).not.toBeUndefined();
-
-            await waitFor(async () => {
-                expect(checkAllRequestsComplete()).toEqual(true);
-            }, {timeout: 10000, interval: 1000});
-
-        })
-
-    }, 100000);
-
-})
-

package/scripts/assets/handlebars/Table.ts.handlebars

@@ -1,193 +0,0 @@
-import {
-    iPostC6RestResponse,
-    restRequest,
-    GET,
-    POST,
-    PUT,
-    DELETE,
-    iDeleteC6RestResponse,
-    iGetC6RestResponse,
-    iPutC6RestResponse,{{#REACT_IMPORT}}
-    removeInvalidKeys,
-    iAPI,
-    Modify{{/REACT_IMPORT}}
-} from "@carbonorm/carbonnode";{{#REACT_IMPORT}}
-import {AxiosResponse} from "axios";{{/REACT_IMPORT}}
-import {C6, {{TABLE_NAME_SHORT}}, i{{TABLE_NAME_SHORT_PASCAL_CASE}}, {{TABLE_NAME_SHORT_PASCAL_CASE}}PrimaryKeys} from "./C6";{{#if REACT_IMPORT}}
-{{{REACT_IMPORT}}};{{/if}}
-
-/**
-{{{TABLE_DEFINITION}}}
-**/
-
-type GetCustomAndRequiredFields = {}
-
-type GetRequestTableOverrides = {}
-
-// required parameters, optional parameters, parameter type overrides, response, and table names
-const Get = restRequest<
-    '{{TABLE_NAME_SHORT}}',
-    i{{TABLE_NAME_SHORT_PASCAL_CASE}},
-    {{TABLE_NAME_SHORT_PASCAL_CASE}}PrimaryKeys,
-    GetCustomAndRequiredFields,
-    GetRequestTableOverrides,
-    iGetC6RestResponse<i{{TABLE_NAME_SHORT_PASCAL_CASE}}>
->({
-    C6: C6,
-    restURL: {{{REST_URL_EXPRESSION}}},
-    restModel: {{TABLE_NAME_SHORT}},
-    requestMethod: GET,
-    queryCallback: (request) => {
-        request.success ??= 'Successfully received {{TABLE_NAME_SHORT}}!'
-        request.error ??= 'An unknown issue occurred creating the {{TABLE_NAME_SHORT}}!'
-        return request
-    },{{#if REACT_IMPORT}}
-    responseCallback: (response, _request) => {
-        const responseData = response?.data?.rest;
-        {{CARBON_REACT_INSTANCE}}.updateRestfulObjectArrays<i{{TABLE_NAME_SHORT_PASCAL_CASE}}>({
-            dataOrCallback: Array.isArray(responseData) ? responseData : [responseData],
-            stateKey: "{{TABLE_NAME_SHORT}}",
-            uniqueObjectId: C6.{{TABLE_NAME_SHORT}}.PRIMARY_SHORT as (keyof i{{TABLE_NAME_SHORT_PASCAL_CASE}})[]
-        })
-    }{{/if}}
-});
-
-type PutCustomAndRequiredFields = {}
-
-type PutRequestTableOverrides = {}
-
-{{#if REACT_IMPORT}}
-export function putState(response: AxiosResponse<iPutC6RestResponse<i{{TABLE_NAME_SHORT_PASCAL_CASE}}>>, request: iAPI<Modify<i{{TABLE_NAME_SHORT_PASCAL_CASE}}, PutRequestTableOverrides>> & PutCustomAndRequiredFields) {
-    {{CARBON_REACT_INSTANCE}}.updateRestfulObjectArrays<i{{TABLE_NAME_SHORT_PASCAL_CASE}}>({
-        dataOrCallback: [
-            removeInvalidKeys<i{{TABLE_NAME_SHORT_PASCAL_CASE}}>({
-                ...request,
-                ...response?.data?.rest,
-            }, C6.TABLES)
-        ],
-        stateKey: "{{TABLE_NAME_SHORT}}",
-        uniqueObjectId: {{TABLE_NAME_SHORT}}.PRIMARY_SHORT as (keyof i{{TABLE_NAME_SHORT_PASCAL_CASE}})[]
-    })
-}
-{{/if}}
-
-const Put = restRequest<
-    '{{TABLE_NAME_SHORT}}',
-    i{{TABLE_NAME_SHORT_PASCAL_CASE}},
-    {{TABLE_NAME_SHORT_PASCAL_CASE}}PrimaryKeys,
-    GetCustomAndRequiredFields,
-    GetRequestTableOverrides,
-    iPutC6RestResponse<i{{TABLE_NAME_SHORT_PASCAL_CASE}}>
->({
-    C6: C6,
-    restURL: {{{REST_URL_EXPRESSION}}},
-    restModel: {{TABLE_NAME_SHORT}},
-    requestMethod: PUT,
-    queryCallback: (request) => {
-        request.success ??= 'Successfully updated {{TABLE_NAME_SHORT}} data!'
-        request.error ??= 'An unknown issue occurred updating the {{TABLE_NAME_SHORT}} data!'
-        return request
-    },{{#if REACT_IMPORT}}
-    responseCallback: putState{{/if}}
-});
-
-type PostCustomAndRequiredFields = {}
-
-type PostRequestTableOverrides = {}
-
-{{#if REACT_IMPORT}}export function postState(
-    response: AxiosResponse<iPostC6RestResponse<i{{TABLE_NAME_SHORT_PASCAL_CASE}}>>,
-    request: iAPI<Modify<i{{TABLE_NAME_SHORT_PASCAL_CASE}}, PostRequestTableOverrides>> & PostCustomAndRequiredFields,
-    success: i{{TABLE_NAME_SHORT_PASCAL_CASE}}[{{TABLE_NAME_SHORT_PASCAL_CASE}}PrimaryKeys] | string | number | boolean | undefined
-) {
-    if ('number' === typeof id || 'string' === typeof success) {
-        if (1 !== {{TABLE_NAME_SHORT}}.PRIMARY_SHORT.length) {
-            console.error("C6 received unexpected result's given the primary key length");
-        } else {
-            request[{{TABLE_NAME_SHORT}}.PRIMARY_SHORT[0]] = success
-        }
-    }
-    {{CARBON_REACT_INSTANCE}}.updateRestfulObjectArrays<i{{TABLE_NAME_SHORT_PASCAL_CASE}}>({
-        dataOrCallback: undefined !== request.dataInsertMultipleRows
-            ? request.dataInsertMultipleRows.map((request, index) => {
-                return removeInvalidKeys<i{{TABLE_NAME_SHORT_PASCAL_CASE}}>({
-                    ...request,
-                    ...(index === 0 ? response?.data?.rest : {}),
-                }, C6.TABLES)
-            })
-            : [
-                removeInvalidKeys<i{{TABLE_NAME_SHORT_PASCAL_CASE}}>({
-                    ...request,
-                    ...response?.data?.rest,
-                }, C6.TABLES)
-            ],
-        stateKey: "{{TABLE_NAME_SHORT}}",
-        uniqueObjectId: {{TABLE_NAME_SHORT}}.PRIMARY_SHORT as (keyof i{{TABLE_NAME_SHORT_PASCAL_CASE}})[]
-    })
-}{{/if}}
-
-const Post = restRequest<
-    '{{TABLE_NAME_SHORT}}',
-    i{{TABLE_NAME_SHORT_PASCAL_CASE}},
-    {{TABLE_NAME_SHORT_PASCAL_CASE}}PrimaryKeys,
-    GetCustomAndRequiredFields,
-    GetRequestTableOverrides,
-    iPostC6RestResponse<i{{TABLE_NAME_SHORT_PASCAL_CASE}}>
->({
-    C6: C6,
-    restURL: {{{REST_URL_EXPRESSION}}},
-    restModel: {{TABLE_NAME_SHORT}},
-    requestMethod: POST,
-    queryCallback: (request) => {
-        request.success ??= 'Successfully created the {{TABLE_NAME_SHORT}} data!'
-        request.error ??= 'An unknown issue occurred creating the {{TABLE_NAME_SHORT}} data!'
-        return request
-    },{{#if REACT_IMPORT}}
-    responseCallback: postState{{/if}}
-});
-
-type DeleteCustomAndRequiredFields = {}
-
-type DeleteRequestTableOverrides = {}
-
-{{#if REACT_IMPORT}}
-export function deleteState(_response: AxiosResponse<iDeleteC6RestResponse<i{{TABLE_NAME_SHORT_PASCAL_CASE}}>>, request: iAPI<Modify<i{{TABLE_NAME_SHORT_PASCAL_CASE}}, DeleteRequestTableOverrides>> & DeleteCustomAndRequiredFields) {
-    {{CARBON_REACT_INSTANCE}}.deleteRestfulObjectArrays<i{{TABLE_NAME_SHORT_PASCAL_CASE}}>({
-        dataOrCallback: [
-            request
-        ],
-        stateKey: "{{TABLE_NAME_SHORT}}",
-        uniqueObjectId: {{TABLE_NAME_SHORT}}.PRIMARY_SHORT as (keyof i{{TABLE_NAME_SHORT_PASCAL_CASE}})[]
-    })
-}
-{{/if}}
-
-const Delete  = restRequest<
-    '{{TABLE_NAME_SHORT}}',
-    i{{TABLE_NAME_SHORT_PASCAL_CASE}},
-    {{TABLE_NAME_SHORT_PASCAL_CASE}}PrimaryKeys,
-    GetCustomAndRequiredFields,
-    GetRequestTableOverrides,
-    iDeleteC6RestResponse<i{{TABLE_NAME_SHORT_PASCAL_CASE}}>
->({
-    C6: C6,
-    restURL: {{{REST_URL_EXPRESSION}}},
-    restModel: {{TABLE_NAME_SHORT}},
-    requestMethod: DELETE,
-    queryCallback: (request) => {
-        request.success ??= 'Successfully removed the {{TABLE_NAME_SHORT}} data!'
-        request.error ??= 'An unknown issue occurred removing the {{TABLE_NAME_SHORT}} data!'
-        return request
-    },{{#if REACT_IMPORT}}
-    responseCallback: deleteState{{/if}}
-});
-
-const {{TABLE_NAME_SHORT_PASCAL_CASE}} = {
-    // Export all GET, POST, PUT, DELETE functions for each table
-    Get,
-    Post,
-    Put,
-    Delete,
-}
-
-export default {{TABLE_NAME_SHORT_PASCAL_CASE}};