@saasicat/ui-vue 0.2.0

package/src/use-bundle-versions-map.ts

@@ -0,0 +1,112 @@
+// useBundleVersionsMap — loads the versions for each bundle in parallel and
+// keeps the mapping `bundleId → BundleVersionRow[]` reactive. Used by the
+// BundlesPage to correctly compute KPIs (live / scheduled / drafts) and a
+// status filter across all bundles — before the user opens an accordion.
+//
+// Trade-off: 1+N HTTP requests on mount. Acceptable for SuperAdmin setups
+// with few bundles (today typically < 20). A backend optimization via an
+// aggregate endpoint (`/admin/catalog/bundles?include=versions` or
+// `/admin/catalog/bundles/aggregates`) can come later additively, without
+// breaking this composable API.
+
+import { ref, watch, type Ref } from 'vue';
+import type { BundleRow, BundleVersionRow } from '@saasicat/types';
+import { defaultHttpClient, type HttpClient } from './types.js';
+
+export interface UseBundleVersionsMapOptions {
+    adminEndpoint: string;
+    /** Reactive list of bundle roots; the watcher reloads when the IDs change. */
+    bundles: Ref<BundleRow[]>;
+    http?: HttpClient;
+    getAuthToken?: () => string | null;
+}
+
+export interface UseBundleVersionsMapResult {
+    /** `bundleId → BundleVersionRow[]`. Empty list for bundles without versions. */
+    versionsByBundle: Ref<Record<string, BundleVersionRow[]>>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    /** Forces a reload of all bundle versions. */
+    refresh: () => Promise<void>;
+    /** Refresh only a single bundle (e.g. after an inline-editor save). */
+    refreshOne: (bundleId: string) => Promise<void>;
+}
+
+export function useBundleVersionsMap(
+    options: UseBundleVersionsMapOptions,
+): UseBundleVersionsMapResult {
+    if (!options?.adminEndpoint) {
+        throw new Error('useBundleVersionsMap: `adminEndpoint` ist Pflicht.');
+    }
+    if (!options?.bundles) {
+        throw new Error('useBundleVersionsMap: `bundles` ist Pflicht.');
+    }
+
+    const http = options.http ?? defaultHttpClient();
+    const versionsByBundle = ref<Record<string, BundleVersionRow[]>>({});
+    const loading = ref(false);
+    const error = ref<Error | null>(null);
+
+    function authHeaders(): Record<string, string> {
+        const token = options.getAuthToken?.();
+        return token ? { Authorization: `Bearer ${token}` } : {};
+    }
+
+    async function loadForBundle(bundleId: string): Promise<BundleVersionRow[]> {
+        const res = await http(`${options.adminEndpoint}/catalog/bundles/${bundleId}/versions`, {
+            method: 'GET',
+            headers: { 'content-type': 'application/json', ...authHeaders() },
+        });
+        if (res.status >= 400) {
+            throw new Error(`HTTP ${res.status} beim Laden der Versionen für Bundle '${bundleId}'`);
+        }
+        return ((await res.json().catch(() => null)) as BundleVersionRow[] | null) ?? [];
+    }
+
+    async function refresh(): Promise<void> {
+        loading.value = true;
+        error.value = null;
+        try {
+            const entries = await Promise.all(
+                options.bundles.value.map(async (b) => {
+                    try {
+                        const versions = await loadForBundle(b.id);
+                        return [b.id, versions] as const;
+                    } catch (err) {
+                        console.warn(
+                            `useBundleVersionsMap: Bundle '${b.bundleKey}' Versions-Load failed`,
+                            err,
+                        );
+                        return [b.id, []] as const;
+                    }
+                }),
+            );
+            versionsByBundle.value = Object.fromEntries(entries);
+        } catch (err) {
+            error.value = err instanceof Error ? err : new Error(String(err));
+        } finally {
+            loading.value = false;
+        }
+    }
+
+    async function refreshOne(bundleId: string): Promise<void> {
+        try {
+            const versions = await loadForBundle(bundleId);
+            versionsByBundle.value = { ...versionsByBundle.value, [bundleId]: versions };
+        } catch (err) {
+            console.warn(`useBundleVersionsMap: refreshOne('${bundleId}') failed`, err);
+        }
+    }
+
+    // Auto-refresh when the bundle list changes (creation, soft-delete).
+    watch(
+        () => options.bundles.value.map((b) => b.id).join(','),
+        () => {
+            if (options.bundles.value.length > 0) void refresh();
+            else versionsByBundle.value = {};
+        },
+        { immediate: true },
+    );
+
+    return { versionsByBundle, loading, error, refresh, refreshOne };
+}

