@gitbeaker/requester-utils 35.8.0 → 35.8.1

package/dist/index.d.ts

@@ -0,0 +1,74 @@
+type ResponseBodyTypes = Record<string, unknown> | Record<string, unknown>[] | ReadableStream | Blob | string | string[] | number | void;
+interface FormattedResponse<T extends ResponseBodyTypes = ResponseBodyTypes> {
+    body: T;
+    headers: Record<string, string>;
+    status: number;
+}
+interface RequesterType {
+    get<T extends ResponseBodyTypes>(endpoint: string, options?: Record<string, unknown>): Promise<FormattedResponse<T>>;
+    post<T extends ResponseBodyTypes>(endpoint: string, options?: Record<string, unknown>): Promise<FormattedResponse<T>>;
+    put<T extends ResponseBodyTypes>(endpoint: string, options?: Record<string, unknown>): Promise<FormattedResponse<T>>;
+    patch<T extends ResponseBodyTypes>(endpoint: string, options?: Record<string, unknown>): Promise<FormattedResponse<T>>;
+    delete<T extends ResponseBodyTypes>(endpoint: string, options?: Record<string, unknown>): Promise<FormattedResponse<T>>;
+}
+interface Constructable<T = any> {
+    new (...args: any[]): T;
+}
+type DefaultResourceOptions = {
+    headers: {
+        [header: string]: string;
+    };
+    requestTimeout: number;
+    url: string;
+    rejectUnauthorized: boolean;
+};
+type DefaultRequestOptions = {
+    body?: FormData | Record<string, unknown>;
+    searchParams?: Record<string, unknown>;
+    sudo?: string;
+    method?: string;
+    asStream?: boolean;
+};
+type RequestOptions = {
+    headers: Record<string, string>;
+    timeout?: number;
+    method: string;
+    searchParams?: string;
+    prefixUrl: string;
+    body?: string | FormData;
+    asStream?: boolean;
+};
+declare function formatQuery(params?: Record<string, unknown>): string;
+type OptionsHandlerFn = (serviceOptions: DefaultResourceOptions, requestOptions: DefaultRequestOptions) => Promise<RequestOptions>;
+declare function defaultOptionsHandler(resourceOptions: DefaultResourceOptions, { body, searchParams, sudo, asStream, method }?: DefaultRequestOptions): Promise<RequestOptions>;
+type RequestHandlerFn<T extends ResponseBodyTypes = ResponseBodyTypes> = (endpoint: string, options?: Record<string, unknown>) => Promise<FormattedResponse<T>>;
+declare function createRequesterFn(optionsHandler: OptionsHandlerFn, requestHandler: RequestHandlerFn): (serviceOptions: DefaultResourceOptions) => RequesterType;
+declare function presetResourceArguments<T extends Record<string, Constructable>>(resources: T, customConfig?: Record<string, unknown>): T;
+
+interface BaseResourceOptions<C> {
+    oauthToken?: string;
+    token?: string;
+    jobToken?: string;
+    host?: string;
+    prefixUrl?: string;
+    rejectUnauthorized?: boolean;
+    camelize?: C;
+    requesterFn?: (resourceOptions: DefaultResourceOptions) => RequesterType;
+    requestTimeout?: number;
+    profileToken?: string;
+    sudo?: string | number;
+    profileMode?: 'execution' | 'memory';
+}
+declare class BaseResource<C extends boolean = false> {
+    readonly url: string;
+    readonly requester: RequesterType;
+    readonly requestTimeout: number;
+    readonly headers: {
+        [header: string]: string;
+    };
+    readonly camelize: C | undefined;
+    readonly rejectUnauthorized: boolean;
+    constructor({ token, jobToken, oauthToken, sudo, profileToken, requesterFn, camelize, profileMode, host, prefixUrl, rejectUnauthorized, requestTimeout, }?: BaseResourceOptions<C>);
+}
+
+export { BaseResource, BaseResourceOptions, Constructable, DefaultRequestOptions, DefaultResourceOptions, FormattedResponse, OptionsHandlerFn, RequestHandlerFn, RequestOptions, RequesterType, ResponseBodyTypes, createRequesterFn, defaultOptionsHandler, formatQuery, presetResourceArguments };

package/dist/index.mjs

