@scaleway/sdk 2.0.0-alpha.13 → 2.0.0-alpha.15

package/dist/scw/client-ini-profile.js

@@ -0,0 +1,54 @@
+import { isAccessKey, isSecretKey } from '../internal/validations/string-validation.js';
+
+/**
+ * Holds access key and secret key.
+ *
+ * @public
+ */
+
+/**
+ * Holds default values of a Scaleway profile.
+ *
+ * @public
+ */
+
+/**
+ * Holds values of a Scaleway profile.
+ *
+ * @public
+ */
+
+/**
+ * Verifies that the payload contains both the accessKey and the secretKey.
+ *
+ * @param obj - The secrets
+ * @returns Whether the secrets are not empty.
+ *
+ * @internal
+ */
+const hasAuthenticationSecrets = obj => typeof obj.accessKey === 'string' && obj.accessKey !== '' && typeof obj.secretKey === 'string' && obj.secretKey !== '';
+
+/**
+ * Asserts the format of secrets.
+ *
+ * @param obj - The secrets
+ * @returns Whether the secrets use a valid format
+ *
+ * @throws Error
+ * Thrown if either the accessKey or the secretKey has en invalid format.
+ *
+ * @internal
+ */
+function assertValidAuthenticationSecrets(obj) {
+  if (!(obj.accessKey && obj.secretKey)) {
+    throw new Error(`Invalid secrets, accessKey & secretKey must be defined. See https://www.scaleway.com/en/docs/identity-and-access-management/iam/how-to/create-api-keys/`);
+  }
+  if (!isAccessKey(obj.accessKey)) {
+    throw new Error(`Invalid access key format '${obj.accessKey}', expected SCWXXXXXXXXXXXXXXXXX format. See https://www.scaleway.com/en/docs/identity-and-access-management/iam/how-to/create-api-keys/`);
+  }
+  if (!isSecretKey(obj.secretKey)) {
+    throw new Error(`Invalid secret key format '${obj.secretKey}', expected a UUID: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx. See https://www.scaleway.com/en/docs/identity-and-access-management/iam/how-to/create-api-keys/`);
+  }
+}
+
+export { assertValidAuthenticationSecrets, hasAuthenticationSecrets };

package/dist/scw/client-settings.js

@@ -0,0 +1,78 @@
+import { isOrganizationId, isProjectId, isRegion, isZone, isURL } from '../internal/validations/string-validation.js';
+
+/**
+ * Holds default values of settings.
+ *
+ * @public
+ */
+
+/**
+ * Settings hold the values of all client options.
+ *
+ * @public
+ */
+
+/**
+ * Validates the content of a {@link Settings} object.
+ *
+ * @throws Error
+ * Thrown if {@link Settings} aren't valid.
+ *
+ * @internal
+ */
+const assertValidSettings = obj => {
+  // Default Organization ID.
+  if (obj.defaultOrganizationId !== undefined) {
+    if (typeof obj.defaultOrganizationId !== 'string' || obj.defaultOrganizationId.length === 0) {
+      throw new Error('Default organization ID cannot be empty');
+    }
+    if (!isOrganizationId(obj.defaultOrganizationId)) {
+      throw new Error(`Invalid organization ID format '${obj.defaultOrganizationId}', expected a UUID: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`);
+    }
+  }
+
+  // Default Project ID.
+  if (obj.defaultProjectId !== undefined) {
+    if (typeof obj.defaultProjectId !== 'string' || obj.defaultProjectId.length === 0) {
+      throw new Error('Default project ID cannot be empty');
+    }
+    if (!isProjectId(obj.defaultProjectId)) {
+      throw new Error(`Invalid project ID format '${obj.defaultProjectId}', expected a UUID: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`);
+    }
+  }
+
+  // Default Region.
+  if (obj.defaultRegion && !isRegion(obj.defaultRegion)) {
+    throw new Error(`Invalid default region format '${obj.defaultRegion}'`);
+  }
+
+  // Default Zone.
+  if (obj.defaultZone && !isZone(obj.defaultZone)) {
+    throw new Error(`Invalid default zone format '${obj.defaultZone}'`);
+  }
+
+  // API URL.
+  if (!isURL(obj.apiURL)) {
+    throw new Error(`Invalid URL ${obj.apiURL}`);
+  }
+  if (obj.apiURL.endsWith('/')) {
+    throw new Error(`Invalid URL ${obj.apiURL}: it should not have a trailing slash`);
+  }
+
+  // HTTP Client.
+  if (typeof obj.httpClient !== typeof fetch) {
+    throw new Error(`Invalid HTTP Client`);
+  }
+
+  // Default Page Size.
+  if (obj.defaultPageSize !== undefined && (typeof obj.defaultPageSize !== 'number' || Number.isNaN(obj.defaultPageSize) || obj.defaultPageSize <= 0)) {
+    throw new Error(`Invalid defaultPageSize ${obj.defaultPageSize}: it should be a number above 0`);
+  }
+
+  // User Agent.
+  if (typeof obj.userAgent !== 'string') {
+    throw new Error(`Invalid User-Agent`);
+  }
+};
+
+export { assertValidSettings };

