@carbonorm/carbonnode 1.5.2 → 1.6.1

package/scripts/generateRestBindings.cjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+"use strict";
 var __values = (this && this.__values) || function(o) {
     var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
     if (m) return m.call(o);
@@ -10,10 +11,12 @@ var __values = (this && this.__values) || function(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
+Object.defineProperty(exports, "__esModule", { value: true });
 var execSync = require('child_process').execSync;
 var fs = require('fs');
 var path = require('path');
 var Handlebars = require('handlebars');
+var package_json_1 = require("../package.json");
 var args = process.argv.slice(2); // Slice the first two elements
 var argMap = {};
 for (var i = 0; i < args.length; i += 2) {
@@ -284,6 +287,7 @@ var parseSQLToTypeScript = function (sql) {
     }
     var tables = Object.values(tableData);
     return {
+        C6VERSION: package_json_1.version,
         PREFIX: MySQLDump.DB_PREFIX,
         TABLES: tables,
         RestTableNames: tables.map(function (table) { return "'" + table.TABLE_NAME + "'"; }).join('\n | '),
@@ -299,8 +303,8 @@ fs.writeFileSync(path.join(process.cwd(), 'C6MySqlDump.json'), JSON.stringify(ta
 // import this file  src/assets/handlebars/C6.tsx.handlebars for a mustache template
 var c6Template = fs.readFileSync(path.resolve(__dirname, 'assets/handlebars/C6.ts.handlebars'), 'utf-8');
 fs.writeFileSync(path.join(MySQLDump.OUTPUT_DIR, 'C6.ts'), Handlebars.compile(c6Template)(tableData));
-var wsLiveUpdatesTemplate = fs.readFileSync(path.resolve(__dirname, 'assets/handlebars/WsLiveUpdates.ts.handlebars'), 'utf-8');
-fs.writeFileSync(path.join(MySQLDump.OUTPUT_DIR, 'WsLiveUpdates.ts'), Handlebars.compile(wsLiveUpdatesTemplate)(tableData));
+var C6RestApiTemplate = fs.readFileSync(path.resolve(__dirname, 'assets/handlebars/C6RestApi.ts.handlebars'), 'utf-8');
+fs.writeFileSync(path.join(MySQLDump.OUTPUT_DIR, 'C6RestApi.ts'), Handlebars.compile(C6RestApiTemplate)(tableData));
 var template = fs.readFileSync(path.resolve(__dirname, 'assets/handlebars/Table.ts.handlebars'), 'utf-8');
 var testTemplate = fs.readFileSync(path.resolve(__dirname, 'assets/handlebars/Table.test.ts.handlebars'), 'utf-8');
 Object.values(tableData.TABLES).forEach(function (tableData) {

package/scripts/generateRestBindings.ts

@@ -4,7 +4,7 @@ const {execSync} = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const Handlebars = require('handlebars');
-
+import {version} from '../package.json';
 
 const args = process.argv.slice(2);  // Slice the first two elements
 const argMap = {};
@@ -130,13 +130,13 @@ const pathRuntimeReference = MySQLDump.RELATIVE_OUTPUT_DIR.replace(/(^\/(src\/)?
 // Usage example
 const dumpFileLocation = MySQLDump.MySQLDump();
 
-type ColumnInfo = {
+/*type ColumnInfo = {
     type: string;
     length?: string;
     autoIncrement: boolean;
     notNull: boolean;
     defaultValue?: string;
-};
+};*/
 
 type foreignKeyInfo = {
     TABLE: string,
@@ -367,6 +367,7 @@ const parseSQLToTypeScript = (sql: string) => {
 
 
     return {
+        C6VERSION: version,
         PREFIX: MySQLDump.DB_PREFIX,
         TABLES: tables,
         RestTableNames: tables.map(table => "'" + table.TABLE_NAME + "'").join('\n | '),
@@ -389,9 +390,9 @@ const c6Template = fs.readFileSync(path.resolve(__dirname, 'assets/handlebars/C6
 
 fs.writeFileSync(path.join(MySQLDump.OUTPUT_DIR, 'C6.ts'), Handlebars.compile(c6Template)(tableData));
 
-const wsLiveUpdatesTemplate = fs.readFileSync(path.resolve(__dirname, 'assets/handlebars/WsLiveUpdates.ts.handlebars'), 'utf-8');
+const C6RestApiTemplate = fs.readFileSync(path.resolve(__dirname, 'assets/handlebars/C6RestApi.ts.handlebars'), 'utf-8');
 
-fs.writeFileSync(path.join(MySQLDump.OUTPUT_DIR, 'WsLiveUpdates.ts'), Handlebars.compile(wsLiveUpdatesTemplate)(tableData));
+fs.writeFileSync(path.join(MySQLDump.OUTPUT_DIR, 'C6RestApi.ts'), Handlebars.compile(C6RestApiTemplate)(tableData));
 
 const template = fs.readFileSync(path.resolve(__dirname, 'assets/handlebars/Table.ts.handlebars'), 'utf-8');
 

package/src/api/interfaces/ormInterfaces.ts

@@ -1,3 +1,13 @@
+import {
+    apiReturn,
+    iAPI,
+    iDeleteC6RestResponse,
+    iPostC6RestResponse,
+    iGetC6RestResponse,
+    iPutC6RestResponse
+} from "api/restRequest";
+
+
 export interface stringMap {
     [key: string]: string;
 }
@@ -38,8 +48,23 @@ export interface iC6RestfulModel<RestShortTableNames extends string = string> {
     TABLE_REFERENCED_BY: { [columnName: string]: iConstraint[] },
 }
 
+export interface iRestApiFunctions {
+    Delete: (request?: (iAPI<any> & any)) => apiReturn<iDeleteC6RestResponse<any>>;
+    Post: (request?: (iAPI<any> & any)) => apiReturn<iPostC6RestResponse<any>>;
+    Get: (request?: (iAPI<any> & any)) => apiReturn<iGetC6RestResponse<any>>;
+    Put: (request?: (iAPI<any> & any)) => apiReturn<iPutC6RestResponse<any>>
+}
+
+export interface tC6Tables { [key: string]: (iC6RestfulModel & { [key: string]: any }) }
+
+export interface tC6RestApi {
+    [key: string]: {
+        REST: iRestApiFunctions,
+        PUT: Function;
+        POST: Function;
+        DELETE: Function;
+    };
+}
 
-export type tC6Tables = { [key: string]: (iC6RestfulModel & { [key: string]: any }) }
 
-export type tWsLiveUpdate = { [key: string]: { PUT: Function, POST: Function, DELETE: Function } };
 

package/src/api/restRequest.ts

@@ -1,6 +1,6 @@
 import axiosInstance from "api/axiosInstance";
 import convertForRequestBody from "api/convertForRequestBody";
-import {iC6RestfulModel} from "api/interfaces/ormInterfaces";
+import {iC6RestfulModel, iConstraint, iRestApiFunctions} from "api/interfaces/ormInterfaces";
 import {AxiosInstance, AxiosPromise, AxiosResponse} from "axios";
 
 import {toast} from "react-toastify";
@@ -105,10 +105,19 @@ type DeepPartialAny<T> = {
     [P in keyof T]?: T[P] extends AnyObject ? DeepPartialAny<T[P]> : any
 }
 
+export enum eFetchDependencies {
+    NONE = 0,
+    REFERENCED = 1,
+    CHILDREN = 1,
+    REFERENCES = 2,
+    PARENTS = 2,
+    ALL = 3
+}
+
 export type iAPI<RestTableInterfaces extends { [key: string]: any }> = RestTableInterfaces & {
     dataInsertMultipleRows?: RestTableInterfaces[],
     cacheResults?: boolean, // aka ignoreCache
-    fetchDependencies?: boolean,
+    fetchDependencies?: eFetchDependencies|Promise<apiReturn<iGetC6RestResponse<any>>>[],
     debug?: boolean,
     success?: string | ((r: AxiosResponse) => (string | void)),
     error?: string | ((r: AxiosResponse) => (string | void)),
@@ -297,11 +306,15 @@ export interface iPutC6RestResponse<RestData = any, RequestData = any> extends i
 }
 
 export interface iC6Object {
+    C6VERSION: string,
     TABLES: {
         [key: string]: iC6RestfulModel &
             { [key: string]: string | number }
     },
     PREFIX: string,
+    IMPORT: (tableName: string) => Promise<{
+        default: iRestApiFunctions
+    }>,
 
     [key: string]: any
 }
@@ -751,8 +764,9 @@ export default function restApi<
                 // we had removed the value from the request to add to the URI.
                 addBackPK?.();  // adding back so post-processing methods work
 
+                // returning the promise with this then is important for tests. todo - we could make that optional.
                 // https://rapidapi.com/guides/axios-async-await
-                return axiosActiveRequest.then(response => {
+                return axiosActiveRequest.then(async (response) => {
 
                     if (typeof response.data === 'string') {
 
@@ -768,58 +782,143 @@ export default function restApi<
 
                     }
 
+                    if (cachingConfirmed) {
+
+                        const cacheIndex = apiRequestCache.findIndex(cache => cache.requestArgumentsSerialized === querySerialized);
+
+                        apiRequestCache[cacheIndex].final = false === returnGetNextPageFunction
+
+                        // only cache get method requests
+                        apiRequestCache[cacheIndex].response = response
+
+                    }
+
                     apiResponse = TestRestfulResponse(response, request?.success, request?.error ?? "An unexpected API error occurred!")
 
-                    if (false !== apiResponse) {
+                    if (false === apiResponse) {
 
-                        responseCallback(response, request, apiResponse)
+                        if (request.debug && isLocal) {
 
-                        if (C6.GET === requestMethod) {
+                            toast.warning("DEVS: TestRestfulResponse returned false for (" + operatingTable + ").", toastOptionsDevs);
 
-                            const responseData = response.data as iGetC6RestResponse<any>;
+                        }
 
-                            // @ts-ignore
-                            returnGetNextPageFunction = 1 !== query?.[C6.PAGINATION]?.[C6.LIMIT] &&
-                                query?.[C6.PAGINATION]?.[C6.LIMIT] === responseData.rest.length
+                        return response;
 
-                            if (false === isTest || true === isVerbose) {
+                    }
 
-                                console.groupCollapsed('%c API: Response returned length (' + responseData.rest?.length + ') of possible (' + query?.[C6.PAGINATION]?.[C6.LIMIT] + ') limit!', 'color: #0c0')
+                    responseCallback(response, request, apiResponse)
 
-                                console.log('%c ' + requestMethod + ' ' + tableName, 'color: #0c0')
+                    if (C6.GET === requestMethod) {
 
-                                console.log('%c Request Data (note you may see the success and/or error prompt):', 'color: #0c0', request)
+                        const responseData = response.data as iGetC6RestResponse<any>;
 
-                                console.log('%c Response Data:', 'color: #0c0', responseData.rest)
+                        returnGetNextPageFunction = 1 !== query?.[C6.PAGINATION]?.[C6.LIMIT] &&
+                            query?.[C6.PAGINATION]?.[C6.LIMIT] === responseData.rest.length
 
-                                console.log('%c Will return get next page function:' + (1 !== query?.[C6.PAGINATION]?.[C6.LIMIT] ? '' : ' (Will not return with explicit limit 1 set)'), 'color: #0c0', true === returnGetNextPageFunction)
+                        if (false === isTest || true === isVerbose) {
 
-                                console.trace();
+                            console.groupCollapsed('%c API: Response returned length (' + responseData.rest?.length + ') of possible (' + query?.[C6.PAGINATION]?.[C6.LIMIT] + ') limit!', 'color: #0c0')
 
-                                console.groupEnd()
+                            console.log('%c ' + requestMethod + ' ' + tableName, 'color: #0c0')
 
-                            }
+                            console.log('%c Request Data (note you may see the success and/or error prompt):', 'color: #0c0', request)
 
-                            if (false === returnGetNextPageFunction
-                                && true === request.debug
-                                && isLocal) {
+                            console.log('%c Response Data:', 'color: #0c0', responseData.rest)
 
-                                toast.success("DEVS: Response returned length (" + responseData.rest?.length + ") less than limit (" + query?.[C6.PAGINATION]?.[C6.LIMIT] + ").", toastOptionsDevs);
+                            console.log('%c Will return get next page function:' + (1 !== query?.[C6.PAGINATION]?.[C6.LIMIT] ? '' : ' (Will not return with explicit limit 1 set)'), 'color: #0c0', true === returnGetNextPageFunction)
 
-                            }
+                            console.trace();
+
+                            console.groupEnd()
 
                         }
 
-                    }
+                        if (false === returnGetNextPageFunction
+                            && true === request.debug
+                            && isLocal) {
 
-                    if (cachingConfirmed) {
+                            toast.success("DEVS: Response returned length (" + responseData.rest?.length + ") less than limit (" + query?.[C6.PAGINATION]?.[C6.LIMIT] + ").", toastOptionsDevs);
 
-                        const cacheIndex = apiRequestCache.findIndex(cache => cache.requestArgumentsSerialized === querySerialized);
+                        }
 
-                        apiRequestCache[cacheIndex].final = false === returnGetNextPageFunction
+                        if (eFetchDependencies.NONE !== request.fetchDependencies) {
 
-                        // only cache get method requests
-                        apiRequestCache[cacheIndex].response = response
+                            console.groupCollapsed('%c API: fetchDependencies segment', 'color: #0c0')
+
+                            console.log('%c ' + requestMethod + ' ' + tableName, 'color: #0c0')
+
+                            console.trace();
+
+                            const fetchDependencies = async (fetchData: {
+                                [key: string]: iConstraint[]
+                            }) => Object.keys(
+                                fetchData
+                            ).map((column) => {
+
+                                // check if the column is in the response
+                                if (undefined === responseData.rest[column]) {
+
+                                    return false
+
+                                }
+
+                                return fetchData[column].map(async (constraint) => {
+
+                                    console.log(column, constraint.TABLE)
+
+                                    const fetchTable = await C6.IMPORT(constraint.TABLE)
+
+                                    const RestApi = fetchTable.default
+
+                                    return RestApi.Get({
+                                        [C6.WHERE]: {
+                                            [constraint.COLUMN]: responseData.rest[column]
+                                        }
+                                    });
+
+                                });
+
+                            });
+
+                            let dependencies: any[] = [];
+
+                            // noinspection FallThroughInSwitchStatementJS
+                            switch (request.fetchDependencies) {
+                                case eFetchDependencies.ALL:
+                                case eFetchDependencies.CHILDREN:
+                                // @ts-ignore
+                                case eFetchDependencies.REFERENCED:
+
+                                    const referencedBy = C6.TABLES[operatingTable].TABLE_REFERENCED_BY;
+
+                                    dependencies = (await fetchDependencies(referencedBy)).flat(Infinity)
+
+                                    if (request.fetchDependencies !== eFetchDependencies.ALL) {
+
+                                        break;
+
+                                    }
+
+                                case eFetchDependencies.PARENTS:
+                                case eFetchDependencies.REFERENCES:
+
+                                    const references = C6.TABLES[operatingTable].TABLE_REFERENCES;
+
+                                    dependencies = [...dependencies, (await fetchDependencies(references)).flat(Infinity)]
+
+                                    break;
+                                default:
+                                    throw new Error('The value of  fetchDependencies (' + request.fetchDependencies?.toString() + ') was not recognized.')
+                            }
+
+                            request.fetchDependencies = dependencies;
+
+                            await Promise.all(dependencies)
+
+                        }
+
+                        console.groupEnd()
 
                     }
 

package/scripts/assets/handlebars/WsLiveUpdates.ts.handlebars

@@ -1,22 +0,0 @@
-import {
-    tWsLiveUpdate
-} from "@carbonorm/carbonnode";
-
-{{#TABLES}}
-import { putState{{TABLE_NAME_SHORT_PASCAL_CASE}}, postState{{TABLE_NAME_SHORT_PASCAL_CASE}}, deleteState{{TABLE_NAME_SHORT_PASCAL_CASE}} } from "./{{TABLE_NAME_SHORT_PASCAL_CASE}}";
-{{/TABLES}}
-
-const wsLiveUpdates: tWsLiveUpdate = {
-{{#TABLES}}
-    {{TABLE_NAME_SHORT}}: {
-        PUT: putState{{TABLE_NAME_SHORT_PASCAL_CASE}},
-        POST: postState{{TABLE_NAME_SHORT_PASCAL_CASE}},
-        DELETE: deleteState{{TABLE_NAME_SHORT_PASCAL_CASE}},
-    },
-{{/TABLES}}
-};
-
-
-export default wsLiveUpdates;
-
-