@fjell/client-api 4.2.1

package/src/ClientApiOptions.ts

@@ -0,0 +1,17 @@
+import { Item } from "@fjell/core";
+import { ClientApi } from "./ClientApi";
+
+export interface ClientApiOptions {
+  readAuthenticated?: boolean;
+  allAuthenticated?: boolean;
+  writeAuthenticated?: boolean;
+  parentApi?: ClientApi<
+    Item<string, string | never, string | never, string | never, string | never, string | never>,
+    string,
+    string | never,
+    string | never,
+    string | never,
+    string | never,
+    string | never
+  >;
+}

package/src/PItemAPI.ts

@@ -0,0 +1,171 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+ 
+import { ComKey, Item, ItemProperties, ItemQuery, PriKey, TypesProperties } from "@fjell/core";
+import { HttpApi } from "@fjell/http-api";
+import { createAItemAPI, PathNamesArray } from "./AItemAPI";
+import { ClientApi } from "./ClientApi";
+
+import { DeleteMethodOptions, GetMethodOptions, PostMethodOptions, PutMethodOptions } from "@fjell/http-api";
+import { ClientApiOptions } from "./ClientApiOptions";
+import LibLogger from "@/logger";
+const logger = LibLogger.get('PItemAPI');
+
+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[]>;
+
+  allAction: (
+    action: string,
+    body: any,
+    options: Partial<PostMethodOptions>
+  ) => Promise<V[]>;
+
+  one: (
+    query: ItemQuery,
+    options: Partial<GetMethodOptions>
+  ) => Promise<V | null>;
+
+  get: (
+    ik: PriKey<S> | ComKey<S, never, never, never, never, never>,
+    options: Partial<GetMethodOptions>,
+    locations?: []
+  ) => Promise<V | null>;
+
+  create: (
+    item: TypesProperties<V, S>,
+    options: Partial<PostMethodOptions>,
+    locations?: []
+  ) => Promise<V>;
+
+  remove: (
+    ik: PriKey<S> | ComKey<S, never, never, never, never, never>,
+    options: Partial<DeleteMethodOptions>,
+    locations?: []
+  ) => Promise<boolean>;
+
+  update: (
+    ik: PriKey<S> | ComKey<S, never, never, never, never, never>,
+    item: TypesProperties<V, S>,
+    options: Partial<PutMethodOptions>,
+    locations?: []
+  ) => Promise<V>;
+
+  find: (
+    finder: string,
+    finderParams: Record<string, string | number | boolean | Date | Array<string | number | boolean | Date>>,
+    options: Partial<GetMethodOptions>,
+    locations?: []
+  ) => Promise<V[]>;
+}
+
+export const createPItemApi = <
+  V extends Item<S>,
+  S extends string
+>(
+    api: HttpApi,
+    type: S,
+    pathName: string,
+    options: ClientApiOptions
+  ): PItemApi<V, S> => {
+
+  logger.default('createPItemApi', { type, pathName, options });
+
+  const aItemAPI = createAItemAPI<V, S>(api, type, [pathName], options);
+
+  const action =
+    async (
+      ik: PriKey<S> | ComKey<S, never, never, never, never, never>,
+      action: string,
+      body: any = {},
+      options: Partial<PostMethodOptions> = {},
+    ): Promise<V> =>
+        await aItemAPI.action(ik, action, body, options) as V;
+
+  const all =
+    async (
+      query: ItemQuery = {} as ItemQuery,
+      options: Partial<GetMethodOptions> = {},
+    ): Promise<V[]> =>
+        await aItemAPI.all(query, options, []) as V[];
+
+  const allAction =
+    async (
+      action: string,
+      body: any = {},
+      options: Partial<PostMethodOptions> = {},
+    ): Promise<V[]> =>
+        await aItemAPI.allAction(action, body, options, []) as V[];
+  
+  const one =
+    async (
+      query: ItemQuery = {} as ItemQuery,
+      options: Partial<GetMethodOptions> = {},
+    ): Promise<V | null> =>
+        await aItemAPI.one(query, options, []) as V | null;
+  
+  const get =
+    async (
+      ik: PriKey<S> | ComKey<S, never, never, never, never, never>,
+      options: Partial<GetMethodOptions> = {},
+    ): Promise<V | null> =>
+        await aItemAPI.get(ik, options) as V | null;
+  
+  const create =
+    async (
+      item: TypesProperties<V, S>,
+      options: Partial<PostMethodOptions> = {},
+    ): Promise<V> =>
+        await aItemAPI.create(item, options, []) as V;
+  
+  const remove =
+    async (
+      ik: PriKey<S> | ComKey<S, never, never, never, never, never>,
+      options: Partial<DeleteMethodOptions> = {},
+    ): Promise<boolean> =>
+        await aItemAPI.remove(ik, options) as boolean;
+  
+  const update =
+    async (
+      ik: PriKey<S> | ComKey<S, never, never, never, never, never>,
+      item: TypesProperties<V, S>,
+      options: Partial<PutMethodOptions> = {},
+    ): Promise<V> =>
+        await aItemAPI.update(ik, item, options) as V;
+  
+  const find =
+    async (
+      finder: string,
+      finderParams: Record<string, string | number | boolean | Date | Array<string | number | boolean | Date>>,
+      options: Partial<GetMethodOptions> = {},
+    ): Promise<V[]> =>
+        await aItemAPI.find(finder, finderParams, options, []) as V[];
+
+  return {
+    ...aItemAPI,
+    action,
+    all,
+    allAction,
+    one,
+    get,
+    create,
+    remove,
+    update,
+    find,
+  };
+
+};

