@rage-against-the-pixel/app-store-connect-api 3.6.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 RageAgainstThePixel
+
+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,53 @@
+# app-store-connect-api
+
+A TypeScript package for communicating with Apple [App Store Connect API](https://developer.apple.com/documentation/appstoreconnectapi)
+
+- Automatically generated API client using the latest [OpenAPI specification](https://developer.apple.com/sample-code/app-store-connect/app-store-connect-openapi-specification.zip) from Apple.
+- Fully typed models and methods for every endpoint.
+- Designed for use in a Node.js server environment.
+
+## Installation
+
+```sh
+npm install @rage-against-the-pixel/app-store-connect-api
+```
+
+## Authentication
+
+To authenticate with the API you will need to [create a API keys for App Store Connect API](https://appstoreconnect.apple.com/access/api).
+
+Download and save the private key `.p8` file to a save, secure location.
+The contents of this file is your `privateKey`.
+The `privateKeyId` and `issuerId` are both listed on the same page where you create your private key.
+
+## Example
+
+```ts
+import { AppStoreConnectClient, AppStoreConnectOptions } from 'app-store-connect-api';
+
+async function main() {
+    const options: AppStoreConnectOptions = {
+        issuerId: '<ISSUER_ID>',
+        privateKeyId: '<PRIVATE_KEY_ID>',
+        privateKey: '<PRIVATE_KEY>',
+    };
+    const client = new AppStoreConnectClient(options);
+    const { data: response, error } = await client.api.appsGetCollection({
+        query: {
+            limit: 10
+        }
+    });
+    if (error) {
+        console.error('Error fetching apps:', error);
+    } else {
+        const apps = response.data.map(app => ({
+            id: app.id,
+            name: app.attributes.name,
+            bundleId: app.attributes.bundleId
+        }));
+        console.log('Apps:', apps);
+    }
+}
+
+main();
+```

package/dist/app_store_connect_api/client/index.d.ts

@@ -0,0 +1,4 @@
+import type { Client, Config } from './types';
+export declare const createClient: (config?: Config) => Client;
+export type { Client, Config, Options, RequestOptionsBase, RequestResult, } from './types';
+export { createConfig, formDataBodySerializer, jsonBodySerializer, type QuerySerializerOptions, urlSearchParamsBodySerializer, } from './utils';

package/dist/app_store_connect_api/client/index.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.urlSearchParamsBodySerializer = exports.jsonBodySerializer = exports.formDataBodySerializer = exports.createConfig = exports.createClient = void 0;
+const utils_1 = require("./utils");
+const createClient = (config = {}) => {
+    let _config = (0, utils_1.mergeConfigs)((0, utils_1.createConfig)(), config);
+    const getConfig = () => ({ ..._config });
+    const setConfig = (config) => {
+        _config = (0, utils_1.mergeConfigs)(_config, config);
+        return getConfig();
+    };
+    const interceptors = (0, utils_1.createInterceptors)();
+    // @ts-expect-error
+    const request = async (options) => {
+        // @ts-expect-error
+        const opts = {
+            ..._config,
+            ...options,
+            headers: (0, utils_1.mergeHeaders)(_config.headers, options.headers),
+        };
+        if (opts.body && opts.bodySerializer) {
+            opts.body = opts.bodySerializer(opts.body);
+        }
+        // remove Content-Type header if body is empty to avoid sending invalid requests
+        if (!opts.body) {
+            opts.headers.delete('Content-Type');
+        }
+        const url = (0, utils_1.getUrl)({
+            baseUrl: opts.baseUrl ?? '',
+            path: opts.path,
+            query: opts.query,
+            querySerializer: typeof opts.querySerializer === 'function'
+                ? opts.querySerializer
+                : (0, utils_1.createQuerySerializer)(opts.querySerializer),
+            url: opts.url,
+        });
+        const requestInit = {
+            redirect: 'follow',
+            ...opts,
+        };
+        let request = new Request(url, requestInit);
+        for (const fn of interceptors.request._fns) {
+            request = await fn(request, opts);
+        }
+        const _fetch = opts.fetch;
+        let response = await _fetch(request);
+        for (const fn of interceptors.response._fns) {
+            response = await fn(response, request, opts);
+        }
+        const result = {
+            request,
+            response,
+        };
+        if (response.ok) {
+            if (response.status === 204 ||
+                response.headers.get('Content-Length') === '0') {
+                return {
+                    data: {},
+                    ...result,
+                };
+            }
+            if (opts.parseAs === 'stream') {
+                return {
+                    data: response.body,
+                    ...result,
+                };
+            }
+            const parseAs = (opts.parseAs === 'auto'
+                ? (0, utils_1.getParseAs)(response.headers.get('Content-Type'))
+                : opts.parseAs) ?? 'json';
+            let data = await response[parseAs]();
+            if (parseAs === 'json' && opts.responseTransformer) {
+                data = await opts.responseTransformer(data);
+            }
+            return {
+                data,
+                ...result,
+            };
+        }
+        let error = await response.text();
+        try {
+            error = JSON.parse(error);
+        }
+        catch {
+            // noop
+        }
+        let finalError = error;
+        for (const fn of interceptors.error._fns) {
+            finalError = (await fn(error, response, request, opts));
+        }
+        finalError = finalError || {};
+        if (opts.throwOnError) {
+            throw finalError;
+        }
+        return {
+            error: finalError,
+            ...result,
+        };
+    };
+    return {
+        connect: (options) => request({ ...options, method: 'CONNECT' }),
+        delete: (options) => request({ ...options, method: 'DELETE' }),
+        get: (options) => request({ ...options, method: 'GET' }),
+        getConfig,
+        head: (options) => request({ ...options, method: 'HEAD' }),
+        interceptors,
+        options: (options) => request({ ...options, method: 'OPTIONS' }),
+        patch: (options) => request({ ...options, method: 'PATCH' }),
+        post: (options) => request({ ...options, method: 'POST' }),
+        put: (options) => request({ ...options, method: 'PUT' }),
+        request,
+        setConfig,
+        trace: (options) => request({ ...options, method: 'TRACE' }),
+    };
+};
+exports.createClient = createClient;
+var utils_2 = require("./utils");
+Object.defineProperty(exports, "createConfig", { enumerable: true, get: function () { return utils_2.createConfig; } });
+Object.defineProperty(exports, "formDataBodySerializer", { enumerable: true, get: function () { return utils_2.formDataBodySerializer; } });
+Object.defineProperty(exports, "jsonBodySerializer", { enumerable: true, get: function () { return utils_2.jsonBodySerializer; } });
+Object.defineProperty(exports, "urlSearchParamsBodySerializer", { enumerable: true, get: function () { return utils_2.urlSearchParamsBodySerializer; } });

package/dist/app_store_connect_api/client/types.d.ts

@@ -0,0 +1,121 @@
+import type { BodySerializer, Middleware, QuerySerializer, QuerySerializerOptions } from './utils';
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+export interface Config<ThrowOnError extends boolean = boolean> extends Omit<RequestInit, 'body' | 'headers' | 'method'> {
+    /**
+     * Base URL for all requests made by this client.
+     * @default ''
+     */
+    baseUrl?: string;
+    /**
+     * Any body that you want to add to your request.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+     */
+    body?: RequestInit['body'] | Record<string, unknown> | Array<Record<string, unknown>> | Array<unknown> | number;
+    /**
+     * A function for serializing request body parameter. By default,
+     * {@link JSON.stringify()} will be used.
+     */
+    bodySerializer?: BodySerializer;
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     * @default globalThis.fetch
+     */
+    fetch?: (request: Request) => ReturnType<typeof fetch>;
+    /**
+     * An object containing any HTTP headers that you want to pre-populate your
+     * `Headers` object with.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+     */
+    headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
+    /**
+     * The request method.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
+     */
+    method?: 'CONNECT' | 'DELETE' | 'GET' | 'HEAD' | 'OPTIONS' | 'PATCH' | 'POST' | 'PUT' | 'TRACE';
+    /**
+     * Return the response data parsed in a specified format. By default, `auto`
+     * will infer the appropriate method from the `Content-Type` response header.
+     * You can override this behavior with any of the {@link Body} methods.
+     * Select `stream` if you don't want to parse response data at all.
+     * @default 'auto'
+     */
+    parseAs?: Exclude<keyof Body, 'body' | 'bodyUsed'> | 'auto' | 'stream';
+    /**
+     * A function for serializing request query parameters. By default, arrays
+     * will be exploded in form style, objects will be exploded in deepObject
+     * style, and reserved characters are percent-encoded.
+     *
+     * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+     */
+    querySerializer?: QuerySerializer | QuerySerializerOptions;
+    /**
+     * A function for transforming response data before it's returned to the
+     * caller function. This is an ideal place to post-process server data,
+     * e.g. convert date ISO strings into native Date objects.
+     */
+    responseTransformer?: (data: unknown) => Promise<unknown>;
+    /**
+     * Throw an error instead of returning it in the response?
+     * @default false
+     */
+    throwOnError?: ThrowOnError;
+}
+export interface RequestOptionsBase<ThrowOnError extends boolean> extends Config<ThrowOnError> {
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    url: string;
+}
+export type RequestResult<Data = unknown, TError = unknown, ThrowOnError extends boolean = boolean> = ThrowOnError extends true ? Promise<{
+    data: Data;
+    request: Request;
+    response: Response;
+}> : Promise<({
+    data: Data;
+    error: undefined;
+} | {
+    data: undefined;
+    error: TError;
+}) & {
+    request: Request;
+    response: Response;
+}>;
+type MethodFn = <Data = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptionsBase<ThrowOnError>, 'method'>) => RequestResult<Data, TError, ThrowOnError>;
+type RequestFn = <Data = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptionsBase<ThrowOnError>, 'method'> & Pick<Required<RequestOptionsBase<ThrowOnError>>, 'method'>) => RequestResult<Data, TError, ThrowOnError>;
+export interface Client<Req = Request, Res = Response, Err = unknown, Options = RequestOptions> {
+    connect: MethodFn;
+    delete: MethodFn;
+    get: MethodFn;
+    getConfig: () => Config;
+    head: MethodFn;
+    interceptors: Middleware<Req, Res, Err, Options>;
+    options: MethodFn;
+    patch: MethodFn;
+    post: MethodFn;
+    put: MethodFn;
+    request: RequestFn;
+    setConfig: (config: Config) => Config;
+    trace: MethodFn;
+}
+export type RequestOptions = RequestOptionsBase<false> & Config<false> & {
+    headers: Headers;
+};
+type OptionsBase<ThrowOnError extends boolean> = Omit<RequestOptionsBase<ThrowOnError>, 'url'> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+};
+export type Options<T = unknown, ThrowOnError extends boolean = boolean> = T extends {
+    body?: any;
+} ? T extends {
+    headers?: any;
+} ? OmitKeys<OptionsBase<ThrowOnError>, 'body' | 'headers'> & T : OmitKeys<OptionsBase<ThrowOnError>, 'body'> & T & Pick<OptionsBase<ThrowOnError>, 'headers'> : T extends {
+    headers?: any;
+} ? OmitKeys<OptionsBase<ThrowOnError>, 'headers'> & T & Pick<OptionsBase<ThrowOnError>, 'body'> : OptionsBase<ThrowOnError> & T;
+export {};

