@mittwald/api-models 4.338.1 → 4.339.0

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

@@ -0,0 +1,96 @@
+import { config } from "../../config/config.js";
+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 "../../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);
+    }
+    static find = provideReact(async (id) => {
+        const data = await config.behaviors.customer.find(id);
+        if (data !== undefined) {
+            return new CustomerDetailed(data);
+        }
+    });
+    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]);
+    async update(data) {
+        await config.behaviors.customer.update(this.id, data);
+    }
+}
+// Common class for future extension
+class CustomerCommon extends classes((DataModel), Customer) {
+    constructor(data) {
+        super([data], [data.customerId]);
+    }
+}
+export class CustomerDetailed extends classes(CustomerCommon, (DataModel)) {
+    constructor(data) {
+        super([data], [data]);
+    }
+}
+export class CustomerListItem extends classes(CustomerCommon, (DataModel)) {
+    constructor(data) {
+        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

@@ -0,0 +1,30 @@
+import { assertStatus, extractTotalCountHeader, } from "@mittwald/api-client";
+import { assertOneOfStatus } from "@mittwald/api-client";
+export const apiCustomerBehaviors = (client) => ({
+    find: async (id) => {
+        const response = await client.customer.getCustomer({
+            customerId: id,
+        });
+        if (response.status === 200) {
+            return response.data;
+        }
+        assertOneOfStatus(response, [404]);
+    },
+    list: async (query) => {
+        const response = await client.customer.listCustomers({
+            queryParameters: query,
+        });
+        assertStatus(response, 200);
+        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/customer/Customer/behaviors/index.js

@@ -0,0 +1,2 @@
+export * from "./api.js";
+export * from "./types.js";

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

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

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

@@ -0,0 +1,2 @@
+export * from "./Customer.js";
+export * from "./types.js";

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

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

package/dist/esm/customer/index.js

@@ -0,0 +1 @@
+export * from "./Customer/index.js";

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

@@ -0,0 +1,106 @@
+import { config } from "../../config/config.js";
+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 "../../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);
+    }
+    static ofHostname(hostname) {
+        return Ingress.ofId(hostname);
+    }
+    /** @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) {
+            return new IngressDetailed(data);
+        }
+    });
+    static get = provideReact(async (id) => {
+        const ingress = await this.find(id);
+        assertObjectFound(ingress, this, id);
+        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;
+    paths;
+    defaultPath;
+    constructor(data) {
+        super([data], [data.id]);
+        this.baseUrl = `https://${data.hostname}`;
+        this.paths = Object.freeze(data.paths.map((p) => new IngressPath(this, p)));
+        const defaultPath = this.paths.find((p) => p.path === "/");
+        if (defaultPath === undefined) {
+            throw new Error(`Ingress ${this.describe()} has no default path.`);
+        }
+        this.defaultPath = defaultPath;
+    }
+}
+export class IngressDetailed extends classes(IngressCommon, (DataModel)) {
+    constructor(data) {
+        super([data], [data]);
+    }
+}
+export class IngressListItem extends classes(IngressCommon, (DataModel)) {
+    constructor(data) {
+        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

@@ -0,0 +1,25 @@
+import { assertStatus } from "@mittwald/api-client";
+import { assertOneOfStatus } from "@mittwald/api-client";
+export const apiIngressBehaviors = (client) => ({
+    find: async (id) => {
+        const response = await client.domain.ingressGetIngress({
+            ingressId: id,
+        });
+        if (response.status === 200) {
+            return response.data;
+        }
+        assertOneOfStatus(response, [404]);
+    },
+    list: async (query = {}) => {
+        const response = await client.domain.ingressListIngresses({
+            queryParameters: query,
+        });
+        assertStatus(response, 200);
+        return {
+            items: response.data,
+            totalCount: response.data.length,
+            /** @todo: use this code when pagination is supported by API */
+            // totalCount: extractTotalCountHeader(response),
+        };
+    },
+});

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

@@ -0,0 +1,2 @@
+export * from "./api.js";
+export * from "./types.js";

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

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

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

@@ -0,0 +1,2 @@
+export * from "./Ingress.js";
+export * from "./types.js";

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

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

package/dist/esm/domain/IngressPath/IngressPath.js

@@ -0,0 +1,15 @@
+import { DataModel } from "../../base/DataModel.js";
+import { ingressTargetFactory, } from "../IngressTarget/IngressTarget.js";
+export class IngressPath extends DataModel {
+    ingress;
+    path;
+    url;
+    target;
+    constructor(ingress, data) {
+        super(data);
+        this.ingress = ingress;
+        this.path = data.path;
+        this.url = new URL(data.path, ingress.baseUrl);
+        this.target = ingressTargetFactory(this, data.target);
+    }
+}

package/dist/esm/domain/IngressPath/IngressPath.test.js

@@ -0,0 +1,16 @@
+import { IngressPath } from "./IngressPath.js";
+import { IngressDetailed } from "../Ingress/index.js";
+const ingressData = {
+    id: "abc",
+    paths: [],
+};
+const corruptIngressTargetData = {};
+const ingressPathData = {
+    path: "/",
+    target: corruptIngressTargetData,
+};
+test("Creating IngressPath with corrupt IngressTarget throws error", () => {
+    expect(() => {
+        new IngressPath(new IngressDetailed(ingressData), ingressPathData);
+    }).toThrowError("Ingress IngressDetailed@abc has no default path.");
+});

