pmcf 1.43.2 → 1.44.1

package/package.json

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

package/src/base.mjs

@@ -16,10 +16,11 @@ export class Base {
     return {
       name: "base",
       properties: {
-        /*   name: { type: "string" },
+        type: { type: "string", writeable: false },
+        name: { type: "string" },
         description: { type: "string" },
-        directory: { type: "string" },
-        owner: {}*/
+        directory: { type: "string", writeable: false },
+        owner: {}
       }
     };
   }
@@ -81,9 +82,18 @@ export class Base {
             }
           }
         } else {
-         // if (typeDef.type) {
-            this[typeDef.type] = new typesByName[typeDef.type](this, slot);
-         // }
+          switch (typeDef.type) {
+            case "undefined":
+              break;
+            case "boolean":
+            case "string":
+            case "number":
+              this[slotName] = slot;
+              break;
+
+            default:
+              this[slotName] = new typesByName[typeDef.type](this, slot);
+          }
         }
       }
     }
@@ -100,7 +110,7 @@ export class Base {
 
   get typeName() {
     // @ts-ignore
-    return this.constructor.typeName;
+    return this.constructor.typeDefinition.name;
   }
 
   get root() {
@@ -220,43 +230,71 @@ export class Base {
     return `${this.fullName}(${this.typeName})`;
   }
 
-  get propertyNames() {
-    return ["name", "description", "directory", "owner"];
-  }
-
   toJSON() {
-    return extractFrom(this);
+    return extractFrom(this, this.constructor.typeDefinition);
   }
 }
 
-export function extractFrom(object) {
-  const json = {};
+export function extractFrom(object, typeDefinition) {
+  if (!typeDefinition || object === undefined) {
+    return object;
+  }
 
-  for (const p of object?.propertyNames || Object.keys(object)) {
-    const value = object[p];
+  const json = {};
 
-    switch (typeof value) {
-      case "undefined":
-        break;
-      case "object":
-        if (value instanceof Base) {
-          json[p] = { type: value.typeName };
-          if (value.name) {
-            json[p].name = value.name;
+  do {
+    for (const [name, def] of Object.entries(typeDefinition.properties)) {
+      let value = object[name];
+
+      switch (typeof value) {
+        case "function":
+          {
+            value = object[name]();
+
+            if (Array.isArray(value)) {
+              if (value.length > 0) {
+                json[name] = value;
+              }
+            } else {
+              if (typeof value?.next === "function") {
+                value = [...value];
+                if (value.length > 0) {
+                  json[name] = value;
+                }
+              } else {
+                json[name] = value;
+              }
+            }
           }
-        } else {
-          if (Array.isArray(value)) {
-            json[p] = value;
+          break;
+        case "object":
+          if (value instanceof Base) {
+            json[name] = { type: value.typeName };
+            if (value.name) {
+              json[name].name = value.name;
+            }
           } else {
-            json[p] = Object.fromEntries(
-              Object.entries(value).map(([k, v]) => [k, extractFrom(v)])
-            );
+            if (Array.isArray(value)) {
+              json[name] = value;
+            } else {
+              json[name] = Object.fromEntries(
+                Object.entries(value).map(([k, v]) => [
+                  k,
+                  extractFrom(v, typesByName[def.type])
+                ])
+              );
+            }
           }
-        }
-        break;
-      default:
-        json[p] = value;
+          break;
+        case "undefined":
+          break;
+
+        default:
+          json[name] = value;
+      }
     }
-  }
+    typeDefinition = typeDefinition?.extends?.typeDefinition;
+  } while (typeDefinition);
+
   return json;
 }

package/src/cluster.mjs

@@ -9,7 +9,7 @@ export class Cluster extends Owner {
   static get typeDefinition() {
     return {
       name: "cluster",
-      extends: "owner",
+      extends: Owner,
       properties: {}
     };
   }

package/src/dns.mjs

@@ -8,23 +8,22 @@ export class DNSService extends Base {
   soaUpdates = [36000, 72000, 600000, 60000];
   hasSVRRecords = true;
   hasCatalog = true;
-
   forwardsTo = [];
 
   static {
     addType(this);
   }
-  
+
   static get typeDefinition() {
     return {
       name: "dns",
       properties: {
-        /*recordTTL: {},
-        soaUpdates: {},
-        hasSVRRecords: {},
-        hasCatalog: {},
-        forwardsTo: {},
-        allowedUpdates: {}*/
+        hasSVRRecords: { type: "boolean" },
+        hasCatalog: { type: "boolean" },
+        recordTTL: { type: "string" },
+        soaUpdates: { type: "number", collection: true },
+        forwardsTo: { type: "host", collection: true },
+        allowedUpdates: { type: "string", collection: true }
       }
     };
   }
@@ -50,17 +49,6 @@ export class DNSService extends Base {
     return [this.owner.domain];
   }
 
-  get propertyNames() {
-    return [
-      "recordTTL",
-      "soaUpdates",
-      "hasSVRRecords",
-      "hasCatalog",
-      "forwardsTo",
-      "allowedUpdates"
-    ];
-  }
-
   async resolvedConfig() {
     const dnsServices = (await Array.fromAsync(this.services())).sort(
       (a, b) => a.priority - b.priority

package/src/host.mjs

@@ -30,17 +30,17 @@ export class Host extends Base {
   static get typeDefinition() {
     return {
       name: "host",
-      extends: "base",
+      extends: Base,
       properties: {
         networkInterfaces: { type: "network_interface", collection: true },
-        services: { type: "service", collection: true }
-        /*os: {},
-        distribution: {},
-        deployment: {},
-        master: { },
-        model: {},
-        replaces: { },
-        depends: {  }*/
+        services: { type: "service", collection: true },
+        os: { type: "string" },
+        distribution: { type: "string" },
+        deployment: { type: "string" },
+        master: { type: "boolean" },
+        model: { type: "string" },
+        replaces: { type: "string" },
+        depends: { type: "string" }
       }
     };
   }
@@ -273,20 +273,6 @@ export class Host extends Base {
     return readFile(join(this.directory, `ssh_host_${type}_key.pub`), "utf8");
   }
 
-  get propertyNames() {
-    return [
-      ...super.propertyNames,
-      "os",
-      "distribution",
-      "deployment",
-      "master",
-      "model",
-      "replaces",
-      "depends",
-      "networkInterfaces"
-    ];
-  }
-
   toJSON() {
     return {
       ...super.toJSON(),
@@ -309,19 +295,18 @@ export class NetworkInterface extends Base {
   static get typeDefinition() {
     return {
       name: "network_interface",
-      extends: "base",
+      extends: Base,
       properties: {
-        /*
-        arpbridge: {},
-        hwaddr: {},
+        hwaddr: { type: "string" },
+        scope: { type: "string" },
+        kind: { type: "string" },
+        ssid: { type: "string" },
+        psk: { type: "string" },
+        metric: { type: "number" },
+        ipAddresses: { type: "string", collection: true },
         network: {},
         gateway: {},
-        ssid: {},
-        psk: {},
-        scope: {},
-        metric: {},
-        kind: {},
-        ipAddresses: {}*/
+        arpbridge: {}
       }
     };
   }
@@ -482,20 +467,4 @@ export class NetworkInterface extends Base {
   get kind() {
     return this.#kind || this.network?.kind;
   }
-
-  get propertyNames() {
-    return [
-      ...super.propertyNames,
-      "arpbridge",
-      "hwaddr",
-      "network",
-      "gateway",
-      "ssid",
-      "psk",
-      "scope",
-      "metric",
-      "kind",
-      "ipAddresses"
-    ];
-  }
 }

package/src/location.mjs

@@ -9,7 +9,7 @@ export class Location extends Owner {
   static get typeDefinition() {
     return {
       name: "location",
-      extends: "owner",
+      extends: Owner,
       properties: {
         networks: { type: "network", collection: true },
         hosts: { type: "host", collection: true },
@@ -35,15 +35,4 @@ export class Location extends Owner {
   get network() {
     return [...this.typeList("network")][0] || super.network;
   }
-
-  /*
-  *subnets() {
-   // yield* super.subnets();
-    
-    for(const network of this.networks()) {
-     // console.log(network.toString());
-      yield* network.typeList("subnet");
-    }
-  }
-  */
 }

package/src/network.mjs

@@ -16,18 +16,18 @@ export class Network extends Owner {
   static get typeDefinition() {
     return {
       name: "network",
-      extends: "owner",
+      extends: Owner,
       properties: {
         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 }
+        dns: { type: "dns", collection: false },
+        //metric: { type: "number" }
 
-        /* kind: {},
-        scope: {},
-        metric: {},
-        bridge: {},
+        /*kind: { type: "string" },
+        scope: { type: "string" },
+        /*bridge: {},
         gateway: {}*/
       }
     };
@@ -41,6 +41,8 @@ export class Network extends Owner {
       delete data.bridge;
     }
 
+    //this.read(data);
+
     Object.assign(this, data);
 
     if (typeof this.gateway === "string") {
@@ -73,15 +75,4 @@ export class Network extends Owner {
   set bridge(bridge) {
     this.#bridge = bridge;
   }
-
-  get propertyNames() {
-    return [
-      ...super.propertyNames,
-      "kind",
-      "scope",
-      "metric",
-      "bridge",
-      "gateway"
-    ];
-  }
 }

package/src/owner.mjs

@@ -17,13 +17,15 @@ export class Owner extends Base {
   static get typeDefinition() {
     return {
       name: "owner",
-      extends: "base",
+      extends: Base,
       properties: {
         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 }
+        dns: { type: "dns", collection: false },
+        domain: { type: "string" },
+        administratorEmail: { type: "string" }
       }
     };
   }
@@ -284,10 +286,6 @@ export class Owner extends Base {
     }
   }
 
-  get propertyNames() {
-    return [...super.propertyNames, "domain", "administratorEmail", "dns"];
-  }
-
   toJSON() {
     const json = super.toJSON();
 

package/src/root.mjs

@@ -5,7 +5,6 @@ import { Location } from "./location.mjs";
 import { addType, types } from "./types.mjs";
 
 export class Root extends Location {
-
   static {
     addType(this);
   }
@@ -13,9 +12,8 @@ export class Root extends Location {
   static get typeDefinition() {
     return {
       name: "root",
-      extends: "location",
-      properties: {
-      }
+      extends: Location,
+      properties: {}
     };
   }
 

package/src/service.mjs

@@ -29,17 +29,17 @@ export class Service extends Base {
   static get typeDefinition() {
     return {
       name: "service",
-      extends: "base",
+      extends: Base,
       properties: {
-        /*ipAddresses: {},
+        ipAddresses: {},
         addresses: {},
-        port: {},
-        protocol: {},
-        alias: {},
-        type: {},
-        master: {},
-        priority: {},
-        weight: {}*/
+        port: { type: "number" },
+        protocol: { type: "string" },
+        alias: { type: "string" },
+        type: { type: "string" },
+        master: { type: "boolean" },
+        priority: { type: "number" },
+        weight: { type: "number" }
       }
     };
   }
@@ -135,19 +135,4 @@ export class Service extends Base {
   get type() {
     return this.#type || this.name;
   }
-
-  get propertyNames() {
-    return [
-      ...super.propertyNames,
-      "ipAddresses",
-      "addresses",
-      "port",
-      "protocol",
-      "alias",
-      "type",
-      "master",
-      "priority",
-      "weight"
-    ];
-  }
 }

package/src/subnet.mjs

@@ -12,13 +12,10 @@ export class Subnet extends Base {
   static get typeDefinition() {
     return {
       name: "subnet",
-      extends: "base",
       properties: {
-        /*
-        address: {},
-        networks: { type: "network", collection true },
+        address: { type: "string" },
+        networks: { type: "network", collection: true },
         prefixLength: { type: "number", writeable: false }
-        */
       }
     };
   }
@@ -65,10 +62,6 @@ export class Subnet extends Base {
     return this.name;
   }
 
-  get propertyNames() {
-    return [...super.propertyNames, "networks", "prefixLength"];
-  }
-
   _traverse(...args) {
     if (super._traverse(...args)) {
       for (const network of this.networks) {

package/types/base.d.mts

@@ -1,9 +1,25 @@
-export function extractFrom(object: any): {};
+export function extractFrom(object: any, typeDefinition: any): any;
 export class Base {
     static get typeName(): string;
     static get typeDefinition(): {
         name: string;
-        properties: {};
+        properties: {
+            type: {
+                type: string;
+                writeable: boolean;
+            };
+            name: {
+                type: string;
+            };
+            description: {
+                type: string;
+            };
+            directory: {
+                type: string;
+                writeable: boolean;
+            };
+            owner: {};
+        };
     };
     static get nameLookupName(): string;
     static get typeFileName(): string;
@@ -34,7 +50,6 @@ export class Base {
     error(...args: any[]): void;
     info(...args: any[]): void;
     toString(): string;
-    get propertyNames(): string[];
-    toJSON(): {};
+    toJSON(): any;
     #private;
 }

package/types/cluster.d.mts

@@ -1,7 +1,7 @@
 export class Cluster extends Owner {
     static get typeDefinition(): {
         name: string;
-        extends: string;
+        extends: typeof Owner;
         properties: {};
     };
     constructor(owner: any, data: any);

package/types/dns.d.mts

@@ -1,4 +1,30 @@
 export class DNSService extends Base {
+    static get typeDefinition(): {
+        name: string;
+        properties: {
+            hasSVRRecords: {
+                type: string;
+            };
+            hasCatalog: {
+                type: string;
+            };
+            recordTTL: {
+                type: string;
+            };
+            soaUpdates: {
+                type: string;
+                collection: boolean;
+            };
+            forwardsTo: {
+                type: string;
+                collection: boolean;
+            };
+            allowedUpdates: {
+                type: string;
+                collection: boolean;
+            };
+        };
+    };
     allowedUpdates: any[];
     recordTTL: string;
     soaUpdates: number[];

package/types/host.d.mts

@@ -1,7 +1,7 @@
 export class Host extends Base {
     static get typeDefinition(): {
         name: string;
-        extends: string;
+        extends: typeof Base;
         properties: {
             networkInterfaces: {
                 type: string;
@@ -11,6 +11,27 @@ export class Host extends Base {
                 type: string;
                 collection: boolean;
             };
+            os: {
+                type: string;
+            };
+            distribution: {
+                type: string;
+            };
+            deployment: {
+                type: string;
+            };
+            master: {
+                type: string;
+            };
+            model: {
+                type: string;
+            };
+            replaces: {
+                type: string;
+            };
+            depends: {
+                type: string;
+            };
         };
     };
     static prepareData(root: any, data: any): Promise<typeof Host>;
@@ -48,18 +69,39 @@ export class Host extends Base {
     get ipAddressesWithPrefixLength(): any[];
     get ipAddress(): any;
     publicKey(type?: string): Promise<any>;
-    toJSON(): {
-        extends: any[];
-        networkInterfaces: any;
-        services: any;
-    };
     #private;
 }
 export class NetworkInterface extends Base {
     static get typeDefinition(): {
         name: string;
-        extends: string;
-        properties: {};
+        extends: typeof Base;
+        properties: {
+            hwaddr: {
+                type: string;
+            };
+            scope: {
+                type: string;
+            };
+            kind: {
+                type: string;
+            };
+            ssid: {
+                type: string;
+            };
+            psk: {
+                type: string;
+            };
+            metric: {
+                type: string;
+            };
+            ipAddresses: {
+                type: string;
+                collection: boolean;
+            };
+            network: {};
+            gateway: {};
+            arpbridge: {};
+        };
     };
     arpbridge: any;
     hwaddr: any;

package/types/location.d.mts

@@ -1,4 +1,30 @@
 export class Location extends Owner {
+    static get typeDefinition(): {
+        name: string;
+        extends: typeof Owner;
+        properties: {
+            networks: {
+                type: string;
+                collection: boolean;
+            };
+            hosts: {
+                type: string;
+                collection: boolean;
+            };
+            clusters: {
+                type: string;
+                collection: boolean;
+            };
+            subnets: {
+                type: string;
+                collection: boolean;
+            };
+            dns: {
+                type: string;
+                collection: boolean;
+            };
+        };
+    };
     get location(): this;
 }
 import { Owner } from "./owner.mjs";

package/types/network.d.mts

@@ -1,4 +1,30 @@
 export class Network extends Owner {
+    static get typeDefinition(): {
+        name: string;
+        extends: typeof Owner;
+        properties: {
+            networks: {
+                type: string;
+                collection: boolean;
+            };
+            hosts: {
+                type: string;
+                collection: boolean;
+            };
+            clusters: {
+                type: string;
+                collection: boolean;
+            };
+            subnets: {
+                type: string;
+                collection: boolean;
+            };
+            dns: {
+                type: string;
+                collection: boolean;
+            };
+        };
+    };
     constructor(owner: any, data: any);
     kind: any;
     scope: any;

package/types/owner.d.mts

@@ -1,7 +1,7 @@
 export class Owner extends Base {
     static get typeDefinition(): {
         name: string;
-        extends: string;
+        extends: typeof Base;
         properties: {
             networks: {
                 type: string;
@@ -23,6 +23,12 @@ export class Owner extends Base {
                 type: string;
                 collection: boolean;
             };
+            domain: {
+                type: string;
+            };
+            administratorEmail: {
+                type: string;
+            };
         };
     };
     constructor(owner: any, data?: {});

package/types/root.d.mts

@@ -1,7 +1,7 @@
 export class Root extends Location {
     static get typeDefinition(): {
         name: string;
-        extends: string;
+        extends: typeof Location;
         properties: {};
     };
     constructor(directory: any);

package/types/service.d.mts

@@ -1,8 +1,32 @@
 export class Service extends Base {
     static get typeDefinition(): {
         name: string;
-        extends: string;
-        properties: {};
+        extends: typeof Base;
+        properties: {
+            ipAddresses: {};
+            addresses: {};
+            port: {
+                type: string;
+            };
+            protocol: {
+                type: string;
+            };
+            alias: {
+                type: string;
+            };
+            type: {
+                type: string;
+            };
+            master: {
+                type: string;
+            };
+            priority: {
+                type: string;
+            };
+            weight: {
+                type: string;
+            };
+        };
     };
     alias: any;
     get protocol(): any;

package/types/subnet.d.mts

@@ -1,8 +1,19 @@
 export class Subnet extends Base {
     static get typeDefinition(): {
         name: string;
-        extends: string;
-        properties: {};
+        properties: {
+            address: {
+                type: string;
+            };
+            networks: {
+                type: string;
+                collection: boolean;
+            };
+            prefixLength: {
+                type: string;
+                writeable: boolean;
+            };
+        };
     };
     networks: Set<any>;
     matchesAddress(address: any): any;