@dfns/sdk 0.2.3-rc.1 → 0.2.4

package/types/signers.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../generated/signers/types"), exports);

package/types/wallets.d.ts

@@ -0,0 +1 @@
+export * from '../generated/wallets/types';

package/types/wallets.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../generated/wallets/types"), exports);

package/types/webhooks.d.ts

@@ -0,0 +1 @@
+export * from '../generated/webhooks/types';

package/types/webhooks.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../generated/webhooks/types"), exports);

package/utils/base64.d.ts

@@ -0,0 +1,3 @@
+import { Buffer } from 'buffer';
+export declare const toBase64Url: (buffer: string | Buffer) => string;
+export declare const fromBase64Url: (encoded: string) => Buffer;

package/utils/base64.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromBase64Url = exports.toBase64Url = void 0;
+const buffer_1 = require("buffer");
+const toBase64Url = (buffer) => {
+    if (typeof buffer === 'string') {
+        buffer = buffer_1.Buffer.from(buffer);
+    }
+    return buffer.toString('base64').replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
+};
+exports.toBase64Url = toBase64Url;
+const fromBase64Url = (encoded) => {
+    const padLength = 4 - (encoded.length % 4);
+    if (padLength < 4) {
+        encoded += '='.repeat(padLength);
+    }
+    encoded = encoded.replace(/\-/g, '+').replace(/_/g, '/');
+    return buffer_1.Buffer.from(encoded, 'base64');
+};
+exports.fromBase64Url = fromBase64Url;

package/utils/fetch.d.ts

@@ -0,0 +1,12 @@
+import { DfnsBaseApiOptions } from '../baseAuthApi';
+import { DfnsApiClientOptions } from '../dfnsApiClient';
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
+export type FetchOptions<T> = {
+    method: HttpMethod;
+    headers?: Record<string, string>;
+    body?: string | unknown;
+    apiOptions: T;
+};
+export type Fetch<T> = (resource: string | URL, options: FetchOptions<T>) => Promise<Response>;
+export declare const simpleFetch: Fetch<DfnsBaseApiOptions>;
+export declare const userActionFetch: Fetch<DfnsApiClientOptions>;

package/utils/fetch.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userActionFetch = exports.simpleFetch = void 0;
+const cross_fetch_1 = require("cross-fetch");
+const dfnsError_1 = require("../dfnsError");
+const baseAuthApi_1 = require("../baseAuthApi");
+const nonce_1 = require("./nonce");
+const fullUrl = (fetch) => {
+    return async (resource, options) => {
+        const { baseUrl } = options.apiOptions;
+        resource = new URL(resource, baseUrl);
+        return fetch(resource, options);
+    };
+};
+const jsonSerializer = (fetch) => {
+    return async (resource, options) => {
+        if (options.body) {
+            options.body = JSON.stringify(options.body);
+            options.headers = {
+                'content-type': 'application/json',
+                ...(options.headers ?? {}),
+            };
+        }
+        return fetch(resource, options);
+    };
+};
+const errorHandler = (fetch) => {
+    return async (resource, options) => {
+        const response = await fetch(resource, options);
+        if (response.ok) {
+            return response;
+        }
+        else {
+            const body = await response.json();
+            const message = body?.error?.message ?? body?.message;
+            throw new dfnsError_1.DfnsError(response.status, message, {
+                url: response.url,
+                headers: response.headers,
+                body,
+            });
+        }
+    };
+};
+const dfnsAuth = (fetch) => {
+    return async (resource, options) => {
+        const { appId, appSecret, authToken } = options.apiOptions;
+        const authorization = authToken
+            ? {
+                authorization: `Bearer ${authToken}`,
+            }
+            : {};
+        const dfnsAppSecret = appSecret
+            ? {
+                'x-dfns-appsecret': appSecret,
+            }
+            : {};
+        options.headers = {
+            'x-dfns-appid': appId,
+            'x-dfns-nonce': (0, nonce_1.generateNonce)(),
+            ...dfnsAppSecret,
+            ...authorization,
+            ...(options.headers ?? {}),
+        };
+        return fetch(resource, options);
+    };
+};
+const userAction = (fetch) => {
+    return async (resource, options) => {
+        if (options.method !== 'GET') {
+            const apiOptions = {
+                ...options.apiOptions,
+                baseUrl: options.apiOptions.baseAuthUrl || options.apiOptions.baseUrl,
+            };
+            const { challenge, challengeIdentifier, allowCredentials } = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+                userActionPayload: options.body ?? '',
+                userActionHttpMethod: options.method,
+                userActionHttpPath: resource.pathname,
+                userActionServerKind: apiOptions?.userActionServerKind || 'Api',
+            }, apiOptions);
+            const assertion = await apiOptions.signer.sign(challenge, allowCredentials);
+            const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge({
+                challengeIdentifier,
+                firstFactor: assertion,
+            }, apiOptions);
+            options.headers = {
+                'x-dfns-useraction': userAction,
+                ...(options.headers ?? {}),
+            };
+        }
+        return fetch(resource, options);
+    };
+};
+exports.simpleFetch = fullUrl(jsonSerializer(dfnsAuth(errorHandler(cross_fetch_1.fetch))));
+exports.userActionFetch = fullUrl(jsonSerializer(dfnsAuth(userAction(errorHandler(cross_fetch_1.fetch)))));

