gdc-sdk-client-ts 1.1.0 → 1.2.0

package/README.md

@@ -264,6 +264,31 @@ const sdk = useMemo(() => {
 }, []);
 ```
 
+### API Config Discovery For Frontend Forms
+
+When a provider API publishes `/.well-known/api-config.json`, the SDK can fetch it and return the form fields in a UI-friendly shape.
+
+```typescript
+const apiConfig = await sdk.fetchWellKnownApiConfig('http://34.8.62.21');
+// or: await sdk.fetchWellKnownApiConfig('did:web:api.example.com');
+
+console.log(apiConfig.language); // "es"
+console.log(apiConfig.fields);
+// [
+//   { code: 'section', display: 'Departamento o sección: ...' },
+//   { code: 'coverage_insurer', display: 'Identificador o nombre de la aseguradora' },
+// ]
+
+const supportedFields = await sdk.fetchSupportedFields('http://34.8.62.21');
+```
+
+The resolved object includes:
+
+- `language`
+- `supportedFields` as the raw `code -> display` map
+- `fields` as `{ code, display }[]` ready for selects/tables
+- `endpoints` with backend route templates such as `create`, `createResponse`, `upload`, and `uploadResponse`
+
 ### Constructing the Provider DID
 
 Before initializing a session, your application must determine the canonical DID of the provider (the organization or host) the user wants to connect to. The SDK supports two scenarios:

package/dist/ClientSDK.d.ts

@@ -1,7 +1,7 @@
 import { IWallet } from 'gdc-common-utils-ts/interfaces/IWallet';
 import { IVaultRepository } from './interfaces/IVaultRepository';
 import { ProfileManager } from './ProfileManager';
-import { SdkConfig } from './interfaces/others';
+import { SdkConfig, WellKnownApiConfigResolved, WellKnownApiSupportedField } from './interfaces/others';
 import { DidDocument } from 'gdc-common-utils-ts/models/did';
 import { IVerifier } from './interfaces/ITrustRegistry';
 import { AppInfo } from './interfaces/others';
@@ -31,6 +31,10 @@ export declare class ClientSDK {
     currentSession: ProfileManager | null;
     profileRegistry: ProfileRegistry | null;
     get operationMode(): string;
+    private resolveApiConfigBaseUrl;
+    private normalizeWellKnownApiConfig;
+    fetchWellKnownApiConfig(source: string): Promise<WellKnownApiConfigResolved>;
+    fetchSupportedFields(source: string): Promise<WellKnownApiSupportedField[]>;
     /**
      * Dynamically adds a mock DID Document to the SDK's configuration for DEMO mode.
      * This allows the UI to inject mock data at runtime to bypass network failures.

package/dist/ClientSDK.js

@@ -11,6 +11,55 @@ export class ClientSDK {
     get operationMode() {
         return this.sdkConfig.api.operationMode;
     }
+    resolveApiConfigBaseUrl(source) {
+        const normalized = String(source || '').trim();
+        if (!normalized) {
+            throw new Error('fetchWellKnownApiConfig requires a provider did:web or a base URL.');
+        }
+        if (normalized.startsWith('did:web:')) {
+            return getBaseUrlFromDidWeb(normalizeDidWeb(normalized));
+        }
+        return normalized.endsWith('/') ? normalized : `${normalized}/`;
+    }
+    normalizeWellKnownApiConfig(payload) {
+        const raw = (payload && typeof payload === 'object') ? payload : {};
+        const supportedFieldsSource = raw.supportedFields && typeof raw.supportedFields === 'object'
+            ? raw.supportedFields
+            : {};
+        const endpointsSource = raw.endpoints && typeof raw.endpoints === 'object'
+            ? raw.endpoints
+            : {};
+        const supportedFields = Object.fromEntries(Object.entries(supportedFieldsSource)
+            .filter(([key, value]) => String(key || '').trim() && String(value || '').trim())
+            .map(([key, value]) => [String(key).trim(), String(value).trim()]));
+        const endpoints = Object.fromEntries(Object.entries(endpointsSource)
+            .filter(([key, value]) => String(key || '').trim() && String(value || '').trim())
+            .map(([key, value]) => [String(key).trim(), String(value).trim()]));
+        const fields = Object.entries(supportedFields).map(([code, display]) => ({
+            code,
+            display,
+        }));
+        return {
+            language: String(raw.language || '').trim(),
+            supportedFields,
+            endpoints,
+            fields,
+        };
+    }
+    async fetchWellKnownApiConfig(source) {
+        const baseUrl = this.resolveApiConfigBaseUrl(source);
+        const url = new URL('.well-known/api-config.json', baseUrl).href;
+        const response = await this._fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch API config from ${url}`);
+        }
+        const payload = await response.json();
+        return this.normalizeWellKnownApiConfig(payload);
+    }
+    async fetchSupportedFields(source) {
+        const config = await this.fetchWellKnownApiConfig(source);
+        return config.fields;
+    }
     /**
      * Dynamically adds a mock DID Document to the SDK's configuration for DEMO mode.
      * This allows the UI to inject mock data at runtime to bypass network failures.

package/dist/interfaces/others.d.ts

@@ -44,6 +44,18 @@ export interface IApiConfig {
         delayMs: number;
     } | undefined;
 }
+export interface WellKnownApiSupportedField {
+    code: string;
+    display: string;
+}
+export interface WellKnownApiConfigDocument {
+    language: string;
+    supportedFields: Record<string, string>;
+    endpoints: Record<string, string>;
+}
+export interface WellKnownApiConfigResolved extends WellKnownApiConfigDocument {
+    fields: WellKnownApiSupportedField[];
+}
 /**
  * Defines the set of optional parameters for enabling the SDK's mock mode.
  * This allows for testing the SDK's logic without a live backend.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-sdk-client-ts",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "private": false,
   "type": "module",
   "dependencies": {