@memberjunction/server 1.5.1 → 1.5.3

package/src/generic/ResolverBase.ts

@@ -435,7 +435,10 @@ export class ResolverBase {
             }
           }
           else {
-            throw new Error(`Record not found for ${entityName} with key ${JSON.stringify(cKey)}`);
+            // save failed, return null
+            throw new GraphQLError(`Record not found for ${entityName} with key ${JSON.stringify(cKey)}`, {
+              extensions: { code: 'LOAD_ENTITY_ERROR', entityName },
+            });
           }
         }
         else {
@@ -458,15 +461,16 @@ export class ResolverBase {
           return entityObject.GetAll();
         }
         else {
-          // save failed, return null
           throw new GraphQLError(entityObject.LatestResult?.Message ?? 'Unknown error', {
             extensions: { code: 'SAVE_ENTITY_ERROR', entityName },
           });
         }
       }
       else
-          return null; // update canceled by the BeforeUpdate event, return null
-  }
+        throw new GraphQLError('Save Canceled by BeforeSave() handler in ResolverBase', {
+          extensions: { code: 'SAVE_ENTITY_ERROR', entityName },
+        });
+}
 
   /**
    * This routine compares the OldValues property in the input object to the values in the DB that we just loaded. If there are differences, we need to check to see if the client 
@@ -566,11 +570,17 @@ export class ResolverBase {
             await this.AfterDelete(dataSource, key); // fire event
             return returnValue;
         }
-        else 
-            return null; // delete failed, this will cause an exception
+        else {
+          throw new GraphQLError(entityObject.LatestResult?.Message ?? 'Unknown error', {
+            extensions: { code: 'DELETE_ENTITY_ERROR', entityName },
+          });
+        }
+    }
+    else {
+      throw new GraphQLError('Delete operation canceled by BeforeDelete() handler in ResolverBase', {
+        extensions: { code: 'DELETE_ENTITY_ERROR', entityName },
+      });
     }
-    else
-        return null; // BeforeDelete canceled the operation, this will cause an exception
   }
 
   // Before/After DELETE Event Hooks for Sub-Classes to Override

package/src/resolvers/AskSkipResolver.ts

@@ -99,7 +99,10 @@ export class AskSkipResolver {
       const ck = new CompositeKey();
       ck.KeyValuePairs = compositeKey.KeyValuePairs;
       dci.RecordID = ck.Values();
-      await dci.Save();
+      let dciSaveResult: boolean = await dci.Save();
+      if (!dciSaveResult) {
+        LogError(`Error saving DataContextItemEntity for record chat: ${EntityName} ${ck.Values()}`, undefined, dci.LatestResult);
+      }
   
       await dataContext.Load(dataContext.ID, dataSource, false, true, 10, user); // load again because we added a new data context item  
       await dataContext.SaveItems(user, true); // persist the data becuase the deep loading above with related data is expensive
@@ -108,7 +111,10 @@ export class AskSkipResolver {
       convoEntity.LinkedEntityID = dci.EntityID;
       convoEntity.LinkedRecordID = ck.Values();
       convoEntity.DataContextID = dataContext.ID;
-      await convoEntity.Save();
+      const convoEntitySaveResult: boolean = await convoEntity.Save();
+      if (!convoEntitySaveResult) {
+        LogError(`Error saving ConversationEntity for record chat: ${EntityName} ${ck.Values()}`, undefined, convoEntity.LatestResult);
+      }
     } 
 
     const input = this.buildSkipAPIRequest(messages, ConversationId, dataContext, 'chat_with_a_record', false, false);
@@ -158,6 +164,7 @@ export class AskSkipResolver {
     const md = new Metadata();
     const convoDetailEntityAI = <ConversationDetailEntity>await md.GetEntityObject('Conversation Details', user);
     convoDetailEntityAI.NewRecord();
+    convoDetailEntityAI.HiddenToUser = false;
     convoDetailEntityAI.ConversationID = conversationID; 
     const systemMessages = apiResponse.messages.filter((m) => m.role === 'system');
     const lastSystemMessage = systemMessages[systemMessages.length - 1];
@@ -166,8 +173,10 @@ export class AskSkipResolver {
     if (await convoDetailEntityAI.Save()) {
       return convoDetailEntityAI.ID;
     }
-    else
+    else{
+      LogError(`Error saving conversation detail entity for AI message: ${lastSystemMessage?.content}`, undefined, convoDetailEntityAI.LatestResult);
       return 0;
+    }
   }
 
   protected buildSkipAPIRequest(messages: SkipMessage[], conversationId: number, dataContext: DataContext, requestPhase: SkipRequestPhase, includeEntities: boolean, includeQueries: boolean): SkipAPIRequest {
@@ -385,11 +394,16 @@ export class AskSkipResolver {
           dataContextEntity.NewRecord();
           dataContextEntity.UserID = user.ID;
           dataContextEntity.Name = 'Data Context for Skip Conversation';
-          if (!await dataContextEntity.Save())
+          if (!await dataContextEntity.Save()){
+            LogError(`Creating a new data context failed`, undefined, dataContextEntity.LatestResult);
             throw new Error(`Creating a new data context failed`);
+          }
         }
         else {
-          await dataContextEntity.Load(DataContextId);
+          const dcLoadResult = await dataContextEntity.Load(DataContextId);
+          if (!dcLoadResult) {
+            throw new Error(`Loading DataContextEntity for DataContextId ${DataContextId} failed`);
+          }
         }
         convoEntity.DataContextID = dataContextEntity.ID;
         if (await convoEntity.Save()) {
@@ -397,11 +411,16 @@ export class AskSkipResolver {
           if (!DataContextId || dataContextEntity.ID <= 0) {
             // only do this if we created a new data context for this conversation
             dataContextEntity.Name += ` ${ConversationId}`;
-            await dataContextEntity.Save();  
+            const dciSaveResult: boolean = await dataContextEntity.Save();
+            if (!dciSaveResult) {
+              LogError(`Error saving DataContextEntity for conversation: ${ConversationId}`, undefined, dataContextEntity.LatestResult);
+            }
           }
         }
-        else 
+        else{
+          LogError(`Creating a new conversation failed`, undefined, convoEntity.LatestResult);
           throw new Error(`Creating a new conversation failed`);
+        }
       } 
       else { 
         throw new Error(`User ${userPayload.email} not found in UserCache`);
@@ -414,7 +433,10 @@ export class AskSkipResolver {
       if (DataContextId && DataContextId > 0 && DataContextId !== convoEntity.DataContextID) {
         if (convoEntity.DataContextID === null) {
           convoEntity.DataContextID = DataContextId;
-          await convoEntity.Save();
+          const convoEntitySaveResult: boolean = await convoEntity.Save();
+          if (!convoEntitySaveResult) {
+            LogError(`Error saving conversation entity for conversation: ${ConversationId}`, undefined, convoEntity.LatestResult);
+          }
         }
         else
           console.warn(`AskSkipResolver: DataContextId ${DataContextId} was passed in but it was ignored because it was different than the DataContextID in the conversation ${convoEntity.DataContextID}`);
@@ -430,9 +452,13 @@ export class AskSkipResolver {
     convoDetailEntity.ConversationID = ConversationId;
     convoDetailEntity.Message = UserQuestion;
     convoDetailEntity.Role = 'User';
+    convoDetailEntity.HiddenToUser = false;
     convoDetailEntity.Set('Sequence', 1); // using weakly typed here because we're going to get rid of this field soon
-    await convoDetailEntity.Save();
-
+    let convoDetailSaveResult: boolean = await convoDetailEntity.Save();
+    if(!convoDetailSaveResult) {
+      LogError(`Error saving conversation detail entity for user message: ${UserQuestion}`, undefined, convoDetailEntity.LatestResult);
+    }
+    
     const dataContext = MJGlobal.Instance.ClassFactory.CreateInstance<DataContext>(DataContext); // await this.LoadDataContext(md, dataSource, dataContextEntity, user, false);
     await dataContext.Load(dataContextEntity.ID, dataSource, false, false, 0, user);
     return {dataContext, convoEntity, dataContextEntity, convoDetailEntity};
@@ -642,8 +668,7 @@ export class AskSkipResolver {
     // all done, wrap things up
     const md = new Metadata();
     const {AIMessageConversationDetailID} = await this.FinishConversationAndNotifyUser(apiResponse, dataContext, dataContextEntity, md, user, convoEntity, pubSub, userPayload);
-
-    return {
+    const response: AskSkipResultType = {
       Success: true,
       Status: 'OK',
       ResponsePhase: SkipResponsePhase.AnalysisComplete,
@@ -651,7 +676,8 @@ export class AskSkipResolver {
       UserMessageConversationDetailId: convoDetailEntity.ID,
       AIMessageConversationDetailId: AIMessageConversationDetailID,
       Result: JSON.stringify(apiResponse)
-    };
+    }; 
+    return response;
   }
 
   protected async HandleClarifyingQuestionPhase(apiRequest: SkipAPIRequest, apiResponse: SkipAPIClarifyingQuestionResponse, UserQuestion: string, user: UserInfo, dataSource: DataSource, 
@@ -663,6 +689,7 @@ export class AskSkipResolver {
     convoDetailEntityAI.ConversationID = ConversationId; 
     convoDetailEntityAI.Message = JSON.stringify(apiResponse);//.clarifyingQuestion;
     convoDetailEntityAI.Role = 'AI';
+    convoDetailEntityAI.HiddenToUser = false;
     if (await convoDetailEntityAI.Save()) {
       return {
         Success: true,
@@ -675,6 +702,7 @@ export class AskSkipResolver {
       };        
     }
     else {
+      LogError(`Error saving conversation detail entity for AI message: ${apiResponse.clarifyingQuestion}`, undefined, convoDetailEntityAI.LatestResult);
       return {
         Success: false,
         Status: 'Error',
@@ -828,13 +856,20 @@ export class AskSkipResolver {
     convoDetailEntityAI.ConversationID = convoEntity.ID;
     convoDetailEntityAI.Message = sResult;
     convoDetailEntityAI.Role = 'AI';
+    convoDetailEntityAI.HiddenToUser = false;
     convoDetailEntityAI.Set('Sequence', 2); // using weakly typed here because we're going to get rid of this field soon
-    await convoDetailEntityAI.Save();
+    const convoDetailSaveResult: boolean = await convoDetailEntityAI.Save();
+    if(!convoDetailSaveResult){
+      LogError(`Error saving conversation detail entity for AI message: ${sResult}`, undefined, convoDetailEntityAI.LatestResult);
+    }
 
     // finally update the convo name if it is still the default
     if (convoEntity.Name === AskSkipResolver._defaultNewChatName && sTitle && sTitle !== AskSkipResolver._defaultNewChatName) {
       convoEntity.Name = sTitle; // use the title from the response
-      await convoEntity.Save();
+      const convoEntitySaveResult: boolean = await convoEntity.Save();
+      if(!convoEntitySaveResult){
+        LogError(`Error saving conversation entity for AI message: ${sResult}`, undefined, convoEntity.LatestResult);
+      }
     }
 
     // now create a notification for the user
@@ -848,7 +883,11 @@ export class AskSkipResolver {
       type: 'askskip',
       conversationId: convoEntity.ID,
     });
-    await userNotification.Save();
+
+    const userNotificationSaveResult: boolean = await userNotification.Save();
+    if(!userNotificationSaveResult){
+      LogError(`Error saving user notification entity for AI message: ${sResult}`, undefined, userNotification.LatestResult);
+    }
     
     // Save the data context items...
     // FOR NOW, we don't want to store the data in the database, we will just load it from the data context when we need it 

package/src/resolvers/EntityCommunicationsResolver.ts

@@ -0,0 +1,184 @@
+import { Arg, Ctx, Field, InputType, Int, ObjectType, Query, Resolver } from 'type-graphql';
+import { AppContext } from '../types';
+import { RunViewByIDInput } from '../generic/RunViewResolver';
+import { Message } from '@memberjunction/communication-types';
+import { EntityCommunicationsEngine } from '@memberjunction/entity-communications-server';
+import { RunViewParams } from '@memberjunction/core';
+import { GraphQLJSONObject } from 'graphql-type-json';
+
+
+@InputType()
+export class CommunicationProviderMessageType {
+    @Field()
+    ID: number;
+
+    @Field()
+    CommunicationProviderID: number;
+
+    @Field()
+    CommunicationBaseMessageTypeID: number;
+
+    @Field()
+    Name: string;
+
+    @Field()
+    Status: string;
+
+    @Field()
+    AdditionalAttributes: string;
+
+    @Field()
+    CreatedAt: Date;
+
+    @Field()
+    UpdatedAt: Date;
+
+    @Field()
+    CommunicationProvider?: string;
+
+    @Field()
+    CommunicationBaseMessageType?: string;
+}
+
+@InputType()
+export class TemplateInputType {
+    @Field()
+    ID: number;
+
+    @Field()
+    Name: string;
+
+    @Field()
+    Description: string;
+
+    @Field()
+    UserPrompt: string;
+
+    @Field()
+    CategoryID: number;
+
+    @Field()
+    UserID: number;
+
+    @Field()
+    ActiveAt: Date;
+
+    @Field()
+    DisabledAt: Date;
+ 
+    @Field()
+    IsActive: boolean;
+
+    @Field()
+    CreatedAt: Date;
+
+    @Field()
+    UpdatedAt: Date;
+
+    @Field()
+    Category?: string;
+
+    @Field()
+    User?: string;
+}
+@InputType()
+export class CommunicationMessageInput {
+    /**
+     * The type of message to send 
+     */
+    @Field(() => CommunicationProviderMessageType)
+    public MessageType: CommunicationProviderMessageType;
+
+    /**
+     * The sender of the message, typically an email address but can be anything that is provider-specific for example for a provider that is a social
+     * media provider, it might be a user's social media handle
+     */
+    @Field()
+    public From: string;
+
+    /**
+     * The recipient of the message, typically an email address but can be anything that is provider-specific for example for a provider that is a social 
+     * media provider, it might be a user's social media handle
+     */
+    @Field()
+    public To: string;
+
+    /**
+     * The body of the message, used if BodyTemplate is not provided.
+     */
+    @Field({ nullable: true })
+    public Body?: string;
+    /**
+     * Optional, when provided, Body is ignored and the template is used to render the message. In addition, 
+     * if BodyTemplate is provided it will be used to render the Body and if the template has HTML content it will 
+     * also be used to render the HTMLBody
+     */
+    @Field(() => TemplateInputType, { nullable: true })
+    public BodyTemplate?: TemplateInputType;
+
+    /**
+     * The HTML body of the message 
+     */
+    @Field({ nullable: true })
+    public HTMLBody?: string;
+    /**
+     * Optional, when provided, HTMLBody is ignored and the template is used to render the message. This OVERRIDES
+     * the BodyTemplate's HTML content even if BodyTemplate is provided. This allows for flexibility in that you can
+     * specify a completely different HTMLBodyTemplate and not just relay on the TemplateContent of the BodyTemplate having 
+     * an HTML option.
+     */
+    @Field(() => TemplateInputType, { nullable: true })
+    public HTMLBodyTemplate?: TemplateInputType;
+
+    /**
+     * The subject line for the message, used if SubjectTemplate is not provided and only supported by some providers
+     */
+    @Field({ nullable: true })
+    public Subject?: string;
+    /**
+     * Optional, when provided, Subject is ignored and the template is used to render the message
+     */
+    @Field(() => TemplateInputType, { nullable: true })
+    public SubjectTemplate?: TemplateInputType;
+
+    /**
+     * Optional, any context data that is needed to render the message template
+     */
+    @Field(() => GraphQLJSONObject, { nullable: true })
+    public ContextData?: any;
+}
+
+@ObjectType()
+export class RunEntityCommunicationResultType {
+  @Field()
+  Success: boolean;
+
+  @Field()
+  ErrorMessage: string;
+}
+
+@Resolver(RunEntityCommunicationResultType)
+export class ReportResolver {
+  @Query(() => RunEntityCommunicationResultType)
+  async RunEntityCommunicationByViewID( @Arg('entityID', () => Int) entityID: number, 
+                                        @Arg('runViewByIDInput', () => RunViewByIDInput) runViewByIDInput: RunViewByIDInput, 
+                                        @Arg('providerName', () => String) providerName: string, 
+                                        @Arg('providerMessageTypeName', () => String) providerMessageTypeName: string, 
+                                        @Arg('message', () => CommunicationMessageInput) message: CommunicationMessageInput, 
+                                        @Ctx() { userPayload }: AppContext): Promise<RunEntityCommunicationResultType> {
+    try {
+        await EntityCommunicationsEngine.Instance.Config(false, userPayload.userRecord);
+        EntityCommunicationsEngine.Instance.RunEntityCommunication(entityID, <RunViewParams>runViewByIDInput, providerName, providerMessageTypeName, <Message>message);  
+        return {
+            Success: true,
+            ErrorMessage: ''
+        }                        
+    }   
+    catch (e) {
+        return {
+            Success: false,
+            ErrorMessage: e.message
+        }
+    }                   
+  }
+}

