keycloak-api 1.0.0 → 1.0.1

package/README.md

@@ -0,0 +1,79 @@
+# keycloak-api
+
+Auto-generated, fully typed client for the [Keycloak Admin and Account REST APIs](https://www.keycloak.org/docs-api/latest/rest-api/index.html).
+
+## Features
+
+- **Fully typed** - every endpoint, parameter and response is generated from the official OpenAPI specs
+- **Admin and Account APIs** - separate clients for the two Keycloak surfaces
+- **Tree-shakable** - only the operations you import end up in your bundle
+- **Runtime agnostic** - uses the global `fetch`, or bring your own implementation
+
+## Installation
+
+```bash
+npm install keycloak-api
+```
+
+## Quick Start
+
+Keycloak is self-hosted, so both clients require the `baseUrl` of your server. Endpoints are addressed
+as `"<METHOD> <path>"`.
+
+### Admin API
+
+```ts
+import { KeycloakAdminApi } from "keycloak-api";
+
+const admin = new KeycloakAdminApi({
+  baseUrl: "https://keycloak.example.com",
+  token: process.env.KEYCLOAK_TOKEN ?? null,
+});
+
+const realms = await admin.request("GET /admin/realms", {});
+const realm = await admin.request("GET /admin/realms/{realm}", {
+  pathParams: { realm: "master" },
+});
+```
+
+### Account API
+
+The Account API is scoped to a single realm, passed at construction time.
+
+```ts
+import { KeycloakAccountApi } from "keycloak-api";
+
+const account = new KeycloakAccountApi({
+  baseUrl: "https://keycloak.example.com",
+  realm: "master",
+  token: process.env.KEYCLOAK_TOKEN ?? null,
+});
+
+const me = await account.request("GET /account/", {});
+```
+
+### Custom fetch
+
+```ts
+const admin = new KeycloakAdminApi({
+  baseUrl: "https://keycloak.example.com",
+  token: process.env.KEYCLOAK_TOKEN ?? null,
+  fetch: myFetchImplementation,
+});
+```
+
+## Entrypoints
+
+| Import | Contents |
+| --- | --- |
+| `keycloak-api` | both client classes, plus admin/account operations, schemas and types |
+| `keycloak-api/admin/components` | admin operations grouped by tag and by path |
+| `keycloak-api/admin/schemas` | Zod schemas for admin operations |
+| `keycloak-api/admin/types` | TypeScript types for admin operations |
+| `keycloak-api/account/components` | account operations grouped by tag and by path |
+| `keycloak-api/account/schemas` | Zod schemas for account operations |
+| `keycloak-api/account/types` | TypeScript types for account operations |
+
+## License
+
+ISC

package/dist/account/components.cjs

@@ -1,392 +1,273 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
-function notEmpty(value) {
-    return value !== null && value !== undefined;
-}
-function compactObject(obj) {
-    return Object.fromEntries(Object.entries(obj).filter(([, value])=>notEmpty(value)));
-}
-
-async function client({ url, method, body, headers, pathParams, queryParams, signal, baseUrl = "", token = null, fetchImpl = fetch }) {
-    try {
-        const requestHeaders = compactObject({
-            "Content-Type": "application/json",
-            Authorization: token ? `Bearer ${token}` : undefined,
-            Accept: "application/json",
-            ...headers
-        });
-        /**
-		 * As the fetch API is being used, when multipart/form-data is specified
-		 * the Content-Type header must be deleted so that the browser can set
-		 * the correct boundary.
-		 * https://developer.mozilla.org/en-US/docs/Web/API/FormData/Using_FormData_Objects#sending_files_using_a_formdata_object
-		 */ if (requestHeaders["Content-Type"]?.toLowerCase().includes("multipart/form-data")) {
-            delete requestHeaders["Content-Type"];
-        }
-        const payload = body instanceof FormData ? body : requestHeaders["Content-Type"] === "application/json" ? JSON.stringify(body) : body;
-        const fullUrl = `${baseUrl}${resolveUrl(url, queryParams, pathParams)}`;
-        const response = await fetchImpl(fullUrl, {
-            signal,
-            method: method.toUpperCase(),
-            body: payload,
-            headers: requestHeaders
-        });
-        if (!response.ok) {
-            let error;
-            try {
-                error = await response.json();
-            } catch (e) {
-                error = {
-                    status: "unknown",
-                    payload: e instanceof Error ? `Unexpected error (${e.message})` : "Unexpected error"
-                };
-            }
-            throw error;
-        }
-        if (response.headers?.get("content-type")?.includes("json")) {
-            return await response.json();
-        } else {
-            // if it is not a json response, assume it is a blob and cast it to TData
-            return await response.text();
-        }
-    } catch (e) {
-        const errorObject = {
-            name: "unknown",
-            message: e instanceof Error ? `Network error (${e.message})` : "Network error",
-            stack: e
-        };
-        throw errorObject;
-    }
-}
-const resolveUrl = (url, queryParams = {}, pathParams = {})=>{
-    let query = new URLSearchParams(queryParams).toString();
-    if (query) query = `?${query}`;
-    return url.replace(/\{\w*\}/g, (key)=>pathParams[key.slice(1, -1)] ?? "") + query;
-};
+var fetcher = require('../fetcher-aq8636lm.cjs');
 
 /**
- * @summary Get account
  * @description Get user details for currently logged in user
- * @link /account/
- */ async function getAccount({ queryParams, config } = {}) {
-    const { client: request = client, ...requestConfig } = config ?? {};
+ * @summary Get account
+ * {@link /account/}
+ */ async function getAccount({ queryParams, config = {} }) {
+    const { client: request = fetcher.client, ...requestConfig } = config;
     const data = await request({
         method: "GET",
         url: `/account/`,
         queryParams,
-        ...requestConfig,
-        headers: {
-            ...requestConfig.headers
-        }
+        ...requestConfig
     });
     return data;
 }
 /**
  * @summary Update account
- * @link /account/
- */ async function updateAccount({ body, config } = {}) {
-    const { client: request = client, ...requestConfig } = config ?? {};
+ * {@link /account/}
+ */ async function updateAccount({ body, config = {} }) {
+    const { client: request = fetcher.client, ...requestConfig } = config;
     const data = await request({
         method: "POST",
         url: `/account/`,
-        body: body,
-        ...requestConfig,
-        headers: {
-            ...requestConfig.headers
-        }
+        body,
+        ...requestConfig
     });
     return data;
 }
 /**
  * @summary Get applications
- * @link /account/applications
- */ async function getApplications({ queryParams, config } = {}) {
-    const { client: request = client, ...requestConfig } = config ?? {};
+ * {@link /account/applications}
+ */ async function getApplications({ queryParams, config = {} }) {
+    const { client: request = fetcher.client, ...requestConfig } = config;
     const data = await request({
         method: "GET",
         url: `/account/applications`,
         queryParams,
-        ...requestConfig,
-        headers: {
-            ...requestConfig.headers
-        }
+        ...requestConfig
     });
     return data;
 }
 /**
  * @summary Get consent
- * @link /account/applications/{clientId}/consent
- */ async function getConsent({ pathParams, config } = {}) {
-    const { client: request = client, ...requestConfig } = config ?? {};
-    if (!pathParams.clientId) {
+ * {@link /account/applications/:clientId/consent}
+ */ async function getConsent({ pathParams: { clientId }, config = {} }) {
+    const { client: request = fetcher.client, ...requestConfig } = config;
+    if (!clientId) {
         throw new Error(`Missing required path parameter: clientId`);
     }
     const data = await request({
         method: "GET",
-        url: `/account/applications/${pathParams.clientId}/consent`,
-        ...requestConfig,
-        headers: {
-            ...requestConfig.headers
-        }
+        url: `/account/applications/${clientId}/consent`,
+        ...requestConfig
     });
     return data;
 }
 /**
  * @summary Create consent
- * @link /account/applications/{clientId}/consent
- */ async function createConsent({ pathParams, config } = {}) {
-    const { client: request = client, ...requestConfig } = config ?? {};
-    if (!pathParams.clientId) {
+ * {@link /account/applications/:clientId/consent}
+ */ async function createConsent({ pathParams: { clientId }, config = {} }) {
+    const { client: request = fetcher.client, ...requestConfig } = config;
+    if (!clientId) {
         throw new Error(`Missing required path parameter: clientId`);
     }
     const data = await request({
         method: "POST",
-        url: `/account/applications/${pathParams.clientId}/consent`,
-        ...requestConfig,
-        headers: {
-            ...requestConfig.headers
-        }
+        url: `/account/applications/${clientId}/consent`,
+        ...requestConfig
     });
     return data;
 }
 /**
  * @summary Update consent
- * @link /account/applications/{clientId}/consent
- */ async function updateConsent({ pathParams, config } = {}) {
-    const { client: request = client, ...requestConfig } = config ?? {};
-    if (!pathParams.clientId) {
+ * {@link /account/applications/:clientId/consent}
+ */ async function updateConsent({ pathParams: { clientId }, config = {} }) {
+    const { client: request = fetcher.client, ...requestConfig } = config;
+    if (!clientId) {
         throw new Error(`Missing required path parameter: clientId`);
     }
     const data = await request({
         method: "PUT",
-        url: `/account/applications/${pathParams.clientId}/consent`,
-        ...requestConfig,
-        headers: {
-            ...requestConfig.headers
-        }
+        url: `/account/applications/${clientId}/consent`,
+        ...requestConfig
     });
     return data;
 }
 /**
  * @summary Delete consent
- * @link /account/applications/{clientId}/consent
- */ async function deleteConsent({ pathParams, config } = {}) {
-    const { client: request = client, ...requestConfig } = config ?? {};
-    if (!pathParams.clientId) {
+ * {@link /account/applications/:clientId/consent}
+ */ async function deleteConsent({ pathParams: { clientId }, config = {} }) {
+    const { client: request = fetcher.client, ...requestConfig } = config;
+    if (!clientId) {
         throw new Error(`Missing required path parameter: clientId`);
     }
     const data = await request({
         method: "DELETE",
-        url: `/account/applications/${pathParams.clientId}/consent`,
-        ...requestConfig,
-        headers: {
-            ...requestConfig.headers
-        }
+        url: `/account/applications/${clientId}/consent`,
+        ...requestConfig
     });
     return data;
 }
 /**
- * @summary Get credentials
  * @description Get credentials for currently logged in user
- * @link /account/credentials
- */ async function getCredentials({ queryParams, config } = {}) {
-    const { client: request = client, ...requestConfig } = config ?? {};
+ * @summary Get credentials
+ * {@link /account/credentials}
+ */ async function getCredentials({ queryParams, config = {} }) {
+    const { client: request = fetcher.client, ...requestConfig } = config;
     const data = await request({
         method: "GET",
         url: `/account/credentials`,
         queryParams,
-        ...requestConfig,
-        headers: {
-            ...requestConfig.headers
-        }
+        ...requestConfig
     });
     return data;
 }
 /**
  * @summary Delete the credential
- * @link /account/credentials/{credentialId}
- */ async function deleteCredential({ pathParams, config } = {}) {
-    const { client: request = client, ...requestConfig } = config ?? {};
-    if (!pathParams.credentialId) {
+ * {@link /account/credentials/:credentialId}
+ */ async function deleteCredential({ pathParams: { credentialId }, config = {} }) {
+    const { client: request = fetcher.client, ...requestConfig } = config;
+    if (!credentialId) {
         throw new Error(`Missing required path parameter: credentialId`);
     }
     const data = await request({
         method: "DELETE",
-        url: `/account/credentials/${pathParams.credentialId}`,
-        ...requestConfig,
-        headers: {
-            ...requestConfig.headers
-        }
+        url: `/account/credentials/${credentialId}`,
+        ...requestConfig
     });
     return data;
 }
 /**
  * @summary Update a user label of specified credential of current user
- * @link /account/credentials/{credentialId}/label
- */ async function updateCredentialLabel({ pathParams, body, config } = {}) {
-    const { client: request = client, ...requestConfig } = config ?? {};
-    if (!pathParams.credentialId) {
+ * {@link /account/credentials/:credentialId/label}
+ */ async function updateCredentialLabel({ pathParams: { credentialId }, body, config = {} }) {
+    const { client: request = fetcher.client, ...requestConfig } = config;
+    if (!credentialId) {
         throw new Error(`Missing required path parameter: credentialId`);
     }
     const data = await request({
         method: "PUT",
-        url: `/account/credentials/${pathParams.credentialId}/label`,
-        body: body,
-        ...requestConfig,
-        headers: {
-            ...requestConfig.headers
-        }
+        url: `/account/credentials/${credentialId}/label`,
+        body,
+        ...requestConfig
     });
     return data;
 }
 /**
- * @summary Get sessions
  * @description Get sessions for currently logged in user
- * @link /account/sessions
- */ async function getSessions({ config } = {}) {
-    const { client: request = client, ...requestConfig } = config ?? {};
+ * @summary Get sessions
+ * {@link /account/sessions}
+ */ async function getSessions({ config = {} }) {
+    const { client: request = fetcher.client, ...requestConfig } = config;
     const data = await request({
         method: "GET",
         url: `/account/sessions`,
-        ...requestConfig,
-        headers: {
-            ...requestConfig.headers
-        }
+        ...requestConfig
     });
     return data;
 }
 /**
  * @summary Delete current session
- * @link /account/sessions
- */ async function deleteCurrentSession({ config } = {}) {
-    const { client: request = client, ...requestConfig } = config ?? {};
+ * {@link /account/sessions}
+ */ async function deleteCurrentSession({ config = {} }) {
+    const { client: request = fetcher.client, ...requestConfig } = config;
     const data = await request({
         method: "DELETE",
         url: `/account/sessions`,
-        ...requestConfig,
-        headers: {
-            ...requestConfig.headers
-        }
+        ...requestConfig
     });
     return data;
 }
 /**
- * @summary Get devices
  * @description Get devices for currently logged in user
- * @link /account/sessions/devices
- */ async function getDevices({ config } = {}) {
-    const { client: request = client, ...requestConfig } = config ?? {};
+ * @summary Get devices
+ * {@link /account/sessions/devices}
+ */ async function getDevices({ config = {} }) {
+    const { client: request = fetcher.client, ...requestConfig } = config;
     const data = await request({
         method: "GET",
         url: `/account/sessions/devices`,
-        ...requestConfig,
-        headers: {
-            ...requestConfig.headers
-        }
+        ...requestConfig
     });
     return data;
 }
 /**
  * @summary Delete the session
- * @link /account/sessions/{sessionId}
- */ async function deleteSession({ pathParams, config } = {}) {
-    const { client: request = client, ...requestConfig } = config ?? {};
-    if (!pathParams.sessionId) {
+ * {@link /account/sessions/:sessionId}
+ */ async function deleteSession({ pathParams: { sessionId }, config = {} }) {
+    const { client: request = fetcher.client, ...requestConfig } = config;
+    if (!sessionId) {
         throw new Error(`Missing required path parameter: sessionId`);
     }
     const data = await request({
         method: "DELETE",
-        url: `/account/sessions/${pathParams.sessionId}`,
-        ...requestConfig,
-        headers: {
-            ...requestConfig.headers
-        }
+        url: `/account/sessions/${sessionId}`,
+        ...requestConfig
     });
     return data;
 }
 /**
- * @summary Get linked accounts
  * @description Get linked accounts for currently logged in user
- * @link /account/linked-accounts
- */ async function getLinkedAccounts({ config } = {}) {
-    const { client: request = client, ...requestConfig } = config ?? {};
+ * @summary Get linked accounts
+ * {@link /account/linked-accounts}
+ */ async function getLinkedAccounts({ config = {} }) {
+    const { client: request = fetcher.client, ...requestConfig } = config;
     const data = await request({
         method: "GET",
         url: `/account/linked-accounts`,
-        ...requestConfig,
-        headers: {
-            ...requestConfig.headers
-        }
+        ...requestConfig
     });
     return data;
 }
 /**
- * @summary Build account linking URI
  * @description Build account linking URI
- * @link /account/linked-accounts/{providerId}
- */ async function buildLinkingUri({ pathParams, queryParams, config } = {}) {
-    const { client: request = client, ...requestConfig } = config ?? {};
-    if (!pathParams.providerId) {
+ * @summary Build account linking URI
+ * {@link /account/linked-accounts/:providerId}
+ */ async function buildLinkingUri({ pathParams: { providerId }, queryParams, config = {} }) {
+    const { client: request = fetcher.client, ...requestConfig } = config;
+    if (!providerId) {
         throw new Error(`Missing required path parameter: providerId`);
     }
     const data = await request({
         method: "GET",
-        url: `/account/linked-accounts/${pathParams.providerId}`,
+        url: `/account/linked-accounts/${providerId}`,
         queryParams,
-        ...requestConfig,
-        headers: {
-            ...requestConfig.headers
-        }
+        ...requestConfig
     });
     return data;
 }
 /**
  * @summary Delete the linked provider
- * @link /account/linked-accounts/{providerId}
- */ async function deleteLinkedProvider({ pathParams, config } = {}) {
-    const { client: request = client, ...requestConfig } = config ?? {};
-    if (!pathParams.providerId) {
+ * {@link /account/linked-accounts/:providerId}
+ */ async function deleteLinkedProvider({ pathParams: { providerId }, config = {} }) {
+    const { client: request = fetcher.client, ...requestConfig } = config;
+    if (!providerId) {
         throw new Error(`Missing required path parameter: providerId`);
     }
     const data = await request({
         method: "DELETE",
-        url: `/account/linked-accounts/${pathParams.providerId}`,
-        ...requestConfig,
-        headers: {
-            ...requestConfig.headers
-        }
+        url: `/account/linked-accounts/${providerId}`,
+        ...requestConfig
     });
     return data;
 }
 /**
  * @summary Get groups that this user is a member of
- * @link /account/groups
- */ async function getGroups({ queryParams, config } = {}) {
-    const { client: request = client, ...requestConfig } = config ?? {};
+ * {@link /account/groups}
+ */ async function getGroups({ queryParams, config = {} }) {
+    const { client: request = fetcher.client, ...requestConfig } = config;
     const data = await request({
         method: "GET",
         url: `/account/groups`,
         queryParams,
-        ...requestConfig,
-        headers: {
-            ...requestConfig.headers
-        }
+        ...requestConfig
     });
     return data;
 }
 /**
- * @summary Get organizations
  * @description Get organizations for currently logged in user
- * @link /account/organizations
- */ async function getOrganizations({ config } = {}) {
-    const { client: request = client, ...requestConfig } = config ?? {};
+ * @summary Get organizations
+ * {@link /account/organizations}
+ */ async function getOrganizations({ config = {} }) {
+    const { client: request = fetcher.client, ...requestConfig } = config;
     const data = await request({
         method: "GET",
         url: `/account/organizations`,
-        ...requestConfig,
-        headers: {
-            ...requestConfig.headers
-        }
+        ...requestConfig
     });
     return data;
 }
@@ -412,7 +293,7 @@ const operationsByPath = {
     "GET /account/organizations": getOrganizations
 };
 const operationsByTag = {
-    "account": {
+    account: {
         getAccount,
         updateAccount,
         getApplications,
@@ -435,8 +316,8 @@ const operationsByTag = {
     }
 };
 const tagDictionary = {
-    "account": {
-        "GET": [
+    account: {
+        GET: [
             "getAccount",
             "getApplications",
             "getConsent",
@@ -448,15 +329,15 @@ const tagDictionary = {
             "getGroups",
             "getOrganizations"
         ],
-        "POST": [
+        POST: [
             "updateAccount",
             "createConsent"
         ],
-        "PUT": [
+        PUT: [
             "updateConsent",
             "updateCredentialLabel"
         ],
-        "DELETE": [
+        DELETE: [
             "deleteConsent",
             "deleteCredential",
             "deleteCurrentSession",