@highstate/common 0.14.2 → 0.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@highstate/common",
-  "version": "0.14.2",
+  "version": "0.16.0",
   "type": "module",
   "files": [
     "dist",
@@ -20,6 +20,14 @@
         "mode": "manual",
         "version": "1"
       },
+      "./units/network/address-space": {
+        "mode": "manual",
+        "version": "1"
+      },
+      "./units/network/endpoint-filter": {
+        "mode": "manual",
+        "version": "1"
+      },
       "./units/network/l3-endpoint": {
         "mode": "manual",
         "version": "1"
@@ -28,6 +36,10 @@
         "mode": "manual",
         "version": "1"
       },
+      "./units/network/l7-endpoint": {
+        "mode": "manual",
+        "version": "1"
+      },
       "./units/existing-server": {
         "mode": "manual",
         "version": "1"
@@ -40,11 +52,11 @@
         "mode": "manual",
         "version": "1"
       },
-      "./units/server-dns": {
+      "./units/server-patch": {
         "mode": "manual",
         "version": "1"
       },
-      "./units/server-patch": {
+      "./units/databases/existing-etcd": {
         "mode": "manual",
         "version": "1"
       },
@@ -63,6 +75,34 @@
       "./units/databases/existing-redis": {
         "mode": "manual",
         "version": "1"
+      },
+      "./units/databases/existing-s3": {
+        "mode": "manual",
+        "version": "1"
+      },
+      "./units/databases/etcd-patch": {
+        "mode": "manual",
+        "version": "1"
+      },
+      "./units/databases/mariadb-patch": {
+        "mode": "manual",
+        "version": "1"
+      },
+      "./units/databases/postgresql-patch": {
+        "mode": "manual",
+        "version": "1"
+      },
+      "./units/databases/mongodb-patch": {
+        "mode": "manual",
+        "version": "1"
+      },
+      "./units/databases/redis-patch": {
+        "mode": "manual",
+        "version": "1"
+      },
+      "./units/databases/s3-patch": {
+        "mode": "manual",
+        "version": "1"
       }
     }
   },
@@ -73,17 +113,27 @@
     },
     "./units/access-point": "./dist/units/access-point/index.js",
     "./units/dns/record-set": "./dist/units/dns/record-set/index.js",
+    "./units/network/address-space": "./dist/units/network/address-space/index.js",
+    "./units/network/endpoint-filter": "./dist/units/network/endpoint-filter/index.js",
     "./units/network/l3-endpoint": "./dist/units/network/l3-endpoint/index.js",
     "./units/network/l4-endpoint": "./dist/units/network/l4-endpoint/index.js",
+    "./units/network/l7-endpoint": "./dist/units/network/l7-endpoint/index.js",
     "./units/existing-server": "./dist/units/existing-server/index.js",
     "./units/ssh/key-pair": "./dist/units/ssh/key-pair/index.js",
     "./units/script": "./dist/units/script/index.js",
-    "./units/server-dns": "./dist/units/server-dns/index.js",
     "./units/server-patch": "./dist/units/server-patch/index.js",
+    "./units/databases/existing-etcd": "./dist/units/databases/existing-etcd/index.js",
     "./units/databases/existing-mariadb": "./dist/units/databases/existing-mariadb/index.js",
     "./units/databases/existing-postgresql": "./dist/units/databases/existing-postgresql/index.js",
     "./units/databases/existing-mongodb": "./dist/units/databases/existing-mongodb/index.js",
