@jskit-ai/crud-core 0.1.26 → 0.1.28

package/test/repositorySupport.test.js

@@ -6,10 +6,49 @@ import {
   requireCrudTableName,
   buildWritePayload,
   mapRecordRow,
+  applyCrudListQueryFilters,
   resolveCrudIdColumn,
-  buildRepositoryColumnMetadata
+  buildRepositoryColumnMetadata,
+  deriveRepositoryMappingFromResource
 } from "../src/server/repositorySupport.js";
 
+function createQueryDouble() {
+  const calls = [];
+  const whereQuery = {
+    where(...args) {
+      calls.push(["innerWhere", ...args]);
+      return whereQuery;
+    },
+    orWhere(...args) {
+      calls.push(["innerOrWhere", ...args]);
+      return whereQuery;
+    }
+  };
+
+  const query = {
+    modify(callback) {
+      calls.push(["modify"]);
+      callback(query);
+      return query;
+    },
+    where(...args) {
+      if (args.length === 1 && typeof args[0] === "function") {
+        calls.push(["whereGroup"]);
+        args[0](whereQuery);
+        return query;
+      }
+
+      calls.push(["where", ...args]);
+      return query;
+    }
+  };
+
+  return {
+    query,
+    calls
+  };
+}
+
 test("normalizeCrudListLimit enforces fallback and max", () => {
   assert.equal(normalizeCrudListLimit(null), DEFAULT_LIST_LIMIT);
   assert.equal(normalizeCrudListLimit("abc"), DEFAULT_LIST_LIMIT);
@@ -53,6 +92,62 @@ test("buildWritePayload respects defined keys", () => {
   });
 });
 
