@memberjunction/server 2.1.4 → 2.2.0

package/src/auth/tokenExpiredError.ts

@@ -0,0 +1,12 @@
+import { GraphQLError } from 'graphql';
+
+export class TokenExpiredError extends GraphQLError {
+  constructor(expiryDate: Date, message = 'The provided token has expired. Please authenticate again.') {
+    super(message, {
+      extensions: {
+        code: 'JWT_EXPIRED',
+        expiryDate: expiryDate.toISOString(),
+      },
+    });
+  }
+}

package/src/cache.ts

@@ -0,0 +1,10 @@
+import { LRUCache } from 'lru-cache';
+
+const oneHourMs = 60 * 60 * 1000;
+
+export const authCache = new LRUCache({
+  max: 50000,
+  ttl: oneHourMs,
+  ttlAutopurge: false,
+});
+

package/src/config.ts

@@ -0,0 +1,89 @@
+import env from 'env-var';
+import fs from 'fs';
+import path from 'path';
+import { z } from 'zod';
+
+export const nodeEnv = env.get('NODE_ENV').asString();
+
+export const dbHost = env.get('DB_HOST').required().asString();
+export const dbPort = env.get('DB_PORT').default('1433').asPortNumber();
+export const dbUsername = env.get('DB_USERNAME').required().asString();
+export const dbPassword = env.get('DB_PASSWORD').required().asString();
+export const dbDatabase = env.get('DB_DATABASE').required().asString();
+export const dbInstanceName = env.get('DB_INSTANCE_NAME').asString();
+export const dbTrustServerCertificate = env.get('DB_TRUST_SERVER_CERTIFICATE').asBool();
+
+export const graphqlPort = env.get('PORT').default('4000').asPortNumber();
+
+export const ___codeGenAPIURL = env.get('CODEGEN_API_URL').asString();
+export const ___codeGenAPIPort = env.get('CODEGEN_API_PORT').default('3999').asPortNumber();
+export const ___codeGenAPISubmissionDelay = env.get('CODEGEN_API_SUBMISSION_DELAY').default(5000).asIntPositive();
+
+export const graphqlRootPath = env.get('ROOT_PATH').default('/').asString();
+
+export const webClientID = env.get('WEB_CLIENT_ID').asString();
+export const tenantID = env.get('TENANT_ID').asString();
+
+export const enableIntrospection = env.get('ENABLE_INTROSPECTION').default('false').asBool();
+export const websiteRunFromPackage = env.get('WEBSITE_RUN_FROM_PACKAGE').asIntPositive();
+export const userEmailMap = env.get('USER_EMAIL_MAP').default('{}').asJsonObject() as Record<string, string>;
+
+export const ___skipAPIurl = env.get('ASK_SKIP_API_URL').asString();
+export const ___skipAPIOrgId = env.get('ASK_SKIP_ORGANIZATION_ID').asString();
+
+export const auth0Domain = env.get('AUTH0_DOMAIN').asString();
+export const auth0WebClientID = env.get('AUTH0_CLIENT_ID').asString();
+export const auth0ClientSecret = env.get('AUTH0_CLIENT_SECRET').asString();
+
+export const mj_core_schema = env.get('MJ_CORE_SCHEMA').asString();
+
+export const configFile = env.get('CONFIG_FILE').asString();
+
+const userHandlingInfoSchema = z.object({
+  autoCreateNewUsers: z.boolean().optional().default(false),
+  newUserLimitedToAuthorizedDomains: z.boolean().optional().default(false),
+  newUserAuthorizedDomains: z.array(z.string()).optional().default([]),
+  newUserRoles: z.array(z.string()).optional().default([]),
+  updateCacheWhenNotFound: z.boolean().optional().default(false),
+  updateCacheWhenNotFoundDelay: z.number().optional().default(30000),
+  contextUserForNewUserCreation: z.string().optional().default(''),
+});
+
+const databaseSettingsInfoSchema = z.object({
+  connectionTimeout: z.number(),
+  requestTimeout: z.number(),
+  metadataCacheRefreshInterval: z.number(),
+});
+
+const viewingSystemInfoSchema = z.object({
+  enableSmartFilters: z.boolean().optional(),
+});
+
+const askSkipInfoSchema = z.object({
+  organizationInfo: z.string().optional(),
+});
+
+const configInfoSchema = z.object({
+  userHandling: userHandlingInfoSchema,
+  databaseSettings: databaseSettingsInfoSchema,
+  viewingSystem: viewingSystemInfoSchema.optional(),
+  askSkip: askSkipInfoSchema.optional(),
+});
+
+export type UserHandlingInfo = z.infer<typeof userHandlingInfoSchema>;
+export type DatabaseSettingsInfo = z.infer<typeof databaseSettingsInfoSchema>;
+export type ViewingSystemSettingsInfo = z.infer<typeof viewingSystemInfoSchema>;
+export type ConfigInfo = z.infer<typeof configInfoSchema>;
+
+export const configInfo: ConfigInfo = loadConfig();
+
+export function loadConfig() {
+  const configPath = configFile ?? path.resolve('config.json');
+
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`Config file ${configPath} does not exist.`);
+  }
+
+  const configData = fs.readFileSync(configPath, 'utf-8');
+  return configInfoSchema.parse(JSON.parse(configData));
+}