package/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './base64';
+export * from './fetch';
+export * from './nonce';
+export * from './url';

package/utils/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./base64"), exports);
+__exportStar(require("./fetch"), exports);
+__exportStar(require("./nonce"), exports);
+__exportStar(require("./url"), exports);

package/utils/nonce.d.ts

@@ -0,0 +1 @@
+export declare const generateNonce: () => string;

package/utils/nonce.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateNonce = void 0;
+const uuid_1 = require("uuid");
+const base64_1 = require("./base64");
+const generateNonce = () => {
+    return (0, base64_1.toBase64Url)(JSON.stringify({
+        uuid: (0, uuid_1.v4)(),
+        date: new Date().toISOString(),
+    }));
+};
+exports.generateNonce = generateNonce;

package/utils/url.d.ts

@@ -0,0 +1,4 @@
+export declare const buildPathAndQuery: (pattern: string, params: {
+    path: Record<string, any>;
+    query: Record<string, string | number | boolean | undefined>;
+}) => string;

package/utils/url.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPathAndQuery = void 0;
+const buildPathAndQuery = (pattern, params) => {
+    let path = pattern;
+    const paramsToReplace = (path.match(new RegExp(`:[a-zA-Z]+`, 'g')) || []).map((v) => v.replace(/^:/, ''));
+    for (const key of paramsToReplace) {
+        path = path.replace(new RegExp(`:${key}`, 'g'), encodeURIComponent(params.path[key]));
+    }
+    const query = Object.entries(params.query)
+        .filter(([_, value]) => !!value)
+        .map(([key, value]) => `${key}=${encodeURIComponent(value.toString())}`)
+        .join('&');
+    return query === '' ? path : `${path}?${query}`;
+};
+exports.buildPathAndQuery = buildPathAndQuery;

package/baseAuthApi.ts

