@scout9/app 1.0.0-alpha.0.1.85 → 1.0.0-alpha.0.1.87

package/src/platform.js

@@ -1,12 +1,12 @@
 import colors from 'kleur';
 import { z } from 'zod';
 import {
-    build as _build,
-    deploy as _deploy,
-    run as _run,
-    runConfig as _runConfig,
-    sync as _sync,
-    test as _test
+  build as _build,
+  deploy as _deploy,
+  run as _run,
+  runConfig as _runConfig,
+  sync as _sync,
+  test as _test
 } from './core/index.js';
 import { loadConfig, loadEnvConfig } from './core/config/index.js';
 import { coalesceToError, ProgressLogger } from './utils/index.js';
@@ -17,221 +17,223 @@ import { logUserValidationError, report } from './report.js';
  * Collection of Scout9 Platform commands
  */
 export const Scout9Platform = {
-    /**
-     * Syncs the project with the Scout9 account
-     * @param {Object} params
-     * @param {string} [params.cwd=process.cwd()] - the working directory
-     * @param {string} [params.src='src'] - the source directory
-     * @param {string} [params.mode='production'] - the build mode
-     * @returns {Promise<Scout9ProjectBuildConfig>}
-     */
-    sync: async function ({cwd = process.cwd(), src = 'src', mode = 'production'} = {}) {
-        const logger = new ProgressLogger();
-        const messages = [];
-        try {
-            logger.log(`Loading Local Config...`);
-            const projectFiles = new ProjectFiles({cwd, src, autoSave: true, logger});
-            const config = await projectFiles.load();
-            logger.success('Local Config Loaded');
-            logger.log(`Syncing project...`);
-            const result = await _sync({cwd, src, logger, projectFiles}, config);
-            logger.success('Sync Complete');
-            report(config, logger);
-            messages.forEach((m) => logger.info(m));
-            logger.done();
-            return result;
-        } catch (e) {
-            logger.done();
-            this.handleError(e);
-        }
-    },
-
-    /**
-     * Builds & Deploys the project
-     * @param {Object} params
-     * @param {string} [params.cwd=process.cwd()] - the working directory
-     * @param {string} [params.src='./src'] - the source directory
-     * @param {string} [params.dest='/tmp/project'] - the destination directory
-     * @param {'development' | 'production'} [params.mode='production'] - the build mode
-     * @param {boolean} [params.sync=true] - whether to sync the project after deploying
-     * @returns {Promise<Scout9ProjectBuildConfig>}
-     */
-    deploy: async function ({
-                                cwd = process.cwd(),
-                                src = './src',
-                                dest = '/tmp/project',
-                                mode = 'production',
-                                sync = true
-                            } = {}) {
-        const logger = new ProgressLogger();
-        const messages = [];
-        try {
-            // @TODO replace loadConfig with ProjectFiles class
-            logger.log(`Loading config...`);
-            let config = await loadConfig({cwd, src, deploying: true, dest, logger, cb: (m) => messages.push(m)});
-            logger.success('Config Loaded');
-            // await _build({cwd, src, dest, mode, logger}, config);
-            logger.log(`Deploying project...`);
-            const {contacts} = await _deploy({cwd, src, dest, logger}, config);
-            report(config, logger);
-            logger.success(`Deploy Complete\n\n`);
-            if (sync) {
-                logger.log(`Syncing project...`);
-                const projectFiles = new ProjectFiles({cwd, src, autoSave: true, logger});
-                config = await projectFiles.load();
-                const result = await _sync({cwd, src, logger, projectFiles}, config);
-                if (result.success) {
-                    logger.success('Sync Complete');
-                    config = result.config;
-                } else {
-                    logger.error('Sync Failed');
-                }
-            } else {
-                logger.warn(`Syncing project... skipped`);
-            }
+  /**
+   * Syncs the project with the Scout9 account
+   * @param {Object} params
+   * @param {string} [params.cwd=process.cwd()] - the working directory
+   * @param {string} [params.src='src'] - the source directory
+   * @param {string} [params.mode='production'] - the build mode
+   * @returns {Promise<import('./runtime/client/config.js').IScout9ProjectBuildConfig>}
+   */
+  sync: async function ({cwd = process.cwd(), src = 'src', mode = 'production'} = {}) {
+    const logger = new ProgressLogger();
+    const messages = [];
+    try {
+      logger.log(`Loading Local Config...`);
+      const projectFiles = new ProjectFiles({cwd, src, autoSave: true, logger});
+      const config = await projectFiles.load();
+      logger.success('Local Config Loaded');
+      logger.log(`Syncing project...`);
+      const result = await _sync({cwd, src, logger, projectFiles}, config);
+      logger.success('Sync Complete');
+      report(config, logger);
+      messages.forEach((m) => logger.info(m));
+      logger.done();
+      return result;
+    } catch (e) {
+      logger.done();
+      this.handleError(e);
+    }
+  },
 
-            logger.write(`\tApplication will be live for the following channels in a few moments:\n${contacts}`);
-            logger.done();
-            messages.forEach((m) => logger.info(m));
-            return config;
-        } catch (e) {
-            logger.done();
-            this.handleError(e);
-        }
-    },
-    /**
-     * Tests the project
-     * @param {Object} params
-     * @param {string} [params.cwd=process.cwd()] - the working directory
-     * @param {string} [params.src='./src'] - the source directory
-     * @param {string} [params.dest='/tmp/project'] - the destination directory
-     * @param {'development' | 'production'} [params.mode='production'] - the build mode
-     * @returns {Promise<Scout9ProjectBuildConfig>}
-     */
-    test: async function ({cwd = process.cwd(), src = './src', dest = '/tmp/project', mode = 'production'} = {}) {
-        const logger = new ProgressLogger();
-        const messages = [];
-        try {
-            logger.log(`Loading test data...`);
-            const config = await loadConfig({cwd, src, logger, cb: (m) => messages.push(m)});
-            logger.success('Test data loaded');
-            logger.log(`Testing project...`);
-            await _test({cwd, src, dest, logger}, config);
-            report(config, logger);
-            messages.forEach((m) => logger.info(m));
-            logger.success(`Test complete`);
-            logger.done();
-            return config;
-        } catch (e) {
-            logger.done();
-            this.handleError(e);
+  /**
+   * Builds & Deploys the project
+   * @param {Object} params
+   * @param {string} [params.cwd=process.cwd()] - the working directory
+   * @param {string} [params.src='./src'] - the source directory
+   * @param {string} [params.dest='/tmp/project'] - the destination directory
+   * @param {'development' | 'production'} [params.mode='production'] - the build mode
+   * @param {boolean} [params.sync=true] - whether to sync the project after deploying
+   * @returns {Promise<import('./runtime/client/config.js').IScout9ProjectBuildConfig>}
+   */
+  deploy: async function (
+    {
+      cwd = process.cwd(),
+      src = './src',
+      dest = '/tmp/project',
+      mode = 'production',
+      sync = true
+    } = {}
+  ) {
+    const logger = new ProgressLogger();
+    const messages = [];
+    try {
+      // @TODO replace loadConfig with ProjectFiles class
+      logger.log(`Loading config...`);
+      let config = await loadConfig({cwd, src, deploying: true, dest, logger, cb: (m) => messages.push(m)});
+      logger.success('Config Loaded');
+      // await _build({cwd, src, dest, mode, logger}, config);
+      logger.log(`Deploying project...`);
+      const {contacts} = await _deploy({cwd, src, dest, logger}, config);
+      report(config, logger);
+      logger.success(`Deploy Complete\n\n`);
+      if (sync) {
+        logger.log(`Syncing project...`);
+        const projectFiles = new ProjectFiles({cwd, src, autoSave: true, logger});
+        config = await projectFiles.load();
+        const result = await _sync({cwd, src, logger, projectFiles}, config);
+        if (result.success) {
+          logger.success('Sync Complete');
+          config = result.config;
+        } else {
+          logger.error('Sync Failed');
         }
-    },
-    /**
-     * Builds the project
-     * @param {Object} params
-     * @param {string} [params.cwd=process.cwd()] - the working directory
-     * @param {string} [params.src='./src'] - the source directory
-     * @param {string} [params.dest='/tmp/project'] - the destination directory
-     * @param {'development' | 'production'} [params.mode='production'] - the build mode
-     * @returns {Promise<Scout9ProjectBuildConfig>}
-     */
-    build: async function ({cwd = process.cwd(), src = './src', dest = '/tmp/project', mode = 'production'} = {}) {
-        const logger = new ProgressLogger();
-        const messages = [];
-        try {
-            logger.log(`Loading config...`);
-            const config = await loadConfig({
-                cwd, src, mode, logger, cb: (m) => {
-                    logger.info(m);
-                }
-            });
-            logger.success('Config Loaded');
-            logger.log(`Building project...`);
-            await _build({cwd, src, dest, mode, logger}, config);
-            report(config, logger);
-            messages.forEach((m) => logger.info(m));
-            logger.success('Build Complete');
-            logger.done();
-            return config;
-        } catch (e) {
-            logger.done();
-            this.handleError(e);
+      } else {
+        logger.warn(`Syncing project... skipped`);
+      }
+
+      logger.write(`\tApplication will be live for the following channels in a few moments:\n${contacts}`);
+      logger.done();
+      messages.forEach((m) => logger.info(m));
+      return config;
+    } catch (e) {
+      logger.done();
+      this.handleError(e);
+    }
+  },
+  /**
+   * Tests the project
+   * @param {Object} params
+   * @param {string} [params.cwd=process.cwd()] - the working directory
+   * @param {string} [params.src='./src'] - the source directory
+   * @param {string} [params.dest='/tmp/project'] - the destination directory
+   * @param {'development' | 'production'} [params.mode='production'] - the build mode
+   * @returns {Promise<import('./runtime/client/config.js').IScout9ProjectBuildConfig>}
+   */
+  test: async function ({cwd = process.cwd(), src = './src', dest = '/tmp/project', mode = 'production'} = {}) {
+    const logger = new ProgressLogger();
+    const messages = [];
+    try {
+      logger.log(`Loading test data...`);
+      const config = await loadConfig({cwd, src, logger, cb: (m) => messages.push(m)});
+      logger.success('Test data loaded');
+      logger.log(`Testing project...`);
+      await _test({cwd, src, dest, logger}, config);
+      report(config, logger);
+      messages.forEach((m) => logger.info(m));
+      logger.success(`Test complete`);
+      logger.done();
+      return config;
+    } catch (e) {
+      logger.done();
+      this.handleError(e);
+    }
+  },
+  /**
+   * Builds the project
+   * @param {Object} params
+   * @param {string} [params.cwd=process.cwd()] - the working directory
+   * @param {string} [params.src='./src'] - the source directory
+   * @param {string} [params.dest='/tmp/project'] - the destination directory
+   * @param {'development' | 'production'} [params.mode='production'] - the build mode
+   * @returns {Promise<import('./runtime/client/config.js').IScout9ProjectBuildConfig>}
+   */
+  build: async function ({cwd = process.cwd(), src = './src', dest = '/tmp/project', mode = 'production'} = {}) {
+    const logger = new ProgressLogger();
+    const messages = [];
+    try {
+      logger.log(`Loading config...`);
+      const config = await loadConfig({
+        cwd, src, mode, logger, cb: (m) => {
+          logger.info(m);
         }
-    },
+      });
+      logger.success('Config Loaded');
+      logger.log(`Building project...`);
+      await _build({cwd, src, dest, mode, logger}, config);
+      report(config, logger);
+      messages.forEach((m) => logger.info(m));
+      logger.success('Build Complete');
+      logger.done();
+      return config;
+    } catch (e) {
+      logger.done();
+      this.handleError(e);
+    }
+  },
 
-    /**
-     * Loads the project config
-     * @param {Object} params
-     * @param {string} [params.cwd=process.cwd()] - the working directory
-     * @param {boolean} [params.local=false] - whether to only load the local config (ignores what's saved on server)
-     * @param {string} [params.src='./src'] - the source directory
-     * @returns {Promise<Scout9ProjectBuildConfig>}
-     */
-    config: async function ({cwd = process.cwd(), local = false, src = './src'} = {}) {
-        try {
-            loadEnvConfig({cwd});
-            if (local) {
-                const projectFiles = new ProjectFiles({cwd, src, autoSave: false});
-                return projectFiles.load();
-            } else {
-                return _runConfig();
-            }
+  /**
+   * Loads the project config
+   * @param {Object} params
+   * @param {string} [params.cwd=process.cwd()] - the working directory
+   * @param {boolean} [params.local=false] - whether to only load the local config (ignores what's saved on server)
+   * @param {string} [params.src='./src'] - the source directory
+   * @returns {Promise<import('./runtime/client/config.js').IScout9ProjectBuildConfig>}
+   */
+  config: async function ({cwd = process.cwd(), local = false, src = './src'} = {}) {
+    try {
+      loadEnvConfig({cwd});
+      if (local) {
+        const projectFiles = new ProjectFiles({cwd, src, autoSave: false});
+        return projectFiles.load();
+      } else {
+        return _runConfig();
+      }
 
-        } catch (e) {
-            this.handleError(e);
-            throw e;
-        }
-    },
+    } catch (e) {
+      this.handleError(e);
+      throw e;
+    }
+  },
 
-    /**
-     * Runs the project in a container
-     * @param {WorkflowEvent} event - every workflow receives an event object
-     * @param {Object} options
-     * @param {string} [options.cwd=process.cwd()] - the working directory
-     * @param {string} [options.mode='production'] - the build mode
-     * @param {string} [options.src='./src'] - the source directory
-     * @param {string} options.eventSource - the source of the workflow event
-     * @returns {Promise<WorkflowResponse<any>>}
-     */
-    run: async function (
-        event,
-        {cwd = process.cwd(), mode = 'production', src = './src', eventSource}
-    ) {
-        try {
-            loadEnvConfig({cwd});
-            return _run(event, {cwd, src, mode, eventSource})
-                .catch(e => {
-                    throw e;
-                });
-        } catch (e) {
-            this.handleError(e);
-            throw e;
-        }
-    },
+  /**
+   * Runs the project in a container
+   * @param {import('./runtime/client/workflow.js').IWorkflowEvent} event - every workflow receives an event object
+   * @param {Object} options
+   * @param {string} [options.cwd=process.cwd()] - the working directory
+   * @param {string} [options.mode='production'] - the build mode
+   * @param {string} [options.src='./src'] - the source directory
+   * @param {string} options.eventSource - the source of the workflow event
+   * @returns {Promise<import('./runtime/client/workflow.js').IWorkflowResponse>}
+   */
+  run: async function (
+    event,
+    {cwd = process.cwd(), mode = 'production', src = './src', eventSource}
+  ) {
+    try {
+      loadEnvConfig({cwd});
+      return _run(event, {cwd, src, mode, eventSource})
+        .catch(e => {
+          throw e;
+        });
+    } catch (e) {
+      this.handleError(e);
+      throw e;
+    }
+  },
 
 
-    handleError: function (e) {
-        const error = coalesceToError(e);
+  handleError: function (e) {
+    const error = coalesceToError(e);
 
-        switch (error.name) {
-            case 'SyntaxError':
-                throw error;
-            case 'ZodError':
-                logUserValidationError(error, error.source || 'src/index.js|ts');
-                break;
-            default:
-                console.error(colors.bold().red(`> ${error.message}`));
-                if (error instanceof z.ZodError) {
-                    console.error(error.issues.map(i => colors.red(`${colors.bold(`\tZod Error (${i.code}): `)}"${i.message}" ${JSON.stringify(
-                        i.path)}`)).join('\n'));
-                    console.error(colors.gray(JSON.stringify(error.format(), null, 2)));
-                }
+    switch (error.name) {
+      case 'SyntaxError':
+        throw error;
+      case 'ZodError':
+        logUserValidationError(error, error.source || 'src/index.js|ts');
+        break;
+      default:
+        console.error(colors.bold().red(`> ${error.message}`));
+        if (error instanceof z.ZodError) {
+          console.error(error.issues.map(i => colors.red(`${colors.bold(`\tZod Error (${i.code}): `)}"${i.message}" ${JSON.stringify(
+            i.path)}`)).join('\n'));
+          console.error(colors.gray(JSON.stringify(error.format(), null, 2)));
+        }
 
-                if (error.stack) {
-                    console.error(colors.gray(error.stack.split('\n').slice(0).join('\n')));
-                }
+        if (error.stack) {
+          console.error(colors.gray(error.stack.split('\n').slice(0).join('\n')));
         }
-        process.exit(1);
     }
+    process.exit(1);
+  }
 };

package/src/public.d.ts

@@ -1,6 +1,7 @@
 
 /**
  * Represents the configuration provided in src/index.{js | ts} in a project
+ * @deprecated use IScout9ProjectConfig
  */
 export interface Scout9ProjectConfig {
 
@@ -64,6 +65,7 @@ export interface Scout9ProjectConfig {
 
 /**
  * Entity config the user provides
+ * @deprecated use IEntityConfiguration
  */
 export interface EntityBuildConfig {
   definitions?: {
@@ -85,6 +87,7 @@ export interface EntityBuildConfig {
 
 /**
  * What gets exported to the scout9 backend, properties are constructed by @scout/app build
+ * @deprecated use IEntityRootProjectConfiguration instead
  */
 export interface ExportedEntityBuildConfig extends EntityBuildConfig {
   entities: string[];
@@ -100,15 +103,27 @@ export interface ExportedEntityBuildConfig extends EntityBuildConfig {
   } | null;
 }
 
+/**
+ * @deprecated use IEntitiesRootProjectConfiguration instead
+ */
 export type EntitiesBuildConfig = ExportedEntityBuildConfig[];
 
+/**
+ * @deprecated use IWorkflowConfiguration instead
+ */
 export type WorkflowBuildConfig = {
   entities: string[];
   entity: string;
 }
+
+/**
+ * @deprecated use IWorkflowsConfiguration instead
+ */
 export type WorkflowsBuildConfig = WorkflowBuildConfig[];
+
 /**
  * Including the provided project config, this is the manifest for all entities and workflows to be managed in build
+ * @deprecated IScout9ProjectBuildConfig
  */
 export interface Scout9ProjectBuildConfig extends Scout9ProjectConfig {
   agents: Agent[];
@@ -131,6 +146,9 @@ export interface RunOptions {
   mode?: 'remote' | 'local';
 }
 
+/**
+ * @deprecated use IConversation
+ */
 export interface Conversation {
   $agent: string;
   $customer: string;
@@ -158,6 +176,9 @@ export interface Conversation {
   intentScore?: number | null;
 }
 
+/**
+ * @deprecated use IMessage
+ */
 export interface Message {
   id: string;
 
@@ -185,6 +206,9 @@ export interface Message {
   intentScore?: number | null;
 }
 
+/**
+ * @deprecated use ICustomer
+ */
 export interface Customer {
   id: string;
   name: string;
@@ -205,6 +229,9 @@ export interface Customer {
   [key: string]: any;
 }
 
+/**
+ * @deprecated use IAgent
+ */
 export interface Agent {
   // Generated Info
   id: string;
@@ -236,10 +263,14 @@ export interface Agent {
   audios?: any[];
 }
 
+/**
+ * @deprecated use IPersona
+ */
 export type Persona = Agent;
 
 /**
  * The input event provided to the application
+ * @deprecated use IWorkflowEvent
  */
 export interface WorkflowEvent<Type = any> {
   messages: Message[];
@@ -256,11 +287,17 @@ export interface WorkflowEvent<Type = any> {
   stagnationCount: number;
 }
 
+/**
+ * @deprecated use IInstruction
+ */
 export interface Instruction {
   id: string;
   content: string;
 }
 
+/**
+ * @deprecated use IWorkflowResponseSlot
+ */
 export interface WorkflowResponseSlot<Type = any> {
   forward?: string | boolean | {
     to?: string;
@@ -281,86 +318,12 @@ export interface WorkflowResponseSlot<Type = any> {
   resetIntent?: boolean;
 }
 
+/**
+ * @deprecated use IWorkflowResponse
+ */
 export type WorkflowResponse<Type = any> = WorkflowResponseSlot<Type> | WorkflowResponseSlot<Type>[];
 
+/**
+ * @deprecated use IWorkflowFunction
+ */
 export type WorkflowFunction<Type = any> = (event: WorkflowEvent) => Promise<WorkflowResponse<Type>> | WorkflowResponse<Type>;
-
-export declare function json<Type = any>(data: Type, init?: ResponseInit): Promise<EventResponse<Type>>;
-
-export declare function run<Type = any>(event: WorkflowEvent, options?: RunOptions): Promise<WorkflowResponse<Type>>;
-
-export declare function sendEvent<Type = any>(event: WorkflowEvent, options?: RunOptions): Promise<WorkflowResponse<Type>>;
-
-export declare function build(options?: BuildOptions): Promise<Scout9ProjectBuildConfig>;
-
-export declare function deploy(options?: DeployOptions): Promise<Scout9ProjectBuildConfig>;
-
-export class EventResponse<Type = any> {
-  /**
-   * Static method to create an EventResponse object.
-   * @param body The body of the response, expected to be an object.
-   * @param options Additional options for the response.
-   */
-  static json<Type = any>(body: object, options?: ResponseInit): EventResponse<Type>;
-
-  /**
-   * The body of the response.
-   */
-  body: object;
-
-  // Alias to body
-  readonly data: object;
-
-  /**
-   * Initialization options for the response.
-   */
-  init?: ResponseInit;
-
-  /**
-   * Creates an instance of EventResponse.
-   * @param body The body of the response, expected to be an object.
-   * @param init Initialization options for the response.
-   */
-  constructor(body: Type, init?: ResponseInit);
-
-  /**
-   * Returns a Response object with JSON body.
-   */
-  readonly response: Response;
-}
-
-export type ApiFunctionParams<Params = Record<string, string>> = {
-  searchParams: {[key: string]: string | string[] };
-  params: Params;
-}
-// export type ApiEntityFunctionParams<Params = Record<string, string>> = ApiFunctionParams<Params> & {id: string};
-export type ApiFunction<Params = Record<string, string>, Response = any> = (params: ApiFunctionParams<Params>) => Promise<EventResponse<Response>>;
-export type QueryApiFunction<Params = Record<string, string>, Response = any> = (params: ApiFunctionParams<Params>) => Promise<EventResponse<Response>>;
-export type GetApiFunction<Params = Record<string, string>, Response = any> = (params: ApiFunctionParams<Params>) => Promise<EventResponse<Response>>;
-export type PostApiFunction<Params = Record<string, string>, RequestBody = any, Response = any> = (params: ApiFunctionParams<Params> & {body: Partial<RequestBody>}) => Promise<EventResponse<Response>>;
-export type PutApiFunction<Params = Record<string, string>, RequestBody = any, Response = any> = (params: ApiFunctionParams<Params> & {body: Partial<RequestBody>}) => Promise<EventResponse<Response>>;
-export type PatchApiFunction<Params = Record<string, string>, RequestBody = any, Response = any> = (params: ApiFunctionParams<Params> & {body: Partial<RequestBody>}) => Promise<EventResponse<Response>>;
-export type DeleteApiFunction<Params = Record<string, string>, Response = any> = (params: ApiFunctionParams<Params>) => Promise<EventResponse<Response>>;
-
-
-export type mimicCustomerMessage = (input: {
-  message: string;
-  messages?: Message[];
-  workflowFn: WorkflowFunction;
-  customer?: Customer;
-  context?: any;
-  /**
-   * Agent or persona id
-   */
-  persona?: string;
-
-  conversation?: Conversation;
-
-  cwd?: string;
-  src?: string;
-  mode?: 'development' | 'production';
-}) => Promise<{
-  messages: Message[];
-  conversation: Conversation;
-  context: any;
-}>