json-rest-api 1.0.10 → 1.0.13

package/plugins/core/rest-api-positioning-plugin.js

@@ -1,16 +1,30 @@
-import { 
-  calculatePosition, 
-  getInitialPosition, 
+import {
+  calculatePosition,
+  getInitialPosition,
   isValidPosition,
-  assignInitialPositions 
+  assignInitialPositions,
 } from './lib/fractional-positioning.js';
+import { createStorageAdapter } from './lib/storage/storage-adapter.js';
 
 export const PositioningPlugin = {
   name: 'positioning',
-  dependencies: ['rest-api', 'rest-api-knex'],
+  dependencies: ['rest-api', 'rest-api-knex|rest-api-anyapi-knex'],
 
   install({ api, addHook, vars, helpers, log, scopes, pluginOptions }) {
-    
+
+    const installedPlugins = Array.from(api._installedPlugins || []);
+    const legacyStorageInstalled = installedPlugins.includes('rest-api-knex');
+    const canonicalStorageInstalled = installedPlugins.includes('rest-api-anyapi-knex');
+    if (!legacyStorageInstalled && !canonicalStorageInstalled) {
+      throw new Error(
+        "Positioning plugin requires either 'rest-api-knex' or 'rest-api-anyapi-knex' to be installed before it."
+      );
+    }
+
+    if (!api.knex?.instance) {
+      throw new Error('Positioning plugin requires a storage plugin with knex support (rest-api-knex or rest-api-anyapi-knex)');
+    }
+
     // Get configuration - hooked-api namespaces options by plugin name
     const positioningOptions = pluginOptions || {};
 
@@ -26,6 +40,25 @@ export const PositioningPlugin = {
       rebalanceThreshold: positioningOptions.rebalanceThreshold || 50 // Max position string length
     };
 
+    const resolveStorageAdapter = (scopeName) => {
+      if (!scopeName) return null;
+      const scope = scopes[scopeName] || api.resources?.[scopeName];
+      const scopeVars = scope?.vars;
+      if (!scopeVars) return null;
+
+      if (scopeVars.storageAdapter) {
+        return scopeVars.storageAdapter;
+      }
+
+      if (scopeVars.schemaInfo && api.knex?.instance) {
+        const adapter = createStorageAdapter({ knex: api.knex.instance, schemaInfo: scopeVars.schemaInfo });
+        scopeVars.storageAdapter = adapter;
+        return adapter;
+      }
+
+      return null;
+    };
+
     // Validate configuration
     if (!['fractional', 'integer'].includes(vars.positioning.strategy)) {
       throw new Error(`Invalid positioning strategy: ${vars.positioning.strategy}. Must be 'fractional' or 'integer'`);
@@ -41,18 +74,65 @@ export const PositioningPlugin = {
     }
 
     // Helper to build filter conditions for position groups
-    function buildPositionFilterConditions(record, schemaInfo) {
+    function buildPositionFilterConditions(adapter, schemaInfo, {
+      attributes = {},
+      rawRecord = {},
+      simplifiedRecord = {},
+      inputRelationships = {},
+      minimalRelationships = {},
+    }) {
       const conditions = {};
-      
-      log.debug('*** buildPositionFilterConditions', { 
+
+      log.debug('*** buildPositionFilterConditions', {
         filters: vars.positioning.filters,
-        record: record,
-        recordKeys: Object.keys(record)
+        attributeKeys: Object.keys(attributes || {}),
+        rawKeys: Object.keys(rawRecord || {}),
+        simplifiedKeys: Object.keys(simplifiedRecord || {}),
       });
-      
-      vars.positioning.filters.forEach(filterField => {
-        if (record[filterField] !== undefined) {
-          conditions[filterField] = record[filterField];
+
+      const tryAssign = (holder, field) => (holder && field in holder ? holder[field] : undefined);
+
+      vars.positioning.filters.forEach((filterField) => {
+        const searchField = schemaInfo.searchSchemaStructure?.[filterField] || null;
+        const schemaField = schemaInfo.schemaStructure?.[filterField] || null;
+        const isRelationship = Boolean(
+          searchField?.isRelationship
+          || schemaField?.belongsTo
+          || schemaField?.belongsToPolymorphic
+        );
+
+        if (!searchField && !schemaField) {
+          log.warn(`Filter field '${filterField}' not found in search schema or resource schema for positioning`);
+        }
+
+        const dbField = searchField?.actualField || filterField;
+        let value;
+
+        const attempt = (candidate) => {
+          if (value === undefined && candidate !== undefined) {
+            value = candidate;
+          }
+        };
+
+        attempt(tryAssign(rawRecord, filterField));
+        attempt(tryAssign(simplifiedRecord, filterField));
+        attempt(tryAssign(rawRecord, dbField));
+        attempt(tryAssign(attributes, filterField));
+        attempt(tryAssign(attributes, dbField));
+
+        if (isRelationship) {
+          attempt(inputRelationships?.[filterField]?.data?.id);
+          attempt(minimalRelationships?.[filterField]?.data?.id);
+          // Some contexts may expose relationship data under attributes
+          attempt(tryAssign(rawRecord?.relationships, filterField)?.data?.id);
+        }
+
+       if (value !== undefined) {
+         const column = adapter.translateColumn(dbField);
+          const normalizedValue = value === null
+            ? null
+            : adapter.translateFilterValue(filterField, value);
+          conditions[column] = normalizedValue;
         }
       });
 
@@ -78,11 +158,27 @@ export const PositioningPlugin = {
         );
       }
 
-      // Validate filter fields exist
+      // Validate filter fields exist (check both relationship names and actual field names)
       vars.positioning.filters.forEach(filterField => {
-        if (!schema[filterField]) {
+        // Check if it's a relationship field by looking for a field with matching 'as' property
+        let fieldExists = false;
+        
+        // First check if the field exists directly in the schema
+        if (schema[filterField]) {
+          fieldExists = true;
+        } else {
+          // Check if it's a relationship name (as property)
+          for (const [fieldName, fieldDef] of Object.entries(schema)) {
+            if (fieldDef.as === filterField) {
+              fieldExists = true;
+              break;
+            }
+          }
+        }
+        
+        if (!fieldExists) {
           throw new Error(
-            `Resource '${scopeName}' must have '${filterField}' field in schema for position filtering`
+            `Resource '${scopeName}' must have '${filterField}' field or relationship in schema for position filtering`
           );
         }
       });
@@ -104,8 +200,14 @@ export const PositioningPlugin = {
       }
 
       try {
+        const adapter = resolveStorageAdapter(scopeName);
+        if (adapter.isCanonical()) {
+          log.debug(`Skipping positioning index for canonical storage on ${scopeName}`);
+          return;
+        }
+
         const knex = api.knex.instance;
-        const tableName = schemaInfo.tableName;
+        const tableName = adapter.getTableName();
         
         // Check if table exists first
         const tableExists = await knex.schema.hasTable(tableName);
@@ -114,23 +216,38 @@ export const PositioningPlugin = {
           return;
         }
         
-        // Build index columns: filters + position field
-        const indexColumns = [
-          ...vars.positioning.filters,
-          vars.positioning.field
-        ];
+        // Build index columns: map filter fields to actual database columns
+        const indexColumns = new Set();
+        
+        // Map each filter field to its database column
+        vars.positioning.filters.forEach(filterField => {
+          const searchField = schemaInfo.searchSchemaStructure?.[filterField];
+          if (searchField) {
+            // Use actualField if it exists (for relationships)
+            const dbField = searchField.actualField || filterField;
+            indexColumns.add(adapter.translateColumn(dbField));
+          } else if (schemaInfo.schemaStructure[filterField]) {
+            // Direct database field
+            indexColumns.add(adapter.translateColumn(filterField));
+          }
+        });
+        
+        // Add the position field
+        indexColumns.add(adapter.translateColumn(vars.positioning.field));
+
+        const indexColumnList = [...indexColumns].filter(Boolean);
         
         const indexName = `idx_${tableName}_positioning`;
         
         // Check if index already exists
-        const hasIndex = await knex.schema.hasIndex(tableName, indexColumns, indexName);
+        const hasIndex = await knex.schema.hasIndex(tableName, indexColumnList, indexName);
         
         if (!hasIndex) {
           await knex.schema.table(tableName, table => {
-            table.index(indexColumns, indexName);
+            table.index(indexColumnList, indexName);
           });
           
-          log.info(`Created positioning index on ${tableName}`, { columns: indexColumns });
+          log.info(`Created positioning index on ${tableName}`, { columns: indexColumnList });
         }
       } catch (error) {
         log.warn(`Could not create positioning index for ${scopeName}:`, error.message);
@@ -160,33 +277,44 @@ export const PositioningPlugin = {
 
       // Check if resource has position field
       const scope = scopes[scopeName];
-      const hasPositionField = scope?.vars?.schemaInfo?.schema?.structure?.[vars.positioning.field];
+      const hasPositionField = scope?.vars?.schemaInfo?.schemaStructure?.[vars.positioning.field];
       
       if (!hasPositionField) {
         return;
       }
 
       // Extract beforeId from JSON:API format attributes
-      const attributes = context.inputRecord?.data?.attributes || {};
+      const attributes = context.inputRecord?.data?.attributes
+        || (context.simplified && context.inputRecord && typeof context.inputRecord === 'object'
+          ? context.inputRecord
+          : {});
       const beforeId = attributes[vars.positioning.beforeIdField];
 
       // Store beforeId in context for later use
       if (beforeId !== undefined) {
         context.positioningBeforeId = beforeId;
-        
+
         // Remove beforeId from attributes so it doesn't get stored
         delete attributes[vars.positioning.beforeIdField];
+
+        if (context.simplified && context.inputRecord && typeof context.inputRecord === 'object') {
+          delete context.inputRecord[vars.positioning.beforeIdField];
+        }
       }
-      
+
       // Remove any manually provided position field - position is managed by this plugin
       if (attributes[vars.positioning.field] !== undefined) {
         delete attributes[vars.positioning.field];
-        
+
         log.debug('Positioning beforeId extracted', { 
           scopeName, 
           beforeId,
           method
         });
+
+        if (context.simplified && context.inputRecord && typeof context.inputRecord === 'object') {
+          delete context.inputRecord[vars.positioning.field];
+        }
       }
 
       // For new records without explicit position, mark for positioning
@@ -242,8 +370,15 @@ export const PositioningPlugin = {
         return;
       }
 
-      // Always work with JSON:API format - get attributes
-      const recordData = context.inputRecord?.data?.attributes || {};
+      const recordData = (() => {
+        if (context.inputRecord?.data?.attributes) {
+          return { ...context.inputRecord.data.attributes };
+        }
+        if (context.simplified && context.inputRecord && typeof context.inputRecord === 'object') {
+          return { ...context.inputRecord };
+        }
+        return {};
+      })();
         
       log.debug('*** Record data for positioning', { 
         recordData,
@@ -251,41 +386,70 @@ export const PositioningPlugin = {
         inputRecord: context.inputRecord
       });
 
+      const jsonApiRecord = context.inputRecord?.data || {};
+      const inputRelationships = jsonApiRecord.relationships || {};
+      const simplifiedRecord = context.simplified && context.inputRecord && typeof context.inputRecord === 'object'
+        ? context.inputRecord
+        : {};
+
+      const minimalAttributes = context.minimalRecord?.attributes || {};
+      const minimalRelationships = context.minimalRecord?.relationships || {};
+
+      const combinedAttributes = {
+        ...minimalAttributes,
+        ...recordData,
+      };
 
-      // For PATCH/PUT, we need to get the current record's filter values
-      let filterData = recordData;
-      if ((context.method === 'patch' || context.method === 'put') && context.minimalRecord) {
-        // Use the minimalRecord that was already fetched by REST API plugin
-        // Merge current record's filter fields with the update data
-        filterData = { ...context.minimalRecord, ...recordData };
-      }
-      
       // Build filter conditions for the position group
-      const filterConditions = buildPositionFilterConditions(filterData, context.schemaInfo);
+      const schemaInfo = context.schemaInfo;
+      const adapter = context.storageAdapter || resolveStorageAdapter(scopeName);
+
+      if (!adapter) {
+        log.warn('*** Positioning skipped - no storage adapter available', { scopeName });
+        return;
+      }
       
+      const filterConditions = buildPositionFilterConditions(adapter, schemaInfo, {
+        attributes: combinedAttributes,
+        rawRecord: recordData,
+        simplifiedRecord,
+        inputRelationships,
+        minimalRelationships,
+      });
+
+      log.debug('*** Position filter conditions', { scopeName, filterConditions });
+
       // Query existing items in the same position group
       const knex = api.knex.instance;
-      const tableName = context.schemaInfo.tableName;
-      const idProperty = context.schemaInfo.idProperty;
+      const tableName = adapter.getTableName();
+      const idProperty = schemaInfo.idProperty;
+      const idColumn = adapter.getIdColumn();
+      const positionColumn = adapter.translateColumn(vars.positioning.field);
       
-      log.debug('*** Building position query', { tableName, idProperty, filterConditions });
+      log.debug('*** Building position query', {
+        tableName,
+        idProperty,
+        idColumn,
+        positionField: vars.positioning.field,
+        positionColumn,
+        filterConditions
+      });
       
       // Check if we have a transaction to use
-      const db = context.transaction || knex;
-      
       // Build base query with filter conditions
-      const baseQuery = db(tableName);
-      Object.entries(filterConditions).forEach(([field, value]) => {
+      const baseQuery = adapter.buildBaseQuery({ transaction: context.transaction });
+      Object.entries(filterConditions).forEach(([column, value]) => {
         if (value === null) {
-          baseQuery.whereNull(field);
+          baseQuery.whereNull(column);
         } else {
-          baseQuery.where(field, value);
+          baseQuery.where(column, value);
         }
       });
-      
+
       // For updates, exclude the current record
       if ((context.method === 'patch' || context.method === 'put') && context.id) {
-        baseQuery.whereNot(idProperty, context.id);
+        const translatedId = adapter.translateFilterValue(idProperty, context.id);
+        baseQuery.whereNot(idColumn, translatedId);
       }
       
       // Calculate effective beforeId first
@@ -302,13 +466,22 @@ export const PositioningPlugin = {
       
       let items = [];
       
+      const selectColumns = {
+        [idProperty]: idColumn,
+        [vars.positioning.field]: positionColumn,
+      };
+      const selectWithAliases = (builder) => adapter.selectColumns(builder, selectColumns);
+
       try {
+        log.debug('*** Positioning query start', {
+          effectiveBeforeId,
+          selectColumns,
+        });
         if (effectiveBeforeId === null) {
           // Positioning at end - only get the last item
-          const lastItem = await baseQuery
-            .clone()
-            .select(idProperty, vars.positioning.field)
-            .orderBy(vars.positioning.field, 'desc')
+          const lastItem = await selectWithAliases(baseQuery
+            .clone())
+            .orderBy(positionColumn, 'desc')
             .first();
           
           if (lastItem) {
@@ -316,10 +489,9 @@ export const PositioningPlugin = {
           }
         } else if (effectiveBeforeId === 'FIRST') {
           // Positioning at beginning - get the first item
-          const firstItem = await baseQuery
-            .clone()
-            .select(idProperty, vars.positioning.field)
-            .orderBy(vars.positioning.field, 'asc')
+          const firstItem = await selectWithAliases(baseQuery
+            .clone())
+            .orderBy(positionColumn, 'asc')
             .first();
           
           if (firstItem) {
@@ -330,19 +502,18 @@ export const PositioningPlugin = {
           }
         } else if (effectiveBeforeId) {
           // Positioning before a specific item - get that item and the one before it
-          const targetItem = await baseQuery
-            .clone()
-            .select(idProperty, vars.positioning.field)
-            .where(idProperty, effectiveBeforeId)
+          const normalizedTargetId = adapter.translateFilterValue(idProperty, effectiveBeforeId);
+          const targetItem = await selectWithAliases(baseQuery
+            .clone())
+            .where(idColumn, normalizedTargetId)
             .first();
           
           if (targetItem) {
             // Get the item immediately before the target
-            const prevItem = await baseQuery
-              .clone()
-              .select(idProperty, vars.positioning.field)
-              .where(vars.positioning.field, '<', targetItem[vars.positioning.field])
-              .orderBy(vars.positioning.field, 'desc')
+            const prevItem = await selectWithAliases(baseQuery
+              .clone())
+              .where(positionColumn, '<', targetItem[vars.positioning.field])
+              .orderBy(positionColumn, 'desc')
               .first();
             
             items = prevItem ? [prevItem, targetItem] : [targetItem];
@@ -352,7 +523,7 @@ export const PositioningPlugin = {
           items = [];
         }
         
-        log.debug('*** Query completed', { itemCount: items.length });
+        log.debug('*** Query completed', { itemCount: items.length, items });
       } catch (error) {
         log.error('*** Query failed', { error: error.message, stack: error.stack });
         throw error;
@@ -363,9 +534,15 @@ export const PositioningPlugin = {
         ? getInitialPosition()
         : calculatePosition(items, effectiveBeforeId, idProperty, vars.positioning.field);
       
-      // Set the position in JSON:API format
-      context.inputRecord.data.attributes = context.inputRecord.data.attributes || {};
-      context.inputRecord.data.attributes[vars.positioning.field] = newPosition;
+      // Set the position on the incoming payload so downstream steps persist it
+      if (context.inputRecord?.data) {
+        context.inputRecord.data.attributes = context.inputRecord.data.attributes || {};
+        context.inputRecord.data.attributes[vars.positioning.field] = newPosition;
+      }
+
+      if (context.simplified && context.inputRecord && typeof context.inputRecord === 'object') {
+        context.inputRecord[vars.positioning.field] = newPosition;
+      }
       
       log.debug('Position calculated', {
         scopeName,
@@ -489,4 +666,4 @@ await api.use(PositioningPlugin, {
   "listId": 456,
   "beforeId": null  // Explicit last position
 }
-*/
+*/