@highstate/common 0.15.0 → 0.17.0

package/src/units/databases/mongodb-patch/index.ts

@@ -0,0 +1,27 @@
+import { databases } from "@highstate/library"
+import { forUnit, toPromise } from "@highstate/pulumi"
+import { l4EndpointToString, parseEndpoints } from "../../../shared"
+
+const { args, inputs, outputs } = forUnit(databases.mongodbPatch)
+
+const mongodb = await toPromise(inputs.mongodb)
+const resolvedInputEndpoints = await toPromise(inputs.endpoints ?? [])
+
+const shouldOverrideEndpoints =
+  args.endpoints.length > 0 || resolvedInputEndpoints.some(endpoint => endpoint != null)
+const endpoints = shouldOverrideEndpoints
+  ? await parseEndpoints(args.endpoints, inputs.endpoints, 4)
+  : mongodb.endpoints
+
+export default outputs({
+  mongodb: {
+    ...mongodb,
+    endpoints,
+    username: args.username ?? mongodb.username,
+    database: args.database ?? mongodb.database,
+  },
+
+  $statusFields: {
+    endpoints: endpoints.map(l4EndpointToString),
+  },
+})

package/src/units/databases/postgresql-patch/index.ts

@@ -0,0 +1,27 @@
+import { databases } from "@highstate/library"
+import { forUnit, toPromise } from "@highstate/pulumi"
+import { l4EndpointToString, parseEndpoints } from "../../../shared"
+
+const { args, inputs, outputs } = forUnit(databases.postgresqlPatch)
+
+const postgresql = await toPromise(inputs.postgresql)
+const resolvedInputEndpoints = await toPromise(inputs.endpoints ?? [])
+
+const shouldOverrideEndpoints =
+  args.endpoints.length > 0 || resolvedInputEndpoints.some(endpoint => endpoint != null)
+const endpoints = shouldOverrideEndpoints
+  ? await parseEndpoints(args.endpoints, inputs.endpoints, 4)
+  : postgresql.endpoints
+
+export default outputs({
+  postgresql: {
+    ...postgresql,
+    endpoints,
+    username: args.username ?? postgresql.username,
+    database: args.database ?? postgresql.database,
+  },
+
+  $statusFields: {
+    endpoints: endpoints.map(l4EndpointToString),
+  },
+})

package/src/units/databases/redis-patch/index.ts

@@ -0,0 +1,32 @@
+import { databases } from "@highstate/library"
+import { forUnit, toPromise } from "@highstate/pulumi"
+import { l4EndpointToString, parseEndpoints } from "../../../shared"
+
+const { args, inputs, outputs } = forUnit(databases.redisPatch)
+
+const redis = await toPromise(inputs.redis)
+const resolvedInputEndpoints = await toPromise(inputs.endpoints ?? [])
+
+const shouldOverrideEndpoints =
+  args.endpoints.length > 0 || resolvedInputEndpoints.some(endpoint => endpoint != null)
+const endpoints = shouldOverrideEndpoints
+  ? await parseEndpoints(args.endpoints, inputs.endpoints, 4)
+  : redis.endpoints
+
+const redisDatabase = args.database === undefined ? undefined : Number.parseInt(args.database, 10)
+
+if (redisDatabase !== undefined && Number.isNaN(redisDatabase)) {
+  throw new Error(`Invalid Redis database number "${args.database}"`)
+}
+
+export default outputs({
+  redis: {
+    ...redis,
+    endpoints,
+    database: redisDatabase ?? redis.database,
+  },
+
+  $statusFields: {
+    endpoints: endpoints.map(l4EndpointToString),
+  },
+})

package/src/units/databases/s3-patch/index.ts

@@ -0,0 +1,28 @@
+import { databases } from "@highstate/library"
+import { forUnit, toPromise } from "@highstate/pulumi"
+import { l4EndpointToString, parseEndpoints } from "../../../shared"
+
+const { args, inputs, outputs } = forUnit(databases.s3Patch)
+
+const s3 = await toPromise(inputs.s3)
+const resolvedInputEndpoints = await toPromise(inputs.endpoints ?? [])
+
+const shouldOverrideEndpoints =
+  args.endpoints.length > 0 || resolvedInputEndpoints.some(endpoint => endpoint != null)
+const endpoints = shouldOverrideEndpoints
+  ? await parseEndpoints(args.endpoints, inputs.endpoints, 4)
+  : s3.endpoints
+
+export default outputs({
+  s3: {
+    ...s3,
+    endpoints,
+    region: args.region ?? s3.region,
+    accessKey: args.accessKey ?? s3.accessKey,
+    buckets: args.buckets ?? s3.buckets,
+  },
+
+  $statusFields: {
+    endpoints: endpoints.map(l4EndpointToString),
+  },
+})

