@dehwyyy/auth 1.0.5 → 2.0.0

package/dist/v2/client/client.js

@@ -0,0 +1,9 @@
+export class ClientInstance {
+    static map = new Map();
+    New(key, clientFactory) {
+        if (!ClientInstance.map.has(key)) {
+            ClientInstance.map.set(key, clientFactory());
+        }
+        return ClientInstance.map.get(key);
+    }
+}

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

@@ -0,0 +1,4 @@
+import { ClientBuilder } from "../../v2/client/builder/index.js";
+import { ClientInstance } from "../../v2/client/client.js";
+import { MiddlewareBuilder } from "../../v2/client/middleware/index.js";
+export { ClientBuilder, ClientInstance, MiddlewareBuilder };

package/dist/v2/client/index.js

@@ -0,0 +1,4 @@
+import { ClientBuilder } from "../../v2/client/builder/index.js";
+import { ClientInstance } from "../../v2/client/client.js";
+import { MiddlewareBuilder } from "../../v2/client/middleware/index.js";
+export { ClientBuilder, ClientInstance, MiddlewareBuilder };

package/dist/v2/client/middleware/builder.d.ts

@@ -0,0 +1,16 @@
+import { BaseAuthService } from '../../../v2/pkg/types/index.js';
+import type { Middleware as OpenAPIMiddleware } from 'openapi-fetch';
+export declare class MiddlewareBuilder {
+    private service;
+    private fetchImpl;
+    private hasRequestClone;
+    private requestCloneMw;
+    private middlewares;
+    constructor(service: BaseAuthService, fetchImpl?: typeof fetch);
+    private addRequestClone;
+    withRequestClone(): this;
+    withAccessToken(): this;
+    withAutoRefresh(): this;
+    buildDefault(): OpenAPIMiddleware[];
+    build(): OpenAPIMiddleware[];
+}

package/dist/v2/client/middleware/builder.js

@@ -0,0 +1,48 @@
+import { Middleware } from '../../../v2/client/middleware/middleware.js';
+export class MiddlewareBuilder {
+    service;
+    fetchImpl;
+    hasRequestClone = false;
+    requestCloneMw = null;
+    middlewares = [];
+    constructor(service, fetchImpl = fetch) {
+        this.service = service;
+        this.fetchImpl = fetchImpl;
+    }
+    addRequestClone() {
+        if (!this.hasRequestClone) {
+            this.requestCloneMw = Middleware.requestClone();
+            this.hasRequestClone = true;
+        }
+    }
+    withRequestClone() {
+        this.addRequestClone();
+        return this;
+    }
+    withAccessToken() {
+        this.middlewares.push(Middleware.accessTokenAttacher(this.service));
+        return this;
+    }
+    // autoRefresh retries the original request after a successful refresh, so it
+    // implicitly requires the request clone middleware. Enabling it pulls in the
+    // clone automatically.
+    withAutoRefresh() {
+        this.addRequestClone();
+        this.middlewares.push(Middleware.autoRefresh(this.service, this.fetchImpl));
+        return this;
+    }
+    buildDefault() {
+        return [
+            Middleware.requestClone(),
+            Middleware.accessTokenAttacher(this.service),
+            Middleware.autoRefresh(this.service, this.fetchImpl),
+        ];
+    }
+    build() {
+        const result = [];
+        if (this.requestCloneMw) {
+            result.push(this.requestCloneMw);
+        }
+        return result.concat(this.middlewares);
+    }
+}

package/dist/v2/client/middleware/index.d.ts

@@ -0,0 +1,2 @@
+import { MiddlewareBuilder } from "../../../v2/client/middleware/builder.js";
+export { MiddlewareBuilder };

package/dist/v2/client/middleware/index.js

@@ -0,0 +1,2 @@
+import { MiddlewareBuilder } from "../../../v2/client/middleware/builder.js";
+export { MiddlewareBuilder };

package/dist/v2/client/middleware/middleware.d.ts

@@ -0,0 +1,7 @@
+import { BaseAuthService } from '../../../v2/pkg/types/index.js';
+import type { Middleware as OpenAPIMiddleware } from 'openapi-fetch';
+export declare class Middleware {
+    static requestClone(): OpenAPIMiddleware;
+    static accessTokenAttacher(service: BaseAuthService): OpenAPIMiddleware;
+    static autoRefresh(service: BaseAuthService, fetchImpl?: typeof fetch): OpenAPIMiddleware;
+}

