How to use the @marblejs/core.httpListener function in @marblejs/core

)),
      map(body => ({ body })),
    );
  }),
);

const listening$: HttpServerEffect = event$ =>
  event$.pipe(
    matchEvent(ServerEvent.listening),
    map(event => event.payload),
    tap(({ port, host }) => console.log(`Server running @ http://${host}:${port}/ 🚀`)),
  );

export const server = createServer({
  port,
  httpListener: httpListener({
    middlewares: [logger$()],
    effects: [test$, fib$],
  }),
  dependencies: [
    bindTo(ClientToken)(client),
  ],
  event$: (...args) => merge(
    listening$(...args),
  ),
});

if (process.env.NODE_ENV !== 'test') {
  server();
}

mapToServer({
      path: '/api/:version/ws',
      server: ask(WsServerToken),
    }),
  );

const listening$: HttpServerEffect = event$ =>
  event$.pipe(
    matchEvent(ServerEvent.listening),
    map(event => event.payload),
    tap(({ port, host }) => console.log(`Server running @ http://${host}:${port}/ 🚀`)),
  );

export const server = createServer({
  port: 1337,
  httpListener: httpListener({
    middlewares: [logger$()],
    effects: [root$],
  }),
  dependencies: [
    bindEagerlyTo(WsServerToken)(websocketsServer),
  ],
  event$: (...args) => merge(
    listening$(...args),
    upgrade$(...args),
  ),
});

if (process.env.NODE_ENV !== 'test') {
  server();
}

const file$ = EffectFactory
  .matchPath('/static/:dir')
  .matchType('GET')
  .use(req$ => req$
    .pipe(
      map(req => req.params!.dir as string),
      switchMap(readFile(STATIC_PATH)),
      map(body => ({ body }))
    ));

const user$ = combineRoutes('/user', [getUserList$, getUserSingle$, postUser$]);

const api$ = combineRoutes('/api/:version', [root$, file$, error$, user$]);

const app = httpListener({
  middlewares: [bodyParser$],
  effects: [api$],
});

describe('API integration', () => {
  it('returns 404 when route not found: /', async () =>
    request(app)
      .post('/')
      .expect(404));

  it('returns status 200: /api/v1', async () =>
    request(app)
      .get('/api/v1')
      .expect(200, '"root"'));

  it('returns error response: /api/v1/error', async () =>

)));

const filesystemMultipart$ = r.pipe(
  r.matchPath('/filesystem'),
  r.matchType('POST'),
  r.useEffect(req$ => req$.pipe(
    use(multipart$({
      stream: streamFileTo(TMP_PATH),
    })),
    map(req => ({ body: {
      files: req.files,
      fields: req.body,
    }}))
  )));

const app = httpListener({
  effects: [memoryMultipart$, memoryWithOptionsMultipart$, filesystemMultipart$],
}).run(createContext());

afterEach(() => {
  if (fs.existsSync(TMP_PATH)) { fs.rmdirSync(TMP_PATH); }
});

describe('multipart$', () => {
  test('parses multipart/form-data request with additional fields and stores it in-memory', async () => {
    const data = Buffer.from('test_buffer_1');

    return request(app)
      .post('/memory')
      .field('field_1', 'test_1')
      .field('field_2', 'test_2')
      .attach('data_field', data)

expect(() => createLambda({
      type: 'unknown' as any,
      httpListener: httpListener({ effects: [] }),
    })).toThrowError('Invalid type specified.');
  });

mapTo(({
      status: 200,
      headers: {
        'transfer-encoding': 'chunked',
      },
      body: new Readable({
        read(): void {
          this.push(JSON.stringify({ key: 'value' }));
          this.push(null);
        }
      }),
    }))
  ))
);

const app = httpListener({
  middlewares: [
    bodyParser$(),
    awsApiGatewayMiddleware$(),
  ],
  effects: [
    effect$,
    chunkedTransferEncodingEffect$,
  ],
});

export const createHandler = () => createLambda({
  httpListener: app,
  type: ProxyType.AWS,
  proxyOptions: {
    logger: () => void 0,
  },

import { bodyParser$ } from '@marblejs/middleware-body';
import { logger$ } from './api/common/middlewares/logger.middleware';
import { cors$ } from './api/common/middlewares/cors.middleware';
import { api$ } from './api';

const middlewares = [
  cors$,
  logger$,
  bodyParser$(),
];

const effects = [
  api$,
];

export const app = httpListener({ middlewares, effects });