package/dist/scw/client.js

@@ -0,0 +1,98 @@
+import { getLogger } from '../internal/logger/index.js';
+import { withLegacyInterceptors, withProfile } from './client-ini-factory.js';
+import { assertValidSettings } from './client-settings.js';
+import { version, userAgent } from './constants.js';
+import { buildFetcher } from './fetch/build-fetcher.js';
+
+/** Default {@link Settings} values. */
+const DEFAULT_SETTINGS = {
+  apiURL: 'https://api.scaleway.com',
+  httpClient: fetch,
+  interceptors: [],
+  userAgent
+};
+
+/**
+ * Scaleway client.
+ */
+
+/**
+ * Creates a Scaleway client with advanced options.
+ * You can either use existing factories
+ * (like `withProfile`, `withUserAgentSuffix`, etc)
+ * or write your own using the interface `ClientConfig`.
+ *
+ * @example
+ * Creates a client with factories:
+ * ```
+ * createAdvancedClient(
+ *   (obj: Settings) => ({
+ *     ...obj,
+ *     defaultPageSize: 100 ,
+ *     httpClient: myFetchWrapper,
+ *   }),
+ *   withUserAgentSuffix('bot-name/1.0'),
+ * )
+ * ```
+ *
+ * @throws Error
+ * Thrown if the setup fails.
+ *
+ * @public
+ */
+const createAdvancedClient = function () {
+  for (var _len = arguments.length, configs = new Array(_len), _key = 0; _key < _len; _key++) {
+    configs[_key] = arguments[_key];
+  }
+  const settings = configs.concat([withLegacyInterceptors()]).reduce((currentSettings, config) => config(currentSettings), DEFAULT_SETTINGS);
+  assertValidSettings(settings);
+  getLogger().info(`init Scaleway SDK version ${version}`);
+  return {
+    fetch: buildFetcher(settings, settings.httpClient),
+    settings
+  };
+};
+
+/**
+ * Creates a Scaleway client with a profile.
+ *
+ * @example
+ * Creates a client with credentials & default values (see https://www.scaleway.com/en/docs/identity-and-access-management/iam/how-to/create-api-keys/):
+ * ```
+ * import { createClient } from '@scaleway/sdk'
+ *
+ * createClient({
+ *   accessKey: 'SCWXXXXXXXXXXXXXXXXX',
+ *   secretKey: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx',
+ *   defaultProjectId: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx',
+ *   defaultRegion: 'fr-par',
+ *   defaultZone: 'fr-par-1',
+ * })
+ * ```
+ *
+ * @example
+ * Creates a client by loading values from the environment (see https://www.scaleway.com/en/docs/identity-and-access-management/iam/how-to/create-api-keys/)
+ * or the config file created by CLI `scw init` (see https://www.scaleway.com/en/cli/):
+ * ```
+ * import { loadProfileFromConfigurationFile } from '@scaleway/configuration-loader'
+ * import { createClient } from '@scaleway/sdk'
+ *
+ * createClient({
+ *   ...await loadProfileFromConfigurationFile(),
+ *   defaultZone: 'fr-par-3',
+ * })
+ * ```
+ *
+ * @throws Error
+ * Thrown if the setup fails.
+ *
+ * @public
+ */
+const createClient = function (profile) {
+  if (profile === void 0) {
+    profile = {};
+  }
+  return createAdvancedClient(withProfile(profile));
+};
+
+export { createAdvancedClient, createClient };

