memind/server/portal-mindspace-asset-delivery-routes.mjs

import {
  createDownloadConversationPackageArtifactHandler,
  createDownloadConversationPackageManifestHandler,
  createGetConversationPackageHandler,
} from '../mindspace-conversation-package-routes.mjs';

function assertRouter(api) {
  if (
    !api ||
    typeof api.get !== 'function' ||
    typeof api.post !== 'function' ||
    typeof api.put !== 'function' ||
    typeof api.delete !== 'function'
  ) {
    throw new Error(
      'attachPortalMindSpaceAssetDeliveryRoutes requires an Express-compatible router',
    );
  }
}

export function attachPortalMindSpaceAssetDeliveryRoutes(
  api,
  {
    rawUploadBody = (_req, _res, next) => next(),
    getConversationPackageRegistry = () => null,
    getUserAuth = () => null,
    getSessionAccess = () => null,
    beforeReadManifest,
    getMindSpaceAssets = () => null,
    ensureMindSpaceEnabled = () => false,
    sendData = (res, _req, data, status = 200) =>
      res.status(status).json({ data }),
    handleMindSpaceError = (_res, _req, error) => {
      throw error;
    },
  } = {},
) {
  assertRouter(api);

  const conversationPackageOptions = {
    getRegistry: getConversationPackageRegistry,
    getUserAuth,
    getSessionAccess,
    ensureMindSpaceEnabled,
    mindSpaceError: handleMindSpaceError,
  };

  api.get(
    '/mindspace/v1/conversation-packages/:sessionId',
    createGetConversationPackageHandler({
      ...conversationPackageOptions,
      sendData,
      beforeReadManifest,
    }),
  );

  api.get(
    '/mindspace/v1/conversation-packages/:sessionId/manifest.json',
    createDownloadConversationPackageManifestHandler({
      ...conversationPackageOptions,
      beforeReadManifest,
    }),
  );

  api.get(
    '/mindspace/v1/conversation-packages/:sessionId/artifacts/:artifactId/download',
    createDownloadConversationPackageArtifactHandler(
      conversationPackageOptions,
    ),
  );

  api.post('/mindspace/v1/uploads', async (req, res) => {
    const mindSpaceAssets = getMindSpaceAssets();
    if (
      !mindSpaceAssets ||
      !ensureMindSpaceEnabled(res, req, { upload: true })
    ) {
      return;
    }
    try {
      const upload = await mindSpaceAssets.createUpload(req.currentUser.id, {
        categoryId: req.body?.category_id,
        filename: req.body?.filename,
        sizeBytes: req.body?.size_bytes,
        declaredMimeType: req.body?.declared_mime_type,
        sourceSessionId: req.body?.session_id,
        sourceMessageId: req.body?.message_id,
      });
      return sendData(res, req, upload, 201);
    } catch (error) {
      return handleMindSpaceError(res, req, error);
    }
  });

  api.put(
    '/mindspace/v1/uploads/:uploadId/content',
    rawUploadBody,
    async (req, res) => {
      const mindSpaceAssets = getMindSpaceAssets();
      if (!mindSpaceAssets) {
        return res.status(503).json({ message: 'MindSpace 未启用' });
      }
      try {
        const result = await mindSpaceAssets.writeUploadContent(
          req.currentUser.id,
          req.params.uploadId,
          req.body,
        );
        return res.json({ data: result });
      } catch (error) {
        return handleMindSpaceError(res, req, error);
      }
    },
  );

  api.post('/mindspace/v1/uploads/:uploadId/complete', async (req, res) => {
    const mindSpaceAssets = getMindSpaceAssets();
    if (!mindSpaceAssets) {
      return res.status(503).json({ message: 'MindSpace 未启用' });
    }
    try {
      const asset = await mindSpaceAssets.completeUpload(
        req.currentUser.id,
        req.params.uploadId,
      );
      return res.status(201).json({ data: asset });
    } catch (error) {
      return handleMindSpaceError(res, req, error);
    }
  });

  api.post(
    '/mindspace/v1/conversation-packages/:sessionId/claim-uploads',
    async (req, res) => {
      const mindSpaceAssets = getMindSpaceAssets();
      if (
        !mindSpaceAssets ||
        !ensureMindSpaceEnabled(res, req, { upload: true })
      ) {
        return;
      }
      try {
        const result =
          await mindSpaceAssets.claimUploadArtifactsForConversation(
            req.currentUser.id,
            {
              sessionId: req.params.sessionId,
              messageId: req.body?.message_id,
            },
          );
        return sendData(res, req, result);
      } catch (error) {
        return handleMindSpaceError(res, req, error);
      }
    },
  );

  api.delete('/mindspace/v1/uploads/:uploadId', async (req, res) => {
    const mindSpaceAssets = getMindSpaceAssets();
    if (!mindSpaceAssets) {
      return res.status(503).json({ message: 'MindSpace 未启用' });
    }
    try {
      const result = await mindSpaceAssets.cancelUpload(
        req.currentUser.id,
        req.params.uploadId,
      );
      return res.json({ data: result });
    } catch (error) {
      return handleMindSpaceError(res, req, error);
    }
  });

  api.get('/mindspace/v1/assets', async (req, res) => {
    const mindSpaceAssets = getMindSpaceAssets();
    if (!mindSpaceAssets) {
      return res.status(503).json({ message: 'MindSpace 未启用' });
    }
    try {
      const assets = await mindSpaceAssets.listAssets(req.currentUser.id, {
        categoryId:
          typeof req.query.category_id === 'string'
            ? req.query.category_id
            : undefined,
        categoryCode:
          typeof req.query.category_code === 'string'
            ? req.query.category_code
            : undefined,
      });
      return res.json({
        data: assets,
        page: { next_cursor: null, has_more: false },
      });
    } catch (error) {
      return handleMindSpaceError(res, req, error);
    }
  });
}