TypeScript routing-controllers.useContainer函數代碼示例

> = (context: interfaces.Context) => (app?: express.Application) => {
  if (!app) {
    app = express();
  }
  context.container.get<interfaces.Factory<express.Application>>(
    registry.ExpressConfig
  )(app);
  useContainer(context.container);
  useExpressServer(app, {
    routePrefix: '/api',
    controllers: [
      CardSetController
    ],
    development: false,
    validation: { validationError: { target: false, value: false } }
  });
  // Setup express to serve static files
  app.use(express.static(path.resolve(__dirname, 'client', 'assets')));
  app.use(express.static(path.resolve(__dirname, 'client')));

  // Catch all route to support Angular 2 pushstate routing
  app.get('*', (_req: express.Request, res: express.Response): void => {
    res.sendFile(path.resolve(__dirname, 'client', 'index.html'));
  });
  context.container.get<interfaces.Factory<express.Application>>(
    registry.ExpressErrorConfig
  )(app);

  return app;
};

> = (context: interfaces.Context) => (app?: express.Application) => {
  if (!app) {
    app = express();
  }
  context.container.get<interfaces.Factory<express.Application>>(
    registry.ExpressConfig
  )(app);
  useContainer(context.container);
  useExpressServer(app, {
    routePrefix: '/api',
    controllers: [
      CardSetController
    ],
    development: true,
    validation: { validationError: { target: false, value: false } }
  });
  app.use(historyApiFallback());
  app.use(
    webpackMiddleware(webpack(webpackDevConfig), {
      publicPath: '/',
      index: 'index.html',
      stats: {
        colors: true
      }
    })
  );
  context.container.get<interfaces.Factory<express.Application>>(
    registry.ExpressErrorConfig
  )(app);

  return app;
};

  beforeEach(async () => {
    container = new Container();
    container.load(ormModule);

    // Services
    container
      .bind<SettingsServiceAttributes>(registry.SettingsService)
      .to(MockSettingsService)
      .inSingletonScope();
    mockSettingsService = container.get<SettingsServiceAttributes>(
      registry.SettingsService
    );
    mockSettingsService.loggerTransports = [
      new winston.transports.Console({
        silent: true
      })
    ];
    mockLogger = new winston.Logger();
    const loggerFactory: interfaces.FactoryCreator<winston.LoggerInstance> = (
      context: interfaces.Context
    ) => {
      return () => {
        return mockLogger;
      };
    };
    container
      .bind<interfaces.Factory<winston.LoggerInstance>>(registry.LoggerFactory)
      .toFactory(loggerFactory);

    // ORM
    container
      .bind<ConnectionOptions>(registry.ORMConnectionOptions)
      .toConstantValue({
        autoSchemaSync: true,
        type: 'sqlite',
        database: ':memory:'
      });
    connection = (await container.get<interfaces.Provider<Connection>>(
      registry.ORMConnectionProvider
    )()) as Connection;

    // Express configs
    container
      .bind<CardSetControllerAttributes>(CardSetController)
      .toSelf();
    app = express();
    useContainer(container);
    useExpressServer(app, {
      routePrefix: '/api',
      controllers: [CardSetController],
      development: true
    });
  });

> = (context: interfaces.Context) => (app?: express.Application) => {
  if (!app) {
    app = express();
  }
  context.container.get<interfaces.Factory<express.Application>>(
    registry.ExpressConfig
  )(app);
  useContainer(context.container);
  useExpressServer(app, {
    routePrefix: '/api',
    controllers: [
      CardSetController
    ],
    development: false,
    validation: { validationError: { target: false, value: false } }
  });
  context.container.get<interfaces.Factory<express.Application>>(
    registry.ExpressErrorConfig
  )(app);

  return app;
};

import "reflect-metadata";
import {useContainer, useExpressServer} from "routing-controllers";
import {Container} from "typedi";

// setup routing-controllers to use typedi container. You can use any container here
useContainer(Container);

// create and setup our own express app
const express = require("express");
const cors = require("cors");
const expressApp = express();
expressApp.use(cors());

// create express server
useExpressServer(expressApp, { // alternatively you can use useExpressServer with your own preconfigured express server
    controllerDirs: [__dirname + "/controllers/**/*.js"]
});

// run express app
expressApp.listen(4000);

console.log("API is up and running at port 4000");

    middlewares: env.app.dirs.middlewares,
});

winston.configure({
    transports: [
        new winston.transports.Console({
            level: env.log.level,
            handleExceptions: true,
            json: env.log.json,
            timestamp: env.node !== "development",
            colorize: env.node === "development",
        }),
    ],
});

routingUseContainer(Container);
ormUseContainer(Container);
classValidatorUseContainer(Container);

// Register validator schemes
env.app.dirs.validatorSchemes.forEach((pattern) => {
    glob(pattern, (err: any, files: Array<string>) => {
        for (const file of files) {
            const schemas = require(file);

            Object.keys(schemas).forEach((key) => {
                registerSchema(schemas[key]);
            });
        }
    });
});

export const bootstrapApp = async (): Promise<BootstrapSettings> => {
    /**
     * We create a new express server instance.
     */
    const app: express.Application = express();

    app.use(json({ limit: "50mb" }));
    app.use(urlencoded({ extended: true }));

    useExpressServer(app, {
        cors: true,
        routePrefix: env.app.routePrefix,
        defaultErrorHandler: false,
        classTransformer: true,
        validation: true,
        /**
         * We can add options about how routing-controllers should configure itself.
         * Here we specify what controllers should be registered in our express server.
         */
        controllers: env.app.dirs.controllers,
        middlewares: env.app.dirs.middlewares,
    });

    winston.configure({
        transports: [
            new winston.transports.Console({
                level: env.log.level,
                handleExceptions: true,
                json: env.log.json,
                timestamp: env.node !== "development",
                colorize: env.node === "development",
            }),
        ],
    });

    routingUseContainer(Container);
    ormUseContainer(Container);
    classValidatorUseContainer(Container);

    // Register validator schemes
    env.app.dirs.validatorSchemes.forEach((pattern) => {
        glob(pattern, (err: any, files: Array<string>) => {
            for (const file of files) {
                const schemas = require(file);

                Object.keys(schemas).forEach((key) => {
                    registerSchema(schemas[key]);
                });
            }
        });
    });
    env.app.dirs.subscribers.forEach((pattern) => {
        glob(pattern, (err: any, files: Array<string>) => {
            for (const file of files) {
                require(file);
            }
        });
    });

    const initTypeORM = async () => {
        const loadedConnectionOptions = await getConnectionOptions();

        const connectionOptions = Object.assign(loadedConnectionOptions, {
            type: env.db.type as any, // See createConnection options for valid types
            host: env.db.host,
            port: env.db.port,
            username: env.db.username,
            password: env.db.password,
            database: env.db.database,
            synchronize: env.db.synchronize,
            logging: env.db.logging,
            entities: env.app.dirs.entities,
            migrations: env.app.dirs.migrations,
        });

        return createConnection(connectionOptions);
    };

    app.get(
        env.app.routePrefix,
        (req: express.Request, res: express.Response) => {
            return res.json({
                name: env.app.name,
                version: env.app.version,
                description: env.app.description,
            });
        },
    );

    const log = new Logger(__filename);

    try {
        const connection = await initTypeORM();

        const server: http.Server = app.listen(env.app.port);

        banner(log);

        return {
            app,
//.........這裏部分代碼省略.........