@scaleway/sdk 0.0.2-alpha.0

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

@@ -0,0 +1,121 @@
+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 { 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;
+
+    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,34 @@
+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,26 @@
+import { isUUID } from '../../../internal/tools/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,64 @@
+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) => {
+  let output = `scaleway-sdk-js: http error ${status}`;
+
+  if (isJSONObject(body)) {
+    if (typeof body.resource === 'string') {
+      output += `: resource ${body.resource}`;
+    }
+
+    if (typeof body.message === 'string') {
+      output += `: ${body.message}`;
+    }
+
+    if (body.fields && isRecordOfStringArray(body.fields)) {
+      const reasonList = Object.entries(body.fields).reduce((acc, _ref) => {
+        let [name, list] = _ref;
+        return acc.concat(`${name} (${list.join(', ')})`);
+      }, []);
+      output += `: ${reasonList.join(', ')}`;
+    }
+  } else if (typeof body === 'string') {
+    output += `: ${body}`;
+  }
+
+  return output;
+};
+/**
+ * Scaleway error.
+ *
+ * @public
+ */
+
+
+class ScalewayError extends Error {
+  constructor(status, body, message = buildDefaultMessage(status, body)) {
+    super(message); // 'Error' breaks prototype chain here
+
+    this.status = status;
+    this.body = body;
+    this.message = message;
+    this.name = new.target.name; // set name as 'CustomError' (or the class name that extends this class)
+
+    Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain
+  }
+
+  static fromJSON(status, obj) {
+    return new ScalewayError(status, obj);
+  }
+
+}
+
+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, `scaleway-sdk-js: resource ${resource} with ID ${resourceId} already exists: ${helpMessage}`);
+    this.status = status;
+    this.body = body;
+    this.resource = resource;
+    this.resourceId = resourceId;
+    this.helpMessage = helpMessage;
+  }
+
+  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,58 @@
+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 `scaleway-sdk-js: 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;
+  }
+
+  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 };

package/dist/scw/errors/standard/index.js

@@ -0,0 +1,12 @@
+export { ScalewayError } from '../scw-error.js';
+export { AlreadyExistsError } from './already-exists-error.js';
+export { DeniedAuthenticationError } from './denied-authentication-error.js';
+export { InvalidArgumentsError } from './invalid-arguments-error.js';
+export { OutOfStockError } from './out-of-stock-error.js';
+export { PermissionsDeniedError } from './permissions-denied-error.js';
+export { PreconditionFailedError } from './precondition-failed-error.js';
+export { QuotasExceededError } from './quotas-exceeded-error.js';
+export { ResourceExpiredError } from './resource-expired-error.js';
+export { ResourceLockedError } from './resource-locked-error.js';
+export { ResourceNotFoundError } from './resource-not-found-error.js';
+export { TransientStateError } from './transient-state-error.js';

package/dist/scw/errors/standard/invalid-arguments-error.js

@@ -0,0 +1,75 @@
+import { isJSONObject } from '../../../helpers/json.js';
+import { ScalewayError } from '../scw-error.js';
+
+/**
+ * Details of an {@link InvalidArgumentsError} error.
+ *
+ * @internal
+ */
+
+/**
+ * Build the default message for {@link InvalidArgumentsError}.
+ *
+ * @param list - The list of {@link InvalidArgumentsErrorDetails}
+ * @returns The error message
+ *
+ * @internal
+ */
+const buildMessage = list => {
+  const invalidArgs = list.reduce((acc, details) => {
+    let readableReason = '';
+
+    switch (details.reason) {
+      case 'required':
+        readableReason = `is required`;
+        break;
+
+      case 'format':
+        readableReason = `is wrongly formatted`;
+        break;
+
+      case 'constraint':
+        readableReason = `does not respect constraint`;
+        break;
+
+      default:
+        readableReason = `is invalid for unexpected reason`;
+        break;
+    }
+
+    if (details.helpMessage && details.helpMessage.length > 0) {
+      readableReason = readableReason.concat(`, `, details.helpMessage);
+    }
+
+    acc.push(`${details.argumentName} ${readableReason}`);
+    return acc;
+  }, []);
+  return `scaleway-sdk-js: invalid argument(s): ${invalidArgs.join('; ')}`;
+};
+/**
+ * InvalidArguments error happens when one or many fields are invalid in the request message.
+ *
+ * @public
+ */
+
+
+class InvalidArgumentsError extends ScalewayError {
+  constructor(status, body, details) {
+    super(status, body, buildMessage(details));
+    this.status = status;
+    this.body = body;
+    this.details = details;
+  }
+
+  static fromJSON(status, obj) {
+    if (!Array.isArray(obj.details)) return null;
+    return new InvalidArgumentsError(status, obj, obj.details.reduce((list, detail) => isJSONObject(detail) && typeof detail.argument_name === 'string' && typeof detail.reason === 'string' ? list.concat({
+      argumentName: detail.argument_name,
+      helpMessage: typeof detail.help_message === 'string' ? detail.help_message : undefined,
+      reason: detail.reason
+    }) : list, []));
+  }
+
+}
+
+export { InvalidArgumentsError };

package/dist/scw/errors/standard/out-of-stock-error.js

@@ -0,0 +1,24 @@
+import { ScalewayError } from '../scw-error.js';
+
+/**
+ * OutOfStock error happens when stocks are empty for the resource.
+ *
+ * @public
+ */
+
+class OutOfStockError extends ScalewayError {
+  constructor(status, body, resource) {
+    super(status, body, `scaleway-sdk-js: resource ${resource} is out of stock`);
+    this.status = status;
+    this.body = body;
+    this.resource = resource;
+  }
+
+  static fromJSON(status, obj) {
+    if (typeof obj.resource !== 'string') return null;
+    return new OutOfStockError(status, obj, obj.resource);
+  }
+
+}
+
+export { OutOfStockError };

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

@@ -0,0 +1,50 @@
+import { isJSONObject } from '../../../helpers/json.js';
+import { ScalewayError } from '../scw-error.js';
+
+/**
+ * Details of an {@link PermissionsDeniedError} error.
+ *
+ * @public
+ */
+
+/**
+ * Build the default message for {@link PermissionsDeniedError}.
+ *
+ * @param list - The list of {@link PermissionsDeniedErrorDetails}
+ * @returns The error message
+ *
+ * @internal
+ */
+const buildMessage = list => `scaleway-sdk-js: insufficient permissions: ${list.map(_ref => {
+  let {
+    action,
+    resource
+  } = _ref;
+  return `${action} ${resource}`;
+}).join('; ')}`;
+/**
+ * PermissionsDenied error happens when one or many permissions are not accorded to the user making the request.
+ *
+ * @public
+ */
+
+
+class PermissionsDeniedError extends ScalewayError {
+  constructor(status, body, list) {
+    super(status, body, buildMessage(list));
+    this.status = status;
+    this.body = body;
+    this.list = list;
+  }
+
+  static fromJSON(status, obj) {
+    if (!Array.isArray(obj.details)) return null;
+    return new PermissionsDeniedError(status, obj, obj.details.reduce((list, detail) => isJSONObject(detail) && typeof detail.resource === 'string' && typeof detail.action === 'string' ? list.concat({
+      action: detail.action,
+      resource: detail.resource
+    }) : list, []));
+  }
+
+}
+
+export { PermissionsDeniedError };

package/dist/scw/errors/standard/precondition-failed-error.js

@@ -0,0 +1,62 @@
+import { ScalewayError } from '../scw-error.js';
+
+/**
+ * Build the default message for {@link PreconditionFailedError}.
+ *
+ * @param precondition - The precondition
+ * @param helpMessage - The message which should help the user to fix the root cause
+ * @returns The error message
+ *
+ * @internal
+ */
+
+const buildMessage = (precondition, helpMessage) => {
+  let message;
+
+  switch (precondition) {
+    case 'unknown_precondition':
+      message = 'unknown precondition';
+      break;
+
+    case 'resource_still_in_use':
+      message = 'resource is still in use';
+      break;
+
+    case 'attribute_must_be_set':
+      message = 'attribute must be set';
+      break;
+
+    default:
+      message = '';
+  }
+
+  if (typeof helpMessage === 'string' && helpMessage.length > 0) {
+    message = message.concat(', ', helpMessage);
+  }
+
+  return `scaleway-sdk-js: precondition failed: ${message}`;
+};
+/**
+ * PreconditionFailed error is used when a precondition is not respected.
+ *
+ * @public
+ */
+
+
+class PreconditionFailedError extends ScalewayError {
+  constructor(status, body, precondition, helpMessage) {
+    super(status, body, buildMessage(precondition, helpMessage));
+    this.status = status;
+    this.body = body;
+    this.precondition = precondition;
+    this.helpMessage = helpMessage;
+  }
+
+  static fromJSON(status, obj) {
+    if (typeof obj.precondition !== 'string' || typeof obj.help_message !== 'string') return null;
+    return new PreconditionFailedError(status, obj, obj.precondition, obj.help_message);
+  }
+
+}
+
+export { PreconditionFailedError };

package/dist/scw/errors/standard/quotas-exceeded-error.js

@@ -0,0 +1,61 @@
+import { isJSONObject } from '../../../helpers/json.js';
+import { ScalewayError } from '../scw-error.js';
+
+/**
+ * Scope of an {@link QuotasExceededErrorDetails} error.
+ *
+ * @public
+ */
+
+/**
+ * Build the default message for {@link QuotasExceededError}.
+ *
+ * @param list - The list of {@link QuotasExceededErrorDetails}
+ * @returns The error message
+ *
+ * @internal
+ */
+const buildMessage = list => `scaleway-sdk-js: quota exceeded(s): ${list.map(details => {
+  const message = `${details.resource} has reached its quota (${details.current}/${details.quota})`;
+  return details.scope ? `${message} for ${details.scope.kind} '${details.scope.id}'` : message;
+}).join('; ')}`;
+
+const buildScope = detail => {
+  if (typeof detail.organization_id === 'string' && detail.organization_id.length) return {
+    id: detail.organization_id,
+    kind: 'organization'
+  };
+  if (typeof detail.project_id === 'string' && detail.project_id.length) return {
+    id: detail.project_id,
+    kind: 'project'
+  };
+  return undefined;
+};
+/**
+ * QuotasExceeded error happens when one or many resource exceed quotas during the creation of a resource.
+ *
+ * @public
+ */
+
+
+class QuotasExceededError extends ScalewayError {
+  constructor(status, body, list) {
+    super(status, body, buildMessage(list));
+    this.status = status;
+    this.body = body;
+    this.list = list;
+  }
+
+  static fromJSON(status, obj) {
+    if (!Array.isArray(obj.details)) return null;
+    return new QuotasExceededError(status, obj, obj.details.reduce((list, detail) => isJSONObject(detail) && typeof detail.resource === 'string' && typeof detail.quota === 'number' && typeof detail.current === 'number' ? list.concat({
+      current: detail.current,
+      quota: detail.quota,
+      resource: detail.resource,
+      scope: buildScope(detail)
+    }) : list, []));
+  }
+
+}
+
+export { QuotasExceededError };

package/dist/scw/errors/standard/resource-expired-error.js

@@ -0,0 +1,26 @@
+import { ScalewayError } from '../scw-error.js';
+
+/**
+ * ResourceExpired error happens when trying to access a resource that has expired.
+ *
+ * @public
+ */
+
+class ResourceExpiredError extends ScalewayError {
+  constructor(status, body, resource, resourceId, expiredSince) {
+    super(status, body, `scaleway-sdk-js: resource ${resource} with ID ${resourceId} expired since ${expiredSince.toISOString()}`);
+    this.status = status;
+    this.body = body;
+    this.resource = resource;
+    this.resourceId = resourceId;
+    this.expiredSince = expiredSince;
+  }
+
+  static fromJSON(status, obj) {
+    if (typeof obj.resource !== 'string' || typeof obj.resource_id !== 'string' || typeof obj.expired_since !== 'string') return null;
+    return new ResourceExpiredError(status, obj, obj.resource, obj.resource_id, new Date(obj.expired_since));
+  }
+
+}
+
+export { ResourceExpiredError };

package/dist/scw/errors/standard/resource-locked-error.js

@@ -0,0 +1,25 @@
+import { ScalewayError } from '../scw-error.js';
+
+/**
+ * ResourceLocked error happens when a resource is locked by trust and safety.
+ *
+ * @public
+ */
+
+class ResourceLockedError extends ScalewayError {
+  constructor(status, body, resource, resourceId) {
+    super(status, body, `scaleway-sdk-js: resource ${resource} with ID ${resourceId} is locked`);
+    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 ResourceLockedError(status, obj, obj.resource, obj.resource_id);
+  }
+
+}
+
+export { ResourceLockedError };