package/src/context.ts

@@ -0,0 +1,111 @@
+import { IncomingMessage } from 'http';
+import * as url from 'url';
+import { default as jwt } from 'jsonwebtoken';
+import 'reflect-metadata';
+import { Subject, firstValueFrom } from 'rxjs';
+import { AuthenticationError, AuthorizationError } from 'type-graphql';
+import { DataSource } from 'typeorm';
+import { getSigningKeys, validationOptions, verifyUserRecord } from './auth/index.js';
+import { authCache } from './cache.js';
+import { userEmailMap } from './config.js';
+import { UserPayload } from './types.js';
+import { TokenExpiredError } from './auth/index.js';
+
+const verifyAsync = async (issuer: string, options: jwt.VerifyOptions, token: string): Promise<jwt.JwtPayload> =>
+  new Promise((resolve, reject) => {
+    jwt.verify(token, getSigningKeys(issuer), options, (err, jwt) => {
+      if (jwt && typeof jwt !== 'string' && !err) {
+        const payload = jwt.payload ?? jwt;
+
+        console.log(`Valid token: ${payload.name} (${payload.email ? payload.email : payload.preferred_username})`); // temporary fix to check preferred_username if email is not present
+        resolve(payload);
+      } else {
+        console.warn('Invalid token');
+        reject(err);
+      }
+    });
+  });
+
+export const getUserPayload = async (
+  bearerToken: string,
+  sessionId = 'default',
+  dataSource: DataSource,
+  requestDomain?: string
+): Promise<UserPayload> => {
+  try {
+    const token = bearerToken.replace('Bearer ', '');
+
+    if (!token) {
+      console.warn('No token to validate');
+      throw new AuthenticationError('Missing token');
+    }
+
+    const payload = jwt.decode(token);
+    if (!payload || typeof payload === 'string') {
+      throw new AuthenticationError('Invalid token payload');
+    }
+
+    const expiryDate = new Date((payload.exp ?? 0) * 1000);
+    if (expiryDate.getTime() <= Date.now()) {
+      throw new TokenExpiredError(expiryDate);
+    }
+
+    if (!authCache.has(token)) {
+      const issuer = payload.iss;
+      if (!issuer) {
+        console.warn('No issuer claim on token');
+        throw new AuthenticationError('Missing issuer claim on token');
+      }
+
+      await verifyAsync(issuer, validationOptions[issuer], token);
+      authCache.set(token, true);
+    }
+
+    const email = payload?.email ? userEmailMap[payload?.email] ?? payload?.email : payload?.preferred_username; // temporary fix to check preferred_username if email is not present
+    const fullName = payload?.name;
+    const firstName = payload?.given_name || fullName?.split(' ')[0];
+    const lastName = payload?.family_name || fullName?.split(' ')[1] || fullName?.split(' ')[0];
+    const userRecord = await verifyUserRecord(email, firstName, lastName, requestDomain, dataSource);
+
+    if (!userRecord) {
+      console.error(`User ${email} not found`);
+      throw new AuthorizationError();
+    } else if (!userRecord.IsActive) {
+      console.error(`User ${email} found but inactive`);
+      throw new AuthorizationError();
+    }
+
+    return { userRecord, email, sessionId };
+  } catch (e) {
+    console.error(e);
+    if (e instanceof TokenExpiredError) {
+      throw e;
+    } else return {} as UserPayload;
+  }
+};
+
+export const contextFunction =
+  ({ setupComplete$, dataSource }: { setupComplete$: Subject<unknown>; dataSource: DataSource }) =>
+  async ({ req }: { req: IncomingMessage }) => {
+    await firstValueFrom(setupComplete$); // wait for setup to complete before processing the request
+
+    const sessionIdRaw = req.headers['x-session-id'];
+    const requestDomain = url.parse(req.headers.origin || '');
+    const sessionId = sessionIdRaw ? sessionIdRaw.toString() : '';
+    const bearerToken = req.headers.authorization ?? '';
+
+    const userPayload = await getUserPayload(
+      bearerToken,
+      sessionId,
+      dataSource,
+      requestDomain?.hostname ? requestDomain.hostname : undefined
+    );
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const operationName: string | undefined = (req as any).body?.operationName;
+    if (operationName !== 'IntrospectionQuery') {
+      console.log({ operationName });
+    }
+
+    return { dataSource, userPayload };
+  };