package/dist/app_store_connect_api/client/types.js

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

package/dist/app_store_connect_api/client/utils.d.ts

@@ -0,0 +1,63 @@
+import type { Config } from './types';
+type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
+type ObjectStyle = 'form' | 'deepObject';
+export type QuerySerializer = (query: Record<string, unknown>) => string;
+export type BodySerializer = (body: any) => any;
+interface SerializerOptions<T> {
+    /**
+     * @default true
+     */
+    explode: boolean;
+    style: T;
+}
+export interface QuerySerializerOptions {
+    allowReserved?: boolean;
+    array?: SerializerOptions<ArrayStyle>;
+    object?: SerializerOptions<ObjectStyle>;
+}
+export declare const createQuerySerializer: <T = unknown>({ allowReserved, array, object, }?: QuerySerializerOptions) => (queryParams: T) => string;
+/**
+ * Infers parseAs value from provided Content-Type header.
+ */
+export declare const getParseAs: (content: string | null) => Exclude<Config["parseAs"], "auto" | "stream">;
+export declare const getUrl: ({ baseUrl, path, query, querySerializer, url: _url, }: {
+    baseUrl: string;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    querySerializer: QuerySerializer;
+    url: string;
+}) => string;
+export declare const mergeConfigs: (a: Config, b: Config) => Config;
+export declare const mergeHeaders: (...headers: Array<Required<Config>["headers"] | undefined>) => Headers;
+type ErrInterceptor<Err, Res, Req, Options> = (error: Err, response: Res, request: Req, options: Options) => Err | Promise<Err>;
+type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
+type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
+declare class Interceptors<Interceptor> {
+    _fns: Interceptor[];
+    constructor();
+    clear(): void;
+    exists(fn: Interceptor): boolean;
+    eject(fn: Interceptor): void;
+    use(fn: Interceptor): void;
+}
+export interface Middleware<Req, Res, Err, Options> {
+    error: Pick<Interceptors<ErrInterceptor<Err, Res, Req, Options>>, 'eject' | 'use'>;
+    request: Pick<Interceptors<ReqInterceptor<Req, Options>>, 'eject' | 'use'>;
+    response: Pick<Interceptors<ResInterceptor<Res, Req, Options>>, 'eject' | 'use'>;
+}
+export declare const createInterceptors: <Req, Res, Err, Options>() => {
+    error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
+    request: Interceptors<ReqInterceptor<Req, Options>>;
+    response: Interceptors<ResInterceptor<Res, Req, Options>>;
+};
+export declare const formDataBodySerializer: {
+    bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(body: T) => FormData;
+};
+export declare const jsonBodySerializer: {
+    bodySerializer: <T>(body: T) => string;
+};
+export declare const urlSearchParamsBodySerializer: {
+    bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(body: T) => URLSearchParams;
+};
+export declare const createConfig: (override?: Config) => Config;
+export {};