package/dist/esm/domain/IngressPath/index.js

@@ -0,0 +1,2 @@
+export * from "./IngressPath.js";
+export * from "./types.js";

package/dist/esm/domain/IngressPath/types.js

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

package/dist/esm/domain/IngressTarget/IngressTarget.js

@@ -0,0 +1,40 @@
+import { DataModel } from "../../base/DataModel.js";
+import { AppInstallation } from "../../app/AppInstallation/index.js";
+class IngressTargetBase extends DataModel {
+    path;
+    constructor(path, data) {
+        super(data);
+        this.path = path;
+    }
+}
+export class IngressRedirectTarget extends IngressTargetBase {
+    type = "redirect";
+    url;
+    constructor(path, data) {
+        super(path, data);
+        this.url = new URL(data.url);
+    }
+}
+export class IngressAppInstallationTarget extends IngressTargetBase {
+    type = "appInstallation";
+    appInstallation;
+    constructor(path, data) {
+        super(path, data);
+        this.appInstallation = AppInstallation.ofId(data.installationId);
+    }
+}
+export class IngressUndefinedTarget extends IngressTargetBase {
+    type = "undefined";
+}
+export const ingressTargetFactory = (path, data) => {
+    if ("url" in data) {
+        return new IngressRedirectTarget(path, data);
+    }
+    if ("installationId" in data) {
+        return new IngressAppInstallationTarget(path, data);
+    }
+    if ("useDefaultPage" in data) {
+        return new IngressUndefinedTarget(path, data);
+    }
+    throw new Error("Ingress target type is not supported.");
+};

package/dist/esm/domain/IngressTarget/IngressTarget.test-types.js

@@ -0,0 +1,10 @@
+const target = {};
+// @ts-expect-error use type-guard first
+void target.url;
+if (target.type === "redirect") {
+    void target.url;
+}
+if (target.type === "appInstallation") {
+    void target.appInstallation.id;
+}
+export {};

package/dist/esm/domain/IngressTarget/index.js

@@ -0,0 +1,2 @@
+export * from "./IngressTarget.js";
+export * from "./types.js";

package/dist/esm/domain/IngressTarget/types.js

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

package/dist/esm/domain/index.js

@@ -0,0 +1 @@
+export * from "./Ingress/index.js";

package/dist/esm/errors/ObjectNotFoundError.js

@@ -0,0 +1,7 @@
+export default class ObjectNotFoundError extends Error {
+    constructor(type, refName) {
+        super(`${type}@${refName} not found`);
+        this.name = "ObjectNotFoundError";
+        Object.setPrototypeOf(this, ObjectNotFoundError.prototype);
+    }
+}

package/dist/esm/index.js

@@ -0,0 +1,7 @@
+export { MittwaldAPIV2Client } from "@mittwald/api-client";
+export * from "./config/index.js";
+export * from "./project/index.js";
+export * from "./server/index.js";
+export * from "./domain/index.js";
+export * from "./customer/index.js";
+export * from "./base/index.js";

package/dist/esm/lib/deepFreeze.js

@@ -0,0 +1,4 @@
+import deepFreezeLib from "another-deep-freeze";
+// eslint-disable-next-line
+const deepFreeze = deepFreezeLib.default;
+export default deepFreeze;

package/dist/esm/lib/joinedId.js

@@ -0,0 +1 @@
+export const joinedId = (...parts) => parts.join(" | ");

package/dist/esm/lib/types.js

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

package/dist/esm/marketplace/Contributor/Contributor.js