package/dist/scw/constants.js

@@ -0,0 +1,4 @@
+const version = 'v2.0.0-alpha.14';
+const userAgent = `scaleway-sdk-js/${version}`;
+
+export { userAgent, version };

package/dist/scw/custom-marshalling.js

@@ -0,0 +1,131 @@
+import { isJSONObject } from '../helpers/json.js';
+import { unmarshalDate, unmarshalArrayOfObject } from '../helpers/marshalling.js';
+
+/**
+ * Unmarshals {@link Money}
+ *
+ * @internal
+ */
+const unmarshalMoney = data => {
+  if (!isJSONObject(data)) {
+    throw new TypeError(`Unmarshalling the type 'Money' failed as data isn't a dictionary.`);
+  }
+  return {
+    currencyCode: data.currency_code,
+    nanos: data.nanos,
+    units: data.units
+  };
+};
+
+/**
+ * Unmarshals {@link ServiceInfo}.
+ *
+ * @internal
+ */
+const unmarshalServiceInfo = data => {
+  if (!isJSONObject(data)) {
+    throw new TypeError(`Unmarshalling the type 'ServiceInfo' failed as data isn't a dictionary.`);
+  }
+  return {
+    description: data.description,
+    documentationUrl: data.documentation_url,
+    name: data.name,
+    version: data.version
+  };
+};
+
+/**
+ * Unmarshals {@link ScwFile}.
+ *
+ * @internal
+ */
+const unmarshalScwFile = data => {
+  if (!isJSONObject(data)) {
+    throw new TypeError(`Unmarshalling the type 'ScwFile' failed as data isn't a dictionary.`);
+  }
+  return {
+    content: data.content,
+    contentType: data.content_type,
+    name: data.name
+  };
+};
+
+/**
+ * Unmarshals {@link TimeSeriesPoint}
+ *
+ * @remarks To optimize the size of this message,
+ * the JSON is compressed in an array instead of a dictionary.
+ * Example: `["2019-08-08T15:00:00Z", 0.2]`.
+ *
+ * @internal
+ */
+const unmarshalTimeSeriesPoint = data => {
+  if (!Array.isArray(data)) {
+    throw new TypeError(`Unmarshalling the type 'TimeSeriesPoint' failed as data isn't an array.`);
+  }
+  return {
+    timestamp: unmarshalDate(data[0]),
+    value: data[1]
+  };
+};
+
+/**
+ * Unmarshals {@link TimeSeries}
+ *
+ * @internal
+ */
+const unmarshalTimeSeries = data => {
+  if (!isJSONObject(data)) {
+    throw new TypeError(`Unmarshalling the type 'TimeSeries' failed as data isn't a dictionary.`);
+  }
+  return {
+    metadata: data.metadata,
+    name: data.name,
+    points: unmarshalArrayOfObject(data.points, unmarshalTimeSeriesPoint)
+  };
+};
+
+/**
+ * Marshals {@link ScwFile}.
+ *
+ * @internal
+ */
+const marshalScwFile = obj => ({
+  content: obj.content,
+  content_type: obj.contentType,
+  name: obj.name
+});
+
+/**
+ * Marshals {@link Money}
+ *
+ * @internal
+ */
+const marshalMoney = obj => ({
+  currency_code: obj.currencyCode,
+  nanos: obj.nanos,
+  units: obj.units
+});
+
+/**
+ * Marshals {@link TimeSeriesPoint}
+ *
+ * @internal
+ */
+const marshalTimeSeriesPoint = obj => ({
+  timestamp: obj.timestamp?.toISOString(),
+  value: obj.value
+});
+
+/**
+ * Marshals {@link TimeSeries}
+ *
+ * @internal
+ */
+const marshalTimeSeries = obj => ({
+  metadata: obj.metadata,
+  name: obj.name,
+  points: obj.points.map(elt => marshalTimeSeriesPoint(elt))
+});
+
+export { marshalMoney, marshalScwFile, marshalTimeSeries, marshalTimeSeriesPoint, unmarshalMoney, unmarshalScwFile, unmarshalServiceInfo, unmarshalTimeSeries, unmarshalTimeSeriesPoint };

