pmcf 1.46.3 → 1.47.0

package/bin/pmcf-host-defs

@@ -2,7 +2,7 @@
 
 import { writeFile, mkdir, copyFile, glob, chmod } from "node:fs/promises";
 import { join } from "node:path";
-import { Host } from "pmcf";
+import { types } from "pmcf";
 import { writeLines, sectionLines } from "../src/utils.mjs";
 import { prepare } from "../src/cmd.mjs";
 
@@ -10,7 +10,7 @@ const { root, args, options } = await prepare();
 
 const hostName = args[0];
 
-const host = await root.load(hostName, { type: Host });
+const host = await root.load(hostName, { type: types.host });
 
 await generateNetworkDefs(host, options.output);
 await generateMachineInfo(host, options.output);
@@ -105,7 +105,7 @@ async function generateNetworkDefs(host, dir) {
           })
         );
 
-        if (ni.arpbridge) {
+        if (ni.arpbridge.length) {
           networkSections.push(
             "",
             sectionLines("Link", { Promiscuous: "yes" })

package/bin/pmcf-location-defs

@@ -2,13 +2,13 @@
 
 import { mkdir, copyFile } from "node:fs/promises";
 import { join } from "node:path";
-import { Location } from "pmcf";
+import { types } from "pmcf";
 import { writeLines, sectionLines } from "../src/utils.mjs";
 import { prepare } from "../src/cmd.mjs";
 
 const { root, args, options } = await prepare();
 
-const location = await root.load(args[0], { type: Location });
+const location = await root.load(args[0], { type: types.location });
 
 await generateLocationDefs(location, options.output);
 

package/bin/pmcf-named-defs

@@ -52,7 +52,7 @@ async function generateNamedDefs(owner, targetDir) {
       };
     };
 
-    for await (const mail of owner.services({ type: "smtp" })) {
+    for await (const mail of owner.findServices({ type: "smtp" })) {
       records.add(
         createRecord("@", "MX", mail.priority, fullName(mail.owner.domainName))
       );
@@ -112,7 +112,7 @@ async function generateNamedDefs(owner, targetDir) {
 
       if (!hosts.has(host)) {
         hosts.add(host);
-        for (const service of host.services()) {
+        for (const service of host.findServices()) {
           if (service.master && service.alias) {
             zone.records.add(
               createRecord(service.alias, "CNAME", fullName(host.domainName))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmcf",
-  "version": "1.46.3",
+  "version": "1.47.0",
   "publishConfig": {
     "access": "public"
   },
@@ -43,11 +43,11 @@
     "pacc": "^3.3.0"
   },
   "devDependencies": {
-    "@types/node": "^22.13.4",
+    "@types/node": "^22.13.5",
     "ava": "^6.2.0",
     "c8": "^10.1.3",
     "documentation": "^14.0.3",
-    "semantic-release": "^24.2.2",
+    "semantic-release": "^24.2.3",
     "typescript": "^5.7.3"
   },
   "engines": {

package/src/base.mjs

@@ -1,32 +1,39 @@
 import { join } from "node:path";
 import { getAttribute } from "pacc";
-import { typesByName } from "./types.mjs";
-import { asArray } from "./utils.mjs";
+import { addType, primitives } from "./types.mjs";
+
+const BaseTypeDefinition = {
+  name: "base",
+  owners: [],
+  properties: {
+    owner: { type: "base", collection: false, writeable: false },
+    type: { type: "string", collection: false, writeable: false },
+    name: {
+      type: "string",
+      collection: false,
+      identifier: true,
+      writeable: true
+    },
+    description: { type: "string", collection: false, writeable: true },
+    directory: { type: "string", collection: false, writeable: false }
+  }
+};
 
 export class Base {
   owner;
-  name;
   description;
+  name;
+
+  static {
+    addType(this);
+  }
 
   static get typeName() {
     return this.typeDefinition.name;
   }
 
   static get typeDefinition() {
-    return {
-      name: "base",
-      properties: {
-        type: { type: "string", writeable: false },
-        name: { type: "string" },
-        description: { type: "string" },
-        directory: { type: "string", writeable: false },
-        owner: {}
-      }
-    };
-  }
-
-  static get nameLookupName() {
-    return this.typeName + "Named";
+    return BaseTypeDefinition;
   }
 
   static get typeFileName() {
@@ -37,16 +44,6 @@ export class Base {
     return "**/" + this.typeFileName;
   }
 
-  static async prepareData(root, data) {
-    return this;
-  }
-
-  static normalizeName(name) {
-    if (name !== undefined) {
-      return name.replace(/\/\w+\.json$/, "");
-    }
-  }
-
   constructor(owner, data) {
     this.owner = owner;
 
@@ -54,62 +51,151 @@ export class Base {
       case "string":
         this.name = data;
         break;
-      case "object": {
-        this.name = data.name;
-        if (data.description) {
-          this.description = data.description;
-        }
+      case "object":
+        this.read(data, BaseTypeDefinition);
+    }
+
+    if (this.name === undefined) {
+      this.error("Missing name", this.owner?.toString(), data);
+    }
+  }
+
+  ownerFor(property, data) {
+    for (const type of property.type.owners) {
+      if (this.typeName === type?.name) {
+        return this;
+      }
+    }
+    for (const type of property.type.owners) {
+      const owner = this[type?.name];
+      if (owner) {
+        return owner;
       }
     }
+
+    return this;
   }
 
-  read(data) {
-    for (const [slotName, typeDef] of Object.entries(
-      this.constructor.typeDefinition.properties
-    )) {
-      let slot = data[slotName];
-      if (slot) {
-        delete data[slotName];
-
-        const type =
-          typeof typeDef.type === "string"
-            ? typesByName[typeDef.type]
-            : typeDef.type;
-
-        if (typeDef.collection) {
-          if (Array.isArray(slot) || typeof slot === "string") {
-            slot = asArray(slot);
-            if (type) {
-              for (const item of slot) {
-                new type(this, item);
+  read(data, type) {
+    const assign = (property, value) => {
+      if (value !== undefined) {
+        if (property.collection) {
+          const current = this[property.name];
+
+          switch (typeof current) {
+            case "undefined":
+              this[property.name] = value;
+              break;
+            case "object":
+              if (Array.isArray(current)) {
+                current.push(value);
+              } else {
+                if (current instanceof Map || current instanceof Set) {
+                  // TODO
+                  this[property.name] = value;
+                } else {
+                  this.error("Unknown collection type", property.name, current);
+                }
+              }
+              break;
+            case "function":
+              if (value instanceof Base) {
+                this.addObject(value);
+              } else {
+                this.error("Unknown collection type", property.name, current);
               }
+              break;
+          }
+        } else {
+          this[property.name] = value;
+        }
+      }
+    };
+
+    const instantiateAndAssign = (property, value) => {
+      if (primitives.has(property.type)) {
+        assign(property, value);
+        return;
+      }
+
+      switch (typeof value) {
+        case "undefined":
+          return;
+        case "function":
+          this.error("Invalid value", property.name, value);
+          break;
+
+        case "boolean":
+        case "bigint":
+        case "number":
+        case "string":
+          {
+            value = this.expand(value);
+            const object = this.typeNamed(property.type.name, value);
+
+            if (object) {
+              assign(property, object);
             } else {
-              this[slotName] = slot;
+              if (property.type.constructWithIdentifierOnly) {
+                new property.type.clazz(this.ownerFor(property, value), value);
+              } else {
+                this.finalize(() => {
+                  value = this.expand(value);
+                  const object =
+                    this.typeNamed(property.type.name, value) ||
+                    this.owner.typeNamed(property.type.name, value) ||
+                    this.root.typeNamed(property.type.name, value); // TODO
+
+                  assign(property, object);
+                });
+              }
             }
+          }
+          break;
+        case "object":
+          if (value instanceof property.type.clazz) {
+            assign(property, value);
           } else {
-            for (const [objectName, objectData] of Object.entries(slot)) {
-              objectData.name = objectName;
-              new type(this, objectData);
-            }
+            assign(
+              property,
+              new property.type.clazz(this.ownerFor(property, value), value)
+            );
           }
-        } else {
-          switch (typeDef.type) {
-            case "undefined":
-              break;
-            case "boolean":
-            case "string":
-            case "number":
-              this[slotName] = slot;
-              break;
+          break;
+      }
+    };
 
-            default:
-              this[slotName] = new type(this, slot);
+    for (const property of Object.values(type.properties)) {
+      if (property.writeable) {
+        const value = data[property.name];
+        if (property.collection) {
+          if (typeof value === "object") {
+            if (Array.isArray(value)) {
+              for (const v of value) {
+                instantiateAndAssign(property, v);
+              }
+            } else {
+              for (const [objectName, objectData] of Object.entries(value)) {
+                objectData[type.identifier.name] = objectName;
+                instantiateAndAssign(property, objectData);
+              }
+            }
+            continue;
           }
         }
+        instantiateAndAssign(property, value);
       }
     }
   }
 
+  typeNamed(typeName, name) {
+    return this.owner.typeNamed(typeName, name);
+  }
+
+  addObject(object) {
+    return this.owner.addObject(object);
+  }
+
   forOwner(owner) {
     if (this.owner !== owner) {
       // @ts-ignore
@@ -119,6 +205,16 @@ export class Base {
     return this;
   }
 
+  isNamed(name) {
+    return name[0] === "/" ? this.fullName === name : this.name === name;
+  }
+
+  relativeName(name) {
+    return name?.[0] === "/"
+      ? name.substring(this.owner.fullName.length + 1)
+      : name;
+  }
+
   get typeName() {
     // @ts-ignore
     return this.constructor.typeDefinition.name;
@@ -150,16 +246,13 @@ export class Base {
   }
 
   get directory() {
-    return (
-      this.#directory ||
-      (this.owner ? join(this.owner.directory, this.name) : this.name)
-    );
+    return this.#directory || join(this.owner.directory, this.name);
   }
 
   get fullName() {
-    return this.owner?.fullName && this.name
-      ? join(this.owner.fullName, this.name)
-      : this.name;
+    return this.name
+      ? join(this.owner.fullName, "/", this.name)
+      : this.owner.fullName;
   }
 
   expand(object) {
@@ -246,7 +339,29 @@ export class Base {
   }
 }
 
-export function extractFrom(object, typeDefinition) {
+export function extractFrom(
+  object,
+  typeDefinition = object?.constructor?.typeDefinition
+) {
+  if (Array.isArray(object)) {
+    if (object.length === 0) {
+      return undefined;
+    }
+
+    if (typeDefinition?.identifier) {
+      return Object.fromEntries(
+        object.map(o => {
+          o = extractFrom(o);
+          const name = o[typeDefinition.identifier.name];
+          delete o[typeDefinition.identifier.name];
+          return [name, o];
+        })
+      );
+    }
+
+    return object.map(o => extractFrom(o));
+  }
+
   if (!typeDefinition || object === undefined) {
     return object;
   }
@@ -262,19 +377,13 @@ export function extractFrom(object, typeDefinition) {
           {
             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;
-              }
+            if (typeof value?.next === "function") {
+              value = [...value];
+            }
+
+            value = extractFrom(value, def.type);
+            if (value !== undefined) {
+              json[name] = value;
             }
           }
           break;
@@ -286,14 +395,17 @@ export function extractFrom(object, typeDefinition) {
             }
           } else {
             if (Array.isArray(value)) {
-              json[name] = value;
+              json[name] = extractFrom(value);
             } else {
-              json[name] = Object.fromEntries(
+              const resultObject = Object.fromEntries(
                 Object.entries(value).map(([k, v]) => [
                   k,
-                  extractFrom(v, typesByName[def.type])
+                  v // extractFrom(v, def.type)
                 ])
               );
+              if (Object.keys(resultObject).length > 0) {
+                json[name] = resultObject;
+              }
             }
           }
           break;
@@ -304,7 +416,7 @@ export function extractFrom(object, typeDefinition) {
           json[name] = value;
       }
     }
-    typeDefinition = typeDefinition?.extends?.typeDefinition;
+    typeDefinition = typeDefinition?.extends;
   } while (typeDefinition);
 
   return json;

package/src/cluster.mjs

@@ -1,21 +1,21 @@
 import { Owner } from "./owner.mjs";
 import { addType } from "./types.mjs";
 
+const typeDefinition = {
+  name: "cluster",
+  owners: [Owner.typeDefinition, "network", "root"],
+  priority: 0.7,
+  extends: Owner.typeDefinition,
+  properties: {}
+};
+
 export class Cluster extends Owner {
   static {
     addType(this);
   }
 
   static get typeDefinition() {
-    return {
-      name: "cluster",
-      extends: Owner,
-      properties: {}
-    };
+    return typeDefinition;
   }
 
-  constructor(owner, data) {
-    super(owner, data);
-    owner.addObject(this);
-  }
 }

package/src/dns.mjs

@@ -1,47 +1,59 @@
 import { Base } from "./base.mjs";
-import { asArray } from "./utils.mjs";
 import { addType } from "./types.mjs";
 
+const DNSServiceTypeDefinition = {
+  name: "dns",
+  owners: ["location", "owner", "network", "cluster", "root"],
+  priority: 0.1,
+  properties: {
+    hasSVRRecords: { type: "boolean", collection: false, writeable: true },
+    hasCatalog: { type: "boolean", collection: false, writeable: true },
+    recordTTL: { type: "string", collection: false, writeable: true },
+    soaUpdates: { type: "number", collection: true, writeable: true },
+    forwardsTo: { type: "network", collection: true, writeable: true },
+    allowedUpdates: { type: "string", collection: true, writeable: true }
+  }
+};
+
 export class DNSService extends Base {
   allowedUpdates = [];
   recordTTL = "1W";
   soaUpdates = [36000, 72000, 600000, 60000];
   hasSVRRecords = true;
   hasCatalog = true;
-  forwardsTo = [];
+  #forwardsTo = [];
 
   static {
     addType(this);
   }
 
   static get typeDefinition() {
-    return {
-      name: "dns",
-      properties: {
-        hasSVRRecords: { type: "boolean" },
-        hasCatalog: { type: "boolean" },
-        recordTTL: { type: "string" },
-        soaUpdates: { type: "number", collection: true },
-        forwardsTo: { type: "host", collection: true },
-        allowedUpdates: { type: "string", collection: true }
-      }
-    };
+    return DNSServiceTypeDefinition;
   }
 
   constructor(owner, data) {
+    if (!data.name) {
+      data.name = DNSServiceTypeDefinition.name; // TODO
+    }
     super(owner, data);
-    Object.assign(this, data);
-    owner.addObject(this);
+    this.read(data, DNSServiceTypeDefinition);
+  }
+
+  set forwardsTo(value) {
+    this.#forwardsTo.push(value);
+  }
+
+  get forwardsTo() {
+    return this.#forwardsTo;
   }
 
-  async *services() {
-    const filter = { type: "dns" };
+  async *findServices() {
+    const filter = { type: DNSServiceTypeDefinition.name };
 
-    yield* this.owner.services(filter);
+    yield* this.owner.findServices(filter);
 
-    for (const s of asArray(this.forwardsTo)) {
-      const owner = await this.owner.root.load(s);
-      yield* owner.services(filter);
+    for (const s of this.forwardsTo) {
+      yield* s.findServices(filter);
     }
   }
 
@@ -50,7 +62,7 @@ export class DNSService extends Base {
   }
 
   async resolvedConfig() {
-    const dnsServices = (await Array.fromAsync(this.services())).sort(
+    const dnsServices = (await Array.fromAsync(this.findServices())).sort(
       (a, b) => a.priority - b.priority
     );