@memberjunction/server 2.89.0 → 2.91.0

package/src/auth/providers/Auth0Provider.ts

@@ -0,0 +1,45 @@
+import { JwtPayload } from 'jsonwebtoken';
+import { RegisterClass } from '@memberjunction/global';
+import { AuthProviderConfig, AuthUserInfo } from '@memberjunction/core';
+import { BaseAuthProvider } from '../BaseAuthProvider.js';
+
+/**
+ * Auth0 authentication provider implementation
+ */
+@RegisterClass(BaseAuthProvider, 'auth0')
+export class Auth0Provider extends BaseAuthProvider {
+  constructor(config: AuthProviderConfig) {
+    super(config);
+  }
+
+  /**
+   * Extracts user information from Auth0 JWT payload
+   */
+  extractUserInfo(payload: JwtPayload): AuthUserInfo {
+    // Auth0 uses standard OIDC claims
+    const email = payload.email as string | undefined;
+    const fullName = payload.name as string | undefined;
+    const firstName = payload.given_name as string | undefined;
+    const lastName = payload.family_name as string | undefined;
+    const preferredUsername = payload.preferred_username as string | undefined || email;
+
+    return {
+      email,
+      firstName: firstName || fullName?.split(' ')[0],
+      lastName: lastName || fullName?.split(' ')[1] || fullName?.split(' ')[0],
+      fullName,
+      preferredUsername
+    };
+  }
+
+  /**
+   * Validates Auth0-specific configuration
+   */
+  validateConfig(): boolean {
+    const baseValid = super.validateConfig();
+    const hasClientId = !!this.config.clientId;
+    const hasDomain = !!this.config.domain;
+    
+    return baseValid && hasClientId && hasDomain;
+  }
+}

package/src/auth/providers/CognitoProvider.ts

@@ -0,0 +1,50 @@
+import { JwtPayload } from 'jsonwebtoken';
+import { RegisterClass } from '@memberjunction/global';
+import { AuthProviderConfig, AuthUserInfo } from '@memberjunction/core';
+import { BaseAuthProvider } from '../BaseAuthProvider.js';
+
+
+/**
+ * AWS Cognito authentication provider implementation
+ */
+@RegisterClass(BaseAuthProvider, 'cognito')
+export class CognitoProvider extends BaseAuthProvider {
+  constructor(config: AuthProviderConfig) {
+    super(config);
+  }
+
+  /**
+   * Extracts user information from Cognito JWT payload
+   */
+  extractUserInfo(payload: JwtPayload): AuthUserInfo {
+    // Cognito uses custom claims with 'cognito:' prefix for some fields
+    const email = payload.email as string | undefined || 
+                  payload['cognito:username'] as string | undefined;
+    const fullName = payload.name as string | undefined;
+    const firstName = payload.given_name as string | undefined;
+    const lastName = payload.family_name as string | undefined;
+    const preferredUsername = payload['cognito:username'] as string | undefined || 
+                             payload.preferred_username as string | undefined || 
+                             email;
+
+    return {
+      email,
+      firstName: firstName || fullName?.split(' ')[0],
+      lastName: lastName || fullName?.split(' ')[1] || fullName?.split(' ')[0],
+      fullName,
+      preferredUsername
+    };
+  }
+
+  /**
+   * Validates Cognito-specific configuration
+   */
+  validateConfig(): boolean {
+    const baseValid = super.validateConfig();
+    const hasClientId = !!this.config.clientId;
+    const hasRegion = !!this.config.region;
+    const hasUserPoolId = !!this.config.userPoolId;
+    
+    return baseValid && hasClientId && hasRegion && hasUserPoolId;
+  }
+}

package/src/auth/providers/GoogleProvider.ts

