@carbonorm/carbonnode 3.7.12 → 3.7.14

package/src/__tests__/expressServer.e2e.test.ts

@@ -0,0 +1,94 @@
+import mysql from "mysql2/promise";
+import axios from "axios";
+import { AddressInfo } from "net";
+import {describe, it, expect, beforeAll, afterAll} from "vitest";
+import {Actor, C6, GLOBAL_REST_PARAMETERS} from "./sakila-db/C6.js";
+import {C6C} from "../api/C6Constants";
+import createTestServer from "../api/handlers/createTestServer";
+
+let pool: mysql.Pool;
+let server: any;
+
+beforeAll(async () => {
+    pool = mysql.createPool({
+        host: "127.0.0.1",
+        user: "root",
+        password: "password",
+        database: "sakila",
+    });
+
+    const app = createTestServer({C6, mysqlPool: pool});
+    server = app.listen(0);
+    await new Promise(resolve => server.on('listening', resolve));
+    const {port} = server.address() as AddressInfo;
+
+    GLOBAL_REST_PARAMETERS.restURL = `http://127.0.0.1:${port}/rest/`;
+    GLOBAL_REST_PARAMETERS.axios = axios;
+    GLOBAL_REST_PARAMETERS.verbose = false;
+    // ensure HTTP executor is used
+    // @ts-ignore
+    delete GLOBAL_REST_PARAMETERS.mysqlPool;
+});
+
+afterAll(async () => {
+    await new Promise(resolve => server.close(resolve));
+    await pool.end();
+});
+
+describe("ExpressHandler e2e", () => {
+    it("handles GET requests", async () => {
+        const data = await Actor.Get({
+            [C6C.PAGINATION]: {
+                [C6C.LIMIT]: 1
+            },
+        });
+        expect(Array.isArray(data?.rest)).toBe(true);
+        expect(data?.rest?.length).toBeGreaterThan(0);
+    });
+
+
+    it("handles empty get requests", async () => {
+        const data = await Actor.Get({});
+        expect(Array.isArray(data?.rest)).toBe(true);
+        expect(data?.rest?.length).toBeGreaterThan(0);
+    });
+
+    it("handles POST, GET by id, PUT, and DELETE", async () => {
+        const first_name = `Test${Date.now()}`;
+        const last_name = `User${Date.now()}`;
+
+        await Actor.Post({
+            first_name,
+            last_name,
+        } as any);
+
+        let data = await Actor.Get({
+            [C6C.WHERE]: { [Actor.FIRST_NAME]: first_name, [Actor.LAST_NAME]: last_name },
+            [C6C.PAGINATION]: { [C6C.LIMIT]: 1 },
+        } as any);
+        expect(data?.rest).toHaveLength(1);
+        const testId = data?.rest[0].actor_id;
+
+
+        await Actor.Put({
+            [C6C.WHERE]: { [Actor.ACTOR_ID]: testId },
+            [C6C.UPDATE]: { first_name: "Updated" },
+        } as any);
+        data = await Actor.Get({
+            [C6C.WHERE]: { [Actor.ACTOR_ID]: testId },
+        } as any);
+        expect(data?.rest).toHaveLength(1);
+        expect(data?.rest[0].first_name).toBe("Updated");
+
+        await Actor.Delete({
+            [C6C.WHERE]: { [Actor.ACTOR_ID]: testId },
+            [C6C.DELETE]: true,
+        } as any);
+        data = await Actor.Get({
+            [C6C.WHERE]: { [Actor.ACTOR_ID]: testId },
+            cacheResults: false,
+        } as any);
+        expect(Array.isArray(data?.rest)).toBe(true);
+        expect(data?.rest.length).toBe(0);
+    });
+});

package/src/__tests__/sakila-db/C6.js

