Merge branch 'feat/g2g-nextjs' of https://github.com/hakumizuki/growi into feat/g2g-nextjs

packages/app/src/interfaces/transfer-key.ts

@@ -0,0 +1,5 @@
+export interface ITransferKey<ID = string> {
+  _id: ID
+  expireAt: Date
+  value: string,
+}

packages/app/src/server/crowi/index.js

@@ -22,6 +22,7 @@ import AclService from '../service/acl';
 import AppService from '../service/app';
 import AttachmentService from '../service/attachment';
 import ConfigManager from '../service/config-manager';
+import { G2GTransferService } from '../service/g2g-transfer';
 import { InstallerService } from '../service/installer';
 import PageService from '../service/page';
 import PageGrantService from '../service/page-grant';
@@ -53,6 +54,7 @@ function Crowi() {
   this.config = {};
   this.configManager = null;
   this.s2sMessagingService = null;
+  this.g2gTransferService = null;
   this.mailService = null;
   this.passportService = null;
   this.globalNotificationService = null;
@@ -121,6 +123,7 @@ Crowi.prototype.init = async function() {
     this.setupSearcher(),
     this.setupMailer(),
     this.setupSlackIntegrationService(),
+    this.setupG2GTransferService(),
     this.setUpFileUpload(),
     this.setUpFileUploaderSwitchService(),
     this.setupAttachmentService(),
@@ -741,4 +744,10 @@ Crowi.prototype.setupSlackIntegrationService = async function() {
   }
 };
 
+Crowi.prototype.setupG2GTransferService = async function() {
+  if (this.g2gTransferService == null) {
+    this.g2gTransferService = new G2GTransferService(this);
+  }
+};
+
 export default Crowi;

packages/app/src/server/models/transfer-key.ts

@@ -0,0 +1,20 @@
+import { Schema } from 'mongoose';
+
+import { ITransferKey } from '~/interfaces/transfer-key';
+
+import loggerFactory from '../../utils/logger';
+import { getOrCreateModel } from '../util/mongoose-utils';
+
+const logger = loggerFactory('growi:models:transfer-key');
+
+const schema = new Schema<ITransferKey>({
+  expireAt: { type: Date, default: () => new Date(), expires: '30m' },
+  value: { type: String, unique: true },
+}, {
+  timestamps: {
+    createdAt: true,
+    updatedAt: false,
+  },
+});
+
+export default getOrCreateModel('TransferKey', schema);

packages/app/src/server/routes/apiv3/g2g-transfer.ts

@@ -0,0 +1,105 @@
+import express, { NextFunction, Request, Router } from 'express';
+import { body } from 'express-validator';
+
+import loggerFactory from '~/utils/logger';
+
+import Crowi from '../../crowi';
+import { apiV3FormValidator } from '../../middlewares/apiv3-form-validator';
+import ErrorV3 from '../../models/vo/error-apiv3';
+
+import { ApiV3Response } from './interfaces/apiv3-response';
+
+const logger = loggerFactory('growi:routes:apiv3:transfer');
+
+const validator = {
+  transfer: [
+    body('transferKey').isString().withMessage('transferKey is required'),
+  ],
+};
+
+/*
+ * Routes
+ */
+module.exports = (crowi: Crowi): Router => {
+  const { g2gTransferService } = crowi;
+  if (g2gTransferService == null) {
+    throw Error('G2GTransferService is not set');
+  }
+
+  const isInstalled = crowi.configManager?.getConfig('crowi', 'app:installed');
+
+  const accessTokenParser = require('../../middlewares/access-token-parser')(crowi);
+  const adminRequired = require('../../middlewares/admin-required')(crowi);
+  const loginRequiredStrictly = require('../../middlewares/login-required')(crowi);
+
+  // Middleware
+  const adminRequiredIfInstalled = (req: Request, res: ApiV3Response, next: NextFunction) => {
+    if (!isInstalled) {
+      next();
+      return;
+    }
+
+    return adminRequired(req, res, next);
+  };
+
+  // Middleware
+  const appSiteUrlRequiredIfNotInstalled = (req: Request, res: ApiV3Response, next: NextFunction) => {
+    if (!isInstalled && req.body.appSiteUrl != null) {
+      next();
+      return;
+    }
+
+    if (crowi.configManager?.getConfig('crowi', 'app:siteUrl') != null || req.body.appSiteUrl != null) {
+      next();
+      return;
+    }
+
+    return res.apiv3Err(new ErrorV3('Body param "appSiteUrl" is required when GROWI is NOT installed yet'), 400);
+  };
+
+  // Middleware to check if key is valid or not
+  const validateTransferKey = async(req: Request, res: ApiV3Response, next: NextFunction) => {
+    const { transferKey } = req.body;
+    // TODO: Check key
+    next();
+  };
+
+  const router = express.Router();
+
+  router.post('/', validator.transfer, apiV3FormValidator, validateTransferKey, async(req: Request, res: ApiV3Response) => {
+    return;
+  });
+
+  router.post('/generate-key', /* accessTokenParser, adminRequiredIfInstalled, appSiteUrlRequiredIfNotInstalled, */ async(req: Request, res: ApiV3Response) => {
+    const strAppSiteUrl = req.body.appSiteUrl ?? crowi.configManager?.getConfig('crowi', 'app:siteUrl');
+
+    // Generate transfer key string
+    let appSiteUrl: URL;
+    try {
+      appSiteUrl = new URL(strAppSiteUrl);
+    }
+    catch (err) {
+      logger.error(err);
+      return res.apiv3Err(new ErrorV3('appSiteUrl may be wrong', 'failed_to_generate_key_string'));
+    }
+
+    // Save TransferKey document
+    let transferKeyString: string;
+    try {
+      transferKeyString = await g2gTransferService.createTransferKey(appSiteUrl);
+    }
+    catch (err) {
+      logger.error(err);
+      return res.apiv3Err(new ErrorV3('Error occurred while generating transfer key.', 'failed_to_generate_key'));
+    }
+
+    return res.apiv3({ transferKey: transferKeyString });
+  });
+
+  // eslint-disable-next-line max-len
+  router.post('/transfer', accessTokenParser, loginRequiredStrictly, adminRequired, validator.transfer, apiV3FormValidator, async(req: Request, res: ApiV3Response) => {
+    return;
+  });
+
+  return router;
+};

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

@@ -2,6 +2,7 @@ import loggerFactory from '~/utils/logger';
 
 import injectUserRegistrationOrderByTokenMiddleware from '../../middlewares/inject-user-registration-order-by-token-middleware';
 
+import g2gTransfer from './g2g-transfer';
 import pageListing from './page-listing';
 import * as userActivation from './user-activation';
 
@@ -36,6 +37,7 @@ module.exports = (crowi) => {
   routerForAdmin.use('/slack-integration-settings', require('./slack-integration-settings')(crowi));
   routerForAdmin.use('/slack-integration-legacy-settings', require('./slack-integration-legacy-settings')(crowi));
   routerForAdmin.use('/activity', require('./activity')(crowi));
+  routerForAdmin.use('/g2g-transfer', g2gTransfer(crowi));
 
   // auth
   routerForAuth.use('/logout', require('./logout')(crowi));

packages/app/src/server/service/g2g-transfer.ts

@@ -0,0 +1,88 @@
+import { Readable } from 'stream';
+
+import { Types as MongooseTypes } from 'mongoose';
+
+import TransferKeyModel from '~/server/models/transfer-key';
+import loggerFactory from '~/utils/logger';
+import { TransferKey } from '~/utils/vo/transfer-key';
+
+const logger = loggerFactory('growi:service:g2g-transfer');
+
+/**
+ * Data used for comparing to/from GROWI information
+ */
+export type IDataFromGROWIInfo = {
+  version: string
+  userLimit: number
+}
+
+interface Pusher {
+  /**
+   * Start transfer data between GROWIs
+   * @param {string} key Transfer key
+   */
+  startTransfer(key: string): Promise<Readable>
+}
+
+interface Receiver {
+  /**
+   * Check if key is not expired
+   * @param {string} key Transfer key
+   */
+  validateTransferKey(key: string): Promise<boolean>
+  /**
+   * Check if transfering is proceedable
+   * @param {IDataFromGROWIInfo} fromGROWIInfo
+   */
+  canTransfer(fromGROWIInfo: IDataFromGROWIInfo): Promise<boolean>
+}
+
+export class G2GTransferService implements Pusher, Receiver {
+
+  crowi: any;
+
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  constructor(crowi: any) {
+    this.crowi = crowi;
+  }
+
+  public async canTransfer(fromGROWIInfo: IDataFromGROWIInfo): Promise<boolean> { return true }
+
+  public async startTransfer(key: string): Promise<Readable> { return new Readable() }
+
+  public async validateTransferKey(key: string): Promise<boolean> { return true }
+
+  /**
+   * This method receives appSiteUrl to create a TransferKey document and returns generated transfer key string.
+   * UUID is the same value as the created document's _id.
+   * @param {URL} appSiteUrl URL type appSiteUrl
+   * @returns {string} Transfer key string (e.g. http://localhost:3000__grw_internal_tranferkey__<uuid>)
+   */
+  public async createTransferKey(appSiteUrl: URL): Promise<string> {
+    const uuid = new MongooseTypes.ObjectId().toString();
+
+    // Generate transfer key string
+    let transferKeyString: string;
+    try {
+      transferKeyString = TransferKey.generateKeyString(appSiteUrl, uuid);
+    }
+    catch (err) {
+      logger.error(err);
+      throw err;
+    }
+
+    // Save TransferKey document
+    try {
+      await TransferKeyModel.create({ _id: uuid, appSiteUrl, value: transferKeyString });
+    }
+    catch (err) {
+      logger.error(err);
+      throw err;
+    }
+
+    return transferKeyString;
+  }
+
+  private onCompleteTransfer(): void { return }
+
+}

packages/app/src/utils/vo/transfer-key.ts

@@ -0,0 +1,54 @@
+/**
+ * VO for TransferKey which has appUrl and key as its public member
+ */
+export class TransferKey {
+
+  private static _internalSeperator = '__grw_internal_tranferkey__';
+
+  public appUrl: URL;
+
+  public key: string;
+
+  constructor(appUrl: URL, key: string) {
+    this.appUrl = appUrl;
+    this.key = key;
+  }
+
+  /**
+   * Parse a transfer key string generated by the generateKeyString static method
+   * @param {string} keyString Transfer key string
+   * @returns {TransferKey}
+   */
+  static parse(keyString: string): TransferKey {
+    const generalErrorPhrase = 'Failed to parse TransferKey from string';
+
+    const splitted = keyString.split(TransferKey._internalSeperator);
+
+    if (splitted.length !== 2) {
+      throw Error(generalErrorPhrase);
+    }
+    const appUrlString = splitted[0];
+    const key = splitted[1];
+
+    let appUrl: URL | null;
+    try {
+      appUrl = new URL(appUrlString);
+    }
+    catch (e) {
+      throw Error(generalErrorPhrase + (e as Error));
+    }
+
+    return new TransferKey(appUrl, key);
+  }
+
+  /**
+   * Generates transfer key string (e.g. https://example.com:8080__grw_internal_tranferkey__key)
+   * @param {URL} appUrl GROWI app site url
+   * @param {string} key Key generated by GROWI
+   * @returns {string} Transfer key string
+   */
+  static generateKeyString(appUrl: URL, key: string): string {
+    return `${appUrl.origin}${TransferKey._internalSeperator}${key}`;
+  }
+
+}