@memberjunction/server 6.1.0-edge.2 → 6.1.0-edge.3

package/src/integration/SchemaRefreshLaunch.ts

@@ -0,0 +1,77 @@
+/**
+ * @fileoverview Pure reporting helpers for the connector schema-refresh pipeline launch.
+ *
+ * The refresh is a live vendor introspect and can run for minutes on a large catalog, so
+ * IntegrationCreateConnection / IntegrationUpdateConnection can launch it *detached* and hand the
+ * caller a tailable run ID instead of blocking. That split creates one easy-to-get-wrong reporting
+ * case: a detached summary's counts are placeholder zeros, and describing them as results ("0
+ * created, 0 updated") reads to an operator as "the refresh found nothing" — the opposite of "the
+ * refresh has not finished yet". This module owns that decision so it can be pinned by a test
+ * without standing up a resolver.
+ */
+
+/**
+ * The subset of the pipeline summary that message construction reads. Structural so both the
+ * GraphQL `@ObjectType` and a test fixture satisfy it without either depending on the other.
+ */
+export interface SchemaRefreshSummaryLike {
+    /** Tailable run ID — the only meaningful field while `InProgress` is true. */
+    RunID: string;
+    /** True ⇒ launched detached and still running; every count below is a placeholder zero. */
+    InProgress: boolean;
+    /**
+     * Whether the pipeline itself succeeded. A pipeline that fails at ConnectionTest RETURNS rather
+     * than throwing, with every count at zero — so counts alone read identically to a clean
+     * no-op refresh. Reporting that as "0 created, 0 updated" tells an operator the vendor had
+     * nothing new when in fact the credentials were never accepted.
+     */
+    Succeeded: boolean;
+    /** The pipeline's own failure reason, when `Succeeded` is false. */
+    FailureMessage?: string;
+    ObjectsCreated: number;
+    ObjectsUpdated: number;
+    UnresolvedObjects: string[];
+}
+
+/** The counts clause, or an explicit failure clause when the pipeline did not succeed. */
+function describeFinishedRefresh(summary: SchemaRefreshSummaryLike): string {
+    if (!summary.Succeeded) {
+        return `schema refresh FAILED (${summary.FailureMessage ?? 'no reason reported'}) — see run ${summary.RunID}`;
+    }
+    return `schema refresh: ${summary.ObjectsCreated} created, ` +
+        `${summary.ObjectsUpdated} updated, ${summary.UnresolvedObjects.length} PK-unresolved`;
+}
+
+/**
+ * Builds the human-facing `Message` for IntegrationCreateConnection.
+ *
+ * @param testConnection whether the caller asked for (and got) a live connection test
+ * @param summary the refresh summary, or undefined when no refresh was requested
+ */
+export function BuildCreateConnectionMessage(
+    testConnection: boolean,
+    summary: SchemaRefreshSummaryLike | undefined
+): string {
+    if (!summary) return 'Connection created and test passed';
+    const created = `Connection created${testConnection ? ', test passed' : ''}`;
+    // Never report a detached run's placeholder counts as findings — point at the run stream instead.
+    if (summary.InProgress) return `${created}, schema refresh running — tail run ${summary.RunID}`;
+    return `${created}, ${describeFinishedRefresh(summary)}`;
+}
+
+/**
+ * Builds the human-facing `Message` for IntegrationUpdateConnection's blocking-refresh path.
+ * Shares {@link describeFinishedRefresh} with create so a failed refresh can never be reported as
+ * a clean zero-count run on one path and honestly on the other.
+ */
+export function BuildUpdateConnectionMessage(summary: SchemaRefreshSummaryLike): string {
+    return `Updated, ${describeFinishedRefresh(summary)}`;
+}
+
+/**
+ * Builds the human-facing `Message` for IntegrationUpdateConnection's detached-refresh path.
+ * Separate from {@link BuildCreateConnectionMessage} because update has no connection-test clause.
+ */
+export function BuildDetachedRefreshMessage(runID: string): string {
+    return `Updated, schema refresh running — tail run ${runID}`;
+}

package/src/providerConfigUnits.ts

