@carbonorm/carbonnode 3.0.2 → 3.0.4

package/src/api/types/ormInterfaces.ts

@@ -1,199 +1,51 @@
-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";
-
-export interface stringMap {
-    [key: string]: string;
-}
-
-export interface stringNumberMap {
-    [key: string]: string | number;
-}
-
-export interface RegExpMap {
-    [key: string]: RegExp | RegExpMap;
-}
-
-export interface complexMap {
-    [key: string]: stringMap | stringNumberMap | stringMap[] | RegExpMap;
-}
-
-export interface iTypeValidation {
-    MYSQL_TYPE: string,
-    MAX_LENGTH: string,
-    AUTO_INCREMENT: boolean,
-    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>;
-};
-
-export interface iConstraint {
-    TABLE: string,
-    COLUMN: string,
-    CONSTRAINT: string
-}
-
-// 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;
-    LIFECYCLE_HOOKS: iRestReactiveLifecycle<RequestGetPutDeleteBody>[];
-    TABLE_REFERENCES: { [columnName: string]: iConstraint[] };
-    TABLE_REFERENCED_BY: { [columnName: string]: iConstraint[] };
-}
+// Refined TypeScript types for CarbonORM
 
-export interface iRestApiFunctions<RestData = any> {
-    Delete: (request?: (iAPI<any> & any)) => apiReturn<iDeleteC6RestResponse<RestData>>;
-    Post: (request?: (iAPI<any> & any)) => apiReturn<iPostC6RestResponse<RestData>>;
-    Get: (request?: (iAPI<any> & any)) => apiReturn<iGetC6RestResponse<RestData>>;
-    Put: (request?: (iAPI<any> & any)) => apiReturn<iPutC6RestResponse<RestData>>,
-}
+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 iDynamicApiImport<RestData = any> {
-    default: iRestApiFunctions<RestData>
-    // the methods below are optional
-    postState?: (response: AxiosResponse<iPostC6RestResponse<RestData>>, request: iAPI<any>, id: string | number | boolean) => void,
-    deleteState?: (response: AxiosResponse<iDeleteC6RestResponse<RestData>>, request: iAPI<any>) => void,
-    putState?: (response: AxiosResponse<iPutC6RestResponse<RestData>>, request: iAPI<any>) => void
-}
-
-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]: {
-        REST: iRestApiFunctions,
-        PUT: Function;
-        POST: Function;
-        DELETE: Function;
-    };
-}
-
-// todo - I don't like that these essentially become reserved words.
-export type iAPI<RestTableInterfaces extends { [key: string]: any }> = RestTableInterfaces & {
-    dataInsertMultipleRows?: RestTableInterfaces[],
-    cacheResults?: boolean, // aka ignoreCache
-    // todo - this should really only be used for get requests - add this to the Get interface or throw error (im actually inclined to ts ignore the function and add to iGetC6 atm; back later)
-    fetchDependencies?: number | eFetchDependencies | Awaited<apiReturn<iGetC6RestResponse<any>>>[],
-    debug?: boolean,
-    success?: string | ((r: AxiosResponse) => (string | void)),
-    error?: string | ((r: AxiosResponse) => (string | void)),
-}
-
-export interface iCacheAPI<ResponseDataType = any> {
-    requestArgumentsSerialized: string,
-    request: AxiosPromise<ResponseDataType>,
-    response?: AxiosResponse,
-    final?: boolean,
-}
-
-
-/**
- * the first argument ....
- *
- * Our api returns a zero argument function iff the method is get and the previous request reached the predefined limit.
- * This function can be aliased as GetNextPageOfResults(). If the end is reached undefined will be returned.
- *
- *
- * For POST, PUT, and DELETE requests one can expect the primary key of the new or modified index, or a boolean success
- * indication if no primary key exists.
- **/
+export type iRestMethods = 'GET' | 'POST' | 'PUT' | 'DELETE';
 export const POST = 'POST';
 export const PUT = 'PUT';
 export const GET = 'GET';
 export const DELETE = 'DELETE';
 
