@scaleway/sdk 2.25.0 → 2.27.0

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

@@ -1,53 +1,36 @@
-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
- */
+import { isJSONObject } from "../../helpers/json.js";
+import { isRecordOfStringArray } from "./types.js";
 const buildDefaultMessage = (status, body) => {
   const message = [`http error ${status}`];
-  if (typeof body === 'string') {
+  if (typeof body === "string") {
     message.push(body);
   } else if (isJSONObject(body)) {
-    if (typeof body.resource === 'string') {
+    if (typeof body.resource === "string") {
       message.push(`resource ${body.resource}`);
     }
-    if (typeof body.message === 'string') {
+    if (typeof body.message === "string") {
       message.push(body.message);
     }
     if (body.fields && isRecordOfStringArray(body.fields)) {
-      message.push(Object.entries(body.fields).map(([name, list]) => `${name} (${list.join(', ')})`).join(', '));
+      message.push(
+        Object.entries(body.fields).map(([name, list]) => `${name} (${list.join(", ")})`).join(", ")
+      );
     }
   }
-  return message.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 = buildDefaultMessage(status, body)) {
-    super(message); // 'Error' breaks prototype chain here
+  constructor(status, body, message = buildDefaultMessage(status, body)) {
+    super(message);
     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
+    this.name = "ScalewayError";
+    this.rawMessage = typeof body === "object" && typeof body.message === "string" ? body.message : void 0;
+    Object.setPrototypeOf(this, new.target.prototype);
   }
+  /** The message originating from the payload. */
+  rawMessage;
   static fromJSON(status, obj) {
     return new ScalewayError(status, obj);
   }
@@ -55,5 +38,6 @@ class ScalewayError extends Error {
     return `${this.name}: ${this.message}`;
   }
 }
-
-export { ScalewayError };
+export {
+  ScalewayError
+};

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const scwError = require("../scw-error.cjs");
+class AlreadyExistsError extends scwError.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
+    );
+  }
+}
+exports.AlreadyExistsError = AlreadyExistsError;

package/dist/scw/errors/standard/already-exists-error.d.ts

