@resolution/organizations-api-client 0.14.0

package/LICENSE.md

@@ -0,0 +1,19 @@
+Copyright (c) 2025 resolution Reichert Network Solutions GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,110 @@
+# Atlassian Organizations API Client
+
+TypeScript/JavaScript client for the Atlassian Organizations API, generated from the Atlassian OpenAPI schema.
+
+## Installation
+
+```bash
+npm install @resolution/organizations-api-client
+```
+
+or
+
+```bash
+yarn add @resolution/organizations-api-client
+```
+
+## Usage
+
+```typescript
+import { OrganizationsApiClient } from '@resolution/organizations-api-client';
+
+// Initialize the client with your API key
+const organizationsClient = new OrganizationsApiClient({
+  apiKey: 'your-api-key-here'
+});
+
+// Example: Get organizations
+async function getOrganizations() {
+  try {
+    const response = await organizationsClient.orgs.getOrgs();
+    console.log('Organizations:', response.data);
+  } catch (error) {
+    console.error('Error fetching organizations:', error);
+  }
+}
+```
+
+## Authentication
+
+This client only supports API key authentication. You need to provide an API key when initializing the client:
+
+```typescript
+const client = new OrganizationsApiClient({
+  apiKey: 'your-api-key-here'
+});
+```
+
+## Available Services
+
+The client provides access to the following services:
+
+- `directory` - Directory management
+- `domains` - Domain management
+- `events` - Event management
+- `groups` - Group management
+- `orgs` - Organization management
+- `policies` - Policy management
+- `users` - User management
+- `validate` - Validation
+- `workspaces` - Workspace management
+
+## Error Handling
+
+The client uses the `ApiError` class for error handling:
+
+```typescript
+import { OrganizationsApiClient, ApiError } from '@resolution/organizations-api-client';
+
+const organizationsClient = new OrganizationsApiClient({
+  apiKey: 'your-api-key-here'
+});
+
+try {
+  await organizationsClient.orgs.getOrgs();
+} catch (error) {
+  if (error instanceof ApiError) {
+    console.error('API Error:', error.message);
+    console.error('Status:', error.statusCode);
+    console.error('Details:', error.details);
+  } else {
+    console.error('Unknown error:', error);
+  }
+}
+```
+
+## Advanced Configuration
+
+You can customize client behavior with additional options:
+
+```typescript
+const client = new OrganizationsApiClient({
+  apiKey: 'your-api-key-here',
+  // Custom validation error handler
+  handleValidationError: (error) => {
+    console.error('Validation error:', error);
+  },
+  // Custom deprecation warning logger
+  logDeprecationWarning: ({ operationName, path, method }) => {
+    console.warn(`Deprecated operation used: ${operationName} (${method} ${path})`);
+  },
+  // Custom retry logic
+  shouldRetryOnError: (error, attemptNumber) => {
+    return attemptNumber < 3 && (error.statusCode === 429 || error.statusCode >= 500);
+  }
+});
+```
+
+## License
+
+MIT

package/lib/index.d.ts

@@ -0,0 +1,39 @@
+import { ApiError, retryOnNetworkAndInternalErrors } from "@resolution/atlassian-api-common";
+import type { CommonHttpClientFetchRequest } from "api-typescript-generator/openapi-client";
+import { BaseOrganizationsApiClient } from "./openapi/organizations/BaseOrganizationsApiClient";
+export * from "./openapi/organizations/BaseOrganizationsApiClient";
+export { ApiError, retryOnNetworkAndInternalErrors };
+/**
+ * The Organizations REST API Client.
+ */
+export interface OrganizationsApiClientOptions {
+    /**
+     * API key for authentication.
+     */
+    apiKey: string;
+    /**
+     * Custom validation error handler.
+     */
+    handleValidationError?(error: Error): void;
+    /**
+     * Custom deprecation warning logger.
+     */
+    logDeprecationWarning?(params: {
+        /**
+         * Either operation method name in case if it's not part of the service, or service name and operation method
+         * name separated by a dot.
+         *
+         * Examples: `users.getUserById`, `getSystemConfig`
+         */
+        operationName: string;
+        path: string;
+        method: CommonHttpClientFetchRequest["method"];
+    }): void;
+    /**
+     * Determine whether to retry the request on error.
+     */
+    shouldRetryOnError?: (error: ApiError, attemptNumber: number) => Promise<boolean> | boolean;
+}
+export declare class OrganizationsApiClient extends BaseOrganizationsApiClient {
+    constructor({ apiKey, shouldRetryOnError, ...otherProps }: OrganizationsApiClientOptions);
+}

