feat: High level GROWI service for MCP server

apps/app/.eslintrc.js

@@ -42,6 +42,7 @@ module.exports = {
     'src/features/growi-plugin/**',
     'src/features/opentelemetry/**',
     'src/features/openai/**',
+    'src/features/ai-tools/**',
     'src/features/rate-limiter/**',
     'src/stores-universal/**',
     'src/interfaces/**',

apps/app/src/features/ai-tools/server/routes/create-page.ts

@@ -0,0 +1,208 @@
+import {
+  GroupType,
+  type IUser,
+  type IUserHasId,
+  SCOPE,
+} from '@growi/core/dist/interfaces';
+import { isUserPage } from '@growi/core/dist/utils/page-path-utils';
+import type { Request, RequestHandler } from 'express';
+import type { ValidationChain } from 'express-validator';
+import { body } from 'express-validator';
+import mongoose, { type HydratedDocument } from 'mongoose';
+
+import type { IApiv3PageCreateParams } from '~/interfaces/apiv3';
+import type { IOptionsForCreate } from '~/interfaces/page';
+import type Crowi from '~/server/crowi';
+import { accessTokenParser } from '~/server/middlewares/access-token-parser';
+import { generateAddActivityMiddleware } from '~/server/middlewares/add-activity';
+import { apiV3FormValidator } from '~/server/middlewares/apiv3-form-validator';
+import { excludeReadOnlyUser } from '~/server/middlewares/exclude-read-only-user';
+import type { PageDocument } from '~/server/models/page';
+import type { ApiV3Response } from '~/server/routes/apiv3/interfaces/apiv3-response';
+import {
+  determineBodyAndTags,
+  postAction,
+  saveTags,
+} from '~/server/routes/apiv3/page/create-page-helpers';
+import loggerFactory from '~/utils/logger';
+
+import { determinePath } from '../services/create-page';
+
+const logger = loggerFactory('growi:routes:apiv3:ai-tools:create-page');
+
+type ReqBody = IApiv3PageCreateParams & {
+  todaysMemoTitle?: string;
+  pathHintKeywords?: string[];
+};
+
+type CreatePageReq = Request<undefined, ApiV3Response, ReqBody> & {
+  user: IUserHasId;
+};
+
+type CreatePageFactory = (crowi: Crowi) => RequestHandler[];
+
+export const createPageHandlersFactory: CreatePageFactory = (crowi) => {
+  const User = mongoose.model<IUser, { isExistUserByUserPagePath: any }>(
+    'User',
+  );
+
+  const loginRequiredStrictly = require('~/server/middlewares/login-required')(
+    crowi,
+  );
+
+  const validator: ValidationChain[] = [
+    body('path').optional().isString().withMessage('"path" must be string'),
+
+    body('todaysMemoTitle')
+      .optional()
+      .isString()
+      .withMessage('"todaysMemoTitle" must be string'),
+
+    body('pathHintKeywords')
+      .optional()
+      .isArray()
+      .withMessage('"pathHintKeywords" must be array'),
+
+    body('body').isString().withMessage('"body" must be string'),
+
+    body('grant')
+      .optional()
+      .isInt({ min: 1, max: 5 })
+      .withMessage('"grant" must be integer from 1 to 5'),
+
+    body('grantUserGroupIds')
+      .optional()
+      .isArray()
+      .withMessage('"grantUserGroupIds" must be array'),
+
+    body('grantUserGroupIds.*.type')
+      .optional()
+      .isIn([GroupType.userGroup, GroupType.externalUserGroup])
+      .withMessage(
+        '"grantUserGroupIds.*.type" must be either "userGroup" or "externalUserGroup"',
+      ),
+
+    body('grantUserGroupIds.*.item')
+      .optional()
+      .isMongoId()
+      .withMessage(
+        '"grantUserGroupIds.*.item" must be a valid MongoDB ObjectId',
+      ),
+
+    body('onlyInheritUserRelatedGrantedGroups')
+      .optional()
+      .isBoolean()
+      .withMessage('onlyInheritUserRelatedGrantedGroups must be boolean'),
+
+    body('overwriteScopesOfDescendants')
+      .optional()
+      .isBoolean()
+      .withMessage('overwriteScopesOfDescendants must be boolean'),
+
+    body('pageTags').optional().isArray().withMessage('pageTags must be array'),
+
+    body('isSlackEnabled')
+      .optional()
+      .isBoolean()
+      .withMessage('isSlackEnabled must be boolean'),
+
+    body('slackChannels')
+      .optional()
+      .isString()
+      .withMessage('slackChannels must be string'),
+
+    body('wip').optional().isBoolean().withMessage('wip must be boolean'),
+  ];
+
+  const addActivity = generateAddActivityMiddleware();
+
+  return [
+    accessTokenParser([SCOPE.WRITE.FEATURES.AI_ASSISTANT]), // TODO: https://redmine.weseek.co.jp/issues/172491
+    loginRequiredStrictly,
+    excludeReadOnlyUser,
+    addActivity,
+    validator,
+    apiV3FormValidator,
+    async (req: CreatePageReq, res: ApiV3Response) => {
+      const {
+        path,
+        todaysMemoTitle,
+        pathHintKeywords,
+        body,
+        grant,
+        grantUserGroupIds,
+        pageTags,
+        onlyInheritUserRelatedGrantedGroups,
+        overwriteScopesOfDescendants,
+        wip,
+      } = req.body;
+
+      if (
+        path == null &&
+        todaysMemoTitle == null &&
+        (pathHintKeywords == null || pathHintKeywords.length === 0)
+      ) {
+        return res.apiv3Err(
+          'Either "path", "todaysMemoTitle" or "pathHintKeywords" is required',
+          400,
+        );
+      }
+
+      let pathToCreate: string;
+      try {
+        pathToCreate = await determinePath(
+          req.user,
+          path,
+          todaysMemoTitle,
+          pathHintKeywords,
+        );
+      } catch (err) {
+        logger.error(err);
+        return res.apiv3Err('Could not determine page path', 400);
+      }
+
+      if (isUserPage(pathToCreate)) {
+        const isExistUser = await User.isExistUserByUserPagePath(pathToCreate);
+        if (!isExistUser) {
+          return res.apiv3Err(
+            "Unable to create a page under a non-existent user's user page",
+          );
+        }
+      }
+
+      const { body: determinedBody, tags: determinedTags } =
+        await determineBodyAndTags(pathToCreate, body, pageTags);
+
+      let createdPage: HydratedDocument<PageDocument>;
+      try {
+        const options: IOptionsForCreate = {
+          onlyInheritUserRelatedGrantedGroups,
+          overwriteScopesOfDescendants,
+          wip,
+        };
+
+        if (grant != null) {
+          options.grant = grant;
+          options.grantUserGroupIds = grantUserGroupIds;
+        }
+
+        createdPage = await crowi.pageService.create(
+          pathToCreate,
+          determinedBody,
+          req.user,
+          options,
+        );
+      } catch (err) {
+        logger.error('Error occurred while creating a page.', err);
+        return res.apiv3Err(err);
+      }
+
+      await saveTags({ createdPage, pageTags: determinedTags }, crowi);
+
+      // TODO: https://redmine.weseek.co.jp/issues/173816
+      res.apiv3({}, 201);
+
+      postAction(req, res, createdPage, crowi);
+    },
+  ];
+};

apps/app/src/features/ai-tools/server/routes/index.ts

@@ -0,0 +1,13 @@
+import express from 'express';
+
+import type Crowi from '~/server/crowi';
+
+import { createPageHandlersFactory } from './create-page';
+
+const router = express.Router();
+
+export const factory = (crowi: Crowi): express.Router => {
+  // TODO: https://redmine.weseek.co.jp/issues/173815
+  router.post('/page', createPageHandlersFactory(crowi));
+  return router;
+};

apps/app/src/features/ai-tools/server/services/create-page.ts

@@ -0,0 +1,64 @@
+import type { IUserHasId } from '@growi/core/dist/interfaces';
+import {
+  isCreatablePage,
+  userHomepagePath,
+} from '@growi/core/dist/utils/page-path-utils';
+import { normalizePath } from '@growi/core/dist/utils/path-utils';
+import { format } from 'date-fns/format';
+
+import { getTranslation } from '~/server/service/i18next';
+
+const normalizeAndValidatePath = (path: string): string => {
+  const normalizedPath = normalizePath(path);
+  if (!isCreatablePage(normalizedPath)) {
+    throw new Error('The specified path is not creatable page path');
+  }
+  return normalizedPath;
+};
+
+const generateTodaysMemoPath = async (
+  user: IUserHasId,
+  todaysMemoTitle: string,
+): Promise<string> => {
+  const { t } = await getTranslation({ lang: user.lang, ns: 'commons' });
+
+  const userHomepagePathName = userHomepagePath(user);
+  const memoPathName = t('create_page_dropdown.todays.memo');
+  const datePathName = format(new Date(), 'yyyy/MM/dd');
+  const title = todaysMemoTitle;
+
+  const path = `${userHomepagePathName}/${memoPathName}/${datePathName}/${title}`;
+  const normalizedPath = normalizeAndValidatePath(path);
+  return normalizedPath;
+};
+
+const generatePathFromKeywords = (
+  user: IUserHasId,
+  pathHintKeywords: string[],
+): Promise<string> => {
+  // TODO: https://redmine.weseek.co.jp/issues/173810
+  throw new Error(
+    'Path determination based on keywords is not yet implemented',
+  );
+};
+
+export const determinePath = async (
+  user: IUserHasId,
+  path?: string,
+  todaysMemoTitle?: string,
+  pathHintKeywords?: string[],
+): Promise<string> => {
+  if (path != null) {
+    return normalizeAndValidatePath(path);
+  }
+
+  if (todaysMemoTitle != null) {
+    return generateTodaysMemoPath(user, todaysMemoTitle);
+  }
+
+  if (pathHintKeywords != null && pathHintKeywords.length > 0) {
+    return generatePathFromKeywords(user, pathHintKeywords);
+  }
+
+  throw new Error('Cannot determine page path');
+};

apps/app/src/server/routes/apiv3/index.js

@@ -1,3 +1,4 @@
+import { factory as aiToolsFactory } from '~/features/ai-tools/server/routes/';
 import growiPlugin from '~/features/growi-plugin/server/routes/apiv3/admin';
 import { factory as openaiRouteFactory } from '~/features/openai/server/routes';
 import { allreadyInstalledMiddleware } from '~/server/middlewares/application-not-installed';
@@ -128,6 +129,8 @@ module.exports = (crowi, app) => {
 
   router.use('/openai', openaiRouteFactory(crowi));
 
+  router.use('/ai-tools', aiToolsFactory(crowi));
+
   router.use('/user', userRouteFactory(crowi));
 
   return [router, routerForAdmin, routerForAuth];