@scaleway/sdk 0.0.2-alpha.0

package/dist/scw/errors/standard/resource-not-found-error.js

@@ -0,0 +1,25 @@
+import { ScalewayError } from '../scw-error.js';
+
+/**
+ * ResourceNotFound error happens when getting a resource that does not exist anymore.
+ *
+ * @public
+ */
+
+class ResourceNotFoundError extends ScalewayError {
+  constructor(status, body, resource, resourceId) {
+    super(status, body, `scaleway-sdk-js: resource ${resource} with ID ${resourceId} is not found`);
+    this.status = status;
+    this.body = body;
+    this.resource = resource;
+    this.resourceId = resourceId;
+  }
+
+  static fromJSON(status, obj) {
+    if (typeof obj.resource !== 'string' || typeof obj.resource_id !== 'string') return null;
+    return new ResourceNotFoundError(status, obj, obj.resource, obj.resource_id);
+  }
+
+}
+
+export { ResourceNotFoundError };

package/dist/scw/errors/standard/transient-state-error.js

@@ -0,0 +1,26 @@
+import { ScalewayError } from '../scw-error.js';
+
+/**
+ * TransientState error happens when trying to perform an action on a resource in a transient state.
+ *
+ * @public
+ */
+
+class TransientStateError extends ScalewayError {
+  constructor(status, body, resource, resourceId, currentState) {
+    super(status, body, `scaleway-sdk-js: resource ${resource} with ID ${resourceId} is in a transient state: ${currentState}`);
+    this.status = status;
+    this.body = body;
+    this.resource = resource;
+    this.resourceId = resourceId;
+    this.currentState = currentState;
+  }
+
+  static fromJSON(status, obj) {
+    if (typeof obj.resource !== 'string' || typeof obj.resource_id !== 'string' || typeof obj.current_state !== 'string') return null;
+    return new TransientStateError(status, obj, obj.resource, obj.resource_id, obj.current_state);
+  }
+
+}
+
+export { TransientStateError };

package/dist/scw/errors/types.js