@@ -0,0 +1,45 @@
+import { JwtPayload } from 'jsonwebtoken';
+import { RegisterClass } from '@memberjunction/global';
+import { AuthProviderConfig, AuthUserInfo } from '@memberjunction/core';
+import { BaseAuthProvider } from '../BaseAuthProvider.js';
+
+
+/**
+ * Google Identity Platform authentication provider implementation
+ */
+@RegisterClass(BaseAuthProvider, 'google')
+export class GoogleProvider extends BaseAuthProvider {
+  constructor(config: AuthProviderConfig) {
+    super(config);
+  }
+
+  /**
+   * Extracts user information from Google JWT payload
+   */
+  extractUserInfo(payload: JwtPayload): AuthUserInfo {
+    // Google uses standard OIDC claims
+    const email = payload.email as string | undefined;
+    const fullName = payload.name as string | undefined;
+    const firstName = payload.given_name as string | undefined;
+    const lastName = payload.family_name as string | undefined;
+    const preferredUsername = email; // Google typically uses email as username
+
+    return {
+      email,
+      firstName: firstName || fullName?.split(' ')[0],
+      lastName: lastName || fullName?.split(' ')[1] || fullName?.split(' ')[0],
+      fullName,
+      preferredUsername
+    };
+  }
+
+  /**
+   * Validates Google-specific configuration
+   */
+  validateConfig(): boolean {
+    const baseValid = super.validateConfig();
+    const hasClientId = !!this.config.clientId;
+    
+    return baseValid && hasClientId;
+  }
+}

package/src/auth/providers/MSALProvider.ts

@@ -0,0 +1,45 @@
+import { JwtPayload } from 'jsonwebtoken';
+import { RegisterClass } from '@memberjunction/global';
+import { AuthProviderConfig, AuthUserInfo } from '@memberjunction/core';
+import { BaseAuthProvider } from '../BaseAuthProvider.js';
+
+/**
+ * Microsoft Authentication Library (MSAL) provider implementation
+ */
+@RegisterClass(BaseAuthProvider, 'msal')
+export class MSALProvider extends BaseAuthProvider {
+  constructor(config: AuthProviderConfig) {
+    super(config);
+  }
+
+  /**
+   * Extracts user information from MSAL/Azure AD JWT payload
+   */
+  extractUserInfo(payload: JwtPayload): AuthUserInfo {
+    // MSAL/Azure AD uses some custom claims
+    const email = payload.email as string | undefined || payload.preferred_username as string | undefined;
+    const fullName = payload.name as string | undefined;
+    const firstName = payload.given_name as string | undefined;
+    const lastName = payload.family_name as string | undefined;
+    const preferredUsername = payload.preferred_username as string | undefined;
+
+    return {
+      email,
+      firstName: firstName || fullName?.split(' ')[0],
+      lastName: lastName || fullName?.split(' ')[1] || fullName?.split(' ')[0],
+      fullName,
+      preferredUsername
+    };
+  }
+
+  /**
+   * Validates MSAL-specific configuration
+   */
+  validateConfig(): boolean {
+    const baseValid = super.validateConfig();
+    const hasClientId = !!this.config.clientId;
+    const hasTenantId = !!this.config.tenantId;
+    
+    return baseValid && hasClientId && hasTenantId;
+  }
+}

package/src/auth/providers/OktaProvider.ts

@@ -0,0 +1,46 @@
+import { JwtPayload } from 'jsonwebtoken';
+import { RegisterClass } from '@memberjunction/global';
+import { AuthProviderConfig, AuthUserInfo } from '@memberjunction/core';
+import { BaseAuthProvider } from '../BaseAuthProvider.js';
+
+
+/**
+ * Okta authentication provider implementation
+ */
+@RegisterClass(BaseAuthProvider, 'okta')
+export class OktaProvider extends BaseAuthProvider {
+  constructor(config: AuthProviderConfig) {
+    super(config);
+  }
+
+  /**
+   * Extracts user information from Okta JWT payload
+   */
+  extractUserInfo(payload: JwtPayload): AuthUserInfo {
+    // Okta uses standard OIDC claims plus some custom ones
+    const email = payload.email as string | undefined || payload.preferred_username as string | undefined;
+    const fullName = payload.name as string | undefined;
+    const firstName = payload.given_name as string | undefined;
+    const lastName = payload.family_name as string | undefined;
+    const preferredUsername = payload.preferred_username as string | undefined || email;
+
+    return {
+      email,
+      firstName: firstName || fullName?.split(' ')[0],
+      lastName: lastName || fullName?.split(' ')[1] || fullName?.split(' ')[0],
+      fullName,
+      preferredUsername
+    };
+  }
+
+  /**
+   * Validates Okta-specific configuration
+   */
+  validateConfig(): boolean {
+    const baseValid = super.validateConfig();
+    const hasClientId = !!this.config.clientId;
+    const hasDomain = !!this.config.domain;
+    
+    return baseValid && hasClientId && hasDomain;
+  }
+}

