@fjell/client-api 4.4.2 → 4.4.3

package/dist/index.cjs

@@ -8,74 +8,78 @@ const deepmerge = require('deepmerge');
 
 const LibLogger = Logging.getLogger('@fjell/client-api');
 
-const logger$e = LibLogger.get('client-api', 'ops', 'all');
+const logger$f = LibLogger.get('client-api', 'ops', 'all');
 const getAllOperation = (api, apiOptions, utilities)=>{
-    const all = async (query = {}, options = {}, locations = [])=>{
-        logger$e.default('all', {
-            query,
-            locations
-        });
+    const all = async (query = {}, locations = [])=>{
         utilities.verifyLocations(locations);
         const loc = locations;
         const params = core.queryToParams(query);
-        const requestOptions = Object.assign({}, options, {
+        const requestOptions = Object.assign({}, apiOptions.getOptions, {
             isAuthenticated: apiOptions.allAuthenticated,
             params
         });
+        logger$f.default('all', {
+            query,
+            locations,
+            requestOptions
+        });
         return utilities.validatePK(await utilities.processArray(api.httpGet(utilities.getPath(loc), requestOptions)));
     };
     return all;
 };
 
-const logger$d = LibLogger.get('client-api', 'ops', 'action');
+const logger$e = LibLogger.get('client-api', 'ops', 'action');
 const getActionOperation = (api, apiOptions, utilities)=>{
-    const action = async (ik, action, body = {}, options = {})=>{
-        logger$d.default('action', {
+    const action = async (ik, action, body = {})=>{
+        const requestOptions = Object.assign({}, apiOptions.postOptions, {
+            isAuthenticated: apiOptions.writeAuthenticated
+        });
+        logger$e.default('action', {
             ik,
             action,
-            body
-        });
-        const requestOptions = Object.assign({}, options, {
-            isAuthenticated: apiOptions.writeAuthenticated
+            body,
+            requestOptions
         });
         return utilities.validatePK(await utilities.processOne(api.httpPost(`${utilities.getPath(ik)}/${action}`, body, requestOptions)));
     };
     return action;
 };
 
-const logger$c = LibLogger.get('client-api', 'ops', 'allAction');
+const logger$d = LibLogger.get('client-api', 'ops', 'allAction');
 const getAllActionOperation = (api, apiOptions, utilities)=>{
-    const allAction = async (action, body = {}, options = {}, locations = [])=>{
-        logger$c.default('allAction', {
+    const allAction = async (action, body = {}, locations = [])=>{
+        const requestOptions = Object.assign({}, apiOptions.postOptions, {
+            isAuthenticated: apiOptions.writeAuthenticated
+        });
+        logger$d.default('allAction', {
             action,
             body,
-            locations
+            locations,
+            requestOptions
         });
         utilities.verifyLocations(locations);
         const loc = locations;
-        const requestOptions = Object.assign({}, options, {
-            isAuthenticated: apiOptions.writeAuthenticated
-        });
         // TODO: This should respond to either a single object, or multiple objects in an array.
         return utilities.validatePK(await utilities.processArray(api.httpPost(utilities.getPath(loc), body, requestOptions)));
     };
     return allAction;
 };
 
-const logger$b = LibLogger.get('client-api', 'ops', 'one');
+const logger$c = LibLogger.get('client-api', 'ops', 'one');
 const getOneOperation = (api, apiOptions, utilities)=>{
-    const one = async (query = {}, options = {}, locations = [])=>{
-        logger$b.default('one', {
-            query,
-            locations
-        });
+    const one = async (query = {}, locations = [])=>{
         utilities.verifyLocations(locations);
         const loc = locations;
         const params = core.queryToParams(query);
-        const requestOptions = Object.assign({}, options, {
+        const requestOptions = Object.assign({}, apiOptions.getOptions, {
             isAuthenticated: apiOptions.readAuthenticated,
             params
         });
+        logger$c.default('one', {
+            query,
+            locations,
+            requestOptions
+        });
         let item = null;
         const items = utilities.validatePK(await utilities.processArray(api.httpGet(utilities.getPath(loc), requestOptions)));
         if (items.length > 0) {
@@ -86,109 +90,115 @@ const getOneOperation = (api, apiOptions, utilities)=>{
     return one;
 };
 
-const logger$a = LibLogger.get('client-api', 'ops', 'create');
+const logger$b = LibLogger.get('client-api', 'ops', 'create');
 const getCreateOperation = (api, apiOptions, utilities)=>{
-    const create = async (item, options = {}, locations = [])=>{
-        logger$a.default('create', {
+    const create = async (item, locations = [])=>{
+        const requestOptions = Object.assign({}, apiOptions.postOptions, {
+            isAuthenticated: apiOptions.writeAuthenticated
+        });
+        logger$b.default('create', {
             item,
-            locations
+            locations,
+            requestOptions
         });
         utilities.verifyLocations(locations);
         const loc = locations;
-        const requestOptions = Object.assign({}, options, {
-            isAuthenticated: apiOptions.writeAuthenticated
-        });
         const created = utilities.validatePK(await utilities.processOne(api.httpPost(utilities.getPath(loc), item, requestOptions)));
         return created;
     };
     return create;
 };
 
-const logger$9 = LibLogger.get('client-api', 'ops', 'update');
+const logger$a = LibLogger.get('client-api', 'ops', 'update');
 const getUpdateOperation = (api, apiOptions, utilities)=>{
-    const update = async (ik, item, options = {})=>{
-        logger$9.default('update', {
-            ik,
-            item
-        });
-        const requestOptions = Object.assign({}, options, {
+    const update = async (ik, item)=>{
+        const requestOptions = Object.assign({}, apiOptions.putOptions, {
             isAuthenticated: apiOptions.writeAuthenticated
         });
+        logger$a.default('update', {
+            ik,
+            item,
+            requestOptions
+        });
         return utilities.validatePK(await utilities.processOne(api.httpPut(utilities.getPath(ik), item, requestOptions)));
     };
     return update;
 };
 
-const logger$8 = LibLogger.get('client-api', 'ops', 'get');
+const logger$9 = LibLogger.get('client-api', 'ops', 'get');
 const getGetOperation = (api, apiOptions, utilities)=>{
-    const get = async (ik, options = {})=>{
-        logger$8.default('get', {
-            ik
-        });
-        const requestOptions = Object.assign({}, options, {
+    const get = async (ik)=>{
+        const requestOptions = Object.assign({}, apiOptions.getOptions, {
             isAuthenticated: apiOptions.readAuthenticated
         });
+        logger$9.default('get', {
+            ik,
+            requestOptions
+        });
         return utilities.validatePK(await utilities.processOne(api.httpGet(utilities.getPath(ik), requestOptions)));
     };
     return get;
 };
 
-const logger$7 = LibLogger.get('client-api', 'ops', 'remove');
+const logger$8 = LibLogger.get('client-api', 'ops', 'remove');
 const getRemoveOperation = (api, apiOptions, utilities)=>{
-    const remove = async (ik, options = {})=>{
-        logger$7.default('remove', {
-            ik
-        });
-        const requestOptions = Object.assign({}, options, {
+    const remove = async (ik)=>{
+        const requestOptions = Object.assign({}, apiOptions.deleteOptions, {
             isAuthenticated: apiOptions.writeAuthenticated
         });
+        logger$8.default('remove', {
+            ik,
+            requestOptions
+        });
         return api.httpDelete(utilities.getPath(ik), requestOptions);
     };
     return remove;
 };
 
-const logger$6 = LibLogger.get('client-api', 'ops', 'find');
+const logger$7 = LibLogger.get('client-api', 'ops', 'find');
 const getFindOperation = (api, apiOptions, utilities)=>{
-    const find = async (finder, finderParams, options = {}, locations = [])=>{
-        logger$6.default('find', {
-            finder,
-            finderParams,
-            locations
-        });
+    const find = async (finder, finderParams = {}, locations = [])=>{
         utilities.verifyLocations(locations);
         const loc = locations;
-        const params = finderToParams(finder, finderParams);
-        const requestOptions = Object.assign({}, options, {
+        const mergedParams = finderToParams(finder, finderParams);
+        const requestOptions = Object.assign({}, apiOptions.getOptions, {
             isAuthenticated: apiOptions.allAuthenticated,
-            params
+            params: mergedParams
+        });
+        logger$7.default('find', {
+            finder,
+            finderParams,
+            locations,
+            requestOptions
         });
         return utilities.validatePK(await utilities.processArray(api.httpGet(utilities.getPath(loc), requestOptions)));
     };
     return find;
 };
 
-const logger$5 = LibLogger.get('client-api', 'ops', 'find');
+const logger$6 = LibLogger.get('client-api', 'ops', 'find');
 const getFindOneOperation = (api, apiOptions, utilities)=>{
-    const findOne = async (finder, finderParams, options = {}, locations = [])=>{
-        logger$5.default('findOne', {
-            finder,
-            finderParams,
-            locations
-        });
+    const findOne = async (finder, finderParams = {}, locations = [])=>{
         utilities.verifyLocations(locations);
         const loc = locations;
         const params = finderToParams(finder, finderParams);
         params.one = true;
-        const requestOptions = Object.assign({}, options, {
+        const requestOptions = Object.assign({}, apiOptions.getOptions, {
             isAuthenticated: apiOptions.allAuthenticated,
             params
         });
+        logger$6.default('findOne', {
+            finder,
+            finderParams,
+            locations,
+            requestOptions
+        });
         return utilities.validatePK(await utilities.processArray(api.httpGet(utilities.getPath(loc), requestOptions)))[0];
     };
     return findOne;
 };
 
-const logger$4 = LibLogger.get('client-api', 'ops', 'facet');
+const logger$5 = LibLogger.get('client-api', 'ops', 'facet');
 const getFacetOperation = (api, apiOptions, utilities)=>{
     /**
    * Executes a facet operation on an item.
@@ -203,24 +213,47 @@ const getFacetOperation = (api, apiOptions, utilities)=>{
    * @param body - Optional request body for the facet operation
    * @param options - Optional HTTP request options
    * @returns Promise resolving to the facet data
-   */ const facet = async (ik, facet, options = {})=>{
-        logger$4.default('facet', {
-            ik,
-            facet
+   */ const facet = async (ik, facet, params = {})=>{
+        const requestOptions = Object.assign({}, apiOptions.getOptions, {
+            isAuthenticated: apiOptions.writeAuthenticated,
+            params
         });
-        const requestOptions = Object.assign({}, options, {
-            isAuthenticated: apiOptions.writeAuthenticated
+        logger$5.default('facet', {
+            ik,
+            facet,
+            requestOptions
         });
         return api.httpGet(`${utilities.getPath(ik)}/${facet}`, requestOptions);
     };
     return facet;
 };
 
+const logger$4 = LibLogger.get('client-api', 'ops', 'allFacet');
+const getAllFacetOperation = (api, apiOptions, utilities)=>{
+    const allFacet = async (facet, params = {}, locations = [])=>{
+        const requestOptions = Object.assign({}, apiOptions.getOptions, {
+            isAuthenticated: apiOptions.writeAuthenticated,
+            params
+        });
+        logger$4.default('allFacet', {
+            facet,
+            locations,
+            requestOptions
+        });
+        utilities.verifyLocations(locations);
+        const loc = locations;
+        // TODO: This should respond to either a single object, or multiple objects in an array.
+        return api.httpGet(utilities.getPath(loc), requestOptions);
+    };
+    return allFacet;
+};
+
 const getOperations = (api, apiOptions, utilities)=>{
     return {
         action: getActionOperation(api, apiOptions, utilities),
         all: getAllOperation(api, apiOptions, utilities),
         allAction: getAllActionOperation(api, apiOptions, utilities),
+        allFacet: getAllFacetOperation(api, apiOptions, utilities),
         create: getCreateOperation(api, apiOptions, utilities),
         facet: getFacetOperation(api, apiOptions, utilities),
         findOne: getFindOneOperation(api, apiOptions, utilities),
@@ -396,7 +429,11 @@ const createAItemAPI = (api, pkType, pathNames, options)=>{
     const defaultOptions = {
         readAuthenticated: true,
         allAuthenticated: true,
-        writeAuthenticated: true
+        writeAuthenticated: true,
+        getOptions: {},
+        postOptions: {},
+        putOptions: {},
+        deleteOptions: {}
     };
     if (options) {
         mergedOptions = Object.assign({}, defaultOptions, options);
@@ -409,6 +446,7 @@ const createAItemAPI = (api, pkType, pathNames, options)=>{
         action: operations.action,
         all: operations.all,
         allAction: operations.allAction,
+        allFacet: operations.allFacet,
         create: operations.create,
         facet: operations.facet,
         find: operations.find,
@@ -433,6 +471,7 @@ const createCItemApi = (api, type, pathNames, options)=>{
         action: aItemAPI.action,
         all: aItemAPI.all,
         allAction: aItemAPI.allAction,
+        allFacet: aItemAPI.allFacet,
         one: aItemAPI.one,
         get: aItemAPI.get,
         create: aItemAPI.create,
@@ -454,22 +493,24 @@ const createPItemApi = (api, type, pathName, options)=>{
     const aItemAPI = createAItemAPI(api, type, [
         pathName
     ], options);
-    const action = async (ik, action, body = {}, options = {})=>await aItemAPI.action(ik, action, body, options);
-    const all = async (query = {}, options = {})=>await aItemAPI.all(query, options, []);
-    const allAction = async (action, body = {}, options = {})=>await aItemAPI.allAction(action, body, options, []);
-    const one = async (query = {}, options = {})=>await aItemAPI.one(query, options, []);
-    const get = async (ik, options = {})=>await aItemAPI.get(ik, options);
-    const create = async (item, options = {})=>await aItemAPI.create(item, options, []);
-    const remove = async (ik, options = {})=>await aItemAPI.remove(ik, options);
-    const update = async (ik, item, options = {})=>await aItemAPI.update(ik, item, options);
-    const facet = async (ik, facet, options = {})=>await aItemAPI.facet(ik, facet, options);
-    const find = async (finder, finderParams, options = {})=>await aItemAPI.find(finder, finderParams, options, []);
-    const findOne = async (finder, finderParams, options = {})=>await aItemAPI.findOne(finder, finderParams, options, []);
+    const action = async (ik, action, body = {})=>await aItemAPI.action(ik, action, body);
+    const all = async (query = {})=>await aItemAPI.all(query, []);
+    const allAction = async (action, body = {})=>await aItemAPI.allAction(action, body, []);
+    const allFacet = async (facet, params = {})=>await aItemAPI.allFacet(facet, 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 remove = async (ik)=>await aItemAPI.remove(ik);
+    const update = async (ik, item)=>await aItemAPI.update(ik, item);
+    const facet = async (ik, facet, params = {})=>await aItemAPI.facet(ik, facet, 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,
+        allFacet,
         one,
         get,
         create,