DScheglov

import { createParamDecorator, ExecutionContext, SetMetadata } from '@nestjs/common';

export const Passport = createParamDecorator((data: unknown, ctx: ExecutionContext) => {
  const req = ctx.switchToHttp().getRequest();
  const logIn = <U>(user: U): Promise<U> => new Promise(
    (resolve, reject) => req.logIn(user, err => err ? reject(err) : resolve(user))
  );
  return { logIn };
})

DScheglov

const message =
  i % 3 === 0 && i % 5 === 0 ? (
    "fizzbuzz"
  ) : i % 3 === 0 ? (
    "fizz"
  ) : i % 5 === 0 ? (
    "buzz"
  ) : i % 7 === 0 ? (
    "foo"
  ) : (

DScheglov

interface IServices {
  logger: ILogger,
  dataAccessService: IDataAccessService,
  ecommerceService: IECommerceService,
}

class ServiceLocator implements IServices {
  private _logger: ILogger | null = null;
  private _dataAccessService: IDataAccessService | null = null;
  private _ecommerceService: IECommerceService | null = null;

DScheglov

import React from 'react';
import { compose } from "...somewhere...";

export const diContext = React.createContext({
  container: {},
  run: () => {},
));

export const { Consumer } = diContext;

DScheglov

const getFrom = container => prop => container[prop];

const createInstance = (factory, deps) =>
  deps.some(isPromise) 
    ? Promise.all(deps).then(resolvedDeps => factory(...resolvedDeps))
    : factory(...deps);

export const asFactory = (factory, inject = factory.inject) => container =>
  Array.isArray(inject)
    ? createInstance(factory, inject.map(getFrom(container)))

DScheglov

const getFrom = container => prop => container[prop];

const createInstance = (factory, deps) =>
  deps.some(isPromise) 
    ? Promise.all(deps).then(resolvedDeps => factory(...resolvedDeps))
    : factory(...deps);

export const asFactory = factory => container =>
  Array.isArray(factory.inject)
    ? createInstance(factory, factory.inject.map(getFrom(container)))

DScheglov

import { multiple } from "true-di";

export const asValue = <T>(value: T) => <C>(dependencies: C) => value;

export const asFactory = <D, T>(factory: (dependencies: D) => T) => factory;

asFactory.multi = multiple;

type ClassConstructor<D extends {}, T> = {
  new (dependencies: D): T

DScheglov

type ComparatorFn<T> = (a: T, b: T) => number;
type CasterFn<T> = (value: T) => number;

export const reverse = <T>(compare: ComparatorFn<T>): ComparatorFn<T> => (a: T, b: T) => -compare(a, b);

const combineComparators = <T>(compareA: ComparatorFn<T>, compareB: ComparatorFn<T>): ComparatorFn<T> =>
   (a: T, b: T) => compareA(a, b) || compareB(a, b);

const voidComparator = <T>(a: T, b: T): number => 0;

DScheglov

import Express from 'express';
import diContainer from 'true-di';
import createDataAccessService from '../services/data-access-service';
import createAuthorizationService from '../services/authorization-service';
import { IApolloContext } from '../interfaces';

const createContext = (dbConnection: Promise<Connection>) => ({ req }: { req: Express.Context }) =>
  dbConnection.then(
    conn => diContainer<IApolloContext>({
      dataAccessService: () => createDataAccessService(conn),

DScheglov

/** @type {(ms: number) => Promise<void>} */
const delay = ms => new Promise(resolve => setTimeout(resolve, ms));

export default delay;