@fjell/client-api 4.4.13 → 4.4.14

package/dist/index.cjs

@@ -1,586 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const core = require('@fjell/core');
-const Logging = require('@fjell/logging');
-const deepmerge = require('deepmerge');
-const registry = require('@fjell/registry');
-
-const LibLogger = Logging.getLogger('@fjell/client-api');
-
-const logger$i = LibLogger.get('client-api', 'ops', 'all');
-const getAllOperation = (api, apiOptions, utilities)=>{
-    const all = async (query = {}, locations = [])=>{
-        utilities.verifyLocations(locations);
-        const loc = locations;
-        const params = core.queryToParams(query);
-        const requestOptions = Object.assign({}, apiOptions.getOptions, {
-            isAuthenticated: apiOptions.allAuthenticated,
-            params
-        });
-        logger$i.default('all', {
-            query,
-            locations,
-            requestOptions
-        });
-        return utilities.validatePK(await utilities.processArray(api.httpGet(utilities.getPath(loc), requestOptions)));
-    };
-    return all;
-};
-
-const logger$h = LibLogger.get('client-api', 'ops', 'action');
-const getActionOperation = (api, apiOptions, utilities)=>{
-    const action = async (ik, action, body = {})=>{
-        const requestOptions = Object.assign({}, apiOptions.postOptions, {
-            isAuthenticated: apiOptions.writeAuthenticated
-        });
-        logger$h.default('action', {
-            ik,
-            action,
-            body,
-            requestOptions
-        });
-        return utilities.validatePK(await utilities.processOne(api.httpPost(`${utilities.getPath(ik)}/${action}`, body, requestOptions)));
-    };
-    return action;
-};
-
-const logger$g = LibLogger.get('client-api', 'ops', 'allAction');
-const getAllActionOperation = (api, apiOptions, utilities)=>{
-    const allAction = async (action, body = {}, locations = [])=>{
-        const requestOptions = Object.assign({}, apiOptions.postOptions, {
-            isAuthenticated: apiOptions.writeAuthenticated
-        });
-        logger$g.default('allAction', {
-            action,
-            body,
-            locations,
-            requestOptions
-        });
-        utilities.verifyLocations(locations);
-        const loc = locations;
-        // 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$f = LibLogger.get('client-api', 'ops', 'one');
-const getOneOperation = (api, apiOptions, utilities)=>{
-    const one = async (query = {}, locations = [])=>{
-        utilities.verifyLocations(locations);
-        const loc = locations;
-        const params = core.queryToParams(query);
-        const requestOptions = Object.assign({}, apiOptions.getOptions, {
-            isAuthenticated: apiOptions.readAuthenticated,
-            params
-        });
-        logger$f.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) {
-            item = items[0];
-        }
-        return item;
-    };
-    return one;
-};
-
-const logger$e = LibLogger.get('client-api', 'ops', 'create');
-const getCreateOperation = (api, apiOptions, utilities)=>{
-    const create = async (item, locations = [])=>{
-        const requestOptions = Object.assign({}, apiOptions.postOptions, {
-            isAuthenticated: apiOptions.writeAuthenticated
-        });
-        logger$e.default('create', {
-            item,
-            locations,
-            requestOptions
-        });
-        utilities.verifyLocations(locations);
-        const loc = locations;
-        const created = utilities.validatePK(await utilities.processOne(api.httpPost(utilities.getPath(loc), item, requestOptions)));
-        return created;
-    };
-    return create;
-};
-
-const logger$d = LibLogger.get('client-api', 'ops', 'update');
-const getUpdateOperation = (api, apiOptions, utilities)=>{
-    const update = async (ik, item)=>{
-        const requestOptions = Object.assign({}, apiOptions.putOptions, {
-            isAuthenticated: apiOptions.writeAuthenticated
-        });
-        logger$d.default('update', {
-            ik,
-            item,
-            requestOptions
-        });
-        return utilities.validatePK(await utilities.processOne(api.httpPut(utilities.getPath(ik), item, requestOptions)));
-    };
-    return update;
-};
-
-const logger$c = LibLogger.get('client-api', 'ops', 'get');
-const getGetOperation = (api, apiOptions, utilities)=>{
-    const get = async (ik)=>{
-        const requestOptions = Object.assign({}, apiOptions.getOptions, {
-            isAuthenticated: apiOptions.readAuthenticated
-        });
-        logger$c.default('get', {
-            ik,
-            requestOptions
-        });
-        return utilities.validatePK(await utilities.processOne(api.httpGet(utilities.getPath(ik), requestOptions)));
-    };
-    return get;
-};
-
-const logger$b = LibLogger.get('client-api', 'ops', 'remove');
-const getRemoveOperation = (api, apiOptions, utilities)=>{
-    const remove = async (ik)=>{
-        const requestOptions = Object.assign({}, apiOptions.deleteOptions, {
-            isAuthenticated: apiOptions.writeAuthenticated
-        });
-        logger$b.default('remove', {
-            ik,
-            requestOptions
-        });
-        return api.httpDelete(utilities.getPath(ik), requestOptions);
-    };
-    return remove;
-};
-
-const logger$a = LibLogger.get('client-api', 'ops', 'find');
-const 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
-        });
-        logger$a.default('find', {
-            finder,
-            finderParams,
-            locations,
-            requestOptions
-        });
-        return utilities.validatePK(await utilities.processArray(api.httpGet(utilities.getPath(loc), requestOptions)));
-    };
-    return find;
-};
-
-const logger$9 = LibLogger.get('client-api', 'ops', 'find');
-const getFindOneOperation = (api, apiOptions, utilities)=>{
-    const findOne = async (finder, finderParams = {}, locations = [])=>{
-        utilities.verifyLocations(locations);
-        const loc = locations;
-        const params = finderToParams(finder, finderParams);
-        params.one = true;
-        const requestOptions = Object.assign({}, apiOptions.getOptions, {
-            isAuthenticated: apiOptions.allAuthenticated,
-            params
-        });
-        logger$9.default('findOne', {
-            finder,
-            finderParams,
-            locations,
-            requestOptions
-        });
-        return utilities.validatePK(await utilities.processArray(api.httpGet(utilities.getPath(loc), requestOptions)))[0];
-    };
-    return findOne;
-};
-
-const logger$8 = LibLogger.get('client-api', 'ops', 'facet');
-const getFacetOperation = (api, apiOptions, utilities)=>{
-    /**
-   * Executes a facet operation on an item.
-   *
-   * A facet is a piece of information that is related to an item - it represents
-   * a specific aspect or characteristic of the item. Unlike actions which may
-   * return items or perform operations, facets are informational queries that
-   * return data about a particular facet of an item.
-   *
-   * @param ik - The item key (composite or primary key) identifying the item
-   * @param facet - The name of the facet to query
-   * @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, params = {})=>{
-        const requestOptions = Object.assign({}, apiOptions.getOptions, {
-            isAuthenticated: apiOptions.writeAuthenticated,
-            params
-        });
-        logger$8.default('facet', {
-            ik,
-            facet,
-            requestOptions
-        });
-        return api.httpGet(`${utilities.getPath(ik)}/${facet}`, requestOptions);
-    };
-    return facet;
-};
-
-const logger$7 = 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$7.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),
-        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)
-    };
-};
-
-const logger$6 = LibLogger.get('client-api', 'Utility');
-const createUtilities = (pkType, pathNames)=>{
-    logger$6.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$6.default('processOne', {
-            apiCall
-        });
-        const response = await apiCall;
-        logger$6.default('processOne response', {
-            response: JSON.stringify(response, null, 2)
-        });
-        return convertDoc(response);
-    };
-    const processArray = async (api)=>{
-        logger$6.default('processArray', {
-            api
-        });
-        const response = await api;
-        logger$6.default('processArray response', {
-            response: JSON.stringify(response, null, 2)
-        });
-        if (response && Array.isArray(response)) {
-            return response.map((subjectChat)=>convertDoc(subjectChat));
-        } else {
-            logger$6.error('Response was not an array', {
-                response
-            });
-            throw new Error('Response was not an array');
-        }
-    };
-    const convertDoc = (doc)=>{
-        logger$6.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$6.default('getPath', {
-            key,
-            pathNames: localPathNames
-        });
-        // console.log('getPath key: ' + JSON.stringify(key));
-        const keys = core.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$6.default('getPath created', {
-            key,
-            path
-        });
-        return path;
-    };
-    const addPath = (base, keys, localPathNames)=>{
-        logger$6.default('addPath', {
-            base,
-            keys,
-            pathNames: localPathNames
-        });
-        if (keys.length < localPathNames.length - 1) {
-            logger$6.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$6.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$6.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 (core.isPriKey(key)) {
-                const PriKey = key;
-                nextBase = `${base}/${pathName}/${PriKey.pk}`;
-                logger$6.default('Adding Path for PK', {
-                    pathName,
-                    PriKey,
-                    nextBase
-                });
-            } else {
-                const LocKey = key;
-                nextBase = `${base}/${pathName}/${LocKey.lk}`;
-                logger$6.default('Retrieving Collection for LK', {
-                    pathName,
-                    LocKey
-                });
-            }
-            logger$6.default('calling addPath recursively', {
-                nextBase,
-                keys,
-                localPathNames
-            });
-            return addPath(nextBase, keys, localPathNames);
-        }
-    };
-    const validatePK = (item)=>{
-        return core.validatePK(item, pkType);
-    };
-    return {
-        verifyLocations,
-        processOne,
-        convertDoc,
-        processArray,
-        getPath,
-        validatePK
-    };
-};
-
-const logger$5 = LibLogger.get('AItemAPI');
-const finderToParams = (finder, finderParams)=>{
-    return {
-        finder,
-        finderParams: JSON.stringify(finderParams)
-    };
-};
-const createAItemAPI = (api, pkType, pathNames, options)=>{
-    logger$5.default('createAItemAPI', {
-        pkType,
-        pathNames,
-        options
-    });
-    let mergedOptions;
-    const defaultOptions = {
-        readAuthenticated: true,
-        allAuthenticated: true,
-        writeAuthenticated: true,
-        getOptions: {},
-        postOptions: {},
-        putOptions: {},
-        deleteOptions: {}
-    };
-    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,
-        allFacet: operations.allFacet,
-        create: operations.create,
-        facet: operations.facet,
-        find: operations.find,
-        findOne: operations.findOne,
-        get: operations.get,
-        one: operations.one,
-        remove: operations.remove,
-        update: operations.update
-    };
-};
-
-const logger$4 = LibLogger.get('CItemAPI');
-const createCItemApi = (api, type, pathNames, options)=>{
-    logger$4.default('createCItemApi', {
-        api,
-        type,
-        pathNames,
-        options
-    });
-    const aItemAPI = createAItemAPI(api, type, pathNames, options);
-    return {
-        action: aItemAPI.action,
-        all: aItemAPI.all,
-        allAction: aItemAPI.allAction,
-        allFacet: aItemAPI.allFacet,
-        one: aItemAPI.one,
-        get: aItemAPI.get,
-        create: aItemAPI.create,
-        remove: aItemAPI.remove,
-        update: aItemAPI.update,
-        facet: aItemAPI.facet,
-        find: aItemAPI.find,
-        findOne: aItemAPI.findOne
-    };
-};
-
-const logger$3 = LibLogger.get('PItemAPI');
-const createPItemApi = (api, type, pathName, options)=>{
-    logger$3.default('createPItemApi', {
-        type,
-        pathName,
-        options
-    });
-    const aItemAPI = createAItemAPI(api, type, [
-        pathName
-    ], 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,
-        remove,
-        update,
-        facet,
-        find,
-        findOne
-    };
-};
-
-const logger$2 = LibLogger.get("Instance");
-const createInstance = (registry$1, coordinate, clientApi)=>{
-    logger$2.debug("createInstance", {
-        coordinate,
-        clientApi,
-        registry: registry$1
-    });
-    const baseInstance = registry.createInstance(registry$1, coordinate);
-    return {
-        ...baseInstance,
-        clientApi
-    };
-};
-
-const logger$1 = LibLogger.get("InstanceFactory");
-/**
- * Factory function for creating client-api instances
- */ const createInstanceFactory = (clientApi)=>{
-    return (coordinate, context)=>{
-        logger$1.debug("Creating client-api instance", {
-            coordinate,
-            registry: context.registry,
-            clientApi
-        });
-        return createInstance(context.registry, coordinate, clientApi);
-    };
-};
-
-const logger = LibLogger.get("Registry");
-/**
- * Factory function for creating client-api registries
- */ const createRegistryFactory = ()=>{
-    return (type, registryHub)=>{
-        if (type !== 'client-api') {
-            throw new Error(`Client API registry factory can only create 'client-api' type registries, got: ${type}`);
-        }
-        logger.debug("Creating client-api registry", {
-            type,
-            registryHub
-        });
-        const baseRegistry = registry.createRegistry(type, registryHub);
-        // Cast to Registry for type safety
-        return baseRegistry;
-    };
-};
-/**
- * Creates a new client-api registry instance
- */ const createRegistry = (registryHub)=>{
-    const baseRegistry = registry.createRegistry('client-api', registryHub);
-    return {
-        ...baseRegistry
-    };
-};
-
-exports.createCItemApi = createCItemApi;
-exports.createInstance = createInstance;
-exports.createInstanceFactory = createInstanceFactory;
-exports.createPItemApi = createPItemApi;
-exports.createRegistry = createRegistry;
-exports.createRegistryFactory = createRegistryFactory;
-//# sourceMappingURL=index.cjs.map