fix type

apps/app/src/server/middlewares/access-token-parser/access-token-parser.ts

@@ -1,10 +1,8 @@
 import type { IUserHasId } from '@growi/core/dist/interfaces';
 import { serializeUserSecurely } from '@growi/core/dist/models/serializers';
 import type { NextFunction, Response } from 'express';
-import type { HydratedDocument } from 'mongoose';
-import mongoose from 'mongoose';
 
-import type { IAccessTokenDocument } from '~/server/models/access-token';
+import { AccessToken } from '~/server/models/access-token';
 import loggerFactory from '~/utils/logger';
 
 import type { AccessTokenParserReq } from './interfaces';
@@ -19,8 +17,6 @@ export const accessTokenParser = async(req: AccessTokenParserReq, res: Response,
     return next();
   }
 
-  const AccessToken = mongoose.model<HydratedDocument<IAccessTokenDocument>, { findUserIdByToken }>('AccessToken');
-
   logger.debug('accessToken is', accessToken);
 
   // check the access token is valid

apps/app/src/server/models/access-token.ts

@@ -1,7 +1,9 @@
 import crypto from 'crypto';
 
 import type { Ref, IUserHasId } from '@growi/core/dist/interfaces';
-import type { Document, Model, Types } from 'mongoose';
+import type {
+  Document, Model, Types, HydratedDocument,
+} from 'mongoose';
 import { Schema } from 'mongoose';
 import mongoosePaginate from 'mongoose-paginate-v2';
 import uniqueValidator from 'mongoose-unique-validator';
@@ -14,6 +16,14 @@ const logger = loggerFactory('growi:models:access-token');
 
 const generateTokenHash = (token: string) => crypto.createHash('sha256').update(token).digest('hex');
 
+type GenerateTokenResult = {
+  token: string,
+  _id: Types.ObjectId,
+  expiredAt: Date,
+  scope?: string[],
+  description?: string,
+}
+
 export type IAccessToken = {
   user: Ref<IUserHasId>,
   tokenHash: string,
@@ -27,13 +37,13 @@ export interface IAccessTokenDocument extends IAccessToken, Document {
 }
 
 export interface IAccessTokenModel extends Model<IAccessTokenDocument> {
-  generateToken: (userId: Types.ObjectId, expiredAt: Date, scope: string[], description?: string,) => Promise<string>
+  generateToken: (userId: Types.ObjectId, expiredAt: Date, scope: string[], description?: string,) => Promise<GenerateTokenResult>
   deleteToken: (token: string) => Promise<void>
   deleteTokenById: (tokenId: Types.ObjectId) => Promise<void>
   deleteAllTokensByUserId: (userId: Types.ObjectId) => Promise<void>
   deleteExpiredToken: () => Promise<void>
-  findUserIdByToken: (token: string) => Promise<Types.ObjectId>
-  findTokenByUserId: (userId: Types.ObjectId) => Promise<IAccessTokenDocument[]>
+  findUserIdByToken: (token: string) => Promise<HydratedDocument<IAccessTokenDocument> | null>
+  findTokenByUserId: (userId: Types.ObjectId) => Promise<HydratedDocument<IAccessTokenDocument>[]>
   validateTokenScopes: (token: string, requiredScope: string[]) => Promise<boolean>
 }
 
@@ -73,20 +83,20 @@ accessTokenSchema.statics.generateToken = async function(userId: Types.ObjectId,
 
 accessTokenSchema.statics.deleteToken = async function(token: string) {
   const tokenHash = generateTokenHash(token);
-  return this.deleteOne({ tokenHash });
+  await this.deleteOne({ tokenHash });
 };
 
 accessTokenSchema.statics.deleteTokenById = async function(tokenId: Types.ObjectId) {
-  return this.deleteOne({ _id: tokenId });
+  await this.deleteOne({ _id: tokenId });
 };
 
 accessTokenSchema.statics.deleteAllTokensByUserId = async function(userId: Types.ObjectId) {
-  return this.deleteMany({ user: userId });
+  await this.deleteMany({ user: userId });
 };
 
 accessTokenSchema.statics.deleteExpiredToken = async function() {
   const now = new Date();
-  return this.deleteMany({ expiredAt: { $lte: now } });
+  await this.deleteMany({ expiredAt: { $lte: now } });
 };
 
 accessTokenSchema.statics.findUserIdByToken = async function(token: string) {