package/src/use-bundles.ts

@@ -0,0 +1,297 @@
+// useBundles + useBundleVersions — Vue 3 composables for SuperAdmin
+// bundle management (backend: BundlesController under
+// /admin/catalog/bundles + /admin/catalog/bundle-versions).
+//
+// **The endpoint prefix is required** and is supplied by the consumer
+// (e.g. `/api/admin` or `/api/v1/admin`). The composables append
+// the catalog paths themselves — the consumer supplies only the admin prefix.
+
+import { ref, type Ref } from 'vue';
+import type {
+    BundleRow,
+    BundleVersionMutationResult,
+    BundleVersionRow,
+    CreateBundleData,
+    CreateBundleVersionDraftData,
+    UpdateBundleData,
+    UpdateBundleVersionDraftData,
+} from '@saasicat/types';
+import { defaultHttpClient, type HttpClient } from './types.js';
+
+export interface UseBundlesOptions {
+    /**
+     * Fully-qualified admin endpoint prefix including the app globalPrefix
+     * (`/api/admin`, `/api/v1/admin`, …). Required. The composable appends
+     * the catalog paths itself (`/catalog/bundles`).
+     */
+    adminEndpoint: string;
+    http?: HttpClient;
+    getAuthToken?: () => string | null;
+    /** Required: projectKey the list is filtered against. */
+    projectKey: string;
+    /** When `true`, loads on composable init. Default `false`. */
+    autoLoad?: boolean;
+}
+
+export class BundlesApiError extends Error {
+    constructor(
+        public readonly status: number,
+        public readonly body: unknown,
+        message: string,
+    ) {
+        super(message);
+        this.name = 'BundlesApiError';
+    }
+}
+
+export interface UseBundlesResult {
+    bundles: Ref<BundleRow[]>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+
+    load: () => Promise<void>;
+    create: (data: CreateBundleData) => Promise<BundleRow>;
+    update: (bundleId: string, data: UpdateBundleData) => Promise<BundleRow>;
+    softDelete: (bundleId: string) => Promise<void>;
+}
+
+export function useBundles(options: UseBundlesOptions): UseBundlesResult {
+    if (!options?.adminEndpoint) {
+        throw new Error(
+            'useBundles: `adminEndpoint` ist Pflicht (z. B. "/api/admin" oder ' +
+                '"/api/v1/admin"). Plattform hat keinen Default, weil Apps ' +
+                'unterschiedliche globalPrefix-Konventionen haben.',
+        );
+    }
+    if (!options?.projectKey) {
+        throw new Error('useBundles: `projectKey` ist Pflicht.');
+    }
+
+    const http = options.http ?? defaultHttpClient();
+    const bundles = ref<BundleRow[]>([]);
+    const loading = ref(false);
+    const error = ref<Error | null>(null);
+
+    const baseUrl = `${options.adminEndpoint}/catalog/bundles`;
+
+    function authHeaders(): Record<string, string> {
+        const token = options.getAuthToken?.();
+        return token ? { Authorization: `Bearer ${token}` } : {};
+    }
+
+    async function fetchJson<T>(url: string, init?: Parameters<HttpClient>[1]): Promise<T | null> {
+        const res = await http(url, {
+            method: init?.method ?? 'GET',
+            headers: { 'content-type': 'application/json', ...authHeaders(), ...init?.headers },
+            body: init?.body,
+        });
+        if (res.status === 204) return null;
+        const body = await res.json().catch(() => null);
+        if (res.status >= 400) {
+            throw new BundlesApiError(
+                res.status,
+                body,
+                `Bundles-API antwortete mit HTTP ${res.status}`,
+            );
+        }
+        return body as T;
+    }
+
+    async function load(): Promise<void> {
+        loading.value = true;
+        error.value = null;
+        try {
+            const data = await fetchJson<BundleRow[]>(
+                `${baseUrl}?projectKey=${encodeURIComponent(options.projectKey)}`,
+            );
+            bundles.value = data ?? [];
+        } catch (err) {
+            error.value = err instanceof Error ? err : new Error(String(err));
+        } finally {
+            loading.value = false;
+        }
+    }
+
+    async function create(data: CreateBundleData): Promise<BundleRow> {
+        const created = await fetchJson<BundleRow>(baseUrl, {
+            method: 'POST',
+            body: JSON.stringify(data),
+        });
+        if (!created) throw new BundlesApiError(0, null, 'Create gab keinen Body zurück');
+        bundles.value = [...bundles.value, created];
+        return created;
+    }
+
+    async function update(bundleId: string, data: UpdateBundleData): Promise<BundleRow> {
+        const updated = await fetchJson<BundleRow>(`${baseUrl}/${bundleId}`, {
+            method: 'PATCH',
+            body: JSON.stringify(data),
+        });
+        if (!updated) throw new BundlesApiError(0, null, 'Update gab keinen Body zurück');
+        bundles.value = bundles.value.map((b) => (b.id === bundleId ? updated : b));
+        return updated;
+    }
+
+    async function softDelete(bundleId: string): Promise<void> {
+        await fetchJson<null>(`${baseUrl}/${bundleId}`, { method: 'DELETE' });
+        bundles.value = bundles.value.filter((b) => b.id !== bundleId);
+    }
+
+    if (options.autoLoad) {
+        void load();
+    }
+
+    return { bundles, loading, error, load, create, update, softDelete };
+}
+
+// =============================================================================
+// useBundleVersions — lifecycle operations for a concrete bundle ID
+// =============================================================================
+
+export interface UseBundleVersionsOptions {
+    adminEndpoint: string;
+    bundleId: string;
+    http?: HttpClient;
+    getAuthToken?: () => string | null;
+    autoLoad?: boolean;
+}
+
+export interface UseBundleVersionsResult {
+    versions: Ref<BundleVersionRow[]>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+
+    load: () => Promise<void>;
+    /** Returns {row, warnings} — warnings should be shown to the user as a banner. */
+    createDraft: (
+        data: Omit<CreateBundleVersionDraftData, 'bundleId'>,
+    ) => Promise<BundleVersionMutationResult>;
+    updateDraft: (
+        versionId: string,
+        data: UpdateBundleVersionDraftData,
+    ) => Promise<BundleVersionMutationResult>;
+    publish: (
+        versionId: string,
+        opts?: {
+            forceRegressive?: boolean;
+            allowZeroPrice?: boolean;
+            validFrom?: string | null;
+            validUntil?: string | null;
+        },
+    ) => Promise<BundleVersionMutationResult>;
+    /**
+     * Discards a draft (`DELETE /admin/catalog/bundle-versions/:id`).
+     * Published versions cannot be discarded — the API responds
+     * with 422 `BUNDLE_VERSION_ALREADY_PUBLISHED`.
+     */
+    discardDraft: (versionId: string) => Promise<void>;
+}
+
+export function useBundleVersions(options: UseBundleVersionsOptions): UseBundleVersionsResult {
+    if (!options?.adminEndpoint) {
+        throw new Error('useBundleVersions: `adminEndpoint` ist Pflicht.');
+    }
+    if (!options?.bundleId) {
+        throw new Error('useBundleVersions: `bundleId` ist Pflicht.');
+    }
+
+    const http = options.http ?? defaultHttpClient();
+    const versions = ref<BundleVersionRow[]>([]);
+    const loading = ref(false);
+    const error = ref<Error | null>(null);
+
+    const bundleVersionsUrl = `${options.adminEndpoint}/catalog/bundles/${options.bundleId}/versions`;
+    const versionUrlBase = `${options.adminEndpoint}/catalog/bundle-versions`;
+
+    function authHeaders(): Record<string, string> {
+        const token = options.getAuthToken?.();
+        return token ? { Authorization: `Bearer ${token}` } : {};
+    }
+
+    async function fetchJson<T>(url: string, init?: Parameters<HttpClient>[1]): Promise<T | null> {
+        const res = await http(url, {
+            method: init?.method ?? 'GET',
+            headers: { 'content-type': 'application/json', ...authHeaders(), ...init?.headers },
+            body: init?.body,
+        });
+        if (res.status === 204) return null;
+        const body = await res.json().catch(() => null);
+        if (res.status >= 400) {
+            throw new BundlesApiError(
+                res.status,
+                body,
+                `BundleVersions-API antwortete mit HTTP ${res.status}`,
+            );
+        }
+        return body as T;
+    }
+
+    async function load(): Promise<void> {
+        loading.value = true;
+        error.value = null;
+        try {
+            const data = await fetchJson<BundleVersionRow[]>(bundleVersionsUrl);
+            versions.value = data ?? [];
+        } catch (err) {
+            error.value = err instanceof Error ? err : new Error(String(err));
+        } finally {
+            loading.value = false;
+        }
+    }
+
+    async function createDraft(
+        data: Omit<CreateBundleVersionDraftData, 'bundleId'>,
+    ): Promise<BundleVersionMutationResult> {
+        const result = await fetchJson<BundleVersionMutationResult>(bundleVersionsUrl, {
+            method: 'POST',
+            body: JSON.stringify(data),
+        });
+        if (!result) throw new BundlesApiError(0, null, 'CreateDraft gab keinen Body zurück');
+        versions.value = [...versions.value, result.bundleVersion];
+        return result;
+    }
+
+    async function updateDraft(
+        versionId: string,
+        data: UpdateBundleVersionDraftData,
+    ): Promise<BundleVersionMutationResult> {
+        const result = await fetchJson<BundleVersionMutationResult>(
+            `${versionUrlBase}/${versionId}`,
+            { method: 'PATCH', body: JSON.stringify(data) },
+        );
+        if (!result) throw new BundlesApiError(0, null, 'UpdateDraft gab keinen Body zurück');
+        versions.value = versions.value.map((v) => (v.id === versionId ? result.bundleVersion : v));
+        return result;
+    }
+
+    async function publish(
+        versionId: string,
+        opts: {
+            forceRegressive?: boolean;
+            allowZeroPrice?: boolean;
+            validFrom?: string | null;
+            validUntil?: string | null;
+        } = {},
+    ): Promise<BundleVersionMutationResult> {
+        const result = await fetchJson<BundleVersionMutationResult>(
+            `${versionUrlBase}/${versionId}/publish`,
+            { method: 'POST', body: JSON.stringify(opts) },
+        );
+        if (!result) throw new BundlesApiError(0, null, 'Publish gab keinen Body zurück');
+        // Reload versions, because publishing may mark another version as
+        // superseded — the local cache would otherwise be inconsistent.
+        await load();
+        return result;
+    }
+
+    async function discardDraft(versionId: string): Promise<void> {
+        await fetchJson<null>(`${versionUrlBase}/${versionId}`, { method: 'DELETE' });
+        versions.value = versions.value.filter((v) => v.id !== versionId);
+    }
+
+    if (options.autoLoad) {
+        void load();
+    }
+
+    return { versions, loading, error, load, createDraft, updateDraft, publish, discardDraft };
+}

