@shopvirge/shopvirge-client 0.2.2

package/README.md

@@ -0,0 +1,106 @@
+# @shopvirge/shopvirge-client
+
+Auto-generated TypeScript API client for the [ShopVirge](https://api.shopvirge.com) API, built from the OpenAPI spec using [@hey-api/openapi-ts](https://github.com/hey-api/openapi-ts).
+
+## Installation
+
+```bash
+npm install @shopvirge/shopvirge-client
+# or
+yarn add @shopvirge/shopvirge-client
+```
+
+## Usage
+
+### Configure the API URL
+
+Before making any API calls, set the `BASE` URL on the exported `OpenAPI` config object:
+
+```ts
+import { OpenAPI } from '@shopvirge/shopvirge-client';
+
+OpenAPI.BASE = 'https://api.shopvirge.com';
+```
+
+### Authentication
+
+You can configure authentication by setting `TOKEN` or `HEADERS`:
+
+```ts
+import { OpenAPI } from '@shopvirge/shopvirge-client';
+
+// Bearer token
+OpenAPI.TOKEN = 'your-access-token';
+
+// Or use custom headers
+OpenAPI.HEADERS = {
+    Authorization: 'Bearer your-access-token',
+};
+```
+
+### Making API calls
+
+Once configured, use the generated service functions to interact with the API:
+
+```ts
+import { OpenAPI, ShopsService } from '@shopvirge/shopvirge-client';
+
+OpenAPI.BASE = 'https://api.shopvirge.com';
+
+const shops = await ShopsService.getShops();
+```
+
+### Full configuration reference
+
+All properties on the `OpenAPI` config object can be overridden:
+
+| Property           | Type                                   | Default     | Description                      |
+| ------------------ | -------------------------------------- | ----------- | -------------------------------- |
+| `BASE`             | `string`                               | `''`        | Base URL for all API requests    |
+| `TOKEN`            | `string \| Resolver`                   | `undefined` | Bearer token or async resolver   |
+| `HEADERS`          | `Record<string, string> \| Resolver`   | `undefined` | Custom headers or async resolver |
+| `CREDENTIALS`      | `'include' \| 'omit' \| 'same-origin'` | `'include'` | Fetch credentials mode           |
+| `WITH_CREDENTIALS` | `boolean`                              | `false`     | XHR withCredentials flag         |
+| `ENCODE_PATH`      | `(path: string) => string`             | `undefined` | Custom path encoder              |
+| `USERNAME`         | `string \| Resolver`                   | `undefined` | Basic auth username              |
+| `PASSWORD`         | `string \| Resolver`                   | `undefined` | Basic auth password              |
+
+### Request/Response interceptors
+
+You can add interceptors to modify requests or responses:
+
+```ts
+import { OpenAPI } from '@shopvirge/shopvirge-client';
+
+OpenAPI.interceptors.request.use((request) => {
+    console.log('Request:', request);
+    return request;
+});
+
+OpenAPI.interceptors.response.use((response) => {
+    console.log('Response:', response);
+    return response;
+});
+```
+
+## Development
+
+### Regenerate the client
+
+From the `packages/shopvirge-client/` directory:
+
+```bash
+# From a local openapi.json file
+yarn openapi-ts
+
+# From the live API
+yarn openapi-ts-live
+```
+
+### Sync package version
+
+After regenerating, sync the package version from the OpenAPI spec:
+
+```bash
+yarn sync-version
+```

package/package.json

@@ -0,0 +1,48 @@
+{
+    "name": "@shopvirge/shopvirge-client",
+    "version": "0.2.2",
+    "publishConfig": {
+        "access": "public"
+    },
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "type": "module",
+    "scripts": {
+        "test": "jest --passWithNoTests",
+        "build": "tsup src/index.ts --format esm --dts --tsconfig tsconfig.json",
+        "tsc": "tsc --noEmit",
+        "lint": "eslint \"src/**/*.ts*\"",
+        "dev": "yarn build -- --watch",
+        "openapi-ts": "openapi-ts -i src/api/openapi.json -o src/api/generated",
+        "openapi-ts-live": "openapi-ts -i https://api.shopvirge.com/openapi.json -o src/api/generated",
+        "sync-version": "node -e \"const pkg=require('./package.json');const api=require('./src/api/openapi.json');pkg.version=api.info.version;require('fs').writeFileSync('package.json',JSON.stringify(pkg,null,4)+'\\n');\""
+    },
+    "dependencies": {
+        "@graphql-typed-document-node/core": "3.2.0",
+        "moment": "2.29.4",
+        "use-query-params": "2.2.1"
+    },
+    "peerDependencies": {
+        "graphql-request": "5.2.0",
+        "next": "^13.4.1",
+        "next-query-params": "4.2.2",
+        "react": "^18.2.0",
+        "react-query": "3.39.3",
+        "stripe": "^13.7.0",
+        "typescript": "^4.9.0"
+    },
+    "devDependencies": {
+        "@hey-api/openapi-ts": "^0.46.3",
+        "@testing-library/jest-dom": "^5.16.1",
+        "@testing-library/react": "^14.0.0",
+        "@testing-library/react-hooks": "^8.0.1",
+        "@testing-library/user-event": "^14.4.3",
+        "@types/jest": "^27.4.0",
+        "esbuild": "^0.14.10",
+        "esbuild-jest": "^0.5.0",
+        "jest": "^27.4.7",
+        "jest-watch-typeahead": "^1.0.0",
+        "react": "^18.2.0",
+        "react-dom": "^18.2.0"
+    }
+}

package/src/api/generated/core/ApiError.ts

@@ -0,0 +1,25 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+
+export class ApiError extends Error {
+    public readonly url: string;
+    public readonly status: number;
+    public readonly statusText: string;
+    public readonly body: unknown;
+    public readonly request: ApiRequestOptions;
+
+    constructor(
+        request: ApiRequestOptions,
+        response: ApiResult,
+        message: string,
+    ) {
+        super(message);
+
+        this.name = 'ApiError';
+        this.url = response.url;
+        this.status = response.status;
+        this.statusText = response.statusText;
+        this.body = response.body;
+        this.request = request;
+    }
+}

package/src/api/generated/core/ApiRequestOptions.ts

@@ -0,0 +1,20 @@
+export type ApiRequestOptions = {
+    readonly method:
+        | 'GET'
+        | 'PUT'
+        | 'POST'
+        | 'DELETE'
+        | 'OPTIONS'
+        | 'HEAD'
+        | 'PATCH';
+    readonly url: string;
+    readonly path?: Record<string, unknown>;
+    readonly cookies?: Record<string, unknown>;
+    readonly headers?: Record<string, unknown>;
+    readonly query?: Record<string, unknown>;
+    readonly formData?: Record<string, unknown>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number | string, string>;
+};

package/src/api/generated/core/ApiResult.ts

@@ -0,0 +1,7 @@
+export type ApiResult<TData = any> = {
+    readonly body: TData;
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly url: string;
+};

package/src/api/generated/core/CancelablePromise.ts

@@ -0,0 +1,130 @@
+export class CancelError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = 'CancelError';
+    }
+
+    public get isCancelled(): boolean {
+        return true;
+    }
+}
+
+export interface OnCancel {
+    readonly isResolved: boolean;
+    readonly isRejected: boolean;
+    readonly isCancelled: boolean;
+
+    (cancelHandler: () => void): void;
+}
+
+export class CancelablePromise<T> implements Promise<T> {
+    private _isResolved: boolean;
+    private _isRejected: boolean;
+    private _isCancelled: boolean;
+    readonly cancelHandlers: (() => void)[];
+    readonly promise: Promise<T>;
+    private _resolve?: (value: T | PromiseLike<T>) => void;
+    private _reject?: (reason?: unknown) => void;
+
+    constructor(
+        executor: (
+            resolve: (value: T | PromiseLike<T>) => void,
+            reject: (reason?: unknown) => void,
+            onCancel: OnCancel,
+        ) => void,
+    ) {
+        this._isResolved = false;
+        this._isRejected = false;
+        this._isCancelled = false;
+        this.cancelHandlers = [];
+        this.promise = new Promise<T>((resolve, reject) => {
+            this._resolve = resolve;
+            this._reject = reject;
+
+            const onResolve = (value: T | PromiseLike<T>): void => {
+                if (this._isResolved || this._isRejected || this._isCancelled) {
+                    return;
+                }
+                this._isResolved = true;
+                if (this._resolve) this._resolve(value);
+            };
+
+            const onReject = (reason?: unknown): void => {
+                if (this._isResolved || this._isRejected || this._isCancelled) {
+                    return;
+                }
+                this._isRejected = true;
+                if (this._reject) this._reject(reason);
+            };
+
+            const onCancel = (cancelHandler: () => void): void => {
+                if (this._isResolved || this._isRejected || this._isCancelled) {
+                    return;
+                }
+                this.cancelHandlers.push(cancelHandler);
+            };
+
+            Object.defineProperty(onCancel, 'isResolved', {
+                get: (): boolean => this._isResolved,
+            });
+
+            Object.defineProperty(onCancel, 'isRejected', {
+                get: (): boolean => this._isRejected,
+            });
+
+            Object.defineProperty(onCancel, 'isCancelled', {
+                get: (): boolean => this._isCancelled,
+            });
+
+            return executor(onResolve, onReject, onCancel as OnCancel);
+        });
+    }
+
+    get [Symbol.toStringTag]() {
+        return 'Cancellable Promise';
+    }
+
+    public then<TResult1 = T, TResult2 = never>(
+        onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
+        onRejected?:
+            | ((reason: unknown) => TResult2 | PromiseLike<TResult2>)
+            | null,
+    ): Promise<TResult1 | TResult2> {
+        return this.promise.then(onFulfilled, onRejected);
+    }
+
+    public catch<TResult = never>(
+        onRejected?:
+            | ((reason: unknown) => TResult | PromiseLike<TResult>)
+            | null,
+    ): Promise<T | TResult> {
+        return this.promise.catch(onRejected);
+    }
+
+    public finally(onFinally?: (() => void) | null): Promise<T> {
+        return this.promise.finally(onFinally);
+    }
+
+    public cancel(): void {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+            return;
+        }
+        this._isCancelled = true;
+        if (this.cancelHandlers.length) {
+            try {
+                for (const cancelHandler of this.cancelHandlers) {
+                    cancelHandler();
+                }
+            } catch (error) {
+                console.warn('Cancellation threw an error', error);
+                return;
+            }
+        }
+        this.cancelHandlers.length = 0;
+        if (this._reject) this._reject(new CancelError('Request aborted'));
+    }
+
+    public get isCancelled(): boolean {
+        return this._isCancelled;
+    }
+}

