@scaleway/sdk 0.0.2-alpha.0

package/dist/index.js

@@ -0,0 +1,13 @@
+export { createAdvancedScwClient, createScwClient } from './scw/client.js';
+export { withProfile } from './scw/client-ini-factory.js';
+export { enableConsoleLogger, setLogger } from './internal/logger/index.js';
+import * as internals from './internals.js';
+export { internals };
+import * as index from './scw/errors/standard/index.js';
+export { index as Errors };
+import * as types from './api/registry/manual/types.js';
+export { types as RegistryNS };
+export { RegistryAPI } from './api/registry/manual/RegistryAPI.js';
+import * as types$1 from './api/function/manual/types.js';
+export { types$1 as FunctionNS };
+export { FunctionAPI } from './api/function/manual/FunctionAPI.js';

package/dist/internal/async/interval-retrier.js

@@ -0,0 +1,89 @@
+import { sleep } from './sleep.js';
+
+const DEFAULT_TIMEOUT = 5 * 60 * 1000;
+const DEFAULT_INTERVAL = 1 * 1000;
+/**
+ * Function to retry logic between each interval.
+ *
+ * @returns The result and if it's done
+ *
+ * @throws An exception might be thrown by the logic being run
+ *
+ * @internal
+ */
+
+/**
+ * Creates a fixed interval strategy.
+ * It returns the same interval value whatever the retry count.
+ *
+ * @param interval - The time interval (in milliseconds) to wait between each run
+ * @returns A fixed interval generator
+ *
+ * @internal
+ */
+function* createFixedIntervalStrategy(interval) {
+  while (true) yield interval;
+}
+/**
+ * Tries a specific logic several times until it succeeds, timeouts, or throws an exception.
+ *
+ * @param retry - The function to retry logic between each interval
+ * @param timeout - The maximum time elapsed before timeout error
+ * @param strategy - An optional generated interval strategy iterator
+ *
+ * @throws An timeout exception or error thrown by the logic being run
+ *
+ * @internal
+ */
+
+const tryAtIntervals = async function (retry, strategy, timeout) {
+  if (timeout === void 0) {
+    timeout = DEFAULT_TIMEOUT;
+  }
+
+  const timeoutTimestamp = Date.now() + timeout;
+  let retryCount = 0;
+
+  while (Date.now() <= timeoutTimestamp) {
+    const {
+      value,
+      done
+    } = await retry();
+    if (done) return value; // Break if timeout has been reached
+
+    if (timeoutTimestamp <= Date.now()) break; // Wait before the next retry
+
+    await sleep(strategy.next(retryCount += 1).value);
+  }
+
+  throw new Error(`Timeout after ${timeout}ms`);
+};
+
+/**
+ * Fetch resource several times until an expected status is reached, timeouts, or throws an exception.
+ *
+ * @param status - The list of expected status
+ * @param fetcher - The method to retrieve resource
+ * @param request - The resource request options
+ * @param options - The retry strategy options
+ * @param strategy - An optional custom strategy
+ *
+ * @returns A promise of resource
+ *
+ * @internal
+ */
+const waitForStatus = function (status, fetcher, request, options, strategy) {
+  if (strategy === void 0) {
+    strategy = createFixedIntervalStrategy((options == null ? void 0 : options.retryInterval) ?? DEFAULT_INTERVAL);
+  }
+
+  return tryAtIntervals(async () => {
+    const value = await fetcher(request);
+    return {
+      done: status.includes(value.status),
+      value
+    };
+  }, strategy, options == null ? void 0 : options.timeout);
+};
+
+export { createFixedIntervalStrategy, tryAtIntervals, waitForStatus };

package/dist/internal/async/sleep.js

@@ -0,0 +1,13 @@
+/**
+ * Sleep for a specified number of time.
+ *
+ * @param ms - The number of milliseconds
+ * @returns The sleep promise
+ *
+ * @internal
+ */
+const sleep = ms => new Promise(resolve => {
+  setTimeout(resolve, ms);
+});
+
+export { sleep };

package/dist/internal/auth.js

