json-rest-api 1.0.14 → 1.0.15

package/plugins/core/lib/storage/storage-adapter.js

@@ -1,26 +1,26 @@
-const passthrough = (value) => value;
-const identityTranslate = (_field, value) => value;
-const identityScope = (query) => query;
+const passthrough = (value) => value
+const identityTranslate = (_field, value) => value
+const identityScope = (query) => query
 
 const selectColumnsOnBuilder = (builder, columns) => {
-  if (!columns) return builder;
+  if (!columns) return builder
   if (Array.isArray(columns)) {
-    columns.forEach((column) => builder.select(column));
+    columns.forEach((column) => builder.select(column))
   } else if (typeof columns === 'object') {
-    builder.select(columns);
+    builder.select(columns)
   }
-  return builder;
-};
+  return builder
+}
 
-const normalizeArray = (value, normalizeFn) => value.map((entry) => normalizeFn(entry));
+const normalizeArray = (value, normalizeFn) => value.map((entry) => normalizeFn(entry))
 
 const normalizeBelongsToValue = (value) => {
-  if (value === null || value === undefined) return value;
+  if (value === null || value === undefined) return value
   if (Array.isArray(value)) {
-    return normalizeArray(value, normalizeBelongsToValue);
+    return normalizeArray(value, normalizeBelongsToValue)
   }
-  return String(value);
-};
+  return String(value)
+}
 
 const baseAdapter = ({
   knex,
@@ -32,9 +32,9 @@ const baseAdapter = ({
   isCanonical = false,
 }) => {
   const buildBaseQuery = ({ transaction } = {}) => {
-    const query = (transaction || knex)(tableName);
-    return applyResourceScope(query);
-  };
+    const query = (transaction || knex)(tableName)
+    return applyResourceScope(query)
+  }
 
   return {
     isCanonical: () => isCanonical,
@@ -45,14 +45,14 @@ const baseAdapter = ({
     applyResourceScope,
     buildBaseQuery,
     selectColumns: (builder, columns) => selectColumnsOnBuilder(builder, columns),
-  };
-};
+  }
+}
 
 const createLegacyAdapter = ({ knex, schemaInfo }) => {
-  const tableName = schemaInfo.tableName;
-  const idColumn = schemaInfo.idProperty || 'id';
+  const tableName = schemaInfo.tableName
+  const idColumn = schemaInfo.idProperty || 'id'
 
-  const translateColumn = (column) => column;
+  const translateColumn = (column) => column
 
   return baseAdapter({
     knex,
@@ -62,79 +62,79 @@ const createLegacyAdapter = ({ knex, schemaInfo }) => {
     translateFilterValue: identityTranslate,
     applyResourceScope: identityScope,
     isCanonical: false,
-  });
-};
+  })
+}
 
 const createCanonicalAdapter = ({ knex, schemaInfo }) => {
-  const descriptor = schemaInfo.descriptor || {};
-  const canonical = descriptor.canonical || {};
-  const canonicalFieldMap = descriptor.canonicalFieldMap || {};
-  const fieldsInfo = descriptor.fields || {};
-  const belongsToInfo = descriptor.belongsTo || {};
+  const descriptor = schemaInfo.descriptor || {}
+  const canonical = descriptor.canonical || {}
+  const canonicalFieldMap = descriptor.canonicalFieldMap || {}
+  const fieldsInfo = descriptor.fields || {}
+  const belongsToInfo = descriptor.belongsTo || {}
 
   const translateColumn = (field) => {
-    if (!field) return field;
-    if (field === 'id') return 'id';
+    if (!field) return field
+    if (field === 'id') return 'id'
 
-    const canonicalEntry = canonicalFieldMap[field];
+    const canonicalEntry = canonicalFieldMap[field]
     if (typeof canonicalEntry === 'string') {
-      return canonicalEntry;
+      return canonicalEntry
     }
     if (canonicalEntry && typeof canonicalEntry === 'object') {
-      if (canonicalEntry.slot) return canonicalEntry.slot;
-      if (canonicalEntry.slotColumn) return canonicalEntry.slotColumn;
-      if (canonicalEntry.idSlot) return canonicalEntry.idSlot;
-      if (canonicalEntry.typeSlot && field.endsWith('_type')) return canonicalEntry.typeSlot;
+      if (canonicalEntry.slot) return canonicalEntry.slot
+      if (canonicalEntry.slotColumn) return canonicalEntry.slotColumn
+      if (canonicalEntry.idSlot) return canonicalEntry.idSlot
+      if (canonicalEntry.typeSlot && field.endsWith('_type')) return canonicalEntry.typeSlot
     }
 
     if (!canonicalEntry && field.endsWith('_id')) {
-      const alias = field.slice(0, -3);
-      const aliasEntry = canonicalFieldMap[alias];
-      if (typeof aliasEntry === 'string') return aliasEntry;
-      if (aliasEntry?.idSlot) return aliasEntry.idSlot;
+      const alias = field.slice(0, -3)
+      const aliasEntry = canonicalFieldMap[alias]
+      if (typeof aliasEntry === 'string') return aliasEntry
+      if (aliasEntry?.idSlot) return aliasEntry.idSlot
     }
 
     if (!canonicalEntry && field.endsWith('_type')) {
-      const alias = field.slice(0, -5);
-      const aliasEntry = canonicalFieldMap[alias];
-      if (aliasEntry?.typeSlot) return aliasEntry.typeSlot;
+      const alias = field.slice(0, -5)
+      const aliasEntry = canonicalFieldMap[alias]
+      if (aliasEntry?.typeSlot) return aliasEntry.typeSlot
     }
 
-    const fieldInfo = fieldsInfo[field];
-    if (fieldInfo?.slot) return fieldInfo.slot;
+    const fieldInfo = fieldsInfo[field]
+    if (fieldInfo?.slot) return fieldInfo.slot
 
-    const belongsInfo = belongsToInfo[field];
-    if (belongsInfo?.idColumn) return belongsInfo.idColumn;
+    const belongsInfo = belongsToInfo[field]
+    if (belongsInfo?.idColumn) return belongsInfo.idColumn
 
-    return field;
-  };
+    return field
+  }
 
   const translateFilterValue = (field, value) => {
-    if (value === null || value === undefined) return value;
+    if (value === null || value === undefined) return value
 
-    const searchField = schemaInfo.searchSchemaStructure?.[field];
-    const schemaField = schemaInfo.schemaStructure?.[field];
+    const searchField = schemaInfo.searchSchemaStructure?.[field]
+    const schemaField = schemaInfo.schemaStructure?.[field]
     const isRelationship = Boolean(
-      searchField?.isRelationship
-      || schemaField?.belongsTo
-      || schemaField?.belongsToPolymorphic
-    );
+      searchField?.isRelationship ||
+      schemaField?.belongsTo ||
+      schemaField?.belongsToPolymorphic
+    )
 
     if (!isRelationship) {
       if (Array.isArray(value)) {
-        return normalizeArray(value, passthrough);
+        return normalizeArray(value, passthrough)
       }
-      return value;
+      return value
     }
 
