@mittwald/api-models 4.53.0 → 4.55.0

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

@@ -4,6 +4,9 @@ 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 { 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), [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/config/config.js

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

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

@@ -4,7 +4,22 @@ 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 { 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,18 @@ 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), [this.id]);
+    findDetailed = provideReact(() => Customer.find(this.id), [this.id]);
 }
 // Common class for future extension
 class CustomerCommon extends classes((DataModel), Customer) {
@@ -41,3 +58,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,9 @@ export const apiCustomerBehaviors = (client) => ({
             queryParameters: query,
         });
         assertStatus(response, 200);
-        return response.data;
+        return {
+            items: response.data,
+            totalCount: extractTotalCountHeader(response),
+        };
     },
 });

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

@@ -5,6 +5,8 @@ import assertObjectFound from "../../base/assertObjectFound.js";
 import { ReferenceModel } from "../../base/ReferenceModel.js";
 import { provideReact } from "../../lib/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) {
@@ -28,6 +28,7 @@ export class Ingress extends ReferenceModel {
         return ingress;
     });
     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

@@ -6,8 +6,20 @@ import { Server } from "../../server/index.js";
 import { provideReact, } from "../../lib/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;
     });
+    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), [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/server/Server/Server.js

@@ -3,9 +3,18 @@ import { config } from "../../config/config.js";
 import { classes } from "polytype";
 import { DataModel } from "../../base/DataModel.js";
 import assertObjectFound from "../../base/assertObjectFound.js";
-import { Project } from "../../project/index.js";
+import { Project, ProjectListQuery } from "../../project/index.js";
 import { provideReact } from "../../lib/provideReact.js";
+import { ListQueryModel } from "../../base/ListQueryModel.js";
+import { ListDataModel } from "../../base/ListDataModel.js";
 export class Server extends ReferenceModel {
+    projects;
+    constructor(id) {
+        super(id);
+        this.projects = new ProjectListQuery({
+            server: this,
+        });
+    }
     static ofId(id) {
         return new Server(id);
     }
@@ -20,13 +29,17 @@ export class Server extends ReferenceModel {
         assertObjectFound(server, this, id);
         return server;
     });
+    static query(query = {}) {
+        return new ServerListQuery(query);
+    }
+    /** @deprecated: use query() or customer.servers */
     static list = provideReact(async (query = {}) => {
-        const projectListData = await config.behaviors.server.list(query);
-        return projectListData.map((d) => new ServerListItem(d));
+        return new ServerListQuery(query).execute().then((r) => r.items);
     });
     async createProject(...parameters) {
         return Project.create(this.id, ...parameters);
     }
+    /** @deprecated Use Server.projects property */
     listProjects = provideReact(async (query = {}) => {
         return Project.list({
             ...query,
@@ -34,6 +47,7 @@ export class Server extends ReferenceModel {
         });
     });
     getDetailed = provideReact(() => Server.get(this.id), [this.id]);
+    findDetailed = provideReact(() => Server.find(this.id), [this.id]);
 }
 // Common class for future extension
 class ServerCommon extends classes((DataModel), Server) {
@@ -51,3 +65,38 @@ export class ServerListItem extends classes(ServerCommon, (DataModel)) {
         super([data], [data]);
     }
 }
+export class ServerListQuery extends ListQueryModel {
+    constructor(query = {}) {
+        super(query);
+    }
+    refine(query) {
+        return new ServerListQuery({
+            ...this.query,
+            ...query,
+        });
+    }
+    execute = provideReact(async () => {
+        const { customer, ...query } = this.query;
+        const { items, totalCount } = await config.behaviors.server.list({
+            limit: config.defaultPaginationLimit,
+            customerId: customer?.id,
+            ...query,
+        });
+        return new ServerList(this.query, items.map((d) => new ServerListItem(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 ServerList extends classes(ServerListQuery, (ListDataModel)) {
+    constructor(query, servers, totalCount) {
+        super([query], [servers, totalCount]);
+    }
+}

package/dist/esm/server/Server/behaviors/api.js

@@ -1,4 +1,4 @@
-import { assertStatus, assertOneOfStatus, } from "@mittwald/api-client";
+import { assertStatus, assertOneOfStatus, extractTotalCountHeader, } from "@mittwald/api-client";
 export const apiServerBehaviors = (client) => ({
     find: async (id) => {
         const response = await client.project.getServer({
@@ -14,6 +14,9 @@ export const apiServerBehaviors = (client) => ({
             queryParameters: query,
         });
         assertStatus(response, 200);
-        return response.data;
+        return {
+            items: response.data,
+            totalCount: extractTotalCountHeader(response),
+        };
     },
 });

package/dist/types/app/AppInstallation/AppInstallation.d.ts

@@ -1,7 +1,10 @@
 import { DataModel } from "../../base/DataModel.js";
 import { ReferenceModel } from "../../base/ReferenceModel.js";
 import type { AsyncResourceVariant } from "../../lib/provideReact.js";
-import { AppInstallationListItemData, AppInstallationData } from "./types.js";
+import { AppInstallationData, AppInstallationListItemData, AppInstallationListQueryData } from "./types.js";
+import { ListQueryModel } from "../../base/ListQueryModel.js";
+import { ListDataModel } from "../../base/ListDataModel.js";
+import { Project } from "../../project/index.js";
 export declare class AppInstallation extends ReferenceModel {
     static find: ((id: string) => Promise<AppInstallationDetailed | undefined>) & {
         asResource: (id: string) => import("@mittwald/react-use-promise").AsyncResource<AppInstallationDetailed | undefined>;
@@ -12,11 +15,14 @@ export declare class AppInstallation extends ReferenceModel {
         use: (id: string) => AppInstallationDetailed;
     };
     static ofId(id: string): AppInstallation;
-    static list: ((projectId: string, query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2ProjectsProjectIdAppInstallations.Get.Parameters.Query | undefined) => Promise<AppInstallationListItem[]>) & {
-        asResource: (projectId: string, query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2ProjectsProjectIdAppInstallations.Get.Parameters.Query | undefined) => import("@mittwald/react-use-promise").AsyncResource<AppInstallationListItem[]>;
-        use: (projectId: string, query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2ProjectsProjectIdAppInstallations.Get.Parameters.Query | undefined) => AppInstallationListItem[];
+    query(project: Project, query?: AppInstallationListQueryData): AppInstallationListQuery;
+    /** @deprecated: use query() or project.appInstallations */
+    static list: ((projectId: string, query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2ProjectsProjectIdAppInstallations.Get.Parameters.Query | undefined) => Promise<readonly AppInstallationListItem[]>) & {
+        asResource: (projectId: string, query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2ProjectsProjectIdAppInstallations.Get.Parameters.Query | undefined) => import("@mittwald/react-use-promise").AsyncResource<readonly AppInstallationListItem[]>;
+        use: (projectId: string, query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2ProjectsProjectIdAppInstallations.Get.Parameters.Query | undefined) => readonly AppInstallationListItem[];
     };
     getDetailed: AsyncResourceVariant<AppInstallationDetailed, []>;
+    findDetailed: AsyncResourceVariant<AppInstallationDetailed | undefined, []>;
 }
 declare const AppInstallationCommon_base: import("polytype").Polytype.ClusteredConstructor<[{
     new (data: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.AppAppInstallation | {
@@ -104,4 +110,27 @@ declare const AppInstallationListItem_base: import("polytype").Polytype.Clustere
 export declare class AppInstallationListItem extends AppInstallationListItem_base {
     constructor(data: AppInstallationListItemData);
 }
+export declare class AppInstallationListQuery extends ListQueryModel<AppInstallationListQueryData> {
+    readonly project: Project;
+    constructor(project: Project, query?: AppInstallationListQueryData);
+    refine(query: AppInstallationListQueryData): AppInstallationListQuery;
+    execute: (() => Promise<AppInstallationList>) & {
+        asResource: () => import("@mittwald/react-use-promise").AsyncResource<AppInstallationList>;
+        use: () => AppInstallationList;
+    };
+    getTotalCount: (() => Promise<number>) & {
+        asResource: () => import("@mittwald/react-use-promise").AsyncResource<number>;
+        use: () => number;
+    };
+    findOneAndOnly: (() => Promise<AppInstallationListItem | undefined>) & {
+        asResource: () => import("@mittwald/react-use-promise").AsyncResource<AppInstallationListItem | undefined>;
+        use: () => AppInstallationListItem | undefined;
+    };
+}
+declare const AppInstallationList_base: import("polytype").Polytype.ClusteredConstructor<[typeof AppInstallationListQuery, {
+    new (items: AppInstallationListItem[], totalCount: number): ListDataModel<AppInstallationListItem>;
+}]>;
+export declare class AppInstallationList extends AppInstallationList_base {
+    constructor(project: Project, query: AppInstallationListQueryData, appInstallations: AppInstallationListItem[], totalCount: number);
+}
 export {};

package/dist/types/app/AppInstallation/behaviors/types.d.ts

@@ -1,5 +1,6 @@
-import { AppInstallationListItemData, AppInstallationData, AppInstallationListQuery } from "../types.js";
+import { AppInstallationListItemData, AppInstallationData, AppInstallationListQueryData } from "../types.js";
+import { QueryResponseData } from "../../../base/index.js";
 export interface AppInstallationBehaviors {
     find: (id: string) => Promise<AppInstallationData | undefined>;
-    list: (projectId: string, query?: AppInstallationListQuery) => Promise<AppInstallationListItemData[]>;
+    list: (projectId: string, query?: AppInstallationListQueryData) => Promise<QueryResponseData<AppInstallationListItemData>>;
 }

package/dist/types/app/AppInstallation/types.d.ts

@@ -1,4 +1,4 @@
 import { MittwaldAPIV2 } from "@mittwald/api-client";
-export type AppInstallationListQuery = MittwaldAPIV2.Paths.V2ProjectsProjectIdAppInstallations.Get.Parameters.Query;
+export type AppInstallationListQueryData = MittwaldAPIV2.Paths.V2ProjectsProjectIdAppInstallations.Get.Parameters.Query;
 export type AppInstallationData = MittwaldAPIV2.Operations.AppGetAppinstallation.ResponseData;
 export type AppInstallationListItemData = MittwaldAPIV2.Operations.AppListAppinstallations.ResponseData[number];

package/dist/types/base/ListDataModel.d.ts

@@ -0,0 +1,5 @@
+export declare class ListDataModel<TItem> {
+    readonly items: readonly TItem[];
+    readonly totalCount: number;
+    constructor(items: TItem[], totalCount: number);
+}

package/dist/types/base/ListQueryModel.d.ts

@@ -0,0 +1,5 @@
+export declare abstract class ListQueryModel<TQuery> {
+    protected readonly query: TQuery;
+    readonly queryId: string;
+    constructor(query: TQuery);
+}

package/dist/types/base/types.d.ts

@@ -1,2 +1,6 @@
 import { DataModel } from "./DataModel.js";
 export type DataType<T> = T extends DataModel<infer TData> ? TData : never;
+export type QueryResponseData<T> = {
+    items: readonly T[];
+    totalCount: number;
+};

package/dist/types/config/config.d.ts

@@ -4,6 +4,7 @@ import { CustomerBehaviors } from "../customer/Customer/behaviors/index.js";
 import { IngressBehaviors } from "../domain/Ingress/behaviors/index.js";
 import { AppInstallationBehaviors } from "../app/AppInstallation/behaviors/index.js";
 interface Config {
+    defaultPaginationLimit: number;
     behaviors: {
         project: ProjectBehaviors;
         server: ServerBehaviors;

package/dist/types/customer/Customer/Customer.d.ts

@@ -1,13 +1,22 @@
 import { DataModel } from "../../base/DataModel.js";
 import { ReferenceModel } from "../../base/ReferenceModel.js";
-import type { AsyncResourceVariant } from "../../lib/provideReact.js";
-import { CustomerListItemData, CustomerData } from "./types.js";
+import { AsyncResourceVariant } from "../../lib/provideReact.js";
+import { CustomerListItemData, CustomerData, CustomerListQueryData } from "./types.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 declare class Customer extends ReferenceModel {
+    readonly servers: ServerListQuery;
+    readonly projects: ProjectListQuery;
+    constructor(id: string);
     static ofId(id: string): Customer;
     static find: ((id: string) => Promise<CustomerDetailed | undefined>) & {
         asResource: (id: string) => import("@mittwald/react-use-promise").AsyncResource<CustomerDetailed | undefined>;
         use: (id: string) => CustomerDetailed | undefined;
     };
+    static query(query?: CustomerListQueryData): CustomerListQuery;
+    /** @deprecated Use query() */
     static list: ((query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Customers.Get.Parameters.Query | undefined) => Promise<readonly CustomerListItem[]>) & {
         asResource: (query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Customers.Get.Parameters.Query | undefined) => import("@mittwald/react-use-promise").AsyncResource<readonly CustomerListItem[]>;
         use: (query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Customers.Get.Parameters.Query | undefined) => readonly CustomerListItem[];
@@ -17,6 +26,7 @@ export declare class Customer extends ReferenceModel {
         use: (id: string) => CustomerDetailed;
     };
     getDetailed: AsyncResourceVariant<CustomerDetailed, []>;
+    findDetailed: AsyncResourceVariant<CustomerDetailed | undefined, []>;
 }
 declare const CustomerCommon_base: import("polytype").Polytype.ClusteredConstructor<[{
     new (data: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CustomerCustomer | {
@@ -108,4 +118,26 @@ declare const CustomerListItem_base: import("polytype").Polytype.ClusteredConstr
 export declare class CustomerListItem extends CustomerListItem_base {
     constructor(data: CustomerListItemData);
 }
+export declare class CustomerListQuery extends ListQueryModel<CustomerListQueryData> {
+    constructor(query?: CustomerListQueryData);
+    refine(query: CustomerListQueryData): CustomerListQuery;
+    execute: (() => Promise<CustomerList>) & {
+        asResource: () => import("@mittwald/react-use-promise").AsyncResource<CustomerList>;
+        use: () => CustomerList;
+    };
+    getTotalCount: (() => Promise<number>) & {
+        asResource: () => import("@mittwald/react-use-promise").AsyncResource<number>;
+        use: () => number;
+    };
+    findOneAndOnly: (() => Promise<CustomerListItem | undefined>) & {
+        asResource: () => import("@mittwald/react-use-promise").AsyncResource<CustomerListItem | undefined>;
+        use: () => CustomerListItem | undefined;
+    };
+}
+declare const CustomerList_base: import("polytype").Polytype.ClusteredConstructor<[typeof CustomerListQuery, {
+    new (items: CustomerListItem[], totalCount: number): ListDataModel<CustomerListItem>;
+}]>;
+export declare class CustomerList extends CustomerList_base {
+    constructor(query: CustomerListQueryData, customers: CustomerListItem[], totalCount: number);
+}
 export {};

package/dist/types/customer/Customer/behaviors/types.d.ts

@@ -1,5 +1,6 @@
-import { CustomerListItemData, CustomerData, CustomerListQuery } from "../types.js";
+import { CustomerListItemData, CustomerData, CustomerListQueryData } from "../types.js";
+import { QueryResponseData } from "../../../base/index.js";
 export interface CustomerBehaviors {
     find: (id: string) => Promise<CustomerData | undefined>;
-    list: (query?: CustomerListQuery) => Promise<CustomerListItemData[]>;
+    list: (query?: CustomerListQueryData) => Promise<QueryResponseData<CustomerListItemData>>;
 }

package/dist/types/customer/Customer/types.d.ts

@@ -1,4 +1,4 @@
 import { MittwaldAPIV2 } from "@mittwald/api-client";
-export type CustomerListQuery = MittwaldAPIV2.Paths.V2Customers.Get.Parameters.Query;
+export type CustomerListQueryData = MittwaldAPIV2.Paths.V2Customers.Get.Parameters.Query;
 export type CustomerData = MittwaldAPIV2.Operations.CustomerGetCustomer.ResponseData;
 export type CustomerListItemData = MittwaldAPIV2.Operations.CustomerListCustomers.ResponseData[number];

package/dist/types/domain/Ingress/Ingress.d.ts

@@ -1,14 +1,17 @@
 import { DataModel } from "../../base/DataModel.js";
 import { ReferenceModel } from "../../base/ReferenceModel.js";
 import type { AsyncResourceVariant } from "../../lib/provideReact.js";
-import { IngressListItemData, IngressData, IngressListQuery } from "./types.js";
+import { IngressData, IngressListItemData, IngressListQueryModelData } from "./types.js";
 import { IngressPath } from "../IngressPath/IngressPath.js";
+import { ListQueryModel } from "../../base/ListQueryModel.js";
+import { ListDataModel } from "../../base/ListDataModel.js";
 export declare class Ingress extends ReferenceModel {
     static ofId(id: string): Ingress;
     static ofHostname(hostname: string): Ingress;
-    static list: ((query?: IngressListQuery | undefined) => Promise<IngressListItem[]>) & {
-        asResource: (query?: IngressListQuery | undefined) => import("@mittwald/react-use-promise").AsyncResource<IngressListItem[]>;
-        use: (query?: IngressListQuery | undefined) => IngressListItem[];
+    /** @deprecated: use query() or project.ingresses */
+    static list: ((query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Ingresses.Get.Parameters.Query | undefined) => Promise<readonly IngressListItem[]>) & {
+        asResource: (query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Ingresses.Get.Parameters.Query | undefined) => import("@mittwald/react-use-promise").AsyncResource<readonly IngressListItem[]>;
+        use: (query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Ingresses.Get.Parameters.Query | undefined) => readonly IngressListItem[];
     };
     static find: ((id: string) => Promise<IngressDetailed | undefined>) & {
         asResource: (id: string) => import("@mittwald/react-use-promise").AsyncResource<IngressDetailed | undefined>;
@@ -19,6 +22,7 @@ export declare class Ingress extends ReferenceModel {
         use: (id: string) => IngressDetailed;
     };
     getDetailed: AsyncResourceVariant<IngressDetailed, []>;
+    findDetailed: AsyncResourceVariant<IngressDetailed | undefined, []>;
 }
 declare const IngressCommon_base: import("polytype").Polytype.ClusteredConstructor<[{
     new (data: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.IngressIngress | {
@@ -97,4 +101,27 @@ declare const IngressListItem_base: import("polytype").Polytype.ClusteredConstru
 export declare class IngressListItem extends IngressListItem_base {
     constructor(data: IngressListItemData);
 }
+export declare class IngressListQuery extends ListQueryModel<IngressListQueryModelData> {
+    constructor(query?: IngressListQueryModelData);
+    refine(query?: IngressListQueryModelData): IngressListQuery;
+    execute: (() => Promise<IngressList>) & {
+        asResource: () => import("@mittwald/react-use-promise").AsyncResource<IngressList>;
+        use: () => IngressList;
+    };
+    getTotalCount: (() => Promise<number>) & {
+        asResource: () => import("@mittwald/react-use-promise").AsyncResource<number>;
+        use: () => number;
+    };
+    findOneAndOnly: (() => Promise<IngressListItem | undefined>) & {
+        asResource: () => import("@mittwald/react-use-promise").AsyncResource<IngressListItem | undefined>;
+        use: () => IngressListItem | undefined;
+    };
+}
+declare const IngressList_base: import("polytype").Polytype.ClusteredConstructor<[typeof IngressListQuery, {
+    new (items: IngressListItem[], totalCount: number): ListDataModel<IngressListItem>;
+}]>;
+export declare class IngressList extends IngressList_base {
+    constructor(query: IngressListQueryModelData, ingresses: IngressListItem[], totalCount: number);
+    getDefault(): IngressListItem;
+}
 export {};

package/dist/types/domain/Ingress/behaviors/types.d.ts

@@ -1,5 +1,6 @@
-import { IngressListItemData, IngressData, IngressListQuery } from "../types.js";
+import { IngressListItemData, IngressData, IngressListQueryData } from "../types.js";
+import { QueryResponseData } from "../../../base/index.js";
 export interface IngressBehaviors {
     find: (id: string) => Promise<IngressData | undefined>;
-    list: (query?: IngressListQuery) => Promise<IngressListItemData[]>;
+    list: (query?: IngressListQueryData) => Promise<QueryResponseData<IngressListItemData>>;
 }

package/dist/types/domain/Ingress/types.d.ts

@@ -1,6 +1,8 @@
 import { MittwaldAPIV2 } from "@mittwald/api-client";
-export interface IngressListQuery {
-    projectId?: string;
-}
+import { Project } from "../../project/index.js";
+export type IngressListQueryData = MittwaldAPIV2.Paths.V2Ingresses.Get.Parameters.Query;
+export type IngressListQueryModelData = Omit<IngressListQueryData, "projectId"> & {
+    project?: Project;
+};
 export type IngressData = MittwaldAPIV2.Operations.IngressGetIngress.ResponseData;
 export type IngressListItemData = MittwaldAPIV2.Operations.IngressListIngresses.ResponseData[number];

package/dist/types/project/Project/Project.d.ts

@@ -1,11 +1,17 @@
-import { ProjectListItemData, ProjectData } from "./types.js";
+import { ProjectData, ProjectListItemData, ProjectListQueryModelData } from "./types.js";
 import { DataModel } from "../../base/DataModel.js";
 import { Server } from "../../server/index.js";
 import { type AsyncResourceVariant } from "../../lib/provideReact.js";
 import { Customer } from "../../customer/Customer/Customer.js";
 import { ReferenceModel } from "../../base/ReferenceModel.js";
-import { IngressListItem } from "../../domain/index.js";
+import { 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 declare class Project extends ReferenceModel {
+    readonly ingresses: IngressListQuery;
+    readonly appInstallations: AppInstallationListQuery;
+    constructor(id: string);
     static ofId(id: string): Project;
     static find: ((id: string) => Promise<ProjectDetailed | undefined>) & {
         asResource: (id: string) => import("@mittwald/react-use-promise").AsyncResource<ProjectDetailed | undefined>;
@@ -15,12 +21,16 @@ export declare class Project extends ReferenceModel {
         asResource: (id: string) => import("@mittwald/react-use-promise").AsyncResource<ProjectDetailed>;
         use: (id: string) => ProjectDetailed;
     };
+    query(query?: ProjectListQueryModelData): ProjectListQuery;
+    /** @deprecated: use query(), Customer.projects or Server.projects */
     static list: ((query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Projects.Get.Parameters.Query | undefined) => Promise<readonly ProjectListItem[]>) & {
         asResource: (query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Projects.Get.Parameters.Query | undefined) => import("@mittwald/react-use-promise").AsyncResource<readonly ProjectListItem[]>;
         use: (query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Projects.Get.Parameters.Query | undefined) => readonly ProjectListItem[];
     };
     static create(serverId: string, description: string): Promise<Project>;
     getDetailed: AsyncResourceVariant<ProjectDetailed, []>;
+    findDetailed: AsyncResourceVariant<ProjectDetailed | undefined, []>;
+    /** @deprecated: use ingresses property */
     listIngresses: AsyncResourceVariant<IngressListItem[], []>;
     getDefaultIngress: AsyncResourceVariant<IngressListItem, []>;
     updateDescription(description: string): Promise<void>;
@@ -29,6 +39,27 @@ export declare class Project extends ReferenceModel {
 }
 declare const ProjectCommon_base: import("polytype").Polytype.ClusteredConstructor<[{
     new (data: {
+        createdAt: string;
+        customerId: string;
+        customerMeta: {
+            id: string;
+        };
+        description: string;
+        disableReason?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectDisableReason;
+        disabledAt?: string;
+        enabled: boolean;
+        id: string;
+        imageRefId?: string;
+        isReady: boolean;
+        projectHostingId?: string;
+        readiness: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectDeprecatedProjectReadinessStatus;
+        serverId?: string;
+        shortId: string;
+        status: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectProjectStatus;
+        statusSetAt: string;
+        webStorageUsageInBytes: number;
+        webStorageUsageInBytesSetAt: string;
+    } | {
         clusterDomain?: string | undefined;
         clusterID?: string | undefined;
         clusterId?: string | undefined;
@@ -55,7 +86,7 @@ declare const ProjectCommon_base: import("polytype").Polytype.ClusteredConstruct
         statusSetAt: string;
         webStorageUsageInBytes: number;
         webStorageUsageInBytesSetAt: string;
-    } | {
+    }): DataModel<{
         createdAt: string;
         customerId: string;
         customerMeta: {
@@ -76,7 +107,7 @@ declare const ProjectCommon_base: import("polytype").Polytype.ClusteredConstruct
         statusSetAt: string;
         webStorageUsageInBytes: number;
         webStorageUsageInBytesSetAt: string;
-    }): DataModel<{
+    } | {
         clusterDomain?: string | undefined;
         clusterID?: string | undefined;
         clusterId?: string | undefined;
@@ -103,27 +134,6 @@ declare const ProjectCommon_base: import("polytype").Polytype.ClusteredConstruct
         statusSetAt: string;
         webStorageUsageInBytes: number;
         webStorageUsageInBytesSetAt: string;
-    } | {
-        createdAt: string;
-        customerId: string;
-        customerMeta: {
-            id: string;
-        };
-        description: string;
-        disableReason?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectDisableReason;
-        disabledAt?: string;
-        enabled: boolean;
-        id: string;
-        imageRefId?: string;
-        isReady: boolean;
-        projectHostingId?: string;
-        readiness: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectDeprecatedProjectReadinessStatus;
-        serverId?: string;
-        shortId: string;
-        status: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectProjectStatus;
-        statusSetAt: string;
-        webStorageUsageInBytes: number;
-        webStorageUsageInBytesSetAt: string;
     }>;
 }, typeof Project]>;
 declare class ProjectCommon extends ProjectCommon_base {
@@ -239,4 +249,26 @@ declare const ProjectListItem_base: import("polytype").Polytype.ClusteredConstru
 export declare class ProjectListItem extends ProjectListItem_base {
     constructor(data: ProjectListItemData);
 }
+export declare class ProjectListQuery extends ListQueryModel<ProjectListQueryModelData> {
+    constructor(query?: ProjectListQueryModelData);
+    refine(query: ProjectListQueryModelData): ProjectListQuery;
+    execute: (() => Promise<ProjectList>) & {
+        asResource: () => import("@mittwald/react-use-promise").AsyncResource<ProjectList>;
+        use: () => ProjectList;
+    };
+    getTotalCount: (() => Promise<number>) & {
+        asResource: () => import("@mittwald/react-use-promise").AsyncResource<number>;
+        use: () => number;
+    };
+    findOneAndOnly: (() => Promise<ProjectListItem | undefined>) & {
+        asResource: () => import("@mittwald/react-use-promise").AsyncResource<ProjectListItem | undefined>;
+        use: () => ProjectListItem | undefined;
+    };
+}
+declare const ProjectList_base: import("polytype").Polytype.ClusteredConstructor<[typeof ProjectListQuery, {
+    new (items: ProjectListItem[], totalCount: number): ListDataModel<ProjectListItem>;
+}]>;
+export declare class ProjectList extends ProjectList_base {
+    constructor(query: ProjectListQueryModelData, projects: ProjectListItem[], totalCount: number);
+}
 export {};

package/dist/types/project/Project/behaviors/types.d.ts

@@ -1,7 +1,8 @@
-import { ProjectListItemData, ProjectData, ProjectListQuery } from "../types.js";
+import { ProjectListItemData, ProjectData, ProjectListQueryData } from "../types.js";
+import { QueryResponseData } from "../../../base/index.js";
 export interface ProjectBehaviors {
     find: (id: string) => Promise<ProjectData | undefined>;
-    list: (query?: ProjectListQuery) => Promise<ProjectListItemData[]>;
+    list: (query?: ProjectListQueryData) => Promise<QueryResponseData<ProjectListItemData>>;
     create: (serverId: string, description: string) => Promise<{
         id: string;
     }>;

package/dist/types/project/Project/types.d.ts

@@ -1,4 +1,10 @@
 import { MittwaldAPIV2 } from "@mittwald/api-client";
-export type ProjectListQuery = MittwaldAPIV2.Paths.V2Projects.Get.Parameters.Query;
+import { Server } from "../../server/index.js";
+import { Customer } from "../../customer/index.js";
+export type ProjectListQueryData = MittwaldAPIV2.Paths.V2Projects.Get.Parameters.Query;
+export type ProjectListQueryModelData = Omit<ProjectListQueryData, "serverId" | "customerId"> & {
+    server?: Server;
+    customer?: Customer;
+};
 export type ProjectData = MittwaldAPIV2.Operations.ProjectGetProject.ResponseData;
 export type ProjectListItemData = MittwaldAPIV2.Operations.ProjectListProjects.ResponseData[number];

package/dist/types/server/Server/Server.d.ts

@@ -1,10 +1,14 @@
 import { ReferenceModel } from "../../base/ReferenceModel.js";
-import { ServerData, ServerListItemData } from "./types.js";
+import { ServerData, ServerListItemData, ServerListQueryData, ServerListQueryModelData } from "./types.js";
 import { DataModel } from "../../base/DataModel.js";
-import { Project } from "../../project/index.js";
+import { Project, ProjectListQuery } from "../../project/index.js";
 import { ParamsExceptFirst } from "../../lib/types.js";
 import { AsyncResourceVariant } from "../../lib/provideReact.js";
+import { ListQueryModel } from "../../base/ListQueryModel.js";
+import { ListDataModel } from "../../base/ListDataModel.js";
 export declare class Server extends ReferenceModel {
+    readonly projects: ProjectListQuery;
+    constructor(id: string);
     static ofId(id: string): Server;
     static find: ((id: string) => Promise<ServerDetailed | undefined>) & {
         asResource: (id: string) => import("@mittwald/react-use-promise").AsyncResource<ServerDetailed | undefined>;
@@ -14,16 +18,20 @@ export declare class Server extends ReferenceModel {
         asResource: (id: string) => import("@mittwald/react-use-promise").AsyncResource<ServerDetailed>;
         use: (id: string) => ServerDetailed;
     };
-    static list: ((query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Servers.Get.Parameters.Query | undefined) => Promise<ServerListItem[]>) & {
-        asResource: (query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Servers.Get.Parameters.Query | undefined) => import("@mittwald/react-use-promise").AsyncResource<ServerListItem[]>;
-        use: (query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Servers.Get.Parameters.Query | undefined) => ServerListItem[];
+    static query(query?: ServerListQueryModelData): ServerListQuery;
+    /** @deprecated: use query() or customer.servers */
+    static list: ((query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Servers.Get.Parameters.Query | undefined) => Promise<readonly ServerListItem[]>) & {
+        asResource: (query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Servers.Get.Parameters.Query | undefined) => import("@mittwald/react-use-promise").AsyncResource<readonly ServerListItem[]>;
+        use: (query?: import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Servers.Get.Parameters.Query | undefined) => readonly ServerListItem[];
     };
     createProject(...parameters: ParamsExceptFirst<typeof Project.create>): ReturnType<typeof Project.create>;
+    /** @deprecated Use Server.projects property */
     listProjects: ((query?: Omit<import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Projects.Get.Parameters.Query | undefined, "serverId"> | undefined) => Promise<readonly import("../../project/index.js").ProjectListItem[]>) & {
         asResource: (query?: Omit<import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Projects.Get.Parameters.Query | undefined, "serverId"> | undefined) => import("@mittwald/react-use-promise").AsyncResource<readonly import("../../project/index.js").ProjectListItem[]>;
         use: (query?: Omit<import("@mittwald/api-client").MittwaldAPIV2.Paths.V2Projects.Get.Parameters.Query | undefined, "serverId"> | undefined) => readonly import("../../project/index.js").ProjectListItem[];
     };
     getDetailed: AsyncResourceVariant<ServerDetailed, []>;
+    findDetailed: AsyncResourceVariant<ServerDetailed | undefined, []>;
 }
 declare const ServerCommon_base: import("polytype").Polytype.ClusteredConstructor<[{
     new (data: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.ProjectServer | {
@@ -103,4 +111,26 @@ declare const ServerListItem_base: import("polytype").Polytype.ClusteredConstruc
 export declare class ServerListItem extends ServerListItem_base {
     constructor(data: ServerListItemData);
 }
+export declare class ServerListQuery extends ListQueryModel<ServerListQueryModelData> {
+    constructor(query?: ServerListQueryModelData);
+    refine(query: ServerListQueryModelData): ServerListQuery;
+    execute: (() => Promise<ServerList>) & {
+        asResource: () => import("@mittwald/react-use-promise").AsyncResource<ServerList>;
+        use: () => ServerList;
+    };
+    getTotalCount: (() => Promise<number>) & {
+        asResource: () => import("@mittwald/react-use-promise").AsyncResource<number>;
+        use: () => number;
+    };
+    findOneAndOnly: (() => Promise<ServerListItem | undefined>) & {
+        asResource: () => import("@mittwald/react-use-promise").AsyncResource<ServerListItem | undefined>;
+        use: () => ServerListItem | undefined;
+    };
+}
+declare const ServerList_base: import("polytype").Polytype.ClusteredConstructor<[typeof ServerListQuery, {
+    new (items: ServerListItem[], totalCount: number): ListDataModel<ServerListItem>;
+}]>;
+export declare class ServerList extends ServerList_base {
+    constructor(query: ServerListQueryData, servers: ServerListItem[], totalCount: number);
+}
 export {};

package/dist/types/server/Server/behaviors/types.d.ts

@@ -1,5 +1,6 @@
-import { ServerListItemData, ServerData, ServerListQuery } from "../types.js";
+import { ServerListItemData, ServerData, ServerListQueryData } from "../types.js";
+import { QueryResponseData } from "../../../base/index.js";
 export interface ServerBehaviors {
     find: (id: string) => Promise<ServerData | undefined>;
-    list: (query?: ServerListQuery) => Promise<ServerListItemData[]>;
+    list: (query?: ServerListQueryData) => Promise<QueryResponseData<ServerListItemData>>;
 }

package/dist/types/server/Server/types.d.ts

@@ -1,4 +1,8 @@
 import { MittwaldAPIV2 } from "@mittwald/api-client";
-export type ServerListQuery = MittwaldAPIV2.Paths.V2Servers.Get.Parameters.Query;
+import { Customer } from "../../customer/index.js";
+export type ServerListQueryData = MittwaldAPIV2.Paths.V2Servers.Get.Parameters.Query;
+export type ServerListQueryModelData = Omit<ServerListQueryData, "customerId"> & {
+    customer?: Customer;
+};
 export type ServerData = MittwaldAPIV2.Operations.ProjectGetServer.ResponseData;
 export type ServerListItemData = MittwaldAPIV2.Operations.ProjectListServers.ResponseData[number];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mittwald/api-models",
-  "version": "4.53.0",
+  "version": "4.55.0",
   "author": "Mittwald CM Service GmbH & Co. KG <opensource@mittwald.de>",
   "type": "module",
   "description": "Collection of domain models for coherent interaction with the API",
@@ -39,8 +39,9 @@
     "test:unit": "node --experimental-vm-modules $(yarn bin jest)"
   },
   "dependencies": {
-    "@mittwald/api-client": "^4.53.0",
+    "@mittwald/api-client": "^4.55.0",
     "another-deep-freeze": "^1.0.0",
+    "object-code": "^1.3.3",
     "polytype": "^0.17.0",
     "type-fest": "^4.23.0"
   },
@@ -73,5 +74,5 @@
       "optional": true
     }
   },
-  "gitHead": "4bc0de67af85b90e25d8972067834213c4b55c68"
+  "gitHead": "29dc540f1f5b407220608e22b966a103b593ae55"
 }