reggi

class MongoOptions () {
    static parse () {
      // does all the parsing without async eg DNS checking operations
    }
    
    static performAsync () {
      // follow up handler to check eg DNS (async) tasks
    }
    
    static parseAsync () {

reggi

Class Design Discussion

This is a document containg many different examples of how to create the same base code. Each example is different, contains a different API, or different added functionality such as cashing.

• Example A
• Example B
• Example C
• Example D
• Example E
• Example F

reggi

echo "\nchanging the directory to home dir --------------------------------------------------------------------------------------------------------\n"
cd ~/

echo "\nkilling all running mongo processes -------------------------------------------------------------------------------------------------------\n"
mongod --shutdown --config /shared/replica-sets/mongod-repl-1.conf 
mongod --shutdown --config /shared/replica-sets/mongod-repl-2.conf 
mongod --shutdown --config /shared/replica-sets/mongod-repl-3.conf 

echo "\nremoving all data directories -------------------------------------------------------------------------------------------------------------\n"
rm -rf /var/mongodb/db/1

reggi

I am trying to find a way that a resolver can essentially return another resolver using [nest.js][1] for creating [Resolvers][2], and [type-graphql][3] to create [object types][4].

Here's an example with the star-wars graphql api

{
  allVehicles(first: 1, last: 100) {
    vehicles {
      name

reggi

export function ServiceState<G>(): new () => { value?: G, set(type: G): G }
export function ServiceState<G>(type: G): new () => { value: G, set(type: G): G }
export function ServiceState<G>(type?: G) {
    return class ServiceState {
        value: G | undefined

        constructor() {
            this.value = type
        }

reggi

namespace Fox {

    export namespace Suppress {
        type ThenArg<T> = T extends Promise<infer U> ? U : T
        type ReturnAdd<T extends Func, G> = ReturnType<T> extends Promise<infer U> ? Promise<ThenArg<ReturnType<T>> | G> : ReturnType<T> | G
        export type Func = (...args: any[]) => any
        export type Return<T extends Func> = ReturnAdd<T, undefined>
    }

reggi

import {journey} from '@reggi/journey'
import * as lodash from 'lodash'

const getPairs = (obj) => lodash.entries(obj).map(([key, method], index) => ({key, method, index}));

const nestedReduce = (pairs, cb) => {
    return pairs.reduce((acq, fromPair) => {
        acq[fromPair.key] = pairs.reduce((acq, toPair) => {
            const r = cb({ fromPair, toPair });
            if (r) acq[toPair.key] = r;

reggi

const libs = []

export enum Types {
    number,
    numbers,
    string,
    buffer,
}

export enum Actions {

reggi

declare const lodash: typeof import('lodash')
export = lodash

reggi

enum Outing {
    COMEDY,
    DJ_DANCE_PARTY,
    SIT_DOWN_LIVE_MUSIC,
    BOARD_GAME_NIGHT,
    MOVIE,
    CONCERT,
    THEATER,
    DANCE_PROFORANCE,
    BILLIARDS,