package/src/api/generated/core/OpenAPI.ts

@@ -0,0 +1,59 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+
+type Headers = Record<string, string>;
+type Middleware<T> = (value: T) => T | Promise<T>;
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+
+export class Interceptors<T> {
+    _fns: Middleware<T>[];
+
+    constructor() {
+        this._fns = [];
+    }
+
+    eject(fn: Middleware<T>): void {
+        const index = this._fns.indexOf(fn);
+        if (index !== -1) {
+            this._fns = [
+                ...this._fns.slice(0, index),
+                ...this._fns.slice(index + 1),
+            ];
+        }
+    }
+
+    use(fn: Middleware<T>): void {
+        this._fns = [...this._fns, fn];
+    }
+}
+
+export type OpenAPIConfig = {
+    BASE: string;
+    CREDENTIALS: 'include' | 'omit' | 'same-origin';
+    ENCODE_PATH?: ((path: string) => string) | undefined;
+    HEADERS?: Headers | Resolver<Headers> | undefined;
+    PASSWORD?: string | Resolver<string> | undefined;
+    TOKEN?: string | Resolver<string> | undefined;
+    USERNAME?: string | Resolver<string> | undefined;
+    VERSION: string;
+    WITH_CREDENTIALS: boolean;
+    interceptors: {
+        request: Interceptors<RequestInit>;
+        response: Interceptors<Response>;
+    };
+};
+
+export const OpenAPI: OpenAPIConfig = {
+    BASE: '',
+    CREDENTIALS: 'include',
+    ENCODE_PATH: undefined,
+    HEADERS: undefined,
+    PASSWORD: undefined,
+    TOKEN: undefined,
+    USERNAME: undefined,
+    VERSION: '0.2.2',
+    WITH_CREDENTIALS: false,
+    interceptors: {
+        request: new Interceptors(),
+        response: new Interceptors(),
+    },
+};