package/lib/index.js

@@ -0,0 +1,46 @@
+"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);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrganizationsApiClient = exports.retryOnNetworkAndInternalErrors = exports.ApiError = void 0;
+const atlassian_api_common_1 = require("@resolution/atlassian-api-common");
+Object.defineProperty(exports, "ApiError", { enumerable: true, get: function () { return atlassian_api_common_1.ApiError; } });
+Object.defineProperty(exports, "retryOnNetworkAndInternalErrors", { enumerable: true, get: function () { return atlassian_api_common_1.retryOnNetworkAndInternalErrors; } });
+const BaseOrganizationsApiClient_1 = require("./openapi/organizations/BaseOrganizationsApiClient");
+const validationSchemaStorage_1 = require("./openapi/organizations/validationSchemaStorage");
+__exportStar(require("./openapi/organizations/BaseOrganizationsApiClient"), exports);
+validationSchemaStorage_1.validationSchemaStorage.setErrorClass(atlassian_api_common_1.ApiError);
+const BASE_PATH = "/admin";
+class OrganizationsApiClient extends BaseOrganizationsApiClient_1.BaseOrganizationsApiClient {
+    constructor(_a) {
+        var { apiKey, shouldRetryOnError } = _a, otherProps = __rest(_a, ["apiKey", "shouldRetryOnError"]);
+        super(Object.assign({ baseUrl: "https://api.atlassian.com", headers: {
+                Authorization: `Bearer ${apiKey}`,
+            }, formatHttpErrorMessage: atlassian_api_common_1.formatHttpErrorMessage, errorClass: atlassian_api_common_1.ApiError, preprocessRequest: (request) => Promise.resolve(Object.assign(Object.assign({}, request), { path: BASE_PATH + request.path })), shouldRetryOnError: shouldRetryOnError }, otherProps));
+    }
+}
+exports.OrganizationsApiClient = OrganizationsApiClient;
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2EAI0C;AASjC,yFAZP,+BAAQ,OAYO;AAAE,gHAVjB,sDAA+B,OAUiB;AALlD,mGAAgG;AAChG,6FAA0F;AAE1F,qFAAmE;AAInE,iDAAuB,CAAC,aAAa,CAAC,+BAAQ,CAAC,CAAC;AAqChD,MAAM,SAAS,GAAG,QAAQ,CAAC;AAE3B,MAAa,sBAAuB,SAAQ,uDAA0B;IACpE,YAAY,EAIoB;YAJpB,EACV,MAAM,EACN,kBAAkB,OAEY,EAD3B,UAAU,cAHH,gCAIX,CADc;QAEb,KAAK,iBACH,OAAO,EAAE,2BAA2B,EACpC,OAAO,EAAE;gBACP,aAAa,EAAE,UAAU,MAAM,EAAE;aAClC,EACD,sBAAsB,EAAtB,6CAAsB,EACtB,UAAU,EAAE,+BAAQ,EACpB,iBAAiB,EAAE,CAAC,OAAO,EAAE,EAAE,CAC7B,OAAO,CAAC,OAAO,iCACV,OAAO,KACV,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,IAC9B,EACJ,kBAAkB,EAChB,kBAAmE,IAClE,UAAU,EACb,CAAC;IACL,CAAC;CACF;AAvBD,wDAuBC"}

package/lib/openapi/core/CommonHttpClient.d.ts