package/src/Utilities.ts

@@ -0,0 +1,183 @@
+import {
+  ComKey,
+  validatePK as coreValidatePK,
+  generateKeyArray,
+  isPriKey,
+  Item,
+  LocKey,
+  LocKeyArray,
+  PriKey,
+} from "@fjell/core";
+
+import LibLogger from "@/logger";
+import deepmerge from "deepmerge";
+
+const logger = LibLogger.get('client-api', 'Utility');
+
+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>;
+    processArray: (api: Promise<V[]>) => Promise<V[]>;
+    convertDoc: (doc: V) => V;
+    getPath: (key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S> | LocKeyArray<L1, L2, L3, L4, L5> | []) => string;
+    validatePK: (item: Item<S, L1, L2, L3, L4, L5> | Item<S, L1, L2, L3, L4, L5>[]) =>
+      Item<S, L1, L2, L3, L4, L5> | Item<S, L1, L2, L3, L4, L5>[];
+}
+
+export const createUtilities = <
+    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
+>(pkType: S, pathNames: string[]): Utilities<V, S, L1, L2, L3, L4, L5> => {
+
+  logger.default('createUtilities', { pkType, pathNames });
+
+  const verifyLocations = (
+    locations: LocKeyArray<L1, L2, L3, L4, L5> | [] | never,
+  ): boolean => {
+  
+    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: Promise<V>,
+  ): Promise<V> => {
+    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: Promise<V[]>,
+  ): Promise<V[]> => {
+    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: V) =>
+        convertDoc(subjectChat),
+      ) as unknown as V[];
+    } else {
+      logger.error('Response was not an array', { response });
+      throw new Error('Response was not an array');
+    }
+  };
+
+  const convertDoc = (doc: V): V => {
+    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 as unknown as V;
+    } else {
+      return doc;
+    }
+  };
+
+  const getPath =
+  (
+    key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S> | LocKeyArray<L1, L2, L3, L4, L5> | [],
+  ):
+    string => {
+
+    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: string = 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: string,
+    keys: Array<PriKey<S> | LocKey<L1 | L2 | L3 | L4 | L5>>,
+    localPathNames: string[],
+  ): string => {
+    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: string;
+      const key = keys.pop();
+      const pathName = localPathNames.pop();
+      if (isPriKey(key)) {
+        const PriKey = key as PriKey<S>;
+        nextBase = `${base}/${pathName}/${PriKey.pk}`;
+        logger.default('Adding Path for PK', { pathName, PriKey, nextBase });
+      } else {
+        const LocKey = key as LocKey<L1 | L2 | L3 | L4 | L5>;
+        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 = (
+    item: Item<S, L1, L2, L3, L4, L5> | Item<S, L1, L2, L3, L4, L5>[]):
+        Item<S, L1, L2, L3, L4, L5> | Item<S, L1, L2, L3, L4, L5>[] => {
+    return coreValidatePK<S, L1, L2, L3, L4, L5>(item, pkType);
+  }
+
+  return {
+    verifyLocations,
+    processOne,
+    convertDoc,
+    processArray,
+    getPath,
+    validatePK,
+  }
+}

package/src/index.ts

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

package/src/logger.ts

@@ -0,0 +1,5 @@
+import Logging from '@fjell/logging';
+
+const LibLogger = Logging.getLogger('@fjellproject/client-api');
+
+export default LibLogger;

package/src/ops/action.ts

@@ -0,0 +1,52 @@
+import {
+  ComKey,
+  Item,
+  PriKey,
+} from "@fjell/core";
+import { HttpApi, PostMethodOptions } from "@fjell/http-api";
+    
+import { ClientApiOptions } from "@/ClientApiOptions";
+import LibLogger from "@/logger";
+import { Utilities } from "@/Utilities";
+    
+const logger = LibLogger.get('client-api', 'ops', 'action');
+  
+export 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>
+     
+  ) => {
+    
+  const action = async (
+    ik: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>,
+    action: string,
+    body: any = {},
+    options: Partial<PostMethodOptions> = {}
+  ):
+        Promise<V> => {
+    logger.default('action', { ik, action, body });
+    
+    const requestOptions = Object.assign({}, options, { isAuthenticated: apiOptions.writeAuthenticated });
+    
+    return utilities.validatePK(
+      await utilities.processOne(
+        api.httpPost<V>(
+          `${utilities.getPath(ik)}/${action}`,
+          body,
+          requestOptions,
+        )
+      )) as V;
+    
+  };
+  
+  return action;
+}
+  

