@memori.ai/memori-api-client 0.1.0

package/src/engine/people.ts

@@ -0,0 +1,82 @@
+import { ResponseSpec, Person } from '../types';
+import { apiFetcher } from '../apiFetcher';
+
+/******************
+ *                *
+ *     People     *
+ *                *
+ ******************/
+
+export default (apiUrl: string) => ({
+  /**
+   * Lists all Person objects.
+   * @param {string} sessionId The session ID
+   */
+  getPeople: async (sessionId: string) =>
+    apiFetcher(`/People/${sessionId}`, {
+      method: 'GET',
+      apiUrl,
+    }) as Promise<
+      ResponseSpec & {
+        people: Person[];
+      }
+    >,
+
+  /**
+   * Gets the details of a Person object.
+   * @param {string} sessionId The session ID
+   * @param {string} personId The Person object ID
+   */
+  getPerson: async (sessionId: string, personId: string) =>
+    apiFetcher(`/Person/${sessionId}/${personId}`, {
+      method: 'GET',
+      apiUrl,
+    }) as Promise<
+      ResponseSpec & {
+        person: Person;
+      }
+    >,
+
+  /**
+   * Updates an existing Person object.
+   * @param {string} sessionId The session ID
+   * @param {Person} person The Person object
+   */
+  patchPerson: async (sessionId: string, person: Person) =>
+    apiFetcher(`/Person/${sessionId}/${person.personID!}`, {
+      method: 'PATCH',
+      body: person,
+      apiUrl,
+    }) as Promise<
+      ResponseSpec & {
+        person: Person;
+      }
+    >,
+
+  /**
+   * Removes an existing Person object.
+   * @param {string} sessionId The session ID
+   * @param {string} personId The Person object ID
+   */
+  deletePerson: async (sessionId: string, personId: string) =>
+    apiFetcher(`/Person/${sessionId}/${personId}`, {
+      method: 'DELETE',
+      apiUrl,
+    }) as Promise<ResponseSpec>,
+
+  /**
+   * Adds a new Person object.
+   * @param {string} sessionId - The session ID
+   * @param {Person} person - The Person object
+   */
+  postPerson: async (sessionId: string, person: Person) =>
+    apiFetcher(`/Person/${sessionId}`, {
+      method: 'POST',
+      body: person,
+      apiUrl,
+    }) as Promise<
+      ResponseSpec & {
+        person: Person;
+      }
+    >,
+});

package/src/engine/promptedQuestions.ts

@@ -0,0 +1,63 @@
+import { ResponseSpec } from '../types';
+import { apiFetcher } from '../apiFetcher';
+
+/*****************************
+ *                           *
+ *     PromptedQuestions     *
+ *                           *
+ *****************************/
+
+export default (apiUrl: string) => ({
+  /**
+   * Lists all Prompted Question objects.
+   * @param {string} sessionId The session ID
+   */
+  getPromptedQuestions: async (sessionId: string) =>
+    apiFetcher(`/PromptedQuestions/${sessionId}`, {
+      method: 'GET',
+      apiUrl,
+    }) as Promise<ResponseSpec>,
+
+  /**
+   * Gets the details of a Prompted Question object.
+   * @param {string} sessionId The session ID
+   * @param {string} promptId The Prompted Question object ID
+   */
+  getPromptedQuestion: async (sessionId: string, promptId: string) =>
+    apiFetcher(`/PromptedQuestion/${sessionId}/${promptId}`, {
+      method: 'GET',
+      apiUrl,
+    }) as Promise<ResponseSpec>,
+
+  /**
+   * Updates an existing Prompted Question object.
+   * @param {string} sessionId The session ID
+   * @param {string} promptId The Prompted Question object ID
+   */
+  patchPromptedQuestion: async (sessionId: string, promptId: string) =>
+    apiFetcher(`/PromptedQuestion/${sessionId}/${promptId}`, {
+      method: 'GET',
+      apiUrl,
+    }) as Promise<ResponseSpec>,
+
+  /**
+   * Removes an existing Prompted Question object.
+   * @param {string} sessionId The session ID
+   * @param {string} promptId The Prompted Question object ID
+   */
+  deletePromptedQuestion: async (sessionId: string, promptId: string) =>
+    apiFetcher(`/PromptedQuestion/${sessionId}/${promptId}`, {
+      method: 'GET',
+      apiUrl,
+    }) as Promise<ResponseSpec>,
+
+  /**
+   * Adds a new Prompted Question object.
+   * @param {string} sessionId The session ID
+   */
+  postPromptedQuestion: async (sessionId: string) =>
+    apiFetcher(`/PromptedQuestion/${sessionId}`, {
+      method: 'GET',
+      apiUrl,
+    }) as Promise<ResponseSpec>,
+});

