api-def 0.12.0-alpha.54 → 0.12.0-alpha.55

package/cjs/ApiUtils.d.ts

@@ -8,5 +8,5 @@ export declare const isCancelledError: (error: Error) => error is CancelledReque
 export declare const isNetworkError: (error: Error) => boolean;
 export declare const isAcceptableStatus: (status: number, acceptableStatus?: AcceptableStatus[]) => boolean;
 export declare const inferResponseType: (contentType: string | null | undefined) => ResponseType;
-export declare const resolvePathParams: (path: string, params: Record<string, string> | undefined) => string;
+export declare const resolvePathParams: (path: string, params: Record<string, string> | undefined, allowMissing?: boolean) => string;
 export declare const resolveUrl: (options: ResolveUrlOptions) => URL;

package/cjs/ApiUtils.js

@@ -55,7 +55,7 @@ var inferResponseType = function (contentType) {
     return "text";
 };
 exports.inferResponseType = inferResponseType;
-var resolvePathParams = function (path, params) {
+var resolvePathParams = function (path, params, allowMissing) {
     var computedPath = path.startsWith("/") ? path : "/".concat(path);
     if (params) {
         var computedPathParts = computedPath.split("/");
@@ -72,13 +72,16 @@ var resolvePathParams = function (path, params) {
             if (paramKey) {
                 var paramValue = params[paramKey];
                 if (!paramValue) {
+                    if (allowMissing) {
+                        continue;
+                    }
                     throw new Error("[api-def] Missing param '".concat(paramKey, "'"));
                 }
                 computedPathParts[i] = paramValue;
                 unusedKeys.delete(paramKey);
             }
         }
-        if (unusedKeys.size > 0) {
+        if (unusedKeys.size > 0 && !allowMissing) {
             throw new Error("[api-def] Missing param '".concat(Array.from(unusedKeys)[0], "'"));
         }
         return computedPathParts.join("/");

package/cjs/RequestContext.d.ts

@@ -8,6 +8,7 @@ import type RequestBackend from "./backend/RequestBackend";
 export default class RequestContext<TResponse = any, TParams extends Params | undefined = Params | undefined, TQuery extends Query | undefined = Query | undefined, TBody extends Body | undefined = Body | undefined, TState extends State = State> {
     readonly id: number;
     readonly key: string;
+    private readonly rawPath;
     private computedPath;
     private computedBaseUrl;
     private computedMethod;
@@ -25,7 +26,8 @@ export default class RequestContext<TResponse = any, TParams extends Params | un
     readonly mocking: EndpointMockingConfig<TResponse, TParams, TQuery, TBody, TState> | null | undefined;
     private parsedBody;
     readonly validation: Validation<TResponse, TParams, TQuery, TBody, TState>;
-    constructor(backend: RequestBackend, host: RequestHost, config: ComputedRequestConfig<TParams, TQuery, TBody, TState>, computedPath: string, mocking: EndpointMockingConfig<TResponse, TParams, TQuery, TBody, TState> | null | undefined);
+    constructor(backend: RequestBackend, host: RequestHost, config: ComputedRequestConfig<TParams, TQuery, TBody, TState>, rawPath: string, mocking: EndpointMockingConfig<TResponse, TParams, TQuery, TBody, TState> | null | undefined);
+    validatePath(): void;
     /**
      * @deprecated Use `requestConfig` instead
      */
@@ -37,6 +39,7 @@ export default class RequestContext<TResponse = any, TParams extends Params | un
     private initMiddleware;
     private generateKey;
     updateHeaders(newHeaders: RawHeaders): this;
+    updateParams(params: Partial<Record<string, string>>): this;
     private parseRequestBody;
     getParsedBody(): any;
     updateQuery(newQuery: Partial<TQuery>): this;

package/cjs/RequestContext.js

@@ -49,7 +49,7 @@ var ApiUtils_1 = require("./ApiUtils");
 var Utils = require("./Utils");
 var contextIdCounter = 0;
 var RequestContext = /** @class */ (function () {
-    function RequestContext(backend, host, config, computedPath, mocking) {
+    function RequestContext(backend, host, config, rawPath, mocking) {
         this.canceler = null;
         this.response = undefined;
         this.error = null;
@@ -60,7 +60,8 @@ var RequestContext = /** @class */ (function () {
         this.host = host;
         this.requestConfig = config;
         Utils.assign({}, this.requestConfig.headers);
-        this.computedPath = computedPath;
+        this.rawPath = rawPath;
+        this.computedPath = (0, ApiUtils_1.resolvePathParams)(host.path, config.params, true);
         this.computedBaseUrl = host.baseUrl;
         this.computedMethod = host.method;
         this.key = this.generateKey();
@@ -77,6 +78,9 @@ var RequestContext = /** @class */ (function () {
         this.parseRequestBody();
         this.computedRequestUrl = this.resolveRequestUrl();
     }
+    RequestContext.prototype.validatePath = function () {
+        this.computedPath = (0, ApiUtils_1.resolvePathParams)(this.rawPath, this.requestConfig.params);
+    };
     Object.defineProperty(RequestContext.prototype, "computedConfig", {
         /**
          * @deprecated Use `requestConfig` instead
@@ -144,6 +148,12 @@ var RequestContext = /** @class */ (function () {
         this.parseRequestBody();
         return this;
     };
+    RequestContext.prototype.updateParams = function (params) {
+        this.requestConfig.params = Utils.assign({}, this.requestConfig.params, params);
+        this.computedPath = (0, ApiUtils_1.resolvePathParams)(this.rawPath, this.requestConfig.params);
+        this.computedRequestUrl = this.resolveRequestUrl();
+        return this;
+    };
     RequestContext.prototype.parseRequestBody = function () {
         var _a;
         if (this.requestConfig.body && this.requestConfig.headers) {

package/cjs/Requester.js

@@ -65,7 +65,7 @@ var submit = function (host, config, mocking) { return __awaiter(void 0, void 0,
             case 0:
                 computedConfig = host.computeConfig(config);
                 backend = mocking ? MOCK_REQUEST_BACKEND : host.getRequestBackend();
-                context = new RequestContext_1.default(backend, host, computedConfig, (0, ApiUtils_1.resolvePathParams)(host.path, config.params), mocking);
+                context = new RequestContext_1.default(backend, host, computedConfig, host.path, mocking);
                 key = context.key;
                 lock = (context.requestConfig || {}).lock;
                 if (typeof lock === "string") {
@@ -123,6 +123,7 @@ var makeRequest = function (context) { return __awaiter(void 0, void 0, void 0,
                 if (beforeSendEventResult && beforeSendEventResult.type === ApiConstants_1.EventResultType.RESPOND) {
                     return [2 /*return*/, (context.response = beforeSendEventResult.response)];
                 }
+                context.validatePath();
                 // validation
                 if (context.validation.query) {
                     try {

package/esm/ApiUtils.d.ts

@@ -8,5 +8,5 @@ export declare const isCancelledError: (error: Error) => error is CancelledReque
 export declare const isNetworkError: (error: Error) => boolean;
 export declare const isAcceptableStatus: (status: number, acceptableStatus?: AcceptableStatus[]) => boolean;
 export declare const inferResponseType: (contentType: string | null | undefined) => ResponseType;
-export declare const resolvePathParams: (path: string, params: Record<string, string> | undefined) => string;
+export declare const resolvePathParams: (path: string, params: Record<string, string> | undefined, allowMissing?: boolean) => string;
 export declare const resolveUrl: (options: ResolveUrlOptions) => URL;

package/esm/ApiUtils.js

@@ -47,7 +47,7 @@ export const inferResponseType = (contentType) => {
     }
     return "text";
 };
-export const resolvePathParams = (path, params) => {
+export const resolvePathParams = (path, params, allowMissing) => {
     const computedPath = path.startsWith("/") ? path : `/${path}`;
     if (params) {
         const computedPathParts = computedPath.split("/");
@@ -64,13 +64,16 @@ export const resolvePathParams = (path, params) => {
             if (paramKey) {
                 const paramValue = params[paramKey];
                 if (!paramValue) {
+                    if (allowMissing) {
+                        continue;
+                    }
                     throw new Error(`[api-def] Missing param '${paramKey}'`);
                 }
                 computedPathParts[i] = paramValue;
                 unusedKeys.delete(paramKey);
             }
         }
-        if (unusedKeys.size > 0) {
+        if (unusedKeys.size > 0 && !allowMissing) {
             throw new Error(`[api-def] Missing param '${Array.from(unusedKeys)[0]}'`);
         }
         return computedPathParts.join("/");

package/esm/RequestContext.d.ts

@@ -8,6 +8,7 @@ import type RequestBackend from "./backend/RequestBackend";
 export default class RequestContext<TResponse = any, TParams extends Params | undefined = Params | undefined, TQuery extends Query | undefined = Query | undefined, TBody extends Body | undefined = Body | undefined, TState extends State = State> {
     readonly id: number;
     readonly key: string;
+    private readonly rawPath;
     private computedPath;
     private computedBaseUrl;
     private computedMethod;
@@ -25,7 +26,8 @@ export default class RequestContext<TResponse = any, TParams extends Params | un
     readonly mocking: EndpointMockingConfig<TResponse, TParams, TQuery, TBody, TState> | null | undefined;
     private parsedBody;
     readonly validation: Validation<TResponse, TParams, TQuery, TBody, TState>;
-    constructor(backend: RequestBackend, host: RequestHost, config: ComputedRequestConfig<TParams, TQuery, TBody, TState>, computedPath: string, mocking: EndpointMockingConfig<TResponse, TParams, TQuery, TBody, TState> | null | undefined);
+    constructor(backend: RequestBackend, host: RequestHost, config: ComputedRequestConfig<TParams, TQuery, TBody, TState>, rawPath: string, mocking: EndpointMockingConfig<TResponse, TParams, TQuery, TBody, TState> | null | undefined);
+    validatePath(): void;
     /**
      * @deprecated Use `requestConfig` instead
      */
@@ -37,6 +39,7 @@ export default class RequestContext<TResponse = any, TParams extends Params | un
     private initMiddleware;
     private generateKey;
     updateHeaders(newHeaders: RawHeaders): this;
+    updateParams(params: Partial<Record<string, string>>): this;
     private parseRequestBody;
     getParsedBody(): any;
     updateQuery(newQuery: Partial<TQuery>): this;

package/esm/RequestContext.js

@@ -7,11 +7,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { resolveUrl } from "./ApiUtils";
+import { resolvePathParams, resolveUrl } from "./ApiUtils";
 import * as Utils from "./Utils";
 let contextIdCounter = 0;
 export default class RequestContext {
-    constructor(backend, host, config, computedPath, mocking) {
+    constructor(backend, host, config, rawPath, mocking) {
         this.canceler = null;
         this.response = undefined;
         this.error = null;
@@ -22,7 +22,8 @@ export default class RequestContext {
         this.host = host;
         this.requestConfig = config;
         Utils.assign({}, this.requestConfig.headers);
-        this.computedPath = computedPath;
+        this.rawPath = rawPath;
+        this.computedPath = resolvePathParams(host.path, config.params, true);
         this.computedBaseUrl = host.baseUrl;
         this.computedMethod = host.method;
         this.key = this.generateKey();
@@ -39,6 +40,9 @@ export default class RequestContext {
         this.parseRequestBody();
         this.computedRequestUrl = this.resolveRequestUrl();
     }
+    validatePath() {
+        this.computedPath = resolvePathParams(this.rawPath, this.requestConfig.params);
+    }
     /**
      * @deprecated Use `requestConfig` instead
      */
@@ -89,6 +93,12 @@ export default class RequestContext {
         this.parseRequestBody();
         return this;
     }
+    updateParams(params) {
+        this.requestConfig.params = Utils.assign({}, this.requestConfig.params, params);
+        this.computedPath = resolvePathParams(this.rawPath, this.requestConfig.params);
+        this.computedRequestUrl = this.resolveRequestUrl();
+        return this;
+    }
     parseRequestBody() {
         var _a;
         if (this.requestConfig.body && this.requestConfig.headers) {

package/esm/Requester.js

@@ -8,7 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { EventResultType, RequestEvent } from "./ApiConstants";
-import { inferResponseType, isAcceptableStatus, isNetworkError, resolvePathParams } from "./ApiUtils";
+import { inferResponseType, isAcceptableStatus, isNetworkError } from "./ApiUtils";
 import RequestContext from "./RequestContext";
 import { RequestErrorCode, convertToRequestError, isRequestError } from "./RequestError";
 import { textDecode } from "./TextDecoding";
@@ -20,7 +20,7 @@ const MOCK_REQUEST_BACKEND = new MockRequestBackend();
 export const submit = (host, config, mocking) => __awaiter(void 0, void 0, void 0, function* () {
     const computedConfig = host.computeConfig(config);
     const backend = mocking ? MOCK_REQUEST_BACKEND : host.getRequestBackend();
-    const context = new RequestContext(backend, host, computedConfig, resolvePathParams(host.path, config.params), mocking);
+    const context = new RequestContext(backend, host, computedConfig, host.path, mocking);
     const { key } = context;
     // don't do this -- should only be for GET requests anyway and should be opt-in
     /*
@@ -72,6 +72,7 @@ const makeRequest = (context) => __awaiter(void 0, void 0, void 0, function* ()
     if (beforeSendEventResult && beforeSendEventResult.type === EventResultType.RESPOND) {
         return (context.response = beforeSendEventResult.response);
     }
+    context.validatePath();
     // validation
     if (context.validation.query) {
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "api-def",
-  "version": "0.12.0-alpha.54",
+  "version": "0.12.0-alpha.55",
   "description": "Typed API definitions with middleware support",
   "main": "cjs/index.js",
   "types": "esm/index.d.ts",