@@ -1,236 +0,0 @@
-import {
-  FirstFactorAttestation,
-  RecoveryFactorAttestation,
-  SecondFactorAttestation,
-  UserRegistrationChallenge,
-} from './store'
-import {
-  AllowCredential,
-  CredentialKind,
-  FirstFactorAssertion,
-  RecoveryKeyAssertion,
-  SecondFactorAssertion,
-} from './signer'
-import { HttpMethod, simpleFetch } from './utils/fetch'
-
-export type DfnsBaseApiOptions = {
-  appId: string
-  appSecret?: string
-  authToken?: string
-  baseUrl: string
-}
-
-export type CreateUserActionChallengeRequest = {
-  userActionPayload: string
-  userActionHttpMethod: HttpMethod
-  userActionHttpPath: string
-  userActionServerKind: 'Api'
-}
-
-export type CredentialFactor = 'first' | 'second' | 'either'
-
-export type UserActionChallengeResponse = {
-  supportedCredentialKinds: {
-    kind: CredentialKind
-    factor: CredentialFactor
-    requiresSecondFactor: boolean
-  }[]
-  challenge: string
-  challengeIdentifier: string
-  externalAuthenticationUrl: string
-  allowCredentials: {
-    key: AllowCredential[]
-    webauthn: AllowCredential[]
-  }
-}
-
-export type SignUserActionChallengeRequest = {
-  challengeIdentifier: string
-  firstFactor: FirstFactorAssertion
-  secondFactor?: SecondFactorAssertion
-}
-
-export type UserActionResponse = {
-  userAction: string
-}
-
-export type CreateUserLoginChallengeRequest = {
-  username: string
-  orgId: string
-}
-
-export type UserLoginChallengeResponse = UserActionChallengeResponse
-
-export type CreateUserLoginRequest = SignUserActionChallengeRequest
-
-export type UserLoginResponse = {
-  token: string
-}
-
-export type CreateUserRegistrationChallengeRequest = {
-  orgId: string
-  username: string
-  registrationCode: string
-}
-
-export type UserRegistrationChallengeResponse = UserRegistrationChallenge
-
-export type CreateUserRegistrationRequest = {
-  firstFactorCredential: FirstFactorAttestation
-  secondFactorCredential?: SecondFactorAttestation
-  recoveryCredential?: RecoveryFactorAttestation
-}
-
-export type UserRegistrationResponse = {
-  credential: {
-    uuid: string
-    kind: CredentialKind
-    name: string
-  }
-  user: {
-    id: string
-    username: string
-    orgId: string
-  }
-}
-
-export type CreateUserRecoveryRequest = {
-  recovery: RecoveryKeyAssertion
-  newCredentials: {
-    firstFactorCredential: FirstFactorAttestation
-    secondFactorCredential?: SecondFactorAttestation
-    recoveryCredential?: RecoveryFactorAttestation
-  }
-}
-
-export type UserRecoveryResponse = UserRegistrationResponse
-
-export class BaseAuthApi {
-  /**
-   * Creates a user action challenge
-   */
-  static async createUserActionChallenge(
-    request: CreateUserActionChallengeRequest,
-    options: DfnsBaseApiOptions
-  ): Promise<UserActionChallengeResponse> {
-    const response = await simpleFetch('/auth/action/init', {
-      method: 'POST',
-      body: request,
-      apiOptions: options,
-    })
-
-    return response.json()
-  }
-
-  /**
-   * Sign a user action challenge
-   */
-  static async signUserActionChallenge(
-    request: SignUserActionChallengeRequest,
-    options: DfnsBaseApiOptions
-  ): Promise<UserActionResponse> {
-    const response = await simpleFetch('/auth/action', {
-      method: 'POST',
-      body: request,
-      apiOptions: options,
-    })
-
-    return response.json()
-  }
-
-  /**
-   * Initiates user login, by creating a challenge that will need to be signed by the user Credentials.
-   */
-  static async createUserLoginChallenge(
-    request: CreateUserLoginChallengeRequest,
-    options: DfnsBaseApiOptions
-  ): Promise<UserLoginChallengeResponse> {
-    const response = await simpleFetch('/auth/login/init', {
-      method: 'POST',
-      body: request,
-      apiOptions: options,
-    })
-
-    return response.json()
-  }
-
-  /**
-   * Completes user login by sending the signed login challenge.
-   */
-  static async createUserLogin(
-    request: CreateUserLoginRequest,
-    options: DfnsBaseApiOptions
-  ): Promise<UserLoginResponse> {
-    const response = await simpleFetch('/auth/login', {
-      method: 'POST',
-      body: request,
-      apiOptions: options,
-    })
-
-    return response.json()
-  }
-  /**
-   * Completes user logout by sending the user auth token.
-   */
-  static async userLogout(
-    options: DfnsBaseApiOptions
-  ): Promise<void> {
-    if (!options.authToken) {
-      throw new Error('authToken is required')
-    }
-    const response = await simpleFetch('/auth/logout', {
-      method: 'PUT',
-      apiOptions: options,
-    })
-
-    return response.json()
-  }
-
-  /**
-   * Initiates Registration by creating a challenge that will need to be signed by a new set of Credentials.
-   */
-  static async createUserRegistrationChallenge(
-    request: CreateUserRegistrationChallengeRequest,
-    options: DfnsBaseApiOptions
-  ): Promise<UserRegistrationChallengeResponse> {
-    const response = await simpleFetch('/auth/registration/init', {
-      method: 'POST',
-      body: request,
-      apiOptions: options,
-    })
-
-    return response.json()
-  }
-
-  /**
-   * Completes Registration by sending the signed registration challenge, containing the new Credential identity created.
-   */
-  static async createUserRegistration(
-    request: CreateUserRegistrationRequest,
-    options: DfnsBaseApiOptions
-  ): Promise<UserRegistrationResponse> {
-    const response = await simpleFetch('/auth/registration', {
-      method: 'POST',
-      body: request,
-      apiOptions: options,
-    })
-
-    return response.json()
-  }
-
-  /**
-   * Completes Recovery by sending the signed recovery challenge, containing the new Credential identity created.
-   */
-  async createUserRecovery(
-    request: CreateUserRecoveryRequest,
-    options: DfnsBaseApiOptions
-  ): Promise<UserRecoveryResponse> {
-    const response = await simpleFetch('/auth/recover/user', {
-      method: 'POST',
-      body: request,
-      apiOptions: options,
-    })
-
-    return response.json()
-  }
-}

