@memberjunction/server 2.47.0 → 2.49.0

package/src/generic/ResolverBase.ts

@@ -17,7 +17,7 @@ import { AuditLogEntity, UserViewEntity } from '@memberjunction/core-entities';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { PubSubEngine } from 'type-graphql';
 import { GraphQLError } from 'graphql';
-import { DataSource } from 'typeorm';
+import sql from 'mssql';
 import { httpTransport, CloudEvent, emitterFor } from 'cloudevents';
 
 import { RunViewGenericParams, UserPayload } from '../types.js';
@@ -70,7 +70,7 @@ export class ResolverBase {
     return dataObject;
   }
 
-  protected ArrayMapFieldNamesToCodeNames(entityName: string, dataObjectArray: []) {
+  protected ArrayMapFieldNamesToCodeNames(entityName: string, dataObjectArray: any[]) {
     // iterate through the array and call MapFieldNamesToCodeNames for each element
     if (dataObjectArray && dataObjectArray.length > 0) {
       dataObjectArray.forEach((element) => {
@@ -80,29 +80,30 @@ export class ResolverBase {
     return dataObjectArray;
   }
 
-  protected async findBy(dataSource: DataSource, entity: string, params: any) {
+  protected async findBy(dataSource: sql.ConnectionPool, entity: string, params: any) {
     // build the SQL query based on the params passed in
     const md = new Metadata();
     const e = md.Entities.find((e) => e.Name === entity);
     if (!e) throw new Error(`Entity ${entity} not found in metadata`);
     // now build a SQL string using the entityInfo and using the properties in the params object
-    let sql = `SELECT * FROM ${e.SchemaName}.${e.BaseView} WHERE `;
+    let sqlQuery = `SELECT * FROM ${e.SchemaName}.${e.BaseView} WHERE `;
     const keys = Object.keys(params);
     keys.forEach((k, i) => {
-      if (i > 0) sql += ' AND ';
+      if (i > 0) sqlQuery += ' AND ';
       // look up the field in the entityInfo to see if it needs quotes
       const field = e.Fields.find((f) => f.Name === k);
       if (!field) throw new Error(`Field ${k} not found in entity ${entity}`);
       const quotes = field.NeedsQuotes ? "'" : '';
-      sql += `${k} = ${quotes}${params[k]}${quotes}`;
+      sqlQuery += `${k} = ${quotes}${params[k]}${quotes}`;
     });
 
     // ok, now we have a SQL string, run it and return the results
-    const result = await dataSource.query(sql);
-    return result;
+    const request = new sql.Request(dataSource);
+    const result = await request.query(sqlQuery);
+    return result.recordset;
   }
 
-  async RunViewByNameGeneric(viewInput: RunViewByNameInput, dataSource: DataSource, userPayload: UserPayload, pubSub: PubSubEngine) {
+  async RunViewByNameGeneric(viewInput: RunViewByNameInput, dataSource: sql.ConnectionPool, userPayload: UserPayload, pubSub: PubSubEngine) {
     try {
       const viewInfo: UserViewEntity = this.safeFirstArrayElement(
         await this.findBy(dataSource, 'User Views', { Name: viewInput.ViewName })
@@ -131,7 +132,7 @@ export class ResolverBase {
     }
   }
 
-  async RunViewByIDGeneric(viewInput: RunViewByIDInput, dataSource: DataSource, userPayload: UserPayload, pubSub: PubSubEngine) {
+  async RunViewByIDGeneric(viewInput: RunViewByIDInput, dataSource: sql.ConnectionPool, userPayload: UserPayload, pubSub: PubSubEngine) {
     try {
       const viewInfo: UserViewEntity = this.safeFirstArrayElement(await this.findBy(dataSource, 'User Views', { ID: viewInput.ViewID }));
       return this.RunViewGenericInternal(
@@ -158,7 +159,7 @@ export class ResolverBase {
     }
   }
 
-  async RunDynamicViewGeneric(viewInput: RunDynamicViewInput, dataSource: DataSource, userPayload: UserPayload, pubSub: PubSubEngine) {
+  async RunDynamicViewGeneric(viewInput: RunDynamicViewInput, dataSource: sql.ConnectionPool, userPayload: UserPayload, pubSub: PubSubEngine) {
     try {
       const md = new Metadata();
       const entity = md.Entities.find((e) => e.Name === viewInput.EntityName);
@@ -197,7 +198,7 @@ export class ResolverBase {
 
   async RunViewsGeneric(
     viewInputs: (RunViewByNameInput & RunViewByIDInput & RunDynamicViewInput)[],
-    dataSource: DataSource,
+    dataSource: sql.ConnectionPool,
     userPayload: UserPayload,
     pubSub: PubSubEngine
   ) {
@@ -332,7 +333,7 @@ export class ResolverBase {
    */
   protected async RunViewGenericInternal(
     viewInfo: UserViewEntity,
-    dataSource: DataSource,
+    dataSource: sql.ConnectionPool,
     extraFilter: string,
     orderBy: string,
     userSearchString: string,
@@ -660,7 +661,7 @@ export class ResolverBase {
     }
   }
 
-  protected async CreateRecord(entityName: string, input: any, dataSource: DataSource, userPayload: UserPayload, pubSub: PubSubEngine) {
+  protected async CreateRecord(entityName: string, input: any, dataSource: sql.ConnectionPool, userPayload: UserPayload, pubSub: PubSubEngine) {
     if (await this.BeforeCreate(dataSource, input)) {
       // fire event and proceed if it wasn't cancelled
       const entityObject = await new Metadata().GetEntityObject(entityName, this.GetUserFromPayload(userPayload));
@@ -680,12 +681,12 @@ export class ResolverBase {
   }
 
   // Before/After CREATE Event Hooks for Sub-Classes to Override
-  protected async BeforeCreate(dataSource: DataSource, input: any): Promise<boolean> {
+  protected async BeforeCreate(dataSource: sql.ConnectionPool, input: any): Promise<boolean> {
     return true;
   }
-  protected async AfterCreate(dataSource: DataSource, input: any) {}
+  protected async AfterCreate(dataSource: sql.ConnectionPool, input: any) {}
 
-  protected async UpdateRecord(entityName: string, input: any, dataSource: DataSource, userPayload: UserPayload, pubSub: PubSubEngine) {
+  protected async UpdateRecord(entityName: string, input: any, dataSource: sql.ConnectionPool, userPayload: UserPayload, pubSub: PubSubEngine) {
     if (await this.BeforeUpdate(dataSource, input)) {
       // fire event and proceed if it wasn't cancelled
       const md = new Metadata();
@@ -893,7 +894,7 @@ export class ResolverBase {
     entityName: string,
     key: CompositeKey,
     options: DeleteOptionsInput,
-    dataSource: DataSource,
+    dataSource: sql.ConnectionPool,
     userPayload: UserPayload,
     pubSub: PubSubEngine
   ) {
@@ -921,14 +922,14 @@ export class ResolverBase {
   }
 
   // Before/After DELETE Event Hooks for Sub-Classes to Override
-  protected async BeforeDelete(dataSource: DataSource, key: CompositeKey): Promise<boolean> {
+  protected async BeforeDelete(dataSource: sql.ConnectionPool, key: CompositeKey): Promise<boolean> {
     return true;
   }
-  protected async AfterDelete(dataSource: DataSource, key: CompositeKey) {}
+  protected async AfterDelete(dataSource: sql.ConnectionPool, key: CompositeKey) {}
 
   // Before/After UPDATE Event Hooks for Sub-Classes to Override
-  protected async BeforeUpdate(dataSource: DataSource, input: any): Promise<boolean> {
+  protected async BeforeUpdate(dataSource: sql.ConnectionPool, input: any): Promise<boolean> {
     return true;
   }
-  protected async AfterUpdate(dataSource: DataSource, input: any) {}
+  protected async AfterUpdate(dataSource: sql.ConnectionPool, input: any) {}
 }

package/src/generic/RunViewResolver.ts

@@ -463,7 +463,9 @@ export class RunViewResolver extends ResolverBase {
       const rawData = await super.RunViewByNameGeneric(input, dataSource, userPayload, pubSub);
       if (rawData === null) return null;
 
-      const entityId = await dataSource.query(`SELECT EntityID from [${this.MJCoreSchema}].vwUserViews WHERE Name='${input.ViewName}'`);
+      const request = dataSource.request();
+      const entityIdResult = await request.query(`SELECT EntityID from [${this.MJCoreSchema}].vwUserViews WHERE Name='${input.ViewName}'`);
+      const entityId = entityIdResult.recordset;
       const returnData = this.processRawData(rawData.Results, entityId[0].EntityID);
       return {
         Results: returnData,
@@ -488,7 +490,9 @@ export class RunViewResolver extends ResolverBase {
       const rawData = await super.RunViewByIDGeneric(input, dataSource, userPayload, pubSub);
       if (rawData === null) return null;
 
-      const entityId = await dataSource.query(`SELECT EntityID from [${this.MJCoreSchema}].vwUserViews WHERE ID=${input.ViewID}`);
+      const request = dataSource.request();
+      const entityIdResult = await request.query(`SELECT EntityID from [${this.MJCoreSchema}].vwUserViews WHERE ID=${input.ViewID}`);
+      const entityId = entityIdResult.recordset;
       const returnData = this.processRawData(rawData.Results, entityId[0].EntityID);
       return {
         Results: returnData,
@@ -513,7 +517,9 @@ export class RunViewResolver extends ResolverBase {
       const rawData = await super.RunDynamicViewGeneric(input, dataSource, userPayload, pubSub);
       if (rawData === null) return null;
 
-      const entityId = await dataSource.query(`SELECT ID from [${this.MJCoreSchema}].vwEntities WHERE Name='${input.EntityName}'`);
+      const request = dataSource.request();
+      const entityIdResult = await request.query(`SELECT ID from [${this.MJCoreSchema}].vwEntities WHERE Name='${input.EntityName}'`);
+      const entityId = entityIdResult.recordset;
       const returnData = this.processRawData(rawData.Results, entityId[0].EntityID);
       return {
         Results: returnData,
@@ -542,9 +548,11 @@ export class RunViewResolver extends ResolverBase {
 
       let results: RunViewGenericResult[] = [];
       for (const [index, data] of rawData.entries()) {
-        const entityId = await dataSource.query(
+        const request = dataSource.request();
+        const entityIdResult = await request.query(
           `SELECT TOP 1 ID from [${this.MJCoreSchema}].vwEntities WHERE Name='${input[index].EntityName}'`
         );
+        const entityId = entityIdResult.recordset;
         const returnData: any[] = this.processRawData(data.Results, entityId[0].ID);
 
         results.push({

package/src/index.ts

@@ -6,6 +6,7 @@ import { expressMiddleware } from '@apollo/server/express4';
 import { mergeSchemas } from '@graphql-tools/schema';
 import { Metadata } from '@memberjunction/core';
 import { setupSQLServerClient, SQLServerProviderConfigData, UserCache } from '@memberjunction/sqlserver-dataprovider';
+import { extendConnectionPoolWithQuery } from './util.js';
 import { default as BodyParser } from 'body-parser';
 import compression from 'compression'; // Add compression middleware
 import cors from 'cors';
@@ -18,13 +19,13 @@ import { sep } from 'node:path';
 import 'reflect-metadata';
 import { ReplaySubject } from 'rxjs';
 import { BuildSchemaOptions, buildSchemaSync, GraphQLTimestamp } from 'type-graphql';
-import { DataSource } from 'typeorm';
+import sql from 'mssql';
 import { WebSocketServer } from 'ws';
 import buildApolloServer from './apolloServer/index.js';
 import { configInfo, dbDatabase, dbHost, dbPort, dbUsername, graphqlPort, graphqlRootPath, mj_core_schema, websiteRunFromPackage, RESTApiOptions } from './config.js';
 import { contextFunction, getUserPayload } from './context.js';
 import { requireSystemUserDirective, publicDirective } from './directives/index.js';
-import orm from './orm.js';
+import createMSSQLConfig from './orm.js';
 import { setupRESTEndpoints } from './rest/setupRESTEndpoints.js';
 
 import { LoadActionEntityServer } from '@memberjunction/actions';
@@ -54,6 +55,7 @@ export * from './generic/ResolverBase.js';
 export * from './generic/RunViewResolver.js';
 export * from './resolvers/RunTemplateResolver.js';
 export * from './resolvers/RunAIPromptResolver.js';
+export * from './resolvers/RunAIAgentResolver.js';
 export * from './generic/KeyValuePairInput.js';
 export * from './generic/KeyInputOutputTypes.js';
 export * from './generic/DeleteOptionsInput.js';
@@ -105,31 +107,31 @@ export const serve = async (resolverPaths: Array<string>, app = createApp(), opt
     console.log({ combinedResolverPaths, paths, cwd: process.cwd() });
   }
 
-  const dataSource = new DataSource(orm(paths));
+  const pool = new sql.ConnectionPool(createMSSQLConfig());
   const setupComplete$ = new ReplaySubject(1);
-  await dataSource.initialize();
+  await pool.connect();
 
-  const config = new SQLServerProviderConfigData(dataSource, '', mj_core_schema, cacheRefreshInterval);
+  const config = new SQLServerProviderConfigData(pool, '', mj_core_schema, cacheRefreshInterval);
   await setupSQLServerClient(config); // datasource is already initialized, so we can setup the client right away
   const md = new Metadata();
   console.log(`Data Source has been initialized. ${md?.Entities ? md.Entities.length : 0} entities loaded.`);
 
-  const dataSources = [new DataSourceInfo({dataSource, type: 'Read-Write', host: dbHost, port: dbPort, database: dbDatabase, userName: dbUsername})];
+  const dataSources = [new DataSourceInfo({dataSource: pool, type: 'Read-Write', host: dbHost, port: dbPort, database: dbDatabase, userName: dbUsername})];
   
   // Establish a second read-only connection to the database if dbReadOnlyUsername and dbReadOnlyPassword exist
-  let readOnlyDataSource: DataSource | null = null;
+  let readOnlyPool: sql.ConnectionPool | null = null;
   if (configInfo.dbReadOnlyUsername && configInfo.dbReadOnlyPassword) {
     const readOnlyConfig = {
-      ...orm(paths),
-      username: configInfo.dbReadOnlyUsername,
+      ...createMSSQLConfig(),
+      user: configInfo.dbReadOnlyUsername,
       password: configInfo.dbReadOnlyPassword,
     };
-    readOnlyDataSource = new DataSource(readOnlyConfig);
-    await readOnlyDataSource.initialize();
+    readOnlyPool = new sql.ConnectionPool(readOnlyConfig);
+    await readOnlyPool.connect();
 
-    // since we created a read-only data source, add it to the list of data sources
-    dataSources.push(new DataSourceInfo({dataSource: readOnlyDataSource, type: 'Read-Only', host: dbHost, port: dbPort, database: dbDatabase, userName: configInfo.dbReadOnlyUsername}));
-    console.log('Read-only Data Source has been initialized.');
+    // since we created a read-only pool, add it to the list of data sources
+    dataSources.push(new DataSourceInfo({dataSource: readOnlyPool, type: 'Read-Only', host: dbHost, port: dbPort, database: dbDatabase, userName: configInfo.dbReadOnlyUsername}));
+    console.log('Read-only Connection Pool has been initialized.');
   }
 
   setupComplete$.next(true);
@@ -224,7 +226,7 @@ export const serve = async (resolverPaths: Array<string>, app = createApp(), opt
     expressMiddleware(apolloServer, {
       context: contextFunction({ 
                                  setupComplete$, 
-                                 dataSource, // default read-write data source
+                                 dataSource: extendConnectionPoolWithQuery(pool), // default read-write data source
                                  dataSources // all data source
                                }),
     })
@@ -288,5 +290,6 @@ export const serve = async (resolverPaths: Array<string>, app = createApp(), opt
   }
 
   await new Promise<void>((resolve) => httpServer.listen({ port: graphqlPort }, resolve));
+  console.log(`📦 Connected to database: ${dbHost}:${dbPort}/${dbDatabase}`);
   console.log(`🚀 Server ready at http://localhost:${graphqlPort}/`);
 };

package/src/orm.ts

@@ -1,36 +1,37 @@
-import { DataSourceOptions } from 'typeorm';
+import sql from 'mssql';
 import { configInfo, dbDatabase, dbHost, dbPassword, dbPort, dbUsername, dbInstanceName, dbTrustServerCertificate } from './config.js';
 
-const orm = (entities: Array<string>): DataSourceOptions => {
-  const ormConfig = {
-    type: 'mssql' as const,
-    entities,
-    logging: false,
-    host: dbHost,
+const createMSSQLConfig = (): sql.config => {
+  const mssqlConfig: sql.config = {
+    server: dbHost,
     port: dbPort,
-    username: dbUsername,
+    user: dbUsername,
     password: dbPassword,
     database: dbDatabase,
-    synchronize: false,
     requestTimeout: configInfo.databaseSettings.requestTimeout,
     connectionTimeout: configInfo.databaseSettings.connectionTimeout,
-    options: {},
+    options: {
+      encrypt: true, // Use encryption
+      enableArithAbort: true,
+    },
   };
+  
   if (dbInstanceName !== null && dbInstanceName !== undefined && dbInstanceName.trim().length > 0) {
-    ormConfig.options = {
-      ...ormConfig.options,
+    mssqlConfig.options = {
+      ...mssqlConfig.options,
       instanceName: dbInstanceName,
     };
   }
+  
   if (dbTrustServerCertificate !== null && dbTrustServerCertificate !== undefined) {
-    ormConfig.options = {
-      ...ormConfig.options,
+    mssqlConfig.options = {
+      ...mssqlConfig.options,
       trustServerCertificate: dbTrustServerCertificate === 'Y',
     };
   }
 
-  //console.log({ ormConfig: { ...ormConfig, password: '***' } });
-  return ormConfig;
+  //console.log({ mssqlConfig: { ...mssqlConfig, password: '***' } });
+  return mssqlConfig;
 };
 
-export default orm;
+export default createMSSQLConfig;

package/src/resolvers/AskSkipResolver.ts

@@ -53,8 +53,8 @@ import {
   UserNotificationEntity,
   AIAgentEntityExtended
 } from '@memberjunction/core-entities';
-import { DataSource } from 'typeorm';
 import { apiKey, baseUrl, configInfo, graphqlPort, mj_core_schema } from '../config.js';
+import mssql from 'mssql';
 
 import { registerEnumType } from 'type-graphql';
 import { MJGlobal, CopyScalarsAndArrays } from '@memberjunction/global';
@@ -882,7 +882,7 @@ cycle.`);
    */
   protected async buildBaseSkipRequest(
     contextUser: UserInfo,
-    dataSource: DataSource,
+    dataSource: mssql.ConnectionPool,
     includeEntities: boolean,
     includeQueries: boolean,
     includeNotes: boolean,
@@ -955,7 +955,7 @@ cycle.`);
     includeQueries: boolean,
     includeNotes: boolean,
     includeRequests: boolean,
-    dataSource: DataSource,
+    dataSource: mssql.ConnectionPool,
     contextUser: UserInfo,
     forceEntitiesRefresh: boolean = false,
     includeCallBackKeyAndAccessToken: boolean = false
@@ -1005,7 +1005,7 @@ cycle.`);
    */
   protected async BuildSkipLearningCycleNewConversations(
     lastLearningCycleDate: Date,
-    dataSource: DataSource,
+    dataSource: mssql.ConnectionPool,
     contextUser: UserInfo
   ): Promise<SkipConversation[]> {
     try {
@@ -1143,7 +1143,7 @@ cycle.`);
     includeNotes: boolean,
     includeRequests: boolean,
     contextUser: UserInfo,
-    dataSource: DataSource,
+    dataSource: mssql.ConnectionPool,
     forceEntitiesRefresh: boolean = false,
     includeCallBackKeyAndAccessToken: boolean = false
   ): Promise<SkipAPIRequest> {
@@ -1191,7 +1191,7 @@ cycle.`);
    * @param conversationId ID of the conversation
    * @returns Array of artifacts associated with the conversation
    */
-  protected async buildSkipAPIArtifacts(contextUser: UserInfo, dataSource: DataSource, conversationId: string): Promise<SkipAPIArtifact[]> {
+  protected async buildSkipAPIArtifacts(contextUser: UserInfo, dataSource: mssql.ConnectionPool, conversationId: string): Promise<SkipAPIArtifact[]> {
     const md = new Metadata();
     const ei = md.EntityByName('MJ: Conversation Artifacts');
     const rv = new RunView();
@@ -1507,7 +1507,7 @@ cycle.`);
    * @param dataSource Database connection
    * @returns Array of entity rows based on packing configuration
    */
-  protected async PackEntityRows(e: EntityInfo, dataSource: DataSource): Promise<any[]> {
+  protected async PackEntityRows(e: EntityInfo, dataSource: mssql.ConnectionPool): Promise<any[]> {
     try {
       if (e.RowsToPackWithSchema === 'None')
         return [];
@@ -1545,12 +1545,13 @@ cycle.`);
               break;
           }
       }
-      const result = await dataSource.query(sql);
-      if (!result) {
+      const request = new mssql.Request(dataSource);
+      const result = await request.query(sql);
+      if (!result || !result.recordset) {
         return [];
       }
       else {
-        return result;
+        return result.recordset;
       }
     }
     catch (e) {
@@ -1567,7 +1568,7 @@ cycle.`);
    * @param dataSource Database connection
    * @returns Array of possible values for the field
    */
-  protected async PackFieldPossibleValues(f: EntityFieldInfo, dataSource: DataSource): Promise<SkipEntityFieldValueInfo[]> {
+  protected async PackFieldPossibleValues(f: EntityFieldInfo, dataSource: mssql.ConnectionPool): Promise<SkipEntityFieldValueInfo[]> {
     try {
       if (f.ValuesToPackWithSchema === 'None') {
         return []; // don't pack anything
@@ -1617,15 +1618,16 @@ cycle.`);
    * @param dataSource Database connection
    * @returns Array of distinct values for the field
    */
-  protected async GetFieldDistinctValues(f: EntityFieldInfo, dataSource: DataSource): Promise<SkipEntityFieldValueInfo[]> {
+  protected async GetFieldDistinctValues(f: EntityFieldInfo, dataSource: mssql.ConnectionPool): Promise<SkipEntityFieldValueInfo[]> {
     try {
       const sql = `SELECT DISTINCT ${f.Name} FROM ${f.SchemaName}.${f.BaseView}`;
-      const result = await dataSource.query(sql);
-      if (!result) {
+      const request = new mssql.Request(dataSource);
+      const result = await request.query(sql);
+      if (!result || !result.recordset) {
         return [];
       }
       else {
-        return result.map((r) => {
+        return result.recordset.map((r) => {
           return {
             value: r[f.Name], 
             displayValue: r[f.Name]
@@ -1652,7 +1654,7 @@ cycle.`);
    * @param dataSource Database connection
    * @returns Updated array of entity information
    */
-  private async refreshSkipEntities(dataSource: DataSource): Promise<SkipEntityInfo[]> {
+  private async refreshSkipEntities(dataSource: mssql.ConnectionPool): Promise<SkipEntityInfo[]> {
     try {
       const md = new Metadata();
       const skipSpecialIncludeEntities = (configInfo.askSkip?.entitiesToSend?.includeEntitiesFromExcludedSchemas ?? [])
@@ -1695,7 +1697,7 @@ cycle.`);
    * @param refreshIntervalMinutes Minutes before cache expires
    * @returns Array of entity information
    */
-  public async BuildSkipEntities(dataSource: DataSource, forceRefresh: boolean = false, refreshIntervalMinutes: number = 15): Promise<SkipEntityInfo[]> {
+  public async BuildSkipEntities(dataSource: mssql.ConnectionPool, forceRefresh: boolean = false, refreshIntervalMinutes: number = 15): Promise<SkipEntityInfo[]> {
     try {
       const now = Date.now();
       const cacheExpired = (now - AskSkipResolver.__lastRefreshTime) > (refreshIntervalMinutes * 60 * 1000);
@@ -1723,7 +1725,7 @@ cycle.`);
    * @param dataSource Database connection
    * @returns Packaged entity information
    */
-  protected async PackSingleSkipEntityInfo(e: EntityInfo, dataSource: DataSource): Promise<SkipEntityInfo> {
+  protected async PackSingleSkipEntityInfo(e: EntityInfo, dataSource: mssql.ConnectionPool): Promise<SkipEntityInfo> {
     try {
       const ret: SkipEntityInfo = {
         id: e.ID,
@@ -1794,7 +1796,7 @@ cycle.`);
    * @param dataSource Database connection
    * @returns Packaged field information
    */
-  protected async PackSingleSkipEntityField(f: EntityFieldInfo, dataSource: DataSource): Promise<SkipEntityFieldInfo> {
+  protected async PackSingleSkipEntityField(f: EntityFieldInfo, dataSource: mssql.ConnectionPool): Promise<SkipEntityFieldInfo> {
     try {
       return {
         //id: f.ID,
@@ -1848,7 +1850,7 @@ cycle.`);
    * @returns Object containing loaded entities and contexts
    */
   protected async HandleSkipChatInitialObjectLoading(
-    dataSource: DataSource,
+    dataSource: mssql.ConnectionPool,
     ConversationId: string,
     UserQuestion: string,
     user: UserInfo,
@@ -1985,7 +1987,7 @@ cycle.`);
    * @returns Array of messages in Skip format
    */
   protected async LoadConversationDetailsIntoSkipMessages(
-    dataSource: DataSource,
+    dataSource: mssql.ConnectionPool,
     ConversationId: string,
     maxHistoricalMessages?: number,
     roleFilter?: string
@@ -2010,14 +2012,15 @@ cycle.`);
                       ConversationID = '${ConversationId}'${roleFilterClause}
                    ORDER
                       BY __mj_CreatedAt DESC`;
-      const result = await dataSource.query(sql);
-      if (!result) 
+      const request = new mssql.Request(dataSource);
+      const result = await request.query(sql);
+      if (!result || !result.recordset) 
         throw new Error(`Error running SQL: ${sql}`);
       else {
         // first, let's sort the result array into a local variable called returnData and in that we will sort by __mj_CreatedAt in ASCENDING order so we have the right chronological order
         // the reason we're doing a LOCAL sort here is because in the SQL query above, we're sorting in DESCENDING order so we can use the TOP clause to limit the number of records and get the
         // N most recent records. We want to sort in ASCENDING order because we want to send the messages to the Skip API in the order they were created.
-        const returnData = result.sort((a: any, b: any) => {
+        const returnData = result.recordset.sort((a: any, b: any) => {
           const aDate = new Date(a.__mj_CreatedAt);
           const bDate = new Date(b.__mj_CreatedAt);
           return aDate.getTime() - bDate.getTime();
@@ -2123,7 +2126,7 @@ cycle.`);
     input: SkipAPIRequest,
     UserQuestion: string,
     user: UserInfo,
-    dataSource: DataSource,
+    dataSource: mssql.ConnectionPool,
     ConversationId: string,
     userPayload: UserPayload,
     pubSub: PubSubEngine,
@@ -2371,7 +2374,7 @@ cycle.`);
     apiResponse: SkipAPIAnalysisCompleteResponse,
     UserQuestion: string,
     user: UserInfo,
-    dataSource: DataSource,
+    dataSource: mssql.ConnectionPool,
     ConversationId: string,
     userPayload: UserPayload,
     pubSub: PubSubEngine,
@@ -2435,7 +2438,7 @@ cycle.`);
     apiResponse: SkipAPIClarifyingQuestionResponse,
     UserQuestion: string,
     user: UserInfo,
-    dataSource: DataSource,
+    dataSource: mssql.ConnectionPool,
     ConversationId: string,
     userPayload: UserPayload,
     pubSub: PubSubEngine,
@@ -2509,7 +2512,7 @@ cycle.`);
     apiResponse: SkipAPIDataRequestResponse,
     UserQuestion: string,
     user: UserInfo,
-    dataSource: DataSource,
+    dataSource: mssql.ConnectionPool,
     ConversationId: string,
     userPayload: UserPayload,
     pubSub: PubSubEngine,
@@ -2681,7 +2684,7 @@ cycle.`);
     convoEntity: ConversationEntity,
     pubSub: PubSubEngine,
     userPayload: UserPayload,
-    dataSource: DataSource,
+    dataSource: mssql.ConnectionPool,
     startTime: Date
   ): Promise<{ AIMessageConversationDetailID: string }> {
     const sTitle = apiResponse.title || apiResponse.reportTitle;
@@ -2722,9 +2725,10 @@ cycle.`);
         const ei = md.EntityByName("MJ: Conversation Artifact Versions");        
         const sSQL = `SELECT ISNULL(MAX(Version),0) AS MaxVersion FROM [${ei.SchemaName}].[${ei.BaseView}] WHERE ConversationArtifactID = '${artifactId}'`;
         try {
-          const result = await dataSource.query(sSQL);
-          if (result && result.length > 0) {
-            newVersion = result[0].MaxVersion + 1;
+          const request = new mssql.Request(dataSource);
+          const result = await request.query(sSQL);
+          if (result && result.recordset && result.recordset.length > 0) {
+            newVersion = result.recordset[0].MaxVersion + 1;
           } 
           else {
             LogError(`Error getting max version for artifact ID: ${artifactId}`, undefined, result);

package/src/resolvers/EntityResolver.ts

@@ -2,11 +2,12 @@ import { EntityPermissionType } from '@memberjunction/core';
 import { AppContext } from '../types.js';
 import { Arg, Ctx, Query, Resolver, InputType, Field } from 'type-graphql';
 import { Entity_, EntityResolverBase } from '../generated/generated.js';
+import sql from 'mssql';
 
 @Resolver(Entity_)
 export class EntityResolver extends EntityResolverBase {
   @Query(() => [Entity_])
-  EntitiesBySchemas(
+  async EntitiesBySchemas(
     @Ctx() { dataSource, userPayload }: AppContext,
     @Arg('IncludeSchemas', () => [String], { nullable: true }) IncludeSchemas?: string[],
     @Arg('ExcludeSchemas', () => [String], { nullable: true }) ExcludeSchemas?: string[]
@@ -30,6 +31,8 @@ export class EntityResolver extends EntityResolverBase {
       else totalWhere = ` WHERE ${rlsWhere}`;
     }
     const sSQL = `SELECT * FROM [${this.MJCoreSchema}].vwEntities${totalWhere}`;
-    return dataSource.query(sSQL);
+    const request = new sql.Request(dataSource);
+    const result = await request.query(sSQL);
+    return result.recordset;
   }
 }

package/src/resolvers/FileCategoryResolver.ts

@@ -3,6 +3,7 @@ import { FileCategoryEntity, FileEntity } from '@memberjunction/core-entities';
 import { AppContext, Arg, Ctx, DeleteOptionsInput, Int, Mutation } from '@memberjunction/server';
 import { mj_core_schema } from '../config.js';
 import { FileCategoryResolver as FileCategoryResolverBase, FileCategory_ } from '../generated/generated.js';
+import sql from 'mssql';
 
 export class FileResolver extends FileCategoryResolverBase {
   @Mutation(() => FileCategory_)
@@ -29,7 +30,9 @@ export class FileResolver extends FileCategoryResolverBase {
     const returnValue = fileCategoryEntity.GetAll();
 
     // Any files using the deleted category fall back to its parent
-    await dataSource.transaction(async () => {
+    const transaction = new sql.Transaction(dataSource);
+    await transaction.begin();
+    try {
       // SHOULD USE BaseEntity for each of these records to ensure object model
       // is used everywhere - new code below. The below is SLOWER than a single
       // Update statement, but it ensures that the object model is used everywhere
@@ -61,7 +64,11 @@ export class FileResolver extends FileCategoryResolverBase {
         }
       }
       await fileCategoryEntity.Delete();
-    });
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
 
     await this.AfterDelete(dataSource, key); // fire event
     return returnValue;

package/src/resolvers/GetDataResolver.ts

@@ -4,6 +4,7 @@ import { LogError, LogStatus, Metadata } from '@memberjunction/core';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { v4 as uuidv4 } from 'uuid';
 import { GetReadOnlyDataSource } from '../util.js';
+import sql from 'mssql';
  
 @InputType() 
 export class GetDataInputType {
@@ -132,8 +133,9 @@ export class GetDataResolver {
             const results = await Promise.allSettled(
                 input.Queries.map(async (query) => {
                     try {
-                        const result = await readOnlyDataSource.query(query);
-                        return { result, error: null };
+                        const request = new sql.Request(readOnlyDataSource);
+                        const result = await request.query(query);
+                        return { result: result.recordset, error: null };
                     } catch (err) {
                         return { result: null, error: err };
                     }