@scout9/app 1.0.0-alpha.0.1.9 → 1.0.0-alpha.0.1.91

package/src/utils/configs/agents.js

@@ -0,0 +1,68 @@
+import path from 'node:path';
+import colors from 'kleur';
+import { globSync } from 'glob';
+import { checkVariableType, requireProjectFile } from '../../utils/index.js';
+import { agentsConfigurationSchema, agentsBaseConfigurationSchema } from '../../runtime/index.js';
+
+/**
+ * @param {Array<Agent>} agents
+ * @returns {*}
+ */
+export function validateAgentConfig(agents) {
+  // Send warnings if not properly registered
+  for (const agent of agents) {
+    if (!agent.forwardPhone && !agent.forwardEmail) {
+      throw new Error(`src/entities/agents.js|ts: must provide either a ".forwardPhone" or ".forwardEmail" to ${agent.firstName || JSON.stringify(agent)}.`)
+    }
+    if (!agent.programmablePhoneNumber) {
+      const userName = agent.firstName ? `${agent.firstName}${agent.lastName ? ' ' + agent.lastName : ''}` : agent.forwardPhone;
+      cb(`⚠️${colors.yellow('Warning')}: ${userName} does not have a masked phone number to do auto replies. You can register one at ${colors.cyan('https://scout9.com/b')} under ${colors.green('users')} > ${colors.green(userName)}. Then run ${colors.cyan('scout9 sync')} to update.`);
+    }
+    if (agent.forwardPhone && agents.filter(a => a.forwardPhone && (a.forwardPhone === agent.forwardPhone)).length > 1) {
+      throw new Error(`src/entities/agents.js|ts: ".forwardPhone: ${agent.forwardPhone}" can only be associated to one agent within your project`);
+    }
+    if (agent.forwardEmail && agents.filter(a => a.forwardEmail && (a.forwardEmail === agent.forwardEmail)).length > 1) {
+      throw new Error(`src/entities/agents.js|ts: ".forwardEmail: ${agent.forwardEmail}" can only be associated to one agent within your project`);
+    }
+  }
+
+  const result = agentsBaseConfigurationSchema.safeParse(agents);
+  if (!result.success) {
+    result.error.source = `src/entities/agents.js|ts`;
+    throw result.error;
+  }
+  return agents;
+}
+
+export default async function loadAgentConfig({cwd = process.cwd(), src = 'src', cb = (message) => {}} = {}) {
+  const paths = globSync(`${src}/entities/agents/{index,config}.{ts,js}`, {cwd, absolute: true});
+  if (paths.length === 0) {
+    throw new Error(`Missing required agents entity file, rerun "scout9 sync" to fix`);
+  }
+  if (paths.length > 1) {
+    throw new Error(`Multiple agents entity files found, rerun "scout9 sync" to fix`);
+  }
+
+  /**
+   * @type {Array<Agent> | function(): Array<Agent> | function(): Promise<Array<Agent>>}
+   */
+  const mod = await requireProjectFile(paths[0]).then(mod => mod.default);
+
+  // @type {Array<Agent>}
+  let agents = [];
+  const entityType = checkVariableType(mod);
+  switch (entityType) {
+    case 'async function':
+    case 'function':
+      agents = await mod();
+      break;
+    case 'array':
+      agents = mod;
+      break;
+    default:
+      throw new Error(`Invalid entity type (${entityType}) returned at "${path}"`);
+  }
+
+  return validateAgentConfig(agents);
+}
+

package/src/utils/configs/entities.js

