@carbonorm/carbonnode 3.0.1 → 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,39 +1,57 @@
 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<
-    CustomAndRequiredFields extends {
-        [key: string]: any;
-    } = any,
-    RestTableInterfaces extends {
-        [key: string]: any
-    } = any,
-    RequestTableOverrides extends {
-        [key: string]: any;
-    } = any,
-    ResponseDataType = any,
-    RestShortTableNames extends string = any
+    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 }
 >(
-    config: iRest<CustomAndRequiredFields, RestTableInterfaces, RequestTableOverrides, ResponseDataType, RestShortTableNames>
+    config: iRest<
+        RestShortTableName,
+        RestTableInterface,
+        PrimaryKey
+    >
 ) {
     return async (
-        request: iAPI<Modify<RestTableInterfaces, RequestTableOverrides>> & CustomAndRequiredFields = {} as iAPI<Modify<RestTableInterfaces, RequestTableOverrides>> & CustomAndRequiredFields
-    ): Promise<apiReturn<ResponseDataType>> => {
+        request: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields = {} as iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields
+    ): 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<CustomAndRequiredFields, RestTableInterfaces, RequestTableOverrides, ResponseDataType, RestShortTableNames>(config, request);
+            const executor = new SqlExecutor<
+                RequestMethod,
+                RestShortTableName,
+                RestTableInterface,
+                PrimaryKey,
+                CustomAndRequiredFields,
+                RequestTableOverrides
+            >(config, request);
             return executor.execute();
         }
 
         // HTTP path fallback
         const {HttpExecutor} = await import('./executors/HttpExecutor');
-        const http = new HttpExecutor<CustomAndRequiredFields, RestTableInterfaces, RequestTableOverrides, ResponseDataType, RestShortTableNames>(config, request);
+        const http = new HttpExecutor<
+            RequestMethod,
+            RestShortTableName,
+            RestTableInterface,
+            PrimaryKey,
+            CustomAndRequiredFields,
+            RequestTableOverrides
+        >(config, request);
         return http.execute();
     };
 }
+

package/src/api/types/ormInterfaces.ts

@@ -1,9 +1,9 @@
-import restRequest from "api/restRequest";
 import {AxiosInstance, AxiosPromise, AxiosResponse} from "axios";
 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;
@@ -28,29 +28,114 @@ 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,
     CONSTRAINT: string
 }
 
