How to use the graphql-middleware.applyMiddleware function in graphql-middleware

const resolvers = {
      Query: {
        book: () => ({ id, ...dataEn }),
        books: () => ([{ id, ...dataEn }]),
      },
      Book: {
        name: () => 'just test',
      },
    };
    const typeConfig = makeExecutableSchema({
      typeDefs,
      resolvers,
    });

    const schemaWithPermissions = applyMiddleware(typeConfig, this.i18n.middleware());
    // Execution
    const query = `
      query {
        book @locale(lang: "zh") {
          name
          author {
            name
          }
        }
        books @locale(lang: "zh") {
          name
          author {
            name
          }
        }
      }

},
    };
    const schema = makeExecutableSchema({
      typeDefs,
      resolvers,
    });

    const roles = ['ADMIN', 'DEVELOPER'];
    const roleSchema = {
      Obj: ['ADMIN', 'DEVELOPER'],
    };
    const getUser = () => ({ role: 'ADMIN' });

    const rbac = new RBAC({roles, schema: roleSchema, getUser});

    const schemaWithPermissions = applyMiddleware(schema, rbac.middleware());
    // Execution
    const query = `
      query {
        test {
          name
        }
      }
    `;
    const adminRes = await graphql(schemaWithPermissions, query, {}, { user: { role: 'ADMIN' } });
    const developerRes = await graphql(schemaWithPermissions, query, {}, { user: { role: 'DEVELOPER' } });

    expect(adminRes.data).to.be.eql({
      test: { name: 'pass' },
    });
    expect(developerRes.data).to.be.eql({
      test: { name: 'pass' },

}
) {
  const schema = makeExecutableSchema({
    typeDefs,
    resolvers,
    schemaDirectives,
    directiveResolvers,
    resolverValidationOptions: {
      requireResolversForResolveType: false,
    },
  })

  // Apollo server options
  const options = {
    ...apolloServerOptions,
    schema: applyGraphQLMiddleware(schema, ...graphqlMiddlewares),
    tracing: true,
    cacheControl: true,
    engine: engineKey ? { apiKey: engineKey } : false,
    dataSources,
    // Resolvers context in POST requests
    context: async ({ req, connection }) => {
      let contextData
      try {
        if (connection) {
          contextData = { ...connection.context }
        } else {
          contextData = await context({ req, request: req })
        }
      } catch (error) {
        logger.error(error)
        throw error

rootNode,
      models,
      dataSources,
      scalars: {
        JSON: GraphQLJSON,
        DateTime: GraphQLDateTime,
      },
      plugins: config.plugins,
    });

    const { typeDefs, resolvers } = gqlify.createApolloConfig();
    const schema = makeExecutableSchema({
      typeDefs: typeDefs as any,
      resolvers
    });
    const schemaWithMiddleware = applyMiddleware(schema, readOnlyMiddleware);

    // context
    const context = config.context || createContext(config);

    this.apolloServer = new ApolloServer({
      debug: true,
      playground: config.graphqlPlayground,
      schema: schemaWithMiddleware as any,
      formatError: (error: any) => {
        return apolloErrorHandler(error, this.logger);
      },
      context,
    });
  }

const middlewarePlugins = plugins.byType("graphql-middleware");
    for (let i = 0; i < middlewarePlugins.length; i++) {
        let plugin = middlewarePlugins[i];
        const middleware =
            typeof plugin.middleware === "function"
                ? await plugin.middleware({ plugins })
                : plugin.middleware;
        if (Array.isArray(middleware)) {
            registeredMiddleware.push(...middleware);
        } else {
            registeredMiddleware.push(middleware);
        }
    }

    if (registeredMiddleware.length) {
        schema = applyMiddleware(schema, ...registeredMiddleware);
    }

    addSchemaLevelResolveFunction(schema, async (root, args, context, info) => {
        // Make sure we do not block this resolver from processing subsequent requests!
        // This is something that is baked into the graphql-tools and cannot be avoided another way.
        delete info.operation["__runAtMostOnce"];

        // Process `graphql-context` plugins
        const ctxPlugins = plugins.byType("graphql-context");
        for (let i = 0; i < ctxPlugins.length; i++) {
            if (typeof ctxPlugins[i].preApply === "function") {
                await ctxPlugins[i].preApply(context);
            }
        }

        for (let i = 0; i < ctxPlugins.length; i++) {

      transformSchema: (schema: any): any => applyMiddleware(schema, permissionConfig.permissions),
      context: async (ctx: { req: Request }) => ({

async function makeSchema(adminLinks) {
  let reportingSchema = await getRemoteSchema(adminLinks['reportingService'])
  
  if (urlMap['reportingService'].permissions) {
    reportingSchema = applyMiddleware(reportingSchema, urlMap['reportingService'].permissions)
  }
  
  let userSchema = await getRemoteSchema(adminLinks['userService'])
  if (urlMap['userService'].permissions) {
    userSchema = applyMiddleware(reportingSchema, urlMap['userService'].permissions)
  }
  const eduSchema = await soapGraphqlSchema(process.env.EDU_URL)
  let cmsSchema = await getRemoteSchema(adminLinks['cmsService'])
  if (urlMap['cmsService'].permissions) {
    cmsSchema = applyMiddleware(graphSchema, urlMap['cmsService'].permissions)
  }
  
  let localSchema = importSchema(__dirname + '/typedefs/schema.graphql')
  const resolvers = require('./resolvers')
  return mergeSchemas({
    schemas: [
      userSchema, 
      reportingSchema,
      eduSchema,
      cmsSchema,
      localSchema,

_empty: String
  }
`;

const Mutation = gql`
  type Mutation {
    _empty: String
  }
`;

const schema = makeExecutableSchema({
  typeDefs: [Query, Mutation, AuthTypes],
  resolvers: merge(authResolvers)
});

const schemaWithMiddleware = applyMiddleware(schema, permissions);

export default schemaWithMiddleware;