@fjell/client-api 4.3.3 → 4.4.0

package/babel.config.cjs

@@ -0,0 +1,14 @@
+module.exports = {
+  presets: [
+    ['@babel/preset-env', { targets: { node: 'current' } }],
+    '@babel/preset-typescript'
+  ],
+  overrides: [
+    {
+      test: /node_modules[\\/](?:@fjell[\\/](core|http-api|logging))/,
+      presets: [
+        ['@babel/preset-env', { targets: { node: 'current' } }]
+      ]
+    }
+  ]
+};

package/dist/{src/AItemAPI.d.ts → AItemAPI.d.ts}

@@ -1,7 +1,7 @@
-import { Item, QueryParams } from "@fjell/core";
-import { HttpApi } from "@fjell/http-api";
-import { ClientApiOptions } from "./ClientApiOptions";
-import { ClientApi } from "./ClientApi";
+import { Item, QueryParams } from '@fjell/core';
+import { HttpApi } from '@fjell/http-api';
+import { ClientApiOptions } from './ClientApiOptions';
+import { ClientApi } from './ClientApi';
 export type PathNamesArray<L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> = ([L5] extends [never] ? ([L4] extends [never] ? ([L3] extends [never] ? ([L2] extends [never] ? ([L1] extends [never] ? [
     string
 ] : [

package/dist/AItemAPI.js

@@ -0,0 +1,45 @@
+import { getOperations } from './ops/index.js';
+import { createUtilities } from './Utilities.js';
+import LibLogger from './logger.js';
+
+const logger = LibLogger.get('AItemAPI');
+const finderToParams = (finder, finderParams)=>{
+    return {
+        finder,
+        finderParams: JSON.stringify(finderParams)
+    };
+};
+const createAItemAPI = (api, pkType, pathNames, options)=>{
+    logger.default('createAItemAPI', {
+        pkType,
+        pathNames,
+        options
+    });
+    let mergedOptions;
+    const defaultOptions = {
+        readAuthenticated: true,
+        allAuthenticated: true,
+        writeAuthenticated: true
+    };
+    if (options) {
+        mergedOptions = Object.assign({}, defaultOptions, options);
+    } else {
+        mergedOptions = defaultOptions;
+    }
+    const utilities = createUtilities(pkType, pathNames);
+    const operations = getOperations(api, mergedOptions, utilities);
+    return {
+        action: operations.action,
+        all: operations.all,
+        allAction: operations.allAction,
+        create: operations.create,
+        find: operations.find,
+        get: operations.get,
+        one: operations.one,
+        remove: operations.remove,
+        update: operations.update
+    };
+};
+
+export { createAItemAPI, finderToParams };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQUl0ZW1BUEkuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/{src/CItemAPI.d.ts → CItemAPI.d.ts}

@@ -1,8 +1,8 @@
-import { ComKey, Item, ItemQuery, LocKeyArray, PriKey, TypesProperties } from "@fjell/core";
-import { DeleteMethodOptions, GetMethodOptions, HttpApi, PostMethodOptions, PutMethodOptions } from "@fjell/http-api";
-import { PathNamesArray } from "./AItemAPI";
-import { ClientApi } from "./ClientApi";
-import { ClientApiOptions } from "./ClientApiOptions";
+import { ComKey, Item, ItemQuery, LocKeyArray, PriKey, TypesProperties } from '@fjell/core';
+import { DeleteMethodOptions, GetMethodOptions, HttpApi, PostMethodOptions, PutMethodOptions } from '@fjell/http-api';
+import { PathNamesArray } from './AItemAPI';
+import { ClientApi } from './ClientApi';
+import { ClientApiOptions } from './ClientApiOptions';
 export interface CItemApi<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> extends ClientApi<V, S, L1, L2, L3, L4, L5> {
     action: (ik: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>, action: string, body: any, options: Partial<PostMethodOptions>) => Promise<V>;
     all: (query: ItemQuery, options: Partial<GetMethodOptions>, locations: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<V[]>;

package/dist/CItemAPI.js

@@ -0,0 +1,27 @@
+import { createAItemAPI } from './AItemAPI.js';
+import LibLogger from './logger.js';
+
+const logger = LibLogger.get('CItemAPI');
+const createCItemApi = (api, type, pathNames, options)=>{
+    logger.default('createCItemApi', {
+        api,
+        type,
+        pathNames,
+        options
+    });
+    const aItemAPI = createAItemAPI(api, type, pathNames, options);
+    return {
+        action: aItemAPI.action,
+        all: aItemAPI.all,
+        allAction: aItemAPI.allAction,
+        one: aItemAPI.one,
+        get: aItemAPI.get,
+        create: aItemAPI.create,
+        remove: aItemAPI.remove,
+        update: aItemAPI.update,
+        find: aItemAPI.find
+    };
+};
+
+export { createCItemApi };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ0l0ZW1BUEkuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/{src/ClientApi.d.ts → ClientApi.d.ts}

@@ -1,5 +1,5 @@
-import { ComKey, Item, ItemQuery, LocKeyArray, PriKey, TypesProperties } from "@fjell/core";
-import { DeleteMethodOptions, GetMethodOptions, PostMethodOptions, PutMethodOptions } from "@fjell/http-api";
+import { ComKey, Item, ItemQuery, LocKeyArray, PriKey, TypesProperties } from '@fjell/core';
+import { DeleteMethodOptions, GetMethodOptions, PostMethodOptions, PutMethodOptions } from '@fjell/http-api';
 export interface ClientApi<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> {
     action: (ik: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>, action: string, body: any, options: Partial<PostMethodOptions>) => Promise<V>;
     all: (query: ItemQuery, options: Partial<GetMethodOptions>, locations: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<V[]>;

package/dist/{src/ClientApiOptions.d.ts → ClientApiOptions.d.ts}

@@ -1,5 +1,5 @@
-import { Item } from "@fjell/core";
-import { ClientApi } from "./ClientApi";
+import { Item } from '@fjell/core';
+import { ClientApi } from './ClientApi';
 export interface ClientApiOptions {
     readAuthenticated?: boolean;
     allAuthenticated?: boolean;

package/dist/{src/PItemAPI.d.ts → PItemAPI.d.ts}

@@ -1,8 +1,7 @@
-import { ComKey, Item, ItemQuery, PriKey, TypesProperties } from "@fjell/core";
-import { HttpApi } from "@fjell/http-api";
-import { ClientApi } from "./ClientApi";
-import { DeleteMethodOptions, GetMethodOptions, PostMethodOptions, PutMethodOptions } from "@fjell/http-api";
-import { ClientApiOptions } from "./ClientApiOptions";
+import { ComKey, Item, ItemQuery, PriKey, TypesProperties } from '@fjell/core';
+import { HttpApi, DeleteMethodOptions, GetMethodOptions, PostMethodOptions, PutMethodOptions } from '@fjell/http-api';
+import { ClientApi } from './ClientApi';
+import { ClientApiOptions } from './ClientApiOptions';
 export interface PItemApi<V extends Item<S>, S extends string> extends ClientApi<V, S> {
     action: (ik: PriKey<S> | ComKey<S, never, never, never, never, never>, action: string, body: any, options: Partial<PostMethodOptions>, locations?: []) => Promise<V>;
     all: (query: ItemQuery, options: Partial<GetMethodOptions>, locations?: []) => Promise<V[]>;

package/dist/PItemAPI.js

@@ -0,0 +1,38 @@
+import { createAItemAPI } from './AItemAPI.js';
+import LibLogger from './logger.js';
+
+const logger = LibLogger.get('PItemAPI');
+const createPItemApi = (api, type, pathName, options)=>{
+    logger.default('createPItemApi', {
+        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 find = async (finder, finderParams, options = {})=>await aItemAPI.find(finder, finderParams, options, []);
+    return {
+        ...aItemAPI,
+        action,
+        all,
+        allAction,
+        one,
+        get,
+        create,
+        remove,
+        update,
+        find
+    };
+};
+
+export { createPItemApi };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUEl0ZW1BUEkuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/{src/Utilities.d.ts → Utilities.d.ts}

@@ -1,4 +1,4 @@
-import { ComKey, Item, LocKeyArray, PriKey } from "@fjell/core";
+import { ComKey, Item, LocKeyArray, PriKey } from '@fjell/core';
 export interface Utilities<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> {
     verifyLocations: (locations: LocKeyArray<L1, L2, L3, L4, L5> | [] | never) => boolean;
     processOne: (apiCall: Promise<V>) => Promise<V>;

package/dist/Utilities.js

@@ -0,0 +1,153 @@
+import { validatePK, generateKeyArray, isPriKey } from '@fjell/core';
+import LibLogger from './logger.js';
+import deepmerge from 'deepmerge';
+
+const logger = LibLogger.get('client-api', 'Utility');
+const createUtilities = (pkType, pathNames)=>{
+    logger.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);
+        }
+        return true;
+    };
+    const processOne = async (apiCall)=>{
+        logger.default('processOne', {
+            apiCall
+        });
+        const response = await apiCall;
+        logger.default('processOne response', {
+            response: JSON.stringify(response, null, 2)
+        });
+        return convertDoc(response);
+    };
+    const processArray = async (api)=>{
+        logger.default('processArray', {
+            api
+        });
+        const response = await api;
+        logger.default('processArray response', {
+            response: JSON.stringify(response, null, 2)
+        });
+        if (response && Array.isArray(response)) {
+            return response.map((subjectChat)=>convertDoc(subjectChat));
+        } else {
+            logger.error('Response was not an array', {
+                response
+            });
+            throw new Error('Response was not an array');
+        }
+    };
+    const convertDoc = (doc)=>{
+        logger.default('convertDoc', {
+            doc
+        });
+        // console.log(JSON.stringify(doc, null, 2));
+        if (doc && doc.events) {
+            const events = doc.events;
+            for(const key in events){
+                events[key] = deepmerge(events[key], {
+                    at: events[key].at ? new Date(events[key].at) : null
+                });
+            }
+            return doc;
+        } else {
+            return doc;
+        }
+    };
+    const getPath = (key)=>{
+        const localPathNames = [
+            ...pathNames
+        ];
+        logger.default('getPath', {
+            key,
+            pathNames: localPathNames
+        });
+        // console.log('getPath key: ' + JSON.stringify(key));
+        const keys = generateKeyArray(key);
+        // console.log('getPath keys: ' + JSON.stringify(keys));
+        // console.log('getPath pathNames: ' + JSON.stringify(pathNames));
+        let path = addPath('', keys, localPathNames);
+        // If there is only one collection left in the collections array, this means that
+        // we received LocKeys and we need to add the last collection to the reference
+        if (localPathNames.length === 1) {
+            path = `${path}/${localPathNames[0]}`;
+        }
+        logger.default('getPath created', {
+            key,
+            path
+        });
+        return path;
+    };
+    const addPath = (base, keys, localPathNames)=>{
+        logger.default('addPath', {
+            base,
+            keys,
+            pathNames: localPathNames
+        });
+        if (keys.length < localPathNames.length - 1) {
+            logger.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) {
+            logger.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) {
+            // If you've recursively consumed all of the keys, return the base.
+            logger.default('addPath returning base', {
+                base
+            });
+            return base;
+        } else {
+            // Retrieve the next key and collection, and create the next base
+            let nextBase;
+            const key = keys.pop();
+            const pathName = localPathNames.pop();
+            if (isPriKey(key)) {
+                const PriKey = key;
+                nextBase = `${base}/${pathName}/${PriKey.pk}`;
+                logger.default('Adding Path for PK', {
+                    pathName,
+                    PriKey,
+                    nextBase
+                });
+            } else {
+                const LocKey = key;
+                nextBase = `${base}/${pathName}/${LocKey.lk}`;
+                logger.default('Retrieving Collection for LK', {
+                    pathName,
+                    LocKey
+                });
+            }
+            logger.default('calling addPath recursively', {
+                nextBase,
+                keys,
+                localPathNames
+            });
+            return addPath(nextBase, keys, localPathNames);
+        }
+    };
+    const validatePK$1 = (item)=>{
+        return validatePK(item, pkType);
+    };
+    return {
+        verifyLocations,
+        processOne,
+        convertDoc,
+        processArray,
+        getPath,
+        validatePK: validatePK$1
+    };
+};
+
+export { createUtilities };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVXRpbGl0aWVzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export type { CItemApi } from './CItemAPI';
+export type { PItemApi } from './PItemAPI';
+export type { ClientApi } from './ClientApi';
+export type { ClientApiOptions } from './ClientApiOptions';
+export { createCItemApi } from './CItemAPI';
+export { createPItemApi } from './PItemAPI';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { createCItemApi } from './CItemAPI.js';
+export { createPItemApi } from './PItemAPI.js';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOyJ9

package/dist/logger.d.ts

@@ -0,0 +1,2 @@
+declare const LibLogger: import('@fjell/logging').Logger;
+export default LibLogger;

package/dist/logger.js

@@ -0,0 +1,6 @@
+import Logging from '@fjell/logging';
+
+const LibLogger = Logging.getLogger('@fjellproject/client-api');
+
+export { LibLogger as default };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2VyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7OyJ9

package/dist/{src/ops → ops}/action.d.ts

@@ -1,5 +1,5 @@
-import { ComKey, Item, PriKey } from "@fjell/core";
-import { HttpApi, PostMethodOptions } from "@fjell/http-api";
-import { ClientApiOptions } from "../ClientApiOptions";
-import { Utilities } from "../Utilities";
+import { ComKey, Item, PriKey } from '@fjell/core';
+import { HttpApi, PostMethodOptions } from '@fjell/http-api';
+import { ClientApiOptions } from '../ClientApiOptions';
+import { Utilities } from '../Utilities';
 export declare const getActionOperation: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(api: HttpApi, apiOptions: ClientApiOptions, utilities: Utilities<V, S, L1, L2, L3, L4, L5>) => (ik: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>, action: string, body?: any, options?: Partial<PostMethodOptions>) => Promise<V>;

package/dist/ops/action.js

@@ -0,0 +1,20 @@
+import LibLogger from '../logger.js';
+
+const logger = LibLogger.get('client-api', 'ops', 'action');
+const getActionOperation = (api, apiOptions, utilities)=>{
+    const action = async (ik, action, body = {}, options = {})=>{
+        logger.default('action', {
+            ik,
+            action,
+            body
+        });
+        const requestOptions = Object.assign({}, options, {
+            isAuthenticated: apiOptions.writeAuthenticated
+        });
+        return utilities.validatePK(await utilities.processOne(api.httpPost(`${utilities.getPath(ik)}/${action}`, body, requestOptions)));
+    };
+    return action;
+};
+
+export { getActionOperation };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aW9uLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/{src/ops → ops}/all.d.ts

@@ -1,6 +1,5 @@
-import { Item, ItemQuery, LocKeyArray } from "@fjell/core";
-import { HttpApi } from "@fjell/http-api";
-import { ClientApiOptions } from "../ClientApiOptions";
-import { Utilities } from "../Utilities";
-import { GetMethodOptions } from "@fjell/http-api";
+import { Item, ItemQuery, LocKeyArray } from '@fjell/core';
+import { HttpApi, GetMethodOptions } from '@fjell/http-api';
+import { ClientApiOptions } from '../ClientApiOptions';
+import { Utilities } from '../Utilities';
 export declare const getAllOperation: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(api: HttpApi, apiOptions: ClientApiOptions, utilities: Utilities<V, S, L1, L2, L3, L4, L5>) => (query?: ItemQuery, options?: Partial<GetMethodOptions>, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<V[]>;

package/dist/ops/all.js

@@ -0,0 +1,24 @@
+import { queryToParams } from '@fjell/core';
+import LibLogger from '../logger.js';
+
+const logger = LibLogger.get('client-api', 'ops', 'all');
+const getAllOperation = (api, apiOptions, utilities)=>{
+    const all = async (query = {}, options = {}, locations = [])=>{
+        logger.default('all', {
+            query,
+            locations
+        });
+        utilities.verifyLocations(locations);
+        const loc = locations;
+        const params = queryToParams(query);
+        const requestOptions = Object.assign({}, options, {
+            isAuthenticated: apiOptions.allAuthenticated,
+            params
+        });
+        return utilities.validatePK(await utilities.processArray(api.httpGet(utilities.getPath(loc), requestOptions)));
+    };
+    return all;
+};
+
+export { getAllOperation };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/{src/ops → ops}/allAction.d.ts

@@ -1,5 +1,5 @@
-import { Item, LocKeyArray } from "@fjell/core";
-import { HttpApi, PostMethodOptions } from "@fjell/http-api";
-import { ClientApiOptions } from "../ClientApiOptions";
-import { Utilities } from "../Utilities";
+import { Item, LocKeyArray } from '@fjell/core';
+import { HttpApi, PostMethodOptions } from '@fjell/http-api';
+import { ClientApiOptions } from '../ClientApiOptions';
+import { Utilities } from '../Utilities';
 export declare const getAllActionOperation: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(api: HttpApi, apiOptions: ClientApiOptions, utilities: Utilities<V, S, L1, L2, L3, L4, L5>) => (action: string, body?: any, options?: Partial<PostMethodOptions>, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<V[]>;

package/dist/ops/allAction.js

@@ -0,0 +1,23 @@
+import LibLogger from '../logger.js';
+
+const logger = LibLogger.get('client-api', 'ops', 'allAction');
+const getAllActionOperation = (api, apiOptions, utilities)=>{
+    const allAction = async (action, body = {}, options = {}, locations = [])=>{
+        logger.default('allAction', {
+            action,
+            body,
+            locations
+        });
+        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;
+};
+
+export { getAllActionOperation };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsQWN0aW9uLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/{src/ops → ops}/create.d.ts

@@ -1,5 +1,5 @@
-import { Item, ItemProperties, LocKeyArray } from "@fjell/core";
-import { HttpApi, PostMethodOptions } from "@fjell/http-api";
-import { ClientApiOptions } from "../ClientApiOptions";
-import { Utilities } from "../Utilities";
+import { Item, ItemProperties, LocKeyArray } from '@fjell/core';
+import { HttpApi, PostMethodOptions } from '@fjell/http-api';
+import { ClientApiOptions } from '../ClientApiOptions';
+import { Utilities } from '../Utilities';
 export declare const getCreateOperation: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(api: HttpApi, apiOptions: ClientApiOptions, utilities: Utilities<V, S, L1, L2, L3, L4, L5>) => (item: ItemProperties<S, L1, L2, L3, L4, L5>, options?: Partial<PostMethodOptions>, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<V>;

package/dist/ops/create.js

@@ -0,0 +1,22 @@
+import LibLogger from '../logger.js';
+
+const logger = LibLogger.get('client-api', 'ops', 'create');
+const getCreateOperation = (api, apiOptions, utilities)=>{
+    const create = async (item, options = {}, locations = [])=>{
+        logger.default('create', {
+            item,
+            locations
+        });
+        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;
+};
+
+export { getCreateOperation };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/{src/ops → ops}/find.d.ts

@@ -1,5 +1,5 @@
-import { Item, LocKeyArray } from "@fjell/core";
-import { GetMethodOptions, HttpApi } from "@fjell/http-api";
-import { ClientApiOptions } from "../ClientApiOptions";
-import { Utilities } from "../Utilities";
+import { Item, LocKeyArray } from '@fjell/core';
+import { GetMethodOptions, HttpApi } from '@fjell/http-api';
+import { ClientApiOptions } from '../ClientApiOptions';
+import { Utilities } from '../Utilities';
 export declare const getFindOperation: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(api: HttpApi, apiOptions: ClientApiOptions, utilities: Utilities<V, S, L1, L2, L3, L4, L5>) => (finder: string, finderParams: Record<string, string | number | boolean | Date | Array<string | number | boolean | Date>>, options?: Partial<GetMethodOptions>, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<V[]>;

package/dist/ops/find.js

@@ -0,0 +1,25 @@
+import { finderToParams } from '../AItemAPI.js';
+import LibLogger from '../logger.js';
+
+const logger = LibLogger.get('client-api', 'ops', 'find');
+const getFindOperation = (api, apiOptions, utilities)=>{
+    const find = async (finder, finderParams, options = {}, locations = [])=>{
+        logger.default('find', {
+            finder,
+            finderParams,
+            locations
+        });
+        utilities.verifyLocations(locations);
+        const loc = locations;
+        const params = finderToParams(finder, finderParams);
+        const requestOptions = Object.assign({}, options, {
+            isAuthenticated: apiOptions.allAuthenticated,
+            params
+        });
+        return utilities.validatePK(await utilities.processArray(api.httpGet(utilities.getPath(loc), requestOptions)));
+    };
+    return find;
+};
+
+export { getFindOperation };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmluZC5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/{src/ops → ops}/get.d.ts

@@ -1,5 +1,5 @@
-import { ComKey, Item, PriKey } from "@fjell/core";
-import { GetMethodOptions, HttpApi } from "@fjell/http-api";
-import { ClientApiOptions } from "../ClientApiOptions";
-import { Utilities } from "../Utilities";
+import { ComKey, Item, PriKey } from '@fjell/core';
+import { GetMethodOptions, HttpApi } from '@fjell/http-api';
+import { ClientApiOptions } from '../ClientApiOptions';
+import { Utilities } from '../Utilities';
 export declare const getGetOperation: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(api: HttpApi, apiOptions: ClientApiOptions, utilities: Utilities<V, S, L1, L2, L3, L4, L5>) => (ik: PriKey<S> | ComKey<S, never, never, never, never, never>, options?: Partial<GetMethodOptions>) => Promise<V | null>;

package/dist/ops/get.js

@@ -0,0 +1,18 @@
+import LibLogger from '../logger.js';
+
+const logger = LibLogger.get('client-api', 'ops', 'get');
+const getGetOperation = (api, apiOptions, utilities)=>{
+    const get = async (ik, options = {})=>{
+        logger.default('get', {
+            ik
+        });
+        const requestOptions = Object.assign({}, options, {
+            isAuthenticated: apiOptions.readAuthenticated
+        });
+        return utilities.validatePK(await utilities.processOne(api.httpGet(utilities.getPath(ik), requestOptions)));
+    };
+    return get;
+};
+
+export { getGetOperation };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/{src/ops → ops}/index.d.ts

@@ -1,6 +1,6 @@
-import { Item } from "@fjell/core";
-import { Utilities } from "../Utilities";
-import { HttpApi } from "@fjell/http-api";
-import { ClientApiOptions } from "../ClientApiOptions";
-import { ClientApi } from "../ClientApi";
+import { Item } from '@fjell/core';
+import { Utilities } from '../Utilities';
+import { HttpApi } from '@fjell/http-api';
+import { ClientApiOptions } from '../ClientApiOptions';
+import { ClientApi } from '../ClientApi';
 export declare const getOperations: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(api: HttpApi, apiOptions: ClientApiOptions, utilities: Utilities<V, S, L1, L2, L3, L4, L5>) => ClientApi<V, S, L1, L2, L3, L4, L5>;

package/dist/ops/index.js

@@ -0,0 +1,26 @@
+import { getAllOperation } from './all.js';
+import { getActionOperation } from './action.js';
+import { getAllActionOperation } from './allAction.js';
+import { getOneOperation } from './one.js';
+import { getCreateOperation } from './create.js';
+import { getUpdateOperation } from './update.js';
+import { getGetOperation } from './get.js';
+import { getRemoveOperation } from './remove.js';
+import { getFindOperation } from './find.js';
+
+const getOperations = (api, apiOptions, utilities)=>{
+    return {
+        action: getActionOperation(api, apiOptions, utilities),
+        all: getAllOperation(api, apiOptions, utilities),
+        allAction: getAllActionOperation(api, apiOptions, utilities),
+        create: getCreateOperation(api, apiOptions, utilities),
+        find: getFindOperation(api, apiOptions, utilities),
+        get: getGetOperation(api, apiOptions, utilities),
+        one: getOneOperation(api, apiOptions, utilities),
+        remove: getRemoveOperation(api, apiOptions, utilities),
+        update: getUpdateOperation(api, apiOptions, utilities)
+    };
+};
+
+export { getOperations };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==