@jskit-ai/json-rest-api-core 0.1.29 → 0.1.31

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/json-rest-api-core",
-  version: "0.1.29",
+  version: "0.1.31",
   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.29",
+  "version": "0.1.31",
   "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.84"
+    "@jskit-ai/kernel": "0.1.86"
   }
 }

package/src/server/jsonRestApiHost.js

@@ -1,6 +1,7 @@
 import { Api } from "hooked-api";
 import { AutoFilterPlugin, RestApiKnexPlugin, RestApiPlugin } from "json-rest-api";
 import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
+import { resolveCrudResourceScopeName } from "@jskit-ai/kernel/shared/support/crudLookup";
 
 const INTERNAL_JSON_REST_API = "internal.json-rest-api";
 
@@ -79,6 +80,12 @@ function cloneJsonRestResourceValue(value, { writeSerializers = {} } = {}) {
       delete next.storage.writeSerializer;
     }
   }
+  if (
+    isPlainJsonRestObject(next.relation) &&
+    normalizeJsonRestText(next.relation.kind).toLowerCase() === "collection"
+  ) {
+    next.virtual = true;
+  }
 
   return next;
 }
@@ -144,6 +151,38 @@ function normalizeJsonRestList(value) {
     .filter(Boolean);
 }
 
+function resolveJsonRestCollectionRelationships(resource = {}) {
+  const resourceSchema = normalizeJsonRestObject(resource?.schema);
+  const relationships = {};
+
+  for (const [fieldName, fieldDefinition] of Object.entries(resourceSchema)) {
+    const normalizedFieldDefinition = normalizeJsonRestObject(fieldDefinition);
+    const relation = normalizeJsonRestObject(normalizedFieldDefinition.relation);
+    if (normalizeJsonRestText(relation.kind).toLowerCase() !== "collection") {
+      continue;
+    }
+
+    const relationshipName = normalizeJsonRestText(relation.as || normalizedFieldDefinition.as, {
+      fallback: fieldName
+    });
+    const target = resolveCrudResourceScopeName(
+      relation.target || relation.targetResource || relation.namespace || relation.apiPath
+    );
+    const foreignKey = normalizeJsonRestText(relation.foreignKey);
+    if (!relationshipName || !target || !foreignKey) {
+      continue;
+    }
+
+    relationships[relationshipName] = {
+      type: "hasMany",
+      target,
+      foreignKey
+    };
+  }
+
+  return relationships;
+}
+
 function buildJsonRestQueryParams(resourceType = "", query = {}, { include = undefined } = {}) {
   const normalizedResourceType = normalizeJsonRestText(resourceType);
   const source = normalizeJsonRestObject(query);
@@ -292,6 +331,23 @@ function createJsonRestResourceScopeOptions(resource = {}, { writeSerializers =
   const scopeOptions = cloneJsonRestResourceValue(resource, {
     writeSerializers: normalizeJsonRestObject(writeSerializers)
   });
+  const collectionRelationships = resolveJsonRestCollectionRelationships(scopeOptions);
+  if (Object.keys(collectionRelationships).length > 0) {
+    if (
+      scopeOptions.relationships !== undefined &&
+      scopeOptions.relationships !== null &&
+      !isPlainJsonRestObject(scopeOptions.relationships)
+    ) {
+      throw new TypeError(
+        "json-rest-api resource relationships must be an object when collection relations are derived."
+      );
+    }
+
+    scopeOptions.relationships = {
+      ...collectionRelationships,
+      ...normalizeJsonRestObject(scopeOptions.relationships)
+    };
+  }
 
   if (typeof normalizeId === "function") {
     scopeOptions.normalizeId = normalizeId;

package/test/entrypoints.boundary.test.js

@@ -290,6 +290,26 @@ test("createJsonRestResourceScopeOptions clones canonical resource metadata and
             required: false
           })
         })
+      }),
+      pets: Object.freeze({
+        type: "array",
+        relation: Object.freeze({
+          kind: "collection",
+          namespace: "pets",
+          foreignKey: "contactId"
+        }),
+        operations: Object.freeze({
+          output: Object.freeze({
+            required: false
+          })
+        })
+      })
+    }),
+    relationships: Object.freeze({
+      auditEvents: Object.freeze({
+        type: "hasMany",
+        target: "auditEvents",
+        foreignKey: "contactId"
       })
     }),
     operations: Object.freeze({
@@ -314,10 +334,23 @@ test("createJsonRestResourceScopeOptions clones canonical resource metadata and
   assert.equal(result.schema.createdAt.storage.serialize(null), null);
   assert.equal(result.schema.createdAt.storage.writeSerializer, undefined);
   assert.equal(result.schema.bookingSteps.virtual, true);
+  assert.equal(result.schema.pets.virtual, true);
   assert.equal(result.normalizeId, normalizeId);
   assert.equal(result.schema.name.maxLength, 190);
   assert.equal(result.schema.name.operations.output.required, true);
   assert.equal(result.operations.view.method, "GET");
+  assert.deepEqual(result.relationships, {
+    pets: {
+      type: "hasMany",
+      target: "pets",
+      foreignKey: "contactId"
+    },
+    auditEvents: {
+      type: "hasMany",
+      target: "auditEvents",
+      foreignKey: "contactId"
+    }
+  });
 
   result.schema.createdAt.indexed = true;
   assert.equal(source.schema.createdAt.indexed, undefined);