package/dist/v2/client/middleware/middleware.js

@@ -0,0 +1,39 @@
+export class Middleware {
+    static requestClone() {
+        return {
+            async onRequest({ request }) {
+                const methodsWithBody = ['POST', 'PUT', 'PATCH', 'DELETE'];
+                if (methodsWithBody.includes(request.method.toUpperCase())) {
+                    request._clone = request.clone();
+                }
+                return request;
+            },
+        };
+    }
+    static accessTokenAttacher(service) {
+        return {
+            async onRequest({ request }) {
+                return service.RequestWithAccessToken(request);
+            }
+        };
+    }
+    static autoRefresh(service, fetchImpl = fetch) {
+        return {
+            async onResponse({ response, request }) {
+                if (response.status !== 401 || request.url.includes('/oauth/v2/token')) {
+                    return response;
+                }
+                const requestToRetry = request._clone || request;
+                const newAccessToken = await service.Refresh()
+                    .catch((e) => {
+                    console.error('failed to refresh', e);
+                    return null;
+                });
+                if (!newAccessToken) {
+                    return response;
+                }
+                return fetchImpl(service.RequestWithAccessToken(requestToRetry, newAccessToken));
+            },
+        };
+    }
+}

package/dist/v2/index.d.ts

@@ -0,0 +1,11 @@
+import { BaseAuthClientInstance, CreateAuthClientInstance } from "../v2/auth/client/index.js";
+import { createAuth } from "../v2/auth/factory.js";
+import type { Auth } from "../v2/auth/factory.js";
+import { AuthService, BaseAuthService } from "../v2/auth/service/index.js";
+import { ClientBuilder, ClientInstance, MiddlewareBuilder } from "../v2/client/index.js";
+import { CallbackError } from "../v2/pkg/errors/index.js";
+import type { CallbackErrorCode } from "../v2/pkg/errors/index.js";
+import type { GetMeResponse, HandleCallbackResult, RouteLocation, VerboseUserInfo, ZitadelConfig } from "../v2/pkg/types/index.js";
+import { RouterAuthGuard } from "../v2/vue/router-guard/index.js";
+export { AuthService, BaseAuthClientInstance, BaseAuthService, CallbackError, ClientBuilder, ClientInstance, createAuth, CreateAuthClientInstance, MiddlewareBuilder, RouterAuthGuard };
+export type { Auth, CallbackErrorCode, GetMeResponse, HandleCallbackResult, RouteLocation, VerboseUserInfo, ZitadelConfig };

package/dist/v2/index.js

@@ -0,0 +1,7 @@
+import { BaseAuthClientInstance, CreateAuthClientInstance } from "../v2/auth/client/index.js";
+import { createAuth } from "../v2/auth/factory.js";
+import { AuthService, BaseAuthService } from "../v2/auth/service/index.js";
+import { ClientBuilder, ClientInstance, MiddlewareBuilder } from "../v2/client/index.js";
+import { CallbackError } from "../v2/pkg/errors/index.js";
+import { RouterAuthGuard } from "../v2/vue/router-guard/index.js";
+export { AuthService, BaseAuthClientInstance, BaseAuthService, CallbackError, ClientBuilder, ClientInstance, createAuth, CreateAuthClientInstance, MiddlewareBuilder, RouterAuthGuard };

package/dist/v2/pkg/errors/errors.d.ts

@@ -0,0 +1,5 @@
+export type CallbackErrorCode = "state_mismatch" | "verifier_missing" | "code_missing" | "exchange_failed";
+export declare class CallbackError extends Error {
+    readonly code: CallbackErrorCode;
+    constructor(code: CallbackErrorCode, message?: string);
+}

package/dist/v2/pkg/errors/errors.js

@@ -0,0 +1,9 @@
+export class CallbackError extends Error {
+    code;
+    constructor(code, message) {
+        super(message ?? code);
+        this.name = "CallbackError";
+        this.code = code;
+        Object.setPrototypeOf(this, CallbackError.prototype);
+    }
+}

package/dist/v2/pkg/errors/index.d.ts

@@ -0,0 +1,4 @@
+import { CallbackError } from "../../../v2/pkg/errors/errors.js";
+import type { CallbackErrorCode } from "../../../v2/pkg/errors/errors.js";
+export { CallbackError };
+export type { CallbackErrorCode };

