@mittwald/api-models 0.0.0-development-74e1fd1-20240611 → 0.0.0-development-e096ee7-20240924

package/README.md

@@ -60,10 +60,10 @@ await projectRef.updateDescription("My new description!");
 const server = project.server;
 
 // List all projects of this server
-const serversProjects = await server.listProjects();
+const serversProjects = await server.projects.execute();
 
 // List all projects
-const allProjects = await Project.list();
+const allProjects = await Project.query().execute();
 
 // Iterate over project List Models
 for (const project of serversProjects) {
@@ -105,10 +105,10 @@ const anotherDetailedProject = projectRef.getDetailed.use();
 const server = project.server;
 
 // List all projects of this server
-const serversProjects = server.listProjects.use();
+const serversProjects = server.projects.execute.use();
 
 // List all projects
-const allProjects = Project.list.use();
+const allProjects = Project.query().execute.use();
 ```
 
 ## Immutability and state updates
@@ -190,10 +190,55 @@ model operations often just need the ID and some input data (deleting, renaming,
 should be used as a return type for newly created models or for linked models.
 
 To get the actual Detailed Model, Reference Models _must_ have a
-`function getDetailed(): Promise<ModelDetailed>` method.
+`function getDetailed(): Promise<ModelDetailed>` and
+`function findDetailed(): Promise<ModelDetailed|undefined>` method.
 
 Consider extending the Reference Model when implementing the Entry-Point Model.
 
+#### Query Models
+
+Querying models usually requires a query object – or short query. The query
+mostly includes pagination settings like `limit`, `skip` or `page`. It may also
+include filters like `fromDate` or `toDate`, and filters to other models like
+`customerId`.
+
+A Query Model represents a specific query to a specific model and should include
+the following methods:
+
+- `execute()`: executes the query and returns the respective List Model
+- `refine(overrideQuery)`: creates a new Query Model with a refined query object
+- `getTotalCount()`: gets the total count of the query (executes the query with
+  `limit: 0`)
+
+When a model supports queries, it should provide a static `query()` method to
+create the respective Query Model.
+
+When a model is used as a query parameters in a Query Model, the model should
+have a property in its Reference Model for this Query Model. See the following
+example:
+
+```typescript
+class Server {
+  public readonly projects: ProjectsListQuery;
+
+  public constructor(id: string) {
+    this.projects = new ProjectListQuery({
+      server: this,
+    });
+  }
+}
+```
+
+#### List Models
+
+List Models are the result of a Query Model execution. A List Model includes
+
+- a list of the respective List Models, limited by the pagination configuration
+- the available total count (useful to implement pagination or count data)
+
+List Models should extend their respective Query Model, because it might be
+helpful to also call `refine()` on an already executed query.
+
 #### Implementation details
 
 When implementing shared functionality, like in the Common Models, you can use
@@ -204,7 +249,7 @@ implementation examples.
 #### Entry-Point Model
 
 Provide a single model (name it `[Model]`) as an entry point for all different
-model types (detailed, list, ...). As a convention provide a default export for
+model types (detailed, query, ...). As a convention provide a default export for
 this model.
 
 ### Use the correct verbs
@@ -221,9 +266,9 @@ method. The get method should return the desired object or throw an
 `ObjectNotFoundError`. You can use the `find` method and assert the existence
 with the `assertObjectFound` function.
 
-#### `list`
+#### `query`
 
-When a list of objects should be loaded use a `list` method. It may support a
+When a list of objects should be queried use a `query` method. It may support a
 `query` parameter to filter the result by given criteria.
 
 #### `create`
@@ -234,9 +279,8 @@ return a reference of the created resource.
 ### Accessing "linked" models
 
 Most of the models are part of a larger model tree. Models should provide
-methods to get the parent and child models, like `project.getServer()`,
-`server.listProjects()` or `server.getCustomer()`. Use `get`, `list` or `find`
-prefixes as described above.
+properties to get the parent and child models, like `project.server`,
+`server.projects` or `server.customer`.
 
 #### Use Reference Models resp. Entry-Point Models when possible!
 

package/dist/esm/app/AppInstallation/AppInstallation.js

@@ -3,7 +3,10 @@ import { classes } from "polytype";
 import { DataModel } from "../../base/DataModel.js";
 import assertObjectFound from "../../base/assertObjectFound.js";
 import { ReferenceModel } from "../../base/ReferenceModel.js";
-import { provideReact } from "../../lib/provideReact.js";
+import { provideReact, } from "../../react/provideReact.js";
+import { ListQueryModel } from "../../base/ListQueryModel.js";
+import { ListDataModel } from "../../base/ListDataModel.js";
+import { Project } from "../../project/index.js";
 export class AppInstallation extends ReferenceModel {
     static find = provideReact(async (id) => {
         const data = await config.behaviors.appInstallation.find(id);
@@ -19,11 +22,17 @@ export class AppInstallation extends ReferenceModel {
     static ofId(id) {
         return new AppInstallation(id);
     }
+    query(project, query = {}) {
+        return new AppInstallationListQuery(project, query);
+    }
+    /** @deprecated: use query() or project.appInstallations */
     static list = provideReact(async (projectId, query = {}) => {
-        const data = await config.behaviors.appInstallation.list(projectId, query);
-        return data.map((d) => new AppInstallationListItem(d));
+        return new AppInstallationListQuery(Project.ofId(projectId), query)
+            .execute()
+            .then((r) => r.items);
     });
-    getDetailed = provideReact(() => AppInstallation.get(this.id));
+    getDetailed = provideReact(() => AppInstallation.get(this.id), [this.id]);
+    findDetailed = provideReact(() => AppInstallation.find(this.id), [this.id]);
 }
 // Common class for future extension
 class AppInstallationCommon extends classes((DataModel), AppInstallation) {
@@ -41,3 +50,38 @@ export class AppInstallationListItem extends classes(AppInstallationCommon, (Dat
         super([data], [data]);
     }
 }
+export class AppInstallationListQuery extends ListQueryModel {
+    project;
+    constructor(project, query = {}) {
+        super(query);
+        this.project = project;
+    }
+    refine(query) {
+        return new AppInstallationListQuery(this.project, {
+            ...this.query,
+            ...query,
+        });
+    }
+    execute = provideReact(async () => {
+        const { items, totalCount } = await config.behaviors.appInstallation.list(this.project.id, {
+            limit: config.defaultPaginationLimit,
+            ...this.query,
+        });
+        return new AppInstallationList(this.project, this.query, items.map((d) => new AppInstallationListItem(d)), totalCount);
+    }, [this.queryId]);
+    getTotalCount = provideReact(async () => {
+        const { totalCount } = await this.refine({ limit: 1 }).execute();
+        return totalCount;
+    }, [this.queryId]);
+    findOneAndOnly = provideReact(async () => {
+        const { items, totalCount } = await this.refine({ limit: 2 }).execute();
+        if (totalCount === 1) {
+            return items[0];
+        }
+    }, [this.queryId]);
+}
+export class AppInstallationList extends classes(AppInstallationListQuery, (ListDataModel)) {
+    constructor(project, query, appInstallations, totalCount) {
+        super([project, query], [appInstallations, totalCount]);
+    }
+}

package/dist/esm/app/AppInstallation/behaviors/api.js

@@ -1,4 +1,4 @@
-import { assertStatus } from "@mittwald/api-client";
+import { assertStatus, extractTotalCountHeader, } from "@mittwald/api-client";
 import { assertOneOfStatus } from "@mittwald/api-client";
 export const apiAppInstallationBehaviors = (client) => ({
     find: async (id) => {
@@ -16,6 +16,9 @@ export const apiAppInstallationBehaviors = (client) => ({
             projectId,
         });
         assertStatus(response, 200);
-        return response.data;
+        return {
+            items: response.data,
+            totalCount: extractTotalCountHeader(response),
+        };
     },
 });

package/dist/esm/base/ListDataModel.js

@@ -0,0 +1,8 @@
+export class ListDataModel {
+    items;
+    totalCount;
+    constructor(items, totalCount) {
+        this.items = Object.freeze(items);
+        this.totalCount = totalCount;
+    }
+}

package/dist/esm/base/ListQueryModel.js

@@ -0,0 +1,9 @@
+import { hash } from "object-code";
+export class ListQueryModel {
+    query;
+    queryId;
+    constructor(query) {
+        this.query = query;
+        this.queryId = hash(query).toString();
+    }
+}

package/dist/esm/base/index.js

@@ -1 +1,6 @@
+export * from "./assertObjectFound.js";
+export * from "./DataModel.js";
+export * from "./ReferenceModel.js";
+export * from "./ListDataModel.js";
+export * from "./ListQueryModel.js";
 export * from "./types.js";

package/dist/esm/config/behaviors/api.js

@@ -5,6 +5,7 @@ import { apiServerBehaviors } from "../../server/Server/behaviors/index.js";
 import { apiCustomerBehaviors } from "../../customer/Customer/behaviors/index.js";
 import { apiIngressBehaviors } from "../../domain/Ingress/behaviors/index.js";
 import { apiAppInstallationBehaviors } from "../../app/AppInstallation/behaviors/index.js";
+import { addUrlTagToProvideReactCache } from "../../react/asyncResourceInvalidation.js";
 class ApiSetupState {
     _client;
     setupWithClient(client) {
@@ -12,6 +13,8 @@ class ApiSetupState {
             throw new Error("API already setup. If you want to operate on the API client use api.client.");
         }
         this._client = client;
+        this._client.defaultRequestOptions.onBeforeRequest =
+            addUrlTagToProvideReactCache;
         config.behaviors.project = apiProjectBehaviors(client);
         config.behaviors.server = apiServerBehaviors(client);
         config.behaviors.customer = apiCustomerBehaviors(client);

package/dist/esm/config/config.js

@@ -1,4 +1,5 @@
 export const config = {
+    defaultPaginationLimit: 50,
     behaviors: {
         project: undefined,
         server: undefined,

package/dist/esm/customer/Customer/Customer.js

@@ -3,8 +3,23 @@ import { classes } from "polytype";
 import { DataModel } from "../../base/DataModel.js";
 import assertObjectFound from "../../base/assertObjectFound.js";
 import { ReferenceModel } from "../../base/ReferenceModel.js";
-import { provideReact } from "../../lib/provideReact.js";
+import { provideReact, } from "../../react/provideReact.js";
+import { ListQueryModel } from "../../base/ListQueryModel.js";
+import { ListDataModel } from "../../base/ListDataModel.js";
+import { ServerListQuery } from "../../server/index.js";
+import { ProjectListQuery } from "../../project/index.js";
 export class Customer extends ReferenceModel {
+    servers;
+    projects;
+    constructor(id) {
+        super(id);
+        this.servers = new ServerListQuery({
+            customer: this,
+        });
+        this.projects = new ProjectListQuery({
+            customer: this,
+        });
+    }
     static ofId(id) {
         return new Customer(id);
     }
@@ -14,16 +29,21 @@ export class Customer extends ReferenceModel {
             return new CustomerDetailed(data);
         }
     });
-    static list = provideReact(async (query = {}) => {
-        const data = await config.behaviors.customer.list(query);
-        return Object.freeze(data.map((d) => new CustomerListItem(d)));
-    });
+    static query(query = {}) {
+        return new CustomerListQuery(query);
+    }
+    /** @deprecated Use query() */
+    static list = provideReact(async (query = {}) => new CustomerListQuery(query).execute().then((res) => res.items));
     static get = provideReact(async (id) => {
         const customer = await this.find(id);
         assertObjectFound(customer, this, id);
         return customer;
     });
-    getDetailed = provideReact(() => Customer.get(this.id));
+    getDetailed = provideReact(() => Customer.get(this.id), [this.id]);
+    findDetailed = provideReact(() => Customer.find(this.id), [this.id]);
+    async update(data) {
+        await config.behaviors.customer.update(this.id, data);
+    }
 }
 // Common class for future extension
 class CustomerCommon extends classes((DataModel), Customer) {
@@ -41,3 +61,36 @@ export class CustomerListItem extends classes(CustomerCommon, (DataModel)) {
         super([data], [data]);
     }
 }
+export class CustomerListQuery extends ListQueryModel {
+    constructor(query = {}) {
+        super(query);
+    }
+    refine(query) {
+        return new CustomerListQuery({
+            ...this.query,
+            ...query,
+        });
+    }
+    execute = provideReact(async () => {
+        const { items, totalCount } = await config.behaviors.customer.list({
+            limit: config.defaultPaginationLimit,
+            ...this.query,
+        });
+        return new CustomerList(this.query, items.map((d) => new CustomerListItem(d)), totalCount);
+    }, [this.queryId]);
+    getTotalCount = provideReact(async () => {
+        const { totalCount } = await this.refine({ limit: 1 }).execute();
+        return totalCount;
+    }, [this.queryId]);
+    findOneAndOnly = provideReact(async () => {
+        const { items, totalCount } = await this.refine({ limit: 2 }).execute();
+        if (totalCount === 1) {
+            return items[0];
+        }
+    }, [this.queryId]);
+}
+export class CustomerList extends classes(CustomerListQuery, (ListDataModel)) {
+    constructor(query, customers, totalCount) {
+        super([query], [customers, totalCount]);
+    }
+}

package/dist/esm/customer/Customer/behaviors/api.js

@@ -1,4 +1,4 @@
-import { assertStatus } from "@mittwald/api-client";
+import { assertStatus, extractTotalCountHeader, } from "@mittwald/api-client";
 import { assertOneOfStatus } from "@mittwald/api-client";
 export const apiCustomerBehaviors = (client) => ({
     find: async (id) => {
@@ -15,6 +15,16 @@ export const apiCustomerBehaviors = (client) => ({
             queryParameters: query,
         });
         assertStatus(response, 200);
-        return response.data;
+        return {
+            items: response.data,
+            totalCount: extractTotalCountHeader(response),
+        };
+    },
+    update: async (id, data) => {
+        const response = await client.customer.updateCustomer({
+            customerId: id,
+            data,
+        });
+        assertStatus(response, 200);
     },
 });

package/dist/esm/domain/Ingress/Ingress.js

@@ -3,8 +3,10 @@ import { classes } from "polytype";
 import { DataModel } from "../../base/DataModel.js";
 import assertObjectFound from "../../base/assertObjectFound.js";
 import { ReferenceModel } from "../../base/ReferenceModel.js";
-import { provideReact } from "../../lib/provideReact.js";
+import { provideReact, } from "../../react/provideReact.js";
 import { IngressPath } from "../IngressPath/IngressPath.js";
+import { ListQueryModel } from "../../base/ListQueryModel.js";
+import { ListDataModel } from "../../base/ListDataModel.js";
 export class Ingress extends ReferenceModel {
     static ofId(id) {
         return new Ingress(id);
@@ -12,10 +14,8 @@ export class Ingress extends ReferenceModel {
     static ofHostname(hostname) {
         return Ingress.ofId(hostname);
     }
-    static list = provideReact(async (query = {}) => {
-        const data = await config.behaviors.ingress.list(query);
-        return data.map((d) => new IngressListItem(d));
-    });
+    /** @deprecated: use query() or project.ingresses */
+    static list = provideReact(async (query = {}) => new IngressListQuery(query).execute().then((r) => r.items));
     static find = provideReact(async (id) => {
         const data = await config.behaviors.ingress.find(id);
         if (data !== undefined) {
@@ -27,7 +27,8 @@ export class Ingress extends ReferenceModel {
         assertObjectFound(ingress, this, id);
         return ingress;
     });
-    getDetailed = provideReact(() => Ingress.get(this.id));
+    getDetailed = provideReact(() => Ingress.get(this.id), [this.id]);
+    findDetailed = provideReact(() => Ingress.find(this.id), [this.id]);
 }
 export class IngressCommon extends classes((DataModel), Ingress) {
     baseUrl;
@@ -54,3 +55,52 @@ export class IngressListItem extends classes(IngressCommon, (DataModel)) {
         super([data], [data]);
     }
 }
+export class IngressListQuery extends ListQueryModel {
+    constructor(query = {}) {
+        super(query);
+    }
+    refine(query = {}) {
+        return new IngressListQuery({
+            ...this.query,
+            ...query,
+        });
+    }
+    execute = provideReact(async () => {
+        const { project, ...query } = this.query;
+        const { items, totalCount } = await config.behaviors.ingress.list({
+            /** @todo: use this code when pagination is supported by API */
+            // limit: config.defaultPaginationLimit,
+            ...query,
+            projectId: project?.id,
+        });
+        return new IngressList(this.query, items.map((d) => new IngressListItem(d)), totalCount);
+    }, [this.queryId]);
+    getTotalCount = provideReact(async () => {
+        /** @todo: use this code when pagination is supported by API */
+        // const { totalCount } = await this.refine({ limit: 1 }).execute();
+        // return totalCount;
+        const { items } = await this.refine({}).execute();
+        return items.length;
+    }, [this.queryId]);
+    findOneAndOnly = provideReact(async () => {
+        /** @todo: use this code when pagination is supported by API */
+        // const { items, totalCount } = await this.refine({ limit: 2 }).execute();
+        // if (totalCount === 1) {
+        //   return items[0];
+        // }
+        const { items, totalCount } = await this.refine({}).execute();
+        if (totalCount === 1) {
+            return items[0];
+        }
+    }, [this.queryId]);
+}
+export class IngressList extends classes(IngressListQuery, (ListDataModel)) {
+    constructor(query, ingresses, totalCount) {
+        super([query], [ingresses, totalCount]);
+    }
+    getDefault() {
+        const defaultIngress = this.items.find((i) => i.data.isDefault);
+        assertObjectFound(defaultIngress, IngressListItem, "IngressList");
+        return defaultIngress;
+    }
+}

package/dist/esm/domain/Ingress/behaviors/api.js

@@ -11,13 +11,15 @@ export const apiIngressBehaviors = (client) => ({
         assertOneOfStatus(response, [404]);
     },
     list: async (query = {}) => {
-        const { projectId } = query;
         const response = await client.domain.ingressListIngresses({
-            queryParameters: {
-                projectId,
-            },
+            queryParameters: query,
         });
         assertStatus(response, 200);
-        return response.data;
+        return {
+            items: response.data,
+            totalCount: response.data.length,
+            /** @todo: use this code when pagination is supported by API */
+            // totalCount: extractTotalCountHeader(response),
+        };
     },
 });

package/dist/esm/project/Project/Project.js

@@ -3,11 +3,23 @@ import { classes } from "polytype";
 import { DataModel } from "../../base/DataModel.js";
 import assertObjectFound from "../../base/assertObjectFound.js";
 import { Server } from "../../server/index.js";
-import { provideReact, } from "../../lib/provideReact.js";
+import { provideReact, } from "../../react/provideReact.js";
 import { Customer } from "../../customer/Customer/Customer.js";
 import { ReferenceModel } from "../../base/ReferenceModel.js";
-import { Ingress, IngressListItem } from "../../domain/index.js";
+import { Ingress, IngressListItem, IngressListQuery, } from "../../domain/index.js";
+import { ListQueryModel } from "../../base/ListQueryModel.js";
+import { ListDataModel } from "../../base/ListDataModel.js";
+import { AppInstallationListQuery } from "../../app/index.js";
 export class Project extends ReferenceModel {
+    ingresses;
+    appInstallations;
+    constructor(id) {
+        super(id);
+        this.ingresses = new IngressListQuery({
+            project: this,
+        });
+        this.appInstallations = new AppInstallationListQuery(this);
+    }
     static ofId(id) {
         return new Project(id);
     }
@@ -22,15 +34,20 @@ export class Project extends ReferenceModel {
         assertObjectFound(project, this, id);
         return project;
     });
+    static query(query = {}) {
+        return new ProjectListQuery(query);
+    }
+    /** @deprecated: use query(), Customer.projects or Server.projects */
     static list = provideReact(async (query = {}) => {
-        const data = await config.behaviors.project.list(query);
-        return Object.freeze(data.map((d) => new ProjectListItem(d)));
+        return new ProjectListQuery(query).execute().then((r) => r.items);
     });
     static async create(serverId, description) {
         const { id } = await config.behaviors.project.create(serverId, description);
         return new Project(id);
     }
-    getDetailed = provideReact(() => Project.get(this.id));
+    getDetailed = provideReact(() => Project.get(this.id), [this.id]);
+    findDetailed = provideReact(() => Project.find(this.id), [this.id]);
+    /** @deprecated: use ingresses property */
     listIngresses = provideReact(() => Ingress.list({ projectId: this.id }));
     getDefaultIngress = provideReact(async () => {
         const ingresses = await Project.ofId(this.id).listIngresses();
@@ -67,3 +84,38 @@ export class ProjectListItem extends classes(ProjectCommon, (DataModel)) {
         super([data], [data]);
     }
 }
+export class ProjectListQuery extends ListQueryModel {
+    constructor(query = {}) {
+        super(query);
+    }
+    refine(query) {
+        return new ProjectListQuery({
+            ...this.query,
+            ...query,
+        });
+    }
+    execute = provideReact(async () => {
+        const { server, customer, ...query } = this.query;
+        const { items, totalCount } = await config.behaviors.project.list({
+            ...query,
+            serverId: server?.id,
+            customerId: customer?.id,
+        });
+        return new ProjectList(this.query, items.map((d) => new ProjectListItem(d)), totalCount);
+    }, [this.queryId]);
+    getTotalCount = provideReact(async () => {
+        const { totalCount } = await this.refine({ limit: 1 }).execute();
+        return totalCount;
+    }, [this.queryId]);
+    findOneAndOnly = provideReact(async () => {
+        const { items, totalCount } = await this.refine({ limit: 2 }).execute();
+        if (totalCount === 1) {
+            return items[0];
+        }
+    }, [this.queryId]);
+}
+export class ProjectList extends classes(ProjectListQuery, (ListDataModel)) {
+    constructor(query, projects, totalCount) {
+        super([query], [projects, totalCount]);
+    }
+}

package/dist/esm/project/Project/behaviors/api.js

@@ -1,4 +1,4 @@
-import { assertStatus } from "@mittwald/api-client";
+import { assertStatus, extractTotalCountHeader, } from "@mittwald/api-client";
 import { assertOneOfStatus } from "@mittwald/api-client";
 export const apiProjectBehaviors = (client) => ({
     find: async (id) => {
@@ -15,7 +15,10 @@ export const apiProjectBehaviors = (client) => ({
             queryParameters: query,
         });
         assertStatus(response, 200);
-        return response.data;
+        return {
+            items: response.data,
+            totalCount: extractTotalCountHeader(response),
+        };
     },
     create: async (serverId, description) => {
         const response = await client.project.createProject({

package/dist/esm/project/Project/behaviors/inMem.js

@@ -1,12 +1,16 @@
 export const inMemProjectBehaviors = (store) => ({
     find: async (id) => store.get(id),
     list: async () => {
-        return Array.from(store.values()).map((detailedProject) => ({
+        const items = Array.from(store.values()).map((detailedProject) => ({
             ...detailedProject,
             customerMeta: {
                 id: detailedProject.customerId,
             },
         }));
+        return {
+            items,
+            totalCount: items.length,
+        };
     },
     create: async () => {
         throw new Error("Not implemented");

package/dist/esm/react/MittwaldApiModelProvider.js

@@ -1,12 +1,12 @@
-import React, { createElement } from "react";
+import { usePromise } from "@mittwald/react-use-promise";
 import { setModule } from "./reactUsePromise.js";
-let loadingPromise = undefined;
 export const MittwaldApiModelProvider = (props) => {
-    if (loadingPromise === undefined) {
-        loadingPromise = import("@mittwald/react-use-promise").then((m) => {
-            setModule(m);
-        });
-        throw loadingPromise;
+    const { fallback, children } = props;
+    const module = usePromise(() => import("@mittwald/react-use-promise").then(setModule), [], {
+        useSuspense: false,
+    });
+    if (!module.hasValue) {
+        return fallback;
     }
-    return createElement(React.Fragment, undefined, props.children);
+    return children;
 };

package/dist/esm/react/asyncResourceInvalidation.js

@@ -0,0 +1,29 @@
+import { reactProvisionContext } from "./reactProvisionContext.js";
+import { refresh } from "@mittwald/react-use-promise";
+import { Store } from "@mittwald/react-use-promise/store";
+const cacheTagStore = new Store();
+export const refreshProvideReactCache = (tag) => {
+    cacheTagStore.getAll(tag).forEach((ids) => {
+        ids.forEach((id) => {
+            refresh({
+                tag: String(id),
+            });
+        });
+    });
+};
+export const addTagToProvideReactCache = (tag) => {
+    const context = reactProvisionContext.use();
+    if (context) {
+        const ids = cacheTagStore.get(tag) ?? new Set();
+        ids.add(context.id);
+        cacheTagStore.set(tag, () => ids, {
+            tags: [tag],
+        });
+    }
+};
+export const addUrlTagToProvideReactCache = (request) => {
+    const url = request.requestConfig.url;
+    if (request.requestConfig.method === "GET" && url) {
+        addTagToProvideReactCache(url);
+    }
+};

package/dist/esm/react/index.js

@@ -1,3 +1,4 @@
+export { refreshProvideReactCache, addTagToProvideReactCache, addUrlTagToProvideReactCache, } from "./asyncResourceInvalidation.js";
 export * from "./MittwaldApiModelProvider.js";
 export * from "./reactUsePromise.js";
-export { provideReact } from "../lib/provideReact.js";
+export { provideReact } from "./provideReact.js";