package/src/engine/search.ts

@@ -0,0 +1,49 @@
+import { ResponseSpec, SearchQuery, SearchMatches } from '../types';
+import { apiFetcher } from '../apiFetcher';
+
+/******************
+ *                *
+ *     Search     *
+ *                *
+ ******************/
+
+export default (apiUrl: string) => ({
+  /**
+   * Searches for matching Memory objects using the same algorithm employed in the Text Entered event of the R1 state of the Dialog State Machine.
+   * @param {string} sessionId The session ID
+   * @param {SearchQuery} query Search query params
+   */
+  searchMemory: async (sessionId: string, query?: SearchQuery) =>
+    apiFetcher(`/Search/${sessionId}`, {
+      method: 'POST',
+      body: query,
+      apiUrl,
+    }) as Promise<
+      ResponseSpec & {
+        matches: SearchMatches[];
+      }
+    >,
+
+  /**
+   * Picks up to 5 random Memory objects using the same algorithm employed in the
+   * Timeout event of the R1 state of the Dialog State Machine.
+   * @param {string} sessionId The session ID
+   */
+  postRandom: async (sessionId: string) =>
+    apiFetcher(`/Random/${sessionId}`, {
+      method: 'POST',
+      apiUrl,
+    }) as Promise<ResponseSpec>,
+
+  /**
+   * Picks up to 20 Memory Hint objects, obtained by searching for Story objects with a date or place set,
+   * and clustering dates and places within an uncertainty of at least 1 year or at least 100 km.
+   * Each Memory Hint may either suggest a date or a place, but not both.
+   * @param {string} sessionId The session ID
+   */
+  postHints: async (sessionId: string) =>
+    apiFetcher(`/Hints/${sessionId}`, {
+      method: 'GET',
+      apiUrl,
+    }) as Promise<ResponseSpec>,
+});

package/src/engine/session.ts

@@ -0,0 +1,49 @@
+import { ResponseSpec, OpenSession, DialogState } from '../types';
+import { apiFetcher } from '../apiFetcher';
+
+/*******************
+ *                 *
+ *     Session     *
+ *                 *
+ *******************/
+
+export default (apiUrl: string) => ({
+  /**
+   * Initializes a new Dialog State Machine session for an existing Memori.
+   */
+  initSession: async (params: OpenSession) =>
+    apiFetcher(`/Session`, {
+      method: 'POST',
+      body: params,
+      apiUrl,
+    }) as Promise<
+      ResponseSpec & {
+        sessionID: string;
+        currentState: DialogState;
+      }
+    >,
+
+  /**
+   * Returns the current state of a session's Dialog State Machine.
+   * @param {string} sessionId The session ID
+   */
+  getSession: async (sessionId: string) =>
+    apiFetcher(`/Session/${sessionId}`, {
+      method: 'GET',
+      apiUrl,
+    }) as Promise<
+      ResponseSpec & {
+        currentState: DialogState;
+      }
+    >,
+
+  /**
+   * Closes the session and disposes of its Dialog State Machine.
+   * @param {string} sessionId The session ID
+   */
+  deleteSession: async (sessionId: string) =>
+    apiFetcher(`/Session/${sessionId}`, {
+      method: 'DELETE',
+      apiUrl,
+    }) as Promise<ResponseSpec>,
+});

package/src/engine/stats.ts

@@ -0,0 +1,44 @@
+import { ResponseSpec, Stats, EventLog } from '../types';
+import { apiFetcher } from '../apiFetcher';
+
+/*****************
+ *               *
+ *     Stats     *
+ *               *
+ *****************/
+
+export default (apiUrl: string) => ({
+  /**
+   * Computes usage statistics for the Memori of the current session.
+   * @param {string} sessionId The session ID
+   */
+  getStatistics: async (sessionId: string) =>
+    apiFetcher(`/Statistics/${sessionId}`, {
+      method: 'GET',
+      apiUrl,
+    }) as Promise<
+      ResponseSpec & {
+        statistics: Stats;
+      }
+    >,
+
+  /**
+   * Get the Event Log objects for the Memori of the current session in a specific date interval
+   * @param {string} sessionId The session ID
+   * @param {string} strDateFrom The optional begin of the date interval, in UTC time, in the format yyyyMMddHHmmssfff
+   * @param {string} strDateTo The optional end of the date interval, in UTC time, in the format yyyyMMddHHmmssfff
+   */
+  getEventLogs: async (
+    sessionId: string,
+    strDateFrom: string,
+    strDateTo: string
+  ) =>
+    apiFetcher(`/EventLogs/${sessionId}/${strDateFrom}/${strDateTo}`, {
+      method: 'GET',
+      apiUrl,
+    }) as Promise<
+      ResponseSpec & {
+        eventLogs: EventLog[];
+      }
+    >,
+});

