@carbonorm/carbonnode 3.11.0 → 4.0.1

package/package.json

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

package/src/__tests__/cacheManager.test.ts

@@ -0,0 +1,67 @@
+import type { AxiosPromise } from "axios";
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  apiRequestCache,
+  checkCache,
+  clearCache,
+  setCache,
+} from "../api/utils/cacheManager";
+import { checkAllRequestsComplete } from "../api/utils/testHelpers";
+
+describe("cacheManager with map storage", () => {
+  const requestData = { id: 1 } as const;
+
+  beforeEach(() => {
+    clearCache({ ignoreWarning: true });
+  });
+
+  it("stores and returns cached requests", () => {
+    const mockRequest = Promise.resolve({ data: { rest: [] } }) as AxiosPromise;
+
+    setCache("GET", "table", requestData, {
+      requestArgumentsSerialized: "serialized",
+      request: mockRequest,
+    });
+
+    const cached = checkCache("GET", "table", { ...requestData });
+    expect(cached).toBe(mockRequest);
+  });
+
+  it("clears cache entries", () => {
+    const mockRequest = Promise.resolve({ data: { rest: [] } }) as AxiosPromise;
+
+    setCache("GET", "table", requestData, {
+      requestArgumentsSerialized: "serialized",
+      request: mockRequest,
+    });
+
+    clearCache({ ignoreWarning: true });
+
+    expect(apiRequestCache.size).toBe(0);
+    expect(checkCache("GET", "table", requestData)).toBe(false);
+  });
+
+  it("reports pending and completed requests via helper", () => {
+    const originalDocument = (global as any).document;
+    (global as any).document = {};
+
+    setCache("GET", "table", requestData, {
+      requestArgumentsSerialized: "pending",
+      request: Promise.resolve({ data: null }) as AxiosPromise,
+    });
+
+    expect(checkAllRequestsComplete()).toEqual(["pending"]);
+
+    setCache("GET", "table", requestData, {
+      requestArgumentsSerialized: "pending",
+      request: Promise.resolve({ data: null }) as AxiosPromise,
+      response: {} as any,
+      final: true,
+    });
+
+    expect(checkAllRequestsComplete()).toBe(true);
+
+    (global as any).document = originalDocument;
+  });
+});
+

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

@@ -2,7 +2,7 @@ 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 {Actor, C6, Film_Actor, GLOBAL_REST_PARAMETERS} from "./sakila-db/C6.js";
 import {C6C} from "../api/C6Constants";
 import createTestServer from "./fixtures/createTestServer";
 