package/src/directives/Public.ts

@@ -0,0 +1,42 @@
+import { FieldMapper, MapperKind, getDirective, mapSchema } from '@graphql-tools/utils';
+import { GraphQLFieldResolver, defaultFieldResolver } from 'graphql';
+import { AuthorizationError, Directive } from 'type-graphql';
+import { AppContext, DirectiveBuilder } from '../types.js';
+
+const DIRECTIVE_NAME = 'Public';
+
+export function Public(): PropertyDecorator & MethodDecorator & ClassDecorator;
+export function Public(): PropertyDecorator | MethodDecorator | ClassDecorator {
+  return (targetOrPrototype, propertyKey, descriptor) =>
+    Directive(`@${DIRECTIVE_NAME}`)(targetOrPrototype, propertyKey, descriptor);
+}
+
+export const publicDirective: DirectiveBuilder = {
+  typeDefs: `directive @${DIRECTIVE_NAME} on FIELD_DEFINITION`,
+  transformer: (schema) => {
+    const fieldMapper: FieldMapper = (fieldConfig) => {
+      const directive = getDirective(schema, fieldConfig, DIRECTIVE_NAME)?.[0];
+      if (directive) {
+        return fieldConfig;
+      } else {
+        // `@Public` directive not present, so will require auth
+        const { resolve = defaultFieldResolver } = fieldConfig;
+        const directiveResolver: GraphQLFieldResolver<unknown, AppContext> = async (
+          source,
+          args,
+          context,
+          info
+        ) => {
+          // eslint-disable-next-line
+          if (!context?.userPayload?.userRecord?.IsActive) {
+            throw new AuthorizationError();
+          }
+          return await resolve(source, args, context, info);
+        };
+
+        return { ...fieldConfig, resolve: directiveResolver };
+      }
+    };
+    return mapSchema(schema, { [MapperKind.OBJECT_FIELD]: fieldMapper });
+  },
+};

package/src/directives/index.ts

@@ -0,0 +1 @@
+export * from './Public.js';

package/src/entitySubclasses/DuplicateRunEntity.server.ts

@@ -0,0 +1,29 @@
+import { BaseEntity, PotentialDuplicateRequest } from "@memberjunction/core";
+import { RegisterClass } from "@memberjunction/global";
+import { DuplicateRunEntity } from "@memberjunction/core-entities";
+import { DuplicateRecordDetector } from "@memberjunction/ai-vector-dupe";
+
+@RegisterClass(BaseEntity, 'Duplicate Runs', 3)
+export class DuplicateRunEntity_Server extends DuplicateRunEntity  {
+    public async Save(): Promise<boolean> {
+        const saveResult: boolean = await super.Save();
+        if (saveResult && this.EndedAt === null) {
+            // do something
+            const duplicateRecordDetector: DuplicateRecordDetector = new DuplicateRecordDetector();
+            let request: PotentialDuplicateRequest = new PotentialDuplicateRequest();
+            request.EntityID = this.EntityID;
+            request.ListID = this.SourceListID;
+            request.Options = {
+                DuplicateRunID: this.ID,
+            };
+            
+            const response = await duplicateRecordDetector.getDuplicateRecords(request, this.ContextCurrentUser);
+        }
+
+        return saveResult;
+    }
+}
+
+export function LoadDuplicateRunEntityServerSubClass() {
+
+}