package/dist/scw/errors/error-parser.js

@@ -0,0 +1,107 @@
+import { InvalidRequestMapper } from './non-standard/invalid-request-mapper.js';
+import { UnknownResourceMapper } from './non-standard/unknown-resource-mapper.js';
+import { ScalewayError } from './scw-error.js';
+import { AlreadyExistsError } from './standard/already-exists-error.js';
+import { DeniedAuthenticationError } from './standard/denied-authentication-error.js';
+import { InvalidArgumentsError } from './standard/invalid-arguments-error.js';
+import { OutOfStockError } from './standard/out-of-stock-error.js';
+import { PermissionsDeniedError } from './standard/permissions-denied-error.js';
+import { PreconditionFailedError } from './standard/precondition-failed-error.js';
+import { QuotasExceededError } from './standard/quotas-exceeded-error.js';
+import { ResourceExpiredError } from './standard/resource-expired-error.js';
+import { ResourceLockedError } from './standard/resource-locked-error.js';
+import { ResourceNotFoundError } from './standard/resource-not-found-error.js';
+import { TooManyRequestsError } from './standard/too-many-requests-error.js';
+import { TransientStateError } from './standard/transient-state-error.js';
+
+/**
+ * Unmarshals a standard error from raw body.
+ *
+ * @param type - The error type
+ * @param status - The status code
+ * @param body - The error response
+ * @returns The standard error if found
+ *
+ * @internal
+ */
+const unmarshalStandardError = (type, status, body) => {
+  let error;
+  switch (type) {
+    case 'denied_authentication':
+      error = DeniedAuthenticationError;
+      break;
+    case 'invalid_arguments':
+      error = InvalidArgumentsError;
+      break;
+    case 'out_of_stock':
+      error = OutOfStockError;
+      break;
+    case 'permissions_denied':
+      error = PermissionsDeniedError;
+      break;
+    case 'precondition_failed':
+      error = PreconditionFailedError;
+      break;
+    case 'quotas_exceeded':
+      error = QuotasExceededError;
+      break;
+    case 'expired':
+      error = ResourceExpiredError;
+      break;
+    case 'not_found':
+      error = ResourceNotFoundError;
+      break;
+    case 'locked':
+      error = ResourceLockedError;
+      break;
+    case 'transient_state':
+      error = TransientStateError;
+      break;
+    case 'already_exists':
+      error = AlreadyExistsError;
+      break;
+    case 'too_many_requests':
+      error = TooManyRequestsError;
+      break;
+    default:
+      return null;
+  }
+  return error.fromJSON(status, body);
+};
+
+/**
+ * Unmarshals a non-standard error from raw body.
+ *
+ * @param type - The error type
+ * @param status - The status code
+ * @param body - The error response
+ * @returns The non-standard error if found
+ *
+ * @internal
+ */
+const unmarshalNonStandardError = (type, status, body) => {
+  switch (type) {
+    case 'unknown_resource':
+      return UnknownResourceMapper.fromJSON(status, body);
+    case 'invalid_request_error':
+      return InvalidRequestMapper.fromJSON(status, body);
+    default:
+      return null;
+  }
+};
+
+/**
+ * Parses Scaleway error from raw body.
+ *
+ * @param status - The status code
+ * @param body - The error response
+ * @returns The resolved error
+ *
+ * @internal
+ */
+const parseScalewayError = (status, body) => {
+  const parsableError = typeof body.type === 'string' && (unmarshalStandardError(body.type, status, body) ?? unmarshalNonStandardError(body.type, status, body));
+  return parsableError || new ScalewayError(status, body);
+};
+
+export { parseScalewayError };