-    return normalizeBelongsToValue(value);
-  };
+    return normalizeBelongsToValue(value)
+  }
 
   const applyResourceScope = (query) => {
     return query
       .where(canonical.tenantColumn, descriptor.tenant)
-      .where(canonical.resourceColumn, descriptor.resource);
-  };
+      .where(canonical.resourceColumn, descriptor.resource)
+  }
 
   return baseAdapter({
     knex,
@@ -144,17 +144,17 @@ const createCanonicalAdapter = ({ knex, schemaInfo }) => {
     translateFilterValue,
     applyResourceScope,
     isCanonical: true,
-  });
-};
+  })
+}
 
 export const createStorageAdapter = ({ knex, schemaInfo }) => {
   if (!schemaInfo) {
-    throw new Error('createStorageAdapter requires schemaInfo');
+    throw new Error('createStorageAdapter requires schemaInfo')
   }
 
   if (schemaInfo?.descriptor?.canonical?.tableName) {
-    return createCanonicalAdapter({ knex, schemaInfo });
+    return createCanonicalAdapter({ knex, schemaInfo })
   }
 
-  return createLegacyAdapter({ knex, schemaInfo });
-};
+  return createLegacyAdapter({ knex, schemaInfo })
+}

package/plugins/core/lib/writing/knex-json-api-transformers-writing.js