@@ -0,0 +1,68 @@
+import { assertValidAuthenticationSecrets } from '../scw/client-ini-profile.js';
+import { addAsyncHeaderInterceptor, addHeaderInterceptor } from './interceptors/request.js';
+
+const SESSION_HEADER_KEY = 'x-session-token';
+const AUTH_HEADER_KEY = 'x-auth-token';
+
+/**
+ * Authenticates with a session token.
+ *
+ * @param getToken - The token accessor
+ * @returns The request interceptor
+ *
+ * @internal
+ */
+const authenticateWithSessionToken = getToken => addAsyncHeaderInterceptor(SESSION_HEADER_KEY, getToken);
+/**
+ * Authenticates with a secrets.
+ *
+ * @param getToken - The secrets
+ * @returns The request interceptor
+ *
+ * @throws Error
+ * Thrown if the secrets are invalid.
+ *
+ * @internal
+ */
+
+const authenticateWithSecrets = secrets => {
+  assertValidAuthenticationSecrets(secrets);
+  return addHeaderInterceptor(AUTH_HEADER_KEY, secrets.secretKey);
+};
+/**
+ * Obfuscates a token.
+ *
+ * @param key - The token
+ * @returns The obfuscated token
+ *
+ * @internal
+ */
+
+const obfuscateToken = key => `${key.substring(0, 5)}xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`;
+/**
+ * Obfuscates an UUID.
+ *
+ * @param key - The UUID
+ * @returns The obfuscated UUID
+ *
+ * @internal
+ */
+
+const obfuscateUUID = key => `${key.substring(0, 8)}-xxxx-xxxx-xxxx-xxxxxxxxxxxx`;
+
+/**
+ * Obfuscates headers entry.
+ *
+ * @param array - The header entry
+ * @returns The obfuscated entry
+ *
+ * @internal
+ */
+const obfuscateAuthHeadersEntry = _ref => {
+  let [name, value] = _ref;
+  if (name === SESSION_HEADER_KEY) return [name, obfuscateToken(value)];
+  if (name === AUTH_HEADER_KEY) return [name, obfuscateUUID(value)];
+  return [name, value];
+};
+
+export { authenticateWithSecrets, authenticateWithSessionToken, obfuscateAuthHeadersEntry, obfuscateToken, obfuscateUUID };

package/dist/internal/interceptors/interceptor.js

@@ -0,0 +1,11 @@
+/**
+ * Composes interceptors.
+ *
+ * @param interceptors - A list of interceptors (that modify an object instance)
+ * @returns An async composed interceptor
+ *
+ * @internal
+ */
+const composeInterceptors = interceptors => async instance => interceptors.reduce(async (asyncResult, interceptor) => interceptor(await asyncResult), Promise.resolve(instance));
+
+export { composeInterceptors };

package/dist/internal/interceptors/request.js

@@ -0,0 +1,29 @@
+/** Request Interceptor. */
+
+/**
+ * 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 clone = request.clone();
+  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 };

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

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

package/dist/internal/logger/index.js

@@ -0,0 +1,38 @@
+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 => {
+  sdkLogger = logger;
+};
+/**
+ * Sets the logger to console logger with given logLevel.
+ *
+ * @param logLevel - The Log level name
+ *
+ * @public
+ */
+
+const enableConsoleLogger = function (logLevel) {
+  if (logLevel === void 0) {
+    logLevel = 'warn';
+  }
+
+  return setLogger(new ConsoleLogger(logLevel));
+};
+/**
+ * Returns the active SDK logger.
+ *
+ * @internal
+ */
+
+const getLogger = () => sdkLogger;
+
+export { enableConsoleLogger, getLogger, setLogger };

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

@@ -0,0 +1,16 @@
+// eslint-disable-next-line eslint-comments/disable-enable-pair
+
+/* eslint-disable @typescript-eslint/naming-convention */
+let LevelResolver;
+
+(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";
+})(LevelResolver || (LevelResolver = {}));
+
+const shouldLog = (currentLevel, level) => LevelResolver[level] <= currentLevel;
+
+export { LevelResolver, shouldLog };

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

@@ -0,0 +1,39 @@
+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 => {
+  let url;
+
+  try {
+    url = new URL(str);
+  } catch {
+    return false;
+  }
+
+  return url.protocol === 'http:' || url.protocol === 'https:';
+}; // Returns true if the given string has an email format.
+
+export { isAccessKey, isOrganizationId, isProjectId, isRegion, isSecretKey, isURL, isUUID, isZone };

package/dist/internals.js

@@ -0,0 +1,4 @@
+export { authenticateWithSessionToken } from './internal/auth.js';
+export { unmarshalAnyRes } from './scw/marshalling.js';
+export { API } from './helpers/API.js';
+export { forRegions } from './helpers/forRegions.js';