package/dist/scw/errors/non-standard/invalid-request-mapper.js

@@ -0,0 +1,36 @@
+import { ScalewayError } from '../scw-error.js';
+import { InvalidArgumentsError } from '../standard/invalid-arguments-error.js';
+import { QuotasExceededError } from '../standard/quotas-exceeded-error.js';
+import { isRecordOfStringArray } from '../types.js';
+
+/**
+ * InvalidRequest error is only returned by the instance API.
+ *
+ * @public
+ */
+class InvalidRequestMapper {
+  static fromJSON(status, obj) {
+    if (typeof obj.message === 'string' && obj.message.toLowerCase().includes('quota exceeded for this resource')) {
+      return new QuotasExceededError(status, obj, [{
+        current: 0,
+        quota: 0,
+        resource: typeof obj.resource === 'string' ? obj.resource : ''
+      }]);
+    }
+    const fields = obj.fields && isRecordOfStringArray(obj.fields) ? obj.fields : {};
+    const fieldsMessages = Object.entries(fields);
+    if (fieldsMessages.length) {
+      return new InvalidArgumentsError(status, obj, fieldsMessages.map(_ref => {
+        let [argumentName, messages] = _ref;
+        return messages.map(helpMessage => ({
+          argumentName,
+          helpMessage,
+          reason: 'constraint'
+        }));
+      }).flat());
+    }
+    return new ScalewayError(status, obj);
+  }
+}
+
+export { InvalidRequestMapper };

package/dist/scw/errors/non-standard/unknown-resource-mapper.js