package/src/entitySubclasses/entityPermissions.server.ts

@@ -0,0 +1,104 @@
+import { RegisterClass } from '@memberjunction/global';
+import { BaseEntity, EntitySaveOptions } from '@memberjunction/core';
+import { EntityPermissionEntity } from '@memberjunction/core-entities';
+import axios from 'axios';
+import { ___codeGenAPIPort, ___codeGenAPISubmissionDelay, ___codeGenAPIURL } from '../config.js';
+
+/**
+ * Server-side only class that extends the entity permissions object to watch for changes to entity permissions, build a queue of entities that have been changed, and then from time to time, submit
+ * them to an API server that will execute the underlying permission changes at the database level.
+ */
+@RegisterClass(BaseEntity, 'Entity Permissions', 3)
+export class EntityPermissionsEntity_Server extends EntityPermissionEntity {
+  protected static _entityIDQueue: string[] = [];
+  protected static _lastModifiedTime: Date | null = null;
+  protected static _submissionTimer: NodeJS.Timeout | null = null;
+  protected static _submissionDelay: number = ___codeGenAPISubmissionDelay;
+  protected static _baseURL: string = ___codeGenAPIURL;
+  protected static _port: number = ___codeGenAPIPort;
+  protected static _apiEndpoint: string = '/api/entity-permissions';
+
+  // Method to construct the full URL dynamically
+  protected static getSubmissionURL(): string {
+    return `${this._baseURL}:${this._port}${this._apiEndpoint}`;
+  }
+
+  public static get EntityIDQueue(): string[] {
+    return this._entityIDQueue;
+  }
+
+  public static ClearQueue(): void {
+    this._entityIDQueue = [];
+    this._submissionTimer = null;
+  }
+  public static AddToQueue(entityID: string): void {
+    if (this._entityIDQueue.indexOf(entityID) === -1) this._entityIDQueue.push(entityID);
+    this._lastModifiedTime = new Date();
+    this.CheckStartSubmissionTimer();
+  }
+
+  protected static CheckStartSubmissionTimer(): void {
+    if (this._submissionTimer === null) {
+      this.StartSubmissionTimer();
+    } else {
+      // we need to cancel the existing timer and start a new one
+      clearTimeout(this._submissionTimer);
+      this.StartSubmissionTimer();
+    }
+  }
+
+  protected static StartSubmissionTimer(): void {
+    this._submissionTimer = setTimeout(() => {
+      this.SubmitQueue();
+    }, this._submissionDelay);
+  }
+
+  protected static async SubmitQueue(): Promise<void> {
+    this._lastModifiedTime = null;
+
+    // now, use Axios to submit the queue to the API server
+    // Check if there's anything to submit
+    if (this._entityIDQueue.length > 0) {
+      try {
+        // Use Axios to submit the queue to the API server
+        const response = await axios.post(this.getSubmissionURL(), {
+          entityIDArray: this._entityIDQueue,
+        });
+
+        // Check the Axios response code implicitly and API response explicitly
+        if (response.status === 200 && response.data.status === 'ok') {
+          console.log('Queue submitted successfully.');
+          // now, clear the queue and timer
+          this.ClearQueue();
+        } else {
+          // Handle API indicating a failure
+          console.error('Failed to submit queue:', response.data.errorMessage || 'Unknown error');
+        }
+      } catch (error) {
+        // Handle errors here
+        console.error('Failed to submit queue:', error);
+        // Consider re-trying or logging the error based on your requirements
+      }
+    } else {
+      console.log('No entities to submit.');
+    }
+  }
+
+  override Save(options?: EntitySaveOptions): Promise<boolean> {
+    // simply queue up the entity ID
+    if (this.Dirty || options?.IgnoreDirtyState) EntityPermissionsEntity_Server.AddToQueue(this.EntityID);
+
+    return super.Save(options);
+  }
+
+  override async Delete(): Promise<boolean> {
+    const success = await super.Delete();
+
+    // simply queue up the entity ID if the delete worked
+    if (success) EntityPermissionsEntity_Server.AddToQueue(this.EntityID);
+
+    return success;
+  }
+}
+
+export function LoadEntityPermissionsServerSubClass() {}