@@ -0,0 +1,26 @@
+import { isJSONObject } from '../../helpers/json.js';
+
+/**
+ * Verifies the object is a record of string to string[].
+ *
+ * @param obj - The object
+ * @returns Whether the object is of the expected type
+ *
+ * @internal
+ */
+
+const isRecordOfStringArray = obj => {
+  if (!isJSONObject(obj)) {
+    return false;
+  }
+
+  for (const elt of Object.values(obj)) {
+    if (!Array.isArray(elt) || Object.values(elt).find(x => typeof x !== 'string') !== undefined) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+export { isRecordOfStringArray };

package/dist/scw/fetch/build-fetcher.js

@@ -0,0 +1,66 @@
+import { isBrowser } from '../../helpers/is-browser.js';
+import { obfuscateAuthHeadersEntry } from '../../internal/auth.js';
+import { composeInterceptors } from '../../internal/interceptors/interceptor.js';
+import { logRequest, logResponse, obfuscateInterceptor } from './http-interceptors.js';
+import { responseParser } from './response-parser.js';
+
+/**
+ * Builds Request from {@link ScwRequest} & {@link Settings}.
+ *
+ * @param request - A scaleway request
+ * @param settings - The settings
+ * @returns A fetch Request
+ *
+ * @internal
+ */
+const buildRequest = (request, settings) => {
+  let {
+    path
+  } = request;
+
+  if (request.urlParams instanceof URLSearchParams) {
+    path = path.concat(`?${request.urlParams.toString()}`);
+  }
+
+  return new Request(`${settings.apiURL}${path}`, {
+    body: request.body,
+    headers: {
+      Accept: 'application/json',
+      ...(!isBrowser() ? {
+        'User-Agent': settings.userAgent
+      } : {}),
+      ...request.headers
+    },
+    method: request.method
+  });
+};
+
+const asIs = response => response;
+
+/**
+ * Builds a resource fetcher.
+ *
+ * @param settings - The {@link Settings} object
+ * @param httpClient - The HTTP client that should be used to call the API
+ * @returns The fetcher
+ *
+ * @internal
+ */
+const buildFetcher = (settings, httpClient) => {
+  let requestNumber = 0;
+
+  const prepareRequest = requestId => composeInterceptors([...settings.requestInterceptors, logRequest(requestId, obfuscateInterceptor(obfuscateAuthHeadersEntry))]);
+
+  const prepareResponse = requestId => composeInterceptors([...settings.responseInterceptors, logResponse(requestId)]);
+
+  return async function (request, unwrapper) {
+    if (unwrapper === void 0) {
+      unwrapper = asIs;
+    }
+
+    const requestId = `${requestNumber += 1}`;
+    return Promise.resolve(buildRequest(request, settings)).then(prepareRequest(requestId)).then(httpClient).then(prepareResponse(requestId)).then(responseParser(unwrapper));
+  };
+};
+
+export { buildFetcher, buildRequest };

package/dist/scw/fetch/http-dumper.js

@@ -0,0 +1,57 @@
+/**
+ * Converts a string to PascalCase.
+ *
+ * @param str - The input string
+ * @returns The string in PascalCase
+ *
+ * @internal
+ */
+const toPascalCase = str => str.replace(/\w+/g, word => `${word[0].toUpperCase()}${word.slice(1).toLowerCase()}`);
+/**
+ * Converts a Headers entry to string.
+ *
+ * @param entry - The header entry as a string tuple
+ * @returns A serialized string
+ *
+ * @internal
+ */
+
+
+const serializeHeadersEntry = _ref => {
+  let [name, value] = _ref;
+  return `${toPascalCase(name)}: ${value}`;
+};
+/**
+ * Converts Headers to safe to log strings (with obfuscated auth secrets).
+ *
+ * @param headers - The Headers
+ * @returns Serialized headers strings
+ *
+ * @internal
+ */
+
+
+const serializeHeaders = headers => Array.from(headers.entries(), serializeHeadersEntry);
+/**
+ * Dumps a Request into a readable string.
+ *
+ * @param request - The request
+ * @returns The readable string
+ *
+ * @internal
+ */
+
+
+const dumpRequest = async request => [`${request.method.toUpperCase()}: ${request.url}`, ...serializeHeaders(request.headers), await request.clone().text()].join('\r\n');
+/**
+ * Dumps a Response into a readable string.
+ *
+ * @param response - The response
+ * @returns The readable string
+ *
+ * @internal
+ */
+
+const dumpResponse = async response => [`HTTP ${response.status} ${response.ok ? 'OK' : 'NOK'}`, ...serializeHeaders(response.headers), await response.clone().text()].join('\r\n');
+
+export { dumpRequest, dumpResponse };

package/dist/scw/fetch/http-interceptors.js

@@ -0,0 +1,80 @@
+import { getLogger } from '../../internal/logger/index.js';
+import { shouldLog, LevelResolver } from '../../internal/logger/level-resolver.js';
+import { dumpRequest, dumpResponse } from './http-dumper.js';
+
+/**
+ * Mapper of an header entry.
+ *
+ * @internal
+ */
+
+/**
+ * HTTP Request with obfuscated secrets.
+ *
+ * @internal
+ */
+class ObfuscatedRequest extends Request {
+  constructor(request, obfuscate) {
+    super(request);
+    this.request = request;
+    this.obfuscate = obfuscate;
+  }
+
+  get headers() {
+    return new Headers(Array.from(this.request.headers, this.obfuscate));
+  }
+
+}
+/**
+ * Creates an interceptor to obfuscate the requests.
+ *
+ * @param obfuscate - The Header entries obfuscator mapper
+ * @returns The obfuscated Request
+ *
+ * @internal
+ */
+
+
+const obfuscateInterceptor = obfuscate => request => new ObfuscatedRequest(request, obfuscate);
+
+const identity = instance => instance;
+/**
+ * Creates an interceptor to log the requests.
+ *
+ * @param identifier - The request identifier
+ * @param obfuscate - The obfuscation interceptor
+ * @returns The interceptor
+ *
+ * @internal
+ */
+
+
+const logRequest = function (identifier, obfuscate) {
+  if (obfuscate === void 0) {
+    obfuscate = identity;
+  }
+
+  return async request => {
+    if (shouldLog(LevelResolver[getLogger().logLevel], 'debug')) getLogger().debug(`--------------- Scaleway SDK REQUEST ${identifier} ---------------
+${await dumpRequest(await obfuscate(request))}
+---------------------------------------------------------`);
+    return request;
+  };
+};
+/**
+ * Creates an interceptor to log the responses.
+ *
+ * @param identifier - The request identifier
+ * @returns The interceptor
+ *
+ * @internal
+ */
+
+const logResponse = identifier => async response => {
+  if (shouldLog(LevelResolver[getLogger().logLevel], 'debug')) getLogger().debug(`--------------- Scaleway SDK RESPONSE ${identifier} ---------------
+${await dumpResponse(response)}
+---------------------------------------------------------`);
+  return response;
+};
+
+export { logRequest, logResponse, obfuscateInterceptor };

package/dist/scw/fetch/resource-paginator.js

@@ -0,0 +1,41 @@
+const extract = key => result => result[key];
+
+function* pages(key, fetcher, request, firstPage) {
+  if (!Array.isArray(firstPage[key])) throw new Error(`Property ${key} is not a list in paginated result`);
+  const getList = extract(key);
+  yield Promise.resolve(getList(firstPage));
+  const {
+    totalCount,
+    [key]: {
+      length
+    }
+  } = firstPage;
+  let page = (request.page || 1) + 1;
+
+  while (length && page <= Math.floor((totalCount + length - 1) / length)) page = (yield fetcher({ ...request,
+    page
+  }).then(getList)) || page + 1;
+}
+/**
+ * Fetches a paginated resource.
+ * @param key - The resource key of values list
+ * @param fetcher - The method to retrieve paginated resources
+ * @param request - A request with pagination options
+ * @returns An async generator of resources arrays
+ */
+
+
+async function* fetchPaginated(key, fetcher, request) {
+  yield* pages(key, fetcher, request, await fetcher(request));
+}
+/**
+ * Fetches all paginated resource.
+ * @param key - The resource key of values list
+ * @param fetcher - The method to retrieve paginated resources
+ * @param request - A request with pagination options
+ * @returns A resources array Promise
+ */
+
+const fetchAll = async (key, fetcher, request) => (await Promise.all(Array.from(pages(key, fetcher, request, await fetcher(request))))).flat();
+
+export { extract, fetchAll, fetchPaginated };

package/dist/scw/fetch/response-parser.js

@@ -0,0 +1,46 @@
+import { isJSONObject } from '../../helpers/json.js';
+import { parseScalewayError } from '../errors/error-parser.js';
+import { ScalewayError } from '../errors/scw-error.js';
+
+/**
+ * Makes response parser.
+ *
+ * @param unmarshaller - The response payload unmarshaller
+ * @returns An async converter of HTTP Response to desired result
+ *
+ * @throws {@link ScalewayError}
+ * Thrown by the API if the request couldn't be completed.
+ *
+ * @throws TypeError
+ * Thrown if the response parameter isn't of the expected type.
+ *
+ * @throws Error
+ * JSON parsing could trigger an error.
+ *
+ * @internal
+ */
+const responseParser = unmarshaller => async response => {
+  if (!(response instanceof Response)) throw new TypeError('Invalid response object');
+
+  if (response.ok) {
+    const contentType = response.headers.get('Content-Type');
+
+    switch (contentType) {
+      case 'application/json':
+        try {
+          return unmarshaller(await response.json());
+        } catch (err) {
+          throw new ScalewayError(response.status, `could not parse ${contentType} response`);
+        }
+
+      default:
+        throw new ScalewayError(response.status, `invalid content type ${contentType ?? ''}`.trim());
+    }
+  }
+
+  const error = await response.clone().json().catch(() => response.text());
+  if (isJSONObject(error)) throw parseScalewayError(response.status, error);
+  throw new ScalewayError(response.status, typeof error === 'string' ? error : 'cannot read error response body');
+};
+
+export { responseParser };

package/dist/scw/marshalling.js

@@ -0,0 +1,103 @@
+import { camelizeKeys } from '../helpers/camelize.js';
+import { isJSONObject } from '../helpers/json.js';
+
+/**
+ * Unmarshals record to convert iso dates from string to Dates.
+ *
+ * @param obj - The input
+ * @param keys - The keys requiring a conversion
+ * @returns The updated input
+ *
+ * @internal
+ */
+
+const unmarshalDates = (obj, keys) => {
+  if (Array.isArray(obj)) return obj.map(v => unmarshalDates(v, keys));
+  if (obj && typeof obj === 'object') return Object.entries(obj).reduce((acc, _ref) => {
+    let [key, value] = _ref;
+    return { ...acc,
+      [key]: typeof value === 'string' && keys.includes(key) ? new Date(value) : unmarshalDates(value, keys)
+    };
+  }, {});
+  return obj;
+};
+/**
+ * Unmarshals input to a record with camilized keys and instanciated Date.
+ *
+ * @param obj - The input
+ * @param ignoreKeys - The keys which should be not be transformed
+ * @param dateKeys - The keys which should be transformed to Date
+ * @returns The record
+ *
+ * @throws TypeError
+ * Thrown if the input isn't {@link JSONObject}.
+ *
+ * @internal
+ */
+
+const unmarshalAnyRes = function (obj, ignoreKeys, dateKeys) {
+  if (ignoreKeys === void 0) {
+    ignoreKeys = [];
+  }
+
+  if (!isJSONObject(obj)) throw new TypeError(`Data isn't a dictionary.`);
+  return camelizeKeys(dateKeys && dateKeys.length > 0 ? unmarshalDates(obj, dateKeys) : obj, ignoreKeys);
+};
+/**
+ * Throws an exception if the parameter is neither a string or defined.
+ *
+ * @param name - The parameter name
+ * @param param - The parameter value
+ *
+ * @throws ReferenceError
+ * Thrown if the parameter is invalid.
+ *
+ * @internal
+ */
+
+function assertNotEmptyParam(name, param) {
+  if (typeof param !== 'string' || param.length === 0) throw new ReferenceError(`param ${name} cannot be empty in request`);
+}
+/**
+ * Resolves the ideal parameter and value amongst an optional list.
+ *
+ * @param list - The list to be looking into
+ * @returns The parameter and value
+ *
+ * @throws ReferenceError
+ * Thrown if no value or default value is specified.
+ *
+ * @internal
+ */
+
+const resolveOneOf = list => {
+  const elt = list.find(obj => obj.value) || list.find(obj => obj.default);
+  const value = (elt == null ? void 0 : elt.value) || (elt == null ? void 0 : elt.default);
+  if (value) return {
+    param: elt.param,
+    value
+  };
+  const keyList = list.map(obj => obj.param).join(' or ');
+  throw new ReferenceError(`one of ${keyList} must be indicated in the request`);
+};
+/**
+ * Filters defined parameters tuples and converts them to URLSearchParams.
+ *
+ * @param paramTuples - The key/value pairs
+ * @returns URLSearchParams
+ *
+ * @internal
+ */
+
+const urlParams = function () {
+  for (var _len = arguments.length, paramTuples = new Array(_len), _key = 0; _key < _len; _key++) {
+    paramTuples[_key] = arguments[_key];
+  }
+
+  return new URLSearchParams(paramTuples.reduce((params, _ref2) => {
+    let [key, value] = _ref2;
+    return typeof key === 'string' && value != null ? [...params, [key, value.toString()]] : params;
+  }, []));
+};
+
+export { assertNotEmptyParam, resolveOneOf, unmarshalAnyRes, unmarshalDates, urlParams };

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@scaleway/sdk",
+  "version": "0.0.2-alpha.0",
+  "license": "Apache-2.0",
+  "description": "Scaleway SDK.",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "directory": "packages/clients"
+  },
+  "engines": {
+    "node": ">=14.x"
+  },
+  "type": "module",
+  "dependencies": {
+    "@scaleway/random-name": "^3.0.0"
+  },
+  "gitHead": "348ef780f8af12baa19e8c5b3c02f3087bcf0964"
+}