json-rest-api 1.0.10 → 1.0.13

package/plugins/core/rest-api-plugin-methods/get-related.js

@@ -1,5 +1,6 @@
 import { RestApiResourceError } from "../../../lib/rest-api-errors.js";
 import { findRelationshipDefinition } from "./common.js";
+import { buildRelationshipUrl } from "../lib/querying/url-helpers.js";
 
 /**
  * GET RELATED
@@ -30,9 +31,15 @@ export default async function getRelatedMethod ({ params, context, vars, helpers
     );
   }
 
-  // Determine target type - relationships are stored as strings
-  const targetType = relDef.belongsTo || relDef.hasMany || 
-                    relDef.manyToMany || relDef.hasOne;
+  // Determine target type based on relationship type
+  let targetType;
+  if (relDef.type === 'hasMany' || relDef.type === 'hasOne') {
+    targetType = relDef.target;
+  } else if (relDef.type === 'manyToMany') {
+    targetType = context.relationshipName; // For manyToMany, use the relationship name
+  } else if (relDef.belongsTo) {
+    targetType = relDef.belongsTo; // belongsTo still in schema
+  }
 
   if (!targetType || !scopes[targetType]) {
     throw new RestApiResourceError(
@@ -57,7 +64,7 @@ export default async function getRelatedMethod ({ params, context, vars, helpers
 
   // Handle to-one relationships (belongsTo and hasOne)
   // For example: GET /api/books/1/country or GET /api/books/1/publisher
-  if (relDef.belongsTo || relDef.hasOne) {
+  if (relDef.belongsTo || relDef.type === 'hasOne') {
     // OPTIMIZATION: Detect if we actually need to make two API calls
     // 
     // The naive approach always makes 2 calls:
@@ -95,7 +102,7 @@ export default async function getRelatedMethod ({ params, context, vars, helpers
       const relatedId = parent.data.relationships?.[context.relationshipName]?.data?.id;
       if (!relatedId) {
         return {
-          links: { self: `${vars.publicBaseUrl || vars.transport?.mountPath || ''}/${scopeName}/${context.id}/${context.relationshipName}` },
+          links: { self: buildRelationshipUrl(context, scope, scopeName, context.id, context.relationshipName, false) },
           data: null
         };
       }
@@ -110,7 +117,7 @@ export default async function getRelatedMethod ({ params, context, vars, helpers
       });
 
       return {
-        links: { self: `${vars.publicBaseUrl || vars.transport?.mountPath || ''}/${scopeName}/${context.id}/${context.relationshipName}` },
+        links: { self: buildRelationshipUrl(context, scope, scopeName, context.id, context.relationshipName, false) },
         data: related.data,
         included: related.included
       };
@@ -134,7 +141,7 @@ export default async function getRelatedMethod ({ params, context, vars, helpers
       const relatedId = parent.data.relationships?.[context.relationshipName]?.data?.id;
       if (!relatedId) {
         return {
-          links: { self: `${vars.publicBaseUrl || vars.transport?.mountPath || ''}/${scopeName}/${context.id}/${context.relationshipName}` },
+          links: { self: buildRelationshipUrl(context, scope, scopeName, context.id, context.relationshipName, false) },
           data: null
         };
       }
@@ -146,14 +153,14 @@ export default async function getRelatedMethod ({ params, context, vars, helpers
       );
 
       return {
-        links: { self: `${vars.publicBaseUrl || vars.transport?.mountPath || ''}/${scopeName}/${context.id}/${context.relationshipName}` },
+        links: { self: buildRelationshipUrl(context, scope, scopeName, context.id, context.relationshipName, false) },
         data: relatedResource || null
       };
     }
   }
 
-  // Handle simple hasMany (one-to-many)
-  if (relDef.hasMany && !relDef.through) {
+  // Handle simple hasMany (one-to-many, NOT many-to-many)
+  if (relDef.type === 'hasMany') {
     // Check if this is a polymorphic relationship using 'via'
     if (relDef.via) {
       // Polymorphic hasMany relationship
@@ -187,13 +194,28 @@ export default async function getRelatedMethod ({ params, context, vars, helpers
       if (!result.links) {
         result.links = {};
       }
-      result.links.self = `${vars.publicBaseUrl || vars.transport?.mountPath || ''}/${scopeName}/${context.id}/${context.relationshipName}`;
+      result.links.self = buildRelationshipUrl(context, scope, scopeName, context.id, context.relationshipName, false);
       return result;
     } else {
       // Regular hasMany with foreignKey
+      // Need to find the relationship name in the target resource that points back to this resource
+      const targetSchema = scopes[targetType].vars.schemaInfo.schemaStructure;
+      let relationshipFilterName = null;
+      
+      // Find the field in target schema that has the foreign key and get its relationship name
+      for (const [fieldName, fieldDef] of Object.entries(targetSchema)) {
+        if (fieldName === relDef.foreignKey && fieldDef.belongsTo === scopeName && fieldDef.as) {
+          relationshipFilterName = fieldDef.as;
+          break;
+        }
+      }
+      
+      // Fall back to foreign key if no relationship name found (shouldn't happen with proper schema)
+      const filterKey = relationshipFilterName || relDef.foreignKey;
+      
       const filters = {
         ...context.queryParams.filters,
-        [relDef.foreignKey]: context.id
+        [filterKey]: context.id
       };
 
       const result = await api.resources[targetType].query({
@@ -206,35 +228,50 @@ export default async function getRelatedMethod ({ params, context, vars, helpers
       if (!result.links) {
         result.links = {};
       }
-      result.links.self = `${vars.publicBaseUrl || vars.transport?.mountPath || ''}/${scopeName}/${context.id}/${context.relationshipName}`;
+      result.links.self = buildRelationshipUrl(context, scope, scopeName, context.id, context.relationshipName, false);
       return result;
     }
   }
 
-  // Handle many-to-many relationships (hasMany with through)
+  // Handle many-to-many relationships
   // For example: GET /api/authors/1/books (where authors and books are linked via book_authors)
-  if (relDef.manyToMany || (relDef.hasMany && relDef.through)) {
-    // APPROACH: Query the pivot table directly
-    //
-    // Instead of:
-    // 1. Getting parent with relationship included to find related IDs
-    // 2. Trying to filter by id:[array] which doesn't work
-    //
-    // We query the pivot table (e.g., book_authors) filtered by the parent ID
-    // and include the target resources. This is simpler and uses existing
-    // API functionality without needing special array filter support.
-    
+  if (relDef?.through) {
+    if (api.anyapi?.links?.listMany) {
+      const identifiers = await api.anyapi.links.listMany({
+        context,
+        scopeName,
+        relName: context.relationshipName,
+      });
+
+      const results = [];
+      for (const identifier of identifiers) {
+        const related = await api.resources[targetType].get({
+          id: identifier.id,
+          queryParams: context.queryParams,
+          transaction: context.transaction,
+          simplified: false,
+          isTransport: params.isTransport,
+        });
+        if (related?.data) {
+          results.push(related.data);
+        }
+      }
+
+      return {
+        links: {
+          self: buildRelationshipUrl(context, scope, scopeName, context.id, context.relationshipName, false)
+        },
+        data: results,
+      };
+    }
+
+    // Legacy fallback
     const pivotResource = relDef.through;
     const foreignKey = relDef.foreignKey;
     const otherKey = relDef.otherKey;
-    
-    // These should already be validated by scope-validations.js
     if (!foreignKey || !otherKey) {
       throw new Error(`Missing foreignKey or otherKey in many-to-many relationship`);
     }
-    
-    // We need to find the relationship name on the pivot table that points to the target
-    // The pivot table should have a belongsTo relationship to the target resource
     const pivotScope = scopes[pivotResource];
     if (!pivotScope) {
       throw new RestApiResourceError(
@@ -242,35 +279,22 @@ export default async function getRelatedMethod ({ params, context, vars, helpers
         { subtype: 'pivot_table_not_found' }
       );
     }
-    
-    // Find the relationship name on the pivot table that points to the target
-    let targetRelationshipName = null;
     const pivotSchema = pivotScope.vars.schemaInfo.schemaStructure;
+    let parentRelationshipName = null;
     for (const [fieldName, fieldDef] of Object.entries(pivotSchema)) {
-      if (fieldDef.belongsTo === targetType && fieldDef.as) {
-        targetRelationshipName = fieldDef.as;
+      if (fieldName === foreignKey && fieldDef.belongsTo === scopeName && fieldDef.as) {
+        parentRelationshipName = fieldDef.as;
         break;
       }
     }
-    
-    if (!targetRelationshipName) {
-      throw new RestApiResourceError(
-        `Cannot find relationship to '${targetType}' in pivot table '${pivotResource}'`,
-        { subtype: 'pivot_relationship_not_found' }
-      );
-    }
-    
-    // Build filters for the pivot table
+    const filterKey = parentRelationshipName || foreignKey;
     const pivotFilters = {
-      [foreignKey]: context.id
+      [filterKey]: context.id
     };
-    
-    // Query the pivot table with the target included
     const pivotResult = await api.resources[pivotResource].query({
       queryParams: {
         filters: pivotFilters,
-        include: [targetRelationshipName],
-        // Pass through other query params that should apply to the included resources
+        include: [context.relationshipName],
         fields: context.queryParams.fields,
         sort: context.queryParams.sort,
         page: context.queryParams.page
@@ -279,17 +303,51 @@ export default async function getRelatedMethod ({ params, context, vars, helpers
       simplified: false,
       isTransport: params.isTransport
     });
-    
-    // Extract the included target resources
-    const includedResources = pivotResult.included?.filter(r => r.type === targetType) || [];
-    
-    // Build the response
+    let includedResources = pivotResult.included?.filter((r) => r.type === targetType) || [];
+
+    if (includedResources.length === 0) {
+      const pivotData = pivotResult.data || [];
+      const relatedIds = [...new Set(pivotData
+        .map((item) => {
+          const attrId = item?.attributes?.[otherKey];
+          if (attrId !== null && attrId !== undefined) {
+            return String(attrId);
+          }
+          const relationships = item?.relationships || {};
+          for (const rel of Object.values(relationships)) {
+            const data = rel?.data;
+            if (data?.type === targetType && data?.id != null) {
+              return String(data.id);
+            }
+          }
+          return null;
+        })
+        .filter((id) => id !== null)
+      )];
+
+      if (relatedIds.length > 0) {
+        includedResources = [];
+        for (const relatedId of relatedIds) {
+          const related = await api.resources[targetType].get({
+            id: relatedId,
+            queryParams: context.queryParams,
+            transaction: context.transaction,
+            simplified: false,
+            isTransport: params.isTransport,
+          });
+          if (related?.data) {
+            includedResources.push(related.data);
+          }
+        }
+      }
+    }
+
     return {
       links: {
-        self: `${vars.publicBaseUrl || vars.transport?.mountPath || ''}/${scopeName}/${context.id}/${context.relationshipName}`
+        self: buildRelationshipUrl(context, scope, scopeName, context.id, context.relationshipName, false)
       },
       data: includedResources,
       meta: pivotResult.meta
     };
   }
-}
+}

package/plugins/core/rest-api-plugin-methods/get-relationship.js

@@ -1,6 +1,7 @@
 
 import { RestApiResourceError } from "../../../lib/rest-api-errors.js";
 import { findRelationshipDefinition } from "./common.js";
+import { buildRelationshipUrl } from "../lib/querying/url-helpers.js";
 
 /**
  * GET RELATIONSHIP
@@ -53,10 +54,10 @@ export default async function getRelationshipMethod ({ params, context, vars, he
   // Build response with links
   return {
     links: {
-      self: `${vars.publicBaseUrl || vars.transport?.mountPath || ''}/${scopeName}/${context.id}/relationships/${context.relationshipName}`,
-      related: `${vars.publicBaseUrl || vars.transport?.mountPath || ''}/${scopeName}/${context.id}/${context.relationshipName}`
+      self: buildRelationshipUrl(context, scope, scopeName, context.id, context.relationshipName, true),
+      related: buildRelationshipUrl(context, scope, scopeName, context.id, context.relationshipName, false)
     },
-    data: relationshipData?.data || (relDef.hasMany || relDef.manyToMany ? [] : null)
+    data: relationshipData?.data || (relDef.type === 'hasMany' || relDef.type === 'manyToMany' ? [] : null)
   };
 };
 

package/plugins/core/rest-api-plugin-methods/get.js

@@ -53,7 +53,7 @@ export default async function getMethod({
   context.scopeName = scopeName;
 
   // These are just shortcuts used in this function and will be returned
-  const schemaStructure = context.schemaInfo.schema.structure;
+  const schemaStructure = context.schemaInfo.schemaInstance.structure;
   const schemaRelationships = context.schemaInfo.schemaRelationships;
 
   context.id = params.id;
@@ -88,10 +88,7 @@ export default async function getMethod({
   // Centralised checkPermissions function
   await scope.checkPermissions({
     method: 'get',
-    auth: context.auth,
-    id: context.id,
-    minimalRecord: context.minimalRecord,
-    transaction: context.transaction
+    originalContext: context,
   });
   
   await runHooks('beforeData');

package/plugins/core/rest-api-plugin-methods/patch.js

@@ -102,10 +102,7 @@ export default async function patchMethod({
     // Centralised checkPermissions function
     await scope.checkPermissions({
       method: 'patch',
-      auth: context.auth,
-      id: context.id,
-      minimalRecord: context.minimalRecord,
-      transaction: context.transaction
+      originalContext: context,
     });
 
     // Merge belongsTo updates into attributes before patching the record
@@ -142,18 +139,20 @@ export default async function patchMethod({
     // Process many-to-many relationships after main record update
     // For PATCH, we only update the relationships that were explicitly provided
     for (const { relName, relDef, relData } of manyToManyRelationships) {
-      
-      // Validate pivot resource exists
+      if (relDef?.through && api.anyapi?.links?.syncMany) {
+        await api.anyapi.links.syncMany({
+          context,
+          scopeName,
+          relName,
+          relDef,
+          relData,
+          isUpdate: true,
+        });
+        continue;
+      }
+
       validatePivotResource(scopes, relDef, relName);
-      
-      // Update many-to-many relationships using intelligent synchronization that preserves pivot data.
-      // This compares current relationships with desired state: removes records no longer needed,
-      // adds new relationships, and crucially preserves existing pivot records with their metadata
-      // (like created_at timestamps or extra pivot fields). This is superior to delete-all-recreate
-      // because it maintains audit trails and custom pivot data.
-      // Example: If article has tags [1,2,3] and you update to [2,3,4], it keeps the pivot records
-      // for tags 2&3 (preserving their created_at), deletes tag 1, and adds new record for tag 4.
-      // Example: If article has tags [1,2,3] and update sends [2,3,4], tag 1 is removed, tags 2,3 kept, tag 4 added
+
       await updateManyToManyRelationship(null, {
         api,
         context: {
@@ -190,4 +189,4 @@ export default async function patchMethod({
   } catch (error) {
     await handleWriteMethodError(error, context, 'PATCH', scopeName, log, runHooks);
   }
-}
+}

package/plugins/core/rest-api-plugin-methods/post-relationship.js

@@ -1,7 +1,6 @@
-import { RestApiResourceError } from "../../../lib/rest-api-errors.js";
+import { RestApiResourceError, RestApiValidationError, RestApiPayloadError } from "../../../lib/rest-api-errors.js";
 import { findRelationshipDefinition, handleWriteMethodError } from "./common.js";
 import { createPivotRecords } from "../lib/writing/many-to-many-manipulations.js";
-import { RestApiValidationError } from "../../../lib/rest-api-errors.js";
 
 /**
    * POST RELATIONSHIP
@@ -36,7 +35,7 @@ import { RestApiValidationError } from "../../../lib/rest-api-errors.js";
       );
   }
 
-  if (!relDef.hasMany && !relDef.manyToMany) {
+  if (relDef.type !== 'hasMany' && relDef.type !== 'manyToMany') {
       throw new RestApiValidationError(
       `Cannot POST to to-one relationship '${context.relationshipName}'. Use PATCH instead.`,
       { fields: ['data'] }
@@ -62,17 +61,25 @@ import { RestApiValidationError } from "../../../lib/rest-api-errors.js";
   }
 
   // Add relationships
-  if (relDef.manyToMany || (relDef.hasMany && relDef.through)) {
-      const manyToManyDef = relDef.manyToMany || {
-      through: relDef.through,
-      foreignKey: relDef.foreignKey,
-      otherKey: relDef.otherKey
-      };
-      
-      await createPivotRecords(api, context.id, manyToManyDef, params.relationshipData, context.transaction);
-  } else {
+  if (relDef?.through) {
+      if (api.anyapi?.links?.attachMany) {
+        await api.anyapi.links.attachMany({
+          context,
+          scopeName,
+          relName: context.relationshipName,
+          relDef,
+          relData: params.relationshipData,
+        });
+      } else {
+        await createPivotRecords(api, context.id, {
+            through: relDef.through,
+            foreignKey: relDef.foreignKey,
+            otherKey: relDef.otherKey
+        }, params.relationshipData, context.transaction);
+      }
+  } else if (relDef.type === 'hasMany') {
       // Update foreign keys for hasMany
-      const targetType = relDef.hasMany;
+      const targetType = relDef.target;
       for (const identifier of params.relationshipData) {
       await api.resources[targetType].patch({
           id: identifier.id,
@@ -101,4 +108,4 @@ import { RestApiValidationError } from "../../../lib/rest-api-errors.js";
   } catch (error) {
   await handleWriteMethodError(error, context, 'POST_RELATIONSHIP', scopeName, log, runHooks);
 }
-};
+};

package/plugins/core/rest-api-plugin-methods/post.js

@@ -84,11 +84,20 @@ export default async function postMethod({
       runHooks
     });
 
+    if (context.inputRecord?.data) {
+      const inputData = context.inputRecord.data;
+      context.minimalRecord = {
+        type: scopeName,
+        ...(inputData.id !== undefined && inputData.id !== null ? { id: String(inputData.id) } : {}),
+        attributes: structuredClone(inputData.attributes || {}),
+        relationships: structuredClone(inputData.relationships || {})
+      };
+    }
+
     // Centralised checkPermissions function
     await scope.checkPermissions({
       method: 'post',
-      auth: context.auth,
-      transaction: context.transaction
+      originalContext: context,
     });
 
     await runHooks('beforeDataCall');
@@ -116,16 +125,19 @@ export default async function postMethod({
     
     // Process many-to-many relationships after main record creation
     for (const { relName, relDef, relData } of manyToManyRelationships) {
+      if (api.anyapi?.links?.attachMany && relDef?.through) {
+        await api.anyapi.links.attachMany({
+          context,
+          scopeName,
+          relName,
+          relDef,
+          relData,
+        });
+        continue;
+      }
+
       // Validate pivot resource exists
       validatePivotResource(scopes, relDef, relName);
-      
-      // Create pivot records in the through table to establish many-to-many relationships.
-      // This creates records in the intermediary table (like 'article_tags') that link the main
-      // resource to each related resource. Before creating each pivot record, it validates that
-      // the related resource actually exists (preventing orphaned relationships). If validateExists
-      // is false, it skips validation for performance in bulk operations.
-      // Example: article.tags: [{id: '1'}, {id: '2'}] creates two article_tags records:
-      // {article_id: 100, tag_id: 1} and {article_id: 100, tag_id: 2}
       await createPivotRecords(api, context.id, relDef, relData, context.transaction);
     }
     
@@ -154,4 +166,4 @@ export default async function postMethod({
   } catch (error) {
     await handleWriteMethodError(error, context, 'POST', scopeName, log, runHooks);
   }
-}
+}

package/plugins/core/rest-api-plugin-methods/put.js

@@ -114,11 +114,7 @@ export default async function putMethod({
     
     // Collect all defined relationships for this resource
     for (const [relName, relDef] of Object.entries(schemaRelationships || {})) {
-      if (relDef.manyToMany) {
-        allRelationships[relName] = { type: 'manyToMany', relDef: relDef.manyToMany };
-      }
-      // Also recognize hasMany with through as many-to-many
-      else if (relDef.hasMany && relDef.through) {
+      if (relDef.type === 'manyToMany') {
         allRelationships[relName] = { 
           type: 'manyToMany', 
           relDef: {
@@ -174,11 +170,7 @@ export default async function putMethod({
     // Centralised checkPermissions function
     await scope.checkPermissions({
       method: 'put',
-      auth: context.auth,
-      id: context.id,
-      minimalRecord: context.minimalRecord,
-      isUpdate: context.isUpdate,
-      transaction: context.transaction
+      originalContext: context,
     });
   
     await runHooks('beforeDataCall');
@@ -205,13 +197,21 @@ export default async function putMethod({
 
     // Process many-to-many relationships after main record update/creation
     for (const { relName, relDef, relData } of manyToManyRelationships) {
-      // Validate pivot resource exists
+      if (relDef?.through && api.anyapi?.links?.syncMany) {
+        await api.anyapi.links.syncMany({
+          context,
+          scopeName,
+          relName,
+          relDef,
+          relData,
+          isUpdate: context.isUpdate,
+        });
+        continue;
+      }
+
       await validatePivotResource(scopes, relDef, relName);
-      
-      // Use smart sync for updates (like industry standard ORMs)
+
       if (context.isUpdate) {
-        // Update many-to-many relationships using intelligent synchronization
-        // This preserves existing pivot data while efficiently updating relationships
         await updateManyToManyRelationship(null, {
           api,
           context: {
@@ -221,11 +221,8 @@ export default async function putMethod({
             transaction: context.transaction
           }
         });
-      } else {
-        // For new records, just create the pivot records
-        if (relData.length > 0) {
-          await createPivotRecords(api, context.id, relDef, relData, context.transaction);
-        }
+      } else if (relData.length > 0) {
+        await createPivotRecords(api, context.id, relDef, relData, context.transaction);
       }
     }
    
@@ -254,4 +251,4 @@ export default async function putMethod({
   } catch (error) {
     await handleWriteMethodError(error, context, 'PUT', scopeName, log, runHooks);
   }
-}
+}

package/plugins/core/rest-api-plugin-methods/query.js

@@ -61,8 +61,8 @@ export default async function queryMethod({
   context.scopeName = scopeName;
 
   // These are just shortcuts used in this function and will be returned
-  const searchSchema = context.schemaInfo.searchSchema;
-  const schemaStructure = context.schemaInfo.schema.structure;
+  const searchSchema = context.schemaInfo.searchSchemaInstance;
+  const schemaStructure = context.schemaInfo.schemaInstance.structure;
   const schemaRelationships = context.schemaInfo.schemaRelationships;
 
   // Sortable fields and sort (mab)
@@ -125,8 +125,7 @@ export default async function queryMethod({
   // Centralised checkPermissions function
   await scope.checkPermissions({
     method: 'query',
-    auth: context.auth,
-    transaction: context.transaction
+    originalContext: context,
   });
 
   await runHooks('beforeData');

package/plugins/core/rest-api-plugin-methods/release.js

@@ -0,0 +1,13 @@
+import { ValidationError } from 'hooked-api';
+
+/**
+ * release
+ * Runs the hook that tells plugins to release resources
+ */
+export default async ({ runHooks }) => {
+
+  // Run the addRoute hook to notify transport plugins
+  await runHooks('release');
+  
+  return { };
+}

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

