@dynamic-labs-sdk/client 0.0.1-alpha.1

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+## 0.0.1-alpha.1 (2025-05-19)
+
+### 🩹 Fixes
+
+- make the client package public ([#74](https://github.com/dynamic-labs/dynamic-sdk/pull/74))
+
+## 0.0.1-alpha.0 (2025-05-16)
+
+Initial release of the Dynamic SDK.

package/README.md

@@ -0,0 +1,29 @@
+# Dynamic Client SDK
+
+Welcome to the Dynamic Client SDK - a powerful and flexible authentication solution for your applications.
+
+## Overview
+
+The Dynamic Client SDK provides a seamless way to integrate authentication and user management into your application. With an easy-to-use API and robust feature set, you can quickly implement secure authentication flows while maintaining a great user experience.
+
+The SDK is designed to be lightweight yet powerful, giving you the tools you need without unnecessary bloat.
+
+## Troubleshooting Initialization
+
+If you are having issues with your client's initialization, try the following:
+
+1. Disable `autoInitialize`:
+
+```typescript
+const client = createDynamicClient({ autoInitialize: false });
+```
+
+2. Initialize the client manually and handle the error:
+
+```typescript
+try {
+  await initializeClient(client);
+} catch (error) {
+  console.log(error);
+}
+```

package/index.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/index.cjs.js

@@ -0,0 +1,530 @@
+'use strict';
+
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+var EventEmitter = require('eventemitter3');
+
+const getCore = (client)=>{
+    // @ts-expect-error - this was hidden from the public API
+    return client.__core;
+};
+
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+var version = "0.0.1-alpha.1";
+var dependencies = {
+    "@dynamic-labs/sdk-api-core": "0.0.630"};
+
+/**
+ * Returns a new instance of the SDK API client.
+ *
+ * This is not meant for storing, as it is very light we can create it whenever needed.
+ */ const createApiClient = (client)=>{
+    const core = getCore(client);
+    const settings = {
+        basePath: core.apiBaseUrl,
+        headers: {
+            'Content-Type': 'application/json',
+            'x-dyn-api-version': dependencies['@dynamic-labs/sdk-api-core'],
+            'x-dyn-version': core.version
+        }
+    };
+    if (client.token) {
+        settings.headers.Authorization = `Bearer ${client.token}`;
+    }
+    return new sdkApiCore.SDKApi(new sdkApiCore.Configuration(_extends({}, settings, {
+        fetchApi: core.fetch
+    })));
+};
+
+/**
+ * Updates the project settings in the core state to the latest values.
+ */ const fetchProjectSettings = async (client)=>{
+    const core = getCore(client);
+    const apiClient = createApiClient(client);
+    const projectSettings = await apiClient.getEnvironmentSettings({
+        environmentId: core.environmentId,
+        sdkVersion: `WalletKit/${core.version}`
+    }, {
+        credentials: 'omit'
+    });
+    core.state.set({
+        projectSettings
+    });
+    return projectSettings;
+};
+
+const getDetails = ({ details, cause })=>{
+    if (cause instanceof BaseError) {
+        return cause.details;
+    }
+    if (cause == null ? void 0 : cause.message) {
+        return cause.message;
+    }
+    return details;
+};
+/**
+ * Formats the error message with all available information
+ */ const formatMessage = ({ shortMessage, details, docsUrl, metaMessages })=>{
+    return [
+        shortMessage,
+        '',
+        ...metaMessages ? [
+            ...metaMessages,
+            ''
+        ] : [],
+        ...docsUrl ? [
+            `Docs: ${docsUrl}`
+        ] : [],
+        ...details ? [
+            `Details: ${details}`
+        ] : [],
+        `Version: ${version}`,
+        `Timestamp: ${new Date().toISOString()}`
+    ].join('\n');
+};
+/**
+ * Base error class that provides structured error handling with detailed information
+ */ class BaseError extends Error {
+    /**
+   * Walks the cause chain of the error and returns the root error
+   */ walk() {
+        const cause = this.cause;
+        if (cause instanceof BaseError) {
+            return cause.walk();
+        }
+        return cause;
+    }
+    constructor(args){
+        const details = getDetails(args);
+        super(formatMessage(_extends({}, args, {
+            details
+        })), args.cause ? {
+            cause: args.cause
+        } : undefined);
+        this.name = 'BaseError';
+        this.details = details;
+        var _args_name;
+        this.name = (_args_name = args.name) != null ? _args_name : this.name;
+        var _args_cause;
+        this.cause = (_args_cause = args.cause) != null ? _args_cause : this.cause;
+    }
+}
+
+class ClientAlreadyInitializedError extends BaseError {
+    constructor(){
+        super({
+            cause: null,
+            docsUrl: null,
+            name: 'ClientAlreadyInitializedError',
+            shortMessage: 'Client must not be initialized more than once'
+        });
+    }
+}
+
+/**
+ * Orchestrates the initialization of all modules and services of the SDK, and keeps
+ * the loading flag updated.
+ */ const initializeClient = async (client)=>{
+    const core = getCore(client);
+    if (core.state.get().initStatus !== 'uninitialized') {
+        throw new ClientAlreadyInitializedError();
+    }
+    core.state.set({
+        initStatus: 'in-progress'
+    });
+    const projectSettingsPromise = fetchProjectSettings(client);
+    core.initTrack.track({
+        name: 'project-settings',
+        promise: projectSettingsPromise
+    });
+    try {
+        await core.initTrack.waitForAll();
+        core.state.set({
+            initStatus: 'finished'
+        });
+    } catch (error) {
+        core.state.set({
+            initStatus: 'failed'
+        });
+        throw error;
+    }
+};
+
+const createDeferredPromise = ()=>{
+    let resolve;
+    let reject;
+    const promise = new Promise((_resolve, _reject)=>{
+        resolve = _resolve;
+        reject = _reject;
+    });
+    return {
+        promise,
+        reject: (reason)=>reject == null ? void 0 : reject(reason),
+        resolve: (value)=>resolve == null ? void 0 : resolve(value)
+    };
+};
+
+class CannotTrackError extends BaseError {
+    constructor(){
+        super({
+            cause: null,
+            docsUrl: null,
+            name: 'CannotTrackError',
+            shortMessage: 'All track calls must be performed in the same node tick'
+        });
+    }
+}
+
+/**
+ * Creates a tracker that associates names with promises and raises as promises resolve.
+ */ const createAsyncTrack = ()=>{
+    /**
+   * Whether tracking is enabled.
+   * All processes must be tracked on the same node tick.
+   *
+   * This ensures no process is missed (as it would throw when tracked on a different node tick).
+   */ let isTrackEnabled = true;
+    const eventEmitter = new EventEmitter.EventEmitter();
+    const allSettledPromise = createDeferredPromise();
+    const tracker = new Map();
+    /**
+   * Checks if all processes are initialized and resolves the main promise if they are.
+   */ const checkIfAllSettled = ()=>{
+        const allSettled = Array.from(tracker.values()).every((status)=>status === 'resolved');
+        if (!allSettled) return;
+        allSettledPromise.resolve();
+    };
+    const track = ({ name, promise })=>{
+        if (!isTrackEnabled) {
+            throw new CannotTrackError();
+        }
+        // Disable tracking in the next node tick
+        void Promise.resolve().then(()=>isTrackEnabled = false);
+        tracker.set(name, 'pending');
+        promise.then(()=>{
+            tracker.set(name, 'resolved');
+            eventEmitter.emit('resolved', name);
+            checkIfAllSettled();
+        }).catch((error)=>{
+            tracker.set(name, 'failed');
+            eventEmitter.emit('failed', name, error);
+            allSettledPromise.reject(error);
+        });
+    };
+    const waitForAll = ()=>allSettledPromise.promise;
+    const getTracker = ()=>tracker;
+    return {
+        getTracker,
+        off: eventEmitter.off.bind(eventEmitter),
+        on: eventEmitter.on.bind(eventEmitter),
+        track,
+        waitForAll
+    };
+};
+
+const createEventEmitter = ()=>new EventEmitter();
+
+/**
+ * Creates a fetch instance that uses the native window.fetch API.
+ */ // eslint-disable-next-line no-restricted-globals -- this is the abstraction for fetch
+const createWebFetch = ()=>window.fetch;
+
+/**
+ * Log levels and their corresponding numeric values
+ */ const LOG_LEVELS = {
+    debug: 0,
+    error: 3,
+    info: 1,
+    warn: 2
+};
+// Assign to avoid lint errors
+const defaultConsole = console;
+/**
+ * Creates a logger instance with configurable log level and event emission capabilities.
+ * @returns A logger instance with debug, info, warn, and error methods
+ */ const createLogger = (options = {})=>{
+    const eventEmitter = new EventEmitter.EventEmitter();
+    var _options_level;
+    // Default to 'debug' if no level is provided
+    const minLevel = (_options_level = options.level) != null ? _options_level : 'warn';
+    // Helper to decide if we should log based on current log level
+    const shouldLog = (level)=>{
+        return LOG_LEVELS[level] >= LOG_LEVELS[minLevel];
+    };
+    // Helper to format the log message
+    const formatMessage = (level, message)=>{
+        const timestamp = new Date().toISOString();
+        return `[${timestamp}] ${level.toUpperCase()}: ${message}`;
+    };
+    // Unified logger function that checks the level and calls the appropriate console method
+    const log = (level, consoleMethod, message, ...args)=>{
+        eventEmitter.emit('log', level, message, ...args);
+        if (!shouldLog(level)) return;
+        consoleMethod(formatMessage(level, message), ...args);
+    };
+    return {
+        debug: (message, ...args)=>log('debug', defaultConsole.debug, message, ...args),
+        error: (message, ...args)=>log('error', defaultConsole.error, message, ...args),
+        info: (message, ...args)=>log('info', defaultConsole.info, message, ...args),
+        off: eventEmitter.off.bind(eventEmitter),
+        on: eventEmitter.on.bind(eventEmitter),
+        warn: (message, ...args)=>log('warn', defaultConsole.warn, message, ...args)
+    };
+};
+
+/**
+ * Creates a deeplink opener that uses the native window.open API.
+ */ const createWebDeeplinkOpener = ()=>{
+    return async (url)=>{
+        // eslint-disable-next-line no-restricted-globals -- this is the abstraction for opening a deeplink
+        window.open(url, '_blank');
+    };
+};
+
+const formatForStorage = (value)=>{
+    const item = {
+        value
+    };
+    return JSON.stringify(item);
+};
+const parseFromStorage = (value)=>{
+    const item = JSON.parse(value);
+    return item.value;
+};
+
+/**
+ * Creates a Storage instance that uses localStorage as the storage model meant for use in the browser.
+ */ const createWebStorage = ()=>({
+        getItem: async (key)=>{
+            const rawItem = localStorage.getItem(key);
+            return rawItem ? parseFromStorage(rawItem) : null;
+        },
+        removeItem: async (key)=>{
+            localStorage.removeItem(key);
+        },
+        setItem: async (key, value)=>{
+            const item = formatForStorage(value);
+            localStorage.setItem(key, item);
+        }
+    });
+
+const createObservableState = (getInitialState)=>{
+    // ===============
+    // NOTIFICATIONS
+    // ===============
+    const subscribers = new Set();
+    const notifySubscribers = (value)=>{
+        subscribers.forEach((callback)=>callback(value));
+    };
+    const subscribe = (callback)=>{
+        subscribers.add(callback);
+        return ()=>unsubscribe(callback);
+    };
+    const unsubscribe = (callback)=>{
+        subscribers.delete(callback);
+    };
+    // ===============
+    // STATE
+    // ===============
+    const currentValue = getInitialState();
+    const get = ()=>currentValue;
+    const set = (partial)=>{
+        Object.assign(currentValue, partial);
+        notifySubscribers(currentValue);
+    };
+    return {
+        get,
+        getInitialState,
+        set,
+        subscribe,
+        unsubscribe
+    };
+};
+
+/**
+ * The default API base URL for Dynamic apps in production.
+ */ const DEFAULT_API_BASE_URL = 'https://app.dynamic.xyz/api/v0';
+
+/**
+ * Creates a core instance that contains all the services and state of the Dynamic SDK client.
+ */ const createCore = (config)=>{
+    var _config_coreConfig, _config_coreConfig1, _config_coreConfig2, _config_coreConfig3, _config_coreConfig4;
+    var _config_coreConfig_apiBaseUrl;
+    const apiBaseUrl = (_config_coreConfig_apiBaseUrl = (_config_coreConfig = config.coreConfig) == null ? void 0 : _config_coreConfig.apiBaseUrl) != null ? _config_coreConfig_apiBaseUrl : DEFAULT_API_BASE_URL;
+    var _config_coreConfig_logger;
+    const logger = (_config_coreConfig_logger = (_config_coreConfig1 = config.coreConfig) == null ? void 0 : _config_coreConfig1.logger) != null ? _config_coreConfig_logger : createLogger();
+    var _config_coreConfig_storage;
+    const storage = (_config_coreConfig_storage = (_config_coreConfig2 = config.coreConfig) == null ? void 0 : _config_coreConfig2.storage) != null ? _config_coreConfig_storage : createWebStorage();
+    var _config_coreConfig_fetch;
+    const fetch = (_config_coreConfig_fetch = (_config_coreConfig3 = config.coreConfig) == null ? void 0 : _config_coreConfig3.fetch) != null ? _config_coreConfig_fetch : createWebFetch();
+    var _config_coreConfig_openDeeplink;
+    const openDeeplink = (_config_coreConfig_openDeeplink = (_config_coreConfig4 = config.coreConfig) == null ? void 0 : _config_coreConfig4.openDeeplink) != null ? _config_coreConfig_openDeeplink : createWebDeeplinkOpener();
+    const state = createObservableState(()=>({
+            initStatus: 'uninitialized',
+            loaded: false,
+            projectSettings: null,
+            token: null,
+            user: null
+        }));
+    const eventEmitter = createEventEmitter();
+    const initTrack = createAsyncTrack();
+    return {
+        apiBaseUrl,
+        environmentId: config.environmentId,
+        eventEmitter,
+        fetch,
+        initTrack,
+        logger,
+        openDeeplink,
+        state,
+        storage,
+        version
+    };
+};
+
+const createDynamicClient = (config)=>{
+    const core = createCore(config);
+    const client = {
+        get __core () {
+            return core;
+        },
+        get initStatus () {
+            return core.state.get().initStatus;
+        },
+        get projectSettings () {
+            return core.state.get().projectSettings;
+        },
+        get token () {
+            return core.state.get().token;
+        },
+        get user () {
+            return core.state.get().user;
+        }
+    };
+    var _config_autoInitialize;
+    const autoInitialize = (_config_autoInitialize = config.autoInitialize) != null ? _config_autoInitialize : true;
+    if (autoInitialize) {
+        void initializeClient(client);
+    }
+    return client;
+};
+
+const logout = async (client)=>{
+    const core = getCore(client);
+    const apiClient = createApiClient(client);
+    await apiClient.revokeSession({
+        environmentId: core.environmentId
+    });
+    core.state.set({
+        token: null,
+        user: null
+    });
+};
+
+/**
+ * Listen to an event from the client.
+ *
+ * @returns A function that can be called to remove the listener.
+ */ const onEvent = (client, event, listener)=>{
+    const { eventEmitter } = getCore(client);
+    eventEmitter.on(event, listener);
+    return ()=>{
+        eventEmitter.off(event, listener);
+    };
+};
+/**
+ * Remove a listener from an event.
+ */ const offEvent = (client, event, listener)=>{
+    const { eventEmitter } = getCore(client);
+    eventEmitter.off(event, listener);
+};
+/**
+ * Listen to an event that will only fire once.
+ *
+ * @returns A function that can be called to remove the listener.
+ */ const onceEvent = (client, event, listener)=>{
+    const { eventEmitter } = getCore(client);
+    eventEmitter.once(event, listener);
+    return ()=>{
+        eventEmitter.off(event, listener);
+    };
+};
+
+const assignClient = (target, client)=>{
+    Object.defineProperty(target, '__client', {
+        // hide from enumeration
+        configurable: true,
+        enumerable: false,
+        get: ()=>client
+    });
+    return target;
+};
+
+class ClientNotPresentError extends BaseError {
+    constructor(){
+        super({
+            cause: null,
+            docsUrl: null,
+            name: 'ClientNotPresentError',
+            shortMessage: 'The client is not present in the target object.'
+        });
+    }
+}
+
+const getClient = (target)=>{
+    if (!Object.prototype.hasOwnProperty.call(target, '__client')) {
+        throw new ClientNotPresentError();
+    }
+    // @ts-expect-error - this was hidden from the public API
+    return target.__client;
+};
+
+const sendEmailOTP = async (client, { email })=>{
+    const core = getCore(client);
+    const apiClient = createApiClient(client);
+    const { verificationUUID } = await apiClient.createEmailVerification({
+        emailVerificationCreateRequest: {
+            email
+        },
+        environmentId: core.environmentId
+    });
+    return assignClient({
+        email,
+        verificationUUID
+    }, client);
+};
+
+const verifyOTP = async (otpVerification, { verificationToken })=>{
+    const client = getClient(otpVerification);
+    const core = getCore(client);
+    const apiClient = createApiClient(client);
+    const { user, minifiedJwt } = await apiClient.signInWithEmailVerification({
+        emailVerificationVerifyRequest: {
+            verificationToken,
+            verificationUUID: otpVerification.verificationUUID
+        },
+        environmentId: core.environmentId
+    });
+    core.state.set({
+        token: minifiedJwt,
+        user
+    });
+    return user;
+};
+
+exports.createDynamicClient = createDynamicClient;
+exports.logout = logout;
+exports.offEvent = offEvent;
+exports.onEvent = onEvent;
+exports.onceEvent = onceEvent;
+exports.sendEmailOTP = sendEmailOTP;
+exports.verifyOTP = verifyOTP;

package/index.esm.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";