@mittwald/api-models 0.1.0-alpha.1

package/dist/index.mjs

@@ -0,0 +1,704 @@
+import { assertStatus } from '@mittwald/api-client';
+import { assertOneOfStatus } from '@mittwald/api-client-commons';
+import { classes } from 'polytype';
+import deepFreezeLib from 'another-deep-freeze';
+import { w as withAsyncResourceVariant } from './shared/api-models.54184fa2.mjs';
+
+const config = {
+  behaviors: {
+    project: void 0,
+    server: void 0,
+    customer: void 0,
+    ingress: void 0,
+    appInstallation: void 0
+  }
+};
+
+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, 200);
+  }
+});
+
+const apiServerBehaviors = (client) => ({
+  find: async (id) => {
+    const response = await client.project.getServer({
+      serverId: id
+    });
+    if (response.status === 200) {
+      return response.data;
+    }
+    assertOneOfStatus(response, [403, 404]);
+  },
+  list: async (query) => {
+    const response = await client.project.listServers({
+      queryParameters: query
+    });
+    assertStatus(response, 200);
+    return response.data;
+  }
+});
+
+const apiCustomerBehaviors = (client) => ({
+  find: async (id) => {
+    const response = await client.customer.getCustomer({
+      customerId: id
+    });
+    if (response.status === 200) {
+      return response.data;
+    }
+    assertOneOfStatus(response, [403]);
+  },
+  list: async (query) => {
+    const response = await client.customer.listCustomers({
+      queryParameters: query
+    });
+    assertStatus(response, 200);
+    return response.data;
+  }
+});
+
+const apiIngressBehaviors = (client) => ({
+  find: async (id) => {
+    const response = await client.domain.ingressGetSpecific({
+      ingressId: id
+    });
+    if (response.status === 200) {
+      return response.data;
+    }
+    assertOneOfStatus(response, [403]);
+  },
+  list: async (query = {}) => {
+    const { projectId } = query;
+    if (projectId) {
+      const response = await client.domain.ingressListForProject({
+        projectId
+      });
+      assertStatus(response, 200);
+      return response.data;
+    } else {
+      const response = await client.domain.ingressListAccessible();
+      assertStatus(response, 200);
+      return response.data;
+    }
+  }
+});
+
+const apiAppInstallationBehaviors = (client) => ({
+  find: async (id) => {
+    const response = await client.appInstallation.getAppInstallation({
+      appInstallationId: id
+    });
+    if (response.status === 200) {
+      return response.data;
+    }
+    assertOneOfStatus(response, [403]);
+  },
+  list: async (query) => {
+    const response = await client.appInstallation.listAppInstallations({
+      queryParameters: query
+    });
+    assertStatus(response, 200);
+    return response.data;
+  }
+});
+
+const setupApiBehaviors = (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);
+};
+
+const deepFreeze = deepFreezeLib.default;
+
+var __defProp$8 = Object.defineProperty;
+var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$8 = (obj, key, value) => {
+  __defNormalProp$8(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class DataModel {
+  constructor(data) {
+    __publicField$8(this, "data");
+    this.data = deepFreeze(data);
+  }
+}
+
+class ObjectNotFoundError extends Error {
+  constructor(type, refName) {
+    super(`${type}@${refName} not found`);
+    this.name = "ObjectNotFoundError";
+    Object.setPrototypeOf(this, ObjectNotFoundError.prototype);
+  }
+}
+
+function assertObjectFound(obj, theClass, refIdOrObject) {
+  if (obj === void 0) {
+    const refName = typeof refIdOrObject === "string" ? refIdOrObject : refIdOrObject.toString();
+    throw new ObjectNotFoundError(theClass.name, refName);
+  }
+}
+
+var __defProp$7 = Object.defineProperty;
+var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$7 = (obj, key, value) => {
+  __defNormalProp$7(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class ReferenceModel {
+  constructor(id) {
+    __publicField$7(this, "id");
+    this.id = id;
+  }
+  describe() {
+    return `${this.constructor.name}@${this.id}`;
+  }
+}
+
+const uuidRegex = RegExp(
+  "^[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}$"
+);
+const isUuid = (testString) => uuidRegex.test(testString);
+
+var __defProp$6 = Object.defineProperty;
+var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$6 = (obj, key, value) => {
+  __defNormalProp$6(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const _Server = class _Server extends ReferenceModel {
+  constructor() {
+    super(...arguments);
+    __publicField$6(this, "listProjects", withAsyncResourceVariant(
+      async (query = {}) => {
+        return Project.list({
+          ...query,
+          serverId: await this.getUuid()
+        });
+      }
+    ));
+    __publicField$6(this, "getDetailed", withAsyncResourceVariant(
+      () => ServerDetailed.get(this.id)
+    ));
+  }
+  static ofId(id) {
+    return new _Server(id);
+  }
+  async getUuid() {
+    return _Server.getUuid(this.id);
+  }
+  static async getUuid(shortIdOrUuid) {
+    if (isUuid(shortIdOrUuid)) {
+      return shortIdOrUuid;
+    }
+    const allServers = await ServerListItem.list();
+    const uuid = allServers.find((p) => p.data.shortId === shortIdOrUuid)?.id;
+    assertObjectFound(uuid, _Server, shortIdOrUuid);
+    return uuid;
+  }
+  async createProject(...parameters) {
+    return Project.create(await this.getUuid(), ...parameters);
+  }
+};
+__publicField$6(_Server, "find", withAsyncResourceVariant(
+  async (id) => {
+    const serverData = await config.behaviors.server.find(
+      await _Server.getUuid(id)
+    );
+    if (serverData !== void 0) {
+      return new ServerDetailed([serverData]);
+    }
+  }
+));
+__publicField$6(_Server, "get", withAsyncResourceVariant(
+  async (id) => {
+    const server = await ServerDetailed.find(id);
+    assertObjectFound(server, _Server, id);
+    return server;
+  }
+));
+__publicField$6(_Server, "list", withAsyncResourceVariant(
+  async (query = {}) => {
+    const projectListData = await config.behaviors.server.list(query);
+    return projectListData.map((d) => new ServerListItem([d]));
+  }
+));
+let Server = _Server;
+class ServerCommon extends classes(
+  DataModel,
+  Server
+) {
+  constructor(data) {
+    super([data], [data.id]);
+  }
+}
+class ServerListItem extends classes(ServerCommon, DataModel) {
+}
+class ServerDetailed extends classes(ServerCommon, DataModel) {
+}
+
+var __defProp$5 = Object.defineProperty;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$5 = (obj, key, value) => {
+  __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const _Customer = class _Customer extends ReferenceModel {
+  constructor() {
+    super(...arguments);
+    __publicField$5(this, "getDetailed", withAsyncResourceVariant(
+      () => _Customer.get(this.id)
+    ));
+  }
+  static ofId(id) {
+    return new _Customer(id);
+  }
+  static async getUuid(numberOrUuid) {
+    if (isUuid(numberOrUuid)) {
+      return numberOrUuid;
+    }
+    const allCustomers = await CustomerListItem.list();
+    const uuid = allCustomers.find(
+      (p) => p.data.customerNumber === numberOrUuid
+    )?.id;
+    assertObjectFound(uuid, _Customer, numberOrUuid);
+    return uuid;
+  }
+};
+__publicField$5(_Customer, "find", withAsyncResourceVariant(
+  async (id) => {
+    const data = await config.behaviors.customer.find(
+      await _Customer.getUuid(id)
+    );
+    if (data !== void 0) {
+      return new CustomerDetailed(data);
+    }
+  }
+));
+__publicField$5(_Customer, "list", withAsyncResourceVariant(
+  async (query = {}) => {
+    const data = await config.behaviors.customer.list(query);
+    return Object.freeze(data.map((d) => new CustomerListItem(d)));
+  }
+));
+__publicField$5(_Customer, "get", withAsyncResourceVariant(
+  async (id) => {
+    const customer = await _Customer.find(id);
+    assertObjectFound(customer, _Customer, id);
+    return customer;
+  }
+));
+let Customer = _Customer;
+class CustomerCommon extends classes(
+  DataModel,
+  Customer
+) {
+  constructor(data) {
+    super([data], [data.customerId]);
+  }
+}
+class CustomerDetailed extends classes(
+  CustomerCommon,
+  DataModel
+) {
+  constructor(data) {
+    super([data], [data]);
+  }
+}
+class CustomerListItem extends classes(
+  CustomerCommon,
+  DataModel
+) {
+  constructor(data) {
+    super([data], [data]);
+  }
+}
+
+var __defProp$4 = Object.defineProperty;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$4 = (obj, key, value) => {
+  __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const _AppInstallation = class _AppInstallation extends ReferenceModel {
+  constructor() {
+    super(...arguments);
+    __publicField$4(this, "getDetailed", withAsyncResourceVariant(
+      () => _AppInstallation.get(this.id)
+    ));
+  }
+  static ofId(id) {
+    return new _AppInstallation(id);
+  }
+};
+__publicField$4(_AppInstallation, "find", withAsyncResourceVariant(
+  async (id) => {
+    const data = await config.behaviors.appInstallation.find(id);
+    if (data !== void 0) {
+      return new AppInstallationDetailed(data);
+    }
+  }
+));
+__publicField$4(_AppInstallation, "get", withAsyncResourceVariant(
+  async (id) => {
+    const appInstallation = await _AppInstallation.find(id);
+    assertObjectFound(appInstallation, _AppInstallation, id);
+    return appInstallation;
+  }
+));
+__publicField$4(_AppInstallation, "list", withAsyncResourceVariant(
+  async (query = {}) => {
+    const data = await config.behaviors.appInstallation.list(query);
+    return data.map((d) => new AppInstallationListItem(d));
+  }
+));
+let AppInstallation = _AppInstallation;
+class AppInstallationCommon extends classes(
+  DataModel,
+  AppInstallation
+) {
+  constructor(data) {
+    super([data], [data.id]);
+  }
+}
+class AppInstallationDetailed extends classes(
+  AppInstallationCommon,
+  DataModel
+) {
+  constructor(data) {
+    super([data], [data]);
+  }
+}
+class AppInstallationListItem extends classes(
+  AppInstallationCommon,
+  DataModel
+) {
+  constructor(data) {
+    super([data], [data]);
+  }
+}
+
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => {
+  __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class IngressTargetBase extends DataModel {
+  constructor(path, data) {
+    super(data);
+    __publicField$3(this, "path");
+    this.path = path;
+  }
+}
+class IngressRedirectTarget extends IngressTargetBase {
+  constructor(path, data) {
+    super(path, data);
+    __publicField$3(this, "type", "redirect");
+    __publicField$3(this, "url");
+    this.url = new URL(data.url);
+  }
+}
+class IngressDirectoryTarget extends IngressTargetBase {
+  constructor(path, data) {
+    super(path, data);
+    __publicField$3(this, "type", "directory");
+    __publicField$3(this, "directory");
+    this.directory = data.directory;
+  }
+}
+class IngressAppInstallationTarget extends IngressTargetBase {
+  constructor(path, data) {
+    super(path, data);
+    __publicField$3(this, "type", "appInstallation");
+    __publicField$3(this, "appInstallation");
+    this.appInstallation = AppInstallation.ofId(data.installationId);
+  }
+}
+class IngressUndefinedTarget extends IngressTargetBase {
+  constructor() {
+    super(...arguments);
+    __publicField$3(this, "type", "undefined");
+  }
+}
+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.");
+};
+
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => {
+  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class IngressPath extends DataModel {
+  constructor(ingress, data) {
+    super(data);
+    __publicField$2(this, "ingress");
+    __publicField$2(this, "path");
+    __publicField$2(this, "url");
+    __publicField$2(this, "target");
+    this.ingress = ingress;
+    this.path = data.path;
+    this.url = new URL(data.path, ingress.baseUrl);
+    this.target = ingressTargetFactory(this, data.target);
+  }
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const _Ingress = class _Ingress extends ReferenceModel {
+  constructor() {
+    super(...arguments);
+    __publicField$1(this, "getDetailed", withAsyncResourceVariant(
+      () => _Ingress.get(this.id)
+    ));
+  }
+  static ofId(id) {
+    return new _Ingress(id);
+  }
+  static ofHostname(hostname) {
+    return _Ingress.ofId(hostname);
+  }
+  static async getUuid(hostnameOrUuid) {
+    if (isUuid(hostnameOrUuid)) {
+      return hostnameOrUuid;
+    }
+    const allIngress = await IngressListItem.list();
+    const uuid = allIngress.find(
+      (p) => p.data.isEnabled && p.data.hostname === hostnameOrUuid
+    )?.id;
+    assertObjectFound(uuid, _Ingress, hostnameOrUuid);
+    return uuid;
+  }
+};
+__publicField$1(_Ingress, "list", withAsyncResourceVariant(
+  async (query = {}) => {
+    const data = await config.behaviors.ingress.list(query);
+    return data.map((d) => new IngressListItem(d));
+  }
+));
+__publicField$1(_Ingress, "find", withAsyncResourceVariant(
+  async (id) => {
+    const data = await config.behaviors.ingress.find(
+      await _Ingress.getUuid(id)
+    );
+    if (data !== void 0) {
+      return new IngressDetailed(data);
+    }
+  }
+));
+__publicField$1(_Ingress, "get", withAsyncResourceVariant(
+  async (id) => {
+    const ingress = await _Ingress.find(id);
+    assertObjectFound(ingress, _Ingress, id);
+    return ingress;
+  }
+));
+let Ingress = _Ingress;
+class IngressCommon extends classes(
+  DataModel,
+  Ingress
+) {
+  constructor(data) {
+    super([data], [data.id]);
+    __publicField$1(this, "baseUrl");
+    __publicField$1(this, "paths");
+    __publicField$1(this, "defaultPath");
+    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 === void 0) {
+      throw new Error(`Ingress ${this.describe()} has no default path.`);
+    }
+    this.defaultPath = defaultPath;
+  }
+}
+class IngressDetailed extends classes(
+  IngressCommon,
+  DataModel
+) {
+  constructor(data) {
+    super([data], [data]);
+  }
+}
+class IngressListItem extends classes(
+  IngressCommon,
+  DataModel
+) {
+  constructor(data) {
+    super([data], [data]);
+  }
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const _Project = class _Project extends ReferenceModel {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "getDetailed", withAsyncResourceVariant(
+      () => _Project.get(this.id)
+    ));
+    __publicField(this, "listIngresses", withAsyncResourceVariant(
+      () => Ingress.list({ projectId: this.id })
+    ));
+    __publicField(this, "getDefaultIngress", withAsyncResourceVariant(async () => {
+      const ingresses = await _Project.ofId(this.id).listIngresses();
+      const defaultIngress = ingresses.find((i) => i.data.isDefault);
+      assertObjectFound(defaultIngress, IngressListItem, this);
+      return defaultIngress;
+    }));
+  }
+  static ofId(id) {
+    return new _Project(id);
+  }
+  static async create(serverId, description) {
+    const { id } = await config.behaviors.project.create(serverId, description);
+    return new _Project(id);
+  }
+  async getUuid() {
+    return _Project.getUuid(this.id);
+  }
+  static async getUuid(shortIdOrUuid) {
+    if (isUuid(shortIdOrUuid)) {
+      return shortIdOrUuid;
+    }
+    const allProjects = await ProjectListItem.list();
+    const uuid = allProjects.find((p) => p.data.shortId === shortIdOrUuid)?.id;
+    assertObjectFound(uuid, _Project, shortIdOrUuid);
+    return uuid;
+  }
+  async updateDescription(description) {
+    await config.behaviors.project.updateDescription(
+      await this.getUuid(),
+      description
+    );
+  }
+  async leave() {
+    await config.behaviors.project.leave(await this.getUuid());
+  }
+  async delete() {
+    await config.behaviors.project.delete(await this.getUuid());
+  }
+};
+__publicField(_Project, "find", withAsyncResourceVariant(
+  async (id) => {
+    const data = await config.behaviors.project.find(
+      await _Project.getUuid(id)
+    );
+    if (data !== void 0) {
+      return new ProjectDetailed(data);
+    }
+  }
+));
+__publicField(_Project, "get", withAsyncResourceVariant(
+  async (id) => {
+    const project = await _Project.find(id);
+    assertObjectFound(project, _Project, id);
+    return project;
+  }
+));
+__publicField(_Project, "list", withAsyncResourceVariant(
+  async (query = {}) => {
+    const data = await config.behaviors.project.list(query);
+    return Object.freeze(data.map((d) => new ProjectListItem(d)));
+  }
+));
+let Project = _Project;
+class ProjectCommon extends classes(
+  DataModel,
+  Project
+) {
+  constructor(data) {
+    super([data], [data.id]);
+    __publicField(this, "server");
+    __publicField(this, "customer");
+    this.server = data.serverId ? Server.ofId(data.serverId) : void 0;
+    this.customer = Customer.ofId(data.customerId);
+  }
+}
+class ProjectDetailed extends classes(
+  ProjectCommon,
+  DataModel
+) {
+  constructor(data) {
+    super([data], [data]);
+  }
+}
+class ProjectListItem extends classes(
+  ProjectCommon,
+  DataModel
+) {
+  constructor(data) {
+    super([data], [data]);
+  }
+}
+
+export { Customer, CustomerDetailed, CustomerListItem, Ingress, IngressCommon, IngressDetailed, IngressListItem, Project, ProjectDetailed, ProjectListItem, Server, ServerDetailed, ServerListItem, setupApiBehaviors };
+//# sourceMappingURL=index.mjs.map