@@ -0,0 +1,16 @@
+import type { JSONObject } from '../../../helpers/json';
+import { ScalewayError } from '../scw-error';
+/**
+ * AlreadyExists error is used when a resource already exists.
+ *
+ * @public
+ */
+export declare class AlreadyExistsError extends ScalewayError {
+    readonly status: number;
+    readonly body: JSONObject;
+    readonly resource: string;
+    readonly resourceId: string;
+    readonly helpMessage: string;
+    constructor(status: number, body: JSONObject, resource: string, resourceId: string, helpMessage: string);
+    static fromJSON(status: number, obj: Readonly<JSONObject>): AlreadyExistsError | null;
+}

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

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

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const scwError = require("../scw-error.cjs");
+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}`;
+};
+class DeniedAuthenticationError extends scwError.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);
+  }
+}
+exports.DeniedAuthenticationError = DeniedAuthenticationError;

package/dist/scw/errors/standard/denied-authentication-error.d.ts

@@ -0,0 +1,15 @@
+import type { JSONObject } from '../../../helpers/json';
+import { ScalewayError } from '../scw-error';
+/**
+ * DeniedAuthentication error is used by the API Gateway auth service to deny a request.
+ *
+ * @public
+ */
+export declare class DeniedAuthenticationError extends ScalewayError {
+    readonly status: number;
+    readonly body: JSONObject;
+    readonly method: string;
+    readonly reason: string;
+    constructor(status: number, body: JSONObject, method: string, reason: string);
+    static fromJSON(status: number, obj: Readonly<JSONObject>): DeniedAuthenticationError | null;
+}

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

@@ -1,24 +1,14 @@
-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
- */
+import { ScalewayError } from "../scw-error.js";
 const buildMessage = (method, reason) => {
   let reasonDesc;
   switch (reason) {
-    case 'invalid_argument':
+    case "invalid_argument":
       reasonDesc = `invalid ${method} format or empty value`;
       break;
-    case 'not_found':
+    case "not_found":
       reasonDesc = `${method} does not exist`;
       break;
-    case 'expired':
+    case "expired":
       reasonDesc = `${method} is expired`;
       break;
     default:
@@ -26,12 +16,6 @@ const buildMessage = (method, reason) => {
   }
   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));
@@ -39,14 +23,15 @@ class DeniedAuthenticationError extends ScalewayError {
     this.body = body;
     this.method = method;
     this.reason = reason;
-    this.name = 'DeniedAuthenticationError';
+    this.name = "DeniedAuthenticationError";
   }
   static fromJSON(status, obj) {
-    if (typeof obj.method !== 'string' || typeof obj.reason !== 'string') {
+    if (typeof obj.method !== "string" || typeof obj.reason !== "string") {
       return null;
     }
     return new DeniedAuthenticationError(status, obj, obj.method, obj.reason);
   }
 }
-
-export { DeniedAuthenticationError };
+export {
+  DeniedAuthenticationError
+};

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const scwError = require("../scw-error.cjs");
+const alreadyExistsError = require("./already-exists-error.cjs");
+const deniedAuthenticationError = require("./denied-authentication-error.cjs");
+const invalidArgumentsError = require("./invalid-arguments-error.cjs");
+const outOfStockError = require("./out-of-stock-error.cjs");
+const permissionsDeniedError = require("./permissions-denied-error.cjs");
+const preconditionFailedError = require("./precondition-failed-error.cjs");
+const quotasExceededError = require("./quotas-exceeded-error.cjs");
+const resourceExpiredError = require("./resource-expired-error.cjs");
+const resourceLockedError = require("./resource-locked-error.cjs");
+const resourceNotFoundError = require("./resource-not-found-error.cjs");
+const tooManyRequestsError = require("./too-many-requests-error.cjs");
+const transientStateError = require("./transient-state-error.cjs");
+exports.ScalewayError = scwError.ScalewayError;
+exports.AlreadyExistsError = alreadyExistsError.AlreadyExistsError;
+exports.DeniedAuthenticationError = deniedAuthenticationError.DeniedAuthenticationError;
+exports.InvalidArgumentsError = invalidArgumentsError.InvalidArgumentsError;
+exports.OutOfStockError = outOfStockError.OutOfStockError;
+exports.PermissionsDeniedError = permissionsDeniedError.PermissionsDeniedError;
+exports.PreconditionFailedError = preconditionFailedError.PreconditionFailedError;
+exports.QuotasExceededError = quotasExceededError.QuotasExceededError;
+exports.ResourceExpiredError = resourceExpiredError.ResourceExpiredError;
+exports.ResourceLockedError = resourceLockedError.ResourceLockedError;
+exports.ResourceNotFoundError = resourceNotFoundError.ResourceNotFoundError;
+exports.TooManyRequestsError = tooManyRequestsError.TooManyRequestsError;
+exports.TransientStateError = transientStateError.TransientStateError;

package/dist/scw/errors/standard/index.d.ts

@@ -0,0 +1,17 @@
+export { ScalewayError } from '../scw-error';
+export { AlreadyExistsError } from './already-exists-error';
+export { DeniedAuthenticationError } from './denied-authentication-error';
+export { InvalidArgumentsError } from './invalid-arguments-error';
+export type { InvalidArgumentsErrorDetails } from './invalid-arguments-error';
+export { OutOfStockError } from './out-of-stock-error';
+export { PermissionsDeniedError } from './permissions-denied-error';
+export type { PermissionsDeniedErrorDetails } from './permissions-denied-error';
+export { PreconditionFailedError } from './precondition-failed-error';
+export { QuotasExceededError } from './quotas-exceeded-error';
+export type { QuotasExceededErrorDetails, QuotasExceededErrorScope, } from './quotas-exceeded-error';
+export { ResourceExpiredError } from './resource-expired-error';
+export { ResourceLockedError } from './resource-locked-error';
+export { ResourceNotFoundError } from './resource-not-found-error';
+export { TooManyRequestsError } from './too-many-requests-error';
+export type { TooManyRequestsQuotaPolicy } from './too-many-requests-error';
+export { TransientStateError } from './transient-state-error';

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

@@ -1,13 +1,28 @@
-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 { TooManyRequestsError } from './too-many-requests-error.js';
-export { TransientStateError } from './transient-state-error.js';
+import { ScalewayError } from "../scw-error.js";
+import { AlreadyExistsError } from "./already-exists-error.js";
+import { DeniedAuthenticationError } from "./denied-authentication-error.js";
+import { InvalidArgumentsError } from "./invalid-arguments-error.js";
+import { OutOfStockError } from "./out-of-stock-error.js";
+import { PermissionsDeniedError } from "./permissions-denied-error.js";
+import { PreconditionFailedError } from "./precondition-failed-error.js";
+import { QuotasExceededError } from "./quotas-exceeded-error.js";
+import { ResourceExpiredError } from "./resource-expired-error.js";
+import { ResourceLockedError } from "./resource-locked-error.js";
+import { ResourceNotFoundError } from "./resource-not-found-error.js";
+import { TooManyRequestsError } from "./too-many-requests-error.js";
+import { TransientStateError } from "./transient-state-error.js";
+export {
+  AlreadyExistsError,
+  DeniedAuthenticationError,
+  InvalidArgumentsError,
+  OutOfStockError,
+  PermissionsDeniedError,
+  PreconditionFailedError,
+  QuotasExceededError,
+  ResourceExpiredError,
+  ResourceLockedError,
+  ResourceNotFoundError,
+  ScalewayError,
+  TooManyRequestsError,
+  TransientStateError
+};

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const json = require("../../../helpers/json.cjs");
+const scwError = require("../scw-error.cjs");
+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 `invalid argument(s): ${invalidArgs.join("; ")}`;
+};
+class InvalidArgumentsError extends scwError.ScalewayError {
+  constructor(status, body, details) {
+    super(status, body, buildMessage(details));
+    this.status = status;
+    this.body = body;
+    this.details = details;
+    this.name = "InvalidArgumentsError";
+  }
+  static fromJSON(status, obj) {
+    if (!Array.isArray(obj.details))
+      return null;
+    return new InvalidArgumentsError(
+      status,
+      obj,
+      obj.details.reduce(
+        (list, detail) => json.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 : void 0,
+          reason: detail.reason
+        }) : list,
+        []
+      )
+    );
+  }
+}
+exports.InvalidArgumentsError = InvalidArgumentsError;

package/dist/scw/errors/standard/invalid-arguments-error.d.ts

@@ -0,0 +1,24 @@
+import type { JSONObject } from '../../../helpers/json';
+import { ScalewayError } from '../scw-error';
+/**
+ * Details of an {@link InvalidArgumentsError} error.
+ *
+ * @public
+ */
+export type InvalidArgumentsErrorDetails = {
+    readonly argumentName: string;
+    readonly reason: string;
+    readonly helpMessage?: string;
+};
+/**
+ * InvalidArguments error happens when one or many fields are invalid in the request message.
+ *
+ * @public
+ */
+export declare class InvalidArgumentsError extends ScalewayError {
+    readonly status: number;
+    readonly body: JSONObject;
+    readonly details: InvalidArgumentsErrorDetails[];
+    constructor(status: number, body: JSONObject, details: InvalidArgumentsErrorDetails[]);
+    static fromJSON(status: number, obj: Readonly<JSONObject>): InvalidArgumentsError | null;
+}

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

@@ -1,31 +1,16 @@
-import { isJSONObject } from '../../../helpers/json.js';
-import { ScalewayError } from '../scw-error.js';
-
-/**
- * Details of an {@link InvalidArgumentsError} error.
- *
- * @public
- */
-
-/**
- * Build the default message for {@link InvalidArgumentsError}.
- *
- * @param list - The list of {@link InvalidArgumentsErrorDetails}
- * @returns The error message
- *
- * @internal
- */
-const buildMessage = list => {
+import { isJSONObject } from "../../../helpers/json.js";
+import { ScalewayError } from "../scw-error.js";
+const buildMessage = (list) => {
   const invalidArgs = list.reduce((acc, details) => {
-    let readableReason = '';
+    let readableReason = "";
     switch (details.reason) {
-      case 'required':
+      case "required":
         readableReason = `is required`;
         break;
-      case 'format':
+      case "format":
         readableReason = `is wrongly formatted`;
         break;
-      case 'constraint':
+      case "constraint":
         readableReason = `does not respect constraint`;
         break;
       default:
@@ -38,30 +23,33 @@ const buildMessage = list => {
     acc.push(`${details.argumentName} ${readableReason}`);
     return acc;
   }, []);
-  return `invalid argument(s): ${invalidArgs.join('; ')}`;
+  return `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;
-    this.name = 'InvalidArgumentsError';
+    this.name = "InvalidArgumentsError";
   }
   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, []));
