tsyringe#container TypeScript Examples

public async craete(req: Request, res: Response): Promise<Response> {
    const user_id = req.user.id;
    const { provider_id, date } = req.body;

    const createAppointment = container.resolve(CreateAppointmentService);

    const appointment = await createAppointment.execute({
      provider_id,
      date,
      user_id,
    });

    return res.json(appointment);
  }

public async create(request: Request, response: Response): Promise<Response> {
    const { name, email } = request.body;

    const createCustomer = container.resolve(CreateCustomerService);

    const customer = await createCustomer.execute({ name, email });

    return response.json(customer);
  }

public init(): void {
    const queues = Object.values(jobs).map(job => {
      const jobInstance = container.resolve(job);

      return {
        key: jobInstance.key,
        queue: new Queue(jobInstance.key, { redis: redisConfig }),
        handle: jobInstance.handle,
      };
    });

    this.queues = queues;
  }

public async index(request: Request, response: Response): Promise<Response> {
    const listItems = container.resolve(ListItemsService);

    const items = await listItems.execute();

    const serializedItems = items
      ? items.map(({ id, title, image }) => ({
          id,
          title,
          image_url: `http://192.168.0.185:3333/uploads/${image}`,
        }))
      : items;

    return response.json(serializedItems);
  }

constructor(context: vscode.ExtensionContext, 
        state: AppState,
        @inject("Executor") executor?:Executor) {
        if(!executor){
            throw Error("executor has to be defined");
        }
        this.executor = executor;
        this.commands=container.resolve(Commands);
        this._state = CommandController.updateState(state);
        this.context = context;
        state.activeProfile = ALL;
    }

export default async function () {
  console.clear()
  console.log(chalk.blue(logo))

  printVersion()

  printer.section("Configuration")
  const storage = container.resolve(StorageService)
  storage.set<string>(HEXON_PORT_KEY, await getPort())
  storage.set<string>(HexoInstanceService.HEXO_BASE_DIR_KEY, await getRoot())
  const { username, password } = await getUserInfo()
  const account = container.resolve(AccountService)
  account.setUserInfo(username, password)

  printer.section("Install")
  const base = path.resolve(__dirname, "../..")
  printer.success(`Hexon has been installed to \`${base}\``)
  printer.log(`Run \`pnpm start\` to start`)
  printer.log(`Run \`pnpm prd\` to start with pm2`)
  printer.log(chalk.grey(`To uninstall, remove the following foler: ${base}`))
}

export function registerDataDependencies() {
  container.register(AppDependencies.ApiProvider, {
    useValue: new BearerAuthorizationRxAxiosProvider({
      baseURL: BuildConfig.ApiUrl,
    }),
  });
  container.register(AppDependencies.LocalAuthenticationDataSource, {
    useClass: KeyChainAuthenticationDataSource,
  });

  container.register(AppDependencies.RemoteAuthenticationDataSource, {
    useClass: ApiAuthenticationDataSource,
  });

  container.register(AppDependencies.SignInUseCase, {
    useClass: SignInUseCase,
  });
}

public async create(request: Request, response: Response): Promise<Response> {
    const user_id = request.user.id;
    const { provider_id, date } = request.body;

    const createAppointment = container.resolve(CreateAppointmentService);

    const appointment = await createAppointment.execute({
      provider_id,
      user_id,
      date,
    });

    return response.json(appointment);
  }

public async create(request: Request, response: Response): Promise<Response> {
    const { provider_id, date } = request.body;
    const { id: user_id } = request.user;

    const createAppointment = container.resolve(CreateAppointmentService);

    const appointment = await createAppointment.execute({
      provider_id,
      user_id,
      date,
    });

    return response.status(200).json(appointment);
  }

/**
   * Move an item
   * UNTESTED
   * @async
   * @param {string} itemId collect item id
   * @param {ItemDestination} destination - info where to move. {id, container, location:{x,y,r} }
   * @param {String} destination.id - item id where we move
   * @param {String} [destination.container="hideout"] - 'main' = container, 'hideout' = stash
   * @param {Object} [destination.location={x:0,y:0,r:0}] - {x, y, r} x & y locations, topleft is 0,0. r = 0 or 1.
   */
  public async moveItem(itemId: string, destination: ItemDestination): Promise<any> {
    const body = JSON.stringify({
      data: [{
        Action: 'Move',
        item: itemId,
        to: {
          container: 'hideout', // main = container, hideout = stash 
          location: { x: 0, y: 0, r: 0 }, // try to put to topleft if empty
          ...destination,
        },
      }],
      tm: 2,
    });
    const result: ApiResponse<any> = await this.api.prod.post('client/game/profile/items/moving', { body });
    return result.body.data;
  }

public async index(req: Request, res: Response): Promise<Response> {
    const user_id = req.user.id;

    const listProviders = container.resolve(ListProvidersService);

    const providers = await listProviders.execute({ user_id });

    return res.json(classToClass(plainToClass(User, providers)));
  }

container.registerSingleton<ICustomersRepository>(
  'CustomersRepository',
  CustomersRepository,
);

container.registerSingleton<IHashProvider>('HashProvider', BCryptHashProvider);

AdrGwContainer = container.createChildContainer()