@jskit-ai/json-rest-api-core 0.1.37 → 0.1.38

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/json-rest-api-core",
-  version: "0.1.37",
+  version: "0.1.38",
   kind: "runtime",
   description: "Shared internal json-rest-api host runtime for JSKIT server packages.",
   dependsOn: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/json-rest-api-core",
-  "version": "0.1.37",
+  "version": "0.1.38",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -11,6 +11,6 @@
   "dependencies": {
     "hooked-api": "1.x.x",
     "json-rest-api": "1.x.x",
-    "@jskit-ai/kernel": "0.1.92"
+    "@jskit-ai/kernel": "0.1.93"
   }
 }

package/src/server/jsonRestApiHost.js

@@ -1,5 +1,5 @@
 import { Api } from "hooked-api";
-import { AutoFilterPlugin, RestApiKnexPlugin, RestApiPlugin } from "json-rest-api";
+import { AutoFilterPlugin, QueryProjectionsPlugin, RestApiKnexPlugin, RestApiPlugin } from "json-rest-api";
 import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
 import { resolveCrudResourceScopeName } from "@jskit-ai/kernel/shared/support/crudLookup";
 
@@ -125,6 +125,45 @@ function normalizeJsonRestText(value, { fallback = "" } = {}) {
   return normalized || fallback;
 }
 