@@ -0,0 +1,111 @@
+import { decamelizeKeys } from 'xcase';
+import { stringify } from 'qs';
+
+// src/RequesterUtils.ts
+function formatQuery(params = {}) {
+  const decamelized = decamelizeKeys(params);
+  return stringify(decamelized, { arrayFormat: "brackets" });
+}
+function isFormData(object) {
+  return typeof object === "object" && object.constructor.name === "FormData";
+}
+function defaultOptionsHandler(resourceOptions, { body, searchParams, sudo, asStream = false, method = "get" } = {}) {
+  const { headers: preconfiguredHeaders, requestTimeout, url } = resourceOptions;
+  const headers = { ...preconfiguredHeaders };
+  const defaultOptions = {
+    headers,
+    timeout: requestTimeout,
+    method,
+    asStream,
+    prefixUrl: url
+  };
+  if (sudo)
+    defaultOptions.headers.sudo = sudo;
+  if (body) {
+    if (isFormData(body)) {
+      defaultOptions.body = body;
+    } else {
+      defaultOptions.body = JSON.stringify(decamelizeKeys(body));
+      headers["content-type"] = "application/json";
+    }
+  }
+  const q = formatQuery(searchParams);
+  if (q)
+    defaultOptions.searchParams = q;
+  return Promise.resolve(defaultOptions);
+}
+function createRequesterFn(optionsHandler, requestHandler) {
+  const methods = ["get", "post", "put", "patch", "delete"];
+  return (serviceOptions) => {
+    const requester = {};
+    methods.forEach((m) => {
+      requester[m] = async (endpoint, options) => {
+        const requestOptions = await optionsHandler(serviceOptions, { ...options, method: m });
+        return requestHandler(endpoint, requestOptions);
+      };
+    });
+    return requester;
+  };
+}
+function extendClass(Base, customConfig = {}) {
+  return class extends Base {
+    constructor(...options) {
+      const [config, ...opts] = options;
+      super({ ...customConfig, ...config }, ...opts);
+    }
+  };
+}
+function presetResourceArguments(resources, customConfig = {}) {
+  const updated = {};
+  Object.entries(resources).filter(([, s]) => typeof s === "function").forEach(([k, r]) => {
+    updated[k] = extendClass(r, customConfig);
+  });
+  return updated;
+}
+
+// src/BaseResource.ts
+var BaseResource = class {
+  url;
+  requester;
+  requestTimeout;
+  headers;
+  camelize;
+  rejectUnauthorized;
+  constructor({
+    token,
+    jobToken,
+    oauthToken,
+    sudo,
+    profileToken,
+    requesterFn,
+    camelize,
+    profileMode = "execution",
+    host = "https://gitlab.com",
+    prefixUrl = "",
+    rejectUnauthorized = true,
+    requestTimeout = 3e5
+  } = {}) {
+    if (!requesterFn)
+      throw new ReferenceError("requesterFn must be passed");
+    this.url = [host, "api", "v4", prefixUrl].join("/");
+    this.headers = {};
+    this.rejectUnauthorized = rejectUnauthorized;
+    this.camelize = camelize;
+    this.requestTimeout = requestTimeout;
+    if (oauthToken)
+      this.headers.authorization = `Bearer ${oauthToken}`;
+    else if (jobToken)
+      this.headers["job-token"] = jobToken;
+    else if (token)
+      this.headers["private-token"] = token;
+    if (profileToken) {
+      this.headers["X-Profile-Token"] = profileToken;
+      this.headers["X-Profile-Mode"] = profileMode;
+    }
+    if (sudo)
+      this.headers.Sudo = `${sudo}`;
+    this.requester = requesterFn({ ...this });
+  }
+};
+
+export { BaseResource, createRequesterFn, defaultOptionsHandler, formatQuery, presetResourceArguments };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gitbeaker/requester-utils",
   "description": "Utility functions for requester implementatons used in @gitbeaker",
-  "version": "35.8.0",
+  "version": "35.8.1",
   "author": {
     "name": "Justin Dalrymple"
   },
@@ -46,6 +46,5 @@
     "build": "rollup -c",
     "test:integration": "node --expose-gc ../../node_modules/.bin/jest --runInBand --logHeapUsage test/integration",
     "test:unit": "node --expose-gc ../../node_modules/.bin/jest --runInBand --logHeapUsage test/unit"
-  },
-  "gitHead": "f42202715f3b6d327bf63b20bffdea41d0d72009"
+  }
 }

package/LICENSE.md

@@ -1,22 +0,0 @@
-# The MIT License
-
-Copyright (c)
-**2020 Justin Dalrymple**
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.