@@ -1,12 +1,12 @@
-import { getSchemaStructure } from '../querying-writing/knex-constants.js';
+import { getSchemaStructure } from '../querying-writing/knex-constants.js'
 
 /**
  * Processes belongsTo relationships from JSON:API input to foreign key updates
- * 
+ *
  * @param {Object} scope - The scope object containing schema info
  * @param {Object} deps - Dependencies object containing context with inputRecord
  * @returns {Object} Object mapping foreign key fields to their values
- * 
+ *
  * @example
  * // Input: JSON:API document with relationships
  * const inputRecord = {
@@ -23,18 +23,18 @@ import { getSchemaStructure } from '../querying-writing/knex-constants.js';
  *     }
  *   }
  * };
- * 
+ *
  * // Schema has: author_id field with belongsTo: 'users', as: 'author'
  * // Schema has: category_id field with belongsTo: 'categories', as: 'category'
- * 
+ *
  * const updates = processBelongsToRelationships(scope, { context: { inputRecord } });
- * 
+ *
  * // Output: Foreign key values extracted
  * // {
  * //   author_id: '123',
  * //   category_id: '456'
  * // }
- * 
+ *
  * @example
  * // Input: Removing a relationship (setting to null)
  * const inputRecord = {
@@ -48,26 +48,26 @@ import { getSchemaStructure } from '../querying-writing/knex-constants.js';
  *     }
  *   }
  * };
- * 
+ *
  * const updates = processBelongsToRelationships(scope, { context: { inputRecord } });
- * 
+ *
  * // Output: Foreign key set to null
  * // {
  * //   author_id: null
  * // }
- * 
+ *
  * @description
  * Used by:
  * - rest-api-knex-plugin's dataPut and dataPatch methods
  * - Called before saving to extract foreign keys from JSON:API relationships
  * - Works in conjunction with relationship-processor for complete handling
- * 
+ *
  * Purpose:
  * - Converts JSON:API relationship format to database foreign keys
  * - Maps from relationship names (e.g., 'author') to field names (e.g., 'author_id')
  * - Handles both setting relationships (with id) and removing them (null)
  * - Only processes belongsTo relationships, not hasMany
- * 
+ *
  * Data flow:
  * 1. Receives JSON:API document with relationships section
  * 2. Looks up schema to find foreign key fields
@@ -76,35 +76,35 @@ import { getSchemaStructure } from '../querying-writing/knex-constants.js';
  * 5. Returns object ready to merge with attributes for database update
  */
 export const processBelongsToRelationships = (scope, deps) => {
-  const foreignKeyUpdates = {};
-  
+  const foreignKeyUpdates = {}
+
   // Extract values from deps
-  const { context } = deps;
-  const inputRecord = context.inputRecord;
-  
+  const { context } = deps
+  const inputRecord = context.inputRecord
+
   if (!inputRecord.data.relationships) {
-    return foreignKeyUpdates;
+    return foreignKeyUpdates
   }
-  
+
   // Extract schema from scope
-  const { 
-    vars: { 
+  const {
+    vars: {
       schemaInfo: { schema }
     }
-  } = scope;
-  
+  } = scope
+
   // Schema might be a Schema object or plain object
-  const schemaStructure = getSchemaStructure(schema);
-  
+  const schemaStructure = getSchemaStructure(schema)
+
   for (const [fieldName, fieldDef] of Object.entries(schemaStructure)) {
     if (fieldDef.belongsTo && fieldDef.as) {
-      const relName = fieldDef.as;
+      const relName = fieldDef.as
       if (inputRecord.data.relationships[relName] !== undefined) {
-        const relData = inputRecord.data.relationships[relName];
-        foreignKeyUpdates[fieldName] = relData.data?.id || null;
+        const relData = inputRecord.data.relationships[relName]
+        foreignKeyUpdates[fieldName] = relData.data?.id || null
       }
     }
   }
-  
-  return foreignKeyUpdates;
-};
+
+  return foreignKeyUpdates
+}