package/src/units/dns/record-set/index.ts

@@ -1,28 +1,23 @@
 import { dns } from "@highstate/library"
-import { forUnit } from "@highstate/pulumi"
-import { updateEndpointsWithFqdn } from "../../../shared"
+import { forUnit, toPromise } from "@highstate/pulumi"
+import { DnsRecordSet, mergeEndpoints, parseEndpoint, replaceEndpointBase } from "../../../shared"
 
 const { name, args, inputs, outputs } = forUnit(dns.recordSet)
 
-const { endpoints: l3Endpoints } = await updateEndpointsWithFqdn(
-  inputs.l3Endpoints ?? [],
-  args.fqdn ?? name,
-  args.endpointFilter,
-  args.patchMode,
-  inputs.dnsProviders,
-  `${args.fqdn ?? name}-l3`,
-)
+const { l3Endpoints, l4Endpoints, l7Endpoints } = await toPromise(inputs)
+const waitServers = await toPromise(inputs.waitServers)
 
-const { endpoints: l4Endpoints } = await updateEndpointsWithFqdn(
-  inputs.l4Endpoints ?? [],
-  args.fqdn ?? name,
-  args.endpointFilter,
-  args.patchMode,
-  inputs.dnsProviders,
-  `${args.fqdn ?? name}-l4`,
-)
+new DnsRecordSet("record-set", {
+  providers: inputs.dnsProviders,
+  name: args.recordName ?? name,
+  values: [...args.values, ...l3Endpoints, ...l4Endpoints, ...l7Endpoints],
+  waitAt: [...(args.waitLocal ? ["local" as const] : []), ...waitServers],
+})
+
+const base = parseEndpoint(args.recordName ?? name)
 
 export default outputs({
-  l3Endpoints,
-  l4Endpoints,
+  l3Endpoints: mergeEndpoints(l3Endpoints.map(endpoint => replaceEndpointBase(endpoint, base))),
+  l4Endpoints: mergeEndpoints(l4Endpoints.map(endpoint => replaceEndpointBase(endpoint, base))),
+  l7Endpoints: mergeEndpoints(l7Endpoints.map(endpoint => replaceEndpointBase(endpoint, base))),
 })

package/src/units/existing-server/index.ts

@@ -1,15 +1,15 @@
 import { common } from "@highstate/library"
 import { forUnit } from "@highstate/pulumi"
 import { map } from "remeda"
-import { createServerBundle, l3EndpointToString, requireInputL3Endpoint } from "../../shared"
+import { createServerBundle, l3EndpointToString, parseEndpoints } from "../../shared"
 
 const { name, args, inputs, secrets, outputs } = forUnit(common.existingServer)
 
