@carbonorm/carbonnode 3.0.3 → 3.0.5

package/src/api/types/ormInterfaces.ts

@@ -1,268 +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";
-import {CarbonReact} from "@carbonorm/carbonreact";
-
-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
-}
-
-
-// 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
-}
-
-// 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;
-};
+// Refined TypeScript types for CarbonORM
 
-export type tPrimaryKeys<
-    TableName extends string,
-    PK extends string
-> = `${TableName}.${PK}`;
+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 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> {
-    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>>,
-}
-
-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;
@@ -270,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;
@@ -284,110 +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<
-    RequestMethod extends iRestMethods,
+    Method extends iRestMethods,
     RestTableInterface extends { [key: string]: any }
-> = RequestMethod extends "POST"
+> = Method extends 'POST'
     ? iPostC6RestResponse<RestTableInterface>
-    : RequestMethod extends "GET"
+    : Method extends 'GET'
         ? iGetC6RestResponse<RestTableInterface>
-        : RequestMethod extends "PUT"
+        : Method extends 'PUT'
             ? iPutC6RestResponse<RestTableInterface>
-            : RequestMethod extends "DELETE"
+            : Method extends 'DELETE'
                 ? iDeleteC6RestResponse<RestTableInterface>
-                : any;
+                : never;
 
 export interface iRest<
     RestShortTableName extends string = any,
     RestTableInterface extends { [key: string]: any } = 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>,
-    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<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*/
+    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/rest/C6.test.ts

@@ -1,88 +0,0 @@
-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);
-    }
-});