@mittwald/api-models 0.0.0-development-04b7288-20240610 → 0.0.0-development-74e1fd1-20240611

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

@@ -0,0 +1,43 @@
+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 "../../lib/provideReact.js";
+export class AppInstallation extends ReferenceModel {
+    static find = provideReact(async (id) => {
+        const data = await config.behaviors.appInstallation.find(id);
+        if (data !== undefined) {
+            return new AppInstallationDetailed(data);
+        }
+    });
+    static get = provideReact(async (id) => {
+        const appInstallation = await this.find(id);
+        assertObjectFound(appInstallation, this, id);
+        return appInstallation;
+    });
+    static ofId(id) {
+        return new AppInstallation(id);
+    }
+    static list = provideReact(async (projectId, query = {}) => {
+        const data = await config.behaviors.appInstallation.list(projectId, query);
+        return data.map((d) => new AppInstallationListItem(d));
+    });
+    getDetailed = provideReact(() => AppInstallation.get(this.id));
+}
+// Common class for future extension
+class AppInstallationCommon extends classes((DataModel), AppInstallation) {
+    constructor(data) {
+        super([data], [data.id]);
+    }
+}
+export class AppInstallationDetailed extends classes(AppInstallationCommon, (DataModel)) {
+    constructor(data) {
+        super([data], [data]);
+    }
+}
+export class AppInstallationListItem extends classes(AppInstallationCommon, (DataModel)) {
+    constructor(data) {
+        super([data], [data]);
+    }
+}

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

@@ -0,0 +1,21 @@
+import { assertStatus } from "@mittwald/api-client";
+import { assertOneOfStatus } from "@mittwald/api-client";
+export const apiAppInstallationBehaviors = (client) => ({
+    find: async (id) => {
+        const response = await client.app.getAppinstallation({
+            appInstallationId: id,
+        });
+        if (response.status === 200) {
+            return response.data;
+        }
+        assertOneOfStatus(response, [404]);
+    },
+    list: async (projectId, query) => {
+        const response = await client.app.listAppinstallations({
+            queryParameters: query,
+            projectId,
+        });
+        assertStatus(response, 200);
+        return response.data;
+    },
+});

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

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

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

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

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

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

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

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

package/dist/esm/app/index.js

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

package/dist/esm/base/DataModel.js

@@ -0,0 +1,7 @@
+import deepFreeze from "../lib/deepFreeze.js";
+export class DataModel {
+    data;
+    constructor(data) {
+        this.data = deepFreeze(data);
+    }
+}

package/dist/esm/base/ReferenceModel.js

@@ -0,0 +1,9 @@
+export class ReferenceModel {
+    id;
+    constructor(id) {
+        this.id = id;
+    }
+    describe() {
+        return `${this.constructor.name}@${this.id}`;
+    }
+}

package/dist/esm/base/assertObjectFound.js

@@ -0,0 +1,9 @@
+import ObjectNotFoundError from "../errors/ObjectNotFoundError.js";
+export default function assertObjectFound(obj, theClass, refIdOrObject) {
+    if (obj === undefined) {
+        const refName = typeof refIdOrObject === "string"
+            ? refIdOrObject
+            : refIdOrObject.toString();
+        throw new ObjectNotFoundError(theClass.name, refName);
+    }
+}

package/dist/esm/base/index.js

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

package/dist/esm/base/types.js

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

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

@@ -0,0 +1,40 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { config } from "../config.js";
+import { apiProjectBehaviors } from "../../project/Project/behaviors/index.js";
+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";
+class ApiSetupState {
+    _client;
+    setupWithClient(client) {
+        if (this._client !== undefined) {
+            throw new Error("API already setup. If you want to operate on the API client use api.client.");
+        }
+        this._client = client;
+        config.behaviors.project = apiProjectBehaviors(client);
+        config.behaviors.server = apiServerBehaviors(client);
+        config.behaviors.customer = apiCustomerBehaviors(client);
+        config.behaviors.ingress = apiIngressBehaviors(client);
+        config.behaviors.appInstallation = apiAppInstallationBehaviors(client);
+    }
+    setupWithApiToken(apiToken) {
+        return this.setupWithClient(MittwaldAPIV2Client.newWithToken(apiToken));
+    }
+    setupUnauthenticated() {
+        return this.setupWithClient(MittwaldAPIV2Client.newUnauthenticated());
+    }
+    get client() {
+        if (!this._client) {
+            throw new Error("Could not get client. Behavior not initialized.");
+        }
+        return this._client;
+    }
+    get defaults() {
+        return this.client.axios.defaults;
+    }
+    get interceptors() {
+        return this.client.axios.interceptors;
+    }
+}
+export const api = new ApiSetupState();

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

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

package/dist/esm/config/config.js

@@ -0,0 +1,9 @@
+export const config = {
+    behaviors: {
+        project: undefined,
+        server: undefined,
+        customer: undefined,
+        ingress: undefined,
+        appInstallation: undefined,
+    },
+};

package/dist/esm/config/index.js

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

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

@@ -0,0 +1,43 @@
+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 "../../lib/provideReact.js";
+export class Customer extends ReferenceModel {
+    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 list = provideReact(async (query = {}) => {
+        const data = await config.behaviors.customer.list(query);
+        return Object.freeze(data.map((d) => new CustomerListItem(d)));
+    });
+    static get = provideReact(async (id) => {
+        const customer = await this.find(id);
+        assertObjectFound(customer, this, id);
+        return customer;
+    });
+    getDetailed = provideReact(() => Customer.get(this.id));
+}
+// 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]);
+    }
+}

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