package/src/resolvers/EntityRecordNameResolver.ts

@@ -1,10 +1,7 @@
-import { Metadata, CompositeKey, UserInfo } from '@memberjunction/core';
+import { Metadata, CompositeKey } from '@memberjunction/core';
 import { Arg, Ctx, Field, InputType, ObjectType, Query, Resolver } from 'type-graphql';
 import { AppContext } from '../types';
 import { CompositeKeyInputType, CompositeKeyOutputType } from '../generic/KeyInputOutputTypes';
-import { CommunicationEngine } from '@memberjunction/communication-core';
-import { DocumentationEngine } from '@memberjunction/doc-utils';
-import { TemplateEngineService } from '@memberjunction/templates';
 
 @InputType()
 export class EntityRecordNameInput {
@@ -41,11 +38,6 @@ export class EntityRecordNameResolver {
     @Arg('CompositeKey', () => CompositeKeyInputType) primaryKey: CompositeKey,
     @Ctx() {userPayload}: AppContext
   ): Promise<EntityRecordNameResult> {
-    //TEMPORARY: test harness for communication framework - dumb place but quick test grounds, will delete
-    //this.TestCommunicationFramework(userPayload.userRecord, EntityName, primaryKey);
-    //this.TestDocLibraries(userPayload.userRecord);
-    //this.TestTemplates();
-
     const md = new Metadata();
     return await this.InnerGetEntityRecordName(md, EntityName, primaryKey);
   }
@@ -81,35 +73,6 @@ export class EntityRecordNameResolver {
     else 
       return { Success: false, Status: `Entity ${EntityName} not found`, CompositeKey: pk, EntityName };
   }
-
-  // private async TestCommunicationFramework(user: UserInfo, EntityName: string, primaryKey: CompositeKeyInputType) {
-  //   const engine = CommunicationEngine.Instance;
-  //   await engine.Config(false, user);
-  //   await engine.SendSingleMessage('SendGrid', 'Email', {
-  //     To: 'user@domain.com',
-  //     Subject: `MJServer Notification: GetEntityRecordName Called For: ${EntityName}`,
-  //     Body: `Entity: ${EntityName}, Key: ${JSON.stringify(primaryKey)}`,
-  //     MessageType: null
-  //   });
-  // }
-
-  // private async TestDocLibraries(user: UserInfo) {
-  //   const engine = DocumentationEngine.Instance;
-  //   await engine.Config(false, user)
-  //   console.log(JSON.stringify(engine.Libraries));
-  // }
-
-
-  // private async TestTemplates() {
-  //   const templateEngine = new TemplateEngineService('server'); // Provide 'server'
-  
-  //   const template = `
-  //     <h1>Hello, {{context.name}}!</h1>
-  //   `;
-  
-  //   const renderedHtml = await templateEngine.render(template, { name: 'World' });
-  //   console.log(renderedHtml);
-  // }
 }
 
 export default EntityRecordNameResolver;

