refactor: move createFromString and resource from Prism Http to CLI

CHANGELOG.md

@@ -8,6 +8,11 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 # Unreleased
 
+## Changed
+
+- **BREAKING**: The `getHttpOperationsFromSpec` and `getHttpOperationsFromResource` have been moved from the HTTP Package to the CLI package. If you're using Prism programmatically, this might require some code changes on your side [#1009](https://github.com/stoplightio/prism/pull/1009)
+- **BREAKING**: The `createClientFromOperations` is now exported as `export function` instead of exporting an object. If you're using Prism programmatically, this might require some code changes on your side [#1009](https://github.com/stoplightio/prism/pull/1009)
+
 # 3.3.4 (2020-05-04)
 
 ## Fixed

docs/guides/http-client.md

@@ -2,19 +2,33 @@
 
 Prism includes a fully-featured HTTP Client that you can use to seamlessly perform requests to both a real server and a mocked document. The client is modeled after Axios so it may feel familiar.
 
-### Create from a filename or http resource
+### Create From Manual HTTP Operations
 
 ```ts
-const client = await createClientFromResource('examples/petstore.oas2.yaml', {
-  mock: true,
-  validateRequest: true,
-  validateResponse: true,
-});
+const createClientFromOperations = require('@stoplight/prism-http/dist/client');
+
+const client = createClientFromOperations(
+  [
+    {
+      method: 'get',
+      path: '/hello',
+      id: 'n1',
+      responses: [{ code: '200' }],
+    },
+  ],
+  { mock: true, validateRequest: true, validateResponse: true }
+);
 ```
 
-### Create from OpenAPI string
+To create the required operations array you can use two utility functions defined in the `@stoplight/prism-cli` package:
+
+### Create from file or HTTP resource
 
 ```ts
+const { getHttpOperationsFromSpec, getHttpOperationsFromResource } = require('@stoplight/prism-cli/dist/operations');
+
+const operations = await getHttpOperationsFromResource('examples/petstore.oas2.yaml');
+
 const descriptionDoc = `
 openapi: 3.0.2
 paths:
@@ -25,27 +39,7 @@ paths:
           description: hello
 `;
 
-const client = await createClientFromString(descriptionDoc, {
-  mock: true,
-  validateRequest: true,
-  validateResponse: true,
-});
-```
-
-### Create From Manual Http Operations
-
-```ts
-const client = createClientFromOperations(
-  [
-    {
-      method: 'get',
-      path: '/hello',
-      id: 'n1',
-      responses: [{ code: '200' }],
-    },
-  ],
-  { mock: true, validateRequest: true, validateResponse: true }
-);
+const operations = await getHttpOperationsFromSpec(descriptionDoc);
 ```
 
 ---

package.json

@@ -16,7 +16,8 @@
     "posttest": "yarn lint",
     "test": "jest",
     "release": "lerna version",
-    "release:beta": "lerna publish --preid beta --no-push --no-git-tag-version --dist-tag beta",
+    "prerelease:beta": "yarn build",
+    "release:beta": "lerna publish --preid beta --force-publish=* --no-push --no-git-tag-version --dist-tag beta",
     "prebuild.binary": "yarn build",
     "build.binary": "npx pkg --output ./cli-binaries/prism-cli ./packages/cli/",
     "test.harness": "jest -c ./jest.harness.config.js"

packages/cli/package.json

