@memberjunction/server 5.43.0 → 5.45.0

package/src/resolvers/QuerySystemUserResolver.ts

@@ -1,7 +1,6 @@
 import { Arg, Ctx, Field, InputType, Mutation, ObjectType, registerEnumType, Resolver, PubSub, PubSubEngine } from 'type-graphql';
 import { AppContext } from '../types.js';
 import { LogError, UserInfo, CompositeKey, DatabaseProviderBase, LogStatus } from '@memberjunction/core';
-import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { MJQueryCategoryEntity, MJQueryPermissionEntity, MJQueryFieldEntity, MJQueryParameterEntity, MJQueryEntityEntity, QueryEngine } from '@memberjunction/core-entities';
 import { MJQueryResolver, MJQuery_, MJQueryField_, MJQueryParameter_, MJQueryEntity_, MJQueryPermission_ } from '../generated/generated.js';
 import { GetReadWriteProvider } from '../util.js';
@@ -229,19 +228,21 @@ export class DeleteQueryResultType {
 @Resolver()
 export class MJQueryResolverExtended extends MJQueryResolver {
     /**
-     * Creates a new query with the provided attributes. This mutation is restricted to system users only.
+     * Creates a new query with the provided attributes. Requires `query:create` scope for API key users;
+     * entity-level create permission on MJ: Queries for all users.
      * @param input - CreateQuerySystemUserInput containing all the query attributes
      * @param context - Application context containing user information
      * @returns CreateQueryResultType with success status and query data
      */
-    @RequireSystemUser()
     @Mutation(() => QueryMutationResultType)
-    async CreateQuerySystemUser(
+    async CreateQueryExtended(
         @Arg('input', () => CreateQuerySystemUserInput) input: CreateQuerySystemUserInput,
         @Ctx() context: AppContext,
         @PubSub() pubSub: PubSubEngine
     ): Promise<QueryMutationResultType> {
         try {
+            await this.CheckAPIKeyScopeAuthorization('query:create', '*', context.userPayload);
+
             // Handle CategoryPath if provided
             let finalCategoryID = input.CategoryID;
             const provider = GetReadWriteProvider(context.providers);
@@ -443,19 +444,21 @@ export class MJQueryResolverExtended extends MJQueryResolver {
     }
 
     /**
-     * Updates an existing query with the provided attributes. This mutation is restricted to system users only.
+     * Updates an existing query with the provided attributes. Requires `query:update` scope for API key users;
+     * entity-level update permission on MJ: Queries for all users.
      * @param input - UpdateQuerySystemUserInput containing the query ID and fields to update
      * @param context - Application context containing user information
      * @returns UpdateQueryResultType with success status and updated query data including related entities
      */
-    @RequireSystemUser()
     @Mutation(() => QueryMutationResultType)
-    async UpdateQuerySystemUser(
+    async UpdateQueryExtended(
         @Arg('input', () => UpdateQuerySystemUserInput) input: UpdateQuerySystemUserInput,
         @Ctx() context: AppContext,
         @PubSub() pubSub: PubSubEngine
     ): Promise<QueryMutationResultType> {
         try {
+            await this.CheckAPIKeyScopeAuthorization('query:update', input.ID, context.userPayload);
+
             // Load the existing query using MJQueryEntityServer
             const provider = GetReadWriteProvider(context.providers);
             const queryEntity = await provider.GetEntityObject<MJQueryEntityServer>('MJ: Queries', context.userPayload.userRecord);
@@ -547,21 +550,22 @@ export class MJQueryResolverExtended extends MJQueryResolver {
     }
 
     /**
-     * Deletes a query by ID. This mutation is restricted to system users only.
+     * Deletes a query by ID. Requires `query:delete` scope for API key users;
+     * entity-level delete permission on MJ: Queries is enforced by the entity framework.
      * @param ID - The ID of the query to delete
      * @param options - Delete options controlling action execution
      * @param context - Application context containing user information
      * @returns DeleteQueryResultType with success status and deleted query data
      */
-    @RequireSystemUser()
     @Mutation(() => DeleteQueryResultType)
-    async DeleteQuerySystemResolver(
+    async DeleteQueryExtended(
         @Arg('ID', () => String) ID: string,
         @Arg('options', () => DeleteOptionsInput, { nullable: true }) options: DeleteOptionsInput | null,
         @Ctx() context: AppContext,
         @PubSub() pubSub: PubSubEngine
     ): Promise<DeleteQueryResultType> {
         try {
+            await this.CheckAPIKeyScopeAuthorization('query:delete', ID, context.userPayload);
             // Validate ID is not null/undefined/empty
             if (!ID || ID.trim() === '') {
                 return {

package/src/resolvers/RealtimeBridgeResolver.ts

@@ -9,6 +9,7 @@ import { CreateBridgeRealtimeSession, FinalizeBridgeCoAgentRuns, GetRealtimeMode
 import { AIBridgeEngine } from '@memberjunction/ai-bridge-server';
 import { SessionManager } from '../agentSessions/SessionManager.js';
 import { NotificationEngine } from '@memberjunction/notifications';
+import { registerMeetingRecordingFile, correlateRecordingStart } from './meetingRecordingRegistration.js';
 
 /**
  * Binds the agent realtime-session factory onto the LiveKit room coordinator's model-session creation seam.
@@ -174,6 +175,10 @@ export class LiveKitRecordingResult {
 
   @Field(() => String)
   Status: string;
+
+  /** The `MJ: Files` row id of the registered recording (set on stop, once the egress MP4 is registered). */
+  @Field(() => String, { nullable: true })
+  RecordingFileID?: string;
 }
 
 /** A selectable provider-native voice for the dev voice picker. */
@@ -444,10 +449,17 @@ export class RealtimeBridgeResolver extends ResolverBase {
     @Ctx() context: AppContext = {} as AppContext,
   ): Promise<LiveKitRecordingResult> {
     try {
-      if (!this.GetUserFromPayload(context.userPayload)) {
+      const user = this.GetUserFromPayload(context.userPayload);
+      if (!user) {
         return { Success: false, ErrorMessage: 'Unable to determine current user.', EgressID: '', Status: '' };
       }
       const info = await new LiveKitEgressService().StartRoomRecording({ RoomName: input.RoomName, Layout: input.Layout });
+
+      // Best-effort: correlate the live recording with the room's Meeting-Room Conversation (if it exists
+      // yet) by stamping its EgressID. Never fail the start on this — the stop-flow resolves/creates it.
+      const provider = GetReadWriteProvider(context.providers) as unknown as IMetadataProvider;
+      void correlateRecordingStart(input.RoomName, info.EgressID, user, provider);
+
       return { Success: true, EgressID: info.EgressID, Status: info.Status };
     } catch (error) {
       const msg = error instanceof Error ? error.message : String(error);
@@ -456,15 +468,35 @@ export class RealtimeBridgeResolver extends ResolverBase {
     }
   }
 
-  /** Stops a recording by egress id. */
+  /**
+   * Stops a recording by egress id, then REGISTERS the completed egress MP4 into MJStorage as an
+   * `MJ: Files` row linked to the room's Meeting-Room Conversation (`Conversation.RecordingFileID`).
+   * Registration is best-effort: a missing storage config or any failure returns the stop result with no
+   * `RecordingFileID` (the recording still stopped) — it never throws.
+   */
   @Mutation(() => LiveKitRecordingResult)
   async StopLiveKitRecording(@Arg('egressID', () => String) egressID: string, @Ctx() context: AppContext = {} as AppContext): Promise<LiveKitRecordingResult> {
     try {
-      if (!this.GetUserFromPayload(context.userPayload)) {
+      const user = this.GetUserFromPayload(context.userPayload);
+      if (!user) {
         return { Success: false, ErrorMessage: 'Unable to determine current user.', EgressID: egressID, Status: '' };
       }
       const info = await new LiveKitEgressService().StopRecording(egressID);
-      return { Success: true, EgressID: info.EgressID, Status: info.Status };
+      const provider = GetReadWriteProvider(context.providers) as unknown as IMetadataProvider;
+
+      // Register the completed egress MP4 as a Files row on the Meeting-Room Conversation. Best-effort:
+      // any failure (e.g. storage provider not configured) leaves RecordingFileID unset but still
+      // returns the successful stop result.
+      const registration = await registerMeetingRecordingFile(
+        { EgressID: info.EgressID, RoomName: info.RoomName, OutputLocation: info.OutputLocation, OutputSizeBytes: info.OutputSizeBytes },
+        user,
+        provider,
+      );
+      if (!registration.Success) {
+        LogError(`StopLiveKitRecording: recording stopped but registration did not complete: ${registration.ErrorMessage ?? 'unknown'}`);
+      }
+
+      return { Success: true, EgressID: info.EgressID, Status: info.Status, RecordingFileID: registration.RecordingFileID };
     } catch (error) {
       const msg = error instanceof Error ? error.message : String(error);
       LogError(`StopLiveKitRecording failed: ${msg}`);