+    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 : void 0,
+          reason: detail.reason
+        }) : list,
+        []
+      )
+    );
   }
 }
-
-export { InvalidArgumentsError };
+export {
+  InvalidArgumentsError
+};

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const scwError = require("../scw-error.cjs");
+class OutOfStockError extends scwError.ScalewayError {
+  constructor(status, body, resource) {
+    super(status, body, `resource ${resource} is out of stock`);
+    this.status = status;
+    this.body = body;
+    this.resource = resource;
+    this.name = "OutOfStockError";
+  }
+  static fromJSON(status, obj) {
+    if (typeof obj.resource !== "string")
+      return null;
+    return new OutOfStockError(status, obj, obj.resource);
+  }
+}
+exports.OutOfStockError = OutOfStockError;

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

@@ -0,0 +1,14 @@
+import type { JSONObject } from '../../../helpers/json';
+import { ScalewayError } from '../scw-error';
+/**
+ * OutOfStock error happens when stocks are empty for the resource.
+ *
+ * @public
+ */
+export declare class OutOfStockError extends ScalewayError {
+    readonly status: number;
+    readonly body: JSONObject;
+    readonly resource: string;
+    constructor(status: number, body: JSONObject, resource: string);
+    static fromJSON(status: number, obj: Readonly<JSONObject>): OutOfStockError | null;
+}

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

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

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const json = require("../../../helpers/json.cjs");
+const scwError = require("../scw-error.cjs");
+const buildMessage = (list) => `insufficient permissions: ${list.map(({ action, resource }) => `${action} ${resource}`).join("; ")}`;
+class PermissionsDeniedError extends scwError.ScalewayError {
+  constructor(status, body, list) {
+    super(status, body, buildMessage(list));
+    this.status = status;
+    this.body = body;
+    this.list = list;
+    this.name = "PermissionsDeniedError";
+  }
+  static fromJSON(status, obj) {
+    if (!Array.isArray(obj.details))
+      return null;
+    return new PermissionsDeniedError(
+      status,
+      obj,
+      obj.details.reduce(
+        (list, detail) => json.isJSONObject(detail) && typeof detail.resource === "string" && typeof detail.action === "string" ? list.concat({
+          action: detail.action,
+          resource: detail.resource
+        }) : list,
+        []
+      )
+    );
+  }
+}
+exports.PermissionsDeniedError = PermissionsDeniedError;