package/src/ops/all.ts

@@ -0,0 +1,52 @@
+import {
+  Item,
+  ItemQuery,
+  LocKeyArray,
+  queryToParams,
+} from "@fjell/core";
+import { HttpApi, QueryParams } from "@fjell/http-api";
+  
+import { ClientApiOptions } from "@/ClientApiOptions";
+import LibLogger from "@/logger";
+import { Utilities } from "@/Utilities";
+import { GetMethodOptions } from "@fjell/http-api";
+  
+const logger = LibLogger.get('client-api', 'ops', 'all');
+
+export 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>
+   
+  ) => {
+  
+  const all = async (
+    query: ItemQuery = {} as ItemQuery,
+    options: Partial<GetMethodOptions> = {},
+    locations: LocKeyArray<L1, L2, L3, L4, L5> | [] = []
+  ): Promise<V[]> => {
+    logger.default('all', { query, locations });
+    utilities.verifyLocations(locations);
+    const loc: LocKeyArray<L1, L2, L3, L4, L5> | [] = locations;
+  
+    const params: QueryParams = queryToParams(query);
+  
+    const requestOptions = Object.assign({}, options, { isAuthenticated: apiOptions.allAuthenticated, params });
+  
+    return utilities.validatePK(await utilities.processArray(
+      api.httpGet<V[]>(
+        utilities.getPath(loc),
+        requestOptions,
+      ))) as V[];
+  }
+
+  return all;
+}
+  

package/src/ops/allAction.ts

@@ -0,0 +1,53 @@
+import {
+  Item,
+  LocKeyArray
+} from "@fjell/core";
+import { HttpApi, PostMethodOptions } from "@fjell/http-api";
+    
+import { ClientApiOptions } from "@/ClientApiOptions";
+import LibLogger from "@/logger";
+import { Utilities } from "@/Utilities";
+    
+const logger = LibLogger.get('client-api', 'ops', 'allAction');
+  
+export 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>
+     
+  ) => {
+    
+  const allAction = async (
+    action: string,
+    body: any = {},
+    options: Partial<PostMethodOptions> = {},
+    locations: LocKeyArray<L1, L2, L3, L4, L5> | [] = []
+  ): Promise<V[]> => {
+    logger.default('allAction', { action, body, locations });
+    utilities.verifyLocations(locations);
+  
+    const loc: LocKeyArray<L1, L2, L3, L4, L5> | [] = 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<V[]>(
+          utilities.getPath(loc),
+          body,
+          requestOptions,
+        )
+      )) as V[];
+  };
+  
+  return allAction;
+}
+    

