@carbonorm/carbonnode 3.0.1 → 3.0.2

package/src/api/executors/HttpExecutor.ts

@@ -14,18 +14,20 @@ import {Executor} from "./Executor";
 import {toastOptions, toastOptionsDevs } from "variables/toastOptions";
 
 export class HttpExecutor<
-    CustomAndRequiredFields extends { [key: string]: any },           // CustomAndRequiredFields
-    RestTableInterfaces extends  { [key: string]: any },            // RestTableInterfaces
-    RequestTableOverrides = { [key in keyof RestTableInterfaces]: any },   // RequestTableOverrides
-    ResponseDataType = any,                // ResponseDataType
-    RestShortTableNames extends string = ""    // RestShortTableNames
+    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
 >
     extends Executor<
+        RestShortTableName,
+        RestTableInterface,
+        PrimaryKey,
         CustomAndRequiredFields,
-        RestTableInterfaces,
         RequestTableOverrides,
-        ResponseDataType,
-        RestShortTableNames
+        ResponseDataType
     > {
 
     public async execute() : Promise<apiReturn<ResponseDataType>> {
@@ -35,7 +37,7 @@ export class HttpExecutor<
             axios,
             restURL,
             withCredentials,
-            tableName,
+            restModel,
             requestMethod,
             queryCallback,
             responseCallback,
@@ -43,6 +45,8 @@ export class HttpExecutor<
             clearCache,
         } = this.config
 
+        const tableName = restModel.TABLE_NAME;
+
         const fullTableList = Array.isArray(tableName) ? tableName : [tableName];
 
         const operatingTableFullName = fullTableList[0];
@@ -75,7 +79,7 @@ export class HttpExecutor<
 
         // an undefined query would indicate queryCallback returned undefined,
         // thus the request shouldn't fire as is in custom cache
-        let query: RequestQueryBody<Modify<RestTableInterfaces, RequestTableOverrides>> | undefined | null;
+        let query: RequestQueryBody<Modify<RestTableInterface, RequestTableOverrides>> | undefined | null;
 
         if ('function' === typeof queryCallback) {
 
@@ -250,7 +254,7 @@ export class HttpExecutor<
 
             let addBackPK: (() => void) | undefined;
 
-            let apiResponse: string | boolean | number | undefined;
+            let apiResponse: RestTableInterface[PrimaryKey] | string | boolean | number | undefined;
 
             let returnGetNextPageFunction = false;
 
@@ -381,7 +385,7 @@ export class HttpExecutor<
                             }
 
                             return [
-                                convertForRequestBody<RestTableInterfaces>(query as RestTableInterfaces, fullTableList, C6, (message) => toast.error(message, toastOptions)),
+                                convertForRequestBody<RestTableInterface>(query as RestTableInterface, fullTableList, C6, (message) => toast.error(message, toastOptions)),
                                 {
                                     withCredentials: withCredentials,
                                 }
@@ -390,7 +394,7 @@ export class HttpExecutor<
                         } else if (requestMethod === PUT) {
 
                             return [
-                                convertForRequestBody<RestTableInterfaces>(query as RestTableInterfaces, fullTableList, C6, (message) => toast.error(message, toastOptions)),
+                                convertForRequestBody<RestTableInterface>(query as RestTableInterface, fullTableList, C6, (message) => toast.error(message, toastOptions)),
                                 {
                                     withCredentials: withCredentials,
                                 }
@@ -399,7 +403,7 @@ export class HttpExecutor<
 
                             return [{
                                 withCredentials: withCredentials,
-                                data: convertForRequestBody<RestTableInterfaces>(query as RestTableInterfaces, fullTableList, C6, (message) => toast.error(message, toastOptions))
+                                data: convertForRequestBody<RestTableInterface>(query as RestTableInterface, fullTableList, C6, (message) => toast.error(message, toastOptions))
                             }]
 
                         } else {

package/src/api/executors/SqlExecutor.ts

@@ -4,23 +4,37 @@ import {buildSelectQuery} from "../builders/sqlBuilder";
 import {Executor} from "./Executor";
 
 
-export class SqlExecutor<CustomAndRequiredFields extends object, RestTableInterfaces extends object, RequestTableOverrides extends object, ResponseDataType, RestShortTableNames extends string>
-    extends Executor<CustomAndRequiredFields, RestTableInterfaces, RequestTableOverrides, ResponseDataType, RestShortTableNames> {
+export class SqlExecutor<
+    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
+>
+    extends Executor<
+        RestShortTableName,
+        RestTableInterface,
+        PrimaryKey,
+        CustomAndRequiredFields,
+        RequestTableOverrides,
+        ResponseDataType
+    > {
 
     public execute():  Promise<apiReturn<ResponseDataType>> {
         switch (this.config.requestMethod) {
             case 'GET':
                 return (this.select(
-                    this.config.tableName as RestShortTableNames,
+                    this.config.restModel.TABLE_NAME,
                     undefined,
                     this.request
                 ) as Promise<any>).then(rows => ({rest: rows})) as any;
             case 'POST':
-                return this.insert(this.config.tableName as RestShortTableNames, this.request) as any;
+                return this.insert(this.config.restModel.TABLE_NAME, this.request) as any;
             case 'PUT':
-                return this.update(this.config.tableName as RestShortTableNames, undefined, this.request) as any;
+                return this.update(this.config.restModel.TABLE_NAME, undefined, this.request) as any;
             case 'DELETE':
-                return this.delete(this.config.tableName as RestShortTableNames, undefined, this.request) as any;
+                return this.delete(this.config.restModel.TABLE_NAME, undefined, this.request) as any;
         }
     }
 

package/src/api/restRequest.ts

@@ -6,34 +6,50 @@ import {apiReturn, iAPI, iRest} 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
+    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
 >(
-    config: iRest<CustomAndRequiredFields, RestTableInterfaces, RequestTableOverrides, ResponseDataType, RestShortTableNames>
+    config: iRest<
+        RestShortTableName,
+        RestTableInterface,
+        PrimaryKey,
+        CustomAndRequiredFields,
+        RequestTableOverrides,
+        ResponseDataType
+    >
 ) {
     return async (
-        request: iAPI<Modify<RestTableInterfaces, RequestTableOverrides>> & CustomAndRequiredFields = {} as iAPI<Modify<RestTableInterfaces, RequestTableOverrides>> & CustomAndRequiredFields
+        request: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields = {} as iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields
     ): Promise<apiReturn<ResponseDataType>> => {
 
         // 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<
+                RestShortTableName,
+                RestTableInterface,
+                PrimaryKey,
+                CustomAndRequiredFields,
+                RequestTableOverrides,
+                ResponseDataType
+            >(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<
+            RestShortTableName,
+            RestTableInterface,
+            PrimaryKey,
+            CustomAndRequiredFields,
+            RequestTableOverrides,
+            ResponseDataType
+        >(config, request);
         return http.execute();
     };
 }

package/src/api/types/ormInterfaces.ts

@@ -1,4 +1,3 @@
-import restRequest from "api/restRequest";
 import {AxiosInstance, AxiosPromise, AxiosResponse} from "axios";
 import {Pool} from "mysql2/promise";
 import {eFetchDependencies} from "./dynamicFetching";
@@ -41,16 +40,33 @@ export interface iConstraint {
     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;
+    LIFECYCLE_HOOKS: iRestReactiveLifecycle<RequestGetPutDeleteBody>[];
+    TABLE_REFERENCES: { [columnName: string]: iConstraint[] };
+    TABLE_REFERENCED_BY: { [columnName: string]: iConstraint[] };
 }
 
 export interface iRestApiFunctions<RestData = any> {
@@ -68,7 +84,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 +120,6 @@ export interface iCacheAPI<ResponseDataType = any> {
 }
 
 
-
 /**
  * the first argument ....
  *
@@ -226,11 +247,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>,
@@ -252,36 +279,32 @@ export type apiReturn<Response> =
 
 
 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 Extract<keyof RestTableInterface, string> = Extract<keyof RestTableInterface, string>,
+    CustomAndRequiredFields extends { [key: string]: any } = any,
+    RequestTableOverrides = { [key in keyof RestTableInterface]: any },
+    ResponseDataType = any
 > {
     C6: iC6Object,
     axios?: AxiosInstance,
     restURL?: string,
     mysqlPool?: Pool;
     withCredentials?: boolean,
-    tableName: RestShortTableNames | RestShortTableNames[],
+    restModel: iC6RestfulModel<RestShortTableName, RestTableInterface, PrimaryKey>,
     requestMethod: iRestMethods,
     clearCache?: () => void,
     skipPrimaryCheck?: boolean,
-    queryCallback: RequestQueryBody<Modify<RestTableInterfaces, RequestTableOverrides>> | ((request: iAPI<Modify<RestTableInterfaces, RequestTableOverrides>> & CustomAndRequiredFields) => (null | undefined | RequestQueryBody<Modify<RestTableInterfaces, RequestTableOverrides>>)),
+    queryCallback: RequestQueryBody<Modify<RestTableInterface, RequestTableOverrides>> | ((request: iAPI<Modify<RestTableInterface, RequestTableOverrides>> & CustomAndRequiredFields) => (null | undefined | RequestQueryBody<Modify<RestTableInterface, 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
+                        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
 }
 
-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

@@ -36,7 +36,6 @@ export function TestRestfulResponse(response: AxiosResponse | any, success: ((r:
 
     return false;
 
-
 }
 
 export function removePrefixIfExists(tableName: string, prefix: string): string {
@@ -47,7 +46,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

@@ -21,6 +21,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";