How to use the typedi.Container.of function in typedi

get(someClass: any, { context }: ResolverData) {
    // use context data to get scoped container
    const container = Container.of(context.requestId);

    // then get from container like normal
    return container.get(someClass);
  },
};

return (req: Request, res: Response, next: NextFunction) => {
        const container = Container.of(req);
        container.set(CurrentRequest, req);
        container.set(CurrentResponse, res);
        allOptions.context.container = container;
        allOptions.context.dataLoaders = {};

        return runHttpQuery([req, res], {
            method: req.method,
            options: allOptions,
            query: req.method === "POST" ? req.body : req.query,
        }).then((gqlResponse) => {

            // commit transaction
            const transactionEntityManager = container.has(EntityManager) ? container.get(EntityManager) : undefined;
            if (transactionEntityManager &&
                transactionEntityManager.connection.options.type !== "mongodb" &&
                transactionEntityManager.queryRunner &&

beforeEach(async () => {
    const requestId = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
    const container = Container.of(requestId);
    context = { requestId, container, user, session: { user } };
    container.set('context', context);

    await connection.dropDatabase();
    await connection.synchronize();
  });

public initialize(options: StoreBuilderOptions) {
    this._container = options.container || Container.of(undefined);
    this._options = {
      actions: options.actions || {},
      getters: options.getters || {},
      modules: options.modules || {},
      mutations: options.mutations || {},
      plugins: options.plugins || [],
      state: options.state,
      strict: options.strict || true
    };
  }

subscribe: withFilter(() => this.options.subscriptionAsyncIterator(action.name || action.methodName), function (playload: any, args: any, context: any, info: any) {
                        const container = Container.of(this);
                        context.container = container;
                        const executionResult = that.actionExecutor.executeControllerAction({
                            metadata: action,
                            request: undefined,
                            response: undefined,
                            container: container,
                            obj: playload,
                            args: args,
                            context: context,
                            info: info
                        });
                        if (executionResult instanceof Promise) {
                            return executionResult.then(result => {
                                if (result === undefined)
                                    return true;
                                return result;