@@ -23,7 +23,12 @@ beforeAll(async () => {
     const {port} = server.address() as AddressInfo;
 
     GLOBAL_REST_PARAMETERS.restURL = `http://127.0.0.1:${port}/rest/`;
-    GLOBAL_REST_PARAMETERS.axios = axios;
+    const 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
@@ -93,6 +98,79 @@ describe("ExpressHandler e2e", () => {
         expect(data?.rest.length).toBe(0);
     });
 
+    it("stringifies plain object values in PUT updates", async () => {
+        const first_name = `Json${Date.now()}`;
+        const last_name = `User${Date.now()}`;
+
+        await Actor.Post({
+            first_name,
+            last_name,
+        } as any);
+
+        const payload = { greeting: "hello", flags: [1, true] };
+
+        let data = await Actor.Get({
+            [C6C.WHERE]: { [Actor.FIRST_NAME]: first_name, [Actor.LAST_NAME]: last_name },
+            [C6C.PAGINATION]: { [C6C.LIMIT]: 1 },
+        } as any);
+
+        const actorId = data?.rest?.[0]?.actor_id;
+        expect(actorId).toBeTruthy();
+
+        await Actor.Put({
+            [C6C.WHERE]: { [Actor.ACTOR_ID]: actorId },
+            [C6C.UPDATE]: { first_name: payload },
+        } as any);
+
+        data = await Actor.Get({
+            [C6C.WHERE]: { [Actor.ACTOR_ID]: actorId },
+        } as any);
+
+        expect(data?.rest?.[0]?.first_name).toBe(JSON.stringify(payload));
+    });
+
+    it("rejects operator-like objects in PUT updates", async () => {
+        const first_name = `Invalid${Date.now()}`;
+        const last_name = `User${Date.now()}`;
+
+        await Actor.Post({
+            first_name,
+            last_name,
+        } as any);
+
+        const data = await Actor.Get({
+            [C6C.WHERE]: { [Actor.FIRST_NAME]: first_name, [Actor.LAST_NAME]: last_name },
+            [C6C.PAGINATION]: { [C6C.LIMIT]: 1 },
+        } as any);
+
+        const actorId = data?.rest?.[0]?.actor_id;
+        expect(actorId).toBeTruthy();
+
+        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({
+                [C6C.WHERE]: { [Actor.ACTOR_ID]: actorId },
+                [C6C.UPDATE]: { first_name: operatorLike },
+            } as any);
+            throw new Error('Expected PUT to reject for operator-like payload.');
+        } 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;
@@ -121,4 +199,28 @@ describe("ExpressHandler e2e", () => {
         expect(response.status).toBe(200);
         expect(response.data?.success).toBeTruthy();
     });
+
+    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({
+            [C6C.PAGINATION]: { [C6C.LIMIT]: 1 },
+        } as any);
+
+        const filmActor = seed.rest[0];
+        expect(filmActor).toBeTruthy();
+
+        const response = await axios.post(`${restURL}${table}/${filmActor.actor_id}?METHOD=GET`, {
+            [C6C.WHERE]: {
+                [Film_Actor.ACTOR_ID]: filmActor.actor_id,
+                [Film_Actor.FILM_ID]: filmActor.film_id,
+            },
+        });
+
+        expect(response.status).toBe(200);
+        expect(response.data?.rest).toHaveLength(1);
+        expect(response.data?.rest?.[0]?.actor_id).toBe(filmActor.actor_id);
+        expect(response.data?.rest?.[0]?.film_id).toBe(filmActor.film_id);
+    });
 });

package/src/__tests__/fixtures/c6.fixture.ts

@@ -43,6 +43,7 @@ export function buildTestConfig() {
     'actor.first_name': 'first_name',
     'actor.last_name': 'last_name',
     'actor.binarycol': 'binarycol',
+    'actor.json_data': 'json_data',
   } as const;
 
   const filmActorCols = {
@@ -62,6 +63,7 @@ export function buildTestConfig() {
 
   // Special-case: mark binary column as BINARY to test conversion
   C6.TABLES.actor.TYPE_VALIDATION['binarycol'].MYSQL_TYPE = 'BINARY(16)';
+  C6.TABLES.actor.TYPE_VALIDATION['json_data'].MYSQL_TYPE = 'JSON';
 
   const baseConfig: iRest<any, any, any> = {
     C6,

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

@@ -23,7 +23,12 @@ beforeAll(async () => {
   const { port } = server.address() as AddressInfo;
 
   GLOBAL_REST_PARAMETERS.restURL = `http://127.0.0.1:${port}/rest/`;
-  GLOBAL_REST_PARAMETERS.axios = axios;
+  const 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
@@ -41,14 +46,14 @@ describe("HttpExecutor singular e2e", () => {
     const last_name = `User${Date.now()}`;
 
     // POST
-    const postRes = await Actor.Post({ first_name, last_name } as any);
-    expect(postRes.affected).toBe(1);
+    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 },
-    } as any);
+    });
+
     expect(data.rest).toHaveLength(1);
     const testId = data.rest[0].actor_id;
 
@@ -89,4 +94,30 @@ describe("HttpExecutor singular e2e", () => {
     expect(Array.isArray(data.rest)).toBe(true);
     expect(data.rest.length).toBe(0);
   });
+
+  it("exposes next when pagination continues", async () => {
+    const data = await Actor.Get({
+      [C6C.PAGINATION]: { [C6C.LIMIT]: 2 },
+    } as any);
+
+    expect(Array.isArray(data.rest)).toBe(true);
+    expect(data.rest).toHaveLength(2);
+    expect(typeof data.next).toBe("function");
+
+    const nextPage = await data.next?.();
+    expect(nextPage?.rest).toBeDefined();
+    expect(Array.isArray(nextPage?.rest)).toBe(true);
+    expect(nextPage?.rest?.length).toBeGreaterThan(0);
+  });
+
+  it("exposes limit 1 does not expose next", async () => {
+    const data = await Actor.Get({
+      [C6C.PAGINATION]: { [C6C.LIMIT]: 1 },
+    } as any);
+
+    expect(Array.isArray(data.rest)).toBe(true);
+    expect(data.rest).toHaveLength(1);
+    expect(typeof data.next).toBe("undefined");
+
+  });
 });

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