@@ -0,0 +1,145 @@
+import { globSync } from 'glob';
+import path from 'node:path';
+import {
+  entitiesRootProjectConfigurationSchema,
+  entityApiConfigurationSchema,
+  entityConfigurationSchema,
+  entityRootProjectConfigurationSchema
+} from '../../runtime/index.js';
+import { checkVariableType, requireOptionalProjectFile, requireProjectFile } from '../module.js';
+
+async function loadEntityApiConfig(cwd, filePath) {
+  const dir = path.dirname(filePath);
+  const extension = path.extname(filePath);
+  const apiFilePath = path.resolve(dir, `api${extension}`);
+  const mod = await requireOptionalProjectFile(apiFilePath);
+
+  if (mod) {
+    const config = {};
+    const methods = ['GET', 'UPDATE', 'QUERY', 'PUT', 'PATCH', 'DELETE'];
+    for (const key in mod) {
+      if (methods.includes(key)) {
+        config[key] = true;
+      }
+    }
+    entityApiConfigurationSchema.parse(config);
+    return config;
+  } else {
+    return null;
+  }
+}
+
+/**
+ * @returns {Promise<EntitiesBuildConfig>}
+ */
+export default async function loadEntitiesConfig(
+  {
+    cwd = process.cwd(),
+    src = 'src',
+    // logger,
+    // cb = (message) => {}
+  } = {}
+) {
+  /** @type EntitiesBuildConfig */
+  const config = [];
+  // const paths = globSync(path.resolve(cwd, `${src}/entities/**/{index,config,api}.{ts,js}`), {cwd, absolute: true});
+  const filePaths = globSync(`${src}/entities/**/{index,config,api}.{ts,js}`, {cwd, absolute: true});
+  const data = [];
+  for (const filePath of filePaths) {
+    const segments = filePath.split(path.sep); // Use path.sep for platform independence
+    // const segments = filePath.split('/');
+    const srcIndex = segments.findIndex((segment, index) => segment === src && segments[index + 1] === 'entities');
+    const parents = segments.slice(srcIndex + 2, -1).reverse(); // +2 to skip "${src}" and "entities"
+    if (parents.length > 0) {
+      const api = await loadEntityApiConfig(cwd, filePath);
+      data.push({filePath, parents, api});
+    } else {
+      console.log(`WARNING: "${filePath}" Is not a valid entity filePath, must be contained in a named src under "${src}/entities/", see "${src}/entities/agents" or "${src}/entities/customers" for examples.`);
+    }
+  }
+
+  const specialEntities = ['agents'];
+
+  for (const {filePath, parents, api} of data) {
+    let entityConfig = {};
+    // const fileName = filePath.split('/')?.pop()?.split('.')?.[0];
+    const fileName = path.basename(filePath, path.extname(filePath));
+    if (!fileName) throw new Error(`Invalid file name "${filePath}"`);
+    const isSpecial = specialEntities.some(se => parents.includes(se));
+    if ((fileName === 'index' || fileName === 'config') && !isSpecial) {
+      const entityConfigHandler = await requireProjectFile(filePath).then(mod => mod.default);
+      // Check if entityConfig is a function or object
+      const entityType = checkVariableType(entityConfigHandler);
+      switch (entityType) {
+        case 'async function':
+        case 'function':
+          entityConfig = await entityConfigHandler();
+          break;
+        case 'object':
+          entityConfig = entityConfigHandler;
+          break;
+        default:
+          throw new Error(`Invalid entity type (${entityType}) returned at "${filePath}"`);
+      }
+
+      // Validate entity configuration
+      const result = entityConfigurationSchema.safeParse(entityConfig, {path: ['entities', config.length]});
+      if (!result.success) {
+        result.error.source = filePath;
+        throw result.error;
+      }
+    } else if (isSpecial && (fileName === 'index' || fileName === 'config')) {
+      // If this is a special entity file, then ignore as we will capture it another method
+      continue;
+    }
+
+    // Validate project configuration
+    const entityProjectConfig = {
+      ...entityConfig,
+      entity: parents[0],
+      entities: parents.reverse(),
+      api
+    };
+    entityRootProjectConfigurationSchema.parse(entityProjectConfig);
+    const existingIndex = config.findIndex(c => c.entity === entityProjectConfig.entity);
+    if (existingIndex > -1) {
+      if (config[existingIndex].entities.length !== entityProjectConfig.entities.length) {
+        throw new Error(`Invalid entity configuration at "${filePath}", entity name mismatch`);
+      }
+        config[existingIndex] = {
+          ...config[existingIndex],
+          definitions: [
+              ...(config[existingIndex].definitions),
+                ...(entityProjectConfig.definitions || [])
+          ],
+          training: [
+            ...(config[existingIndex].training),
+            ...(entityProjectConfig.training || [])
+          ],
+          tests: [
+            ...(config[existingIndex].tests),
+            ...(entityProjectConfig.tests || [])
+          ],
+            api: (!config[existingIndex].api && !entityProjectConfig.api) ? null : {
+            ...(config[existingIndex].api || {}),
+            ...(entityProjectConfig.api || {})
+          }
+        }
+    } else {
+      config.push(entityProjectConfig);
+    }
+  }
+
+  // if (!config.some(c => c.entity === 'customers')) {
+  //   throw new Error(`Missing required entity: "entities/customers" in ${src}`);
+  // }
+  // if (!config.some(c => c.entity === '[customer]')) {
+  //   throw new Error(`Missing required entity: "entities/customers/[customer]"`);
+  // }
+
+  // Validate the config
+  entitiesRootProjectConfigurationSchema.parse(config);
+
+  return config;
+}
+

