Each request creates an Alova instance, causing a memory leak on the server

[chen6516]

Is this a Bug?

• I have confirmed that I want to report a Bug

Has this issue been reported before?

• I have confirmed that this Issue has not been reported before

Alova Version

3.x

Framework

Nodejs

Problem Description

packages/alova/src/alova.ts

  constructor(options: AlovaOptions<AG>) {
    const instance = this;
    instance.id = (options.id || (idCount += 1)).toString();
    // If storage is not specified, local storage is used by default.
    instance.l1Cache = options.l1Cache || memoryAdapter();
    instance.l2Cache = options.l2Cache || localStorageAdapter();

    // Merge default options
    instance.options = {
      ...(defaultAlovaOptions as Partial<AlovaOptions<AG>>),
      ...options
    };
    instance.snapshots = newInstance(
      MethodSnapshotContainer<AG>,
      options.snapshots ?? defaultAlovaOptions.snapshots ?? 0
    );
  }

export const createAlova = <
  RequestConfig,
  Response,
  ResponseHeader,
  L1Cache extends AlovaGlobalCacheAdapter = AlovaDefaultCacheAdapter,
  L2Cache extends AlovaGlobalCacheAdapter = AlovaDefaultCacheAdapter
>(
  options: AlovaOptions<AlovaGenerics<any, any, RequestConfig, Response, ResponseHeader, L1Cache, L2Cache>>
) => {
  const alovaInstance = newInstance(
    Alova<AlovaGenerics<any, any, RequestConfig, Response, ResponseHeader, L1Cache, L2Cache>>,
    options
  );
  const newStatesHook = alovaInstance.options.statesHook;
  if (boundStatesHook) {
    myAssert(boundStatesHook === newStatesHook, 'expected to use the same `statesHook`');
  }
  boundStatesHook = newStatesHook;


  const { l1Cache, l2Cache } = alovaInstance;
  !usingL1CacheAdapters.includes(l1Cache) && pushItem(usingL1CacheAdapters, l1Cache);
  !usingL2CacheAdapters.includes(l2Cache) && pushItem(usingL2CacheAdapters, l2Cache);
  return alovaInstance;
};

When rendering on the server side, l1Cache/l2Cache user configuration is null or undefined, and each request (each request will call createServerAlova to create an alova instance)
usingL1CacheAdapters/usingL2CacheAdapters will be pushed to the default l1Cache/l2Cache, resulting in a memory leak.

In a stateless multi-user node.js system, each request will create a new alova instance to request (each user's authentication information header is different, although the request is to the same address, the returned data is the user's own private data, and the cache is handled by the API, so the front-end service does not use the cache)
So I encountered this problem

Expected Behavior

If cacheFor is null, no cache should be used, including l1Cache, l2Cache

Reproduction Link

No response

Reproduction Steps

In the node.js server-side rendering program, each request will call the createAlova method to create a request instance. The configuration snippet is as follows:

createAlova({
    baseURL: `${apiUrl}${reqUrl}`,
    timeout: 30000,

    statesHook: VueHook,
    cacheFor: null,
    l1Cache: void 0,
    l2Cache: void 0,

    requestAdapter: axiosRequestAdapter(),
    cacheLogger: import.meta.env.DEV,
}

System Information

Additional Information

We used the following method to temporarily solve:

const emptyCache = {
  set: () => void 0,
  get: () => void 0,
  remove: () => void 0,
  clear: () => void 0,
  emitter: createEventManager(),
} as AlovaDefaultCacheAdapter;


createAlova({
    baseURL: `${apiUrl}${reqUrl}`,
    timeout: 30000,

    statesHook: VueHook,
    cacheFor: null,
    l1Cache: emptyCache,
    l2Cache: emptyCache,

    requestAdapter: axiosRequestAdapter(),
    cacheLogger: import.meta.env.DEV,
}

[JOU-amjs]

Generally we don't recommend to create alova instance infinitely, In some reasons the cacheAdapters need to be cached, and I wonder in what scenario it is necessary to create an instance for each request?

[chen6516]

感谢大佬翻牌, 我简单的画了一张图说明情况

1. 系统是一个多用户系统, 每个用户都有自己的身份认证cookie
2. 当用户请求一个页面的时候会携带身份认证cookie , 同时渲染页面前会先调用认证校验服务器, 如果认证成功会返回认证header
3. 请求业务api会携带上面得到的认证header

创建 alova instance的部分代码如下:

export function createServerAlova({
  baseURL,
  headers,
}: {
  baseURL?: string;
  headers?: PrivateHeaders;
}): AlovaInstance {
....
    beforeRequest(method) {
      Object.assign(method.config, {
        headers: {
          ...method.config.headers,
          ...headers,
        },
        _requestTime: Date.now(),
      });
    },
  .....
  return alovaInstance;
}

所以我们在使用alova神器调用api的时候会调用上面的createServerAlova 方法, 传入 上面提到的认证header.
我们考虑的是在一个多用户系统中,我们在node.js这一层是无状态的web服务器, 缓存的意义可能不大,
每个用户都有自己的数据返回, 哪怕是调用的同一个api地址.
故而为了方便配制, 使用了下面的代码统一处理每一个api 的认证 header携带问题.

Object.assign(method.config, {
        headers: {
          ...method.config.headers,
          ...headers,
        },
        _requestTime: Date.now(),
      });
    },

如果按照大佬说的共用一个alova instance,那么就需要在api 调用方法中同时处理调用地址, 调用方法, 数据Data和认证header, 这样重复代码就很多, 而且还要考虑客户端调用和服务器端调用api的情况.
我们的情况大概如此.这样的Node.js微服务+多用户系统还是很常见,当然可能我们能力还没有到达大佬的高度,误用了, 如果方便的话,请大佬多指教, 再次感谢大佬~

[JOU-amjs]

nodejs里可以使用AsyncLocalStorage（node v16+）处理请求级别的数据。所以大概可以这样处理，以express为例：

const { AsyncLocalStorage } = require('node:async_hooks');
const express = require('express');

const app = express();
const requestContext = new AsyncLocalStorage();

const alova = createAlova({
  // ...
  async beforeRequest(method) {
    // 获取请求级数据
    const cookie = requestContext. getStore();

    // 这里触发认证，这里你也可以缓存认证结果，过期再重新认证
    const authRes = await alova.Post('/auth', { /* 发送cookie认证 */ });

    // 把认证结果合并到headers中
    Object.assign(method.config, {
        headers: {
          ...method.config.headers,
          ...authRes.headers,
        },
        _requestTime: Date.now(),
      });
    };
  }
});

app.use(async (req, res, next) => {
  // 这里保存请求级数据
  requestContext.run(req.cookies, () => {
    next();
  });
});

关于AsyncLocalStorage的详细可以看这边：https://developer.aliyun.com/article/1496780

突发奇想：应该还可以使用alova的token认证拦截器实现token过期自动刷新（未亲测）。

const { AsyncLocalStorage } = require('node:async_hooks');
const express = require('express');
const { createClientTokenAuthentication } = require('alova/client'); //虽然是client的，但服务端也是能用
const { createAlova } = require('alova');

const app = express();
const requestContext = new AsyncLocalStorage();
const { onAuthRequired, onResponseRefreshToken } = createClientTokenAuthentication({
  refreshToken: {
    isExpired: () => {
      const { cookie } = requestContext.getStore();
      return cookie.expire < Date.now();
    },
    handler: async () => {
      // 获取请求级数据
      const store = requestContext.getStore();
      // 这里触发认证，这里你也可以缓存认证结果，过期再重新认证
      const authRes = await alova.Post('/auth', { /* 发送cookie认证 */ }, {
        meta: 'authRole'
      });
      store.authRes = authRes; // 这里保存认证结果
    }
  },
  assignToken: method => {
    const { authRes } = requestContext.getStore();

    // 把认证结果合并到headers中
    Object.assign(method.config, {
      headers: {
        ...method.config.headers,
        ...authRes.headers,
      },
      _requestTime: Date.now(),
    });
  }
});

const alova = createAlova({
  // ...
  beforeRequest: onAuthRequired(method => {
    // ...原请求前拦截器
  }),
  responded: onResponseRefreshToken((response, method) => {
    //...原响应成功拦截器
    return response.json();
  })
});

app.use(async (req, res, next) => {
  // 这里保存请求级数据
  requestContext.run({ cookie: req.cookies }, () => {
    next();
  });
});

[chen6516]

https://developer.aliyun.com/article/1496780
我们一直使用的就是文中提到的"方案2：直接透传参数", 现在有了 AsyncLocalStorage 就可以很优雅的解决了alova多实例问题, 感谢大佬的耐心解答,祝你好运连连~

[JOU-amjs]

@chen6516 don't mind it