package/src/entitySubclasses/userViewEntity.server.ts

@@ -0,0 +1,187 @@
+import { CleanJSON, MJGlobal, RegisterClass } from "@memberjunction/global";
+import { BaseEntity, EntityInfo, LogError, Metadata } from "@memberjunction/core";
+import { AIModelEntity, AIModelEntityExtended, UserViewEntityExtended } from '@memberjunction/core-entities'
+import { BaseLLM, ChatParams, GetAIAPIKey } from "@memberjunction/ai";
+import { AIEngine } from "@memberjunction/aiengine";
+import { LoadOpenAILLM } from "@memberjunction/ai-openai";
+LoadOpenAILLM(); // this is to prevent tree shaking since the openai package is not directly used and rather instantiated dynamically in the LoadOpenAILLM function. Since no static code path exists tree shaking can result in this class being optimized out
+
+@RegisterClass(BaseEntity, 'User Views')  
+export class UserViewEntity_Server extends UserViewEntityExtended  {
+    /**
+     * This property is hard-coded to true in this class because we DO support smart filters in this class. If you want to disable smart filters for a specific view you can override this property in your subclass and set it to false.
+     */
+    protected override get SmartFilterImplemented(): boolean {
+        return true;
+    }
+
+    /**
+     * Default implementation simply returns 'OpenAI' - override this in your subclass if you are using a different AI vendor.
+     * @returns 
+     */
+    protected get AIVendorName(): string {
+        return 'OpenAI';
+    }
+
+    /**
+     * Default implementation simply grabs the first AI model that matches GetAIModelName().
+     * @returns 
+     */
+    protected async GetAIModel(): Promise<AIModelEntityExtended> {
+        await AIEngine.Instance.Config(false, this.ContextCurrentUser); // most of the time this is already loaded, but just in case it isn't we will load it here
+        const models = AIEngine.Instance.Models.filter(m => m.AIModelType.trim().toLowerCase() === 'llm' && 
+                                                   m.Vendor.trim().toLowerCase() === this.AIVendorName.trim().toLowerCase())  
+        // next, sort the models by the PowerRank field so that the highest power rank model is the first array element
+        models.sort((a, b) => b.PowerRank - a.PowerRank); // highest power rank first
+        return models[0];
+    }
+
+    /** 
+     * This method will use AI to return a valid WHERE clause based on the provided prompt. This is automatically called at the right time if the view has SmartFilterEnabled turned on and the SmartFilterPrompt is set. If you want
+     * to call this directly to get back a WHERE clause for other purposes you can call this method directly and provide both a prompt and the entity that the view is based on.
+     * @param prompt 
+     */
+    public async GenerateSmartFilterWhereClause(prompt: string, entityInfo: EntityInfo): Promise<{whereClause: string, userExplanation: string}> {
+        try {
+            const model = await this.GetAIModel();
+            const llm = MJGlobal.Instance.ClassFactory.CreateInstance<BaseLLM>(BaseLLM, model.DriverClass, GetAIAPIKey(model.DriverClass)); 
+
+            const chatParams: ChatParams = {
+                model: model.APINameOrName,
+                messages: [      
+                    {
+                        role: 'system',
+                        content: this.GenerateSysPrompt(entityInfo)
+                    },
+                    {
+                        role: 'user',
+                        content: `${prompt}`,
+                    },
+                ],
+            }
+            const result = await llm.ChatCompletion(chatParams);
+            if (result && result.data) {
+                const llmResponse = result.data.choices[0].message.content;
+                if (llmResponse) {
+                    // try to parse it as JSON
+                    try {
+                        const cleansed = CleanJSON(llmResponse);
+                        if (!cleansed)
+                            throw new Error('Invalid JSON response from AI: ' + llmResponse);
+
+                        const parsed = JSON.parse(cleansed);
+                        if (parsed.whereClause && parsed.whereClause.length > 0) {
+                            // we have the where clause. Sometimes the LLM prefixes it with WHERE and somtimes not, we need to strip WHERE if it is there
+                            const trimmed = parsed.whereClause.trim();
+                            let ret: string = '';
+                            if (trimmed.toLowerCase().startsWith('where '))
+                                ret = trimmed.substring(6);
+                            else
+                                ret = parsed.whereClause;
+
+                            return  { 
+                                        whereClause: ret, 
+                                        userExplanation: parsed.userExplanationMessage
+                                    };
+                        }
+                        else if (parsed.whereClause !== undefined && parsed.whereClause !== null) {
+                            return  { 
+                                whereClause: '',  // empty string is valid, it means no where clause
+                                userExplanation: parsed.userExplanationMessage
+                            };
+                        }
+                        else {
+                            // if we get here, no whereClause property was provided by the LLM, that is an error
+                            throw new Error('Invalid response from AI, no whereClause property found in response: ' + llmResponse);
+                        }
+                    }
+                    catch (e) {
+                        LogError(e);
+                        throw new Error('Error parsing JSON response from AI: ' + llmResponse);
+                    }
+                }
+                else 
+                    throw new Error('Null response from AI');
+            }
+            else
+                throw new Error('No result returned from AI');
+        }
+        catch (e) {
+            LogError(e);
+            throw e;
+        }
+    }
+
+    public GenerateSysPrompt(entityInfo: EntityInfo): string {
+        const processedViews: string[] = [entityInfo.BaseView];
+        const md = new Metadata();
+        const gptSysPrompt: string = `You are an expert in SQL and Microsoft SQL Server.
+You will be provided a user prompt representing how they want to filter the data.
+You may *NOT* use JOINS, only sub-queries for related tables. 
+
+I am a bot and can only understand JSON. Your response must be parsable into this type:
+const returnType = {
+    whereClause: string,
+    orderByClause: string
+    userExplanationMessage: string
+};
+
+The view that the user is querying is called ${entityInfo.BaseView} and has these fields:
+${entityInfo.Fields.map(f => {
+    let ret: string = `${f.Name} (${f.Type})`;
+    if (f.RelatedEntity) {
+        ret += ` (fkey to ${f.RelatedEntityBaseView})`;
+    }
+    return ret;
+}).join(',')}`
+
+        const fkeyFields = entityInfo.Fields.filter(f => f.RelatedEntity && f.RelatedEntity.length > 0);
+        const fkeyBaseViewsDistinct = fkeyFields.map(f => f.RelatedEntityBaseView).filter((v, i, a) => a.indexOf(v) === i);
+        const relationships: string = `
+In addition, ${entityInfo.BaseView} has links to other views, as shown here, you can use these views in sub-queries to achieve the request from the user.
+If there are multiple filters related to a single related view, attempt to combine them into a single sub-query for efficiency.
+${
+    // this part returns a list of all the related views and the fields that are related to the current view via fkeys in the current view
+    fkeyBaseViewsDistinct.map(v => {
+        if (processedViews.indexOf(v) === -1) {
+            const e = md.Entities.find(e => e.BaseView === v);
+            if (e) {
+                processedViews.push(v); // already processed this view now, so we won't repeat it
+                return `* ${e.SchemaName}.${e.BaseView}: ${e.Fields.map(ef => {
+                    return ef.Name + ' (' + ef.Type + ')';
+                }).join(',') }`
+            }
+            else
+                return '';    
+        }
+        else 
+            return ''; // already did this at some point
+    }).join('\n')
+}
+${
+    // this part returns a list of all the related views and the fields that are related to the current view fkeys in THOSE views
+    entityInfo.RelatedEntities.map(r => {
+        const e = md.Entities.find(e => e.Name === r.RelatedEntity);
+        if (e) {
+            if (processedViews.indexOf(e.BaseView) === -1) {
+                processedViews.push(e.BaseView); // note that we are processing this view now, so we won't repeat it
+                return `* ${e.SchemaName}.${e.BaseView}: ${e.Fields.map(ef => {
+                    let ret: string = `${ef.Name} (${ef.Type})`;
+                    if (ef.RelatedEntity) {
+                        ret += ` (fkey to ${ef.RelatedEntityBaseView})`;
+                    }
+                    return ret;
+                }).join(',') }`    
+            }
+            else
+                return ''; // already did this at some point
+        }
+        else
+            return '';
+    }).join('\n')
+}`
+
+        return gptSysPrompt + (processedViews.length > 1 /*we always have 1 from the entity base view*/ ? relationships : '') + `
+        **** REMEMBER **** I am a BOT, do not return anything other than JSON to me or I will choke on your response!`;
+    }    
+}