-    "./units/databases/existing-redis": "./dist/units/databases/existing-redis/index.js"
+    "./units/databases/existing-redis": "./dist/units/databases/existing-redis/index.js",
+    "./units/databases/existing-s3": "./dist/units/databases/existing-s3/index.js",
+    "./units/databases/etcd-patch": "./dist/units/databases/etcd-patch/index.js",
+    "./units/databases/mariadb-patch": "./dist/units/databases/mariadb-patch/index.js",
+    "./units/databases/postgresql-patch": "./dist/units/databases/postgresql-patch/index.js",
+    "./units/databases/mongodb-patch": "./dist/units/databases/mongodb-patch/index.js",
+    "./units/databases/redis-patch": "./dist/units/databases/redis-patch/index.js",
+    "./units/databases/s3-patch": "./dist/units/databases/s3-patch/index.js"
   },
   "publishConfig": {
     "access": "public"
@@ -96,29 +146,33 @@
   "dependencies": {
     "@noble/hashes": "^1.7.1",
     "@pulumi/command": "^1.0.2",
+    "filter-expression": "^1.0.0",
+    "import-meta-resolve": "^4.1.0",
     "micro-key-producer": "^0.7.3",
     "minimatch": "^10.0.3",
     "remeda": "^2.21.0",
     "tar": "^7.4.3",
     "unzipper": "^0.12.3",
-    "import-meta-resolve": "^4.1.0",
-    "@highstate/library": "0.14.2",
-    "@highstate/pulumi": "0.15.0",
-    "@highstate/contract": "0.15.0"
+    "@highstate/pulumi": "0.17.0",
+    "@highstate/library": "0.16.0",
+    "@highstate/contract": "0.17.0"
   },
   "devDependencies": {
     "@biomejs/biome": "2.2.0",
     "@types/tar": "^6.1.13",
     "@types/unzipper": "^0.10.11",
     "@typescript/native-preview": "^7.0.0-dev.20250920.1",
+    "@vitest/coverage-v8": "2.1.8",
+    "vitest": "^3.2.4",
     "type-fest": "^4.41.0",
-    "@highstate/cli": "0.15.0"
+    "@highstate/cli": "0.17.0"
   },
   "repository": {
     "url": "https://github.com/highstate-io/highstate"
   },
   "scripts": {
     "build": "highstate build",
+    "test": "vitest run",
     "update-images": "../../../scripts/update-images.sh ./assets/images.json",
     "typecheck": "tsgo --noEmit --skipLibCheck",
     "biome": "biome check --write --unsafe --error-on-warnings",

package/src/shared/command.ts

@@ -13,7 +13,7 @@ import {
 import { sha256 } from "@noble/hashes/sha2"
 import { local, remote, type types } from "@pulumi/command"
 import { flat } from "remeda"
-import { l3EndpointToString } from "./network"
+import { l3EndpointToString } from "./network/endpoints"
 
 /**
  * Creates a connection object for the given SSH credentials.

package/src/shared/dns.ts

@@ -1,4 +1,4 @@
-import type { ArrayPatchMode, dns, network } from "@highstate/library"
+import type { dns, network } from "@highstate/library"
 import { getOrCreate, z } from "@highstate/contract"
 import {
   ComponentResource,
@@ -10,19 +10,12 @@ import {
   type Output,
   output,
   type ResourceOptions,
-  toPromise,
   type Unwrap,
 } from "@highstate/pulumi"
-import { flat, groupBy, uniqueBy } from "remeda"
+import { flat } from "remeda"
 import { Command, type CommandHost } from "./command"
 import { ImplementationMediator } from "./impl-ref"
-import {
-  filterEndpoints,
-  type InputL3Endpoint,
-  l3EndpointToString,
-  l34EndpointToString,
-  parseL3Endpoint,
-} from "./network"
+import { type InputEndpoint, l3EndpointToString, parseEndpoint } from "./network/endpoints"
 
 export const dnsRecordMediator = new ImplementationMediator(
   "dns-record",
@@ -52,7 +45,7 @@ export type DnsRecordArgs = {
   /**
    * The value of the DNS record.
    */
-  value: Input<InputL3Endpoint>
+  value: Input<InputEndpoint>
 
   /**
    * Whether the DNS record is proxied (e.g. to provide DDoS protection).
@@ -105,12 +98,12 @@ export type DnsRecordSetArgs = Omit<DnsRecordArgs, "provider" | "value"> & {
   /**
    * The value of the DNS record.
    */
-  value?: Input<InputL3Endpoint>
+  value?: Input<InputEndpoint>
 
   /**
    * The values of the DNS records.
    */
-  values?: InputArray<InputL3Endpoint>
+  values?: InputArray<InputEndpoint>
 }
 
 function getTypeByEndpoint(endpoint: network.L3Endpoint): string {
@@ -145,7 +138,7 @@ export class DnsRecord extends ComponentResource {
   constructor(name: string, args: DnsRecordArgs, opts?: ResourceOptions) {
     super("highstate:common:DnsRecord", name, args, opts)
 
-    const l3Endpoint = output(args.value).apply(value => parseL3Endpoint(value))
+    const l3Endpoint = output(args.value).apply(value => parseEndpoint(value))
     const resolvedValue = l3Endpoint.apply(l3EndpointToString)
     const resolvedType = args.type ? output(args.type) : l3Endpoint.apply(getTypeByEndpoint)
 
@@ -238,7 +231,9 @@ export class DnsRecordSet extends ComponentResource {
       providers: args.providers,
       name: args.name ?? name,
     }).apply(({ providers, name }) => {
-      const matchedProviders = providers.filter(provider => name.endsWith(provider.domain))
+      const matchedProviders = providers.filter(provider =>
+        provider.zones.some(zone => name.endsWith(zone)),
+      )
 
       if (matchedProviders.length === 0) {
         throw new Error(`No DNS provider matched the domain "${name}"`)
@@ -253,7 +248,7 @@ export class DnsRecordSet extends ComponentResource {
         providers: matchedProviders,
       }).apply(({ name, providers }) => {
         return providers.flatMap(provider => {
-          const l3Endpoint = parseL3Endpoint(value)
+          const l3Endpoint = parseEndpoint(value)
 
           return new DnsRecord(
             `${name}.${provider.id}.${l3EndpointToString(l3Endpoint)}`,
@@ -297,80 +292,3 @@ export class DnsRecordSet extends ComponentResource {
     )
   }
 }
-
-/**
- * Registers the DNS record set for the given endpoints and prepends the corresponding hostname endpoint to the list.
- *
- * Waits for the DNS record set to be created/updated before continuing.
- *
- * Ignores the "hostname" endpoints in the list.
- *
- * @param endpoints The list of endpoints to register. Will be modified in place.
- * @param fqdn The FQDN to register the DNS record set for. If not provided, no DNS record set will be created and array will not be modified.
- * @param fqdnEndpointFilter The filter to apply to the endpoints before passing them to the DNS record set. Does not apply to the resulted endpoint list.
- * @param patchMode The patch mode to use when modifying the endpoints list.
- * @param dnsProviders The DNS providers to use to create the DNS records.
- * @param dnsSetName The name of the DNS record set. If not provided, the FQDN will be used.
- */
-export async function updateEndpointsWithFqdn<TEndpoint extends network.L34Endpoint>(
-  endpoints: Input<TEndpoint[]>,
-  fqdn: string | undefined,
-  fqdnEndpointFilter: network.EndpointFilter,
-  patchMode: ArrayPatchMode,
-  dnsProviders: Input<dns.Provider[]>,
-  dnsSetName?: string,
-): Promise<{ endpoints: TEndpoint[]; dnsRecordSet: DnsRecordSet | undefined }> {
-  const resolvedEndpoints = await toPromise(endpoints)
-
-  if (!fqdn) {
-    return {
-      endpoints: resolvedEndpoints as TEndpoint[],
-      dnsRecordSet: undefined,
-    }
-  }
-
-  const filteredEndpoints = filterEndpoints(resolvedEndpoints, fqdnEndpointFilter)
-
-  const dnsRecordSet = new DnsRecordSet(dnsSetName ?? fqdn, {
-    name: fqdn,
-    providers: dnsProviders,
-    values: filteredEndpoints,
-    waitAt: "local",
-  })
-
-  const portProtocolGroups = groupBy(filteredEndpoints, endpoint =>
-    endpoint.port ? `${endpoint.port}-${endpoint.protocol}` : "",
-  )
-
-  const newEndpoints: TEndpoint[] = []
-
-  for (const group of Object.values(portProtocolGroups)) {
-    newEndpoints.unshift({
-      type: "hostname",
-      hostname: fqdn,
-      visibility: group[0].visibility,
-      port: group[0].port,
-      protocol: group[0].protocol,
-    } as TEndpoint)
-  }
-
-  await toPromise(
-    dnsRecordSet.waitCommands.apply(waitCommands => waitCommands.map(command => command.stdout)),
-  )
-
-  if (patchMode === "prepend") {
-    return {
-      endpoints: uniqueBy(
-        //
-        [...newEndpoints, ...(resolvedEndpoints as TEndpoint[])],
-        endpoint => l34EndpointToString(endpoint),
-      ),
-      dnsRecordSet,
-    }
-  }
-
-  return {
-    endpoints: newEndpoints,
-    dnsRecordSet,
-  }
-}

package/src/shared/files.ts

@@ -11,7 +11,7 @@ import { asset, type Input, toPromise } from "@highstate/pulumi"
 import { minimatch } from "minimatch"
 import * as tar from "tar"
 import unzipper from "unzipper"
-import { type InputL7Endpoint, l7EndpointToString, parseL7Endpoint } from "./network"
+import { type InputL7Endpoint, l7EndpointToString, parseEndpoint } from "./network/endpoints"
 
 export type FolderPackOptions = {
   /**
@@ -728,7 +728,7 @@ export async function fetchFileSize(endpoint: network.L7Endpoint): Promise<numbe
  * Extracts the name from an L7 endpoint URL without its file extension.
  */
 export function getNameByEndpoint(endpoint: InputL7Endpoint): string {
-  const parsedEndpoint = parseL7Endpoint(endpoint)
+  const parsedEndpoint = parseEndpoint(endpoint, 7)
 
-  return parsedEndpoint.resource ? basename(parsedEndpoint.resource) : ""
+  return parsedEndpoint.path ? basename(parsedEndpoint.path) : ""
 }

package/src/shared/impl-ref.ts

@@ -128,3 +128,7 @@ export class ImplementationMediator<
     return output(this.call(implRef, input))
   }
 }
+
+export function areImplRefsEqual(a: ImplementationReference, b: ImplementationReference): boolean {
+  return a.package === b.package && JSON.stringify(a.data) === JSON.stringify(b.data)
+}

package/src/shared/index.ts

@@ -5,6 +5,8 @@ export * from "./files"
 export * from "./gateway"
 export * from "./impl-ref"
 export * from "./network"
+export * from "./network/address-space"
 export * from "./passwords"
 export * from "./ssh"
 export * from "./tls"
+export * from "./utils"

package/src/shared/network/address-space.spec.ts

@@ -0,0 +1,114 @@
+import { network } from "@highstate/library"
+import { describe, expect, it } from "vitest"
+import { parseAddress } from "./address"
+import { createAddressSpace } from "./address-space"
+import { parseEndpoint } from "./endpoints"
+import { subnetToString } from "./subnet"
+
+describe("createAddressSpace", () => {
+  it("returns a single canonical CIDR for adjacent subnets", () => {
+    const result = createAddressSpace({
+      included: ["10.0.0.0/25", "10.0.0.128/25"],
+    })
+
+    expect(result.subnets.map(subnetToString)).toEqual(["10.0.0.0/24"])
+  })
+
+  it("applies exclusions and keeps canonical ordering", () => {
+    const result = createAddressSpace({
+      included: ["10.0.0.0/24"],
+      excluded: ["10.0.0.64/26"],
+    })
+
+    expect(result.subnets.map(subnetToString)).toEqual(["10.0.0.0/26", "10.0.0.128/25"])
+  })
+
+  it("converts dash ranges to a canonical CIDR list", () => {
+    const result = createAddressSpace({
+      included: ["10.0.0.10-10.0.0.20"],
+    })
+
+    expect(result.subnets.map(subnetToString)).toEqual([
+      "10.0.0.10/31",
+      "10.0.0.12/30",
+      "10.0.0.16/30",
+      "10.0.0.20/32",
+    ])
+  })
+
+  it("ignores hostname L3 endpoints", () => {
+    const hostnameEndpoint = parseEndpoint("example.com")
+
+    const result = createAddressSpace({
+      included: [hostnameEndpoint],
+    })
+
+    expect(result.subnets).toEqual([])
+  })
+
+  it("canonicalizes IPv6 addresses", () => {
+    const result = createAddressSpace({
+      included: ["2001:db8:0:0:0:0:0:1"],
+    })
+
+    expect(result.subnets.map(subnetToString)).toEqual(["2001:db8::1/128"])
+  })
+
+  it("produces a schema-valid address space", () => {
+    const result = createAddressSpace({
+      included: ["10.0.0.0/24", "2001:db8::1"],
+      excluded: ["10.0.0.10"],
+    })
+
+    const parsed = network.addressSpaceEntity.schema.safeParse(result)
+    expect(parsed.success).toBe(true)
+  })
+
+  it("accepts network.Subnet inputs", () => {
+    const subnet = {
+      type: "ipv4",
+      baseAddress: "10.1.0.0",
+      prefixLength: 24,
+    } satisfies network.Subnet
+
+    const result = createAddressSpace({
+      included: [subnet],
+    })
+
+    expect(result.subnets.map(subnetToString)).toEqual(["10.1.0.0/24"])
+  })
+
+  it("accepts network.AddressSpace inputs", () => {
+    const seed = createAddressSpace({
+      included: ["10.2.0.0/25", "10.2.0.128/25"],
+    })
+
+    const addressSpace = seed satisfies network.AddressSpace
+
+    const result = createAddressSpace({
+      included: [addressSpace],
+    })
+
+    expect(result.subnets.map(subnetToString)).toEqual(["10.2.0.0/24"])
+  })
+
+  it("accepts network.Address inputs", () => {
+    const address = parseAddress("10.3.0.7") satisfies network.Address
+
+    const result = createAddressSpace({
+      included: [address],
+    })
+
+    expect(result.subnets.map(subnetToString)).toEqual(["10.3.0.7/32"])
+  })
+
+  it("accepts non-hostname network.L3Endpoint inputs", () => {
+    const endpoint = parseEndpoint("10.4.0.9")
+
+    const result = createAddressSpace({
+      included: [endpoint],
+    })
+
+    expect(result.subnets.map(subnetToString)).toEqual(["10.4.0.9/32"])
+  })
+})