@@ -1304,7 +1304,7 @@ export const TABLES = {
 };
 export const C6 = {
     ...C6Constants,
-    C6VERSION: '3.7.12',
+    C6VERSION: '3.7.14',
     IMPORT: async (tableName) => {
         tableName = tableName.toLowerCase();
         // if tableName is not a key in the TABLES object then throw an error

package/src/__tests__/sakila-db/C6.ts

@@ -1940,7 +1940,7 @@ export type RestTableInterfaces = iActor
 
 export const C6 : iC6Object<RestTableInterfaces> = {
     ...C6Constants,
-    C6VERSION: '3.7.12',
+    C6VERSION: '3.7.14',
     IMPORT: async (tableName: string) : Promise<iDynamicApiImport> => {
 
         tableName = tableName.toLowerCase();

package/src/api/executors/HttpExecutor.ts

@@ -15,11 +15,11 @@ import {
     PUT, RequestQueryBody
 } from "../types/ormInterfaces";
 import {removeInvalidKeys, removePrefixIfExists, TestRestfulResponse} from "../utils/apiHelpers";
-import { normalizeSingularRequest } from "../utils/normalizeSingularRequest";
 import {apiRequestCache, checkCache, userCustomClearCache} from "../utils/cacheManager";
 import {sortAndSerializeQueryObject} from "../utils/sortAndSerializeQueryObject";
 import {Executor} from "./Executor";
 import {toastOptions, toastOptionsDevs} from "variables/toastOptions";
+import {normalizeSingularRequest} from "../utils/normalizeSingularRequest";
 
 export class HttpExecutor<
     G extends OrmGenerics
@@ -130,8 +130,6 @@ export class HttpExecutor<
             clearCache,
         } = this.config
 
-        console.log('this.config', this.config)
-
         await this.runLifecycleHooks<"beforeProcessing">(
             "beforeProcessing", {
                 config: this.config,
@@ -790,7 +788,7 @@ export class HttpExecutor<
                                                 accumulator.push(row['entity_tag']);
                                             }
                                             return accumulator;
-                                        }, []).map((entityTag) => entityTag.split('\\').pop().toLowerCase());
+                                        }, []).map((entityTag) => entityTag.split('\\')?.pop()?.toLowerCase()!);
 
                                         const shouldContinue = referencesTables.find((referencesTable) => tableToFetch.endsWith(referencesTable))
 

package/src/api/handlers/createTestServer.ts

@@ -0,0 +1,15 @@
+import express, {Express} from "express";
+import {Pool} from "mysql2/promise";
+import {iC6Object} from "api/types/ormInterfaces";
+import {ExpressHandler} from "./ExpressHandler";
+
+export function createTestServer({C6, mysqlPool}: {C6: iC6Object; mysqlPool: Pool;}): Express {
+    const app = express();
+    app.set('query parser', 'extended');
+    app.use(express.json());
+    app.all("/rest/:table", ExpressHandler({C6, mysqlPool}));
+    app.all("/rest/:table/:primary", ExpressHandler({C6, mysqlPool}));
+    return app;
+}
+
+export default createTestServer;

package/src/api/types/ormInterfaces.ts

@@ -127,7 +127,8 @@ export interface iGetC6RestResponse<
     ResponseDataType extends { [key: string]: any },
     ResponseDataOverrides = {}
 > extends iC6RestResponse<
-    Modify<ResponseDataType, ResponseDataOverrides> | Modify<ResponseDataType, ResponseDataOverrides>[]
+    // TODO - We removed Modify<ResponseDataType, ResponseDataOverrides> |
+    Modify<ResponseDataType, ResponseDataOverrides>[]
 > {
     next?: () => Promise<DetermineResponseDataType<"GET", ResponseDataType, ResponseDataOverrides>>;
 }

package/src/index.ts

@@ -16,6 +16,8 @@ export * from "./api/executors/Executor";
 export * from "./api/executors/HttpExecutor";
 export * from "./api/executors/SqlExecutor";
 export * from "./api/handlers/ExpressHandler";
+export { default as createTestServer } from "./api/handlers/createTestServer";
+export * from "./api/handlers/createTestServer";
 export * from "./api/orm/queryHelpers";
 export * from "./api/orm/builders/AggregateBuilder";
 export * from "./api/orm/builders/ConditionBuilder";