+test("applyCrudListQueryFilters applies search and cursor filters", () => {
+  const { query, calls } = createQueryDouble();
+  const result = applyCrudListQueryFilters(query, {
+    idColumn: "id",
+    cursor: "3",
+    q: "ani",
+    searchColumns: ["first_name", "last_name"]
+  });
+
+  assert.equal(result, query);
+  assert.deepEqual(calls, [
+    ["modify"],
+    ["whereGroup"],
+    ["innerWhere", "first_name", "like", "%ani%"],
+    ["innerOrWhere", "last_name", "like", "%ani%"],
+    ["where", "id", ">", 3]
+  ]);
+});
+
+test("applyCrudListQueryFilters skips search and cursor when inputs are empty", () => {
+  const { query, calls } = createQueryDouble();
+  const result = applyCrudListQueryFilters(query, {
+    cursor: 0,
+    q: "  ",
+    searchColumns: []
+  });
+
+  assert.equal(result, query);
+  assert.deepEqual(calls, []);
+});
+
+test("applyCrudListQueryFilters applies parent FK filters from allowed columns", () => {
+  const { query, calls } = createQueryDouble();
+  const result = applyCrudListQueryFilters(query, {
+    parentFilters: {
+      contactId: " 7 ",
+      ignored: "x"
+    },
+    parentFilterColumns: {
+      contactId: "contact_id"
+    }
+  });
+
+  assert.equal(result, query);
+  assert.deepEqual(calls, [
+    ["where", "contact_id", "7"]
+  ]);
+});
+
+test("applyCrudListQueryFilters throws for invalid query builders", () => {
+  assert.throws(
+    () => applyCrudListQueryFilters({}),
+    /requires query builder/
+  );
+});
+
 test("resolveCrudIdColumn falls back and rejects empties", () => {
   assert.equal(resolveCrudIdColumn("  custom_id  "), "custom_id");
   assert.equal(resolveCrudIdColumn(undefined, { fallback: "fallback_id" }), "fallback_id");
@@ -71,3 +166,189 @@ test("buildRepositoryColumnMetadata normalizes columns and applies overrides", (
   assert.equal(metadata.writeMappings.length, 1);
   assert.equal(metadata.outputMappings[1].column, "surname");
 });
+
+test("deriveRepositoryMappingFromResource reads schema keys and fieldMeta dbColumn overrides", () => {
+  const resource = {
+    operations: {
+      view: {
+        outputValidator: {
+          schema: {
+            type: "object",
+            properties: {
+              id: { type: "integer" },
+              firstName: { type: "string" },
+              createdAt: { type: "string" }
+            }
+          }
+        }
+      },
+      create: {
+        bodyValidator: {
+          schema: {
+            type: "object",
+            properties: {
+              firstName: { type: "string" },
+              vetId: { type: "integer" }
+            }
+          }
+        }
+      }
+    },
+    fieldMeta: [
+      {
+        key: "createdAt",
+        dbColumn: "created_at"
+      },
+      {
+        key: "vetId",
+        dbColumn: "vet_id",
+        relation: {
+          kind: "lookup",
+          namespace: "vets",
+          valueKey: "id"
+        }
+      }
+    ]
+  };
+
+  const mapping = deriveRepositoryMappingFromResource(resource);
+  assert.deepEqual(mapping.outputKeys, ["id", "firstName", "createdAt"]);
+  assert.deepEqual(mapping.writeKeys, ["firstName", "vetId"]);
+  assert.deepEqual(mapping.columnOverrides, {
+    createdAt: "created_at",
+    vetId: "vet_id"
+  });
+  assert.deepEqual(mapping.listSearchColumns, ["first_name", "created_at"]);
+  assert.deepEqual(mapping.parentFilterColumns, {
+    vetId: "vet_id"
+  });
+});
+
+test("deriveRepositoryMappingFromResource excludes runtime-only lookups output key from db mapping", () => {
+  const resource = {
+    operations: {
+      view: {
+        outputValidator: {
+          schema: {
+            type: "object",
+            properties: {
+              id: { type: "integer" },
+              firstName: { type: "string" },
+              lookups: { type: "object" }
+            }
+          }
+        }
+      },
+      create: {
+        bodyValidator: {
+          schema: {
+            type: "object",
+            properties: {
+              firstName: { type: "string" }
+            }
+          }
+        }
+      }
+    },
+    fieldMeta: []
+  };
+
+  const mapping = deriveRepositoryMappingFromResource(resource);
+  assert.deepEqual(mapping.outputKeys, ["id", "firstName"]);
+});
+
+test("deriveRepositoryMappingFromResource excludes custom lookup output container key", () => {
+  const resource = {
+    contract: {
+      lookup: {
+        containerKey: "lookupData"
+      }
+    },
+    operations: {
+      view: {
+        outputValidator: {
+          schema: {
+            type: "object",
+            properties: {
+              id: { type: "integer" },
+              firstName: { type: "string" },
+              lookupData: { type: "object" }
+            }
+          }
+        }
+      },
+      create: {
+        bodyValidator: {
+          schema: {
+            type: "object",
+            properties: {
+              firstName: { type: "string" }
+            }
+          }
+        }
+      }
+    },
+    fieldMeta: []
+  };
+
+  const mapping = deriveRepositoryMappingFromResource(resource);
+  assert.deepEqual(mapping.outputKeys, ["id", "firstName"]);
+});
+
+test("deriveRepositoryMappingFromResource throws when view schema properties are missing", () => {
+  const resource = {
+    operations: {
+      view: {
+        outputValidator: {
+          schema: {
+            type: "object"
+          }
+        }
+      },
+      create: {
+        bodyValidator: {
+          schema: {
+            type: "object",
+            properties: {
+              firstName: { type: "string" }
+            }
+          }
+        }
+      }
+    }
+  };
+
+  assert.throws(
+    () => deriveRepositoryMappingFromResource(resource),
+    /operations\.view\.outputValidator\.schema\.properties/
+  );
+});
+
+test("deriveRepositoryMappingFromResource throws when create schema properties are missing", () => {
+  const resource = {
+    operations: {
+      view: {
+        outputValidator: {
+          schema: {
+            type: "object",
+            properties: {
+              id: { type: "integer" }
+            }
+          }
+        }
+      },
+      create: {
+        bodyValidator: {
+          schema: {
+            type: "object"
+          }
+        }
+      }
+    }
+  };
+
+  assert.throws(
+    () => deriveRepositoryMappingFromResource(resource),
+    /operations\.create\.bodyValidator\.schema\.properties/
+  );
+});

package/test/serviceEvents.test.js

@@ -0,0 +1,28 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createCrudServiceEvents } from "../src/server/serviceEvents.js";
+
+test("createCrudServiceEvents builds CRUD realtime events from resource namespace", () => {
+  const events = createCrudServiceEvents({
+    resource: "contacts"
+  });
+
+  assert.equal(events.createRecord[0].realtime.event, "contacts.record.changed");
+  assert.equal(events.updateRecord[0].realtime.event, "contacts.record.changed");
+  assert.equal(events.deleteRecord[0].realtime.event, "contacts.record.changed");
+});
+
+test("createCrudServiceEvents normalizes namespace into realtime event format", () => {
+  const events = createCrudServiceEvents({
+    resource: "customer-orders"
+  });
+
+  assert.equal(events.createRecord[0].realtime.event, "customer_orders.record.changed");
+});
+
+test("createCrudServiceEvents validates required resource namespace", () => {
+  assert.throws(
+    () => createCrudServiceEvents({}),
+    /resource\.resource/
+  );
+});