-export interface iC6RestfulModel<RestShortTableNames extends string = string> {
-    TABLE_NAME: RestShortTableNames,
-    PRIMARY: string[],
-    PRIMARY_SHORT: string[],
-    COLUMNS: stringMap,
-    LIFECYCLE_HOOKS: iRestReactiveLifecycle<RequestGetPutDeleteBody>[],
-    REGEX_VALIDATION: RegExpMap,
-    TYPE_VALIDATION: { [key: string]: iTypeValidation },
-    TABLE_REFERENCES: { [columnName: string]: iConstraint[] },
-    TABLE_REFERENCED_BY: { [columnName: string]: iConstraint[] },
+// This maps full column names to short column keys
+export type tColumns<
+    TableName extends string,
+    T extends { [key: string]: any }
+> = {
+    [K in keyof T & string as `${TableName}.${K}`]: K;
+};
+
+export type tPrimaryKeys<
+    TableName extends string,
+    PK extends string
+> = `${TableName}.${PK}`;
+
+export interface iC6RestfulModel<
+    RestShortTableNames extends string,
+    RestTableInterfaces extends { [key: string]: any },
+    PK extends keyof RestTableInterfaces & string,
+> {
+    TABLE_NAME: RestShortTableNames;
+    PRIMARY: tPrimaryKeys<RestShortTableNames, PK>[];
+    PRIMARY_SHORT: PK[];
+    COLUMNS: tColumns<RestShortTableNames, RestTableInterfaces>;
+    TYPE_VALIDATION: { [key: string]: iTypeValidation };
+    REGEX_VALIDATION: RegExpMap;
+    // 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[] };
 }
 
 export interface iRestApiFunctions<RestData = any> {
@@ -68,7 +153,13 @@ export interface iDynamicApiImport<RestData = any> {
     putState?: (response: AxiosResponse<iPutC6RestResponse<RestData>>, request: iAPI<any>) => void
 }
 
-export interface tC6Tables { [key: string]: (iC6RestfulModel & { [key: string]: any }) }
+export interface tC6Tables<
+    RestShortTableName extends string = any,
+    RestTableInterface extends { [key: string]: any } = any,
+    PrimaryKey extends Extract<keyof RestTableInterface, string> = Extract<keyof RestTableInterface, string>
+> {
+    [key: string]: iC6RestfulModel<RestShortTableName, RestTableInterface, PrimaryKey> & { [key: string]: any }
+}
 
 export interface tC6RestApi {
     [key: string]: {
@@ -98,7 +189,6 @@ export interface iCacheAPI<ResponseDataType = any> {
 }
 
 
-
 /**
  * the first argument ....
  *
@@ -226,11 +316,17 @@ export interface iPutC6RestResponse<RestData = any, RequestData = any> extends i
     updated: boolean | number | string | RequestData,
 }
 
-export interface iC6Object {
+export interface iC6Object<
+    RestShortTableName extends string = any,
+    RestTableInterface extends { [key: string]: any } = any,
+    PrimaryKey extends Extract<keyof RestTableInterface, string> = Extract<keyof RestTableInterface, string>
+> {
     C6VERSION: string,
     TABLES: {
-        [key: string]: iC6RestfulModel &
-            { [key: string]: string | number }
+        [key: string]: iC6RestfulModel<RestShortTableName, RestTableInterface, PrimaryKey>
+            & {
+            [key: string]: string | number
+        }
     },
     PREFIX: string,
     IMPORT: (tableName: string) => Promise<iDynamicApiImport>,
@@ -251,37 +347,47 @@ 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<
-    CustomAndRequiredFields extends { [key: string]: any },
-    RestTableInterfaces extends { [key: string]: any },
-    RequestTableOverrides = { [key in keyof RestTableInterfaces]: any },
-    ResponseDataType = any,
-    RestShortTableNames extends string = any
+    RestShortTableName extends string = any,
+    RestTableInterface extends { [key: string]: any } = any,
+    PrimaryKey extends keyof RestTableInterface & string = any
 > {
     C6: iC6Object,
     axios?: AxiosInstance,
     restURL?: string,
     mysqlPool?: Pool;
     withCredentials?: boolean,
-    tableName: RestShortTableNames | RestShortTableNames[],
+    restModel: iC6RestfulModel<RestShortTableName, RestTableInterface, PrimaryKey>,
+    reactBootstrap?: CarbonReact<any, any>,
     requestMethod: iRestMethods,
     clearCache?: () => void,
     skipPrimaryCheck?: boolean,
-    queryCallback: RequestQueryBody<Modify<RestTableInterfaces, RequestTableOverrides>> | ((request: iAPI<Modify<RestTableInterfaces, RequestTableOverrides>> & CustomAndRequiredFields) => (null | undefined | RequestQueryBody<Modify<RestTableInterfaces, RequestTableOverrides>>)),
-    responseCallback?: (response: AxiosResponse<ResponseDataType>,
-                        request: iAPI<Modify<RestTableInterfaces, RequestTableOverrides>> & CustomAndRequiredFields,
-                        success: (ResponseDataType extends iPutC6RestResponse | iDeleteC6RestResponse ? RequestQueryBody<Modify<RestTableInterfaces, RequestTableOverrides>> : string) | string | number | boolean) => 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*/
 }
 
-export function extendedTypeHints<RestTableInterfaces extends {
-    [key: string]: any
-}, RestShortTableNames extends string>() {
-    return <CustomAndRequiredFields extends {
-        [key: string]: any
-    } = any, RequestTableTypes extends RestTableInterfaces = any, RequestTableOverrides extends {
-        [key: string]: any
-    } = any, ResponseDataType extends {
-        [key: string]: any
-    } = any>(argv) => restRequest<CustomAndRequiredFields, RequestTableTypes, RequestTableOverrides, ResponseDataType, RestShortTableNames>(argv)
-}
+
 

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']
@@ -36,7 +40,6 @@ export function TestRestfulResponse(response: AxiosResponse | any, success: ((r:
 
     return false;
 
-
 }
 
 export function removePrefixIfExists(tableName: string, prefix: string): string {
@@ -47,7 +50,7 @@ export function removePrefixIfExists(tableName: string, prefix: string): string
 }
 
 export function removeInvalidKeys<iRestObject>(request: any, c6Tables: {
-    [key: string]: (iC6RestfulModel & { [key: string]: any })
+    [key: string]: (iC6RestfulModel<any,any,any> & { [key: string]: any })
 }): iRestObject {
 
     let intersection: iRestObject = {} as iRestObject

package/src/api/utils/determineRuntimeJsType.ts

@@ -0,0 +1,46 @@
+import {iC6RestfulModel} from "../types/ormInterfaces";
+
+type JsPrimitive = 'string' | 'number' | 'boolean' | 'buffer' | 'object';
+
+export function determineRuntimeJsType(mysqlType: string): JsPrimitive {
+    const base = mysqlType.toLowerCase().split('(')[0];
+
+    if ([
+        'binary', 'varbinary', 'blob', 'tinyblob', 'mediumblob', 'longblob'
+    ].includes(base)) return 'buffer';
+
+    if ([
+        'json', 'geometry', 'point', 'polygon', 'multipoint', 'multilinestring', 'multipolygon', 'geometrycollection'
+    ].includes(base)) return 'object';
+
+    if ([
+        'tinyint', 'smallint', 'mediumint', 'int', 'integer', 'bigint',
+        'decimal', 'dec', 'numeric', 'float', 'double', 'real'
+    ].includes(base)) return 'number';
+
+    if ([
+        'boolean', 'bool'
+    ].includes(base)) return 'boolean';
+
+    return 'string';
+}
+
+export function getPrimaryKeyTypes(
+    table: iC6RestfulModel<string, any, any>
+): Record<string, JsPrimitive> {
+    const result: Record<string, JsPrimitive> = {};
+
+    for (const key of table.PRIMARY_SHORT) {
+        const fullKey = Object.entries(table.COLUMNS).find(([_, short]) => short === key)?.[0];
+
+        if (typeof fullKey === 'string') {
+            const validation = table.TYPE_VALIDATION[fullKey];
+            if (!validation) continue;
+
+            result[key] = determineRuntimeJsType(validation.MYSQL_TYPE);
+        }
+    }
+
+    return result;
+}
+

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";
@@ -21,6 +22,7 @@ export * from "./api/types/mysqlTypes";
 export * from "./api/types/ormInterfaces";
 export * from "./api/utils/apiHelpers";
 export * from "./api/utils/cacheManager";
+export * from "./api/utils/determineRuntimeJsType";
 export * from "./api/utils/logger";
 export * from "./api/utils/sortAndSerializeQueryObject";
 export * from "./api/utils/testHelpers";

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