@jskit-ai/json-rest-api-core 0.1.2 → 0.1.4

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/json-rest-api-core",
-  version: "0.1.2",
+  version: "0.1.4",
   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.2",
+  "version": "0.1.4",
   "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.57"
+    "@jskit-ai/kernel": "0.1.59"
   }
 }

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,77 @@ function buildJsonRestQueryParams(resourceType = "", query = {}, { include = und
   return queryParams;
 }
 
-function createJsonApiInputRecord(resourceType = "", attributes = {}, { id = null, relationships = null } = {}) {
-  const normalizedRelationships = normalizeJsonRestObject(relationships);
+function extractJsonRestCollectionRows(payload = null) {
+  if (Array.isArray(payload)) {
+    return payload;
+  }
+
+  const source = normalizeJsonRestObject(payload);
+  return Array.isArray(source.data) ? source.data : [];
+}
+
+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 })
     }
   };
 }
@@ -236,131 +300,6 @@ function createJsonRestResourceScopeOptions(resource = {}, { writeSerializers =
   return scopeOptions;
 }
 
-function normalizeJsonApiResourceObject(resource = {}) {
-  const normalizedResource = normalizeJsonRestObject(resource);
-  return {
-    type: normalizeJsonRestText(normalizedResource.type),
-    id: normalizedResource.id == null ? null : String(normalizedResource.id),
-    attributes: normalizeJsonRestObject(normalizedResource.attributes),
-    relationships: normalizeJsonRestObject(normalizedResource.relationships)
-  };
-}
-
-function buildJsonApiIncludedIndex(payload = {}) {
-  const included = Array.isArray(payload?.included) ? payload.included : [];
-  const index = new Map();
-
-  for (const entry of included) {
-    const normalizedEntry = normalizeJsonApiResourceObject(entry);
-    if (!normalizedEntry.type || !normalizedEntry.id) {
-      continue;
-    }
-
-    index.set(`${normalizedEntry.type}:${normalizedEntry.id}`, normalizedEntry);
-  }
-
-  return index;
-}
-
-function simplifyJsonApiRelationshipData(data, { includedIndex = null, seen = null } = {}) {
-  if (Array.isArray(data)) {
-    return data
-      .map((entry) => simplifyJsonApiRelationshipData(entry, { includedIndex, seen }))
-      .filter((entry) => entry != null);
-  }
-
-  if (data == null) {
-    return null;
-  }
-
-  const normalizedReference = normalizeJsonApiResourceObject(data);
-  if (!normalizedReference.id) {
-    return null;
-  }
-
-  const referenceKey =
-    normalizedReference.type && normalizedReference.id
-      ? `${normalizedReference.type}:${normalizedReference.id}`
-      : "";
-  const nextSeen = seen instanceof Set ? new Set(seen) : new Set();
-
-  if (referenceKey) {
-    if (nextSeen.has(referenceKey)) {
-      return {
-        id: normalizedReference.id,
-        ...(normalizedReference.type ? { type: normalizedReference.type } : {})
-      };
-    }
-    nextSeen.add(referenceKey);
-  }
-
-  if (referenceKey && includedIndex instanceof Map && includedIndex.has(referenceKey)) {
-    return simplifyJsonApiResourceObject(includedIndex.get(referenceKey), {
-      includedIndex,
-      seen: nextSeen
-    });
-  }
-
-  return {
-    id: normalizedReference.id,
-    ...(normalizedReference.type ? { type: normalizedReference.type } : {})
-  };
-}
-
-function simplifyJsonApiResourceObject(resource = {}, { includedIndex = null, seen = null } = {}) {
-  const normalizedResource = normalizeJsonApiResourceObject(resource);
-  const resourceKey =
-    normalizedResource.type && normalizedResource.id
-      ? `${normalizedResource.type}:${normalizedResource.id}`
-      : "";
-  const nextSeen = seen instanceof Set ? new Set(seen) : new Set();
-
-  if (resourceKey) {
-    nextSeen.add(resourceKey);
-  }
-
-  const simplified = {
-    ...(normalizedResource.id == null ? {} : { id: normalizedResource.id }),
-    ...normalizedResource.attributes
-  };
-
-  for (const [relationshipKey, relationshipValue] of Object.entries(normalizedResource.relationships)) {
-    if (!relationshipKey || !relationshipValue || !Object.hasOwn(relationshipValue, "data")) {
-      continue;
-    }
-
-    simplified[relationshipKey] = simplifyJsonApiRelationshipData(relationshipValue.data, {
-      includedIndex,
-      seen: nextSeen
-    });
-  }
-
-  return simplified;
-}
-
-function simplifyJsonApiDocument(payload = {}) {
-  const source = normalizeJsonRestObject(payload);
-  const includedIndex = buildJsonApiIncludedIndex(source);
-
-  if (Array.isArray(source.data)) {
-    return source.data.map((entry) => simplifyJsonApiResourceObject(entry, { includedIndex }));
-  }
-
-  if (source.data && typeof source.data === "object") {
-    return simplifyJsonApiResourceObject(source.data, { includedIndex });
-  }
-
-  if (Object.hasOwn(source, "data") && source.data == null) {
-    return null;
-  }
-
-  if (source.meta && typeof source.meta === "object" && !Array.isArray(source.meta)) {
-    return source.meta;
-  }
-
-  return payload;
-}
-
 function createJsonRestContext(context = null) {
   if (!context || typeof context !== "object" || Array.isArray(context)) {
     return {};
@@ -481,11 +420,11 @@ export {
   createJsonApiRelationship,
   createJsonRestResourceScopeOptions,
   createJsonRestContext,
+  extractJsonRestCollectionRows,
   isJsonRestResourceMissingError,
   returnNullWhenJsonRestResourceMissing,
   resolveWorkspaceScopeValue,
   resolveUserScopeValue,
-  simplifyJsonApiDocument,
   createJsonRestApiHost,
   registerJsonRestApiHost
 };

package/test/entrypoints.boundary.test.js

@@ -12,12 +12,12 @@ import {
   createJsonRestResourceScopeOptions,
   createJsonRestContext,
   createJsonRestApiHost,
+  extractJsonRestCollectionRows,
   isJsonRestResourceMissingError,
   registerJsonRestApiHost,
   returnNullWhenJsonRestResourceMissing,
   resolveWorkspaceScopeValue,
-  resolveUserScopeValue,
-  simplifyJsonApiDocument
+  resolveUserScopeValue
 } from "../src/server/jsonRestApiHost.js";
 import { JsonRestApiCoreServiceProvider } from "../src/server/JsonRestApiCoreServiceProvider.js";
 
@@ -28,6 +28,11 @@ test("package exports include explicit server jsonRestApiHost entrypoint only",
   assert.equal(exportsMap["./server"], undefined);
 });
 
+test("server jsonRestApiHost entrypoint no longer exports host-side JSON:API simplification helpers", async () => {
+  const hostModule = await import("../src/server/jsonRestApiHost.js");
+  assert.equal(Object.hasOwn(hostModule, "simplifyJsonApiDocument"), false);
+});
+
 test("server entrypoint exports shared host helpers", () => {
   assert.equal(INTERNAL_JSON_REST_API, "internal.json-rest-api");
   assert.equal(typeof addResourceIfMissing, "function");
@@ -37,12 +42,12 @@ test("server entrypoint exports shared host helpers", () => {
   assert.equal(typeof createJsonRestResourceScopeOptions, "function");
   assert.equal(typeof createJsonRestContext, "function");
   assert.equal(typeof createJsonRestApiHost, "function");
+  assert.equal(typeof extractJsonRestCollectionRows, "function");
   assert.equal(typeof isJsonRestResourceMissingError, "function");
   assert.equal(typeof registerJsonRestApiHost, "function");
   assert.equal(typeof returnNullWhenJsonRestResourceMissing, "function");
   assert.equal(typeof resolveWorkspaceScopeValue, "function");
   assert.equal(typeof resolveUserScopeValue, "function");
-  assert.equal(typeof simplifyJsonApiDocument, "function");
   assert.equal(typeof JsonRestApiCoreServiceProvider, "function");
 });
 
@@ -84,6 +89,23 @@ test("createJsonRestContext returns an empty mutable object when source context
   assert.equal(result.method, "query");
 });
 
+test("extractJsonRestCollectionRows understands the internal collection-document contract", () => {
+  const rows = [{ id: "1" }, { id: "2" }];
+
+  assert.deepEqual(extractJsonRestCollectionRows(rows), rows);
+  assert.deepEqual(
+    extractJsonRestCollectionRows({
+      data: rows,
+      links: {
+        self: "/contacts"
+      }
+    }),
+    rows
+  );
+  assert.deepEqual(extractJsonRestCollectionRows({ data: null }), []);
+  assert.deepEqual(extractJsonRestCollectionRows(null), []);
+});
+
 test("createJsonRestApiHost installs normalizeRecordId as the default resource id normalizer", async () => {
   const fakeKnex = Object.assign(() => {}, {
     client: {
@@ -166,45 +188,41 @@ test("shared query/document helpers build json-rest-api request shapes", () => {
   );
 
   assert.deepEqual(
-    simplifyJsonApiDocument({
-      data: [
-        {
-          type: "workspace-memberships",
-          id: "11",
-          attributes: {
-            roleSid: "owner"
+    createJsonApiInputRecord("products", {
+      serviceId: "9",
+      name: "Style Groom"
+    }, {
+      resource: {
+        schema: {
+          serviceId: {
+            type: "id",
+            belongsTo: "services",
+            as: "service"
           },
-          relationships: {
-            user: {
-              data: {
-                type: "user-profiles",
-                id: "9"
-              }
-            }
-          }
-        }
-      ],
-      included: [
-        {
-          type: "user-profiles",
-          id: "9",
-          attributes: {
-            displayName: "Chiara"
+          name: {
+            type: "string"
           }
         }
-      ]
+      }
     }),
-    [
-      {
-        id: "11",
-        roleSid: "owner",
-        user: {
-          id: "9",
-          displayName: "Chiara"
+    {
+      data: {
+        type: "products",
+        attributes: {
+          name: "Style Groom"
+        },
+        relationships: {
+          service: {
+            data: {
+              type: "services",
+              id: "9"
+            }
+          }
         }
       }
-    ]
+    }
   );
+
 });
 
 test("createJsonRestResourceScopeOptions clones canonical resource metadata and resolves symbolic write serializers", () => {
@@ -237,6 +255,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({
@@ -258,7 +287,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);