+export interface stringMap { [key: string]: string; }
+export interface stringNumberMap { [key: string]: string | number; }
+export interface RegExpMap { [key: string]: RegExp | RegExpMap; }
+export interface complexMap { [key: string]: stringMap | stringNumberMap | stringMap[] | RegExpMap; }
 
-export type iRestMethods = 'GET' | 'POST' | 'PUT' | 'DELETE';
-
-// ========================
-// 📦 SELECT
-// ========================
+export interface iTypeValidation {
+    MYSQL_TYPE: string;
+    MAX_LENGTH: string;
+    AUTO_INCREMENT: boolean;
+    SKIP_COLUMN_IN_POST: boolean;
+}
 
-export type SubSelect<T = any> = {
+export type SubSelect<T extends { [key: string]: any } = any> = {
     subSelect: true;
-    table: string; // could be enum’d to known table names
-    args: RequestGetPutDeleteBody<T>;
+    table: string;
+    args: RequestQueryBody<'GET', T>;
     alias: string;
 };
 
-export type SelectField<T = any> =
+export type SelectField<T extends { [key: string]: any } = any> =
     | keyof T
     | [keyof T, 'AS', string]
     | [SQLFunction, keyof T]
-    | [SQLFunction, keyof T, string] // With alias
-    | SubSelect<T>; // Fully nested sub-select
-
-
-// ========================
-// 🧠 WHERE (Recursive)
-// ========================
-
-export type WhereClause<T = any> =
-    | Partial<T>
-    | LogicalGroup<T>
-    | ComparisonClause<T>;
-
-export type LogicalGroup<T = any> = {
-    [logicalGroup: string]: Array<WhereClause<T>>;
-};
+    | [SQLFunction, keyof T, string]
+    | SubSelect<T>;
 
+export type WhereClause<T = any> = Partial<T> | LogicalGroup<T> | ComparisonClause<T>;
+export type LogicalGroup<T = any> = { [logicalGroup: string]: Array<WhereClause<T>> };
 export type ComparisonClause<T = any> = [keyof T, SQLComparisonOperator, any];
 
-
-// ========================
-// 🔗 JOIN
-// ========================
-
-export type JoinTableCondition<T = any> =
-    | Partial<T>
-    | WhereClause<T>[]
-    | ComparisonClause<T>[];
-
-export type JoinClause<T = any> = {
-    [table: string]: JoinTableCondition<T>;
-};
-
-export type Join<T = any> = {
-    [K in JoinType]?: JoinClause<T>;
-};
-
-
-// ========================
-// 📄 PAGINATION
-// ========================
+export type JoinTableCondition<T = any> = Partial<T> | WhereClause<T>[] | ComparisonClause<T>[];
+export type JoinClause<T = any> = { [table: string]: JoinTableCondition<T>; };
+export type Join<T = any> = { [K in JoinType]?: JoinClause<T>; };
 
 export type Pagination<T = any> = {
     PAGE?: number;
@@ -201,12 +53,7 @@ export type Pagination<T = any> = {
     ORDER?: Partial<Record<keyof T, OrderDirection>>;
 };
 
-
-// ========================
-// 🌐 MAIN API TYPE
-// ========================
-
-export type RequestGetPutDeleteBody<T = any> = {
+export type RequestGetPutDeleteBody<T extends { [key: string]: any } = any> = {
     SELECT?: SelectField<T>[];
     UPDATE?: Partial<T>;
     DELETE?: boolean;
@@ -215,96 +62,211 @@ export type RequestGetPutDeleteBody<T = any> = {
     PAGINATION?: Pagination<T>;
 };
 
+export type iAPI<T extends { [key: string]: any }> = T & {
+    dataInsertMultipleRows?: T[];
+    cacheResults?: boolean;
+    fetchDependencies?: number | eFetchDependencies | Awaited<apiReturn<iGetC6RestResponse<any>>>[];
+    debug?: boolean;
+    success?: string | ((r: AxiosResponse) => string | void);
+    error?: string | ((r: AxiosResponse) => string | void);
+};
 
-export type RequestQueryBody<RestTableInterfaces extends { [key: string]: any }> =
-    iAPI<RestTableInterfaces>
-    | RequestGetPutDeleteBody;
-
-export function isPromise(x) {
-    return Object(x).constructor === Promise
-}
+export type RequestQueryBody<
+    Method extends iRestMethods,
+    T extends { [key: string]: any },
+    Custom extends { [key: string]: any } = {},
+    Overrides extends { [key: string]: any } = {}
+> = Method extends 'GET' | 'PUT' | 'DELETE'
+    ? iAPI<RequestGetPutDeleteBody<Modify<T, Overrides> & Custom>>
+    : iAPI<Modify<T, Overrides> & Custom>;
 
-interface iC6RestResponse<RestData> {
-    rest: RestData,
-    session?: any,
-    sql?: any
+export interface iCacheAPI<ResponseDataType = any> {
+    requestArgumentsSerialized: string;
+    request: AxiosPromise<ResponseDataType>;
+    response?: AxiosResponse;
+    final?: boolean;
 }
 
-
-interface iChangeC6Data {
-    rowCount: number,
-}
+export interface iChangeC6Data { rowCount: number; }
 
 export interface iDeleteC6RestResponse<RestData = any, RequestData = any> extends iChangeC6Data, iC6RestResponse<RestData> {
-    deleted: boolean | number | string | RequestData,
+    deleted: boolean | number | string | RequestData;
 }
 
 export interface iPostC6RestResponse<RestData = any> extends iC6RestResponse<RestData> {
-    created: boolean | number | string,
+    created: boolean | number | string;
 }
 
 export interface iPutC6RestResponse<RestData = any, RequestData = any> extends iChangeC6Data, iC6RestResponse<RestData> {
-    updated: boolean | number | string | RequestData,
+    updated: boolean | number | string | RequestData;
 }
 
-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<RestShortTableName, RestTableInterface, PrimaryKey>
-            & {
-            [key: string]: string | number
-        }
-    },
-    PREFIX: string,
-    IMPORT: (tableName: string) => Promise<iDynamicApiImport>,
-
-    [key: string]: any
+export interface iC6RestResponse<RestData> {
+    rest: RestData;
+    session?: any;
+    sql?: any;
 }
 
-// todo - I'm not sure that Modify<ResponseDataType, ResponseDataOverrides>[]> is needed?
-export type iGetC6RestResponse<ResponseDataType, ResponseDataOverrides = {}> = iC6RestResponse<Modify<ResponseDataType, ResponseDataOverrides> | Modify<ResponseDataType, ResponseDataOverrides>[]>
+export type iGetC6RestResponse<ResponseDataType, ResponseDataOverrides = {}> = iC6RestResponse<
+    Modify<ResponseDataType, ResponseDataOverrides> | Modify<ResponseDataType, ResponseDataOverrides>[]
+>;
 
-// returning undefined means no more results are available, thus we've queried everything possible
-// null means the request is currently being executed
-// https://www.typescriptlang.org/docs/handbook/2/conditional-types.html
 export type apiReturn<Response> =
-    null
+    | null
     | undefined
     | AxiosPromise<Response>
-    | (Response extends iPutC6RestResponse | iDeleteC6RestResponse | iPostC6RestResponse ? null : (() => apiReturn<Response>))
-
+    | (Response extends iPutC6RestResponse | iDeleteC6RestResponse | iPostC6RestResponse ? null : () => apiReturn<Response>);
+
+export type DetermineResponseDataType<
+    Method extends iRestMethods,
+    RestTableInterface extends { [key: string]: any }
+> = Method extends 'POST'
+    ? iPostC6RestResponse<RestTableInterface>
+    : Method extends 'GET'
+        ? iGetC6RestResponse<RestTableInterface>
+        : Method extends 'PUT'
+            ? iPutC6RestResponse<RestTableInterface>
+            : Method extends 'DELETE'
+                ? iDeleteC6RestResponse<RestTableInterface>
+                : never;
 
 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,
-    restURL?: string,
+    C6: iC6Object;
+    axios?: AxiosInstance;
+    restURL?: string;
     mysqlPool?: Pool;
-    withCredentials?: boolean,
-    restModel: iC6RestfulModel<RestShortTableName, RestTableInterface, PrimaryKey>,
-    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
+    withCredentials?: boolean;
+    restModel: iC6RestfulModel<RestShortTableName, RestTableInterface, PrimaryKey>;
+    reactBootstrap?: CarbonReact<any, any>;
+    requestMethod: iRestMethods;
+    clearCache?: () => void;
+    skipPrimaryCheck?: boolean;
 }
 
+export interface iConstraint {
+    TABLE: string;
+    COLUMN: string;
+    CONSTRAINT: string;
+}
+
+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;
+    LIFECYCLE_HOOKS: iRestHooks<RestShortTableNames, RestTableInterfaces, PK>;
+    TABLE_REFERENCES: { [columnName: string]: iConstraint[] };
+    TABLE_REFERENCED_BY: { [columnName: string]: iConstraint[] };
+}
 
+export type iRestReactiveLifecycle<
+    Method extends iRestMethods,
+    RestShortTableName extends string,
+    RestTableInterface extends { [key: string]: any },
+    PrimaryKey extends keyof RestTableInterface & string,
+    CustomAndRequiredFields extends { [key: string]: any },
+    RequestTableOverrides extends { [key: string]: any }
+> = {
+    beforeProcessing?: {
+        [key: string]: (args: {
+            config: iRest<RestShortTableName, RestTableInterface, PrimaryKey>;
+            request: RequestQueryBody<Method, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>;
+        }) => void | Promise<void>;
+    };
+    beforeExecution?: {
+        [key: string]: (args: {
+            config: iRest<RestShortTableName, RestTableInterface, PrimaryKey>;
+            request: RequestQueryBody<Method, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>;
+        }) => void | Promise<void>;
+    };
+    afterExecution?: {
+        [key: string]: (args: {
+            config: iRest<RestShortTableName, RestTableInterface, PrimaryKey>;
+            request: RequestQueryBody<Method, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>;
+            response: AxiosResponse<DetermineResponseDataType<Method, RestTableInterface>>;
+        }) => void | Promise<void>;
+    };
+    afterCommit?: {
+        [key: string]: (args: {
+            config: iRest<RestShortTableName, RestTableInterface, PrimaryKey>;
+            request: RequestQueryBody<Method, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>;
+            response: AxiosResponse<DetermineResponseDataType<Method, RestTableInterface>>;
+        }) => void | Promise<void>;
+    };
+};
+
+export type iRestHooks<
+    RestShortTableName extends string,
+    RestTableInterface extends { [key: string]: any },
+    PrimaryKey extends keyof RestTableInterface & string,
+    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 iDynamicApiImport<RestData extends { [key: string]: any } = any> {
+    default: iRestApiFunctions<RestData>;
+    postState?: (response: AxiosResponse<iPostC6RestResponse<RestData>>, request: iAPI<any>, id: string | number | boolean) => void;
+    deleteState?: (response: AxiosResponse<iDeleteC6RestResponse<RestData>>, request: iAPI<any>) => void;
+    putState?: (response: AxiosResponse<iPutC6RestResponse<RestData>>, request: iAPI<any>) => void;
+}
+
+export interface iRestApiFunctions<RestData extends { [key: string]: any } = any> {
+    Delete: (request?: RequestQueryBody<'DELETE', RestData>) => apiReturn<iDeleteC6RestResponse<RestData>>;
+    Post: (request?: RequestQueryBody<'POST', RestData>) => apiReturn<iPostC6RestResponse<RestData>>;
+    Get: (request?: RequestQueryBody<'GET', RestData>) => apiReturn<iGetC6RestResponse<RestData>>;
+    Put: (request?: RequestQueryBody<'PUT', RestData>) => apiReturn<iPutC6RestResponse<RestData>>;
+}
+
+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<RestShortTableName, RestTableInterface, PrimaryKey> & {
+            [key: string]: string | number;
+        };
+    };
+    PREFIX: string;
+    IMPORT: (tableName: string) => Promise<iDynamicApiImport>;
+    [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]: {
+        REST: iRestApiFunctions;
+        PUT: Function;
+        POST: Function;
+        DELETE: Function;
+    };
+}

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