@@ -1342,7 +1342,7 @@ export const TABLES = {
 };
 export const C6 = {
     ...C6Constants,
-    C6VERSION: '3.11.0',
+    C6VERSION: '4.0.1',
     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

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

package/src/__tests__/sqlBuilders.test.ts

@@ -61,6 +61,51 @@ describe('SQL Builders', () => {
     expect(params).toEqual(['BOB', 'SMITH']);
   });
 
+  it('stringifies plain object inserts for JSON columns', () => {
+    const config = buildTestConfig();
+    const payload = { hello: 'world', nested: { ok: true } };
+    const qb = new PostQueryBuilder(config as any, {
+      [C6C.INSERT]: {
+        'actor.json_data': payload,
+      },
+    } as any, false);
+
+    const { sql, params } = qb.build('actor');
+
+    expect(sql).toContain('`json_data`');
+    expect(params).toEqual([JSON.stringify(payload)]);
+  });
+
+  it('stringifies dotted-key JSON payloads for JSON columns on UPDATE', () => {
+    const config = buildTestConfig();
+    const payload = { 'section1.preparedBy': 'Prepared by Assessorly, Co.' };
+    const qb = new UpdateQueryBuilder(config as any, {
+      [C6C.UPDATE]: {
+        'actor.json_data': payload,
+      },
+      WHERE: {
+        'actor.actor_id': [C6C.EQUAL, 5],
+      }
+    } as any, false);
+
+    const { params } = qb.build('actor');
+
+    expect(params).toEqual([JSON.stringify(payload), 5]);
+  });
+
+  it('throws on operator-shaped insert payloads', () => {
+    const config = buildTestConfig();
+    const qb = new PostQueryBuilder(config as any, {
+      [C6C.INSERT]: {
+        'actor.first_name': {
+          [C6C.GREATER_THAN]: 'ALICE',
+        },
+      },
+    } as any, false);
+
+    expect(() => qb.build('actor')).toThrowError(/requires two operands/);
+  });
+
   it('builds UPDATE with WHERE and pagination', () => {
     const config = buildTestConfig();
     const qb = new UpdateQueryBuilder(config as any, {

package/src/api/axiosInstance.ts

@@ -151,7 +151,36 @@ axiosInstance.interceptors.request.use((config) => {
         }
     }
 
+    (config as any).__carbonStart = performance.now();
+
     return config;
 });
 
+
+axiosInstance.interceptors.response.use(
+    (response) => {
+        const end = performance.now();
+        const start = (response.config as any).__carbonStart;
+        (response as any).__carbonTiming = {
+            start,
+            end,
+            duration: end - start,
+        };
+        return response;
+    },
+    (error) => {
+        if (error.config) {
+            const end = performance.now();
+            const start = (error.config as any).__carbonStart;
+            (error as any).__carbonTiming = {
+                start,
+                end,
+                duration: end - start,
+            };
+        }
+        throw error;
+    }
+);
+
+
 export default axiosInstance