@@ -0,0 +1,27 @@
+import { isUUID } from '../../../internal/validations/string-validation.js';
+import { ScalewayError } from '../scw-error.js';
+import { ResourceNotFoundError } from '../standard/resource-not-found-error.js';
+
+/**
+ * UnknownResource error is only returned by the instance API.
+ *
+ * @public
+ */
+class UnknownResourceMapper {
+  static fromJSON(status, obj) {
+    // Split the message
+    // Note: some errors uses ' and not "
+    // Examples: `"111..." not found` or `Security Group '111...' not found`
+    const messageParts = typeof obj.message === 'string' ? obj.message.split(/"|'/) : [];
+    if (messageParts.length === 3 && isUUID(messageParts[1])) {
+      return new ResourceNotFoundError(status, obj,
+      // transform `Security group ` to `security_group`
+      // `.replaceAll()` may be too recent to use yet.
+      // that's why we're using `.split(' ').join('_')` for now.
+      messageParts[0].trim().toLowerCase().split(' ').join('_'), messageParts[1]);
+    }
+    return new ScalewayError(status, obj);
+  }
+}
+
+export { UnknownResourceMapper };

package/dist/scw/errors/scw-error.js

@@ -0,0 +1,66 @@
+import { isJSONObject } from '../../helpers/json.js';
+import { isRecordOfStringArray } from './types.js';
+
+/**
+ * Builds the default message for {@link ScalewayError}.
+ *
+ * @param status - The response code
+ * @param body - The response body
+ * @returns The error message
+ *
+ * @internal
+ */
+const buildDefaultMessage = (status, body) => {
+  const message = [`http error ${status}`];
+  if (typeof body === 'string') {
+    message.push(body);
+  } else if (isJSONObject(body)) {
+    if (typeof body.resource === 'string') {
+      message.push(`resource ${body.resource}`);
+    }
+    if (typeof body.message === 'string') {
+      message.push(body.message);
+    }
+    if (body.fields && isRecordOfStringArray(body.fields)) {
+      message.push(Object.entries(body.fields).map(_ref => {
+        let [name, list] = _ref;
+        return `${name} (${list.join(', ')})`;
+      }).join(', '));
+    }
+  }
+  return message.join(': ');
+};
+
+/**
+ * Scaleway error.
+ *
+ * @public
+ */
+class ScalewayError extends Error {
+  /** The message originating from the payload. */
+
+  constructor( /** The response status. */
+  status, /** The response payload. */
+  body, /** The augmented message. */
+  message) {
+    if (message === void 0) {
+      message = buildDefaultMessage(status, body);
+    }
+    super(message); // 'Error' breaks prototype chain here
+    this.status = status;
+    this.body = body;
+    this.message = message;
+    this.name = 'ScalewayError';
+    this.rawMessage = typeof body === 'object' && typeof body.message === 'string' ? body.message : undefined;
+    Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain
+  }
+
+  static fromJSON(status, obj) {
+    return new ScalewayError(status, obj);
+  }
+  toString() {
+    return `${this.name}: ${this.message}`;
+  }
+}
+
+export { ScalewayError };

package/dist/scw/errors/standard/already-exists-error.js

@@ -0,0 +1,26 @@
+import { ScalewayError } from '../scw-error.js';
+
+/**
+ * AlreadyExists error is used when a resource already exists.
+ *
+ * @public
+ */
+class AlreadyExistsError extends ScalewayError {
+  constructor(status, body, resource, resourceId, helpMessage) {
+    super(status, body, `resource ${resource} with ID ${resourceId} already exists: ${helpMessage}`);
+    this.status = status;
+    this.body = body;
+    this.resource = resource;
+    this.resourceId = resourceId;
+    this.helpMessage = helpMessage;
+    this.name = 'AlreadyExistsError';
+  }
+  static fromJSON(status, obj) {
+    if (typeof obj.resource !== 'string' || typeof obj.resource_id !== 'string' || typeof obj.help_message !== 'string') {
+      return null;
+    }
+    return new AlreadyExistsError(status, obj, obj.resource, obj.resource_id, obj.help_message);
+  }
+}
+
+export { AlreadyExistsError };

package/dist/scw/errors/standard/denied-authentication-error.js

@@ -0,0 +1,52 @@
+import { ScalewayError } from '../scw-error.js';
+
+/**
+ * Build the default message for {@link DeniedAuthenticationError}.
+ *
+ * @param method - The authentication method
+ * @param reason - The deny reason
+ * @returns The error message
+ *
+ * @internal
+ */
+const buildMessage = (method, reason) => {
+  let reasonDesc;
+  switch (reason) {
+    case 'invalid_argument':
+      reasonDesc = `invalid ${method} format or empty value`;
+      break;
+    case 'not_found':
+      reasonDesc = `${method} does not exist`;
+      break;
+    case 'expired':
+      reasonDesc = `${method} is expired`;
+      break;
+    default:
+      reasonDesc = `unknown reason for ${method}`;
+  }
+  return `denied authentication: ${reasonDesc}`;
+};
+
+/**
+ * DeniedAuthentication error is used by the API Gateway auth service to deny a request.
+ *
+ * @public
+ */
+class DeniedAuthenticationError extends ScalewayError {
+  constructor(status, body, method, reason) {
+    super(status, body, buildMessage(method, reason));
+    this.status = status;
+    this.body = body;
+    this.method = method;
+    this.reason = reason;
+    this.name = 'DeniedAuthenticationError';
+  }
+  static fromJSON(status, obj) {
+    if (typeof obj.method !== 'string' || typeof obj.reason !== 'string') {
+      return null;
+    }
+    return new DeniedAuthenticationError(status, obj, obj.method, obj.reason);
+  }
+}
+
+export { DeniedAuthenticationError };