@@ -0,0 +1,21 @@
+/**
+ * Unit-conversion seam between MJServer's configuration and SQLServerDataProvider.
+ *
+ * MJServer configures `databaseSettings.metadataCacheRefreshInterval` in **milliseconds**
+ * (default 180000 = 3 minutes, overridable via the METADATA_CACHE_REFRESH_INTERVAL env var).
+ * `SQLServerProviderConfigData`'s third constructor parameter is `checkRefreshIntervalSeconds`
+ * — declared in **seconds**.
+ *
+ * Commit 645c5a5e8 fixed a bug where the raw millisecond value was handed straight to the
+ * provider, so the "3 minute" default became a 180000-second (~50 hour) metadata cache
+ * refresh cadence. This function is the single place that conversion happens; both provider
+ * bootstrap call sites in `index.ts` (the main pool and the CodeGen-credentialed pool) go
+ * through it, and `config-units.test.ts` pins the contract so the units can never silently
+ * regress again.
+ *
+ * @param metadataCacheRefreshIntervalMs - the configured refresh interval, in milliseconds
+ * @returns the same interval expressed in seconds, the unit `checkRefreshIntervalSeconds` declares
+ */
+export function MetadataCacheRefreshIntervalSeconds(metadataCacheRefreshIntervalMs: number): number {
+    return metadataCacheRefreshIntervalMs / 1000;
+}

package/src/resolvers/FileResolver.ts

@@ -41,6 +41,7 @@ import { FieldMapper } from '@memberjunction/graphql-dataprovider';
 import { GetReadOnlyProvider } from '../util.js';
 import { configInfo } from '../config.js';
 import { MediaAccessKeyManager } from '../rest/MediaAccessKeys.js';
+import { UploadTokenManager } from '../rest/UploadTokenManager.js';
 import { deriveSidecarPath, parsePeaksSidecar } from './peaksSidecar.js';
 
 @InputType()
@@ -49,6 +50,63 @@ export class CreateUploadURLInput {
   FileID: string;
 }
 
