@memberjunction/server 5.37.0 → 5.39.0

package/src/agents/skip-sdk.ts

@@ -25,7 +25,7 @@ import {
 } from '@memberjunction/skip-types';
 import { DataContext } from '@memberjunction/data-context';
 import { IMetadataProvider, UserInfo, LogStatus, LogError, Metadata, RunQuery, RunView, EntityInfo, EntityFieldInfo, EntityFieldValueInfo, DatabaseProviderBase } from '@memberjunction/core';
-import { MJConversationDetailEntity } from '@memberjunction/core-entities';
+import { MJConversationDetailEntity, QueryEngine } from '@memberjunction/core-entities';
 import { request as httpRequest } from 'http';
 import { request as httpsRequest } from 'https';
 import { gzip as gzipCompress, createGunzip } from 'zlib';
@@ -483,15 +483,15 @@ export class SkipSDK {
      * Build saved queries for Skip
      */
     private buildQueries(status: "Pending" | "In-Review" | "Approved" | "Rejected" | "Obsolete" = 'Approved'): SkipQueryInfo[] {
-        const md = this.Provider;
-        const approvedQueries = md.Queries.filter((q) => q.Status === status);
+        const qe = QueryEngine.Instance;
+        const approvedQueries = qe.Queries.filter((q) => q.Status === status);
 
         return approvedQueries.map((q) => ({
             ID: q.ID,
             Name: q.Name,
             Description: q.Description,
             Category: q.Category,
-            CategoryPath: this.buildQueryCategoryPath(md, q.CategoryID),
+            CategoryPath: this.buildQueryCategoryPath(qe, q.CategoryID),
             CategoryID: q.CategoryID,
             SQL: q.SQL,
             Status: q.Status,
@@ -501,7 +501,7 @@ export class SkipSDK {
             EmbeddingModelID: q.EmbeddingModelID,
             EmbeddingModelName: q.EmbeddingModel,
             TechnicalDescription: q.TechnicalDescription,
-            Fields: q.Fields.map((f) => ({
+            Fields: qe.GetQueryFields(q.ID).map((f) => ({
                 ID: f.ID,
                 QueryID: f.QueryID,
                 Name: f.Name,
@@ -517,7 +517,7 @@ export class SkipSDK {
                 IsSummary: f.IsSummary,
                 SummaryDescription: f.SummaryDescription
             })),
-            Parameters: q.Parameters.map((p) => ({
+            Parameters: qe.GetQueryParameters(q.ID).map((p) => ({
                 ID: p.ID,
                 QueryID: p.QueryID,
                 Name: p.Name,
@@ -528,12 +528,15 @@ export class SkipSDK {
                 SampleValue: p.SampleValue,
                 ValidationFilters: p.ValidationFilters
             })),
-            Entities: q.Entities.map((e) => ({
+            Entities: qe.QueryEntities.filter(e => UUIDsEqual(e.QueryID, q.ID)).map((e) => ({
                 ID: e.ID,
                 QueryID: e.QueryID,
                 EntityID: e.EntityID,
                 Entity: e.Entity
             })),
+            SQLDialectID: q.SQLDialectID,
+            UsesTemplate: q.UsesTemplate,
+            IsApproved: q.IsApproved,
             CacheEnabled: q.CacheEnabled,
             CacheMaxSize: q.CacheMaxSize,
             CacheTTLMinutes: q.CacheTTLMinutes,
@@ -544,11 +547,11 @@ export class SkipSDK {
     /**
      * Recursively build category path for a query
      */
-    private buildQueryCategoryPath(md: IMetadataProvider, categoryID: string): string {
-        const cat = md.QueryCategories.find((c) => UUIDsEqual(c.ID, categoryID));
+    private buildQueryCategoryPath(qe: QueryEngine, categoryID: string): string {
+        const cat = qe.Categories.find((c) => UUIDsEqual(c.ID, categoryID));
         if (!cat) return '';
         if (!cat.ParentID) return cat.Name;
-        const parentPath = this.buildQueryCategoryPath(md, cat.ParentID);
+        const parentPath = this.buildQueryCategoryPath(qe, cat.ParentID);
         return parentPath ? `${parentPath}/${cat.Name}` : cat.Name;
     }
 
@@ -560,11 +563,11 @@ export class SkipSDK {
      * across all queries, not just approved ones.
      */
     private buildQueryCatalog(): SkipQueryCatalogEntry[] {
-        const md = this.Provider;
+        const qe = QueryEngine.Instance;
 
-        return md.Queries.map((q) => ({
+        return qe.Queries.map((q) => ({
             Name: q.Name,
-            CategoryPath: this.buildQueryCategoryPath(md, q.CategoryID)
+            CategoryPath: this.buildQueryCategoryPath(qe, q.CategoryID)
         }));
     }
 

package/src/apolloServer/index.ts

@@ -15,6 +15,63 @@ import { SQLServerDataProvider } from '@memberjunction/sqlserver-dataprovider';
  * @param servers - HTTP server and WebSocket cleanup disposable
  * @param additionalPlugins - Optional additional plugins to merge with built-in plugins
  */
+/**
+ * Apollo plugin: log every Integration* GraphQL operation to stdout as
+ * structured JSON.  Lets operators tailing the MJAPI log see exactly which
+ * resolver the wizard / Explorer hit on each press, with arg names (values
+ * redacted for credentials).  Diagnostic-only — no behavior change.
+ *
+ * Emits two events per operation:
+ *   {"event":"gql.integration.request","method":"...","fieldName":"...","argNames":[...]}
+ *   {"event":"gql.integration.response","method":"...","fieldName":"...","durationMs":N,"hasErrors":bool}
+ *
+ * Filter from the log:
+ *   tail -f /tmp/mjapi.log | grep '"event":"gql\.integration\.'
+ */
+const integrationOperationTracer: ApolloServerPlugin = {
+  async requestDidStart(requestCtx) {
+    // Off by default — the plugin stays registered but emits nothing unless the
+    // MJ_INTEGRATION_TRACE debug flag is explicitly set. Avoids logging on every
+    // request in normal operation.
+    if (process.env.MJ_INTEGRATION_TRACE !== 'true') return undefined;
+    const opName = requestCtx.request.operationName ?? 'anonymous';
+    const query = requestCtx.request.query ?? '';
+    // Lightweight match — fire only for operations that touch an Integration
+    // resolver field.  Avoid logging every Color / User / Task query.
+    if (!query.includes('Integration')) return undefined;
+    const startedAt = Date.now();
+    return {
+      async willSendResponse(rc) {
+        // Walk the fields the operation queried; only those starting with
+        // "Integration" matter.  Variables surfaced as keys only.
+        const op = rc.operation;
+        if (!op) return;
+        const integrationFields: string[] = [];
+        for (const sel of op.selectionSet.selections) {
+          if (sel.kind === 'Field' && sel.name.value.startsWith('Integration')) {
+            integrationFields.push(sel.name.value);
+          }
+        }
+        if (integrationFields.length === 0) return;
+        const argNames = Object.keys(rc.request.variables ?? {});
+        const durationMs = Date.now() - startedAt;
+        const hasErrors = !!(rc.response.body.kind === 'single' && rc.response.body.singleResult.errors?.length);
+        for (const field of integrationFields) {
+          console.log(JSON.stringify({
+            ts: new Date().toISOString(),
+            event: 'gql.integration.response',
+            operationName: opName,
+            method: field,
+            argNames,
+            durationMs,
+            hasErrors,
+          }));
+        }
+      },
+    };
+  },
+};
+
 const buildApolloServer = (
   configOverride: ApolloServerOptions<AppContext>,
   { httpServer, serverCleanup }: { httpServer: Server; serverCleanup: Disposable },
@@ -22,6 +79,7 @@ const buildApolloServer = (
 ) => {
   const builtInPlugins: ApolloServerPlugin[] = [
     ApolloServerPluginDrainHttpServer({ httpServer }),
+    integrationOperationTracer,
     {
       async serverWillStart() {
         return {

package/src/config.ts

@@ -205,6 +205,21 @@ const cacheSettingsSchema = z.object({
   verboseLogging: z.boolean().optional().default(false),
 });
 
+const loggingSettingsSchema = z.object({
+  graphql: z.object({
+    /**
+     * When true, emit a redacted variables block per root resolver call via the
+     * type-graphql global middleware. Default: false in all environments regardless
+     * of NODE_ENV. Env override: `MJ_LOG_GRAPHQL_VARIABLES`.
+     *
+     * SECURITY: this is an opt-in verbose-echo path for developers debugging locally.
+     * The always-on request log line in `context.ts` does NOT emit variables — that
+     * is the load-bearing leak fix. This flag is additive on top of the always-on log.
+     */
+    logVariables: z.boolean().optional().default(false),
+  }).optional().default({}),
+});
+
 const feedbackGithubSettingsSchema = z.object({
   owner: z.string().optional(),
   repo: z.string().optional(),
@@ -236,6 +251,7 @@ const configInfoSchema = z.object({
   multiTenancy: multiTenancySchema.optional().default({}),
   serverExtensions: z.array(serverExtensionSchema).optional().default([]),
   cacheSettings: cacheSettingsSchema.optional().default({}),
+  loggingSettings: loggingSettingsSchema.optional().default({}),
   feedbackSettings: feedbackSettingsSchema.optional().default({}),
 
   apiKey: z.string().optional(),
@@ -284,6 +300,7 @@ export type QueryDialectConfig = z.infer<typeof queryDialectSchema>;
 export type MultiTenancyConfig = z.infer<typeof multiTenancySchema>;
 export type ServerExtensionConfig = z.infer<typeof serverExtensionSchema>;
 export type CacheSettingsConfig = z.infer<typeof cacheSettingsSchema>;
+export type LoggingSettingsConfig = z.infer<typeof loggingSettingsSchema>;
 export type FeedbackGithubSettingsConfig = z.infer<typeof feedbackGithubSettingsSchema>;
 export type FeedbackSettingsConfig = z.infer<typeof feedbackSettingsSchema>;
 export type ConfigInfo = z.infer<typeof configInfoSchema>;
@@ -421,6 +438,16 @@ export const DEFAULT_SERVER_CONFIG: Partial<ConfigInfo> = {
     verboseLogging: false,
   },
 
+  // Logging settings defaults — variables logging is always off unless the operator
+  // sets MJ_LOG_GRAPHQL_VARIABLES=true (or sets logVariables in mj.config.cjs).
+  // NOTE: this only governs the opt-in verbose-echo middleware. The always-on request
+  // log in context.ts already strips variables unconditionally.
+  loggingSettings: {
+    graphql: {
+      logVariables: parseBooleanEnv(process.env.MJ_LOG_GRAPHQL_VARIABLES),
+    },
+  },
+
   // Auth providers (environment-driven)
   authProviders: [
     // Microsoft Azure AD / Entra ID

package/src/context.ts

@@ -9,6 +9,7 @@ import { getSigningKeys, getSystemUser, getValidationOptions, verifyUserRecord,
 import { TokenExpiredError, AuthProviderFactory } from '@memberjunction/auth-providers';
 import { authCache } from './cache.js';
 import { userEmailMap, apiKey, mj_core_schema } from './config.js';
+import { buildBoundaryLogPayload } from './logging/boundaryLogPayload.js';
 import { DataSourceInfo, UserPayload } from './types.js';
 import { GetReadOnlyDataSource, GetReadWriteDataSource } from './util.js';
 import { v4 as uuidv4 } from 'uuid';
@@ -21,24 +22,6 @@ import { UUIDsEqual } from '@memberjunction/global';
 import { resolveDbPlatformFromEnv } from '@memberjunction/generic-database-provider';
 import { GetAPIKeyEngine } from '@memberjunction/api-keys';
 
-/**
- * Renders a value for one-line console logging without Node's `[Object]` truncation.
- * Arrays keep their structure; non-array objects collapse to JSON, truncated at `maxLen`.
- * Objects whose JSON exceeds `maxLen` and contain nested structure are recursed into so
- * outer keys remain visible.
- */
-function shortenForLog(value: unknown, maxLen = 300): unknown {
-  if (value === null || typeof value !== 'object') return value;
-  if (Array.isArray(value)) return value.map((v) => shortenForLog(v, maxLen));
-  const json = JSON.stringify(value);
-  if (json.length <= maxLen) return json;
-  const result: Record<string, unknown> = {};
-  for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
-    result[k] = shortenForLog(v, maxLen);
-  }
-  return result;
-}
-
 const verifyAsync = async (issuer: string, token: string): Promise<jwt.JwtPayload> =>
   new Promise((resolve, reject) => {
     const options = getValidationOptions(issuer);
@@ -342,7 +325,7 @@ export const contextFunction =
     const reqAny = req as any;
     const operationName: string | undefined = reqAny.body?.operationName;
     if (operationName !== 'IntrospectionQuery') {
-      console.dir({ operationName, variables: shortenForLog(reqAny.body?.variables) }, { depth: null, breakLength: 200 });
+      console.dir(buildBoundaryLogPayload(operationName), { depth: null, breakLength: 200 });
     }
 
     // Auth already happened in the unified auth middleware — just read the result