@memberjunction/server 2.112.0 → 2.113.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/global';
+import { LogError, Metadata } from '@memberjunction/core';
 import { GetReadOnlyProvider } from '../util.js';
 
 @ObjectType()
@@ -33,16 +33,17 @@ 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 {
@@ -89,11 +90,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/global';
+import { RunViewParams } from '@memberjunction/core';
 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/global';
+import { Metadata, CompositeKey, DatabaseProviderBase } from '@memberjunction/core';
 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,21 +47,17 @@ 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/global';
+import { EntityPermissionType, IRunViewProvider } from '@memberjunction/core';
 import { AppContext } from '../types.js';
 import { Arg, Ctx, Query, Resolver, InputType, Field } from 'type-graphql';
 import { MJEntity_, MJEntityResolverBase } from '../generated/generated.js';
@@ -33,16 +33,14 @@ 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/global';
+import { CompositeKey, EntityDeleteOptions, EntityPermissionType, EntitySaveOptions, Metadata, RunView } from '@memberjunction/core';
 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/global';
+import { EntityPermissionType, Metadata, FieldValueCollection, EntitySaveOptions } from '@memberjunction/core';
 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,124 +1,136 @@
-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';
+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";
 
 @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,
-          };
+    /**
+     * 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,
+            }
         }
-      } 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,
+            }
+        }
     }
-  }
-}
+}