@@ -0,0 +1,83 @@
+import { config } from "../../config/config.js";
+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 "../../react/provideReact.js";
+import { ListQueryModel } from "../../base/ListQueryModel.js";
+import { ListDataModel } from "../../base/ListDataModel.js";
+import { ContributorIncomingInvoiceListQuery } from "./ContributorIncomingInvoice.js";
+export class Contributor extends ReferenceModel {
+    incomingInvoices;
+    constructor(id) {
+        super(id);
+        this.incomingInvoices = new ContributorIncomingInvoiceListQuery(this);
+    }
+    static ofId(id) {
+        return new Contributor(id);
+    }
+    static find = provideReact(async (id) => {
+        const data = await config.behaviors.contributor.find(id);
+        if (data !== undefined) {
+            return new ContributorDetailed(data);
+        }
+    });
+    static query(query = {}) {
+        return new ContributorListQuery(query);
+    }
+    static get = provideReact(async (id) => {
+        const contributor = await this.find(id);
+        assertObjectFound(contributor, this, id);
+        return contributor;
+    });
+    getDetailed = provideReact(() => Contributor.get(this.id), [this.id]);
+    findDetailed = provideReact(() => Contributor.find(this.id), [this.id]);
+}
+class ContributorCommon extends classes((DataModel), Contributor) {
+    constructor(data) {
+        super([data], [data.id]);
+    }
+}
+export class ContributorDetailed extends classes(ContributorCommon, (DataModel)) {
+    constructor(data) {
+        super([data], [data]);
+    }
+}
+export class ContributorListItem extends classes(ContributorCommon, (DataModel)) {
+    constructor(data) {
+        super([data], [data]);
+    }
+}
+export class ContributorListQuery extends ListQueryModel {
+    constructor(query = {}) {
+        super(query);
+    }
+    refine(query) {
+        return new ContributorListQuery({
+            ...this.query,
+            ...query,
+        });
+    }
+    execute = provideReact(async () => {
+        const { items, totalCount } = await config.behaviors.contributor.list({
+            limit: config.defaultPaginationLimit,
+            ...this.query,
+        });
+        return new ContributorList(this.query, items.map((d) => new ContributorListItem(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 ContributorList extends classes(ContributorListQuery, (ListDataModel)) {
+    constructor(query, contributors, totalCount) {
+        super([query], [contributors, totalCount]);
+    }
+}

package/dist/esm/marketplace/Contributor/ContributorIncomingInvoice.js

@@ -0,0 +1,53 @@
+import { classes } from "polytype";
+import { ListQueryModel } from "../../base/ListQueryModel.js";
+import { Money } from "../../base/Money.js";
+import { provideReact } from "../../react.js";
+import { DateTime } from "luxon";
+import { ListDataModel } from "../../base/ListDataModel.js";
+import { DataModel } from "../../base/DataModel.js";
+import { config } from "../../config/config.js";
+export class ContributorIncomingInvoice extends DataModel {
+    contributor;
+    id;
+    pdfId;
+    invoiceNumber;
+    date;
+    totalNet;
+    totalGross;
+    constructor(contributor, data) {
+        super(data);
+        this.contributor = contributor;
+        this.id = data.id;
+        this.pdfId = data.pdfId;
+        this.invoiceNumber = data.invoiceNumber;
+        this.date = DateTime.fromISO(data.date);
+        this.totalNet = Money({ amount: data.totalNet, currency: "EUR" });
+        this.totalGross = Money({ amount: data.totalGross, currency: "EUR" });
+    }
+}
+export class ContributorIncomingInvoiceListQuery extends ListQueryModel {
+    contributor;
+    constructor(contributor, query = {}) {
+        super(query, { dependencies: [contributor.id] });
+        this.contributor = contributor;
+    }
+    refine(query) {
+        return new ContributorIncomingInvoiceListQuery(this.contributor, {
+            ...this.query,
+            ...query,
+        });
+    }
+    execute = provideReact(async () => {
+        const { items, totalCount } = await config.behaviors.contributor.listIncomingInvoices(this.contributor.id, this.query);
+        return new ContributorIncomingInvoicesList(this.contributor, this.query, items.map((i) => new ContributorIncomingInvoice(this.contributor, i)), totalCount);
+    }, [this.queryId]);
+    getTotalCount = provideReact(async () => {
+        const result = await this.refine({ limit: 1, skip: 0 }).execute();
+        return result.totalCount;
+    });
+}
+export class ContributorIncomingInvoicesList extends classes(ContributorIncomingInvoiceListQuery, (ListDataModel)) {
+    constructor(contributor, query, invoices, totalCount) {
+        super([contributor, query], [invoices, totalCount]);
+    }
+}

package/dist/esm/marketplace/Contributor/behaviors/api.js

@@ -0,0 +1,39 @@
+import { extractTotalCountHeader, assertStatus, } from "@mittwald/api-client";
+export const apiContributorBehaviors = (client) => ({
+    find: async (contributorId) => {
+        const response = await client.marketplace.extensionGetContributor({
+            contributorId,
+        });
+        if (response.status === 200) {
+            return response.data;
+        }
+        assertStatus(response, 404);
+    },
+    list: async (query) => {
+        const response = await client.marketplace.extensionListContributors({
+            queryParameters: query,
+        });
+        assertStatus(response, 200);
+        return {
+            items: response.data,
+            totalCount: extractTotalCountHeader(response),
+        };
+    },
+    listIncomingInvoices: async (contributorId, queryParameters) => {
+        const response = await client.marketplace.contributorListIncomingInvoices({
+            contributorId,
+            queryParameters,
+        });
+        if (response.status === 200) {
+            return {
+                items: response.data,
+                totalCount: extractTotalCountHeader(response),
+            };
+        }
+        assertStatus(response, 404);
+        return {
+            items: [],
+            totalCount: 0,
+        };
+    },
+});

package/dist/esm/marketplace/Contributor/behaviors/index.js

@@ -0,0 +1,2 @@
+export * from "./api.js";
+export * from "./types.js";

package/dist/esm/marketplace/Contributor/behaviors/types.js

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

package/dist/esm/marketplace/Contributor/index.js

@@ -0,0 +1,3 @@
+export * from "./Contributor.js";
+export * from "./ContributorIncomingInvoice.js";
+export * from "./types.js";

package/dist/esm/marketplace/Contributor/types.js

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

package/dist/esm/marketplace/index.js

@@ -0,0 +1 @@
+export * from "./Contributor/index.js";