@memberjunction/server 2.111.1 → 2.112.0

package/src/resolvers/DatasetResolver.ts

@@ -1,6 +1,6 @@
 import { Arg, Ctx, Field, InputType, Int, ObjectType, Query, Resolver } from 'type-graphql';
 import { AppContext } from '../types.js';
-import { LogError, Metadata } from '@memberjunction/core';
+import { LogError, Metadata } from '@memberjunction/global';
 import { GetReadOnlyProvider } from '../util.js';
 
 @ObjectType()
@@ -33,17 +33,16 @@ export class DatasetItemFilterTypeGQL {
   Filter: string;
 }
 
-
 @Resolver(DatasetResultType)
 export class DatasetResolverExtended {
   @Query(() => DatasetResultType)
   async GetDatasetByName(
     @Arg('DatasetName', () => String) DatasetName: string,
-    @Ctx() {providers}: AppContext,
+    @Ctx() { providers }: AppContext,
     @Arg('ItemFilters', () => [DatasetItemFilterTypeGQL], { nullable: 'itemsAndList' }) ItemFilters?: DatasetItemFilterTypeGQL[]
   ) {
     try {
-      const md = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true});
+      const md = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
       const result = await md.GetDatasetByName(DatasetName, ItemFilters);
       if (result) {
         return {
@@ -90,11 +89,11 @@ export class DatasetStatusResolver {
   @Query(() => DatasetStatusResultType)
   async GetDatasetStatusByName(
     @Arg('DatasetName', () => String) DatasetName: string,
-    @Ctx() {providers}: AppContext,
+    @Ctx() { providers }: AppContext,
     @Arg('ItemFilters', () => [DatasetItemFilterTypeGQL], { nullable: 'itemsAndList' }) ItemFilters?: DatasetItemFilterTypeGQL[]
   ) {
     try {
-      const md = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true});
+      const md = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
       const result = await md.GetDatasetStatusByName(DatasetName, ItemFilters);
       if (result) {
         return {

package/src/resolvers/EntityCommunicationsResolver.ts

@@ -3,7 +3,7 @@ import { AppContext } from '../types.js';
 import { RunViewByIDInput } from '../generic/RunViewResolver.js';
 import { Message } from '@memberjunction/communication-types';
 import { EntityCommunicationsEngine } from '@memberjunction/entity-communications-server';
-import { RunViewParams } from '@memberjunction/core';
+import { RunViewParams } from '@memberjunction/global';
 import { GraphQLJSONObject } from 'graphql-type-json';
 import { TemplateEngineServer } from '@memberjunction/templates';
 import { EntityCommunicationParams } from '@memberjunction/entity-communications-base';

package/src/resolvers/EntityRecordNameResolver.ts

@@ -1,4 +1,4 @@
-import { Metadata, CompositeKey, DatabaseProviderBase } from '@memberjunction/core';
+import { Metadata, CompositeKey, DatabaseProviderBase } from '@memberjunction/global';
 import { Arg, Ctx, Field, InputType, ObjectType, Query, Resolver } from 'type-graphql';
 import { AppContext } from '../types.js';
 import { CompositeKeyInputType, CompositeKeyOutputType } from '../generic/KeyInputOutputTypes.js';
@@ -39,7 +39,7 @@ export class EntityRecordNameResolver {
     @Arg('CompositeKey', () => CompositeKeyInputType) primaryKey: CompositeKey,
     @Ctx() { providers, userPayload }: AppContext
   ): Promise<EntityRecordNameResult> {
-    const md = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true});
+    const md = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
 
     return await this.InnerGetEntityRecordName(md, EntityName, primaryKey);
   }
@@ -47,17 +47,21 @@ export class EntityRecordNameResolver {
   @Query(() => [EntityRecordNameResult])
   async GetEntityRecordNames(
     @Arg('info', () => [EntityRecordNameInput]) info: EntityRecordNameInput[],
-    @Ctx() {providers}: AppContext
+    @Ctx() { providers }: AppContext
   ): Promise<EntityRecordNameResult[]> {
     const result: EntityRecordNameResult[] = [];
-    const md = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true});
+    const md = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
     for (const i of info) {
       result.push(await this.InnerGetEntityRecordName(md, i.EntityName, i.CompositeKey));
     }
     return result;
   }
 
-  async InnerGetEntityRecordName(md: DatabaseProviderBase, EntityName: string, primaryKey: CompositeKeyInputType): Promise<EntityRecordNameResult> {
+  async InnerGetEntityRecordName(
+    md: DatabaseProviderBase,
+    EntityName: string,
+    primaryKey: CompositeKeyInputType
+  ): Promise<EntityRecordNameResult> {
     const pk = new CompositeKey(primaryKey.KeyValuePairs);
     const e = md.Entities.find((e) => e.Name === EntityName);
     if (e) {

package/src/resolvers/EntityResolver.ts

@@ -1,4 +1,4 @@
-import { EntityPermissionType, IRunViewProvider } from '@memberjunction/core';
+import { EntityPermissionType, IRunViewProvider } from '@memberjunction/global';
 import { AppContext } from '../types.js';
 import { Arg, Ctx, Query, Resolver, InputType, Field } from 'type-graphql';
 import { MJEntity_, MJEntityResolverBase } from '../generated/generated.js';
@@ -33,14 +33,16 @@ export class EntityResolver extends MJEntityResolverBase {
       else totalWhere = ` ${rlsWhere}`;
     }
     const rv = provider as any as IRunViewProvider;
-    const result = await rv.RunView({
-      EntityName: 'Entities',
-      ExtraFilter: totalWhere,
-    }, userPayload.userRecord);
+    const result = await rv.RunView(
+      {
+        EntityName: 'Entities',
+        ExtraFilter: totalWhere,
+      },
+      userPayload.userRecord
+    );
     if (result && result.Success) {
       return result.Results;
-    }
-    else {
+    } else {
       throw new Error(`Failed to fetch entities: ${result?.ErrorMessage || 'Unknown error'}`);
     }
   }

package/src/resolvers/FileCategoryResolver.ts

@@ -1,4 +1,4 @@
-import { CompositeKey, EntityDeleteOptions, EntityPermissionType, EntitySaveOptions, Metadata, RunView } from '@memberjunction/core';
+import { CompositeKey, EntityDeleteOptions, EntityPermissionType, EntitySaveOptions, Metadata, RunView } from '@memberjunction/global';
 import { FileCategoryEntity, FileEntity } from '@memberjunction/core-entities';
 import { AppContext, Arg, Ctx, DeleteOptionsInput, Int, Mutation } from '@memberjunction/server';
 import { mj_core_schema } from '../config.js';
@@ -16,7 +16,7 @@ export class FileResolver extends FileCategoryResolverBase {
   ) {
     const key = new CompositeKey();
     key.LoadFromSingleKeyValuePair('ID', ID);
-    const p = GetReadWriteProvider(providers);    
+    const p = GetReadWriteProvider(providers);
 
     if (!(await this.BeforeDelete(p, key))) {
       return null;

package/src/resolvers/FileResolver.ts

@@ -1,4 +1,4 @@
-import { EntityPermissionType, Metadata, FieldValueCollection, EntitySaveOptions } from '@memberjunction/core';
+import { EntityPermissionType, Metadata, FieldValueCollection, EntitySaveOptions } from '@memberjunction/global';
 import { FileEntity, FileStorageProviderEntity } from '@memberjunction/core-entities';
 import {
   AppContext,
@@ -52,7 +52,7 @@ export class FileResolver extends FileResolverBase {
     @PubSub() pubSub: PubSubEngine
   ) {
     // Check to see if there's already an object with that name
-    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true})    
+    const provider = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
     const user = this.GetUserFromPayload(context.userPayload);
     const fileEntity = await provider.GetEntityObject<FileEntity>('Files', user);
     const providerEntity = await provider.GetEntityObject<FileStorageProviderEntity>('File Storage Providers', user);
@@ -107,7 +107,7 @@ export class FileResolver extends FileResolverBase {
     @PubSub() pubSub: PubSubEngine
   ) {
     // if the name is changing, rename the target object as well
-    const md = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true});
+    const md = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
     const user = this.GetUserFromPayload(context.userPayload);
     const fileEntity = await md.GetEntityObject<FileEntity>('Files', user);
     fileEntity.CheckPermissions(EntityPermissionType.Update, true);
@@ -135,7 +135,7 @@ export class FileResolver extends FileResolverBase {
     @Ctx() context: AppContext,
     @PubSub() pubSub: PubSubEngine
   ) {
-    const md = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true});
+    const md = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
     const userInfo = this.GetUserFromPayload(context.userPayload);
 
     const fileEntity = await md.GetEntityObject<FileEntity>('Files', userInfo);

package/src/resolvers/GetDataContextDataResolver.ts

@@ -1,136 +1,124 @@
-import { Arg, Ctx, Field, ObjectType, Query } from "type-graphql";
-import { AppContext } from "../types.js";
-import { DataContext } from "@memberjunction/data-context";
-import { GetReadOnlyDataSource, GetReadOnlyProvider } from "../util.js";
-import { Metadata } from "@memberjunction/core";
-import { DataContextItemEntity } from "@memberjunction/core-entities";
+import { Arg, Ctx, Field, ObjectType, Query } from 'type-graphql';
+import { AppContext } from '../types.js';
+import { DataContext } from '@memberjunction/data-context';
+import { GetReadOnlyDataSource, GetReadOnlyProvider } from '../util.js';
+import { Metadata } from '@memberjunction/global';
+import { DataContextItemEntity } from '@memberjunction/core-entities';
 
 @ObjectType()
 export class GetDataContextItemDataOutputType {
-    @Field(() => Boolean)
-    Success: boolean;
+  @Field(() => Boolean)
+  Success: boolean;
 
-    /**
-     * If not successful, this will be the error message.
-     */
-    @Field(() => String, { nullable: true })
-    ErrorMessage: string | null;
+  /**
+   * If not successful, this will be the error message.
+   */
+  @Field(() => String, { nullable: true })
+  ErrorMessage: string | null;
 
-    /**
-     * If successful, this will be the JSON for the data context item's data.
-     */
-    @Field(() => String, { nullable: true })  
-    Result: string | null;
+  /**
+   * If successful, this will be the JSON for the data context item's data.
+   */
+  @Field(() => String, { nullable: true })
+  Result: string | null;
 }
 
 @ObjectType()
 export class GetDataContextDataOutputType {
-    @Field(() => Boolean)
-    Success: boolean;
+  @Field(() => Boolean)
+  Success: boolean;
 
-    @Field(() => [String], { nullable: 'itemsAndList' }) // Allow nulls inside array & entire field nullable
-    ErrorMessages: (string | null)[];
+  @Field(() => [String], { nullable: 'itemsAndList' }) // Allow nulls inside array & entire field nullable
+  ErrorMessages: (string | null)[];
 
-    /**
-     * Each data context item's results will be converted to JSON and returned as a string
-     */
-    @Field(() => [String], { nullable: 'itemsAndList' }) // Allow nulls inside array & entire field nullable
-    Results: (string | null)[];
+  /**
+   * Each data context item's results will be converted to JSON and returned as a string
+   */
+  @Field(() => [String], { nullable: 'itemsAndList' }) // Allow nulls inside array & entire field nullable
+  Results: (string | null)[];
 }
 
-
 export class GetDataContextDataResolver {
-    /**
-     * Returns data for a given data context item. 
-     * @param DataContextItemID 
-     */
-    @Query(() => GetDataContextItemDataOutputType)
-    async GetDataContextItemData(
-        @Arg('DataContextItemID', () => String) DataContextItemID: string,
-        @Ctx() appCtx: AppContext
-    ) {
-        try {
-            const ds = GetReadOnlyDataSource(appCtx.dataSources, {
-                allowFallbackToReadWrite: true,
-            })
-            const md = GetReadOnlyProvider(appCtx.providers, {allowFallbackToReadWrite: true});
-            const dciData = await md.GetEntityObject<DataContextItemEntity>("Data Context Items", appCtx.userPayload.userRecord);
-            if (await dciData.Load(DataContextItemID)) {
-                const dci = DataContext.CreateDataContextItem(); // use class factory to get whatever lowest level sub-class is registered
-                await dci.LoadMetadataFromEntityRecord(dciData, Metadata.Provider, appCtx.userPayload.userRecord);
-                // now the metadata is loaded so we can call the regular load function
-                if (await dci.LoadData(ds)) {
-                    return {
-                        Success: true,
-                        ErrorMessage: null,
-                        Result: JSON.stringify(dci.Data),
-                    }
-                }
-                else {
-                    return {
-                        Success: false,
-                        ErrorMessage: 'Error loading data context item data',
-                        Result: null,
-                    }
-                }
-            }
-            else {
-                return {
-                    Success: false,
-                    ErrorMessage: 'Error loading data context item metadata',
-                    Result: null,
-                }
-            }    
-        }
-        catch (e) {
-            return {
-                Success: false,
-                ErrorMessage: e,
-                Result: null,
-            }
+  /**
+   * Returns data for a given data context item.
+   * @param DataContextItemID
+   */
+  @Query(() => GetDataContextItemDataOutputType)
+  async GetDataContextItemData(@Arg('DataContextItemID', () => String) DataContextItemID: string, @Ctx() appCtx: AppContext) {
+    try {
+      const ds = GetReadOnlyDataSource(appCtx.dataSources, {
+        allowFallbackToReadWrite: true,
+      });
+      const md = GetReadOnlyProvider(appCtx.providers, { allowFallbackToReadWrite: true });
+      const dciData = await md.GetEntityObject<DataContextItemEntity>('Data Context Items', appCtx.userPayload.userRecord);
+      if (await dciData.Load(DataContextItemID)) {
+        const dci = DataContext.CreateDataContextItem(); // use class factory to get whatever lowest level sub-class is registered
+        await dci.LoadMetadataFromEntityRecord(dciData, Metadata.Provider, appCtx.userPayload.userRecord);
+        // now the metadata is loaded so we can call the regular load function
+        if (await dci.LoadData(ds)) {
+          return {
+            Success: true,
+            ErrorMessage: null,
+            Result: JSON.stringify(dci.Data),
+          };
+        } else {
+          return {
+            Success: false,
+            ErrorMessage: 'Error loading data context item data',
+            Result: null,
+          };
         }
+      } else {
+        return {
+          Success: false,
+          ErrorMessage: 'Error loading data context item metadata',
+          Result: null,
+        };
+      }
+    } catch (e) {
+      return {
+        Success: false,
+        ErrorMessage: e,
+        Result: null,
+      };
     }
+  }
 
-    /**
-     * Returns data for a given data context. 
-     * @param DataContextID 
-     */
-    @Query(() => GetDataContextDataOutputType)
-    async GetDataContextData(
-        @Arg('DataContextID', () => String) DataContextID: string,
-        @Ctx() appCtx: AppContext
-    ) {
-        try {
-            // our job here is to load the entire data context, so we do that with the Data Context object
-            const dc = new DataContext();
-            const ds = GetReadOnlyDataSource(appCtx.dataSources, {
-                allowFallbackToReadWrite: true,
-            })
-            const success = await dc.Load(DataContextID, ds, true, false, 0, appCtx.userPayload.userRecord);
-            if (success) {
-                const retVal =   {
-                    Success: true,
-                    ErrorMessages: null,
-                    Results: dc.Items.map((item) => {
-                        return JSON.stringify(item.Data);
-                    }),
-                }
-                return retVal;
-            }
-            else {
-                return {
-                    Success: false,
-                    ErrorMessages: ['Error loading data context'],
-                    Results: null,    
-                }
-            }
-        }
-        catch (e) {
-            return {
-                Success: false,
-                ErrorMessages: [e],
-                Results: null,
-            }
-        }
+  /**
+   * Returns data for a given data context.
+   * @param DataContextID
+   */
+  @Query(() => GetDataContextDataOutputType)
+  async GetDataContextData(@Arg('DataContextID', () => String) DataContextID: string, @Ctx() appCtx: AppContext) {
+    try {
+      // our job here is to load the entire data context, so we do that with the Data Context object
+      const dc = new DataContext();
+      const ds = GetReadOnlyDataSource(appCtx.dataSources, {
+        allowFallbackToReadWrite: true,
+      });
+      const success = await dc.Load(DataContextID, ds, true, false, 0, appCtx.userPayload.userRecord);
+      if (success) {
+        const retVal = {
+          Success: true,
+          ErrorMessages: null,
+          Results: dc.Items.map((item) => {
+            return JSON.stringify(item.Data);
+          }),
+        };
+        return retVal;
+      } else {
+        return {
+          Success: false,
+          ErrorMessages: ['Error loading data context'],
+          Results: null,
+        };
+      }
+    } catch (e) {
+      return {
+        Success: false,
+        ErrorMessages: [e],
+        Results: null,
+      };
     }
-}
+  }
+}