+@InputType()
+export class UploadStorageFileInput {
+  @Field(() => String, { nullable: true })
+  FileName?: string;
+
+  @Field(() => String, { nullable: true })
+  Base64Data?: string;
+
+  @Field(() => String, { nullable: true })
+  UploadToken?: string;
+
+  @Field(() => String, { nullable: true })
+  MimeType?: string;
+
+  @Field(() => String, { nullable: true })
+  AccountID?: string;
+
+  @Field(() => String, { nullable: true })
+  CategoryID?: string;
+
+  @Field(() => String, { nullable: true })
+  Description?: string;
+
+  @Field(() => String, { nullable: true })
+  PathPrefix?: string;
+}
+
+@ObjectType()
+export class UploadStorageFilePayload {
+  @Field(() => Boolean)
+  Success: boolean;
+
+  @Field(() => String, { nullable: true })
+  FileID?: string;
+
+  @Field(() => MJFile_, { nullable: true })
+  File?: MJFile_;
+
+  @Field(() => String, { nullable: true })
+  ErrorMessage?: string;
+}
+
+@ObjectType()
+export class CreateUploadStageTokenPayload {
+  @Field(() => Boolean)
+  Success: boolean;
+
+  @Field(() => String, { nullable: true })
+  Token?: string;
+
+  @Field(() => String, { nullable: true })
+  Url?: string;
+
+  @Field(() => String, { nullable: true })
+  ErrorMessage?: string;
+}
+
 @ObjectType()
 export class CreateFilePayload {
   @Field(() => MJFile_)
@@ -414,7 +472,8 @@ export class FileResolver extends FileResolverBase {
 
       // Access authorized — mint the capability token.
       const { Token, ExpiresAt } = MediaAccessKeyManager.Instance.Sign(fileId, contextUser.ID);
-      const url = `${this.resolvePublicBaseUrl()}/media/${encodeURIComponent(fileId)}?token=${encodeURIComponent(Token)}`;
+      const fileNameSuffix = fileEntity.Name ? `/${encodeURIComponent(fileEntity.Name)}` : '';
+      const url = `${this.resolvePublicBaseUrl()}/media/${encodeURIComponent(fileId)}${fileNameSuffix}?token=${encodeURIComponent(Token)}`;
 
       // Best-effort: surface precomputed waveform peaks from a peaks.json sidecar beside the file, so
       // the player renders the real waveform instantly without fetching/decoding the audio. Never
@@ -573,6 +632,85 @@ export class FileResolver extends FileResolverBase {
     return { File, UploadUrl, NameExists };
   }
 
+  /**
+   * Direct server-side file upload using MJ Storage subsystem.
+   * Uploads file contents directly via the configured storage driver (Box, Azure, S3, Google Drive, Dropbox, etc.)
+   * and creates/persists the MJ: Files database record.
+   */
+  @Mutation(() => UploadStorageFilePayload)
+  async UploadStorageFile(
+    @Arg('input', () => UploadStorageFileInput) input: UploadStorageFileInput,
+    @Ctx() context: AppContext
+  ): Promise<UploadStorageFilePayload> {
+    try {
+      const provider = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
+      const user = this.GetUserFromPayload(context.userPayload);
+
+      // Permission check on MJ: Files
+      const fileEntity = await provider.GetEntityObject<MJFileEntity>('MJ: Files', user);
+      fileEntity.CheckPermissions(EntityPermissionType.Create, true);
+
+      let buffer: Buffer;
+      let fileName: string = input.FileName || 'file';
+      let mimeType: string = input.MimeType || 'application/octet-stream';
+
+      if (input.UploadToken) {
+        const staged = UploadTokenManager.Instance.Consume(input.UploadToken, user.ID);
+        if (!staged) {
+          return {
+            Success: false,
+            ErrorMessage: 'Upload token is invalid, expired, or has already been used.',
+          };
+        }
+        buffer = staged.buffer;
+        fileName = input.FileName || staged.fileName || 'file';
+        mimeType = input.MimeType || staged.mimeType || 'application/octet-stream';
+      } else if (input.Base64Data) {
+        buffer = Buffer.from(input.Base64Data, 'base64');
+      } else {
+        return {
+          Success: false,
+          ErrorMessage: 'Either UploadToken or Base64Data must be provided.',
+        };
+      }
+
+      // Ensure FileStorageEngine is configured under the user context
+      await FileStorageEngine.Instance.Config(false, user, provider);
+      if (input.AccountID && !FileStorageEngine.Instance.GetAccountById(input.AccountID)) {
+        await FileStorageEngine.Instance.Config(true, user, provider);
+      }
+
+      const uploadResult = await FileStorageEngine.Instance.UploadFile({
+        content: buffer,
+        fileName,
+        mimeType,
+        contextUser: user,
+        storageAccountId: input.AccountID,
+        categoryID: input.CategoryID,
+        description: input.Description,
+        pathPrefix: input.PathPrefix,
+        provider,
+      });
+
+      const loaded = await fileEntity.Load(uploadResult.FileID);
+      const mapper = new FieldMapper();
+      const File = loaded ? (mapper.MapFields({ ...fileEntity.GetAll() }) as unknown as MJFile_) : undefined;
+
+      return {
+        Success: true,
+        FileID: uploadResult.FileID,
+        File,
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      LogError(`UploadStorageFile failed for '${input.FileName}': ${message}`);
+      return {
+        Success: false,
+        ErrorMessage: message,
+      };
+    }
+  }
+
   @FieldResolver(() => String)
   async DownloadUrl(@Root() file: MJFile_, @Ctx() context: AppContext) {
     const md = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
@@ -580,6 +718,19 @@ export class FileResolver extends FileResolverBase {
     const fileEntity = await md.GetEntityObject<MJFileEntity>('MJ: Files', user);
     fileEntity.CheckPermissions(EntityPermissionType.Read, true);
 
+    await FileStorageEngine.Instance.Config(false, user, md);
+    let accounts = FileStorageEngine.Instance.GetAccountsByProviderID(file.ProviderID);
+    if (accounts.length === 0) {
+      await FileStorageEngine.Instance.Config(true, user, md);
+      accounts = FileStorageEngine.Instance.GetAccountsByProviderID(file.ProviderID);
+    }
+
+    if (accounts.length > 0) {
+      const account = accounts[0];
+      const driver = await FileStorageEngine.Instance.GetDriver(account.ID, user);
+      return await driver.CreatePreAuthDownloadUrl(file.ProviderKey ?? file.Name);
+    }
+
     const providerEntity = await md.GetEntityObject<MJFileStorageProviderEntity>('MJ: File Storage Providers', user);
     await providerEntity.Load(file.ProviderID);
 
@@ -734,16 +885,13 @@ export class FileResolver extends FileResolverBase {
     const md = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
     const user = this.GetUserFromPayload(context.userPayload);
 
-    // Load the account and its provider
-    const { account, provider: providerEntity } = await this.loadAccountAndProvider(input.AccountID, context);
-
     // Check permissions
     const fileEntity = await md.GetEntityObject<MJFileEntity>('MJ: Files', user);
     fileEntity.CheckPermissions(EntityPermissionType.Read, true);
 
-    // Create download URL with extended user context (includes account for credential lookup)
-    const userContext = this.buildExtendedUserContext(context, account);
-    const downloadUrl = await createDownloadUrl(providerEntity, input.ObjectName, userContext);
+    await FileStorageEngine.Instance.Config(false, user, md);
+    const driver = await FileStorageEngine.Instance.GetDriver(input.AccountID, user);
+    const downloadUrl = await driver.CreatePreAuthDownloadUrl(input.ObjectName);
     return downloadUrl;
   }
 
@@ -762,67 +910,79 @@ export class FileResolver extends FileResolverBase {
    * @see CreateFile for the legacy path that also creates a File entity record.
    */
   @Mutation(() => CreatePreAuthUploadUrlPayload)
-  async CreatePreAuthUploadUrl(@Arg('input', () => CreatePreAuthUploadUrlInput) input: CreatePreAuthUploadUrlInput, @Ctx() context: AppContext) {
+  async CreatePreAuthUploadUrl(
+    @Arg('input', () => CreatePreAuthUploadUrlInput) input: CreatePreAuthUploadUrlInput,
+    @Ctx() context: AppContext
+  ): Promise<CreatePreAuthUploadUrlPayload> {
     const md = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
     const user = this.GetUserFromPayload(context.userPayload);
 
-    // Load the account and its provider
-    const { account, provider: providerEntity } = await this.loadAccountAndProvider(input.AccountID, context);
-
     // Check permissions
     const fileEntity = await md.GetEntityObject<MJFileEntity>('MJ: Files', user);
     fileEntity.CheckPermissions(EntityPermissionType.Create, true);
 
-    // Create upload URL with extended user context (includes account for credential lookup)
-    const userContext = this.buildExtendedUserContext(context, account);
-    const { UploadUrl, updatedInput } = await createUploadUrl(
-      providerEntity,
-      {
-        ID: '', // Not needed for direct upload
-        Name: input.ObjectName,
-        ProviderID: providerEntity.ID,
-        ContentType: input.ContentType,
-      },
-      userContext,
-    );
-
-    // Extract ProviderKey if it exists (spread into updatedInput by createUploadUrl)
-    const providerKey = (updatedInput as { ProviderKey?: string }).ProviderKey;
+    await FileStorageEngine.Instance.Config(false, user, md);
+    const driver = await FileStorageEngine.Instance.GetDriver(input.AccountID, user);
+    if (!driver.SupportsPreAuthUpload) {
+      throw new Error(`Storage provider '${driver.constructor.name}' does not support pre-authenticated direct uploads.`);
+    }
+
+    const result = await driver.CreatePreAuthUploadUrl(input.ObjectName);
 
     return {
-      UploadUrl,
-      ProviderKey: providerKey,
+      UploadUrl: result.UploadUrl,
+      ProviderKey: result.ProviderKey,
     };
   }
 
+  /**
+   * Mints a cryptographically signed, short-lived media-upload token for staging raw binary files.
+   * Checks user permissions on `MJ: Files` before issuing.
+   */
+  @Mutation(() => CreateUploadStageTokenPayload)
+  async CreateUploadStageToken(
+    @Ctx() context: AppContext
+  ): Promise<CreateUploadStageTokenPayload> {
+    try {
+      const provider = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
+      const user = this.GetUserFromPayload(context.userPayload);
+
+      // Permission check on MJ: Files
+      const fileEntity = await provider.GetEntityObject<MJFileEntity>('MJ: Files', user);
+      fileEntity.CheckPermissions(EntityPermissionType.Create, true);
+
+      const mint = MediaAccessKeyManager.Instance.SignUpload(user.ID);
+
+      return {
+        Success: true,
+        Token: mint.Token,
+        Url: '/media/upload-stage',
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        Success: false,
+        ErrorMessage: message,
+      };
+    }
+  }
+
   @Mutation(() => Boolean)
   async DeleteStorageObject(@Arg('input', () => DeleteStorageObjectInput) input: DeleteStorageObjectInput, @Ctx() context: AppContext) {
-    console.log('[FileResolver] DeleteStorageObject called:', input);
-
     const md = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
     const user = this.GetUserFromPayload(context.userPayload);
 
     // Load the account and its provider
     const { account, provider: providerEntity } = await this.loadAccountAndProvider(input.AccountID, context);
 
-    console.log('[FileResolver] Provider loaded:', {
-      providerID: providerEntity.ID,
-      providerName: providerEntity.Name,
-      serverDriverKey: providerEntity.ServerDriverKey,
-    });
-
     // Check permissions
     const fileEntity = await md.GetEntityObject<MJFileEntity>('MJ: Files', user);
     fileEntity.CheckPermissions(EntityPermissionType.Delete, true);
 
-    console.log('[FileResolver] Permissions checked, calling deleteObject...');
-
     // Delete the object with extended user context (includes account for credential lookup)
     const userContext = this.buildExtendedUserContext(context, account);
     const success = await deleteObject(providerEntity, input.ObjectName, userContext);
 
-    console.log('[FileResolver] deleteObject returned:', success);
-
     return success;
   }