package/src/engine/unansweredQuestions.ts

@@ -0,0 +1,38 @@
+import { ResponseSpec, UnansweredQuestion } from '../types';
+import { apiFetcher } from '../apiFetcher';
+
+/*******************************
+ *                             *
+ *     UnansweredQuestions     *
+ *                             *
+ *******************************/
+
+export default (apiUrl: string) => ({
+  /**
+   * Lists all Unanswered Question objects.
+   * @param {string} sessionId The session ID
+   */
+  getUnansweredQuestions: async (sessionId: string) =>
+    apiFetcher(`/UnansweredQuestions/${sessionId}`, {
+      method: 'GET',
+      apiUrl,
+    }) as Promise<
+      ResponseSpec & {
+        unansweredQuestions: UnansweredQuestion[];
+      }
+    >,
+
+  /**
+   * Removes an existing Unanswered Question object.
+   * @param {string} sessionId The session ID
+   * @param {string} unansweredQuestionId The Unanswered Question object ID
+   */
+  deleteUnansweredQuestion: async (
+    sessionId: string,
+    unansweredQuestionId: string
+  ) =>
+    apiFetcher(`/UnansweredQuestion/${sessionId}/${unansweredQuestionId}`, {
+      method: 'DELETE',
+      apiUrl,
+    }) as Promise<ResponseSpec>,
+});

package/src/engine/webhooks.ts

@@ -0,0 +1,32 @@
+import { ResponseSpec } from '../types';
+import { apiFetcher } from '../apiFetcher';
+
+/********************
+ *                  *
+ *     WebHooks     *
+ *                  *
+ ********************/
+
+export default (apiUrl: string) => ({
+  /**
+   * Returns test slot values. Currently available test slots are:<ul><li><code>number</code>: integer numbers between 1 and 10</li><li><code>letter</code>: uppercase letters between A and Z</li><li><code>greek_letter</code>: capitalized Greek letters between Alpha and Omega</li></ul>
+   */
+  postTestSlot: async () =>
+    apiFetcher(`/TestSlot`, {
+      method: 'GET',
+      apiUrl,
+    }) as Promise<ResponseSpec>,
+
+  /**
+      * Returns test intent results. Currently available test intents are:<ul><li><code>ECHO</code>: emits the intent utterance as-is.</li><li><code>COMBINE_LETTER_AND_NUMBER</code>: requires a letter slot and a number slot,
+   emits the content of the two slots in justaxposition, e.g. "A10".</li><li><code>DATE_RANGE</code>: requires a date slot, emits the date range indicated
+   by the date slot in the format "yyyy/MM/dd - yyyy/MM/dd".</li><li><code>AUTOINCREMENT</code>: returns a progressive number that increments by 1
+   each time the intent is called.</li><li><code>FIBONACCI</code>: returns the next element of the Fibonacci series, using
+   context variables to store the series progression.</li></ul>
+      */
+  postTestIntent: async () =>
+    apiFetcher(`/TestIntent`, {
+      method: 'GET',
+      apiUrl,
+    }) as Promise<ResponseSpec>,
+});

package/src/engine.ts

