@fjell/client-api 4.4.43 → 4.4.45

package/dist/index.js

@@ -17,12 +17,12 @@ var getAllOperation = (api, apiOptions, utilities) => {
     const params = queryToParams(query);
     const requestOptions = Object.assign({}, apiOptions.getOptions, { isAuthenticated: apiOptions.allAuthenticated, params });
     logger.default("all", { query, locations, requestOptions });
-    return utilities.validatePK(await utilities.processArray(
+    return await utilities.processArray(
       api.httpGet(
         utilities.getPath(loc),
         requestOptions
       )
-    ));
+    );
   };
   return all;
 };
@@ -30,17 +30,17 @@ var getAllOperation = (api, apiOptions, utilities) => {
 // src/ops/action.ts
 var logger2 = logger_default.get("client-api", "ops", "action");
 var getActionOperation = (api, apiOptions, utilities) => {
-  const action = async (ik, action2, body = {}) => {
+  const action = async (ik, action2, params) => {
     const requestOptions = Object.assign({}, apiOptions.postOptions, { isAuthenticated: apiOptions.writeAuthenticated });
-    logger2.default("action", { ik, action: action2, body, requestOptions });
+    logger2.default("action", { ik, action: action2, params, requestOptions });
     const response = await api.httpPost(
       `${utilities.getPath(ik)}/${action2}`,
-      body,
+      params || {},
       requestOptions
     );
     const [item, affectedItems] = response;
     return [
-      utilities.validatePK(await utilities.processOne(Promise.resolve(item))),
+      await utilities.processOne(Promise.resolve(item)),
       affectedItems
     ];
   };
@@ -50,24 +50,23 @@ var getActionOperation = (api, apiOptions, utilities) => {
 // src/ops/allAction.ts
 var logger3 = logger_default.get("client-api", "ops", "allAction");
 var getAllActionOperation = (api, apiOptions, utilities) => {
-  const allAction = async (action, body = {}, locations = []) => {
+  const allAction = async (action, params, locations) => {
     const requestOptions = Object.assign({}, apiOptions.postOptions, { isAuthenticated: apiOptions.writeAuthenticated });
-    logger3.default("allAction", { action, body, locations, requestOptions });
-    utilities.verifyLocations(locations);
-    const loc = locations;
+    const loc = locations || [];
+    logger3.default("allAction", { action, params, locations: loc, requestOptions });
+    utilities.verifyLocations(loc);
     const response = await api.httpPost(
       `${utilities.getPath(loc)}/${action}`,
-      body,
+      params || {},
       requestOptions
     );
     let items = [];
     let affectedItems = [];
     if (Array.isArray(response)) {
-      if (response[0] !== void 0 && response[1] !== void 0) {
+      if (response.length === 2 && Array.isArray(response[0])) {
         [items, affectedItems] = response;
-      } else if (response[0] !== void 0) {
-        items = response[0];
-        affectedItems = [];
+      } else {
+        return response;
       }
     } else if (response && typeof response === "object" && Object.keys(response).length === 0) {
       items = [];
@@ -76,10 +75,12 @@ var getAllActionOperation = (api, apiOptions, utilities) => {
       items = [];
       affectedItems = [];
     }
+    const processedItems = await utilities.processArray(Promise.resolve(items));
+    if (Array.isArray(processedItems)) {
+      processedItems.forEach((item) => utilities.validatePK(item));
+    }
     return [
-      utilities.validatePK(
-        await utilities.processArray(Promise.resolve(items))
-      ),
+      processedItems,
       affectedItems
     ];
   };
@@ -99,12 +100,12 @@ var getOneOperation = (api, apiOptions, utilities) => {
     const requestOptions = Object.assign({}, apiOptions.getOptions, { isAuthenticated: apiOptions.readAuthenticated, params });
     logger4.default("one", { query, locations, requestOptions });
     let item = null;
-    const items = utilities.validatePK(await utilities.processArray(
+    const items = await utilities.processArray(
       api.httpGet(
         utilities.getPath(loc),
         requestOptions
       )
-    ));
+    );
     if (items.length > 0) {
       item = items[0];
     }
@@ -114,7 +115,11 @@ var getOneOperation = (api, apiOptions, utilities) => {
 };
 
 // src/ops/errorHandling.ts
+import { isFjellHttpError } from "@fjell/http-api";
 function shouldRetryError(error) {
+  if (isFjellHttpError(error)) {
+    return error.isRetryable();
+  }
   if (error.code === "ECONNREFUSED" || error.code === "ENOTFOUND" || error.code === "ENETUNREACH" || error.message?.includes("timeout") || error.message?.includes("network")) {
     return true;
   }
@@ -134,6 +139,9 @@ function calculateRetryDelay(attempt, config) {
 }
 function enhanceError(error, context) {
   if (!error) return new Error("Unknown error occurred");
+  if (isFjellHttpError(error)) {
+    return error;
+  }
   if (error.context) return error;
   const enhancedError = new Error(error.message || "HTTP operation failed");
   Object.assign(enhancedError, {
@@ -153,27 +161,27 @@ function getRetryConfig(apiOptions) {
     ...apiOptions.retryConfig
   };
 }
-function executeErrorHandler(errorHandler, error, context, logger21) {
+function executeErrorHandler(errorHandler, error, context, logger22) {
   if (!errorHandler) return;
   try {
     errorHandler(error, context);
   } catch (handlerError) {
-    logger21.error("Custom error handler failed", {
+    logger22.error("Custom error handler failed", {
       originalError: error.message,
       handlerError: handlerError?.message || String(handlerError)
     });
   }
 }
-async function executeWithRetry(operation, operationName, operationContext, apiOptions, logger21, specialErrorHandling) {
+async function executeWithRetry(operation, operationName, operationContext, apiOptions, logger22, specialErrorHandling) {
   const retryConfig = getRetryConfig(apiOptions);
   let lastError = null;
   const startTime = Date.now();
   for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
     try {
-      logger21.debug(`Executing ${operationName} (attempt ${attempt + 1})`, operationContext);
+      logger22.debug(`Executing ${operationName} (attempt ${attempt + 1})`, operationContext);
       const result = await operation();
       if (attempt > 0) {
-        logger21.info(`${operationName} operation succeeded after ${attempt} retries`, {
+        logger22.info(`${operationName} operation succeeded after ${attempt} retries`, {
           ...operationContext,
           totalAttempts: attempt + 1,
           duration: Date.now() - startTime
@@ -193,7 +201,7 @@ async function executeWithRetry(operation, operationName, operationContext, apiO
       }
       const isRetryable = shouldRetryError(error);
       if (!isRetryable) {
-        logger21.debug(`Not retrying ${operationName} operation due to non-retryable error`, {
+        logger22.debug(`Not retrying ${operationName} operation due to non-retryable error`, {
           ...operationContext,
           errorMessage: error.message,
           errorCode: error.code || error.status,
@@ -202,7 +210,7 @@ async function executeWithRetry(operation, operationName, operationContext, apiO
         break;
       }
       const delay = calculateRetryDelay(attempt, retryConfig);
-      logger21.warning(`Retrying ${operationName} operation (attempt ${attempt + 2}) after ${delay}ms`, {
+      logger22.warning(`Retrying ${operationName} operation (attempt ${attempt + 2}) after ${delay}ms`, {
         ...operationContext,
         errorMessage: error.message,
         errorCode: error.code || error.status,
@@ -213,8 +221,8 @@ async function executeWithRetry(operation, operationName, operationContext, apiO
     }
   }
   const finalError = enhanceError(lastError, operationContext);
-  executeErrorHandler(apiOptions.errorHandler, finalError, operationContext, logger21);
-  logger21.error(`${operationName} operation failed after ${retryConfig.maxRetries + 1} attempts`, {
+  executeErrorHandler(apiOptions.errorHandler, finalError, operationContext, logger22);
+  logger22.error(`${operationName} operation failed after ${retryConfig.maxRetries + 1} attempts`, {
     ...operationContext,
     errorMessage: finalError.message,
     errorCode: finalError.code || finalError.status,
@@ -227,10 +235,15 @@ async function executeWithRetry(operation, operationName, operationContext, apiO
 // src/ops/create.ts
 var logger5 = logger_default.get("client-api", "ops", "create");
 var getCreateOperation = (api, apiOptions, utilities) => {
-  const create = async (item, locations = []) => {
+  const create = async (item, options) => {
+    const locations = options?.locations || [];
     const requestOptions = Object.assign({}, apiOptions.postOptions, { isAuthenticated: apiOptions.writeAuthenticated });
-    logger5.default("create", { item, locations, requestOptions });
+    logger5.default("create", { item, options, locations, requestOptions });
     utilities.verifyLocations(locations);
+    let itemToCreate = item;
+    if (options?.key) {
+      itemToCreate = { ...item, ...options.key };
+    }
     const loc = locations;
     const operationContext = {
       operation: "create",
@@ -252,10 +265,10 @@ var getCreateOperation = (api, apiOptions, utilities) => {
         logger5.debug(`Creating item (attempt ${attempt + 1})`, operationContext);
         const result = await utilities.processOne(api.httpPost(
           utilities.getPath(loc),
-          item,
+          itemToCreate,
           requestOptions
         ));
-        const created = utilities.validatePK(result);
+        utilities.validatePK(result);
         if (attempt > 0) {
           logger5.info(`Create operation succeeded after ${attempt} retries`, {
             ...operationContext,
@@ -263,7 +276,7 @@ var getCreateOperation = (api, apiOptions, utilities) => {
             duration: Date.now() - startTime
           });
         }
-        return created;
+        return result;
       } catch (error) {
         lastError = error;
         if (attempt === retryConfig.maxRetries) {
@@ -319,23 +332,42 @@ var getUpdateOperation = (api, apiOptions, utilities) => {
   const update = async (ik, item) => {
     const requestOptions = Object.assign({}, apiOptions.putOptions, { isAuthenticated: apiOptions.writeAuthenticated });
     logger6.default("update", { ik, item, requestOptions });
-    return utilities.validatePK(await utilities.processOne(
+    return await utilities.processOne(
       api.httpPut(
         utilities.getPath(ik),
         item,
         requestOptions
       )
-    ));
+    );
   };
   return update;
 };
 
+// src/ops/upsert.ts
+var logger7 = logger_default.get("client-api", "ops", "upsert");
+var getUpsertOperation = (api, apiOptions, utilities) => {
+  const upsert = async (key, item, locations) => {
+    const requestOptions = Object.assign({}, apiOptions.putOptions, { isAuthenticated: apiOptions.writeAuthenticated });
+    logger7.default("upsert", { key, item, locations, requestOptions });
+    const path = utilities.getPath(key);
+    const url = locations && locations.length > 0 ? `${path}?locations=${encodeURIComponent(JSON.stringify(locations))}` : path;
+    return await utilities.processOne(
+      api.httpPut(
+        url,
+        { ...item, upsert: true },
+        requestOptions
+      )
+    );
+  };
+  return upsert;
+};
+
 // src/ops/get.ts
-var logger7 = logger_default.get("client-api", "ops", "get");
+var logger8 = logger_default.get("client-api", "ops", "get");
 var getGetOperation = (api, apiOptions, utilities) => {
   const get = async (ik) => {
     const requestOptions = Object.assign({}, apiOptions.getOptions, { isAuthenticated: apiOptions.readAuthenticated });
-    logger7.default("get", { ik, requestOptions });
+    logger8.default("get", { ik, requestOptions });
     const operationContext = {
       operation: "get",
       path: utilities.getPath(ik),
@@ -352,26 +384,26 @@ var getGetOperation = (api, apiOptions, utilities) => {
     const startTime = Date.now();
     for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
       try {
-        logger7.debug(`Getting item (attempt ${attempt + 1})`, operationContext);
+        logger8.debug(`Getting item (attempt ${attempt + 1})`, operationContext);
         const result = await utilities.processOne(
           api.httpGet(
             utilities.getPath(ik),
             requestOptions
           )
         );
-        const item = utilities.validatePK(result);
+        utilities.validatePK(result);
         if (attempt > 0) {
-          logger7.info(`Get operation succeeded after ${attempt} retries`, {
+          logger8.info(`Get operation succeeded after ${attempt} retries`, {
             ...operationContext,
             totalAttempts: attempt + 1,
             duration: Date.now() - startTime
           });
         }
-        return item;
+        return result;
       } catch (error) {
         lastError = error;
         if (error.status === 404) {
-          logger7.debug("Item not found (404)", operationContext);
+          logger8.debug("Item not found (404)", operationContext);
           return null;
         }
         if (attempt === retryConfig.maxRetries) {
@@ -379,7 +411,7 @@ var getGetOperation = (api, apiOptions, utilities) => {
         }
         const isRetryable = shouldRetryError(error);
         if (!isRetryable) {
-          logger7.debug("Not retrying get operation due to non-retryable error", {
+          logger8.debug("Not retrying get operation due to non-retryable error", {
             ...operationContext,
             errorMessage: error.message,
             errorCode: error.code || error.status,
@@ -388,7 +420,7 @@ var getGetOperation = (api, apiOptions, utilities) => {
           break;
         }
         const delay = calculateRetryDelay(attempt, retryConfig);
-        logger7.warning(`Retrying get operation (attempt ${attempt + 2}) after ${delay}ms`, {
+        logger8.warning(`Retrying get operation (attempt ${attempt + 2}) after ${delay}ms`, {
           ...operationContext,
           errorMessage: error.message,
           errorCode: error.code || error.status,
@@ -403,13 +435,13 @@ var getGetOperation = (api, apiOptions, utilities) => {
       try {
         apiOptions.errorHandler(finalError, operationContext);
       } catch (handlerError) {
-        logger7.error("Custom error handler failed", {
+        logger8.error("Custom error handler failed", {
           originalError: finalError.message,
           handlerError: handlerError?.message || String(handlerError)
         });
       }
     }
-    logger7.error(`Get operation failed after ${retryConfig.maxRetries + 1} attempts`, {
+    logger8.error(`Get operation failed after ${retryConfig.maxRetries + 1} attempts`, {
       ...operationContext,
       errorMessage: finalError.message,
       errorCode: finalError.code || finalError.status,
@@ -422,37 +454,41 @@ var getGetOperation = (api, apiOptions, utilities) => {
 };
 
 // src/ops/remove.ts
-var logger8 = logger_default.get("client-api", "ops", "remove");
+var logger9 = logger_default.get("client-api", "ops", "remove");
 var getRemoveOperation = (api, apiOptions, utilities) => {
   const remove = async (ik) => {
     const requestOptions = Object.assign({}, apiOptions.deleteOptions, { isAuthenticated: apiOptions.writeAuthenticated });
-    logger8.default("remove", { ik, requestOptions });
-    return api.httpDelete(utilities.getPath(ik), requestOptions);
+    logger9.default("remove", { ik, requestOptions });
+    const result = await api.httpDelete(utilities.getPath(ik), requestOptions);
+    if (typeof result === "boolean") {
+      return;
+    }
+    return result;
   };
   return remove;
 };
 
 // src/ops/find.ts
-var logger9 = logger_default.get("client-api", "ops", "find");
+var logger10 = logger_default.get("client-api", "ops", "find");
 var getFindOperation = (api, apiOptions, utilities) => {
   const find = async (finder, finderParams = {}, locations = []) => {
     utilities.verifyLocations(locations);
     const loc = locations;
     const mergedParams = finderToParams(finder, finderParams);
     const requestOptions = Object.assign({}, apiOptions.getOptions, { isAuthenticated: apiOptions.allAuthenticated, params: mergedParams });
-    logger9.default("find", { finder, finderParams, locations, requestOptions });
-    return utilities.validatePK(await utilities.processArray(
+    logger10.default("find", { finder, finderParams, locations, requestOptions });
+    return await utilities.processArray(
       api.httpGet(
         utilities.getPath(loc),
         requestOptions
       )
-    ));
+    );
   };
   return find;
 };
 
 // src/ops/findOne.ts
-var logger10 = logger_default.get("client-api", "ops", "find");
+var logger11 = logger_default.get("client-api", "ops", "find");
 var getFindOneOperation = (api, apiOptions, utilities) => {
   const findOne = async (finder, finderParams = {}, locations = []) => {
     utilities.verifyLocations(locations);
@@ -460,23 +496,28 @@ var getFindOneOperation = (api, apiOptions, utilities) => {
     const params = finderToParams(finder, finderParams);
     params.one = true;
     const requestOptions = Object.assign({}, apiOptions.getOptions, { isAuthenticated: apiOptions.allAuthenticated, params });
-    logger10.default("findOne", { finder, finderParams, locations, requestOptions });
-    return utilities.validatePK(await utilities.processArray(
+    logger11.default("findOne", { finder, finderParams, locations, requestOptions });
+    const results = await utilities.processArray(
       api.httpGet(
         utilities.getPath(loc),
         requestOptions
       )
-    ))[0];
+    );
+    const result = results[0];
+    if (result) {
+      utilities.validatePK(result);
+    }
+    return result;
   };
   return findOne;
 };
 
 // src/ops/facet.ts
-var logger11 = logger_default.get("client-api", "ops", "facet");
+var logger12 = logger_default.get("client-api", "ops", "facet");
 var getFacetOperation = (api, apiOptions, utilities) => {
   const facet = async (ik, facet2, params = {}) => {
     const requestOptions = Object.assign({}, apiOptions.getOptions, { isAuthenticated: apiOptions.writeAuthenticated, params });
-    logger11.default("facet", { ik, facet: facet2, requestOptions });
+    logger12.default("facet", { ik, facet: facet2, requestOptions });
     return api.httpGet(
       `${utilities.getPath(ik)}/${facet2}`,
       requestOptions
@@ -486,11 +527,11 @@ var getFacetOperation = (api, apiOptions, utilities) => {
 };
 
 // src/ops/allFacet.ts
-var logger12 = logger_default.get("client-api", "ops", "allFacet");
+var logger13 = logger_default.get("client-api", "ops", "allFacet");
 var getAllFacetOperation = (api, apiOptions, utilities) => {
   const allFacet = async (facet, params = {}, locations = []) => {
     const requestOptions = Object.assign({}, apiOptions.getOptions, { isAuthenticated: apiOptions.writeAuthenticated, params });
-    logger12.default("allFacet", { facet, locations, requestOptions });
+    logger13.default("allFacet", { facet, locations, requestOptions });
     utilities.verifyLocations(locations);
     const loc = locations;
     return api.httpGet(
@@ -563,6 +604,11 @@ var getOperations = (api, apiOptions, utilities) => {
       api,
       apiOptions,
       utilities
+    ),
+    upsert: getUpsertOperation(
+      api,
+      apiOptions,
+      utilities
     )
   };
 };
@@ -574,9 +620,9 @@ import {
   isPriKey
 } from "@fjell/core";
 import deepmerge from "deepmerge";
-var logger13 = logger_default.get("client-api", "Utility");
+var logger14 = logger_default.get("client-api", "Utility");
 var createUtilities = (pkType, pathNames) => {
-  logger13.default("createUtilities", { pkType, pathNames });
+  logger14.default("createUtilities", { pkType, pathNames });
   const verifyLocations = (locations) => {
     if (locations && locations.length < pathNames.length - 1) {
       throw new Error("Not enough locations for pathNames: locations:" + locations.length + " pathNames:" + pathNames.length);
@@ -584,18 +630,18 @@ var createUtilities = (pkType, pathNames) => {
     return true;
   };
   const processOne = async (apiCall) => {
-    logger13.default("processOne", { apiCall });
+    logger14.default("processOne", { apiCall });
     const response = await apiCall;
-    logger13.default("processOne response", {
+    logger14.default("processOne response", {
       responseType: typeof response,
       hasData: !!response
     });
     return convertDoc(response);
   };
   const processArray = async (api) => {
-    logger13.default("processArray", { api });
+    logger14.default("processArray", { api });
     const response = await api;
-    logger13.default("processArray response", {
+    logger14.default("processArray response", {
       responseType: typeof response,
       isArray: Array.isArray(response),
       length: Array.isArray(response) ? response.length : 0
@@ -605,12 +651,12 @@ var createUtilities = (pkType, pathNames) => {
         (subjectChat) => convertDoc(subjectChat)
       );
     } else {
-      logger13.error("Response was not an array", { response });
+      logger14.error("Response was not an array", { response });
       throw new Error("Response was not an array");
     }
   };
   const convertDoc = (doc) => {
-    logger13.default("convertDoc", { doc });
+    logger14.default("convertDoc", { doc });
     if (doc && doc.events) {
       const events = doc.events;
       for (const key in events) {
@@ -621,101 +667,58 @@ var createUtilities = (pkType, pathNames) => {
       return doc;
     }
   };
-  const validateLocationKeyOrder = (keys) => {
-    const locKeys = keys.filter((k) => !isPriKey(k));
-    if (locKeys.length <= 1) {
-      return;
-    }
-    const pathNameOrder = /* @__PURE__ */ new Map();
-    pathNames.forEach((pathName, index) => {
-      const pathParts = pathName.split("/");
-      const lastPart = pathParts[pathParts.length - 1];
-      pathNameOrder.set(pathName, index);
-      pathNameOrder.set(pathName.toLowerCase(), index);
-      pathNameOrder.set(lastPart, index);
-      pathNameOrder.set(lastPart.toLowerCase(), index);
-      const singular = lastPart.endsWith("s") ? lastPart.slice(0, -1) : lastPart;
-      const plural = lastPart + "s";
-      const pluralEs = lastPart + "es";
-      pathNameOrder.set(singular, index);
-      pathNameOrder.set(plural, index);
-      pathNameOrder.set(pluralEs, index);
-      pathNameOrder.set(singular.toLowerCase(), index);
-      pathNameOrder.set(plural.toLowerCase(), index);
-    });
-    let lastIndex = -1;
-    const keyDetails = [];
-    for (const locKey of locKeys) {
-      const keyType = locKey.kt;
-      const currentIndex = pathNameOrder.get(keyType);
-      keyDetails.push({ kt: keyType, pathNameIndex: currentIndex });
-      if (typeof currentIndex !== "undefined") {
-        if (currentIndex <= lastIndex) {
-          logger13.error("Location keys are not in the correct hierarchical order", {
-            keys: locKeys.map((k) => ({ kt: k.kt, lk: k.lk })),
-            pathNames,
-            keyDetails,
-            issue: `Key type "${keyType}" (index ${currentIndex}) should come before the previous key (index ${lastIndex})`
-          });
-          throw new Error(
-            `Location keys must be ordered from parent to child according to the entity hierarchy. Expected order based on pathNames: [${pathNames.join(", ")}]. Received key types in order: [${locKeys.map((k) => k.kt).join(", ")}]. Key "${keyType}" is out of order - it should appear earlier in the hierarchy.`
-          );
-        }
-        lastIndex = currentIndex;
-      }
-    }
-    logger13.default("Location key order validation passed", {
-      locKeys: locKeys.map((k) => ({ kt: k.kt, lk: k.lk })),
-      keyDetails
-    });
-  };
   const getPath = (key) => {
     const localPathNames = [...pathNames];
-    logger13.default("getPath", { key, pathNames: localPathNames });
+    logger14.default("getPath", { key, pathNames: localPathNames });
     const keys = generateKeyArray(key);
-    validateLocationKeyOrder(keys);
     if (keys.length > 1) {
       const priKeys = keys.filter((k) => isPriKey(k));
       const locKeys = keys.filter((k) => !isPriKey(k));
-      const reorderedKeys = [...locKeys, ...priKeys];
-      logger13.default("Reordered keys for contained item", {
+      const reversedLocKeys = [...locKeys].reverse();
+      const reorderedKeys = [...reversedLocKeys, ...priKeys];
+      logger14.default("Reordered keys for contained item", {
         original: keys,
+        locKeys,
+        reversedLocKeys,
         reordered: reorderedKeys,
-        priKeys,
-        locKeys
+        priKeys
       });
       let path = addPath("", reorderedKeys, localPathNames);
       if (localPathNames.length === 1) {
         path = `${path}/${localPathNames[0]}`;
       }
-      logger13.default("getPath created", { key, path });
+      logger14.default("getPath created", { key, path });
       return path;
     } else {
-      let path = addPath("", keys, localPathNames);
+      const priKeys = keys.filter((k) => isPriKey(k));
+      const locKeys = keys.filter((k) => !isPriKey(k));
+      const reversedLocKeys = locKeys.length > 0 ? [...locKeys].reverse() : [];
+      const orderedKeys = [...reversedLocKeys, ...priKeys];
+      let path = addPath("", orderedKeys, localPathNames);
       if (localPathNames.length === 1) {
         path = `${path}/${localPathNames[0]}`;
       }
-      logger13.default("getPath created", { key, path });
+      logger14.default("getPath created", { key, path });
       return path;
     }
   };
   const addPath = (base, keys, localPathNames) => {
-    logger13.default("addPath", { base, keys, pathNames: localPathNames });
+    logger14.default("addPath", { base, keys, pathNames: localPathNames });
     if (keys.length < localPathNames.length - 1) {
-      logger13.error(
+      logger14.error(
         "addPath should never have keys with a length less than the length of pathNames - 1",
         { keys, localPathNames }
       );
       throw new Error("addPath should never have keys with a length less than the length of pathNames - 1: " + keys.length + " " + localPathNames.length + " " + JSON.stringify(keys, localPathNames));
     } else if (keys.length > localPathNames.length) {
-      logger13.error(
+      logger14.error(
         "addPath should never have keys with a length greater than the length of pathNames",
         { keys, pathNames }
       );
       throw new Error("addPath should never have keys with a length greater than the length of pathNames: " + keys.length + " " + localPathNames.length + " " + JSON.stringify(keys, localPathNames));
     }
     if (keys.length === 0) {
-      logger13.default("addPath returning base", { base });
+      logger14.default("addPath returning base", { base });
       return base;
     } else {
       const currentKey = keys[0];
@@ -734,7 +737,7 @@ var createUtilities = (pkType, pathNames) => {
         const key = keys.shift();
         const id = isPriKey(key) ? key.pk : key.lk;
         const nextBase = `${base}/${pathName}/${id}`;
-        logger13.default("Adding Path (matched)", {
+        logger14.default("Adding Path (matched)", {
           pathName,
           keyType,
           isPriKey: isPriKey(key),
@@ -747,7 +750,7 @@ var createUtilities = (pkType, pathNames) => {
         const key = keys.shift();
         const id = isPriKey(key) ? key.pk : key.lk;
         const nextBase = `${base}/${pathName}/${id}`;
-        logger13.default("Adding Path (no match, using first)", {
+        logger14.default("Adding Path (no match, using first)", {
           pathName,
           keyType,
           isPriKey: isPriKey(key),
@@ -772,7 +775,7 @@ var createUtilities = (pkType, pathNames) => {
 };
 
 // src/AItemAPI.ts
-var logger14 = logger_default.get("AItemAPI");
+var logger15 = logger_default.get("AItemAPI");
 var finderToParams = (finder, finderParams) => {
   return {
     finder,
@@ -780,7 +783,7 @@ var finderToParams = (finder, finderParams) => {
   };
 };
 var createAItemAPI = (api, pkType, pathNames, options) => {
-  logger14.default("createAItemAPI", { pkType, pathNames, options });
+  logger15.default("createAItemAPI", { pkType, pathNames, options });
   let mergedOptions;
   const defaultOptions = {
     readAuthenticated: true,
@@ -810,14 +813,15 @@ var createAItemAPI = (api, pkType, pathNames, options) => {
     get: operations.get,
     one: operations.one,
     remove: operations.remove,
-    update: operations.update
+    update: operations.update,
+    upsert: operations.upsert
   };
 };
 
 // src/CItemAPI.ts
-var logger15 = logger_default.get("CItemAPI");
+var logger16 = logger_default.get("CItemAPI");
 var createCItemApi = (api, type, pathNames, options) => {
-  logger15.default("createCItemApi", { api, type, pathNames, options });
+  logger16.default("createCItemApi", { api, type, pathNames, options });
   const aItemAPI = createAItemAPI(api, type, pathNames, options);
   return {
     action: aItemAPI.action,
@@ -829,6 +833,7 @@ var createCItemApi = (api, type, pathNames, options) => {
     create: aItemAPI.create,
     remove: aItemAPI.remove,
     update: aItemAPI.update,
+    upsert: aItemAPI.upsert,
     facet: aItemAPI.facet,
     find: aItemAPI.find,
     findOne: aItemAPI.findOne
@@ -836,24 +841,24 @@ var createCItemApi = (api, type, pathNames, options) => {
 };
 
 // src/PItemAPI.ts
-var logger16 = logger_default.get("PItemAPI");
+var logger17 = logger_default.get("PItemAPI");
 var createPItemApi = (api, type, pathName, options) => {
-  logger16.default("createPItemApi", { type, pathName, options });
+  logger17.default("createPItemApi", { type, pathName, options });
   const aItemAPI = createAItemAPI(api, type, [pathName], options);
-  const action = async (ik, action2, body = {}) => await aItemAPI.action(ik, action2, body);
-  const all = async (query = {}) => await aItemAPI.all(query, []);
-  const allAction = async (action2, body = {}) => await aItemAPI.allAction(action2, body, []);
-  const allFacet = async (facet2, params = {}) => await aItemAPI.allFacet(facet2, params);
-  const one = async (query = {}) => await aItemAPI.one(query, []);
+  const action = async (ik, action2, params) => await aItemAPI.action(ik, action2, params);
+  const all = async (query) => await aItemAPI.all(query || {}, []);
+  const allAction = async (action2, params) => await aItemAPI.allAction(action2, params, []);
+  const allFacet = async (facet2, params) => await aItemAPI.allFacet(facet2, params);
+  const one = async (query) => await aItemAPI.one(query || {}, []);
   const get = async (ik) => await aItemAPI.get(ik);
-  const create = async (item) => await aItemAPI.create(item, []);
+  const create = async (item, options2) => await aItemAPI.create(item, options2);
   const remove = async (ik) => await aItemAPI.remove(ik);
   const update = async (ik, item) => await aItemAPI.update(ik, item);
-  const facet = async (ik, facet2, params = {}) => await aItemAPI.facet(ik, facet2, params);
-  const find = async (finder, finderParams = {}) => await aItemAPI.find(finder, finderParams);
-  const findOne = async (finder, finderParams = {}) => await aItemAPI.findOne(finder, finderParams);
+  const upsert = async (ik, item, locations) => await aItemAPI.upsert(ik, item, locations);
+  const facet = async (ik, facet2, params) => await aItemAPI.facet(ik, facet2, params);
+  const find = async (finder, finderParams) => await aItemAPI.find(finder, finderParams);
+  const findOne = async (finder, finderParams) => await aItemAPI.findOne(finder, finderParams);
   return {
-    ...aItemAPI,
     action,
     all,
     allAction,
@@ -863,6 +868,7 @@ var createPItemApi = (api, type, pathName, options) => {
     create,
     remove,
     update,
+    upsert,
     facet,
     find,
     findOne
@@ -871,18 +877,18 @@ var createPItemApi = (api, type, pathName, options) => {
 
 // src/Instance.ts
 import { createInstance as createBaseInstance } from "@fjell/registry";
-var logger17 = logger_default.get("Instance");
+var logger18 = logger_default.get("Instance");
 var createInstance = (registry, coordinate, clientApi) => {
-  logger17.debug("createInstance", { coordinate, clientApi, registry });
+  logger18.debug("createInstance", { coordinate, clientApi, registry });
   const baseInstance = createBaseInstance(registry, coordinate);
   return { ...baseInstance, clientApi };
 };
 
 // src/InstanceFactory.ts
-var logger18 = logger_default.get("InstanceFactory");
+var logger19 = logger_default.get("InstanceFactory");
 var createInstanceFactory = (clientApi) => {
   return (coordinate, context) => {
-    logger18.debug("Creating client-api instance", { coordinate, registry: context.registry, clientApi });
+    logger19.debug("Creating client-api instance", { coordinate, registry: context.registry, clientApi });
     return createInstance(context.registry, coordinate, clientApi);
   };
 };
@@ -891,13 +897,13 @@ var createInstanceFactory = (clientApi) => {
 import {
   createRegistry as createBaseRegistry
 } from "@fjell/registry";
-var logger19 = logger_default.get("Registry");
+var logger20 = logger_default.get("Registry");
 var createRegistryFactory = () => {
   return (type, registryHub) => {
     if (type !== "client-api") {
       throw new Error(`Client API registry factory can only create 'client-api' type registries, got: ${type}`);
     }
-    logger19.debug("Creating client-api registry", { type, registryHub });
+    logger20.debug("Creating client-api registry", { type, registryHub });
     const baseRegistry = createBaseRegistry(type, registryHub);
     return baseRegistry;
   };
@@ -1096,8 +1102,11 @@ function isClientApiError(error) {
   return error instanceof ClientApiError;
 }
 
+// src/index.ts
+import { FjellHttpError, isFjellHttpError as isFjellHttpError2, extractErrorInfo } from "@fjell/http-api";
+
 // src/http/HttpWrapper.ts
-var logger20 = {
+var logger21 = {
   debug: (message, context) => console.debug(message, context),
   info: (message, context) => console.info(message, context),
   warning: (message, context) => console.warn(message, context),
@@ -1115,7 +1124,7 @@ var DEFAULT_RETRY_CONFIG = {
     return false;
   },
   onRetry: (error, attemptNumber, delay) => {
-    logger20.warning(`Retrying HTTP request (attempt ${attemptNumber + 1}) after ${delay}ms`, {
+    logger21.warning(`Retrying HTTP request (attempt ${attemptNumber + 1}) after ${delay}ms`, {
       errorCode: error.code,
       errorMessage: error.message,
       delay,
@@ -1148,14 +1157,14 @@ var HttpWrapper = class {
     const startTime = Date.now();
     for (let attempt = 0; attempt <= this.retryConfig.maxRetries; attempt++) {
       try {
-        logger20.debug(`Executing ${operationName}`, {
+        logger21.debug(`Executing ${operationName}`, {
           attempt: attempt + 1,
           maxRetries: this.retryConfig.maxRetries + 1,
           ...context
         });
         const result = await operation();
         if (attempt > 0) {
-          logger20.info(`${operationName} succeeded after ${attempt} retries`, {
+          logger21.info(`${operationName} succeeded after ${attempt} retries`, {
             totalAttempts: attempt + 1,
             duration: Date.now() - startTime,
             ...context
@@ -1168,7 +1177,7 @@ var HttpWrapper = class {
           break;
         }
         if (!this.retryConfig.shouldRetry(lastError, attempt)) {
-          logger20.debug(`Not retrying ${operationName} due to non-retryable error`, {
+          logger21.debug(`Not retrying ${operationName} due to non-retryable error`, {
             errorCode: lastError.code,
             errorMessage: lastError.message,
             attempt: attempt + 1,
@@ -1184,7 +1193,7 @@ var HttpWrapper = class {
         await sleep(delay);
       }
     }
-    logger20.error(`${operationName} failed after ${this.retryConfig.maxRetries + 1} attempts`, {
+    logger21.error(`${operationName} failed after ${this.retryConfig.maxRetries + 1} attempts`, {
       errorCode: lastError?.code,
       errorMessage: lastError?.message,
       duration: Date.now() - startTime,
@@ -1276,6 +1285,7 @@ export {
   ClientApiError,
   ConfigurationError,
   ConflictError,
+  FjellHttpError,
   HttpError,
   HttpWrapper,
   NetworkError,
@@ -1298,8 +1308,10 @@ export {
   enhanceError,
   executeErrorHandler,
   executeWithRetry,
+  extractErrorInfo,
   getRetryConfig,
   isClientApiError,
+  isFjellHttpError2 as isFjellHttpError,
   isRetryableError,
   shouldRetryError
 };