@jskit-ai/json-rest-api-core 0.1.1 → 0.1.3

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/json-rest-api-core",
-  version: "0.1.1",
+  version: "0.1.3",
   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.1",
+  "version": "0.1.3",
   "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.56"
+    "@jskit-ai/kernel": "0.1.58"
   }
 }

package/src/server/jsonRestApiHost.js

@@ -63,6 +63,9 @@ function cloneJsonRestResourceValue(value, { writeSerializers = {} } = {}) {
 
   if (isPlainJsonRestObject(next.storage)) {
     const serializerKey = normalizeJsonRestText(next.storage.writeSerializer).toLowerCase();
+    if (next.storage.virtual === true) {
+      next.virtual = true;
+    }
     if (serializerKey) {
       const serializer = writeSerializers[serializerKey];
       if (typeof serializer !== "function") {
@@ -195,16 +198,68 @@ function buildJsonRestQueryParams(resourceType = "", query = {}, { include = und
   return queryParams;
 }
 
-function createJsonApiInputRecord(resourceType = "", attributes = {}, { id = null, relationships = null } = {}) {
-  const normalizedRelationships = normalizeJsonRestObject(relationships);
+function extractJsonApiInputRelationships(attributes = {}, resource = null, relationships = null) {
+  const normalizedAttributes = {
+    ...normalizeJsonRestObject(attributes)
+  };
+  const normalizedRelationships = {
+    ...normalizeJsonRestObject(relationships)
+  };
+  const resourceSchema = normalizeJsonRestObject(resource?.schema);
+
+  for (const [fieldName, fieldDefinition] of Object.entries(resourceSchema)) {
+    if (!Object.hasOwn(normalizedAttributes, fieldName)) {
+      continue;
+    }
+
+    const normalizedFieldDefinition = normalizeJsonRestObject(fieldDefinition);
+    const relationshipType = normalizeJsonRestText(normalizedFieldDefinition.belongsTo);
+    if (!relationshipType) {
+      continue;
+    }
+
+    const relationshipName = normalizeJsonRestText(normalizedFieldDefinition.as, {
+      fallback: fieldName
+    });
+    if (!relationshipName) {
+      continue;
+    }
+
+    const relationshipValue = normalizedAttributes[fieldName];
+    delete normalizedAttributes[fieldName];
+
+    if (relationshipValue === undefined) {
+      continue;
+    }
+
+    if (!Object.hasOwn(normalizedRelationships, relationshipName)) {
+      normalizedRelationships[relationshipName] = createJsonApiRelationship(
+        relationshipType,
+        relationshipValue
+      );
+    }
+  }
+
+  return {
+    attributes: normalizedAttributes,
+    relationships: normalizedRelationships
+  };
+}
+
+function createJsonApiInputRecord(
+  resourceType = "",
+  attributes = {},
+  { id = null, relationships = null, resource = null } = {}
+) {
+  const normalizedInput = extractJsonApiInputRelationships(attributes, resource, relationships);
   return {
     data: {
       type: normalizeJsonRestText(resourceType),
       ...(id == null ? {} : { id: String(id) }),
-      attributes: {
-        ...normalizeJsonRestObject(attributes)
-      },
-      ...(Object.keys(normalizedRelationships).length < 1 ? {} : { relationships: normalizedRelationships })
+      attributes: normalizedInput.attributes,
+      ...(Object.keys(normalizedInput.relationships).length < 1
+        ? {}
+        : { relationships: normalizedInput.relationships })
     }
   };
 }

package/test/entrypoints.boundary.test.js

@@ -106,6 +106,9 @@ test("createJsonRestApiHost installs normalizeRecordId as the default resource i
   });
 
   assert.equal(api.vars.normalizeId, normalizeRecordId);
+  assert.equal(api.vars.normalizeId(7), "7");
+  assert.equal(api.vars.normalizeId(0), null);
+  assert.equal(api.vars.normalizeId(7.5), null);
 });
 
 test("shared query/document helpers build json-rest-api request shapes", () => {
@@ -162,6 +165,42 @@ test("shared query/document helpers build json-rest-api request shapes", () => {
     }
   );
 
+  assert.deepEqual(
+    createJsonApiInputRecord("products", {
+      serviceId: "9",
+      name: "Style Groom"
+    }, {
+      resource: {
+        schema: {
+          serviceId: {
+            type: "id",
+            belongsTo: "services",
+            as: "service"
+          },
+          name: {
+            type: "string"
+          }
+        }
+      }
+    }),
+    {
+      data: {
+        type: "products",
+        attributes: {
+          name: "Style Groom"
+        },
+        relationships: {
+          service: {
+            data: {
+              type: "services",
+              id: "9"
+            }
+          }
+        }
+      }
+    }
+  );
+
   assert.deepEqual(
     simplifyJsonApiDocument({
       data: [
@@ -234,6 +273,17 @@ test("createJsonRestResourceScopeOptions clones canonical resource metadata and
             required: true
           })
         })
+      }),
+      bookingSteps: Object.freeze({
+        type: "array",
+        storage: Object.freeze({
+          virtual: true
+        }),
+        operations: Object.freeze({
+          output: Object.freeze({
+            required: false
+          })
+        })
       })
     }),
     operations: Object.freeze({
@@ -255,7 +305,9 @@ test("createJsonRestResourceScopeOptions clones canonical resource metadata and
   assert.notEqual(result.schema.createdAt, source.schema.createdAt);
   assert.equal(result.schema.createdAt.storage.column, "created_at");
   assert.equal(result.schema.createdAt.storage.serialize, serializer);
+  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.normalizeId, normalizeId);
   assert.equal(result.schema.name.maxLength, 190);
   assert.equal(result.schema.name.operations.output.required, true);