@@ -0,0 +1,51 @@
+import correlationPairs from './engine/correlationPairs';
+import dialog from './engine/dialog';
+import importExport from './engine/importExport';
+import intents from './engine/intents';
+import localizationKeys from './engine/localizationKeys';
+import media from './engine/media';
+import memori from './engine/memori';
+import memories from './engine/memories';
+import nlp from './engine/nlp';
+import people from './engine/people';
+import promptedQuestions from './engine/promptedQuestions';
+import search from './engine/search';
+import session from './engine/session';
+import stats from './engine/stats';
+import unansweredQuestions from './engine/unansweredQuestions';
+import webhooks from './engine/webhooks';
+
+export default (apiUrl: string) => ({
+  correlationPairs: correlationPairs(apiUrl),
+  ...correlationPairs(apiUrl),
+  dialog: dialog(apiUrl),
+  ...dialog(apiUrl),
+  importExport: importExport(apiUrl),
+  ...importExport(apiUrl),
+  intents: intents(apiUrl),
+  ...intents(apiUrl),
+  localizationKeys: localizationKeys(apiUrl),
+  ...localizationKeys(apiUrl),
+  media: media(apiUrl),
+  ...media(apiUrl),
+  memori: memori(apiUrl),
+  ...memori(apiUrl),
+  memories: memories(apiUrl),
+  ...memories(apiUrl),
+  nlp: nlp(apiUrl),
+  ...nlp(apiUrl),
+  people: people(apiUrl),
+  ...people(apiUrl),
+  promptedQuestions: promptedQuestions(apiUrl),
+  ...promptedQuestions(apiUrl),
+  search: search(apiUrl),
+  ...search(apiUrl),
+  session: session(apiUrl),
+  ...session(apiUrl),
+  stats: stats(apiUrl),
+  ...stats(apiUrl),
+  unansweredQuestions: unansweredQuestions(apiUrl),
+  ...unansweredQuestions(apiUrl),
+  webhooks: webhooks(apiUrl),
+  ...webhooks(apiUrl),
+});

package/src/helpers/asset.ts

@@ -0,0 +1,52 @@
+export interface ResourceURLParams {
+  type?: 'avatar' | 'cover' | 'default';
+  resourceURI?: string;
+  sessionID?: string;
+  baseURL?: string;
+}
+
+export default (apiUrl: string) => ({
+  /**
+   * getResourceUrl
+   * @description Returns the correct URL of a resource from the DB.
+   * @param {obj} params
+   * @param {string=} params.type - wheather is the avatar or the cover
+   * @param {string=} params.resourceURI - the resource URI
+   * @param {string=} params.sessionID - the session ID, required for memory media attachments
+   * @param {string=} params.baseURL - the base URL for default static assets (defaults to https://app.twincreator.com)
+   * @returns {string}
+   */
+  getResourceUrl: ({
+    type,
+    resourceURI,
+    sessionID,
+    baseURL = 'https://app.twincreator.com',
+  }: ResourceURLParams): string => {
+    let defaultUri =
+      type === 'cover'
+        ? `${baseURL}/images/memoriCover.png`
+        : `${baseURL}/images/memoriAvatar.png`;
+    if (!resourceURI || resourceURI.length === 0) {
+      return defaultUri;
+    } else if (resourceURI.includes('memoriai/memory')) {
+      return `${resourceURI}?memori-ai-session-id=${sessionID}`;
+    } else if (
+      resourceURI.startsWith('https://') ||
+      resourceURI.startsWith('http://')
+    ) {
+      return `${resourceURI}${sessionID ? `/${sessionID}` : ''}`;
+    } else if (resourceURI.startsWith('cloud://')) {
+      return `${apiUrl.replace(/v2/, 'v1')}/CloudAsset/${resourceURI.replace(
+        'cloud://',
+        ''
+      )}`;
+    } else if (resourceURI.startsWith('guid://')) {
+      return `${apiUrl.replace(/v2/, 'v1')}/GuidAsset/${resourceURI.replace(
+        'guid://',
+        ''
+      )}`;
+    } else {
+      return defaultUri;
+    }
+  },
+});

package/src/helpers/getApiUrl.ts

@@ -0,0 +1,6 @@
+export const getApiUrl = (hostname?: string) =>
+  hostname
+    ? new URL(
+        hostname.startsWith('http') ? hostname : `https://${hostname}`
+      ).origin.replace('http://', 'https://')
+    : 'https://backend.memori.ai';

package/src/index.ts

@@ -0,0 +1,20 @@
+import { getApiUrl } from './helpers/getApiUrl';
+import backend from './backend';
+import engine from './engine';
+import * as constants from './constants';
+import speech from './speech';
+import asset from './helpers/asset';
+
+const api = (hostname?: string) => {
+  const apiUrl = getApiUrl(hostname);
+
+  return {
+    backend: backend(`${apiUrl}/api/v2`),
+    ...engine(`${apiUrl}/memori/v2`),
+    speech,
+    constants,
+    asset: asset(`${apiUrl}/api/v2`),
+  };
+};
+
+export default api;