-const endpoint = await requireInputL3Endpoint(args.endpoint, inputs.endpoint)
+const endpoints = await parseEndpoints([args.endpoint], inputs.endpoints)
 
 const { server, terminal } = await createServerBundle({
   name,
-  endpoints: [endpoint],
+  endpoints,
   sshArgs: args.ssh,
   sshPassword: secrets.sshPassword,
   sshPrivateKey: secrets.sshPrivateKey,
@@ -18,7 +18,6 @@ const { server, terminal } = await createServerBundle({
 
 export default outputs({
   server,
-  endpoints: server.endpoints,
 
   $statusFields: {
     hostname: server.hostname,

package/src/units/network/address-space/index.ts

@@ -0,0 +1,20 @@
+import { network } from "@highstate/library"
+import { forUnit, toPromise } from "@highstate/pulumi"
+import { createAddressSpace, subnetToString } from "../../../shared"
+
+const { args, inputs, outputs } = forUnit(network.addressSpace)
+
+const resolvedInputs = await toPromise(inputs)
+
+const addressSpace = createAddressSpace({
+  included: [...args.included, ...resolvedInputs.included],
+  excluded: [...args.excluded, ...resolvedInputs.excluded],
+})
+
+export default outputs({
+  addressSpace,
+
+  $statusFields: {
+    subnets: addressSpace.subnets.map(subnetToString),
+  },
+})

package/src/units/network/endpoint-filter/index.ts

@@ -1,13 +1,13 @@
 import { network } from "@highstate/library"
 import { forUnit, toPromise } from "@highstate/pulumi"
-import { filterEndpoints } from "../../../shared"
+import { filterByExpression } from "../../../shared"
 
 const { args, inputs, outputs } = forUnit(network.endpointFilter)
 
-const l3EndpointsResolved = await toPromise(inputs.l3Endpoints)
-const l4EndpointsResolved = await toPromise(inputs.l4Endpoints)
+const resolvedInputs = await toPromise(inputs)
 
 export default outputs({
-  l3Endpoints: filterEndpoints(l3EndpointsResolved, args.endpointFilter),
-  l4Endpoints: filterEndpoints(l4EndpointsResolved, args.endpointFilter),
+  l3Endpoints: filterByExpression(resolvedInputs.l3Endpoints, args.endpointFilter),
+  l4Endpoints: filterByExpression(resolvedInputs.l4Endpoints, args.endpointFilter),
+  l7Endpoints: filterByExpression(resolvedInputs.l7Endpoints, args.endpointFilter),
 })

package/src/units/network/l3-endpoint/index.ts

@@ -1,9 +1,9 @@
 import { network } from "@highstate/library"
 import { forUnit } from "@highstate/pulumi"
-import { parseL3Endpoint } from "../../../shared"
+import { addEndpointMetadata, parseEndpoint } from "../../../shared"
 
 const { args, outputs } = forUnit(network.l3Endpoint)
 
 export default outputs({
-  endpoint: parseL3Endpoint(args.endpoint),
+  endpoint: addEndpointMetadata(parseEndpoint(args.endpoint), args.metadata),
 })

package/src/units/network/l4-endpoint/index.ts

@@ -1,9 +1,9 @@
 import { network } from "@highstate/library"
 import { forUnit } from "@highstate/pulumi"
-import { parseL4Endpoint } from "../../../shared"
+import { addEndpointMetadata, parseEndpoint } from "../../../shared"
 
 const { args, outputs } = forUnit(network.l4Endpoint)
 
 export default outputs({
-  endpoint: parseL4Endpoint(args.endpoint),
+  endpoint: addEndpointMetadata(parseEndpoint(args.endpoint, 4), args.metadata),
 })

package/src/units/network/l7-endpoint/index.ts

@@ -1,9 +1,9 @@
 import { network } from "@highstate/library"
 import { forUnit } from "@highstate/pulumi"
-import { parseL7Endpoint } from "../../../shared"
+import { addEndpointMetadata, parseEndpoint } from "../../../shared"
 
 const { args, outputs } = forUnit(network.l7Endpoint)
 
 export default outputs({
-  endpoint: parseL7Endpoint(args.endpoint),
+  endpoint: addEndpointMetadata(parseEndpoint(args.endpoint, 7), args.metadata),
 })

package/src/units/remote-file/index.ts

@@ -1,17 +1,24 @@
 import { common } from "@highstate/library"
-import { forUnit } from "@highstate/pulumi"
-import { parseL7Endpoint } from "../../shared"
+import { forUnit, toPromise } from "@highstate/pulumi"
+import { parseEndpoint } from "../../shared"
 
-const { args, inputs, outputs } = forUnit(common.remoteFile)
+const { name, args, inputs, outputs } = forUnit(common.remoteFile)
+
+const resolvedInputs = await toPromise(inputs)
+if (!resolvedInputs.endpoint && !args.url) {
+  throw new Error("Either 'endpoint' input or 'url' argument must be provided.")
+}
+
+const endpoint = parseEndpoint(resolvedInputs.endpoint ?? args.url!, 7)
 
 export default outputs({
   file: {
     meta: {
-      name: args.url ? new URL(args.url).pathname.split("/").pop() || "file" : "file",
+      name: args.fileName ?? endpoint.path?.split("/").pop() ?? name,
     },
     content: {
       type: "remote",
-      endpoint: inputs.endpoint ? inputs.endpoint : parseL7Endpoint(args.url!),
+      endpoint,
     },
   },
 })

package/src/units/server-patch/index.ts

@@ -1,23 +1,20 @@
 import { common } from "@highstate/library"
-import { forUnit } from "@highstate/pulumi"
-import { l3EndpointToString, updateEndpoints } from "../../shared"
+import { forUnit, toPromise } from "@highstate/pulumi"
+import { l3EndpointToString, parseEndpoints } from "../../shared"
 
 const { args, inputs, outputs } = forUnit(common.serverPatch)
 
-const endpoints = await updateEndpoints(
-  inputs.server.endpoints,
-  args.endpoints,
-  inputs.endpoints,
-  args.endpointsPatchMode,
-)
+const server = await toPromise(inputs.server)
+const endpoints = await parseEndpoints(args.endpoints, inputs.endpoints, 3)
+
+const newEndpoints = endpoints.length > 0 ? endpoints : server.endpoints
 
 export default outputs({
-  server: inputs.server.apply(server => ({
+  server: {
     ...server,
-    endpoints,
-  })),
-
-  endpoints,
+    hostname: args.hostname ?? server.hostname,
+    endpoints: newEndpoints,
+  },
 
   $statusFields: {
     endpoints: endpoints.map(l3EndpointToString),