pmcf 6.1.1 → 6.1.2

package/README.md

@@ -95,6 +95,7 @@ generates config packages for:
     *   [Parameters](#parameters-17)
 *   [cidrAddresses](#cidraddresses)
     *   [Parameters](#parameters-18)
+*   [families](#families)
 *   [secretName](#secretname)
 *   [directHosts](#directhosts)
 *   [subnetForAddress](#subnetforaddress)
@@ -357,6 +358,10 @@ Returns **Iterable<[string](https://developer.mozilla.org/docs/Web/JavaScript/Re
 
 Returns **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)<[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)>**&#x20;
 
+## families
+
+Returns **[Set](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Set)<[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)>**&#x20;
+
 ## secretName
 
 Returns **[string](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)**&#x20;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmcf",
-  "version": "6.1.1",
+  "version": "6.1.2",
   "publishConfig": {
     "access": "public"
   },

package/src/core-service.mjs

@@ -0,0 +1,381 @@
+import { FAMILY_IPV4, FAMILY_IPV6 } from "ip-utilties";
+import {
+  string_attribute_writable,
+  number_attribute_writable,
+  string_set_attribute,
+  default_collection_attribute_writable,
+  boolean_attribute_false,
+  port_attribute_writable,
+  type_attribute_writable,
+  priority_attribute
+} from "pacc";
+import {
+  Base,
+  Host,
+  Endpoint,
+  DomainNameEndpoint,
+  HTTPEndpoint,
+  UnixEndpoint,
+  addType
+} from "pmcf";
+import { asArray } from "./utils.mjs";
+import { networkAddressAttributes } from "./common-attributes.mjs";
+import {
+  serviceTypeEndpoints,
+  serviceTypes,
+  ServiceTypes
+} from "./service-types.mjs";
+import {
+  DNSRecord,
+  dnsFullName,
+  dnsFormatParameters,
+  dnsMergeParameters,
+  dnsPriority
+} from "./dns-utils.mjs";
+
+export const endpointAttributes = {
+  port: port_attribute_writable,
+  protocol: {
+    ...string_attribute_writable,
+    name: "protocol",
+    values: new Set(["tcp", "udp", "quic"])
+  },
+  type: type_attribute_writable,
+  types: { ...string_set_attribute, name: "types" },
+  tls: { ...boolean_attribute_false, name: "tls" }
+};
+
+export class CoreService extends Base {
+  static name = "core-service";
+  static priority = 1.1;
+  static owners = [Host, "cluster", "network_interface"];
+  static specializationOf = CoreService;
+  static specializations = {};
+  static factoryFor(owner, value) {
+    const type = value.type ?? value.name;
+    const st = this.specializations[type];
+
+    if (st) {
+      delete value.type;
+      return st;
+    }
+
+    return baseServiceClass;
+  }
+  static attributes = {
+    ...networkAddressAttributes,
+    ...endpointAttributes,
+    extends: {
+      ...default_collection_attribute_writable,
+      name: "extends",
+      type: CoreService
+    },
+    alias: { ...string_attribute_writable, name: "alias" },
+    priority: priority_attribute,
+    weight: { ...number_attribute_writable, name: "weight" /*default: 1*/ },
+    systemdService: { ...string_attribute_writable, name: "systemdService" }
+  };
+
+  static {
+    addType(this);
+  }
+
+  _alias;
+  _weight;
+  _port;
+  _systemdService;
+
+  toString() {
+    return `${this.fullName}(${this.type})`;
+  }
+
+  get network() {
+    return this.host.network;
+  }
+
+  get host() {
+    if (this.owner instanceof Host) {
+      return this.owner;
+    }
+  }
+
+  get hosts() {
+    return this.owner.hosts;
+  }
+
+  get domainName() {
+    return this.host?.domainName;
+  }
+
+  get networks() {
+    return this.host.networks;
+  }
+
+  get subnets() {
+    return this.host.subnets;
+  }
+
+  get url() {
+    return this.endpoint()?.url;
+  }
+
+  get serviceTypeEndpoints() {
+    return serviceTypeEndpoints(ServiceTypes[this.type]);
+  }
+
+  endpoints(filter) {
+    const data = serviceTypeEndpoints(ServiceTypes[this.type]);
+    if (!data) {
+      return [];
+    }
+
+    const result = [];
+
+    const domainNames = new Set([undefined]);
+
+    for (const e of data) {
+      switch (e.family) {
+        case "unix":
+          result.push(new UnixEndpoint(this, e.path, e));
+          break;
+
+        case undefined:
+        case "dns":
+        case FAMILY_IPV4:
+        case FAMILY_IPV6:
+          const options =
+            this._port === undefined ? { ...e } : { ...e, port: this._port };
+          delete options.kind;
+
+          for (const na of this.host.networkAddresses()) {
+            if (e.kind && e.kind !== na.networkInterface.kind) {
+              continue;
+            }
+
+            if (e.pathname) {
+              result.push(new HTTPEndpoint(this, na, options));
+            } else {
+              if (e.family === na.family) {
+                result.push(new Endpoint(this, na, options));
+              }
+            }
+          }
+
+          if (!domainNames.has(this.domainName)) {
+            domainNames.add(this.domainName);
+            result.push(new DomainNameEndpoint(this, this.domainName, options));
+          }
+
+          break;
+      }
+    }
+
+    switch (typeof filter) {
+      case "string":
+        return result.filter(endpoint => endpoint.type === filter);
+
+      case "undefined":
+        return result;
+
+      default:
+        return result.filter(filter);
+    }
+  }
+
+  endpoint(filter) {
+    return this.endpoints(filter)[0];
+  }
+
+  address(
+    options = {
+      endpoints: e =>
+        e.networkInterface && e.networkInterface.kind !== "loopbak",
+      select: e => e.domainName || e.address,
+      limit: 1,
+      join: ""
+    }
+  ) {
+    const all = this.endpoints(options.endpoints);
+    const res = [...new Set(options.select ? all.map(options.select) : all)];
+
+    if (options.limit < res.length) {
+      res.length = options.limit;
+    }
+
+    return options.join !== undefined ? res.join(options.join) : res;
+  }
+
+  set alias(value) {
+    this._alias = value;
+  }
+
+  get alias() {
+    return this.attribute("_alias");
+  }
+
+  set port(value) {
+    this._port = value;
+  }
+
+  get port() {
+    return (
+      this.attribute("_port") ??
+      serviceTypeEndpoints(ServiceTypes[this.type])[0]?.port
+    );
+  }
+
+  set priority(value) {
+    this._priority = value;
+  }
+
+  get priority() {
+    return this.attribute("_priority") ?? this.owner?.priority ?? 1;
+  }
+
+  set weight(value) {
+    this._weight = value;
+  }
+
+  get weight() {
+    return this.attribute("_weight") ?? this.owner.weight ?? 1;
+  }
+
+  get type() {
+    return this.constructor.name;
+  }
+
+  get types() {
+    return serviceTypes(ServiceTypes[this.type]);
+  }
+
+  get systemdService() {
+    return (
+      this.attribute("_systemdService") ??
+      ServiceTypes[this.type]?.systemdService
+    );
+  }
+
+  get packageData() {
+    const packageData = super.packageData;
+    const name = `${this.owner.name}-${this.host.name}`;
+    packageData.properties.name = `${this.type}-${name}`;
+    packageData.properties.description = `${this.type} service definitions for ${this.fullName}`;
+    packageData.properties.groups.push("service-config", name);
+    return packageData;
+  }
+
+  async *preparePackages(dir) {
+    const pd = this.packageData;
+    pd.sources = await Array.fromAsync(this.templateContent());
+    if (pd.sources.length) {
+      yield pd;
+    }
+  }
+
+  dnsRecordsForDomainName(domainName, hasSVRRecords) {
+    const records = [];
+    if (this.priority >= 390 && this.alias) {
+      records.push(DNSRecord(this.alias, "CNAME", dnsFullName(domainName)));
+    }
+
+    if (hasSVRRecords) {
+      for (const ep of this.endpoints(
+        e =>
+          e.protocol &&
+          e.networkInterface &&
+          e.networkInterface.kind !== "loopback"
+      )) {
+        records.push(
+          DNSRecord(
+            dnsFullName(`_${this.type}._${ep.protocol}.${domainName}`),
+            "SRV",
+            dnsPriority(this.priority),
+            this.weight,
+            ep.port,
+            dnsFullName(this.domainName)
+          )
+        );
+        break; // TODO only one ?
+      }
+    }
+
+    const dnsRecord = ServiceTypes[this.type]?.dnsRecord;
+    if (dnsRecord) {
+      let parameters = dnsRecord.parameters;
+
+      if (parameters) {
+        for (const service of this.services) {
+          if (service !== this) {
+            const serviceType = ServiceTypes[service.type];
+            /*if(!serviceType) {
+              throw new Error(`Unknown service '${service.type}'`);
+            }*/
+            const r = serviceType?.dnsRecord;
+
+            if (r?.type === dnsRecord.type) {
+              parameters = dnsMergeParameters(parameters, r.parameters);
+            }
+          }
+        }
+
+        records.push(
+          DNSRecord(
+            dnsFullName(domainName),
+            dnsRecord.type,
+            dnsPriority(this.priority),
+            ".",
+            dnsFormatParameters(parameters)
+          )
+        );
+      } else {
+        records.push(
+          DNSRecord(
+            "@",
+            dnsRecord.type,
+            dnsPriority(this.priority),
+            dnsFullName(domainName)
+          )
+        );
+      }
+    }
+
+    return records;
+  }
+}
+
+export let baseServiceClass = CoreService;
+
+export function setBaseService(value) {
+  baseServiceClass = value;
+}
+
+export const sortAscendingByPriority = (a, b) => a.priority - b.priority;
+export const sortDescendingByPriority = (a, b) => b.priority - a.priority;
+
+/**
+ *
+ * @param {*} sources
+ * @param {Object} [options]
+ * @param {Function} [options.services] filter for services
+ * @param {Function} [options.endpoints] filter for endpoints
+ * @param {Function} [options.select] mapper from Endpoint into result
+ * @param {number} [options.limit] upper limit of # result items
+ * @param {string} [options.join] join result(s) into a string
+ * @returns {string|any}
+ */
+export function serviceEndpoints(sources, options = {}) {
+  const all = asArray(sources)
+    .map(source => Array.from(source.expression(options.services)))
+    .flat()
+    .sort(sortDescendingByPriority)
+    .map(service => service.endpoints(options.endpoints))
+    .flat();
+
+  const res = [...new Set(options.select ? all.map(options.select) : all)];
+
+  if (options.limit < res.length) {
+    res.length = options.limit;
+  }
+
+  return options.join ? res.join(options.join) : res;
+}

package/src/endpoint.mjs

@@ -1,11 +1,11 @@
 import { FAMILY_IPV6 } from "ip-utilties";
 import { addType } from "pmcf";
-import { endpointAttributes, Service } from "./service.mjs";
+import { endpointAttributes, CoreService } from "./core-service.mjs";
 
 class BaseEndpoint {
   static name = "endpoint";
   static priority = 1.1;
-  static owners = [Service, "network_interface"];
+  static owners = [CoreService, "network_interface"];
   static key = "type";
   attributes = endpointAttributes;
 

package/src/extra-source-service.mjs

@@ -1,11 +1,10 @@
 import { AggregatedMap } from "aggregated-map";
 import { default_collection_attribute_writable, addType } from "pacc";
-import { Service } from "./service.mjs";
+import { CoreService } from "./core-service.mjs";
 import { networkAddressType } from "pmcf";
 
-export class ExtraSourceService extends Service {
+export class ExtraSourceService extends CoreService {
   static name = "extra-source-service";
-
   static attributes = {
     source: {
       ...default_collection_attribute_writable,
@@ -20,10 +19,6 @@ export class ExtraSourceService extends Service {
 
   source = [];
 
-  get type() {
-    return this.constructor.name;
-  }
-
   get services() {
     return new AggregatedMap([
       this.owner.owner.services,

package/src/host.mjs

@@ -8,7 +8,6 @@ import {
   string_attribute_writable,
   string_set_attribute_writable,
   number_attribute_writable,
-  boolean_attribute_false,
   priority_attribute
 } from "pacc";
 import { addresses, addType, assign } from "pmcf";

package/src/module.mjs

@@ -16,6 +16,7 @@ export * from "./network-interfaces/wlan.mjs";
 export * from "./network-interfaces/wireguard.mjs";
 export * from "./network-interfaces/tun.mjs";
 export * from "./service-types.mjs";
+export * from "./core-service.mjs";
 export * from "./service.mjs";
 export * from "./extra-source-service.mjs";
 export * from "./endpoint.mjs";

package/src/service.mjs

@@ -1,244 +1,21 @@
-import { FAMILY_IPV4, FAMILY_IPV6 } from "ip-utilties";
-import {
-  string_attribute_writable,
-  number_attribute_writable,
-  string_set_attribute,
-  default_collection_attribute_writable,
-  boolean_attribute_false,
-  port_attribute_writable,
-  type_attribute_writable,
-  priority_attribute
-} from "pacc";
-import {
-  Base,
-  Host,
-  Endpoint,
-  DomainNameEndpoint,
-  HTTPEndpoint,
-  UnixEndpoint,
-  addType
-} from "pmcf";
-import { asArray } from "./utils.mjs";
-import { networkAddressAttributes } from "./common-attributes.mjs";
-import {
-  serviceTypeEndpoints,
-  serviceTypes,
-  ServiceTypes
-} from "./service-types.mjs";
-import {
-  DNSRecord,
-  dnsFullName,
-  dnsFormatParameters,
-  dnsMergeParameters,
-  dnsPriority
-} from "./dns-utils.mjs";
+import { string_attribute_writable } from "pacc";
+import { setBaseService, CoreService, addType } from "pmcf";
 
-export const endpointAttributes = {
-  port: port_attribute_writable,
-  protocol: {
-    ...string_attribute_writable,
-    name: "protocol",
-    values: new Set(["tcp", "udp", "quic"])
-  },
-  type: type_attribute_writable,
-  types: { ...string_set_attribute, name: "types" },
-  tls: { ...boolean_attribute_false, name: "tls" }
-};
-
-export class Service extends Base {
+export class Service extends CoreService {
   static name = "service";
-  static priority = 1.1;
-  static owners = [Host, "cluster", "network_interface"];
-  static specializationOf = Service;
-  static specializations = {};
-  static factoryFor(owner, value) {
-    const type = value.type ?? value.name;
-    const st = this.specializations[type];
-
-    if (st) {
-      delete value.type;
-      return st;
-    }
-
-    return Service;
-  }
   static attributes = {
-    ...networkAddressAttributes,
-    ...endpointAttributes,
-    extends: {
-      ...default_collection_attribute_writable,
-      name: "extends",
-      type: Service
-    },
-    alias: { ...string_attribute_writable, name: "alias" },
-    priority: priority_attribute,
-    weight: { ...number_attribute_writable, name: "weight" /*default: 1*/ },
-    systemdService: { ...string_attribute_writable, name: "systemdService" }
+    type: { ...string_attribute_writable, name: "type" }
   };
-
   static {
     addType(this);
-  }
-
-  _alias;
-  _weight;
-  _type;
-  _port;
-  _systemdService;
-
-  toString() {
-    return `${this.fullName}(${this.type})`;
-  }
-
-  get network() {
-    return this.host.network;
-  }
-
-  get host() {
-    if (this.owner instanceof Host) {
-      return this.owner;
-    }
-  }
-
-  get hosts() {
-    return this.owner.hosts;
-  }
-
-  get domainName() {
-    return this.host?.domainName;
-  }
-
-  get networks() {
-    return this.host.networks;
-  }
-
-  get subnets() {
-    return this.host.subnets;
-  }
-
-  get url() {
-    return this.endpoint()?.url;
-  }
-
-  get serviceTypeEndpoints() {
-    return serviceTypeEndpoints(ServiceTypes[this.type]);
-  }
-
-  endpoints(filter) {
-    const data = serviceTypeEndpoints(ServiceTypes[this.type]);
-    if (!data) {
-      return [];
-    }
-
-    const result = [];
-
-    const domainNames = new Set([undefined]);
-
-    for (const e of data) {
-      switch (e.family) {
-        case "unix":
-          result.push(new UnixEndpoint(this, e.path, e));
-          break;
-
-        case undefined:
-        case "dns":
-        case FAMILY_IPV4:
-        case FAMILY_IPV6:
-          const options =
-            this._port === undefined ? { ...e } : { ...e, port: this._port };
-          delete options.kind;
-
-          for (const na of this.host.networkAddresses()) {
-            if (e.kind && e.kind !== na.networkInterface.kind) {
-              continue;
-            }
-
-            if (e.pathname) {
-              result.push(new HTTPEndpoint(this, na, options));
-            } else {
-              if (e.family === na.family) {
-                result.push(new Endpoint(this, na, options));
-              }
-            }
-          }
-
-          if (!domainNames.has(this.domainName)) {
-            domainNames.add(this.domainName);
-            result.push(new DomainNameEndpoint(this, this.domainName, options));
-          }
-
-          break;
-      }
-    }
-
-    switch (typeof filter) {
-      case "string":
-        return result.filter(endpoint => endpoint.type === filter);
-
-      case "undefined":
-        return result;
-
-      default:
-        return result.filter(filter);
-    }
-  }
-
-  endpoint(filter) {
-    return this.endpoints(filter)[0];
-  }
 
-  address(
-    options = {
-      endpoints: e =>
-        e.networkInterface && e.networkInterface.kind !== "loopbak",
-      select: e => e.domainName || e.address,
-      limit: 1,
-      join: ""
-    }
-  ) {
-    const all = this.endpoints(options.endpoints);
-    const res = [...new Set(options.select ? all.map(options.select) : all)];
-
-    if (options.limit < res.length) {
-      res.length = options.limit;
-    }
-
-    return options.join !== undefined ? res.join(options.join) : res;
-  }
-
-  set alias(value) {
-    this._alias = value;
-  }
-
-  get alias() {
-    return this.attribute("_alias");
+    setBaseService(this);
   }
 
-  set port(value) {
-    this._port = value;
-  }
-
-  get port() {
-    return (
-      this.attribute("_port") ??
-      serviceTypeEndpoints(ServiceTypes[this.type])[0]?.port
-    );
-  }
-
-  set priority(value) {
-    this._priority = value;
-  }
-
-  get priority() {
-    return this.attribute("_priority") ?? this.owner?.priority ?? 1;
-  }
-
-  set weight(value) {
-    this._weight = value;
-  }
+  _type;
 
-  get weight() {
-    return this.attribute("_weight") ?? this.owner.weight ?? 1;
+  set type(value) {
+    this._type = value;
   }
 
   set type(value) {
@@ -248,133 +25,4 @@ export class Service extends Base {
   get type() {
     return this.attribute("_type") ?? this.name;
   }
-
-  get types() {
-    return serviceTypes(ServiceTypes[this.type]);
-  }
-
-  get systemdService() {
-    return (
-      this.attribute("_systemdService") ??
-      ServiceTypes[this.type]?.systemdService
-    );
-  }
-
-  get packageData() {
-    const packageData = super.packageData;
-    const name = `${this.owner.name}-${this.host.name}`;
-    packageData.properties.name = `${this.type}-${name}`;
-    packageData.properties.description = `${this.type} service definitions for ${this.fullName}`;
-    packageData.properties.groups.push("service-config", name);
-    return packageData;
-  }
-
-  async *preparePackages(dir) {
-    const pd = this.packageData;
-    pd.sources = await Array.fromAsync(this.templateContent());
-    if (pd.sources.length) {
-      yield pd;
-    }
-  }
-
-  dnsRecordsForDomainName(domainName, hasSVRRecords) {
-    const records = [];
-    if (this.priority >= 390 && this.alias) {
-      records.push(DNSRecord(this.alias, "CNAME", dnsFullName(domainName)));
-    }
-
-    if (hasSVRRecords) {
-      for (const ep of this.endpoints(
-        e =>
-          e.protocol &&
-          e.networkInterface &&
-          e.networkInterface.kind !== "loopback"
-      )) {
-        records.push(
-          DNSRecord(
-            dnsFullName(`_${this.type}._${ep.protocol}.${domainName}`),
-            "SRV",
-            dnsPriority(this.priority),
-            this.weight,
-            ep.port,
-            dnsFullName(this.domainName)
-          )
-        );
-        break; // TODO only one ?
-      }
-    }
-
-    const dnsRecord = ServiceTypes[this.type]?.dnsRecord;
-    if (dnsRecord) {
-      let parameters = dnsRecord.parameters;
-
-      if (parameters) {
-        for (const service of this.services) {
-          if (service !== this) {
-            const serviceType = ServiceTypes[service.type];
-            /*if(!serviceType) {
-              throw new Error(`Unknown service '${service.type}'`);
-            }*/
-            const r = serviceType?.dnsRecord;
-
-            if (r?.type === dnsRecord.type) {
-              parameters = dnsMergeParameters(parameters, r.parameters);
-            }
-          }
-        }
-
-        records.push(
-          DNSRecord(
-            dnsFullName(domainName),
-            dnsRecord.type,
-            dnsPriority(this.priority),
-            ".",
-            dnsFormatParameters(parameters)
-          )
-        );
-      } else {
-        records.push(
-          DNSRecord(
-            "@",
-            dnsRecord.type,
-            dnsPriority(this.priority),
-            dnsFullName(domainName)
-          )
-        );
-      }
-    }
-
-    return records;
-  }
-}
-
-export const sortAscendingByPriority = (a, b) => a.priority - b.priority;
-export const sortDescendingByPriority = (a, b) => b.priority - a.priority;
-
-/**
- *
- * @param {*} sources
- * @param {Object} [options]
- * @param {Function} [options.services] filter for services
- * @param {Function} [options.endpoints] filter for endpoints
- * @param {Function} [options.select] mapper from Endpoint into result
- * @param {number} [options.limit] upper limit of # result items
- * @param {string} [options.join] join result(s) into a string
- * @returns {string|any}
- */
-export function serviceEndpoints(sources, options = {}) {
-  const all = asArray(sources)
-    .map(source => Array.from(source.expression(options.services)))
-    .flat()
-    .sort(sortDescendingByPriority)
-    .map(service => service.endpoints(options.endpoints))
-    .flat();
-
-  const res = [...new Set(options.select ? all.map(options.select) : all)];
-
-  if (options.limit < res.length) {
-    res.length = options.limit;
-  }
-
-  return options.join ? res.join(options.join) : res;
 }

package/src/services/alpm.mjs

@@ -4,7 +4,7 @@ import {
   string_attribute_writable,
   string_set_attribute_writable
 } from "pacc";
-import { addType, Service, Base } from "pmcf";
+import { addType, CoreService, Base } from "pmcf";
 import { owner_attribute } from "../common-attributes.mjs";
 
 class alpm_repository extends Base {
@@ -22,7 +22,7 @@ class alpm_repository extends Base {
   architectures = new Set();
 }
 
-export class alpm extends Service {
+export class alpm extends CoreService {
   static attributes = {
     repositories: {
       ...default_collection_attribute_writable,

package/src/services/headscale.mjs

@@ -1,7 +1,7 @@
 import { FAMILY_IPV4 } from "ip-utilties";
-import { Service, addType } from "pmcf";
+import { CoreService, addType } from "pmcf";
 
-export class headscale extends Service {
+export class headscale extends CoreService {
   static service = {
     endpoints: [
       {

package/src/services/influxdb.mjs

@@ -2,14 +2,14 @@ import { join } from "node:path";
 import { FAMILY_IPV4, FAMILY_IPV6 } from "ip-utilties";
 import { FileContentProvider } from "npm-pkgbuild";
 import { boolean_attribute_writable_true } from "pacc";
-import { Service, addType } from "pmcf";
+import { CoreService, addType } from "pmcf";
 import {
   writeLines,
   setionLinesFromPropertyIterator,
   filterConfigurable
 } from "../utils.mjs";
 
-export class influxdb extends Service {
+export class influxdb extends CoreService {
   static attributes = {
     metricsDisabled: {
       ...boolean_attribute_writable_true,

package/src/services/kea.mjs

@@ -13,7 +13,7 @@ import {
 } from "pacc";
 import {
   addType,
-  Service,
+  CoreService,
   sortDescendingByPriority,
   serviceEndpoints,
   SUBNET_LOCALHOST_IPV4,
@@ -23,7 +23,7 @@ import { writeLines } from "../utils.mjs";
 
 const keaVersion = "3.0.1";
 
-export class kea extends Service {
+export class kea extends CoreService {
   static attributes = {
     "ddns-send-updates": {
       ...boolean_attribute_writable_true,

package/src/services/mosquitto.mjs

@@ -1,7 +1,7 @@
 import { port_attribute, string_attribute_writable } from "pacc";
-import { Service, addType } from "pmcf";
+import { CoreService, addType } from "pmcf";
 
-export class mosquitto extends Service {
+export class mosquitto extends CoreService {
   static attributes = {
     listener: {
       ...port_attribute,

package/src/services/openldap.mjs

@@ -1,7 +1,7 @@
 import { string_attribute_writable } from "pacc";
-import { Service, addType } from "pmcf";
+import { CoreService, addType } from "pmcf";
 
-export class openldap extends Service {
+export class openldap extends CoreService {
   static attributes = {
     base: { ...string_attribute_writable, name: "base" },
     uri: { ...string_attribute_writable, name: "uri" }

package/src/services/postfix.mjs

@@ -1,6 +1,6 @@
-import { Service, addType } from "pmcf";
+import { CoreService, addType } from "pmcf";
 
-export class postfix extends Service {
+export class postfix extends CoreService {
   static service = {
     systemdService: "postfix.service",
     extends: ["smtp", "lmtp", "submission"],

package/src/services/systemd-journal-remote.mjs

@@ -5,16 +5,15 @@ import {
   boolean_attribute_writable,
   integer_attribute_writable
 } from "pacc";
-import { Service, addType } from "pmcf";
+import { CoreService, addType } from "pmcf";
 import { filterConfigurable, sectionLines } from "../utils.mjs";
 
 /**
  * @property {string} ServerCertificateFile
  * @property {string} ServerKeyFile
  */
-export class SystemdJournalRemoteService extends Service {
+export class SystemdJournalRemoteService extends CoreService {
   static name = "systemd-journal-remote";
-
   static attributes = {
     Seal: {
       ...boolean_attribute_writable,
@@ -96,10 +95,6 @@ export class SystemdJournalRemoteService extends Service {
     addType(this);
   }
 
-  get type() {
-    return this.constructor.name;
-  }
-
   /**
    *
    * @param {string} name

package/src/services/systemd-journal-upload.mjs

@@ -3,7 +3,7 @@ import {
   string_collection_attribute_writable,
   boolean_attribute_writable
 } from "pacc";
-import { Service, addType } from "pmcf";
+import { CoreService, addType } from "pmcf";
 import { filterConfigurable, sectionLines } from "../utils.mjs";
 
 /**
@@ -11,7 +11,7 @@ import { filterConfigurable, sectionLines } from "../utils.mjs";
  * @property {string} ServerCertificateFile
  * @property {string} ServerKeyFile
  */
-export class SystemdJournalUploadService extends Service {
+export class SystemdJournalUploadService extends CoreService {
   static name = "systemd-journal-upload";
   static attributes = {
     URL: { ...string_attribute_writable, name: "URL", configurable: true },
@@ -53,10 +53,6 @@ export class SystemdJournalUploadService extends Service {
     addType(this);
   }
 
-  get type() {
-    return this.constructor.name;
-  }
-
   /**
    *
    * @param {string} name

package/src/services/systemd-journald.mjs

@@ -1,8 +1,8 @@
 import { string_attribute_writable, duration_attribute_writable } from "pacc";
-import { Service, addType } from "pmcf";
+import { CoreService, addType } from "pmcf";
 import { filterConfigurable, sectionLines } from "../utils.mjs";
 
-export class SystemdJournaldService extends Service {
+export class SystemdJournaldService extends CoreService {
   static name = "systemd-journald";
   static attributes = {
     Storage: {
@@ -128,10 +128,6 @@ export class SystemdJournaldService extends Service {
     addType(this);
   }
 
-  get type() {
-    return this.constructor.name;
-  }
-
   systemdConfigs(name) {
     return {
       serviceName: this.systemdService,

package/src/services/tailscale.mjs

@@ -1,7 +1,7 @@
 import { FAMILY_IPV4 } from "ip-utilties";
-import { Service, addType } from "pmcf";
+import { CoreService, addType } from "pmcf";
 
-export class tailscale extends Service {
+export class tailscale extends CoreService {
   static service = {
     endpoints: [
       {