package/dist/v2/pkg/errors/index.js

@@ -0,0 +1,2 @@
+import { CallbackError } from "../../../v2/pkg/errors/errors.js";
+export { CallbackError };

package/dist/v2/pkg/localStorage/index.d.ts

@@ -0,0 +1,2 @@
+import { SessionKey, SessionStore, Storage, StorageKey } from "../../../v2/pkg/localStorage/localStorage.js";
+export { SessionKey, SessionStore, Storage, StorageKey };

package/dist/v2/pkg/localStorage/index.js

@@ -0,0 +1,2 @@
+import { SessionKey, SessionStore, Storage, StorageKey } from "../../../v2/pkg/localStorage/localStorage.js";
+export { SessionKey, SessionStore, Storage, StorageKey };

package/dist/v2/pkg/localStorage/localStorage.d.ts

@@ -0,0 +1,20 @@
+export declare const enum StorageKey {
+    ACCESS_TOKEN = "accessToken",
+    REFRESH_TOKEN = "refreshToken",
+    ID_TOKEN = "idToken"
+}
+export declare class Storage {
+    static Set(key: StorageKey, value: string): void;
+    static Delete(key: StorageKey): void;
+    static Get(key: StorageKey): string | null;
+}
+export declare const enum SessionKey {
+    PKCE_VERIFIER = "pkce_verifier",
+    PKCE_STATE = "pkce_state",
+    RETURN_TO = "pkce_return_to"
+}
+export declare class SessionStore {
+    static Set(key: SessionKey, value: string): void;
+    static Delete(key: SessionKey): void;
+    static Get(key: SessionKey): string | null;
+}

package/dist/v2/pkg/localStorage/localStorage.js

@@ -0,0 +1,34 @@
+export var StorageKey;
+(function (StorageKey) {
+    StorageKey["ACCESS_TOKEN"] = "accessToken";
+    StorageKey["REFRESH_TOKEN"] = "refreshToken";
+    StorageKey["ID_TOKEN"] = "idToken";
+})(StorageKey || (StorageKey = {}));
+export class Storage {
+    static Set(key, value) {
+        localStorage.setItem(key, value);
+    }
+    static Delete(key) {
+        localStorage.removeItem(key);
+    }
+    static Get(key) {
+        return localStorage.getItem(key);
+    }
+}
+export var SessionKey;
+(function (SessionKey) {
+    SessionKey["PKCE_VERIFIER"] = "pkce_verifier";
+    SessionKey["PKCE_STATE"] = "pkce_state";
+    SessionKey["RETURN_TO"] = "pkce_return_to";
+})(SessionKey || (SessionKey = {}));
+export class SessionStore {
+    static Set(key, value) {
+        sessionStorage.setItem(key, value);
+    }
+    static Delete(key) {
+        sessionStorage.removeItem(key);
+    }
+    static Get(key) {
+        return sessionStorage.getItem(key);
+    }
+}

package/dist/v2/pkg/pkce/index.d.ts

@@ -0,0 +1,2 @@
+import { challengeS256, generateState, generateVerifier } from "../../../v2/pkg/pkce/pkce.js";
+export { challengeS256, generateState, generateVerifier };

package/dist/v2/pkg/pkce/index.js

@@ -0,0 +1,2 @@
+import { challengeS256, generateState, generateVerifier } from "../../../v2/pkg/pkce/pkce.js";
+export { challengeS256, generateState, generateVerifier };

package/dist/v2/pkg/pkce/pkce.d.ts

@@ -0,0 +1,3 @@
+export declare function generateVerifier(length?: number): string;
+export declare function generateState(): string;
+export declare function challengeS256(verifier: string): Promise<string>;

package/dist/v2/pkg/pkce/pkce.js

