@scaleway/sdk 2.25.0 → 2.27.0

package/dist/internal/interceptors/helpers.d.ts

@@ -0,0 +1,21 @@
+import type { RequestInterceptor } from './types';
+/**
+ * Adds an header to a request through an interceptor.
+ *
+ * @param key - The header key
+ * @param value - The header value
+ * @returns The Request interceptor
+ *
+ * @internal
+ */
+export declare const addHeaderInterceptor: (key: string, value?: string) => RequestInterceptor;
+/**
+ * Adds asynchronously an header to a request through an interceptor.
+ *
+ * @param key - The header key
+ * @param value - The header value as a Promise
+ * @returns The Request interceptor
+ *
+ * @internal
+ */
+export declare const addAsyncHeaderInterceptor: (key: string, getter: () => Promise<string | undefined>) => RequestInterceptor;

package/dist/internal/interceptors/helpers.js

@@ -1,31 +1,12 @@
-/**
- * Adds an header to a request through an interceptor.
- *
- * @param key - The header key
- * @param value - The header value
- * @returns The Request interceptor
- *
- * @internal
- */
-const addHeaderInterceptor = (key, value) => ({
-  request
-}) => {
+const addHeaderInterceptor = (key, value) => ({ request }) => {
   const clone = request.clone();
-  if (value !== undefined) {
+  if (value !== void 0) {
     clone.headers.append(key, value);
   }
   return clone;
 };
-
-/**
- * Adds asynchronously an header to a request through an interceptor.
- *
- * @param key - The header key
- * @param value - The header value as a Promise
- * @returns The Request interceptor
- *
- * @internal
- */
-const addAsyncHeaderInterceptor = (key, getter) => async request => addHeaderInterceptor(key, await getter())(request);
-
-export { addAsyncHeaderInterceptor, addHeaderInterceptor };
+const addAsyncHeaderInterceptor = (key, getter) => async (request) => addHeaderInterceptor(key, await getter())(request);
+export {
+  addAsyncHeaderInterceptor,
+  addHeaderInterceptor
+};

package/dist/internal/interceptors/types.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Defines the interceptor for a `Request`.
+ * This allows you to intercept requests before starting.
+ *
+ * @example
+ * Adds a custom header to a request:
+ * ```
+ * const addCustomHeaderInterceptor
+ *   ({ key, value }: { key: string; value: string }): RequestInterceptor =>
+ *   ({ request }) => {
+ *     const clone = request.clone()
+ *     clone.headers.set(key, value)
+ *
+ *     return clone
+ * }
+ * ```
+ *
+ * @public
+ */
+export interface RequestInterceptor {
+    ({ request }: {
+        request: Readonly<Request>;
+    }): Request | Promise<Request>;
+}
+/**
+ * Defines the interceptor for a `Response`.
+ * This allows you to intercept responses before unmarshalling.
+ *
+ * @example
+ * Adds a delay before sending the response:
+ * ```
+ * const addDelayInterceptor: ResponseInterceptor = ({ response }) =>
+ *   new Promise(resolve => {
+ *     setTimeout(() => resolve(response), 1000)
+ *   })
+ * ```
+ *
+ * @public
+ */
+export interface ResponseInterceptor {
+    ({ response }: {
+        response: Readonly<Response>;
+    }): Response | Promise<Response>;
+}
+/**
+ * Defines the interceptor for a `Response` error.
+ * This allows you to intercept a response error before exiting the whole process.
+ * You can either rethrow an error, and resolve with a different response.
+ *
+ * @remarks
+ * You must return either:
+ * 1. An error (`throw error` or `Promise.reject(error)`)
+ * 2. Data (directly, or via a Promise)
+ *
+ * @example
+ * Reports error to tracking service:
+ * ```
+ * const reportErrorToTrackingService: ResponseErrorInterceptor = async ({
+ *   request,
+ *   error,
+ * }: {
+ *   request: Request
+ *   error: unknown
+ * }) => {
+ *   await sendErrorToErrorService(request, error)
+ *   throw error
+ * }
+ * ```
+ *
+ * @public
+ */
+export interface ResponseErrorInterceptor {
+    ({ request, error }: {
+        request: Request;
+        error: unknown;
+    }): unknown;
+}
+/**
+ * Defines the network interceptors.
+ * Please check the documentation of {@link RequestInterceptor},
+ * {@link ResponseInterceptor} and {@link ResponseErrorInterceptor} for examples.
+ *
+ * @public
+ */
+export type NetworkInterceptors = {
+    request?: RequestInterceptor;
+    response?: ResponseInterceptor;
+    responseError?: ResponseErrorInterceptor;
+};

package/dist/internal/logger/console-logger.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const levelResolver = require("./level-resolver.cjs");
+class ConsoleLogger {
+  constructor(logLevel, prefix = "", output = console) {
+    this.logLevel = logLevel;
+    this.prefix = prefix;
+    this.output = output;
+    this.level = levelResolver.LevelResolver[this.logLevel];
+  }
+  level;
+  makeMethod(method) {
+    return (message) => {
+      if (levelResolver.shouldLog(this.level, method)) {
+        this.output[method](this.prefix ? `${this.prefix} ${message}` : message);
+      }
+    };
+  }
+  debug = this.makeMethod("debug");
+  error = this.makeMethod("error");
+  info = this.makeMethod("info");
+  warn = this.makeMethod("warn");
+}
+exports.ConsoleLogger = ConsoleLogger;

package/dist/internal/logger/console-logger.d.ts

@@ -0,0 +1,23 @@
+import type { LogLevel } from './level-resolver';
+import type { Logger } from './logger';
+/**
+ * A Logger using console output.
+ *
+ * @param logLevel - The logger level name
+ * @param prefix - An optional logger message prefix
+ * @param output - The output to print logs, using by default the global console object
+ *
+ * @internal
+ */
+export declare class ConsoleLogger implements Logger {
+    readonly logLevel: LogLevel;
+    private readonly prefix;
+    private output;
+    private level;
+    constructor(logLevel: LogLevel, prefix?: string, output?: typeof console);
+    private makeMethod;
+    debug: (message: string) => void;
+    error: (message: string) => void;
+    info: (message: string) => void;
+    warn: (message: string) => void;
+}

package/dist/internal/logger/console-logger.js

@@ -1,32 +1,24 @@
-import { LevelResolver, shouldLog } from './level-resolver.js';
-
-/**
- * A Logger using console output.
- *
- * @param logLevel - The logger level name
- * @param prefix - An optional logger message prefix
- * @param output - The output to print logs, using by default the global console object
- *
- * @internal
- */
+import { LevelResolver, shouldLog } from "./level-resolver.js";
 class ConsoleLogger {
-  constructor(logLevel, prefix = '', output = console) {
+  constructor(logLevel, prefix = "", output = console) {
     this.logLevel = logLevel;
     this.prefix = prefix;
     this.output = output;
     this.level = LevelResolver[this.logLevel];
   }
+  level;
   makeMethod(method) {
-    return message => {
+    return (message) => {
       if (shouldLog(this.level, method)) {
         this.output[method](this.prefix ? `${this.prefix} ${message}` : message);
       }
     };
   }
-  debug = this.makeMethod('debug');
-  error = this.makeMethod('error');
-  info = this.makeMethod('info');
-  warn = this.makeMethod('warn');
+  debug = this.makeMethod("debug");
+  error = this.makeMethod("error");
+  info = this.makeMethod("info");
+  warn = this.makeMethod("warn");
 }
-
-export { ConsoleLogger };
+export {
+  ConsoleLogger
+};

package/dist/internal/logger/index.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const consoleLogger = require("./console-logger.cjs");
+let sdkLogger = new consoleLogger.ConsoleLogger("silent");
+const setLogger = (logger) => {
+  sdkLogger = logger;
+};
+const enableConsoleLogger = (logLevel = "warn", prefix = "scaleway-sdk-js:") => setLogger(new consoleLogger.ConsoleLogger(logLevel, prefix));
+const getLogger = () => sdkLogger;
+exports.enableConsoleLogger = enableConsoleLogger;
+exports.getLogger = getLogger;
+exports.setLogger = setLogger;

package/dist/internal/logger/index.d.ts

@@ -0,0 +1,25 @@
+import type { LogLevel } from './level-resolver';
+import type { Logger } from './logger';
+/**
+ * Sets a logger to be used within the SDK.
+ *
+ * @param logger - The Logger instance
+ *
+ * @public
+ */
+export declare const setLogger: (logger: Readonly<Logger>) => void;
+/**
+ * Sets the logger to console logger with given logLevel (log is disabled by default).
+ *
+ * @param logLevel - The Log level (default to 'warn')
+ * @param prefix - A Log message prefix (default to 'scaleway-sdk-js:')
+ *
+ * @public
+ */
+export declare const enableConsoleLogger: (logLevel?: LogLevel, prefix?: string) => void;
+/**
+ * Returns the active SDK logger.
+ *
+ * @internal
+ */
+export declare const getLogger: () => Readonly<Logger>;

package/dist/internal/logger/index.js

@@ -1,33 +1,12 @@
-import { ConsoleLogger } from './console-logger.js';
-
-let sdkLogger = /*#__PURE__*/new ConsoleLogger('silent');
-
-/**
- * Sets a logger to be used within the SDK.
- *
- * @param logger - The Logger instance
- *
- * @public
- */
-const setLogger = logger => {
+import { ConsoleLogger } from "./console-logger.js";
+let sdkLogger = new ConsoleLogger("silent");
+const setLogger = (logger) => {
   sdkLogger = logger;
 };
-
-/**
- * Sets the logger to console logger with given logLevel (log is disabled by default).
- *
- * @param logLevel - The Log level (default to 'warn')
- * @param prefix - A Log message prefix (default to 'scaleway-sdk-js:')
- *
- * @public
- */
-const enableConsoleLogger = (logLevel = 'warn', prefix = 'scaleway-sdk-js:') => setLogger(new ConsoleLogger(logLevel, prefix));
-
-/**
- * Returns the active SDK logger.
- *
- * @internal
- */
+const enableConsoleLogger = (logLevel = "warn", prefix = "scaleway-sdk-js:") => setLogger(new ConsoleLogger(logLevel, prefix));
 const getLogger = () => sdkLogger;
-
-export { enableConsoleLogger, getLogger, setLogger };
+export {
+  enableConsoleLogger,
+  getLogger,
+  setLogger
+};

package/dist/internal/logger/level-resolver.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var LevelResolver = /* @__PURE__ */ ((LevelResolver2) => {
+  LevelResolver2[LevelResolver2["silent"] = 0] = "silent";
+  LevelResolver2[LevelResolver2["error"] = 1] = "error";
+  LevelResolver2[LevelResolver2["warn"] = 2] = "warn";
+  LevelResolver2[LevelResolver2["info"] = 3] = "info";
+  LevelResolver2[LevelResolver2["debug"] = 4] = "debug";
+  return LevelResolver2;
+})(LevelResolver || {});
+const shouldLog = (currentLevel, level) => LevelResolver[level] <= currentLevel;
+exports.LevelResolver = LevelResolver;
+exports.shouldLog = shouldLog;

package/dist/internal/logger/level-resolver.d.ts

@@ -0,0 +1,9 @@
+export declare enum LevelResolver {
+    silent = 0,
+    error = 1,
+    warn = 2,
+    info = 3,
+    debug = 4
+}
+export type LogLevel = keyof typeof LevelResolver;
+export declare const shouldLog: (currentLevel: LevelResolver, level: LogLevel) => boolean;

package/dist/internal/logger/level-resolver.js

@@ -1,13 +1,13 @@
-// eslint-disable-next-line eslint-comments/disable-enable-pair
-/* eslint-disable @typescript-eslint/naming-convention */
-let LevelResolver = /*#__PURE__*/function (LevelResolver) {
-  LevelResolver[LevelResolver["silent"] = 0] = "silent";
-  LevelResolver[LevelResolver["error"] = 1] = "error";
-  LevelResolver[LevelResolver["warn"] = 2] = "warn";
-  LevelResolver[LevelResolver["info"] = 3] = "info";
-  LevelResolver[LevelResolver["debug"] = 4] = "debug";
-  return LevelResolver;
-}({});
+var LevelResolver = /* @__PURE__ */ ((LevelResolver2) => {
+  LevelResolver2[LevelResolver2["silent"] = 0] = "silent";
+  LevelResolver2[LevelResolver2["error"] = 1] = "error";
+  LevelResolver2[LevelResolver2["warn"] = 2] = "warn";
+  LevelResolver2[LevelResolver2["info"] = 3] = "info";
+  LevelResolver2[LevelResolver2["debug"] = 4] = "debug";
+  return LevelResolver2;
+})(LevelResolver || {});
 const shouldLog = (currentLevel, level) => LevelResolver[level] <= currentLevel;
-
-export { LevelResolver, shouldLog };
+export {
+  LevelResolver,
+  shouldLog
+};

package/dist/internal/logger/logger.d.ts

@@ -0,0 +1,13 @@
+import type { LogLevel } from './level-resolver';
+/**
+ * Logger.
+ *
+ * @public
+ */
+export interface Logger {
+    readonly logLevel: LogLevel;
+    debug: (message: string) => void;
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+}

package/dist/internal/validations/string-validation.cjs

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isAccessKeyRegex = /^SCW[A-Z0-9]{17}$/i;
+const isRegionRegex = /^[a-z]{2}-[a-z]{3}$/i;
+const isUUIDRegex = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/i;
+const isZoneRegex = /^[a-z]{2}-[a-z]{3}-[1-9]$/i;
+const isUUID = (str) => isUUIDRegex.test(str);
+const isAccessKey = (str) => isAccessKeyRegex.test(str);
+const isSecretKey = (str) => isUUID(str);
+const isOrganizationId = (str) => isUUID(str);
+const isProjectId = (str) => isUUID(str);
+const isRegion = (str) => isRegionRegex.test(str);
+const isZone = (str) => isZoneRegex.test(str);
+const isURL = (str) => {
+  let url;
+  try {
+    url = new URL(str);
+  } catch {
+    return false;
+  }
+  return url.protocol === "http:" || url.protocol === "https:";
+};
+exports.isAccessKey = isAccessKey;
+exports.isOrganizationId = isOrganizationId;
+exports.isProjectId = isProjectId;
+exports.isRegion = isRegion;
+exports.isSecretKey = isSecretKey;
+exports.isURL = isURL;
+exports.isUUID = isUUID;
+exports.isZone = isZone;

package/dist/internal/validations/string-validation.d.ts

@@ -0,0 +1,18 @@
+/** Returns true if the given string has a valid UUID format. */
+export declare const isUUID: (str: string) => boolean;
+/** Returns true if the given string has a valid Scaleway access key format. */
+export declare const isAccessKey: (str: string) => boolean;
+/** Returns true if the given string has a valid Scaleway secret key format. */
+export declare const isSecretKey: (str: string) => boolean;
+/** Returns true if the given string has a valid Scaleway organization ID format. */
+export declare const isOrganizationId: (str: string) => boolean;
+/** Returns true if the given string has a valid Scaleway project ID format. */
+export declare const isProjectId: (str: string) => boolean;
+/** Returns true if the given string has a valid region format. */
+export declare const isRegion: (str: string) => boolean;
+/** Returns true if the given string has a valid zone format. */
+export declare const isZone: (str: string) => boolean;
+/** Returns true if the given string has a valid URL format and starts by `http(s):`. */
+export declare const isURL: (str: string) => boolean;
+/** Returns true if the given string has an email format. */
+export declare const isEmail: (str: string) => boolean;

package/dist/internal/validations/string-validation.js

@@ -2,37 +2,29 @@ const isAccessKeyRegex = /^SCW[A-Z0-9]{17}$/i;
 const isRegionRegex = /^[a-z]{2}-[a-z]{3}$/i;
 const isUUIDRegex = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/i;
 const isZoneRegex = /^[a-z]{2}-[a-z]{3}-[1-9]$/i;
-
-/** Returns true if the given string has a valid UUID format. */
-const isUUID = str => isUUIDRegex.test(str);
-
-/** Returns true if the given string has a valid Scaleway access key format. */
-const isAccessKey = str => isAccessKeyRegex.test(str);
-
-/** Returns true if the given string has a valid Scaleway secret key format. */
-const isSecretKey = str => isUUID(str);
-
-/** Returns true if the given string has a valid Scaleway organization ID format. */
-const isOrganizationId = str => isUUID(str);
-
-/** Returns true if the given string has a valid Scaleway project ID format. */
-const isProjectId = str => isUUID(str);
-
-/** Returns true if the given string has a valid region format. */
-const isRegion = str => isRegionRegex.test(str);
-
-/** Returns true if the given string has a valid zone format. */
-const isZone = str => isZoneRegex.test(str);
-
-/** Returns true if the given string has a valid URL format and starts by `http(s):`. */
-const isURL = str => {
+const isUUID = (str) => isUUIDRegex.test(str);
+const isAccessKey = (str) => isAccessKeyRegex.test(str);
+const isSecretKey = (str) => isUUID(str);
+const isOrganizationId = (str) => isUUID(str);
+const isProjectId = (str) => isUUID(str);
+const isRegion = (str) => isRegionRegex.test(str);
+const isZone = (str) => isZoneRegex.test(str);
+const isURL = (str) => {
   let url;
   try {
     url = new URL(str);
   } catch {
     return false;
   }
-  return url.protocol === 'http:' || url.protocol === 'https:';
+  return url.protocol === "http:" || url.protocol === "https:";
+};
+export {
+  isAccessKey,
+  isOrganizationId,
+  isProjectId,
+  isRegion,
+  isSecretKey,
+  isURL,
+  isUUID,
+  isZone
 };
-
-export { isAccessKey, isOrganizationId, isProjectId, isRegion, isSecretKey, isURL, isUUID, isZone };

package/dist/internals.d.ts

@@ -0,0 +1,10 @@
+export { isJSONObject } from './helpers/json';
+export { createExponentialBackoffStrategy, tryAtIntervals, waitForResource, } from './internal/async/interval-retrier';
+export { addAsyncHeaderInterceptor } from './internal/interceptors/helpers';
+export { API } from './scw/api';
+export { authenticateWithSessionToken } from './scw/auth';
+export type { DefaultValues } from './scw/client-settings';
+export { marshalScwFile, marshalMoney, marshalTimeSeries, unmarshalMoney, unmarshalScwFile, unmarshalServiceInfo, unmarshalTimeSeries, unmarshalTimeSeriesPoint, } from './scw/custom-marshalling';
+export type { ServiceInfo } from './scw/custom-types';
+export { resolveOneOf, unmarshalDate, unmarshalArrayOfObject, unmarshalMapOfObject, urlParams, validatePathParam, } from './helpers/marshalling';
+export { enrichForPagination } from './scw/fetch/resource-paginator';

package/dist/scw/api.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let API$1 = class API {
+  constructor(client) {
+    this.client = client;
+  }
+};
+exports.API = API$1;

package/dist/scw/api.d.ts

@@ -0,0 +1,10 @@
+import type { Client } from './client';
+/**
+ * Abstract class to instantiate API from a {@link Client}.
+ *
+ * @internal
+ */
+export declare abstract class API {
+    protected client: Client;
+    constructor(client: Client);
+}

package/dist/scw/api.js

@@ -1,12 +1,8 @@
-/**
- * Abstract class to instantiate API from a {@link Client}.
- *
- * @internal
- */
 let API$1 = class API {
   constructor(client) {
     this.client = client;
   }
 };
-
-export { API$1 as API };
+export {
+  API$1 as API
+};

package/dist/scw/auth.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const helpers = require("../internal/interceptors/helpers.cjs");
+const clientIniProfile = require("./client-ini-profile.cjs");
+const SESSION_HEADER_KEY = "x-session-token";
+const AUTH_HEADER_KEY = "x-auth-token";
+const authenticateWithSessionToken = (getToken) => helpers.addAsyncHeaderInterceptor(SESSION_HEADER_KEY, getToken);
+const authenticateWithSecrets = (secrets) => {
+  clientIniProfile.assertValidAuthenticationSecrets(secrets);
+  return helpers.addHeaderInterceptor(AUTH_HEADER_KEY, secrets.secretKey);
+};
+const obfuscateToken = (key) => `${key.substring(0, 5)}xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`;
+const obfuscateUUID = (key) => `${key.substring(0, 8)}-xxxx-xxxx-xxxx-xxxxxxxxxxxx`;
+const obfuscateAuthHeadersEntry = ([
+  name,
+  value
+]) => {
+  if (name === SESSION_HEADER_KEY)
+    return [name, obfuscateToken(value)];
+  if (name === AUTH_HEADER_KEY)
+    return [name, obfuscateUUID(value)];
+  return [name, value];
+};
+exports.authenticateWithSecrets = authenticateWithSecrets;
+exports.authenticateWithSessionToken = authenticateWithSessionToken;
+exports.obfuscateAuthHeadersEntry = obfuscateAuthHeadersEntry;
+exports.obfuscateToken = obfuscateToken;
+exports.obfuscateUUID = obfuscateUUID;

package/dist/scw/auth.d.ts

@@ -0,0 +1,57 @@
+import type { RequestInterceptor } from '../internal/interceptors/types';
+import type { AuthenticationSecrets } from './client-ini-profile';
+interface TokenAccessor {
+    (): Promise<string | undefined>;
+}
+/**
+ * Authenticates with a session token.
+ *
+ * @param getToken - The token accessor
+ * @returns The request interceptor
+ *
+ * @deprecated Please use addAsyncHeaderInterceptor instead.
+ *
+ * @internal
+ */
+export declare const authenticateWithSessionToken: (getToken: TokenAccessor) => RequestInterceptor;
+/**
+ * Authenticates with a secrets.
+ *
+ * @param getToken - The secrets
+ * @returns The request interceptor
+ *
+ * @throws Error
+ * Thrown if the secrets are invalid.
+ *
+ * @internal
+ */
+export declare const authenticateWithSecrets: (secrets: AuthenticationSecrets) => RequestInterceptor;
+/**
+ * Obfuscates a token.
+ *
+ * @param key - The token
+ * @returns The obfuscated token
+ *
+ * @internal
+ */
+export declare const obfuscateToken: (key: string) => string;
+/**
+ * Obfuscates an UUID.
+ *
+ * @param key - The UUID
+ * @returns The obfuscated UUID
+ *
+ * @internal
+ */
+export declare const obfuscateUUID: (key: string) => string;
+type HeaderEntry = [string, string];
+/**
+ * Obfuscates headers entry.
+ *
+ * @param array - The header entry
+ * @returns The obfuscated entry
+ *
+ * @internal
+ */
+export declare const obfuscateAuthHeadersEntry: ([name, value,]: HeaderEntry) => HeaderEntry;
+export {};