package/codegen/Assets/AssetsClient.ts

@@ -1,137 +0,0 @@
-import { DfnsApiClientOptions } from '../../dfnsApiClient'
-import { simpleFetch, userActionFetch } from '../../utils/fetch'
-import { buildPathAndQuery } from '../../utils/url'
-import * as T from './types'
-
-export class AssetsClient {
-  constructor(private apiOptions: DfnsApiClientOptions) {}
-
-  async initiatePayment(
-    request: T.InitiatePaymentRequest
-  ): Promise<T.InitiatePaymentResponse> {
-    const path = buildPathAndQuery(
-      '/assets/asset-accounts/:assetAccountId/payments',
-      {
-        path: { assetAccountId: request.assetAccountId },
-        query: {},
-      }
-    )
-
-    const response = await userActionFetch(path, {
-      method: 'POST',
-      body: request.body,
-      apiOptions: this.apiOptions,
-    })
-
-    return response.json()
-  }
-
-  async getPaymentById(
-    request: T.GetPaymentByIdRequest
-  ): Promise<T.GetPaymentByIdResponse> {
-    const path = buildPathAndQuery(
-      '/assets/asset-accounts/:assetAccountId/payments/:paymentId',
-      {
-        path: {
-          assetAccountId: request.assetAccountId,
-          paymentId: request.paymentId,
-        },
-        query: {},
-      }
-    )
-
-    const response = await simpleFetch(path, {
-      method: 'GET',
-      apiOptions: this.apiOptions,
-    })
-
-    return response.json()
-  }
-
-  async listPayments(
-    request: T.ListPaymentsRequest
-  ): Promise<T.ListPaymentsResponse> {
-    const path = buildPathAndQuery(
-      '/assets/asset-accounts/:assetAccountId/payments',
-      {
-        path: { assetAccountId: request.assetAccountId },
-        query: {},
-      }
-    )
-
-    const response = await simpleFetch(path, {
-      method: 'GET',
-      apiOptions: this.apiOptions,
-    })
-
-    return response.json()
-  }
-
-  async createAssetAccount(
-    request: T.CreateAssetAccountRequest
-  ): Promise<T.CreateAssetAccountResponse> {
-    const path = buildPathAndQuery('/assets/asset-accounts', {
-      path: {},
-      query: {},
-    })
-
-    const response = await userActionFetch(path, {
-      method: 'POST',
-      body: request.body,
-      apiOptions: this.apiOptions,
-    })
-
-    return response.json()
-  }
-
-  async getAssetAccountById(
-    request: T.GetAssetAccountByIdRequest
-  ): Promise<T.GetAssetAccountByIdResponse> {
-    const path = buildPathAndQuery('/assets/asset-accounts/:assetAccountId', {
-      path: { assetAccountId: request.assetAccountId },
-      query: {},
-    })
-
-    const response = await simpleFetch(path, {
-      method: 'GET',
-      apiOptions: this.apiOptions,
-    })
-
-    return response.json()
-  }
-
-  async listAssetAccounts(
-    request: T.ListAssetAccountsRequest
-  ): Promise<T.ListAssetAccountsResponse> {
-    const path = buildPathAndQuery('/assets/asset-accounts', {
-      path: {},
-      query: request.query ?? {},
-    })
-
-    const response = await simpleFetch(path, {
-      method: 'GET',
-      apiOptions: this.apiOptions,
-    })
-
-    return response.json()
-  }
-
-  async getAssetAccountBalanceById(
-    request: T.GetAssetAccountBalanceByIdRequest
-  ): Promise<T.GetAssetAccountBalanceByIdResponse> {
-    const path = buildPathAndQuery(
-      '/assets/asset-accounts/:assetAccountId/balance',
-      {
-        path: { assetAccountId: request.assetAccountId },
-        query: {},
-      }
-    )
-
-    const response = await simpleFetch(path, {
-      method: 'GET',
-      apiOptions: this.apiOptions,
-    })
-
-    return response.json()
-  }
-}