@@ -0,0 +1,30 @@
+const VERIFIER_CHARSET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~";
+function randomBytes(length) {
+    const bytes = new Uint8Array(length);
+    crypto.getRandomValues(bytes);
+    return bytes;
+}
+function base64UrlEncode(bytes) {
+    let binary = "";
+    for (let i = 0; i < bytes.length; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+export function generateVerifier(length = 64) {
+    const size = Math.min(128, Math.max(43, length));
+    const bytes = randomBytes(size);
+    let verifier = "";
+    for (let i = 0; i < size; i++) {
+        verifier += VERIFIER_CHARSET[bytes[i] % VERIFIER_CHARSET.length];
+    }
+    return verifier;
+}
+export function generateState() {
+    return base64UrlEncode(randomBytes(32));
+}
+export async function challengeS256(verifier) {
+    const data = new TextEncoder().encode(verifier);
+    const digest = await crypto.subtle.digest("SHA-256", data);
+    return base64UrlEncode(new Uint8Array(digest));
+}

package/dist/v2/pkg/types/authClient.d.ts

@@ -0,0 +1,3 @@
+import { paths } from "@dehwyyy/auth/v2/pkg/types/schema";
+import createClient from "openapi-fetch";
+export type HttpAuthClient = ReturnType<typeof createClient<paths>>;

package/dist/{types.js → v2/pkg/types/authClient.js}

@@ -1,2 +1 @@
-;
 export {};

package/dist/v2/pkg/types/authService.d.ts

@@ -0,0 +1,42 @@
+import { components } from "@dehwyyy/auth/v2/pkg/types/schema";
+type UserInfo = components["schemas"]["UserInfo"];
+export type ZitadelConfig = {
+    issuer: string;
+    clientId: string;
+    redirectUri: string;
+    postLogoutRedirectUri?: string;
+    scopes?: string[];
+};
+export type VerboseUserInfo = {
+    username?: UserInfo["preferred_username"];
+    email?: UserInfo["email"];
+    email_verified?: UserInfo["email_verified"];
+    name?: UserInfo["name"];
+    picture?: UserInfo["picture"];
+};
+export type GetMeResponse = {
+    user_id: UserInfo["sub"];
+    roles: string[];
+    active: boolean;
+    info?: VerboseUserInfo;
+};
+export type HandleCallbackResult = {
+    me: GetMeResponse | null;
+    returnTo: string | null;
+};
+export type RouteLocation = {
+    path: string;
+    fullPath: string;
+    query: Record<string, string | null | (string | null)[] | undefined>;
+};
+export interface BaseAuthService {
+    RequestWithAccessToken(req: Request, token?: string | null): Request;
+    Refresh(): Promise<string | null>;
+}
+export interface AuthService {
+    Login(returnTo?: string): Promise<void>;
+    HandleCallback(): Promise<HandleCallbackResult>;
+    GetMe(verbose?: boolean): Promise<GetMeResponse | null>;
+    Logout(): Promise<void>;
+}
+export {};

package/dist/v2/pkg/types/authService.js

@@ -0,0 +1 @@
+export {};

package/dist/v2/pkg/types/index.d.ts

@@ -0,0 +1,3 @@
+import type { HttpAuthClient } from "../../../v2/pkg/types/authClient.js";
+import type { AuthService, BaseAuthService, GetMeResponse, HandleCallbackResult, RouteLocation, VerboseUserInfo, ZitadelConfig } from "../../../v2/pkg/types/authService.js";
+export { AuthService, BaseAuthService, GetMeResponse, HandleCallbackResult, HttpAuthClient, RouteLocation, VerboseUserInfo, ZitadelConfig };

package/dist/v2/pkg/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/v2/pkg/url/index.d.ts

@@ -0,0 +1,2 @@
+import { normalizeIssuer, pathnameOf, sanitizeReturnTo } from "../../../v2/pkg/url/url.js";
+export { normalizeIssuer, pathnameOf, sanitizeReturnTo };

package/dist/v2/pkg/url/index.js

@@ -0,0 +1,2 @@
+import { normalizeIssuer, pathnameOf, sanitizeReturnTo } from "../../../v2/pkg/url/url.js";
+export { normalizeIssuer, pathnameOf, sanitizeReturnTo };

package/dist/v2/pkg/url/url.d.ts

@@ -0,0 +1,8 @@
+export declare function normalizeIssuer(issuer: string): string;
+export declare function pathnameOf(url: string): string;
+/**
+ * Returns `returnTo` only when it is safe to redirect to (relative path or
+ * same-origin absolute URL). Absolute URLs pointing at a foreign origin are
+ * rejected (returns null) to close open-redirect vectors inside the library.
+ */
+export declare function sanitizeReturnTo(returnTo: string | null): string | null;

package/dist/v2/pkg/url/url.js

@@ -0,0 +1,40 @@
+export function normalizeIssuer(issuer) {
+    return issuer.replace(/\/+$/, "");
+}
+export function pathnameOf(url) {
+    try {
+        return new URL(url, "http://localhost").pathname;
+    }
+    catch {
+        return url;
+    }
+}
+/**
+ * Returns `returnTo` only when it is safe to redirect to (relative path or
+ * same-origin absolute URL). Absolute URLs pointing at a foreign origin are
+ * rejected (returns null) to close open-redirect vectors inside the library.
+ */
+export function sanitizeReturnTo(returnTo) {
+    if (!returnTo) {
+        return null;
+    }
+    // Single-slash absolute path only. Reject protocol-relative forms: a second
+    // "/" or a "\" after the first slash (browsers normalize "\" -> "/", so
+    // "/\evil.com/x" would otherwise navigate cross-origin).
+    if (/^\/(?![/\\])/.test(returnTo)) {
+        return returnTo;
+    }
+    if (typeof location === "undefined") {
+        return null;
+    }
+    try {
+        const parsed = new URL(returnTo, location.origin);
+        if (parsed.origin === location.origin) {
+            return parsed.pathname + parsed.search + parsed.hash;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}

package/dist/v2/vue/router-guard/guard.d.ts

@@ -0,0 +1,27 @@
+import { AuthService, GetMeResponse, RouteLocation } from "../../../v2/pkg/types/index.js";
+type User = Omit<GetMeResponse, "info">;
+interface RouterAuthGuardProps {
+    callbackPath: string;
+    cacheTTL?: number;
+    onGetMe: (data: User | null) => void;
+    fallbackPage: string;
+    baseServiceURL: string;
+}
+type DynamicUnauthorizedRedirect = {
+    to: string;
+    roles: string[];
+}[];
+export declare class RouterAuthGuard {
+    private authService;
+    private props;
+    private getMeCache;
+    constructor(authService: AuthService, props: RouterAuthGuardProps);
+    private cacheTTL;
+    private queryValue;
+    private hasCode;
+    private isCallback;
+    Authorized(roles?: string[]): (to: RouteLocation, _from: RouteLocation) => Promise<string | boolean>;
+    Unauthorized(redirectProps: DynamicUnauthorizedRedirect): (_to: RouteLocation, _from: RouteLocation) => Promise<string | true>;
+    private RolesIntercept;
+}
+export {};

package/dist/v2/vue/router-guard/guard.js

@@ -0,0 +1,105 @@
+const DEFAULT_CACHE_TTL_MS = 15_000;
+export class RouterAuthGuard {
+    authService;
+    props;
+    getMeCache = null;
+    constructor(authService, props) {
+        this.authService = authService;
+        this.props = props;
+    }
+    cacheTTL() {
+        return this.props.cacheTTL ?? DEFAULT_CACHE_TTL_MS;
+    }
+    queryValue(value) {
+        const v = Array.isArray(value) ? value[0] : value;
+        return typeof v === "string" ? v : "";
+    }
+    hasCode(query) {
+        return Boolean(this.queryValue(query.code)) && Boolean(this.queryValue(query.state));
+    }
+    // The callback may only be entered on the configured callbackPath with both
+    // code and state present. Matching any route with ?code&state would let an
+    // attacker bypass the guard by appending those params to any protected URL.
+    isCallback(to) {
+        if (to.path !== this.props.callbackPath) {
+            return false;
+        }
+        if (this.hasCode(to.query ?? {})) {
+            return true;
+        }
+        if (typeof location !== "undefined" && location.search) {
+            const params = new URLSearchParams(location.search);
+            return Boolean(params.get("code")) && Boolean(params.get("state"));
+        }
+        return false;
+    }
+    Authorized(roles = []) {
+        return async (to, _from) => {
+            // Let the callback page resolve the OIDC redirect; do not bounce to login.
+            if (this.isCallback(to)) {
+                return true;
+            }
+            // If cache is valid
+            if (this.getMeCache && this.getMeCache.expiresAt > Date.now()) {
+                return this.RolesIntercept(roles, this.getMeCache.data.roles || [])
+                    ? true
+                    : this.props.fallbackPage;
+            }
+            try {
+                const data = await this.authService.GetMe();
+                this.props.onGetMe(data);
+                if (!data) {
+                    this.getMeCache = null;
+                    await this.authService.Login(this.props.baseServiceURL + to.fullPath);
+                    return false;
+                }
+                this.getMeCache = {
+                    data,
+                    expiresAt: Date.now() + this.cacheTTL(),
+                };
+                if (!this.RolesIntercept(roles, data.roles || [])) {
+                    return this.props.fallbackPage;
+                }
+                return true;
+            }
+            catch (e) {
+                console.error("failed to authorize:", e);
+            }
+            return false;
+        };
+    }
+    Unauthorized(redirectProps) {
+        return async (_to, _from) => {
+            // If cache is valid
+            let roles = [];
+            // Try to get user from cache
+            if (this.getMeCache && this.getMeCache.expiresAt > Date.now()) {
+                roles = this.getMeCache.data.roles || [];
+            }
+            else {
+                // Or get user from API
+                const user = await this.authService.GetMe();
+                this.props.onGetMe(user);
+                if (user) {
+                    this.getMeCache = {
+                        data: user,
+                        expiresAt: Date.now() + this.cacheTTL(),
+                    };
+                    roles = user.roles || [];
+                }
+            }
+            for (const { to, roles: requiredRoles } of redirectProps) {
+                if (this.RolesIntercept(requiredRoles, roles)) {
+                    return to;
+                }
+            }
+            return true;
+        };
+    }
+    RolesIntercept(requiredRoles, userRoles) {
+        if (requiredRoles.length === 0) {
+            return true;
+        }
+        return requiredRoles.filter(role => userRoles.includes(role)).length !== 0;
+    }
+}

package/dist/v2/vue/router-guard/index.d.ts

@@ -0,0 +1 @@
+export { RouterAuthGuard } from "../../../v2/vue/router-guard/guard.js";

package/dist/v2/vue/router-guard/index.js

@@ -0,0 +1 @@
+export { RouterAuthGuard } from "../../../v2/vue/router-guard/guard.js";

package/package.json

@@ -1,27 +1,31 @@
 {
   "name": "@dehwyyy/auth",
-  "version": "1.0.5",
+  "version": "2.0.0",
   "private": false,
   "description": "dehwyyy auth utilities",
   "type": "module",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "module": "dist/v2/index.js",
+  "types": "dist/v2/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js"
+      "types": "./dist/v2/index.d.ts",
+      "import": "./dist/v2/index.js"
     },
-    "./guard": {
-      "import": "./dist/guard/index.js"
+    "./v2": {
+      "types": "./dist/v2/index.d.ts",
+      "import": "./dist/v2/index.js"
     }
   },
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "tsc",
+    "gen": "openapi-typescript ./spec/zitadel-oidc.yaml -o ./src/v2/pkg/types/schema.d.ts",
+    "build": "tsc && tsc-alias --resolve-full-paths",
     "prepack": "npm run build",
     "lint": "prettier --check .",
-    "ts": "tsc",
+    "ts": "tsc && tsc-alias --resolve-full-paths",
+    "test": "bun test",
     "format": "prettier --write ."
   },
   "engines": {
@@ -32,10 +36,13 @@
     "dehwyyy",
     "dehwyyyauth"
   ],
-  "author": "",
+  "author": "dehwyy",
   "license": "MIT",
   "devDependencies": {
+    "@types/bun": "^1.1.0",
+    "openapi-typescript": "^7.4.0",
     "prettier": "^3.0.0",
+    "tsc-alias": "^1.8.16",
     "typescript": "5.8.2"
   },
   "dependencies": {

package/dist/client/client.d.ts

@@ -1,2 +0,0 @@
-import type { paths } from './schema';
-export declare const getClient: (app: string, baseUrl: string, redirectBaseUrl: string, redirectUriPrefix?: string) => import("openapi-fetch").Client<paths, `${string}/${string}`>;

package/dist/client/client.js

@@ -1,14 +0,0 @@
-import createClient from 'openapi-fetch';
-import { Middleware } from './middleware';
-let client = null;
-export const getClient = (app, baseUrl, redirectBaseUrl, redirectUriPrefix = "") => {
-    if (!client) {
-        client = createClient({
-            baseUrl,
-            credentials: 'include',
-        });
-        const middleware = new Middleware(app, baseUrl, redirectBaseUrl, redirectUriPrefix);
-        client.use(middleware.RequestCloner, middleware.AuthorizationHeaderAttacher, middleware.TokenRefresher);
-    }
-    return client;
-};