@carbonorm/carbonnode 6.0.12 → 6.0.13

package/dist/types/ormInterfaces.d.ts

@@ -1,4 +1,4 @@
-import type { AxiosInstance, AxiosPromise, AxiosResponse } from "axios";
+import type { AxiosInstance, AxiosResponse } from "axios";
 import type { Pool } from "mysql2/promise";
 import { eFetchDependencies } from "./dynamicFetching";
 import { Modify } from "./modifyTypes";
@@ -92,10 +92,20 @@ export type RequestQueryBody<Method extends iRestMethods, T extends {
 } = {}, Overrides extends {
     [key: string]: any;
 } = {}> = Method extends 'GET' | 'PUT' | 'DELETE' ? iAPI<RequestGetPutDeleteBody<Modify<T, Overrides> & Custom>> : iAPI<RequestPostBody<Modify<T, Overrides> & Custom>>;
+export interface iCacheRequestConfig {
+    method?: string;
+    url?: string;
+    headers?: any;
+}
+export interface iCacheResponse<ResponseDataType = any> {
+    data: ResponseDataType;
+    config?: iCacheRequestConfig;
+    [key: string]: any;
+}
 export interface iCacheAPI<ResponseDataType = any> {
     requestArgumentsSerialized: string;
-    request: AxiosPromise<ResponseDataType>;
-    response?: AxiosResponse & {
+    request: Promise<iCacheResponse<ResponseDataType>>;
+    response?: iCacheResponse<ResponseDataType> & {
         __carbonTiming?: {
             start: number;
             end: number;

package/dist/utils/cacheManager.d.ts

@@ -1,9 +1,8 @@
-import type { AxiosPromise } from "axios";
-import type { iCacheAPI } from "../types/ormInterfaces";
+import type { iCacheAPI, iCacheResponse } from "../types/ormInterfaces";
 export declare const apiRequestCache: Map<string, iCacheAPI<any>>;
 export declare const userCustomClearCache: (() => void)[];
 export declare function clearCache(props?: {
     ignoreWarning?: boolean;
 }): void;
-export declare function checkCache<ResponseDataType = any>(method: string, tableName: string | string[], requestData: any): AxiosPromise<ResponseDataType> | false;
+export declare function checkCache<ResponseDataType = any>(method: string, tableName: string | string[], requestData: any): Promise<iCacheResponse<ResponseDataType>> | false;
 export declare function setCache<ResponseDataType = any>(method: string, tableName: string | string[], requestData: any, cacheEntry: iCacheAPI<ResponseDataType>): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carbonorm/carbonnode",
-  "version": "6.0.12",
+  "version": "6.0.13",
   "browser": "dist/index.umd.js",
   "repository": {
     "type": "git",

package/src/__tests__/convertForRequestBody.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from "vitest";
+import convertForRequestBody from "../api/convertForRequestBody";
+import { C6Constants as C6C } from "../constants/C6Constants";
+
+const C6 = {
+  TABLES: {
+    actor: {
+      TABLE_NAME: "actor",
+      ACTOR_ID: "actor.actor_id",
+      FIRST_NAME: "actor.first_name",
+      LAST_NAME: "actor.last_name",
+      COLUMNS: {
+        "actor.actor_id": "actor_id",
+        "actor.first_name": "first_name",
+        "actor.last_name": "last_name",
+      },
+      REGEX_VALIDATION: {},
+    },
+  },
+} as any;
+
+describe("convertForRequestBody", () => {
+  it("preserves primitive control keys and maps shorthand columns", () => {
+    const payload = convertForRequestBody(
+      {
+        actor_id: 5,
+        [C6C.DELETE]: true,
+        cacheResults: false,
+      } as any,
+      "actor",
+      C6,
+    );
+
+    expect(payload).toMatchObject({
+      "actor.actor_id": 5,
+      [C6C.DELETE]: true,
+      cacheResults: false,
+    });
+  });
+
+  it("normalizes object control keys deterministically", () => {
+    const payload = convertForRequestBody(
+      {
+        [C6C.WHERE]: {
+          "actor.last_name": "B",
+          "actor.first_name": "A",
+        },
+      } as any,
+      "actor",
+      C6,
+    );
+
+    expect(Object.keys(payload[C6C.WHERE])).toEqual([
+      "actor.first_name",
+      "actor.last_name",
+    ]);
+  });
+});

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

@@ -2,12 +2,49 @@ import mysql from "mysql2/promise";
 import axios from "axios";
 import { AddressInfo } from "net";
 import {describe, it, expect, beforeAll, afterAll} from "vitest";
-import {Actor, C6, Film_Actor, GLOBAL_REST_PARAMETERS} from "./sakila-db/C6.js";
+import { restOrm } from "@carbonorm/carbonnode";
+import {Actor, C6, Film_Actor} from "./sakila-db/C6.js";
 import {C6C} from "../constants/C6Constants";
 import createTestServer from "./fixtures/createTestServer";
 
 let pool: mysql.Pool;
 let server: any;
+let restURL: string;
+let axiosClient: ReturnType<typeof axios.create>;
+const actorHttp = restOrm<any>(() => ({
+    C6,
+    restModel: C6.TABLES.actor,
+    restURL,
+    axios: axiosClient,
+    verbose: false,
+}));
+const filmActorHttp = restOrm<any>(() => ({
+    C6,
+    restModel: C6.TABLES.film_actor,
+    restURL,
+    axios: axiosClient,
+    verbose: false,
+}));
+
+const actorRequest = async (
+    method: "GET" | "POST" | "PUT" | "DELETE",
+    request: any
+) => {
+    if (method === "GET") return actorHttp.Get(request as any);
+    if (method === "POST") return actorHttp.Post(request as any);
+    if (method === "PUT") return actorHttp.Put(request as any);
+    return actorHttp.Delete(request as any);
+};
+
+const filmActorRequest = async (
+    method: "GET" | "POST" | "PUT" | "DELETE",
+    request: any
+) => {
+    if (method === "GET") return filmActorHttp.Get(request as any);
+    if (method === "POST") return filmActorHttp.Post(request as any);
+    if (method === "PUT") return filmActorHttp.Put(request as any);
+    return filmActorHttp.Delete(request as any);
+};
 
 beforeAll(async () => {
     pool = mysql.createPool({
@@ -22,17 +59,12 @@ beforeAll(async () => {
     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/`;
-    const axiosClient = axios.create();
+    restURL = `http://127.0.0.1:${port}/rest/`;
+    axiosClient = axios.create();
     axiosClient.interceptors.response.use(
         response => response,
         error => Promise.reject(new Error(error?.message ?? 'Request failed')),
     );
-    GLOBAL_REST_PARAMETERS.axios = axiosClient;
-    GLOBAL_REST_PARAMETERS.verbose = false;
-    // ensure HTTP executor is used
-    // @ts-ignore
-    delete GLOBAL_REST_PARAMETERS.mysqlPool;
 });
 
 afterAll(async () => {
@@ -42,7 +74,7 @@ afterAll(async () => {
 
 describe("ExpressHandler e2e", () => {
     it("handles GET requests", async () => {
-        const data = await Actor.Get({
+        const data = await actorRequest("GET", {
             [C6C.PAGINATION]: {
                 [C6C.LIMIT]: 1
             },
@@ -53,7 +85,7 @@ describe("ExpressHandler e2e", () => {
 
 
     it("handles empty get requests", async () => {
-        const data = await Actor.Get({});
+        const data = await actorRequest("GET", {});
         expect(Array.isArray(data?.rest)).toBe(true);
         expect(data?.rest?.length).toBeGreaterThan(0);
     });
@@ -62,12 +94,12 @@ describe("ExpressHandler e2e", () => {
         const first_name = `Test${Date.now()}`;
         const last_name = `User${Date.now()}`;
 
-        await Actor.Post({
+        await actorRequest("POST", {
             first_name,
             last_name,
         } as any);
 
-        let data = await Actor.Get({
+        let data = await actorRequest("GET", {
             [C6C.WHERE]: { [Actor.FIRST_NAME]: first_name, [Actor.LAST_NAME]: last_name },
             [C6C.PAGINATION]: { [C6C.LIMIT]: 1 },
         } as any);
@@ -75,22 +107,22 @@ describe("ExpressHandler e2e", () => {
         expect(data?.rest).toHaveLength(1);
         const testId = data?.rest[0].actor_id;
 
-        await Actor.Put({
+        await actorRequest("PUT", {
             [C6C.WHERE]: { [Actor.ACTOR_ID]: testId },
             [C6C.UPDATE]: { first_name: "Updated" },
         } as any);
 
-        data = await Actor.Get({
+        data = await actorRequest("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({
+        await actorRequest("DELETE", {
             [C6C.WHERE]: { [Actor.ACTOR_ID]: testId },
             [C6C.DELETE]: true,
         } as any);
-        data = await Actor.Get({
+        data = await actorRequest("GET", {
             [C6C.WHERE]: { [Actor.ACTOR_ID]: testId },
             cacheResults: false,
         } as any);
@@ -102,14 +134,14 @@ describe("ExpressHandler e2e", () => {
         const first_name = `Json${Date.now()}`;
         const last_name = `User${Date.now()}`;
 
-        await Actor.Post({
+        await actorRequest("POST", {
             first_name,
             last_name,
         } as any);
 
         const payload = { greeting: "hello", flags: [1, true] };
 
-        let data = await Actor.Get({
+        let data = await actorRequest("GET", {
             [C6C.WHERE]: { [Actor.FIRST_NAME]: first_name, [Actor.LAST_NAME]: last_name },
             [C6C.PAGINATION]: { [C6C.LIMIT]: 1 },
         } as any);
@@ -117,12 +149,12 @@ describe("ExpressHandler e2e", () => {
         const actorId = data?.rest?.[0]?.actor_id;
         expect(actorId).toBeTruthy();
 
-        await Actor.Put({
+        await actorRequest("PUT", {
             [C6C.WHERE]: { [Actor.ACTOR_ID]: actorId },
             [C6C.UPDATE]: { first_name: payload },
         } as any);
 
-        data = await Actor.Get({
+        data = await actorRequest("GET", {
             [C6C.WHERE]: { [Actor.ACTOR_ID]: actorId },
         } as any);
 
@@ -133,12 +165,12 @@ describe("ExpressHandler e2e", () => {
         const first_name = `Invalid${Date.now()}`;
         const last_name = `User${Date.now()}`;
 
-        await Actor.Post({
+        await actorRequest("POST", {
             first_name,
             last_name,
         } as any);
 
-        const data = await Actor.Get({
+        const data = await actorRequest("GET", {
             [C6C.WHERE]: { [Actor.FIRST_NAME]: first_name, [Actor.LAST_NAME]: last_name },
             [C6C.PAGINATION]: { [C6C.LIMIT]: 1 },
         } as any);
@@ -148,14 +180,14 @@ describe("ExpressHandler e2e", () => {
 
         const operatorLike = { [C6C.GREATER_THAN]: "oops" } as any;
 
-        const prevRestUrl = GLOBAL_REST_PARAMETERS.restURL;
-        const prevAxios = GLOBAL_REST_PARAMETERS.axios;
-        GLOBAL_REST_PARAMETERS.mysqlPool = pool as any;
-        delete (GLOBAL_REST_PARAMETERS as any).restURL;
-        delete (GLOBAL_REST_PARAMETERS as any).axios;
-
         try {
-            await Actor.Put({
+            const actorSql = restOrm<any>(() => ({
+                C6,
+                restModel: C6.TABLES.actor,
+                mysqlPool: pool,
+                verbose: false,
+            }));
+            await actorSql.Put({
                 [C6C.WHERE]: { [Actor.ACTOR_ID]: actorId },
                 [C6C.UPDATE]: { first_name: operatorLike },
             } as any);
@@ -163,16 +195,10 @@ describe("ExpressHandler e2e", () => {
         } catch (error: any) {
             const message = String(error?.message ?? error);
             expect(message).toMatch(/operand/i);
-        } finally {
-            GLOBAL_REST_PARAMETERS.restURL = prevRestUrl;
-            GLOBAL_REST_PARAMETERS.axios = prevAxios;
-            // @ts-ignore
-            delete GLOBAL_REST_PARAMETERS.mysqlPool;
         }
     });
 
     it("respects METHOD=GET override on POST", async () => {
-        const {restURL} = GLOBAL_REST_PARAMETERS;
         const table = Actor.TABLE_NAME;
 
         const response = await axios.post(`${restURL}${table}?METHOD=GET`, {
@@ -185,7 +211,6 @@ describe("ExpressHandler e2e", () => {
     });
 
     it("ignores unsupported METHOD overrides", async () => {
-        const {restURL} = GLOBAL_REST_PARAMETERS;
         const table = Actor.TABLE_NAME;
 
         const first_name = `Override${Date.now()}`;
@@ -201,10 +226,9 @@ describe("ExpressHandler e2e", () => {
     });
 
     it("allows composite keys when a URL primary is present", async () => {
-        const {restURL} = GLOBAL_REST_PARAMETERS;
         const table = Film_Actor.TABLE_NAME;
 
-        const seed = await Film_Actor.Get({
+        const seed = await filmActorRequest("GET", {
             [C6C.PAGINATION]: { [C6C.LIMIT]: 1 },
         } as any);
 

package/src/__tests__/fixtures/createTestServer.ts

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

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

@@ -2,12 +2,32 @@ import mysql from "mysql2/promise";
 import axios from "axios";
 import { AddressInfo } from "net";
 import { describe, it, expect, beforeAll, afterAll, vi } from "vitest";
-import { Actor, C6, GLOBAL_REST_PARAMETERS } from "./sakila-db/C6.js";
+import { restOrm } from "@carbonorm/carbonnode";
+import { Actor, C6 } from "./sakila-db/C6.js";
 import { C6C } from "../constants/C6Constants";
 import createTestServer from "./fixtures/createTestServer";
 
 let pool: mysql.Pool;
 let server: any;
+let restURL: string;
+let axiosClient: ReturnType<typeof axios.create>;
+const actorHttp = restOrm<any>(() => ({
+  C6,
+  restModel: C6.TABLES.actor,
+  restURL,
+  axios: axiosClient,
+  verbose: false,
+}));
+
+const actorRequest = async (
+  method: "GET" | "POST" | "PUT" | "DELETE",
+  request: any
+) => {
+  if (method === "GET") return actorHttp.Get(request as any);
+  if (method === "POST") return actorHttp.Post(request as any);
+  if (method === "PUT") return actorHttp.Put(request as any);
+  return actorHttp.Delete(request as any);
+};
 
 beforeAll(async () => {
   pool = mysql.createPool({
@@ -22,17 +42,20 @@ beforeAll(async () => {
   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/`;
-  const axiosClient = axios.create();
+  restURL = `http://127.0.0.1:${port}/rest/`;
+  axiosClient = axios.create();
   axiosClient.interceptors.response.use(
     response => response,
-    error => Promise.reject(new Error(error?.message ?? "Request failed")),
+    error => {
+      const serverError = error?.response?.data?.error;
+      const message =
+        serverError?.message
+        ?? (typeof serverError === "string" ? serverError : undefined)
+        ?? error?.message
+        ?? "Request failed";
+      return Promise.reject(new Error(message));
+    },
   );
-  GLOBAL_REST_PARAMETERS.axios = axiosClient;
-  GLOBAL_REST_PARAMETERS.verbose = false;
-  // ensure HTTP executor is used
-  // @ts-ignore
-  delete GLOBAL_REST_PARAMETERS.mysqlPool;
 });
 
 afterAll(async () => {
@@ -44,59 +67,73 @@ describe("HttpExecutor singular e2e", () => {
   it("handles CRUD with singular objects", async () => {
     const first_name = `Test${Date.now()}`;
     const last_name = `User${Date.now()}`;
-
-    // POST
-    await Actor.Post({ first_name, last_name } as any);
-
-    // Fetch inserted id using complex query
-    let data = await Actor.Get({
-      [C6C.WHERE]: { [Actor.FIRST_NAME]: first_name, [Actor.LAST_NAME]: last_name },
-      [C6C.PAGINATION]: { [C6C.LIMIT]: 1 },
-    });
-
-    expect(data.rest).toHaveLength(1);
-    const testId = data.rest[0].actor_id;
-
-    // GET singular
-    data = await Actor.Get({ actor_id: testId } as any);
-    expect(data.rest).toHaveLength(1);
-    expect(data.rest[0].actor_id).toBe(testId);
-
-    // PUT singular
-    await Actor.Put({ actor_id: testId, first_name: "Updated" } as any);
-    data = await Actor.Get({ actor_id: testId, cacheResults: false } as any);
-    expect(data.rest).toHaveLength(1);
-    expect(data.rest[0].first_name).toBe("Updated");
-
-    // PUT using fully qualified keys
-    const updateStub = vi.fn();
-    GLOBAL_REST_PARAMETERS.reactBootstrap = {
-      updateRestfulObjectArrays: updateStub,
-      deleteRestfulObjectArrays: vi.fn(),
-    } as any;
-    await Actor.Put({
-      [Actor.ACTOR_ID]: testId,
-      [Actor.FIRST_NAME]: "UpdatedFQ",
-    } as any);
-    expect(updateStub).toHaveBeenCalled();
-    const args = updateStub.mock.calls[0][0];
-    expect(args.dataOrCallback[0]).toHaveProperty("first_name", "UpdatedFQ");
-    expect(args.dataOrCallback[0]).toHaveProperty("actor_id", testId);
-    expect(args.dataOrCallback[0]).not.toHaveProperty(Actor.FIRST_NAME);
-    GLOBAL_REST_PARAMETERS.reactBootstrap = undefined as any;
-    data = await Actor.Get({ actor_id: testId, cacheResults: false } as any);
-    expect(data.rest).toHaveLength(1);
-    expect(data.rest[0].first_name).toBe("UpdatedFQ");
-
-    // DELETE singular
-    await Actor.Delete({ actor_id: testId } as any);
-    data = await Actor.Get({ actor_id: testId, cacheResults: false } as any);
-    expect(Array.isArray(data.rest)).toBe(true);
-    expect(data.rest.length).toBe(0);
+    let step = "POST";
+
+    try {
+      // POST
+      await actorRequest("POST", { first_name, last_name } as any);
+
+      step = "GET-complex";
+      // Fetch inserted id using complex query
+      let data = await actorRequest("GET", {
+        [C6C.WHERE]: { [Actor.FIRST_NAME]: first_name, [Actor.LAST_NAME]: last_name },
+        [C6C.PAGINATION]: { [C6C.LIMIT]: 1 },
+      });
+
+      expect(data.rest).toHaveLength(1);
+      const testId = data.rest[0].actor_id;
+
+      step = "GET-singular";
+      // GET singular
+      data = await actorRequest("GET", { actor_id: testId } as any);
+      expect(data.rest).toHaveLength(1);
+      expect(data.rest[0].actor_id).toBe(testId);
+
+      step = "PUT-singular";
+      // PUT singular
+      await actorRequest("PUT", { actor_id: testId, first_name: "Updated" } as any);
+      data = await actorRequest("GET", { actor_id: testId, cacheResults: false } as any);
+      expect(data.rest).toHaveLength(1);
+      expect(data.rest[0].first_name).toBe("Updated");
+
+      step = "PUT-fq-react";
+      // PUT using fully qualified keys
+      const updateStub = vi.fn();
+      const reactBootstrap = {
+        updateRestfulObjectArrays: updateStub,
+        deleteRestfulObjectArrays: vi.fn(),
+      } as any;
+      const actorHttpWithReact = restOrm<any>(() => ({
+        C6,
+        restModel: C6.TABLES.actor,
+        restURL,
+        axios: axiosClient,
+        verbose: false,
+        reactBootstrap,
+      }));
+      await actorHttpWithReact.Put({
+        [Actor.ACTOR_ID]: testId,
+        [Actor.FIRST_NAME]: "UpdatedFQ",
+      } as any);
+      expect(updateStub).toHaveBeenCalled();
+      const args = updateStub.mock.calls[0][0];
+      expect(args.dataOrCallback[0]).toHaveProperty("first_name", "UpdatedFQ");
+      expect(args.dataOrCallback[0]).toHaveProperty("actor_id", testId);
+      expect(args.dataOrCallback[0]).not.toHaveProperty(Actor.FIRST_NAME);
+
+      step = "DELETE-singular";
+      // DELETE singular
+      await actorRequest("DELETE", { actor_id: testId } as any);
+      data = await actorRequest("GET", { actor_id: testId, cacheResults: false } as any);
+      expect(Array.isArray(data.rest)).toBe(true);
+      expect(data.rest.length).toBe(0);
+    } catch (error: any) {
+      throw new Error(`Failed at step ${step}: ${String(error?.message ?? error)}`);
+    }
   });
 
   it("exposes next when pagination continues", async () => {
-    const data = await Actor.Get({
+    const data = await actorRequest("GET", {
       [C6C.PAGINATION]: { [C6C.LIMIT]: 2 },
     } as any);
 
@@ -111,7 +148,7 @@ describe("HttpExecutor singular e2e", () => {
   });
 
   it("exposes limit 1 does not expose next", async () => {
-    const data = await Actor.Get({
+    const data = await actorRequest("GET", {
       [C6C.PAGINATION]: { [C6C.LIMIT]: 1 },
     } as any);
 

package/src/__tests__/logSql.test.ts

@@ -67,4 +67,17 @@ describe("colorSql", () => {
         expect(colored).toContain("\x1b[94mUPDATE\x1b[0m");
         expect(colored).toContain("\x1b[94mDUPLICATE\x1b[0m");
     });
+
+    it("collapses repeated multi-row value groups", () => {
+        const sql = `INSERT INTO \`valuation_report_comparables\` (a,b,c) VALUES
+            (?, ?, ?),
+            (?, ?, ?),
+            (?, ?, ?),
+            (?, ?, ?)`;
+        const colored = colorSql(sql);
+        const plain = stripAnsi(colored);
+
+        expect(plain).toContain("(? ×3) ×4");
+        expect(plain).not.toContain("(? ×3),");
+    });
 });

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

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