package/src/config.ts

@@ -102,6 +102,18 @@ const sqlLoggingSchema = z.object({
   sessionTimeout: z.number().optional().default(3600000), // 1 hour
 });
 
+const authProviderSchema = z.object({
+  name: z.string(),
+  type: z.string(),
+  issuer: z.string(),
+  audience: z.string(),
+  jwksUri: z.string(),
+  clientId: z.string().optional(),
+  clientSecret: z.string().optional(),
+  tenantId: z.string().optional(),
+  domain: z.string().optional(),
+}).passthrough(); // Allow additional provider-specific fields
+
 const configInfoSchema = z.object({
   userHandling: userHandlingInfoSchema,
   databaseSettings: databaseSettingsInfoSchema,
@@ -109,6 +121,7 @@ const configInfoSchema = z.object({
   restApiOptions: restApiOptionsSchema.optional().default({}),
   askSkip: askSkipInfoSchema.optional(),
   sqlLogging: sqlLoggingSchema.optional(),
+  authProviders: z.array(authProviderSchema).optional(),
 
   apiKey: z.string().optional(),
   baseUrl: z.string().default('http://localhost'),
@@ -131,17 +144,12 @@ const configInfoSchema = z.object({
   ___codeGenAPIPort: z.coerce.number().optional().default(3999),
   ___codeGenAPISubmissionDelay: z.coerce.number().optional().default(5000),
   graphqlRootPath: z.string().optional().default('/'),
-  webClientID: z.string().optional(),
-  tenantID: z.string().optional(),
   enableIntrospection: z.coerce.boolean().optional().default(false),
   websiteRunFromPackage: z.coerce.number().optional(),
   userEmailMap: z
     .string()
     .transform((val) => z.record(z.string()).parse(JSON.parse(val)))
     .optional(),
-  auth0Domain: z.string().optional(),
-  auth0WebClientID: z.string().optional(),
-  auth0ClientSecret: z.string().optional(),
   mjCoreSchema: z.string(),
 });
 
@@ -152,6 +160,7 @@ export type RESTApiOptions = z.infer<typeof restApiOptionsSchema>;
 export type AskSkipInfo = z.infer<typeof askSkipInfoSchema>;
 export type SqlLoggingOptions = z.infer<typeof sqlLoggingOptionsSchema>;
 export type SqlLoggingInfo = z.infer<typeof sqlLoggingSchema>;
+export type AuthProviderConfig = z.infer<typeof authProviderSchema>;
 export type ConfigInfo = z.infer<typeof configInfoSchema>;
 
 export const configInfo: ConfigInfo = loadConfig();
@@ -169,14 +178,9 @@ export const {
   ___codeGenAPIPort,
   ___codeGenAPISubmissionDelay,
   graphqlRootPath,
-  webClientID,
-  tenantID,
   enableIntrospection,
   websiteRunFromPackage,
   userEmailMap,
-  auth0Domain,
-  auth0WebClientID,
-  auth0ClientSecret,
   apiKey,
   baseUrl,
   mjCoreSchema: mj_core_schema,

package/src/context.ts

@@ -5,24 +5,33 @@ import 'reflect-metadata';
 import { Subject, firstValueFrom } from 'rxjs';
 import { AuthenticationError, AuthorizationError } from 'type-graphql';
 import sql from 'mssql';
-import { getSigningKeys, getSystemUser, validationOptions, verifyUserRecord } from './auth/index.js';
+import { getSigningKeys, getSystemUser, getValidationOptions, verifyUserRecord, extractUserInfoFromPayload, TokenExpiredError } from './auth/index.js';
 import { authCache } from './cache.js';
 import { userEmailMap, apiKey, mj_core_schema } from './config.js';
 import { DataSourceInfo, UserPayload } from './types.js';
-import { TokenExpiredError } from './auth/index.js';
 import { GetReadOnlyDataSource, GetReadWriteDataSource } from './util.js';
 import { v4 as uuidv4 } from 'uuid';
 import e from 'express';
 import { DatabaseProviderBase } from '@memberjunction/core';
 import { SQLServerDataProvider, SQLServerProviderConfigData } from '@memberjunction/sqlserver-dataprovider';
+import { AuthProviderFactory } from './auth/AuthProviderFactory.js';
 
-const verifyAsync = async (issuer: string, options: jwt.VerifyOptions, token: string): Promise<jwt.JwtPayload> =>
+const verifyAsync = async (issuer: string, token: string): Promise<jwt.JwtPayload> =>
   new Promise((resolve, reject) => {
+    const options = getValidationOptions(issuer);
+    
+    if (!options) {
+      reject(new Error(`No validation options found for issuer ${issuer}`));
+      return;
+    }
+
     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
+        // Use provider to extract user info for logging
+        const userInfo = extractUserInfoFromPayload(payload);
+        console.log(`Valid token: ${userInfo.fullName || 'Unknown'} (${userInfo.email || userInfo.preferredUsername || 'Unknown'})`);
         resolve(payload);
       } else {
         console.warn('Invalid token');
@@ -81,15 +90,28 @@ export const getUserPayload = async (
         throw new AuthenticationError('Missing issuer claim on token');
       }
 
-      await verifyAsync(issuer, validationOptions[issuer], token);
+      // Verify issuer is supported
+      const factory = AuthProviderFactory.getInstance();
+      if (!factory.getByIssuer(issuer)) {
+        console.warn(`Unsupported issuer: ${issuer}`);
+        throw new AuthenticationError(`Unsupported authentication provider: ${issuer}`);
+      }
+
+      await verifyAsync(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, readWriteDataSource);
+    // Use provider to extract user information
+    const userInfo = extractUserInfoFromPayload(payload);
+    const email = userInfo.email ? ((userEmailMap ?? {})[userInfo.email] ?? userInfo.email) : userInfo.preferredUsername;
+    
+    const userRecord = await verifyUserRecord(
+      email, 
+      userInfo.firstName, 
+      userInfo.lastName, 
+      requestDomain, 
+      readWriteDataSource
+    );
 
     if (!userRecord) {
       console.error(`User ${email} not found`);
@@ -99,12 +121,13 @@ export const getUserPayload = async (
       throw new AuthorizationError();
     }
 
-    return { userRecord, email, sessionId };
-  } catch (e) {
-    console.error(e);
-    if (e instanceof TokenExpiredError) {
-      throw e;
-    } else return {} as UserPayload;
+    return { userRecord, email: userRecord.Email, sessionId };
+  } catch (error) {
+    console.error(error);
+    if (error instanceof TokenExpiredError) {
+      throw error;
+    }
+    throw new AuthenticationError('Unable to authenticate user');
   }
 };
 
@@ -171,4 +194,4 @@ export const contextFunction =
     };
     
     return contextResult;
-  };
+  };

package/src/generated/generated.ts

@@ -37957,6 +37957,15 @@ export class Component_ {
     @Field(() => Int, {description: `Number of component dependencies defined in the specification. Used to assess component complexity.`}) 
     DependencyCount: number;
         
+    @Field({nullable: true, description: `The ID of the AI model used to generate the vector embedding for the technical design`}) 
+    TechnicalDesignVectorEmbeddingModelID?: string;
+        
+    @Field({nullable: true, description: `The ID of the AI model used to generate the vector embedding for the functional requirements`}) 
+    FunctionalRequirementsVectorEmbeddingModelID?: string;
+        
+    @Field(() => Boolean, {description: `Indicates whether the component has any custom properties that are marked as required. This is auto-calculated based on the component's properties array to identify components with mandatory custom configuration.`}) 
+    HasRequiredCustomProps: boolean;
+        
     @Field({nullable: true}) 
     @MaxLength(510)
     SourceRegistry?: string;
@@ -38048,6 +38057,15 @@ export class CreateComponentInput {
 
     @Field(() => Int, { nullable: true })
     DependencyCount?: number;
+
+    @Field({ nullable: true })
+    TechnicalDesignVectorEmbeddingModelID: string | null;
+
+    @Field({ nullable: true })
+    FunctionalRequirementsVectorEmbeddingModelID: string | null;
+
+    @Field(() => Boolean, { nullable: true })
+    HasRequiredCustomProps?: boolean;
 }
     
 
@@ -38128,6 +38146,15 @@ export class UpdateComponentInput {
     @Field(() => Int, { nullable: true })
     DependencyCount?: number;
 
+    @Field({ nullable: true })
+    TechnicalDesignVectorEmbeddingModelID?: string | null;
+
+    @Field({ nullable: true })
+    FunctionalRequirementsVectorEmbeddingModelID?: string | null;
+
+    @Field(() => Boolean, { nullable: true })
+    HasRequiredCustomProps?: boolean;
+
     @Field(() => [KeyValuePairInput], { nullable: true })
     OldValues___?: KeyValuePairInput[];
 }
@@ -39108,6 +39135,10 @@ export class ComponentLibrary_ {
     @MaxLength(10)
     _mj__UpdatedAt: Date;
         
+    @Field({description: `Status of the component library. Active: fully supported; Deprecated: works but shows console warning; Disabled: throws error if used`}) 
+    @MaxLength(40)
+    Status: string;
+        
     @Field(() => [ComponentLibraryLink_])
     MJ_ComponentLibraryLinks_LibraryIDArray: ComponentLibraryLink_[]; // Link to MJ_ComponentLibraryLinks
     
@@ -39144,6 +39175,9 @@ export class CreateComponentLibraryInput {
 
     @Field({ nullable: true })
     Description: string | null;
+
+    @Field({ nullable: true })
+    Status?: string;
 }
     
 
@@ -39179,6 +39213,9 @@ export class UpdateComponentLibraryInput {
     @Field({ nullable: true })
     Description?: string | null;
 
+    @Field({ nullable: true })
+    Status?: string;
+
     @Field(() => [KeyValuePairInput], { nullable: true })
     OldValues___?: KeyValuePairInput[];
 }

package/src/generic/ResolverBase.ts

@@ -16,7 +16,7 @@ import {
   RunViewResult,
   UserInfo,
 } from '@memberjunction/core';
-import { AuditLogEntity, ErrorLogEntity, UserViewEntity } from '@memberjunction/core-entities';
+import { AuditLogEntity, ErrorLogEntity, UserViewEntityExtended } from '@memberjunction/core-entities';
 import { SQLServerDataProvider, UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { PubSubEngine } from 'type-graphql';
 import { GraphQLError } from 'graphql';
@@ -117,7 +117,7 @@ export class ResolverBase {
   async RunViewByNameGeneric(viewInput: RunViewByNameInput, provider: DatabaseProviderBase, userPayload: UserPayload, pubSub: PubSubEngine) {
     try {
       const rv = provider as any as IRunViewProvider;
-      const result = await rv.RunView<UserViewEntity>({
+      const result = await rv.RunView<UserViewEntityExtended>({
         EntityName: 'User Views',
         ExtraFilter: "Name='" + viewInput.ViewName + "'",
       }, userPayload.userRecord);
@@ -139,7 +139,8 @@ export class ResolverBase {
           viewInput.AuditLogDescription,
           viewInput.ResultType,
           userPayload,
-          viewInput.MaxRows
+          viewInput.MaxRows,
+          viewInput.StartRow
         );
       }
       else {
@@ -155,7 +156,7 @@ export class ResolverBase {
   async RunViewByIDGeneric(viewInput: RunViewByIDInput, provider: DatabaseProviderBase, userPayload: UserPayload, pubSub: PubSubEngine) {
     try {
       const contextUser = this.GetUserFromPayload(userPayload);
-      const viewInfo = await provider.GetEntityObject<UserViewEntity>('User Views', contextUser);
+      const viewInfo = await provider.GetEntityObject<UserViewEntityExtended>('User Views', contextUser);
       await viewInfo.Load(viewInput.ViewID);
       return this.RunViewGenericInternal(
         provider,
@@ -173,7 +174,8 @@ export class ResolverBase {
         viewInput.AuditLogDescription,
         viewInput.ResultType,
         userPayload,
-        viewInput.MaxRows
+        viewInput.MaxRows,
+        viewInput.StartRow
       );
     } catch (err) {
       console.log(err);
@@ -187,12 +189,12 @@ export class ResolverBase {
       const entity = md.Entities.find((e) => e.Name === viewInput.EntityName);
       if (!entity) throw new Error(`Entity ${viewInput.EntityName} not found in metadata`);
 
-      const viewInfo: UserViewEntity = {
+      const viewInfo: UserViewEntityExtended = {
         ID: '',
         Entity: viewInput.EntityName,
         EntityID: entity.ID,
         EntityBaseView: entity.BaseView as string,
-      } as UserViewEntity; // only providing a few bits of data here, but it's enough to get the view to run
+      } as UserViewEntityExtended; // only providing a few bits of data here, but it's enough to get the view to run
 
       return this.RunViewGenericInternal(
         provider,
@@ -210,7 +212,8 @@ export class ResolverBase {
         viewInput.AuditLogDescription,
         viewInput.ResultType,
         userPayload,
-        viewInput.MaxRows
+        viewInput.MaxRows,
+        viewInput.StartRow
       );
     } catch (err) {
       console.log(err);
@@ -228,12 +231,12 @@ export class ResolverBase {
     let params: RunViewGenericParams[] = [];
     for (const viewInput of viewInputs) {
       try {
-        let viewInfo: UserViewEntity | null = null;
+        let viewInfo: UserViewEntityExtended | null = null;
 
         if (viewInput.ViewName) {
           viewInfo = this.safeFirstArrayElement(await this.findBy(provider, 'User Views', { Name: viewInput.ViewName }, userPayload.userRecord));
         } else if (viewInput.ViewID) {
-          viewInfo = await provider.GetEntityObject<UserViewEntity>('User Views', contextUser);
+          viewInfo = await provider.GetEntityObject<UserViewEntityExtended>('User Views', contextUser);
           await viewInfo.Load(viewInput.ViewID);
         } else if (viewInput.EntityName) {
           const entity = md.Entities.find((e) => e.Name === viewInput.EntityName);
@@ -247,7 +250,7 @@ export class ResolverBase {
             Entity: viewInput.EntityName,
             EntityID: entity.ID,
             EntityBaseView: entity.BaseView,
-          } as UserViewEntity;
+          } as UserViewEntityExtended;
         } else {
           throw new Error('Unable to determine input type');
         }
@@ -356,7 +359,7 @@ export class ResolverBase {
    */
   protected async RunViewGenericInternal(
     provider: DatabaseProviderBase,
-    viewInfo: UserViewEntity,
+    viewInfo: UserViewEntityExtended,
     extraFilter: string,
     orderBy: string,
     userSearchString: string,
@@ -370,7 +373,8 @@ export class ResolverBase {
     auditLogDescription: string | undefined,
     resultType: string | undefined,
     userPayload: UserPayload | null,
-    maxRows: number | undefined
+    maxRows: number | undefined,
+    startRow: number | undefined
   ) {
     try {
       if (!viewInfo || !userPayload) return null;
@@ -420,6 +424,7 @@ export class ResolverBase {
           ExcludeDataFromAllPriorViewRuns: excludeDataFromAllPriorViewRuns,
           IgnoreMaxRows: ignoreMaxRows,
           MaxRows: maxRows,
+          StartRow: startRow,
           ForceAuditLog: forceAuditLog,
           AuditLogDescription: auditLogDescription,
           ResultType: rt,

package/src/generic/RunViewResolver.ts

@@ -4,7 +4,7 @@ import { ResolverBase } from './ResolverBase.js';
 import { LogError, LogStatus } from '@memberjunction/core';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { GetReadOnlyProvider } from '../util.js';
-import { UserViewEntity } from '@memberjunction/core-entities';
+import { UserViewEntityExtended } from '@memberjunction/core-entities';
 
 /********************************************************************************
  * The PURPOSE of this resolver is to provide a generic way to run a view and return the results.
@@ -468,7 +468,7 @@ export class RunViewResolver extends ResolverBase {
       if (rawData === null) 
         return null;
 
-      const viewInfo = super.safeFirstArrayElement<UserViewEntity>(await super.findBy<UserViewEntity>(provider, "User Views", { Name: input.ViewName }, userPayload.userRecord));
+      const viewInfo = super.safeFirstArrayElement<UserViewEntityExtended>(await super.findBy<UserViewEntityExtended>(provider, "User Views", { Name: input.ViewName }, userPayload.userRecord));
       const returnData = this.processRawData(rawData.Results, viewInfo.EntityID);
       return {
         Results: returnData,
@@ -495,7 +495,7 @@ export class RunViewResolver extends ResolverBase {
       if (rawData === null) 
         return null;
 
-      const viewInfo = super.safeFirstArrayElement<UserViewEntity>(await super.findBy<UserViewEntity>(provider, "User Views", { ID: input.ViewID }, userPayload.userRecord));
+      const viewInfo = super.safeFirstArrayElement<UserViewEntityExtended>(await super.findBy<UserViewEntityExtended>(provider, "User Views", { ID: input.ViewID }, userPayload.userRecord));
       const returnData = this.processRawData(rawData.Results, viewInfo.EntityID);
       return {
         Results: returnData,
@@ -613,7 +613,7 @@ export class RunViewResolver extends ResolverBase {
       const rawData = await super.RunViewByIDGeneric(input, provider, userPayload, pubSub);
       if (rawData === null) return null;
 
-      const viewInfo = super.safeFirstArrayElement<UserViewEntity>(await super.findBy<UserViewEntity>(provider, "User Views", { ID: input.ViewID }, userPayload.userRecord));
+      const viewInfo = super.safeFirstArrayElement<UserViewEntityExtended>(await super.findBy<UserViewEntityExtended>(provider, "User Views", { ID: input.ViewID }, userPayload.userRecord));
       const returnData = this.processRawData(rawData.Results, viewInfo.EntityID);
       return {
         Results: returnData,

package/src/resolvers/AskSkipResolver.ts

@@ -1441,6 +1441,9 @@ cycle.`);
         createdAt: q.__mj_CreatedAt,
         updatedAt: q.__mj_UpdatedAt,
         categoryID: q.CategoryID,
+        embeddingVector: q.EmbeddingVector,
+        embeddingModelID: q.EmbeddingModelID,
+        embeddingModelName: q.EmbeddingModel,
         fields: q.Fields.map((f) => {
           return {
             id: f.ID,

package/src/resolvers/RunAIAgentResolver.ts

@@ -1,7 +1,7 @@
 import { Resolver, Mutation, Arg, Ctx, ObjectType, Field, PubSub, PubSubEngine, Subscription, Root, ResolverFilterData, ID } from 'type-graphql';
 import { UserPayload } from '../types.js';
 import { LogError, LogStatus } from '@memberjunction/core';
-import { AIAgentEntity } from '@memberjunction/core-entities';
+import { AIAgentEntityExtended } from '@memberjunction/core-entities';
 import { AgentRunner } from '@memberjunction/ai-agents';
 import { ExecuteAgentResult } from '@memberjunction/ai-core-plus';
 import { AIEngine } from '@memberjunction/aiengine';
@@ -169,12 +169,12 @@ export class RunAIAgentResolver extends ResolverBase {
     /**
      * Validate the agent entity
      */
-    private async validateAgent(agentId: string, currentUser: any): Promise<AIAgentEntity> {
+    private async validateAgent(agentId: string, currentUser: any): Promise<AIAgentEntityExtended> {
         // Use AIEngine to get cached agent data
         await AIEngine.Instance.Config(false, currentUser);
         
         // Find agent in cached collection
-        const agentEntity = AIEngine.Instance.Agents.find((a: AIAgentEntity) => a.ID === agentId);
+        const agentEntity = AIEngine.Instance.Agents.find((a: AIAgentEntityExtended) => a.ID === agentId);
         
         if (!agentEntity) {
             throw new Error(`AI Agent with ID ${agentId} not found`);