+function normalizeJsonRestFilterValue(value) {
+  if (value == null) {
+    return undefined;
+  }
+
+  if (Array.isArray(value)) {
+    const entries = value
+      .map((entry) => normalizeJsonRestFilterValue(entry))
+      .filter((entry) => entry !== undefined);
+    return entries.length > 0 ? entries : undefined;
+  }
+
+  if (isPlainJsonRestObject(value)) {
+    const entries = Object.entries(value)
+      .map(([key, entry]) => [normalizeJsonRestText(key), normalizeJsonRestFilterValue(entry)])
+      .filter(([key, entry]) => key && entry !== undefined);
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+  }
+
+  if (typeof value === "string") {
+    const normalized = normalizeJsonRestText(value);
+    return normalized || undefined;
+  }
+
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : undefined;
+  }
+
+  if (typeof value === "bigint") {
+    return String(value);
+  }
+
+  if (typeof value === "boolean") {
+    return value;
+  }
+
+  return undefined;
+}
+
 function normalizeJsonRestObject(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return {};
@@ -183,6 +222,99 @@ function resolveJsonRestCollectionRelationships(resource = {}) {
   return relationships;
 }
 
+function normalizeJsonRestQueryField(fieldName = "", fieldDefinition = {}, projectionDefinition = null) {
+  const normalizedFieldName = normalizeJsonRestText(fieldName);
+  const sourceProjection = isPlainJsonRestObject(projectionDefinition)
+    ? projectionDefinition
+    : isPlainJsonRestObject(fieldDefinition?.storage?.queryProjection)
+      ? fieldDefinition.storage.queryProjection
+      : isPlainJsonRestObject(fieldDefinition?.queryProjection)
+        ? fieldDefinition.queryProjection
+        : null;
+  if (!normalizedFieldName || !sourceProjection) {
+    return null;
+  }
+
+  const sourceFieldDefinition = isPlainJsonRestObject(fieldDefinition) ? fieldDefinition : {};
+  const select = typeof sourceProjection.select === "function"
+    ? sourceProjection.select
+    : typeof sourceProjection.project === "function"
+      ? sourceProjection.project
+      : null;
+  const type = normalizeJsonRestText(sourceProjection.type || sourceFieldDefinition.type);
+  return {
+    ...sourceProjection,
+    ...(type ? { type } : {}),
+    ...(select ? { select } : {})
+  };
+}
+
+function isJsonRestVirtualField(fieldDefinition = null) {
+  return fieldDefinition?.virtual === true ||
+    fieldDefinition?.storage?.virtual === true ||
+    Boolean(fieldDefinition?.storage?.queryProjection || fieldDefinition?.queryProjection);
+}
+
+function applyJsonRestQueryFields(scopeOptions = {}, extraQueryFields = {}) {
+  const schema = normalizeJsonRestObject(scopeOptions.schema);
+  const queryFields = {
+    ...normalizeJsonRestObject(scopeOptions.queryFields)
+  };
+
+  for (const [fieldName, fieldDefinition] of Object.entries(schema)) {
+    const queryField = normalizeJsonRestQueryField(fieldName, fieldDefinition);
+    if (!queryField) {
+      continue;
+    }
+
+    queryFields[fieldName] = queryField;
+    delete schema[fieldName];
+  }
+
+  for (const key of Object.keys(queryFields)) {
+    const schemaFieldDefinition = schema[key];
+    if (!schemaFieldDefinition) {
+      continue;
+    }
+    if (!isJsonRestVirtualField(schemaFieldDefinition)) {
+      throw new Error(
+        `json-rest-api query field "${key}" conflicts with a column-backed schema field.`
+      );
+    }
+    delete schema[key];
+  }
+
+  for (const [fieldName, projectionDefinition] of Object.entries(normalizeJsonRestObject(extraQueryFields))) {
+    const key = normalizeJsonRestText(fieldName);
+    if (!key) {
+      continue;
+    }
+
+    const schemaFieldDefinition = schema[key];
+    if (schemaFieldDefinition && !isJsonRestVirtualField(schemaFieldDefinition)) {
+      throw new Error(
+        `json-rest-api query field "${key}" conflicts with a column-backed schema field.`
+      );
+    }
+
+    const queryField = normalizeJsonRestQueryField(key, schemaFieldDefinition, projectionDefinition);
+    if (!queryField) {
+      continue;
+    }
+
+    queryFields[key] = queryField;
+    if (schemaFieldDefinition) {
+      delete schema[key];
+    }
+  }
+
+  if (Object.keys(queryFields).length > 0) {
+    scopeOptions.queryFields = queryFields;
+  } else {
+    delete scopeOptions.queryFields;
+  }
+}
+
 function buildJsonRestQueryParams(resourceType = "", query = {}, { include = undefined } = {}) {
   const normalizedResourceType = normalizeJsonRestText(resourceType);
   const source = normalizeJsonRestObject(query);
@@ -194,8 +326,8 @@ function buildJsonRestQueryParams(resourceType = "", query = {}, { include = und
       continue;
     }
 
-    const normalizedValue = normalizeJsonRestText(rawValue);
-    if (!normalizedValue) {
+    const normalizedValue = normalizeJsonRestFilterValue(rawValue);
+    if (normalizedValue === undefined) {
       continue;
     }
 
@@ -327,10 +459,25 @@ function createJsonApiRelationship(resourceType = "", id = null) {
   };
 }
 
-function createJsonRestResourceScopeOptions(resource = {}, { writeSerializers = {}, normalizeId = null } = {}) {
+function createJsonRestResourceScopeOptions(
+  resource = {},
+  {
+    writeSerializers = {},
+    normalizeId = null,
+    searchSchema = null,
+    queryFields = null
+  } = {}
+) {
   const scopeOptions = cloneJsonRestResourceValue(resource, {
     writeSerializers: normalizeJsonRestObject(writeSerializers)
   });
+  if (isPlainJsonRestObject(searchSchema)) {
+    scopeOptions.searchSchema = {
+      ...normalizeJsonRestObject(scopeOptions.searchSchema),
+      ...searchSchema
+    };
+  }
+  applyJsonRestQueryFields(scopeOptions, queryFields);
   const collectionRelationships = resolveJsonRestCollectionRelationships(scopeOptions);
   if (Object.keys(collectionRelationships).length > 0) {
     if (
@@ -442,6 +589,7 @@ async function createJsonRestApiHost({ knex }) {
     normalizeId: normalizeRecordId
   });
 
+  await api.use(QueryProjectionsPlugin);
   await api.use(RestApiKnexPlugin, { knex });
   await api.use(AutoFilterPlugin, {
     resolvers: {

package/test/entrypoints.boundary.test.js

@@ -249,6 +249,38 @@ test("shared query/document helpers build json-rest-api request shapes", () => {
 
 });
 
+test("buildJsonRestQueryParams preserves structured filter values", () => {
+  assert.deepEqual(
+    buildJsonRestQueryParams("receivals", {
+      status: ["pending", "open", ""],
+      supplierId: [7, " 8 "],
+      availability: true,
+      weight: {
+        min: 12.5,
+        max: " 18 "
+      },
+      emptyList: [],
+      emptyObject: {},
+      emptyText: " ",
+      cursor: "cursor_1"
+    }),
+    {
+      filters: {
+        status: ["pending", "open"],
+        supplierId: [7, "8"],
+        availability: true,
+        weight: {
+          min: 12.5,
+          max: "18"
+        }
+      },
+      page: {
+        after: "cursor_1"
+      }
+    }
+  );
+});
+
 test("createJsonRestResourceScopeOptions clones canonical resource metadata and resolves symbolic write serializers", () => {
   const serializer = (value) => value;
   const normalizeId = (value) => String(value || "").trim() || null;
@@ -356,6 +388,109 @@ test("createJsonRestResourceScopeOptions clones canonical resource metadata and
   assert.equal(source.schema.createdAt.indexed, undefined);
 });
 
+test("createJsonRestResourceScopeOptions maps server query projections into json-rest-api queryFields", () => {
+  const select = ({ knex }) => knex.raw("1");
+  const resource = {
+    namespace: "receivals",
+    schema: {
+      id: { type: "id", primary: true },
+      remainingProcessableWeight: {
+        type: "number",
+        storage: {
+          virtual: true,
+          queryProjection: {
+            sortable: true,
+            select
+          }
+        }
+      },
+      availableCapacityWeight: {
+        type: "number",
+        storage: {
+          virtual: true
+        }
+      }
+    }
+  };
+
+  const result = createJsonRestResourceScopeOptions(resource, {
+    queryFields: {
+      availableCapacityWeight: {
+        type: "number",
+        select
+      }
+    },
+    searchSchema: {
+      status: { type: "string", filterOperator: "=" }
+    }
+  });
+
+  assert.deepEqual(Object.keys(result.schema), ["id"]);
+  assert.equal(result.queryFields.remainingProcessableWeight.type, "number");
+  assert.equal(result.queryFields.remainingProcessableWeight.sortable, true);
+  assert.equal(result.queryFields.remainingProcessableWeight.select, select);
+  assert.equal(result.queryFields.availableCapacityWeight.select, select);
+  assert.deepEqual(result.searchSchema, {
+    status: { type: "string", filterOperator: "=" }
+  });
+  assert.equal(resource.schema.remainingProcessableWeight.storage.virtual, true);
+});
+
+test("createJsonRestResourceScopeOptions rejects query field names for column-backed schema fields", () => {
+  assert.throws(
+    () => createJsonRestResourceScopeOptions({
+      namespace: "receivals",
+      schema: {
+        id: { type: "id", primary: true },
+        status: { type: "string" }
+      }
+    }, {
+      queryFields: {
+        status: {
+          type: "string",
+          select() {}
+        }
+      }
+    }),
+    /query field "status" conflicts with a column-backed schema field/
+  );
+});
+
+test("createJsonRestApiHost installs json-rest-api query projections", async () => {
+  const fakeKnex = Object.assign(() => {}, {
+    client: {
+      config: {
+        client: "sqlite3"
+      }
+    },
+    raw(sql) {
+      if (String(sql || "").includes("sqlite_version")) {
+        return [{ version: "3.35.5" }];
+      }
+      return { sql };
+    },
+    async transaction() {}
+  });
+  const api = await createJsonRestApiHost({ knex: fakeKnex });
+
+  await api.addResource("projectionContacts", {
+    tableName: "projection_contacts",
+    schema: {
+      id: { type: "id", primary: true }
+    },
+    queryFields: {
+      displayName: {
+        type: "string",
+        select({ knex }) {
+          return knex.raw("'Display'");
+        }
+      }
+    }
+  });
+
+  assert.equal(typeof api.resources.projectionContacts.vars.queryFields.displayName.select, "function");
+});
+
 test("returnNullWhenJsonRestResourceMissing only swallows missing-resource errors", async () => {
   await assert.doesNotReject(async () => {
     const result = await returnNullWhenJsonRestResourceMissing(async () => {