@@ -0,0 +1,316 @@
+/**
+ * Options for the common HTTP client.
+ */
+export interface CommonHttpClientOptions {
+    /**
+     * Base URL for the API. Endpoints are relative to this URL.
+     */
+    baseUrl: string;
+    /**
+     * Error class to be thrown when an error occurs.
+     */
+    errorClass: {
+        new (url: URL, request: CommonHttpClientFetchRequest | undefined, response: CommonHttpClientFetchResponse | undefined, options: CommonHttpClientOptions | undefined, message: string): Error;
+    };
+    /**
+     * Class name of the API client.
+     */
+    apiClientClassName: string;
+    /**
+     * Default headers to be sent with each request.
+     */
+    headers?: CommonHttpClientRequestHeaders;
+    /**
+     * Preprocess the request before sending it.
+     */
+    preprocessRequest?: (request: CommonHttpClientRequest) => Promise<CommonHttpClientRequest>;
+    /**
+     * Preprocess the response before returning it.
+     */
+    preprocessFetchResponse?: (response: CommonHttpClientFetchResponse, request: CommonHttpClientFetchRequest) => Promise<CommonHttpClientFetchResponse>;
+    /**
+     * Fetch function. Default is window.fetch-based implementation.
+     */
+    fetch?: (url: URL, request: CommonHttpClientFetchRequest) => Promise<CommonHttpClientFetchResponse>;
+    /**
+     * Type of the response body for binary responses.
+     */
+    binaryResponseType: 'blob' | 'readableStream';
+    /**
+     * Format the HTTP error message.
+     */
+    formatHttpErrorMessage?: (response: CommonHttpClientFetchResponse, request: CommonHttpClientFetchRequest) => string;
+    /**
+     * Custom validation error handling. Can be used to log errors.
+     */
+    handleValidationError?: (error: Error) => void;
+    /**
+     * Deprecated operations. Used to warn about deprecated operations.
+     */
+    deprecatedOperations?: {
+        [methodAndPath: string]: string;
+    };
+    /**
+     * Log a deprecation warning.
+     */
+    logDeprecationWarning?(params: {
+        /**
+         * Either operation method name in case if it's not part of the service, or service name and operation method
+         * name separated by a dot.
+         *
+         * Examples: `users.getUserById`, `getSystemConfig`
+         */
+        operationName: string;
+        path: string;
+        method: CommonHttpClientFetchRequest['method'];
+    }): void;
+    /**
+     * Determine whether to retry on error.
+     */
+    shouldRetryOnError?: (error: Error, attemptNumber: number) => boolean | Promise<boolean>;
+}
+/**
+ * Request headers as used by the fetch function.
+ */
+export interface CommonHttpClientFetchRequestHeaders {
+    [headerName: string]: string;
+}
+/**
+ * A forgiving version of the request headers. Undefined and null values are allowed.
+ */
+export interface CommonHttpClientRequestHeaders {
+    [headerName: string]: string | undefined | null;
+}
+/**
+ * Request prepared for the fetch function.
+ */
+export interface CommonHttpClientFetchRequest {
+    /**
+     * HTTP Method.
+     */
+    method: 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'PATCH';
+    /**
+     * Request headers.
+     */
+    headers: CommonHttpClientFetchRequestHeaders;
+    /**
+     * Request body.
+     */
+    body?: BodyInit;
+    /**
+     * Cache mode.
+     */
+    cache: 'default' | 'force-cache' | 'no-cache' | 'no-store' | 'only-if-cached' | 'reload';
+    /**
+     * Credentials mode.
+     */
+    credentials: 'include' | 'omit' | 'same-origin';
+    /**
+     * Redirect mode.
+     */
+    redirect: 'error' | 'follow' | 'manual';
+    /**
+     * Custom request properties. Can be used to pass metadata to the fetch function.
+     */
+    customRequestProps?: Record<string, unknown>;
+}
+/**
+ * Parameter serialization style.
+ */
+export type CommonHttpClientRequestParameterSerializeStyle = 'simple' | 'label' | 'matrix' | 'form' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
+/**
+ * Information about how to serialize a request parameter.
+ */
+export interface CommonHttpClientRequestParameterSerializeInfo {
+    /**
+     * Serialization style.
+     */
+    style?: CommonHttpClientRequestParameterSerializeStyle;
+    /**
+     * Serialization explode.
+     */
+    explode?: boolean;
+}
+/**
+ * Request parameter location.
+ */
+export type CommonHttpClientRequestParameterLocation = 'path' | 'query' | 'header' | 'cookie';
+/**
+ * Request parameters.
+ */
+export type CommonHttpClientRequestParameters = {
+    [K in CommonHttpClientRequestParameterLocation]?: Record<string, CommonHttpClientRequestParameterSerializeInfo>;
+};
+/**
+ * Request in terms of OpenAPI.
+ */
+export type CommonHttpClientRequest = Omit<CommonHttpClientFetchRequest, 'body' | 'headers' | 'cache' | 'credentials' | 'redirect'> & {
+    /**
+     * Path to the resource.
+     */
+    path: string;
+    /**
+     * Path parameters, i.e. {id}.
+     */
+    pathParams?: Record<string, unknown>;
+    /**
+     * Query parameters.
+     */
+    query?: Record<string, unknown>;
+    /**
+     * Request body.
+     */
+    body?: unknown;
+    /**
+     * Request headers.
+     */
+    headers?: CommonHttpClientRequestHeaders;
+    /**
+     * Request parameters serialization information.
+     */
+    parameters?: CommonHttpClientRequestParameters;
+} & Partial<Pick<CommonHttpClientFetchRequest, 'cache' | 'credentials' | 'redirect'>>;
+/**
+ * Response of the fetch function.
+ */
+export interface CommonHttpClientFetchResponse {
+    /**
+     * HTTP status code.
+     */
+    status: number;
+    /**
+     * HTTP status code explanation.
+     */
+    statusText: string;
+    /**
+     * Response body.
+     */
+    body: CommonHttpClientFetchResponseBody;
+    /**
+     * Whether the request was successful. True for 2xx status codes.
+     */
+    ok: boolean;
+    /**
+     * The final URL of the request (after redirects).
+     */
+    url: string;
+    /**
+     * Response headers.
+     */
+    headers: CommonHttpClientResponseHeaders;
+    /**
+     * Custom request properties. Can be used to pass metadata outside the fetch function.
+     */
+    customRequestProps?: Record<string, unknown>;
+}
+export type CommonHttpClientResponseHeaders = Record<string, string> & {
+    'set-cookie'?: string[];
+};
+export type CommonHttpClientFetchResponseBody = {
+    type: 'json';
+    data: unknown;
+} | {
+    type: 'blob';
+    data: Blob;
+} | {
+    type: 'readableStream';
+    data: ReadableStream<Uint8Array>;
+};
+export interface CommonHttpClientResponse<T> {
+    status: number;
+    mediaType?: string;
+    body: T;
+    response: CommonHttpClientFetchResponse;
+}
+/** Error thrown by the common HTTP client. */
+export declare class CommonHttpClientError extends Error {
+    /** URL of the request. */
+    readonly url: URL;
+    /**
+     * Request that caused the error. Can be undefined in case of failure during
+     * request building phase.
+     */
+    readonly request: CommonHttpClientFetchRequest | undefined;
+    /** Response that caused the error. Can be undefined in case of network failure. */
+    readonly response: CommonHttpClientFetchResponse | undefined;
+    /** Options of the common HTTP client. */
+    readonly options: CommonHttpClientOptions | undefined;
+    constructor(url: URL, request: CommonHttpClientFetchRequest | undefined, response: CommonHttpClientFetchResponse | undefined, options: CommonHttpClientOptions | undefined, message: string);
+}
+/**
+ * `extends unknown` is a trick to split the union into individual types.
+ */
+type ResponseByMediaType<T extends CommonHttpClientResponse<unknown>, K extends string> = T extends unknown ? ((a: T) => void) extends (a: {
+    mediaType: K;
+    status: infer _Status;
+    body: infer _Body;
+    response: CommonHttpClientFetchResponse;
+}) => void ? T : never : never;
+export declare function checkReponseMediaType<T extends CommonHttpClientResponse<unknown>, K extends string>(response: T, mediaType: K): response is ResponseByMediaType<T, K> extends never ? ResponseByMediaType<T, '*/*'> : ResponseByMediaType<T, K>;
+export declare function isJsonMediaType(mediaType: string): boolean;
+type AsCreatedResponseFunction<KCreated extends string, KOther extends string> = <T extends CommonHttpClientResponse<unknown>>(response: T) => ({
+    [K in KCreated]: Extract<T, {
+        status: 201;
+    }>['body'];
+} & {
+    created: true;
+}) | ({
+    [K in KOther]: Extract<T, {
+        status: 200;
+    }>['body'];
+} & {
+    created: false;
+});
+export declare function asCreatedResponse<KCreated extends string>(keyCreated: KCreated): AsCreatedResponseFunction<KCreated, KCreated>;
+export declare function asCreatedResponse<KCreated extends string, KOther extends string>(keyCreated: KCreated, keyOther: KOther): AsCreatedResponseFunction<KCreated, KOther>;
+export declare const getBody: <T>({ body }: CommonHttpClientResponse<T>) => T;
+export declare const castResponse: <T extends Omit<CommonHttpClientResponse<unknown>, "response">>() => (response: CommonHttpClientResponse<unknown>) => WithResponse<T>;
+export declare const discardResult: () => void;
+export type WithResponse<T> = T & {
+    response: CommonHttpClientFetchResponse;
+};
+export declare function createClientWithServices<TOptions, TClient extends {
+    getClient(): CommonHttpClient;
+}, TServices extends Record<string, {
+    new (client: CommonHttpClient): unknown;
+}>>(this: {
+    new (options?: TOptions): TClient;
+}, services: TServices, options?: TOptions): TClient & {
+    [K in keyof TServices as K extends string ? Uncapitalize<K extends `${infer TName}Service` ? TName : K> : K]: InstanceType<TServices[K]>;
+};
+/** Common HTTP client. Configurable for different environments. */
+export declare class CommonHttpClient {
+    protected options: CommonHttpClientOptions;
+    constructor(options: CommonHttpClientOptions);
+    /** Configure the client. */
+    setOptions(options: CommonHttpClientOptions): void;
+    /** Get the current configuration. */
+    getOptions(): CommonHttpClientOptions;
+    /** Logs a deprecation warning if the operation is deprecated. */
+    protected logDeprecationWarningIfNecessary(params: {
+        path: string;
+        method: CommonHttpClientFetchRequest['method'];
+    }): void;
+    /** Turns an object with query params into a URLSearchParams object. */
+    protected getSearchParams(params: Record<string, unknown>, parameters: Record<string, CommonHttpClientRequestParameterSerializeInfo>): URLSearchParams;
+    /** Build the URL path from the request by applying path params. */
+    protected buildUrlPath(request: CommonHttpClientRequest, parameters: Record<string, CommonHttpClientRequestParameterSerializeInfo>): string;
+    /** Build the full URL from the request. */
+    protected buildUrl(request: CommonHttpClientRequest): URL;
+    /** Default fetch implementation. */
+    protected fetch(url: URL, request: CommonHttpClientFetchRequest): Promise<CommonHttpClientFetchResponse>;
+    /** Perform a request. */
+    request(request: CommonHttpClientRequest): Promise<CommonHttpClientFetchResponse>;
+    /** Post-process the response. */
+    responseHandler(distribution: {
+        [statusCode: string]: {
+            [mediaType: string]: CommonHttpClientFetchResponseBody['type'];
+        };
+    }): (response: CommonHttpClientFetchResponse) => Promise<CommonHttpClientResponse<unknown>>;
+    validation<D>(validator: (data: D) => D): (data: D) => D;
+    /** Remove undefined and null values from headers. */
+    private cleanupHeaders;
+    protected getRequestBody(request: CommonHttpClientRequest): BodyInit | undefined;
+    protected preprocessRequest(request: CommonHttpClientRequest): Promise<CommonHttpClientRequest>;
+}
+export {};