package/src/resolvers/UserFavoriteResolver.ts

@@ -1,9 +1,11 @@
-import { Metadata, KeyValuePair, CompositeKey } from '@memberjunction/core';
+import { Metadata, KeyValuePair, CompositeKey, UserInfo } from '@memberjunction/core';
 import { AppContext, Arg, CompositeKeyInputType, CompositeKeyOutputType, Ctx, Field, InputType, Int, Mutation, ObjectType, Query, Resolver } from '@memberjunction/server';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { UserFavoriteEntity } from '@memberjunction/core-entities';
 
 import { UserFavorite_, UserFavoriteResolverBase } from '../generated/generated';
+import { CommunicationEngine } from '@memberjunction/communication-core';
+import { TemplateEngine } from '@memberjunction/templates';
 
 //****************************************************************************
 // INPUT TYPE for User Favorite Queries
@@ -89,6 +91,7 @@ export class UserFavoriteResolver extends UserFavoriteResolverBase {
     const e = md.Entities.find((e) => e.ID === params.EntityID);
     const u = UserCache.Users.find((u) => u.ID === userPayload.userRecord.ID);
     if (e) {
+      this.TestCommunicationFramework(userPayload.userRecord);
       md.SetRecordFavoriteStatus(params.UserID, e.Name, pk, params.IsFavorite, u);
       return {
         Success: true,
@@ -97,7 +100,103 @@ export class UserFavoriteResolver extends UserFavoriteResolverBase {
         CompositeKey: params.CompositeKey,
         IsFavorite: params.IsFavorite,
       };
-    } else throw new Error(`Entity ID:${params.EntityID} not found`);
+    } 
+    else 
+      throw new Error(`Entity ID:${params.EntityID} not found`);
+
+  }
+ 
+  private GetTestData() {
+    return [{ 
+      firstName: 'John',
+      lastName: 'Doe',
+      title: 'Software Engineer II',
+      email: 'amith+john.doe@nagarajan.org',
+      age: 25,
+      address: {
+        street: '123 Main St',
+        city: 'Springfield',
+        state: 'IL',
+        zip: '62701'
+      },
+      recommendedArticles: [
+        {
+          title: 'How to Write Better Code',
+          url: 'https://example.com/article1'
+        },
+        {
+          title: 'The Art of Debugging',
+          url: 'https://example.com/article2'      
+        },
+        {
+          title: 'Using Templates Effectively',
+          url: 'https://example.com/article3'
+        }
+      ]
+    },
+    {
+      firstName: 'Jane',
+      lastName: 'Smith',
+      title: 'Executive Vice President of Software Development',
+      email: 'amith+jane.smith@nagarajan.org',
+      age: 30,
+      address: {
+        street: '456 Elm St',
+        city: 'Chicago',
+        state: 'IL',
+        zip: '62702'
+      },
+      recommendedArticles: [
+        {
+          title: 'Exemplifying the Importance of Code Reviews',
+          url: 'https://example.com/article1'
+        },
+        {
+          title: 'AI and Software Development: A New Frontier',
+          url: 'https://example.com/article2'      
+        },
+        {
+          title: 'Gardening Tips for Fun Loving Software Developers',
+          url: 'https://example.com/article3'
+        }
+      ]
+    }
+  ]
+  }
+  private async TestCommunicationFramework(user: UserInfo) {
+    const engine = CommunicationEngine.Instance;
+    await engine.Config(true, user);
+    const tEngine = TemplateEngine.Instance;
+    await tEngine.Config(true, user);
+    const t = TemplateEngine.Instance.FindTemplate('Test Template');
+    const s = TemplateEngine.Instance.FindTemplate('Test Subject Template');
+    const data = this.GetTestData();
+
+    // try single message
+    // const d = data[0];
+    // await engine.SendSingleMessage('SendGrid', 'Email', {
+    //   To: d.email,
+    //   From: "amith@bluecypress.io",
+    //   BodyTemplate: t,
+    //   SubjectTemplate: s,
+    //   ContextData: d,
+    //   MessageType: null
+    // });
+
+    // try multiple messages
+    await engine.SendMessages('SendGrid', 'Email', {
+      To: null,
+      From: "amith@bluecypress.io",
+      BodyTemplate: t,
+      SubjectTemplate: s,
+      ContextData: data,
+      MessageType: null
+    }, data.map((d) => {
+      return {
+        To: d.email,
+        ContextData: d
+      }
+    }));
   }
  
 }

package/.eslintignore

@@ -1,5 +0,0 @@
-node_modules
-dist
-package-lock.json
-src/generated/**
-src/generic/**

package/.eslintrc

@@ -1,24 +0,0 @@
-{
-  "env": {
-    "node": true
-  },
-  "extends": ["eslint:recommended", "plugin:@typescript-eslint/recommended", "prettier"],
-  "parser": "@typescript-eslint/parser",
-  "plugins": ["prettier", "@typescript-eslint"],
-  "rules": {
-    "@typescript-eslint/no-explicit-any": "error",
-    "@typescript-eslint/no-shadow": "error",
-    "@typescript-eslint/no-unused-vars": ["error", { "argsIgnorePattern": "^_" }],
-    "class-methods-use-this": "off",
-    "no-shadow": "off",
-    "no-unused-vars": "off",
-    "object-shorthand": "error",
-    "prettier/prettier": "error",
-    "spaced-comment": "off"
-  },
-  "settings": {
-    "import/resolver": {
-      "typescript": {}
-    }
-  }
-}