package/src/use-business-types.ts

@@ -0,0 +1,269 @@
+// useBusinessTypes + useBusinessTypeVersions — Vue 3 composables for
+// SuperAdmin business-type management (backend: BusinessTypesController under
+// /admin/catalog/business-types + /admin/catalog/business-type-versions).
+//
+// Pattern analogous to use-bundles.ts.
+
+import { ref, type Ref } from 'vue';
+import type {
+    BusinessTypeRow,
+    BusinessTypeVersionMutationResult,
+    BusinessTypeVersionRow,
+    CreateBusinessTypeData,
+    CreateBusinessTypeVersionDraftData,
+    UpdateBusinessTypeData,
+    UpdateBusinessTypeVersionDraftData,
+} from '@saasicat/types';
+import { defaultHttpClient, type HttpClient } from './types.js';
+
+export interface UseBusinessTypesOptions {
+    adminEndpoint: string;
+    http?: HttpClient;
+    getAuthToken?: () => string | null;
+    projectKey: string;
+    autoLoad?: boolean;
+}
+
+export class BusinessTypesApiError extends Error {
+    constructor(
+        public readonly status: number,
+        public readonly body: unknown,
+        message: string,
+    ) {
+        super(message);
+        this.name = 'BusinessTypesApiError';
+    }
+}
+
+export interface UseBusinessTypesResult {
+    businessTypes: Ref<BusinessTypeRow[]>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+
+    load: () => Promise<void>;
+    create: (data: CreateBusinessTypeData) => Promise<BusinessTypeRow>;
+    update: (businessTypeId: string, data: UpdateBusinessTypeData) => Promise<BusinessTypeRow>;
+    softDelete: (businessTypeId: string) => Promise<void>;
+}
+
+export function useBusinessTypes(options: UseBusinessTypesOptions): UseBusinessTypesResult {
+    if (!options?.adminEndpoint) {
+        throw new Error('useBusinessTypes: `adminEndpoint` ist Pflicht.');
+    }
+    if (!options?.projectKey) {
+        throw new Error('useBusinessTypes: `projectKey` ist Pflicht.');
+    }
+
+    const http = options.http ?? defaultHttpClient();
+    const businessTypes = ref<BusinessTypeRow[]>([]);
+    const loading = ref(false);
+    const error = ref<Error | null>(null);
+
+    const baseUrl = `${options.adminEndpoint}/catalog/business-types`;
+
+    function authHeaders(): Record<string, string> {
+        const token = options.getAuthToken?.();
+        return token ? { Authorization: `Bearer ${token}` } : {};
+    }
+
+    async function fetchJson<T>(url: string, init?: Parameters<HttpClient>[1]): Promise<T | null> {
+        const res = await http(url, {
+            method: init?.method ?? 'GET',
+            headers: { 'content-type': 'application/json', ...authHeaders(), ...init?.headers },
+            body: init?.body,
+        });
+        if (res.status === 204) return null;
+        const body = await res.json().catch(() => null);
+        if (res.status >= 400) {
+            throw new BusinessTypesApiError(
+                res.status,
+                body,
+                `BusinessTypes-API antwortete mit HTTP ${res.status}`,
+            );
+        }
+        return body as T;
+    }
+
+    async function load(): Promise<void> {
+        loading.value = true;
+        error.value = null;
+        try {
+            const data = await fetchJson<BusinessTypeRow[]>(
+                `${baseUrl}?projectKey=${encodeURIComponent(options.projectKey)}`,
+            );
+            businessTypes.value = data ?? [];
+        } catch (err) {
+            error.value = err instanceof Error ? err : new Error(String(err));
+        } finally {
+            loading.value = false;
+        }
+    }
+
+    async function create(data: CreateBusinessTypeData): Promise<BusinessTypeRow> {
+        const created = await fetchJson<BusinessTypeRow>(baseUrl, {
+            method: 'POST',
+            body: JSON.stringify(data),
+        });
+        if (!created) throw new BusinessTypesApiError(0, null, 'Create gab keinen Body zurück');
+        businessTypes.value = [...businessTypes.value, created];
+        return created;
+    }
+
+    async function update(
+        businessTypeId: string,
+        data: UpdateBusinessTypeData,
+    ): Promise<BusinessTypeRow> {
+        const updated = await fetchJson<BusinessTypeRow>(`${baseUrl}/${businessTypeId}`, {
+            method: 'PATCH',
+            body: JSON.stringify(data),
+        });
+        if (!updated) throw new BusinessTypesApiError(0, null, 'Update gab keinen Body zurück');
+        businessTypes.value = businessTypes.value.map((b) =>
+            b.id === businessTypeId ? updated : b,
+        );
+        return updated;
+    }
+
+    async function softDelete(businessTypeId: string): Promise<void> {
+        await fetchJson<null>(`${baseUrl}/${businessTypeId}`, { method: 'DELETE' });
+        businessTypes.value = businessTypes.value.filter((b) => b.id !== businessTypeId);
+    }
+
+    if (options.autoLoad) {
+        void load();
+    }
+
+    return { businessTypes, loading, error, load, create, update, softDelete };
+}
+
+// =============================================================================
+// useBusinessTypeVersions
+// =============================================================================
+
+export interface UseBusinessTypeVersionsOptions {
+    adminEndpoint: string;
+    businessTypeId: string;
+    http?: HttpClient;
+    getAuthToken?: () => string | null;
+    autoLoad?: boolean;
+}
+
+export interface UseBusinessTypeVersionsResult {
+    versions: Ref<BusinessTypeVersionRow[]>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+
+    load: () => Promise<void>;
+    createDraft: (
+        data: Omit<CreateBusinessTypeVersionDraftData, 'businessTypeId'>,
+    ) => Promise<BusinessTypeVersionMutationResult>;
+    updateDraft: (
+        versionId: string,
+        data: UpdateBusinessTypeVersionDraftData,
+    ) => Promise<BusinessTypeVersionMutationResult>;
+    publish: (
+        versionId: string,
+        opts?: { forceRegressive?: boolean },
+    ) => Promise<BusinessTypeVersionMutationResult>;
+}
+
+export function useBusinessTypeVersions(
+    options: UseBusinessTypeVersionsOptions,
+): UseBusinessTypeVersionsResult {
+    if (!options?.adminEndpoint) {
+        throw new Error('useBusinessTypeVersions: `adminEndpoint` ist Pflicht.');
+    }
+    if (!options?.businessTypeId) {
+        throw new Error('useBusinessTypeVersions: `businessTypeId` ist Pflicht.');
+    }
+
+    const http = options.http ?? defaultHttpClient();
+    const versions = ref<BusinessTypeVersionRow[]>([]);
+    const loading = ref(false);
+    const error = ref<Error | null>(null);
+
+    const versionsUrl = `${options.adminEndpoint}/catalog/business-types/${options.businessTypeId}/versions`;
+    const versionUrlBase = `${options.adminEndpoint}/catalog/business-type-versions`;
+
+    function authHeaders(): Record<string, string> {
+        const token = options.getAuthToken?.();
+        return token ? { Authorization: `Bearer ${token}` } : {};
+    }
+
+    async function fetchJson<T>(url: string, init?: Parameters<HttpClient>[1]): Promise<T | null> {
+        const res = await http(url, {
+            method: init?.method ?? 'GET',
+            headers: { 'content-type': 'application/json', ...authHeaders(), ...init?.headers },
+            body: init?.body,
+        });
+        if (res.status === 204) return null;
+        const body = await res.json().catch(() => null);
+        if (res.status >= 400) {
+            throw new BusinessTypesApiError(
+                res.status,
+                body,
+                `BusinessTypeVersions-API antwortete mit HTTP ${res.status}`,
+            );
+        }
+        return body as T;
+    }
+
+    async function load(): Promise<void> {
+        loading.value = true;
+        error.value = null;
+        try {
+            const data = await fetchJson<BusinessTypeVersionRow[]>(versionsUrl);
+            versions.value = data ?? [];
+        } catch (err) {
+            error.value = err instanceof Error ? err : new Error(String(err));
+        } finally {
+            loading.value = false;
+        }
+    }
+
+    async function createDraft(
+        data: Omit<CreateBusinessTypeVersionDraftData, 'businessTypeId'>,
+    ): Promise<BusinessTypeVersionMutationResult> {
+        const result = await fetchJson<BusinessTypeVersionMutationResult>(versionsUrl, {
+            method: 'POST',
+            body: JSON.stringify(data),
+        });
+        if (!result) throw new BusinessTypesApiError(0, null, 'CreateDraft gab keinen Body zurück');
+        versions.value = [...versions.value, result.businessTypeVersion];
+        return result;
+    }
+
+    async function updateDraft(
+        versionId: string,
+        data: UpdateBusinessTypeVersionDraftData,
+    ): Promise<BusinessTypeVersionMutationResult> {
+        const result = await fetchJson<BusinessTypeVersionMutationResult>(
+            `${versionUrlBase}/${versionId}`,
+            { method: 'PATCH', body: JSON.stringify(data) },
+        );
+        if (!result) throw new BusinessTypesApiError(0, null, 'UpdateDraft gab keinen Body zurück');
+        versions.value = versions.value.map((v) =>
+            v.id === versionId ? result.businessTypeVersion : v,
+        );
+        return result;
+    }
+
+    async function publish(
+        versionId: string,
+        opts: { forceRegressive?: boolean } = {},
+    ): Promise<BusinessTypeVersionMutationResult> {
+        const result = await fetchJson<BusinessTypeVersionMutationResult>(
+            `${versionUrlBase}/${versionId}/publish`,
+            { method: 'POST', body: JSON.stringify(opts) },
+        );
+        if (!result) throw new BusinessTypesApiError(0, null, 'Publish gab keinen Body zurück');
+        await load();
+        return result;
+    }
+
+    if (options.autoLoad) {
+        void load();
+    }
+
+    return { versions, loading, error, load, createDraft, updateDraft, publish };
+}