package/src/ops/create.ts

@@ -0,0 +1,50 @@
+import {
+  Item,
+  ItemProperties,
+  LocKeyArray
+} from "@fjell/core";
+import { HttpApi, PostMethodOptions } from "@fjell/http-api";
+  
+import { ClientApiOptions } from "@/ClientApiOptions";
+import LibLogger from "@/logger";
+import { Utilities } from "@/Utilities";
+  
+const logger = LibLogger.get('client-api', 'ops', 'create');
+
+export 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>
+   
+  ) => {
+  
+  const create = async (
+    item: ItemProperties<S, L1, L2, L3, L4, L5>,
+    options: Partial<PostMethodOptions> = {},
+    locations: LocKeyArray<L1, L2, L3, L4, L5> | [] = []
+  ): Promise<V> => {
+    logger.default('create', { item, locations });
+    utilities.verifyLocations(locations);
+  
+    const loc: LocKeyArray<L1, L2, L3, L4, L5> | [] = locations;
+    const requestOptions = Object.assign({}, options, { isAuthenticated: apiOptions.writeAuthenticated });
+  
+    const created: V =
+        utilities.validatePK(await utilities.processOne(api.httpPost<V>(
+          utilities.getPath(loc),
+          item,
+          requestOptions,
+        ))) as V;
+    return created;
+  };
+
+  return create;
+}
+  

package/src/ops/find.ts

@@ -0,0 +1,52 @@
+import {
+  Item,
+  LocKeyArray,
+  QueryParams
+} from "@fjell/core";
+import { GetMethodOptions, HttpApi } from "@fjell/http-api";
+    
+import { finderToParams } from "@/AItemAPI";
+import { ClientApiOptions } from "@/ClientApiOptions";
+import LibLogger from "@/logger";
+import { Utilities } from "@/Utilities";
+    
+const logger = LibLogger.get('client-api', 'ops', 'find');
+  
+export 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>
+     
+  ) => {
+    
+  const find = async (
+    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[]> => {
+    logger.default('find', { finder, finderParams, locations });
+    utilities.verifyLocations(locations);
+    const loc: LocKeyArray<L1, L2, L3, L4, L5> | [] = locations;
+  
+    const params: QueryParams = finderToParams(finder, finderParams);
+  
+    const requestOptions = Object.assign({}, options, { isAuthenticated: apiOptions.allAuthenticated, params });
+  
+    return utilities.validatePK(await utilities.processArray(
+      api.httpGet<V[]>(
+        utilities.getPath(loc),
+        requestOptions,
+      ))) as V[];
+  }
+    
+  return find;
+}
+    

package/src/ops/get.ts

@@ -0,0 +1,45 @@
+import {
+  ComKey,
+  Item,
+  PriKey,
+} from "@fjell/core";
+import { GetMethodOptions, HttpApi } from "@fjell/http-api";
+    
+import { ClientApiOptions } from "@/ClientApiOptions";
+import LibLogger from "@/logger";
+import { Utilities } from "@/Utilities";
+    
+const logger = LibLogger.get('client-api', 'ops', 'get');
+  
+export 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>
+     
+  ) => {
+    
+  const get = async (
+    ik: PriKey<S> | ComKey<S, never, never, never, never, never>,
+    options: Partial<GetMethodOptions> = {},
+  ): Promise<V | null> => {
+    logger.default('get', { ik });
+  
+    const requestOptions = Object.assign({}, options, { isAuthenticated: apiOptions.readAuthenticated });
+  
+    return utilities.validatePK(await utilities.processOne(
+      api.httpGet<V>(
+        utilities.getPath(ik),
+        requestOptions,
+      ))) as V;
+  }
+  
+  return get;
+}
+