@@ -0,0 +1,20 @@
+import { assertStatus } 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 response.data;
+    },
+});

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,56 @@
+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 "../../lib/provideReact.js";
+import { IngressPath } from "../IngressPath/IngressPath.js";
+export class Ingress extends ReferenceModel {
+    static ofId(id) {
+        return new Ingress(id);
+    }
+    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));
+    });
+    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));
+}
+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]);
+    }
+}

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

@@ -0,0 +1,23 @@
+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 { projectId } = query;
+        const response = await client.domain.ingressListIngresses({
+            queryParameters: {
+                projectId,
+            },
+        });
+        assertStatus(response, 200);
+        return response.data;
+    },
+});

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,51 @@
+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 IngressDirectoryTarget extends IngressTargetBase {
+    type = "directory";
+    directory;
+    constructor(path, data) {
+        super(path, data);
+        this.directory = data.directory;
+    }
+}
+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 ("directory" in data) {
+        return new IngressDirectoryTarget(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,13 @@
+const target = {};
+// @ts-expect-error use type-guard first
+void target.url;
+if (target.type === "redirect") {
+    void target.url;
+}
+if (target.type === "directory") {
+    void target.directory;
+}
+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/provideReact.js

@@ -0,0 +1,5 @@
+import { reactUsePromise } from "../react/reactUsePromise.js";
+export const provideReact = (loader) => Object.assign(loader, {
+    asResource: (...params) => reactUsePromise.getAsyncResource(loader, params),
+    use: (...params) => reactUsePromise.getAsyncResource(loader, params).use(),
+});

package/dist/esm/lib/types.js

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

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

@@ -0,0 +1,69 @@
+import { config } from "../../config/config.js";
+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 { Customer } from "../../customer/Customer/Customer.js";
+import { ReferenceModel } from "../../base/ReferenceModel.js";
+import { Ingress, IngressListItem } from "../../domain/index.js";
+export class Project extends ReferenceModel {
+    static ofId(id) {
+        return new Project(id);
+    }
+    static find = provideReact(async (id) => {
+        const data = await config.behaviors.project.find(id);
+        if (data !== undefined) {
+            return new ProjectDetailed(data);
+        }
+    });
+    static get = provideReact(async (id) => {
+        const project = await this.find(id);
+        assertObjectFound(project, this, id);
+        return project;
+    });
+    static list = provideReact(async (query = {}) => {
+        const data = await config.behaviors.project.list(query);
+        return Object.freeze(data.map((d) => new ProjectListItem(d)));
+    });
+    static async create(serverId, description) {
+        const { id } = await config.behaviors.project.create(serverId, description);
+        return new Project(id);
+    }
+    getDetailed = provideReact(() => Project.get(this.id));
+    listIngresses = provideReact(() => Ingress.list({ projectId: this.id }));
+    getDefaultIngress = provideReact(async () => {
+        const ingresses = await Project.ofId(this.id).listIngresses();
+        const defaultIngress = ingresses.find((i) => i.data.isDefault);
+        assertObjectFound(defaultIngress, IngressListItem, this);
+        return defaultIngress;
+    });
+    async updateDescription(description) {
+        await config.behaviors.project.updateDescription(this.id, description);
+    }
+    async leave() {
+        await config.behaviors.project.leave(this.id);
+    }
+    async delete() {
+        await config.behaviors.project.delete(this.id);
+    }
+}
+class ProjectCommon extends classes((DataModel), Project) {
+    server;
+    customer;
+    constructor(data) {
+        super([data], [data.id]);
+        this.server = data.serverId ? Server.ofId(data.serverId) : undefined;
+        this.customer = Customer.ofId(data.customerId);
+    }
+}
+export class ProjectDetailed extends classes(ProjectCommon, (DataModel)) {
+    constructor(data) {
+        super([data], [data]);
+    }
+}
+export class ProjectListItem extends classes(ProjectCommon, (DataModel)) {
+    constructor(data) {
+        super([data], [data]);
+    }
+}

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

@@ -0,0 +1,51 @@
+import { assertStatus } from "@mittwald/api-client";
+import { assertOneOfStatus } from "@mittwald/api-client";
+export const apiProjectBehaviors = (client) => ({
+    find: async (id) => {
+        const response = await client.project.getProject({
+            projectId: id,
+        });
+        if (response.status === 200) {
+            return response.data;
+        }
+        assertOneOfStatus(response, [403]);
+    },
+    list: async (query) => {
+        const response = await client.project.listProjects({
+            queryParameters: query,
+        });
+        assertStatus(response, 200);
+        return response.data;
+    },
+    create: async (serverId, description) => {
+        const response = await client.project.createProject({
+            serverId,
+            data: {
+                description,
+            },
+        });
+        assertStatus(response, 201);
+        return response.data;
+    },
+    leave: async (id) => {
+        const response = await client.project.leaveProject({
+            projectId: id,
+        });
+        assertStatus(response, 204);
+    },
+    delete: async (id) => {
+        const response = await client.project.deleteProject({
+            projectId: id,
+        });
+        assertStatus(response, 204);
+    },
+    updateDescription: async (id, description) => {
+        const response = await client.project.updateProjectDescription({
+            projectId: id,
+            data: {
+                description,
+            },
+        });
+        assertStatus(response, 204);
+    },
+});

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

@@ -0,0 +1,23 @@
+export const inMemProjectBehaviors = (store) => ({
+    find: async (id) => store.get(id),
+    list: async () => {
+        return Array.from(store.values()).map((detailedProject) => ({
+            ...detailedProject,
+            customerMeta: {
+                id: detailedProject.customerId,
+            },
+        }));
+    },
+    create: async () => {
+        throw new Error("Not implemented");
+    },
+    leave: async () => {
+        throw new Error("Not implemented");
+    },
+    delete: async () => {
+        throw new Error("Not implemented");
+    },
+    updateDescription: async () => {
+        throw new Error("Not implemented");
+    },
+});