@@ -17,6 +17,7 @@ import deleteMethod from './rest-api-plugin-methods/delete.js';
 import enrichAttributesMethod from './rest-api-plugin-methods/enrich-attributes.js';
 import checkPermissionsMethod from './rest-api-plugin-methods/check-permissions.js';
 import addRouteMethod from './rest-api-plugin-methods/add-route.js';
+import releaseMethod from './rest-api-plugin-methods/release.js';
 import { defaultDataHelpers } from './lib/querying-writing/default-data-helpers.js';
 import { DEFAULT_QUERY_LIMIT, DEFAULT_MAX_QUERY_LIMIT, DEFAULT_INCLUDE_DEPTH_LIMIT } from './lib/querying-writing/knex-constants.js';
 
@@ -54,7 +55,6 @@ export const RestApiPlugin = {
     vars.queryDefaultLimit = restApiOptions.queryDefaultLimit || DEFAULT_QUERY_LIMIT
     vars.queryMaxLimit = restApiOptions.queryMaxLimit || DEFAULT_MAX_QUERY_LIMIT
     vars.includeDepthLimit = restApiOptions.includeDepthLimit || DEFAULT_INCLUDE_DEPTH_LIMIT
-    vars.publicBaseUrl = restApiOptions.publicBaseUrl || ''
     vars.enablePaginationCounts = restApiOptions.enablePaginationCounts || true
 
     // New simplified settings
@@ -127,6 +127,8 @@ export const RestApiPlugin = {
 
     addApiMethod('addRoute', addRouteMethod);
 
+    addApiMethod('release', releaseMethod);
+
     // Main REST methods
     addScopeMethod('query', queryMethod);
     addScopeMethod('get', getMethod);
@@ -161,8 +163,5 @@ export const RestApiPlugin = {
     // Add default getLocation helper for generating resource URLs
     // This can be overridden by storage plugins if needed
     helpers.getLocation = ({ scopeName, id }) => `/${scopeName}/${id}`
-    
-    // Helper to get the URL prefix for generating links
-    helpers.getUrlPrefix = ({ scope }) => scope?.vars?.publicBaseUrl || vars.publicBaseUrl || vars.transport?.mountPath || ''
   }
 };