@@ -7,6 +7,12 @@
   },
   "bugs": "https://github.com/stoplightio/prism/issues",
   "dependencies": {
+    "@stoplight/http-spec": "^2.12.0",
+    "@stoplight/json": "^3.1.2",
+    "@stoplight/json-ref-readers": "^1.1.1",
+    "@stoplight/json-ref-resolver": "^3.0.1",
+    "@stoplight/yaml": "^3.0.2",
+    "node-fetch": "^2.6.0",
     "@stoplight/prism-core": "^3.3.4",
     "@stoplight/prism-http": "^3.3.4",
     "@stoplight/prism-http-server": "^3.3.4",

packages/cli/src/commands/__tests__/commands.spec.ts

@@ -1,4 +1,4 @@
-import * as prismHttp from '@stoplight/prism-http';
+import * as operationUtils from '../../operations';
 import * as yargs from 'yargs';
 import { createMultiProcessPrism, createSingleProcessPrism } from '../../util/createServer';
 import mockCommand from '../mock';
@@ -11,7 +11,7 @@ jest.mock('../../util/createServer', () => ({
   createSingleProcessPrism: jest.fn().mockResolvedValue([]),
 }));
 
-jest.spyOn(prismHttp, 'getHttpOperationsFromResource').mockResolvedValue([]);
+jest.spyOn(operationUtils, 'getHttpOperationsFromResource').mockResolvedValue([]);
 
 describe.each<{ 0: string; 1: string; 2: unknown }>([
   ['mock', '', { dynamic: false }],

packages/http/src/getHttpOperations.ts → packages/cli/src/operations.ts

@@ -31,10 +31,10 @@ export async function getHttpOperationsFromResource(file: string): Promise<IHttp
     ? fetch(file).then(d => d.text())
     : fs.promises.readFile(file, { encoding: 'utf8' }));
 
-  return getHttpOperations(fileContent, isRemote ? file : resolve(file));
+  return getHttpOperationsFromSpec(fileContent, isRemote ? file : resolve(file));
 }
 
-export default async function getHttpOperations(specContent: string, baseUri?: string): Promise<IHttpOperation[]> {
+export async function getHttpOperationsFromSpec(specContent: string, baseUri?: string): Promise<IHttpOperation[]> {
   const parsedContent = parse(specContent);
   const { result: resolvedContent, errors } = await httpAndFileResolver.resolve(parsedContent, { baseUri });
 

packages/http/src/__tests__/getHttpOperations.spec.ts → packages/cli/src/util/__tests__/getHttpOperations.spec.ts

@@ -1,10 +1,10 @@
-import getHttpOperations from '../getHttpOperations';
+import { getHttpOperationsFromSpec } from '../../operations';
 
-describe('getHttpOperations()', () => {
+describe('getHttpOperationsFromSpec()', () => {
   describe('ref resolving fails', () => {
     it('fails with exception', () => {
       return expect(
-        getHttpOperations(
+        getHttpOperationsFromSpec(
           JSON.stringify({
             openapi: '3.0.0',
             paths: { $ref: 'abc://' },
@@ -17,7 +17,7 @@ describe('getHttpOperations()', () => {
 
     it('deduplicates similar errors', () => {
       return expect(
-        getHttpOperations(
+        getHttpOperationsFromSpec(
           JSON.stringify({
             openapi: '3.0.0',
             paths: { $ref: 'abc://' },
@@ -33,18 +33,18 @@ describe('getHttpOperations()', () => {
   describe('ref resolving succeeds', () => {
     describe('OpenAPI 2 document is provided', () => {
       it('detects it properly', () => {
-        return expect(getHttpOperations(JSON.stringify({ swagger: '2.0' }))).resolves.toBeTruthy();
+        return expect(getHttpOperationsFromSpec(JSON.stringify({ swagger: '2.0' }))).resolves.toBeTruthy();
       });
     });
 
     describe('OpenAPI 3 document is provided', () => {
       it('detects it properly', () => {
-        return expect(getHttpOperations(JSON.stringify({ openapi: '3.0.0' }))).resolves.toBeTruthy();
+        return expect(getHttpOperationsFromSpec(JSON.stringify({ openapi: '3.0.0' }))).resolves.toBeTruthy();
       });
 
       it('returns correct HttpOperation', () => {
         return expect(
-          getHttpOperations(
+          getHttpOperationsFromSpec(
             JSON.stringify({
               openapi: '3.0.0',
               paths: {
@@ -71,13 +71,15 @@ describe('getHttpOperations()', () => {
 
     describe('Postman Collection document is provided', () => {
       it('detects it properly', () => {
-        return expect(getHttpOperations(JSON.stringify({ info: { name: 'Test' }, item: [] }))).resolves.toBeTruthy();
+        return expect(
+          getHttpOperationsFromSpec(JSON.stringify({ info: { name: 'Test' }, item: [] }))
+        ).resolves.toBeTruthy();
       });
     });
 
     describe('unknown document is provided', () => {
       it('throws error', () => {
-        return expect(getHttpOperations(JSON.stringify({}))).rejects.toThrow(/^Unsupported document format$/);
+        return expect(getHttpOperationsFromSpec(JSON.stringify({}))).rejects.toThrow(/^Unsupported document format$/);
       });
     });
   });

packages/cli/src/util/createServer.ts

@@ -1,5 +1,5 @@
 import { createLogger } from '@stoplight/prism-core';
-import { IHttpConfig, IHttpProxyConfig, getHttpOperationsFromResource } from '@stoplight/prism-http';
+import { IHttpConfig, IHttpProxyConfig } from '@stoplight/prism-http';
 import { createServer as createHttpServer } from '@stoplight/prism-http-server';
 import * as chalk from 'chalk';
 import * as cluster from 'cluster';
@@ -13,6 +13,7 @@ import { LOG_COLOR_MAP } from '../const/options';
 import { createExamplePath } from './paths';
 import { attachTagsToParamsValues, transformPathParamsValues } from './colorizer';
 import { CreatePrism } from './runner';
+import { getHttpOperationsFromResource } from '../operations';
 
 signale.config({ displayTimestamp: true });
 

packages/cli/src/util/runner.ts

@@ -1,8 +1,8 @@
-import { getHttpOperationsFromResource } from '@stoplight/prism-http';
 import { IPrismHttpServer } from '@stoplight/prism-http-server/src/types';
 import * as chokidar from 'chokidar';
 import * as os from 'os';
 import { CreateMockServerOptions } from './createServer';
+import { getHttpOperationsFromResource } from '../operations';
 
 export type CreatePrism = (options: CreateMockServerOptions) => Promise<IPrismHttpServer | void>;
 

packages/http-server/src/__tests__/server.oas.spec.ts

@@ -1,5 +1,6 @@
 import { createLogger } from '@stoplight/prism-core';
-import { getHttpOperationsFromResource, IHttpConfig } from '@stoplight/prism-http';
+import { getHttpOperationsFromResource } from '@stoplight/prism-cli/src/operations';
+import { IHttpConfig } from '@stoplight/prism-http';
 import { resolve } from 'path';
 import { merge } from 'lodash';
 import fetch, { RequestInit } from 'node-fetch';

packages/http-server/src/serialize.ts

@@ -1,19 +1,19 @@
 import { j2xParser } from 'fast-xml-parser';
-import typeIs = require('type-is');
+import { is as typeIs } from 'type-is';
 
 const xmlSerializer = new j2xParser({});
 
 const serializers = [
   {
-    test: (value: string) => !!typeIs.is(value, ['application/json', 'application/*+json']),
+    test: (value: string) => !!typeIs(value, ['application/json', 'application/*+json']),
     serializer: JSON.stringify,
   },
   {
-    test: (value: string) => !!typeIs.is(value, ['application/xml', 'application/*+xml']),
+    test: (value: string) => !!typeIs(value, ['application/xml', 'application/*+xml']),
     serializer: (data: unknown) => (typeof data === 'string' ? data : xmlSerializer.parse({ xml: data })),
   },
   {
-    test: (value: string) => !!typeIs.is(value, ['text/*']),
+    test: (value: string) => !!typeIs(value, ['text/*']),
     serializer: (data: unknown) => {
       if (['string', 'undefined'].includes(typeof data)) {
         return data;

packages/http/package.json

@@ -16,10 +16,7 @@
     "node": ">=8"
   },
   "dependencies": {
-    "@stoplight/http-spec": "2.11.0",
-    "@stoplight/json": "^3.1.2",
-    "@stoplight/json-ref-readers": "^1.1.1",
-    "@stoplight/json-ref-resolver": "^3.0.1",
+    "@stoplight/json": "^3.7.1",
     "@stoplight/prism-core": "^3.3.4",
     "@stoplight/types": "^11.6.0",
     "@stoplight/yaml": "^3.0.2",

packages/http/src/__tests__/http-prism-instance.spec.ts

@@ -4,7 +4,7 @@ import { Scope as NockScope } from 'nock';
 import * as nock from 'nock';
 import { basename, resolve } from 'path';
 import { createInstance, IHttpProxyConfig, IHttpRequest, IHttpResponse, ProblemJsonError } from '../';
-import { getHttpOperationsFromResource } from '../getHttpOperations';
+import { getHttpOperationsFromResource } from '@stoplight/prism-cli/src/operations';
 import { UNPROCESSABLE_ENTITY } from '../mocker/errors';
 import { NO_PATH_MATCHED_ERROR, NO_SERVER_MATCHED_ERROR } from '../router/errors';
 import { assertResolvesRight, assertResolvesLeft } from '@stoplight/prism-core/src/__tests__/utils';

packages/http/src/client.ts

@@ -1,10 +1,9 @@
 import { IPrismOutput } from '@stoplight/prism-core';
 import { IHttpOperation } from '@stoplight/types';
-import { defaults, partial } from 'lodash';
+import { defaults } from 'lodash';
 import { parse as parseQueryString } from 'querystring';
 import { parse as parseUrl } from 'url';
 import { createInstance } from '.';
-import getHttpOperations, { getHttpOperationsFromResource } from './getHttpOperations';
 import { IHttpConfig, IHttpRequest, IHttpResponse, IHttpUrl } from './types';
 import { fold } from 'fp-ts/lib/TaskEither';
 import * as Task from 'fp-ts/lib/Task';
@@ -18,18 +17,7 @@ interface IClientConfig extends IHttpConfig {
   baseUrl?: string;
 }
 
-function createClientFrom(
-  getResource: (v: string) => Promise<IHttpOperation[]>,
-  document: string,
-  defaultConfig: IHttpConfig
-): Promise<PrismHttp> {
-  return getResource(document).then(resources => createClientFromOperations(resources, defaultConfig));
-}
-
-const createClientFromResource = partial(createClientFrom, getHttpOperationsFromResource);
-const createClientFromString = partial(createClientFrom, getHttpOperations);
-
-function createClientFromOperations(resources: IHttpOperation[], defaultConfig: IClientConfig): PrismHttp {
+export function createClientFromOperations(resources: IHttpOperation[], defaultConfig: IClientConfig): PrismHttp {
   const obj = createInstance(defaultConfig, { logger });
 
   type headersFromRequest = Required<Pick<IHttpRequest, 'headers'>>;
@@ -178,5 +166,3 @@ export type PrismHttp = {
   patch: IRequestFunctionWithMethodWithBody;
   trace: IRequestFunctionWithMethod;
 };
-
-export { createClientFromResource, createClientFromString, createClientFromOperations };

packages/http/src/index.ts

@@ -6,7 +6,6 @@ import mock from './mocker';
 import route from './router';
 import { validateInput, validateOutput, validateSecurity } from './validator';
 export * from './types';
-export * from './getHttpOperations';
 export * from './mocker/errors';
 export * from './router/errors';
 export * from './mocker/serializer/style';

packages/http/src/mocker/generator/JSONSchema.ts

@@ -1,4 +1,4 @@
-import * as faker from 'faker';
+import * as faker from 'faker/locale/en_US';
 import { cloneDeep } from 'lodash';
 import { JSONSchema } from '../../types';
 

packages/http/src/mocker/index.ts

@@ -20,7 +20,7 @@ import { map } from 'fp-ts/lib/Array';
 import { Do } from 'fp-ts-contrib/lib/Do';
 import { isNumber, isString, keyBy, mapValues, groupBy, get } from 'lodash';
 import { Logger } from 'pino';
-import * as typeIs from 'type-is';
+import { is } from 'type-is';
 import {
   ContentExample,
   IHttpOperationConfig,
@@ -112,7 +112,7 @@ function parseBodyIfUrlEncoded(request: IHttpRequest, resource: IHttpOperation)
   const mediaType = caseless(request.headers || {}).get('content-type');
   if (!mediaType) return request;
 
-  if (!typeIs.is(mediaType, ['application/x-www-form-urlencoded'])) return request;
+  if (!is(mediaType, ['application/x-www-form-urlencoded'])) return request;
 
   const specs = pipe(
     O.fromNullable(resource.request),

packages/http/src/utils/parseResponse.ts

@@ -1,4 +1,4 @@
-import { Response } from 'node-fetch';
+import type { Response } from 'node-fetch';
 import { is as typeIs } from 'type-is';
 import * as E from 'fp-ts/lib/Either';
 import * as TE from 'fp-ts/lib/TaskEither';

packages/http/src/validator/index.ts

@@ -10,7 +10,7 @@ import * as caseless from 'caseless';
 import { findFirst, isNonEmpty } from 'fp-ts/lib/Array';
 import * as O from 'fp-ts/lib/Option';
 import * as E from 'fp-ts/lib/Either';
-import * as typeIs from 'type-is';
+import { is as typeIs } from 'type-is';
 import { pipe } from 'fp-ts/lib/pipeable';
 import { inRange } from 'lodash';
 import { validateSecurity } from './validators/security';
@@ -95,7 +95,7 @@ const findResponseByStatus = (responses: IHttpOperationResponse[], statusCode: n
 const validateMediaType = (contents: NonEmptyArray<IMediaTypeContent>, mediaType: string) =>
   pipe(
     contents,
-    findFirst(c => !!typeIs.is(mediaType, [c.mediaType])),
+    findFirst(c => !!typeIs(mediaType, [c.mediaType])),
     E.fromOption<IPrismDiagnostic>(() => ({
       message: `The received media type "${mediaType || ''}" does not match the one${
         contents.length > 1 ? 's' : ''

packages/http/src/validator/validators/body.ts

@@ -9,7 +9,7 @@ import { JSONSchema } from '../../types';
 import { body } from '../deserializers';
 import { IHttpValidator } from './types';
 import { validateAgainstSchema } from './utils';
-import { is } from 'type-is';
+import { is as typeIs } from 'type-is';
 import * as NonEmptyArray from 'fp-ts/lib/NonEmptyArray';
 
 export function deserializeFormBody(
@@ -58,7 +58,7 @@ export function decodeUriEntities(target: Dictionary<string>) {
 export function findContentByMediaTypeOrFirst(specs: IMediaTypeContent[], mediaType: string) {
   return pipe(
     specs,
-    Array.findFirst(spec => !!is(mediaType, [spec.mediaType])),
+    Array.findFirst(spec => !!typeIs(mediaType, [spec.mediaType])),
     O.alt(() => Array.head(specs)),
     O.map(content => ({ mediaType, content }))
   );
@@ -105,7 +105,7 @@ export class HttpBodyValidator implements IHttpValidator<any, IMediaTypeContent>
         ({ content, mediaType: mt, schema }) =>
           pipe(
             mt,
-            O.fromPredicate(mediaType => !!is(mediaType, ['application/x-www-form-urlencoded'])),
+            O.fromPredicate(mediaType => !!typeIs(mediaType, ['application/x-www-form-urlencoded'])),
             O.fold(
               () =>
                 pipe(