pmcf 1.41.0 → 1.42.0

package/package.json

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

package/src/base.mjs

@@ -1,5 +1,6 @@
 import { join } from "node:path";
 import { getAttribute } from "pacc";
+import { typesByName } from "./types.mjs";
 
 export class Base {
   owner;
@@ -10,6 +11,12 @@ export class Base {
     return "base";
   }
 
+  static get typeDefinition() {
+    return {
+      //      name: { type: "string", collection: false }
+    };
+  }
+
   static get pluralTypeName() {
     return this.typeName + "s";
   }
@@ -47,6 +54,25 @@ export class Base {
     }
   }
 
+  read(data) {
+    for (const [slotName, typeDef] of Object.entries(
+      this.constructor.typeDefinition
+    )) {
+      const slot = data[slotName];
+      if (slot) {
+        delete data[slotName];
+        if (typeDef.collection) {
+          for (const [objectName, objectData] of Object.entries(slot)) {
+            objectData.name = objectName;
+            new typesByName[typeDef.type](this, objectData);
+          }
+        } else {
+          this[typeDef.type] = new typesByName[typeDef.type](this, slot);
+        }
+      }
+    }
+  }
+
   forOwner(owner) {
     if (this.owner !== owner) {
       // @ts-ignore

package/src/host.mjs

@@ -1,6 +1,5 @@
 import { Base } from "./base.mjs";
 import { Network } from "./network.mjs";
-import { Service } from "./service.mjs";
 import {
   asArray,
   isIPv4Address,
@@ -32,6 +31,13 @@ export class Host extends Base {
     return "host";
   }
 
+  static get typeDefinition() {
+    return {
+      networkInterfaces: { type: "network_interface", collection: true },
+      services: { type: "service", collection: true }
+    };
+  }
+
   static async prepareData(root, data) {
     if (data.extends) {
       data.extends = await Promise.all(
@@ -86,32 +92,14 @@ export class Host extends Base {
       delete data.provides;
     }
 
-    if (data.services) {
-      for (const [name, sd] of Object.entries(data.services)) {
-        sd.name = name;
-        new Service(this, sd);
-      }
-      delete data.services;
-    }
-
-    if (data.networkInterfaces) {
-      for (const [name, iface] of Object.entries(data.networkInterfaces)) {
-        iface.name = name;
-        new NetworkInterface(this, iface);
-      }
-      delete data.networkInterfaces;
-    }
-
     for (const host of this.extends) {
       for (const service of host.services()) {
         service.forOwner(this);
       }
-
-      /*for (const ni of host.networkInterfaces.values()) {
-        ni.forOwner(this);
-      }*/
     }
 
+    this.read(data);
+
     Object.assign(this, data);
 
     owner.addObject(this);

package/src/owner.mjs

@@ -1,13 +1,11 @@
 import { asArray, normalizeCIDR } from "./utils.mjs";
 import { Base } from "./base.mjs";
 import { Subnet } from "./subnet.mjs";
-import { DNSService } from "./dns.mjs";
-import { addType, typesByName } from "./types.mjs";
+import { addType } from "./types.mjs";
 
 export class Owner extends Base {
   #membersByType = new Map();
   #bridges = new Set();
-  #dns;
   #administratorEmail;
   domain;
   ntp = { servers: [] };
@@ -20,17 +18,19 @@ export class Owner extends Base {
     return "owner";
   }
 
+  static get typeDefinition() {
+    return {
+      networks: { type: "network", collection: true },
+      hosts: { type: "host", collection: true },
+      clusters: { type: "cluster", collection: true },
+      /*  subnets: { type: "subnet", collection: true },*/
+      dns: { type: "dns", collection: false }
+    };
+  }
+
   constructor(owner, data = {}) {
     super(owner, data);
 
-    let dns;
-    if (data.dns) {
-      dns = data.dns;
-      delete data.dns;
-    }
-
-    this.#dns = new DNSService(this, dns);
-
     if (data.administratorEmail) {
       this.#administratorEmail = data.administratorEmail;
       delete data.administratorEmail;
@@ -46,15 +46,7 @@ export class Owner extends Base {
       delete data.ntp;
     }
 
-    if (data.networks) {
-      const networks = data.networks;
-      delete data.networks;
-
-      for (const [name, data] of Object.entries(networks)) {
-        data.name = name;
-        new typesByName.network(this, data);
-      }
-    }
+    this.read(data);
 
     owner?.addObject(this);
   }
@@ -73,10 +65,6 @@ export class Owner extends Base {
     return false;
   }
 
-  get dns() {
-    return this.#dns;
-  }
-
   named(name) {
     //console.log("NAMED", this.#membersByType.keys());
     for (const slot of this.#membersByType.values()) {
@@ -92,6 +80,10 @@ export class Owner extends Base {
     return typeSlot?.get(name) || this.owner?.typeNamed(typeName, name);
   }
 
+  typeObject(typeName) {
+    return this.#membersByType.get(typeName);
+  }
+
   typeList(typeName) {
     const typeSlot = this.#membersByType.get(typeName);
     if (typeSlot) {

package/types/base.d.mts

@@ -1,6 +1,7 @@
 export function extractFrom(object: any): {};
 export class Base {
     static get typeName(): string;
+    static get typeDefinition(): {};
     static get pluralTypeName(): string;
     static get nameLookupName(): string;
     static get typeFileName(): string;
@@ -11,6 +12,7 @@ export class Base {
     owner: any;
     name: any;
     description: any;
+    read(data: any): void;
     forOwner(owner: any): any;
     get typeName(): any;
     get root(): any;

package/types/host.d.mts

@@ -1,4 +1,14 @@
 export class Host extends Base {
+    static get typeDefinition(): {
+        networkInterfaces: {
+            type: string;
+            collection: boolean;
+        };
+        services: {
+            type: string;
+            collection: boolean;
+        };
+    };
     static prepareData(root: any, data: any): Promise<typeof Host>;
     postinstall: any[];
     _traverse(...args: any[]): boolean;

package/types/owner.d.mts

@@ -1,13 +1,31 @@
 export class Owner extends Base {
+    static get typeDefinition(): {
+        networks: {
+            type: string;
+            collection: boolean;
+        };
+        hosts: {
+            type: string;
+            collection: boolean;
+        };
+        clusters: {
+            type: string;
+            collection: boolean;
+        };
+        dns: {
+            type: string;
+            collection: boolean;
+        };
+    };
     constructor(owner: any, data?: {});
     domain: any;
     ntp: {
         servers: any[];
     };
     _traverse(...args: any[]): boolean;
-    get dns(): DNSService;
     named(name: any): any;
     typeNamed(typeName: any, name: any): any;
+    typeObject(typeName: any): any;
     typeList(typeName: any): any;
     _addObject(typeName: any, fullName: any, object: any): void;
     addObject(object: any): void;
@@ -32,4 +50,3 @@ export class Owner extends Base {
     #private;
 }
 import { Base } from "./base.mjs";
-import { DNSService } from "./dns.mjs";