package/src/utils/configs/project.js

@@ -0,0 +1,23 @@
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import fss from 'node:fs';
+import fs from 'node:fs/promises';
+
+/**
+ * Loads the users local package.json, if they provide a package-s9-test.json, it will load that instead (used for scout9 internal testing)
+ * @param {cwd?: string}
+ * @returns {Promise<{isTest: boolean, pkg: {name: string; version: string; dependencies: Record<string, string>}}>}
+ */
+export async function loadUserPackageJson({cwd = process.cwd()}) {
+  const packageJsonPath = path.resolve(cwd, './package.json');
+  const packageTestJsonPath = path.resolve(cwd, './package-s9-test.json');
+  const packageJsonUrl = pathToFileURL(packageJsonPath);
+  const packageTestJsonUrl = pathToFileURL(packageTestJsonPath);
+  const isTest = fss.existsSync(packageTestJsonUrl);
+  const targetPkgUrl = isTest ? packageTestJsonUrl : packageJsonUrl;
+  const pkg = JSON.parse(await fs.readFile(new URL(targetPkgUrl, import.meta.url), 'utf-8'));
+  return {
+    pkg,
+    isTest
+  }
+}

package/src/utils/configs/workflow.js

@@ -0,0 +1,47 @@
+import { globSync } from 'glob';
+import { WorkflowConfigurationSchema, WorkflowsConfigurationSchema } from '../../runtime/index.js';
+
+
+/**
+ * @returns {Promise<WorkflowsBuildConfig>}
+ */
+export default async function loadWorkflowsConfig(
+  {
+    cwd = process.cwd(),
+    src = 'src',
+    // cb = (message) => {}
+  } = {}
+) {
+  // const config = globSync(path.resolve(cwd, `${src}/workflows/**/workflow.{ts,js}`), {cwd, absolute: true})
+  const config = globSync(`${src}/workflows/**/workflow.{ts,js}`, {cwd, absolute: true})
+    .map((path) => {
+      const segments = path.split('/');
+      const srcIndex = segments.findIndex((segment, index) => segment === src && segments[index + 1] === 'workflows');
+      const parents = segments.slice(srcIndex + 2, -1).reverse(); // +2 to skip "${src}" and "workflows"
+      return {path, parents};
+    })
+    .filter(path => {
+      if (path.parents.length > 0) {
+        return true;
+      } else {
+        console.log(`WARNING: "${path}" Is not a valid entity path, must be contained in a named src under workflows/`);
+      }
+    })
+    .map(({path, parents}) => {
+
+      // Validate project configuration
+      /** @type {WorkflowBuildConfig} */
+      const workflowConfig = {
+        entity: parents[0],
+        entities: parents.reverse(),
+      }
+      WorkflowConfigurationSchema.parse(workflowConfig);
+
+      return workflowConfig;
+    });
+
+  // Validate the config
+  WorkflowsConfigurationSchema.parse(config);
+
+  return config;
+}