@dfns/sdk 0.1.0-alpha.1

package/dfnsDelegatedApiClient.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DfnsDelegatedApiClient = void 0;
+const ApiKeys_1 = require("./codegen/ApiKeys");
+const Assets_1 = require("./codegen/Assets");
+const Callbacks_1 = require("./codegen/Callbacks");
+const Permissions_1 = require("./codegen/Permissions");
+const PolicyExecution_1 = require("./codegen/PolicyExecution");
+const PolicyManagement_1 = require("./codegen/PolicyManagement");
+const PublicKeys_1 = require("./codegen/PublicKeys");
+const Wallets_1 = require("./codegen/Wallets");
+class DfnsDelegatedApiClient {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    get apiKeys() {
+        return new ApiKeys_1.DelegatedApiKeysClient(this.apiOptions);
+    }
+    get assets() {
+        return new Assets_1.DelegatedAssetsClient(this.apiOptions);
+    }
+    get callbacks() {
+        return new Callbacks_1.DelegatedCallbacksClient(this.apiOptions);
+    }
+    get permissions() {
+        return new Permissions_1.DelegatedPermissionsClient(this.apiOptions);
+    }
+    get policyExecution() {
+        return new PolicyExecution_1.DelegatedPolicyExecutionClient(this.apiOptions);
+    }
+    get policyManagement() {
+        return new PolicyManagement_1.DelegatedPolicyManagementClient(this.apiOptions);
+    }
+    get publicKeys() {
+        return new PublicKeys_1.DelegatedPublicKeysClient(this.apiOptions);
+    }
+    get wallets() {
+        return new Wallets_1.DelegatedWalletsClient(this.apiOptions);
+    }
+}
+exports.DfnsDelegatedApiClient = DfnsDelegatedApiClient;

package/dfnsError.d.ts

@@ -0,0 +1,5 @@
+export declare class DfnsError extends Error {
+    httpStatus: number;
+    context?: unknown;
+    constructor(httpStatus: number, message: string, context?: unknown);
+}

package/dfnsError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DfnsError = void 0;
+class DfnsError extends Error {
+    constructor(httpStatus, message, context) {
+        super(message);
+        this.httpStatus = httpStatus;
+        this.context = context;
+    }
+}
+exports.DfnsError = DfnsError;

package/index.d.ts

@@ -0,0 +1,3 @@
+export * from './dfnsApiClient';
+export * from './dfnsAuthenticator';
+export * from './dfnsError';

package/index.js

@@ -0,0 +1,19 @@
+"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("./dfnsApiClient"), exports);
+__exportStar(require("./dfnsAuthenticator"), exports);
+__exportStar(require("./dfnsError"), exports);

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@dfns/sdk",
+  "version": "0.1.0-alpha.1",
+  "dependencies": {
+    "buffer": "^6.0.3",
+    "cross-fetch": "^3.1.6",
+    "uuid": "9.0.0"
+  },
+  "main": "./index.js",
+  "types": "./index.d.ts"
+}

package/signer.d.ts

@@ -0,0 +1,47 @@
+export type CredentialTransport = 'usb' | 'nfc' | 'ble' | 'internal';
+export type AllowCredential = {
+    type: 'public-key';
+    id: string;
+    transports: CredentialTransport[];
+};
+export type KeyAssertion = {
+    credId: string;
+    clientData: string;
+    signature: string;
+};
+export type Fido2Assertion = {
+    credId: string;
+    clientData: string;
+    authenticatorData: string;
+    signature: string;
+    userHandle?: string;
+};
+export type FirstFactorAssertion = {
+    kind: 'Key';
+    credentialAssertion: KeyAssertion;
+} | {
+    kind: 'Fido2';
+    credentialAssertion: Fido2Assertion;
+} | {
+    kind: 'Password';
+    password: string;
+};
+export type SecondFactorAssertion = {
+    kind: 'Key';
+    credentialAssertion: KeyAssertion;
+} | {
+    kind: 'Fido2';
+    credentialAssertion: Fido2Assertion;
+} | {
+    kind: 'Totp';
+    otpCode: string;
+};
+export interface Signer {
+    sign(challenge: string, allowCredentials: {
+        key: AllowCredential[];
+        webauthn: AllowCredential[];
+    }): Promise<{
+        firstFactor: FirstFactorAssertion;
+        secondFactor?: SecondFactorAssertion;
+    }>;
+}

package/signer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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,89 @@
+"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) => {
+        var _a;
+        if (options.body) {
+            options.body = JSON.stringify(options.body);
+            options.headers = {
+                'content-type': 'application/json',
+                ...((_a = options.headers) !== null && _a !== void 0 ? _a : {}),
+            };
+        }
+        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();
+            throw new dfnsError_1.DfnsError(response.status, body.message, body);
+        }
+    };
+};
+const dfnsAuth = (fetch) => {
+    return async (resource, options) => {
+        var _a;
+        const { appId, appSecret, accessToken } = options.apiOptions;
+        const authorization = accessToken
+            ? {
+                authorization: `Bearer ${accessToken}`,
+            }
+            : {};
+        const dfnsAppSecret = appSecret
+            ? {
+                'x-dfns-appsecret': appSecret,
+            }
+            : {};
+        options.headers = {
+            'x-dfns-appid': appId,
+            'x-dfns-nonce': (0, nonce_1.generateNonce)(),
+            ...dfnsAppSecret,
+            ...authorization,
+            ...((_a = options.headers) !== null && _a !== void 0 ? _a : {}),
+        };
+        return fetch(resource, options);
+    };
+};
+const userAction = (fetch) => {
+    return async (resource, options) => {
+        var _a, _b;
+        if (options.method !== 'GET') {
+            const { challenge, challengeIdentifier, allowCredentials } = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+                userActionPayload: (_a = options.body) !== null && _a !== void 0 ? _a : '',
+                userActionHttpMethod: options.method,
+                userActionHttpPath: resource.pathname,
+                userActionServerKind: 'Api',
+            }, options.apiOptions);
+            const { signer } = options.apiOptions;
+            const assertions = await signer.sign(challenge, allowCredentials);
+            const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge({
+                challengeIdentifier,
+                ...assertions,
+            }, options.apiOptions);
+            options.headers = {
+                'x-dfns-useraction': userAction,
+                ...((_b = options.headers) !== null && _b !== void 0 ? _b : {}),
+            };
+        }
+        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/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, string>;
+    query: Record<string, string | number | boolean | undefined>;
+}) => string;

package/utils/url.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPathAndQuery = void 0;
+const buildPathAndQuery = (pattern, params) => {
+    let path = pattern;
+    for (const key in params.path) {
+        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;