@alienplatform/core 1.10.7 → 1.11.1

package/src/generated/zod/machines-compute-machine-status-schema.ts

@@ -0,0 +1,30 @@
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+
+import * as z from "zod";
+import { ComputeDrainBlockerSchema } from "./compute-drain-blocker-schema.js";
+
+export const MachinesComputeMachineStatusSchema = z.object({
+    "capacityGroup": z.string(),
+"cpuCores": z.number().nullish(),
+get "drainBlockers"(){
+                return z.array(ComputeDrainBlockerSchema).optional()
+              },
+"drainDeadlineAt": z.string().nullish(),
+"drainForce": z.boolean(),
+"drainRequestedAt": z.string().nullish(),
+"drainedAt": z.string().nullish(),
+"horizondVersion": z.string().nullish(),
+"lastHeartbeat": z.string(),
+"machineId": z.string(),
+"memoryBytes": z.int().nullish(),
+"overlayIp": z.string().nullish(),
+"publicIp": z.string().nullish(),
+"replicaCount": z.int(),
+"status": z.string(),
+"zone": z.string()
+    })
+
+export type MachinesComputeMachineStatus = z.infer<typeof MachinesComputeMachineStatusSchema>

package/src/generated/zod/machines-daemon-heartbeat-data-schema.ts

@@ -0,0 +1,35 @@
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+
+import * as z from "zod";
+import { ManagedRuntimeEventSnapshotSchema } from "./managed-runtime-event-snapshot-schema.js";
+import { ManagedRuntimeUnitStatusSchema } from "./managed-runtime-unit-status-schema.js";
+import { WorkloadHeartbeatStatusSchema } from "./workload-heartbeat-status-schema.js";
+
+export const MachinesDaemonHeartbeatDataSchema = z.object({
+    "assignedMachines": z.int().min(0),
+"capacityGroup": z.string(),
+"commandSupported": z.boolean(),
+get "daemonInstances"(){
+                return z.array(ManagedRuntimeUnitStatusSchema)
+              },
+"daemonName": z.optional(z.string()),
+"desiredMachines": z.int().min(0),
+get "events"(){
+                return z.array(ManagedRuntimeEventSnapshotSchema)
+              },
+"healthyInstances": z.int().min(0),
+"horizonClusterId": z.string(),
+"horizonStatus": z.string(),
+"horizonStatusMessage": z.string().nullish(),
+"horizonStatusReason": z.string().nullish(),
+"latestUpdateTimestamp": z.string(),
+get "status"(){
+                return WorkloadHeartbeatStatusSchema
+              },
+"unavailableInstances": z.int().min(0)
+    })
+
+export type MachinesDaemonHeartbeatData = z.infer<typeof MachinesDaemonHeartbeatDataSchema>

package/src/generated/zod/network-settings-schema.ts

@@ -27,6 +27,7 @@ export const NetworkSettingsSchema = z.union([z.object({
 "type": z.enum(["byo-vpc-gcp"])
     }), z.object({
     "application_gateway_subnet_name": z.string().describe("Name of the dedicated classic Application Gateway subnet within the VNet.").nullish(),
+"private_endpoint_subnet_name": z.string().describe("Name of the dedicated subnet that hosts Private Endpoints (e.g. for a\nPostgres Flexible Server). A Private Endpoint must not share the private\nsubnet, which is already claimed by the Container Apps environment's\n`infrastructure_subnet_id`. Required only when the stack contains a\nPostgres resource; otherwise unused.").nullish(),
 "private_subnet_name": z.string().describe("Name of the private subnet within the VNet"),
 "public_subnet_name": z.string().describe("Name of the public subnet within the VNet"),
 "type": z.enum(["byo-vnet-azure"]),

package/src/generated/zod/observed-inventory-batch-schema.ts

@@ -0,0 +1,27 @@
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+
+import * as z from "zod";
+import { HeartbeatBackendSchema } from "./heartbeat-backend-schema.js";
+import { ObservedResourceSampleSchema } from "./observed-resource-sample-schema.js";
+import { PlatformSchema } from "./platform-schema.js";
+
+export const ObservedInventoryBatchSchema = z.object({
+    get "backend"(){
+                return HeartbeatBackendSchema.describe("Backend whose observer produced this snapshot.")
+              },
+"complete": z.boolean().describe("Whether this batch is a complete replacement for the scope. Complete\nbatches tombstone previously observed rows in the same scope when they\nare absent from `resources`."),
+get "controllerPlatform"(){
+                return PlatformSchema.describe("Represents the target cloud platform.")
+              },
+"inventoryScope": z.string().describe("Stable scope for the provider list operation that produced this batch."),
+"observedAt": z.iso.datetime().describe("Time the inventory scope was observed."),
+get "resources"(){
+                return z.array(ObservedResourceSampleSchema)
+              },
+"sourceKind": z.string().describe("Writer/source for this inventory pass, such as `operator` or\n`manager-observer`.")
+    })
+
+export type ObservedInventoryBatch = z.infer<typeof ObservedInventoryBatchSchema>

package/src/generated/zod/observed-resource-sample-schema.ts

@@ -0,0 +1,54 @@
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+
+import * as z from "zod";
+import { HeartbeatCollectionIssueSchema } from "./heartbeat-collection-issue-schema.js";
+import { ObservedCountsSchema } from "./observed-counts-schema.js";
+import { ObservedHealthSchema } from "./observed-health-schema.js";
+import { ProviderLifecycleStateSchema } from "./provider-lifecycle-state-schema.js";
+import { RawHeartbeatSnippetSchema } from "./raw-heartbeat-snippet-schema.js";
+import { ResourceTypeSchema } from "./resource-type-schema.js";
+import { ValueSchema } from "./value-schema.js";
+
+export const ObservedResourceSampleSchema = z.object({
+    "alienResourceId": z.string().nullish(),
+"attributes": z.optional(z.object({
+    
+    }).catchall(z.lazy(() => ValueSchema))),
+get "collectionIssues"(){
+                return z.array(HeartbeatCollectionIssueSchema).optional()
+              },
+get "counts"(){
+                return z.union([ObservedCountsSchema, z.null()]).optional()
+              },
+"deploymentId": z.string().nullish(),
+"displayName": z.string(),
+get "health"(){
+                return ObservedHealthSchema
+              },
+"labels": z.optional(z.object({
+    
+    }).catchall(z.string())),
+get "lifecycle"(){
+                return ProviderLifecycleStateSchema
+              },
+"message": z.string().nullish(),
+"namespace": z.string().nullish(),
+"partial": z.boolean(),
+"providerKind": z.string().describe("Provider-native kind, such as `apps/v1/Deployment`,\n`AWS::S3::Bucket`, `storage.googleapis.com/Bucket`, or an Azure\nresource type."),
+"providerStale": z.boolean(),
+get "raw"(){
+                return z.array(RawHeartbeatSnippetSchema).optional()
+              },
+"rawIdentity": z.string().describe("Provider-native stable identity: Kubernetes object identity, cloud ARN,\nGCP full resource name, Azure resource id, etc."),
+"region": z.string().nullish(),
+get "resourceTypeHint"(){
+                return z.union([ResourceTypeSchema, z.null()]).optional()
+              },
+"scope": z.string().nullish(),
+"version": z.string().describe("Release/version identity observed from the provider resource, when available.").nullish()
+    })
+
+export type ObservedResourceSample = z.infer<typeof ObservedResourceSampleSchema>

package/src/generated/zod/platform-schema.ts

@@ -8,6 +8,6 @@ import * as z from "zod";
 /**
  * @description Represents the target cloud platform.
  */
-export const PlatformSchema = z.enum(["aws", "gcp", "azure", "kubernetes", "local", "test"]).describe("Represents the target cloud platform.")
+export const PlatformSchema = z.enum(["aws", "gcp", "azure", "kubernetes", "machines", "local", "test"]).describe("Represents the target cloud platform.")
 
 export type Platform = z.infer<typeof PlatformSchema>

package/src/generated/zod/postgres-backend-schema.ts

@@ -0,0 +1,15 @@
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+
+import * as z from "zod";
+
+/**
+ * @description Cloud backend for a Postgres resource. Only Aurora Serverless v2 ships in v1;\nthe enum reserves the slot so provisioned RDS is an additive variant later.
+ */
+export const PostgresBackendSchema = z.object({
+    "type": z.enum(["auroraServerlessV2"])
+    }).describe("Cloud backend for a Postgres resource. Only Aurora Serverless v2 ships in v1;\nthe enum reserves the slot so provisioned RDS is an additive variant later.")
+
+export type PostgresBackend = z.infer<typeof PostgresBackendSchema>

package/src/generated/zod/postgres-heartbeat-data-schema.ts

@@ -0,0 +1,22 @@
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+
+import * as z from "zod";
+import { AuroraPostgresHeartbeatDataSchema } from "./aurora-postgres-heartbeat-data-schema.js";
+import { AzureFlexibleServerPostgresHeartbeatDataSchema } from "./azure-flexible-server-postgres-heartbeat-data-schema.js";
+import { GcpCloudSqlPostgresHeartbeatDataSchema } from "./gcp-cloud-sql-postgres-heartbeat-data-schema.js";
+import { LocalPostgresHeartbeatDataSchema } from "./local-postgres-heartbeat-data-schema.js";
+
+export const PostgresHeartbeatDataSchema = z.union([z.lazy(() => AuroraPostgresHeartbeatDataSchema).and(z.object({
+    "backend": z.enum(["aurora"])
+    })), z.lazy(() => GcpCloudSqlPostgresHeartbeatDataSchema).and(z.object({
+    "backend": z.enum(["cloudSql"])
+    })), z.lazy(() => AzureFlexibleServerPostgresHeartbeatDataSchema).and(z.object({
+    "backend": z.enum(["flexibleServer"])
+    })), z.lazy(() => LocalPostgresHeartbeatDataSchema).and(z.object({
+    "backend": z.enum(["local"])
+    }))])
+
+export type PostgresHeartbeatData = z.infer<typeof PostgresHeartbeatDataSchema>

package/src/generated/zod/postgres-heartbeat-status-schema.ts

@@ -0,0 +1,26 @@
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+
+import * as z from "zod";
+import { HeartbeatCollectionIssueSchema } from "./heartbeat-collection-issue-schema.js";
+import { ObservedHealthSchema } from "./observed-health-schema.js";
+import { ProviderLifecycleStateSchema } from "./provider-lifecycle-state-schema.js";
+
+export const PostgresHeartbeatStatusSchema = z.object({
+    get "collectionIssues"(){
+                return z.array(HeartbeatCollectionIssueSchema)
+              },
+get "health"(){
+                return ObservedHealthSchema
+              },
+get "lifecycle"(){
+                return ProviderLifecycleStateSchema
+              },
+"message": z.string().nullish(),
+"partial": z.boolean(),
+"stale": z.boolean()
+    })
+
+export type PostgresHeartbeatStatus = z.infer<typeof PostgresHeartbeatStatusSchema>

package/src/generated/zod/postgres-outputs-schema.ts

@@ -0,0 +1,17 @@
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+
+import * as z from "zod";
+
+/**
+ * @description Outputs generated by a successfully provisioned Postgres database.
+ */
+export const PostgresOutputsSchema = z.object({
+    "database": z.string().describe("The default database created for this resource. On cloud backends this is the fixed\nlabel `POSTGRES_DATABASE_NAME` (`alien`); on Local it is the resource id."),
+"endpoint": z.string().describe("Host (or host:port) the database listens on; never publicly reachable."),
+"port": z.int().min(0).describe("Listening port, when known.").nullish()
+    }).describe("Outputs generated by a successfully provisioned Postgres database.")
+
+export type PostgresOutputs = z.infer<typeof PostgresOutputsSchema>

package/src/generated/zod/postgres-schema.ts

@@ -0,0 +1,24 @@
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+
+import * as z from "zod";
+import { PostgresBackendSchema } from "./postgres-backend-schema.js";
+
+/**
+ * @description A managed PostgreSQL database. The target platform decides the backend\n(AWS Aurora Serverless v2, GCP Cloud SQL, Azure Flexible Server, or an\nembedded native process on Local); the database is never publicly reachable.
+ */
+export const PostgresSchema = z.object({
+    get "backend"(){
+                return z.union([PostgresBackendSchema, z.null()]).optional()
+              },
+"cpu": z.string().describe("Requested vCPUs (e.g. \"0.5\", \"2\"). None = smallest available tier.").nullish(),
+"highAvailability": z.optional(z.boolean().describe("Multi-AZ / regional / zone-redundant high availability. Default false.")),
+"id": z.string(),
+"memory": z.string().describe("Requested memory (e.g. \"1Gi\", \"8Gi\"). None = smallest available tier.").nullish(),
+"storage": z.optional(z.string().default("20Gi").describe("Allocated storage (e.g. \"20Gi\"). Default \"20Gi\". Grow-only.")),
+"version": z.optional(z.string().default("17").describe("Major engine version: \"15\" | \"16\" | \"17\". Default \"17\"."))
+    }).describe("A managed PostgreSQL database. The target platform decides the backend\n(AWS Aurora Serverless v2, GCP Cloud SQL, Azure Flexible Server, or an\nembedded native process on Local); the database is never publicly reachable.")
+
+export type Postgres = z.infer<typeof PostgresSchema>

package/src/generated/zod/public-endpoint-target-settings-schema.ts

@@ -0,0 +1,18 @@
+/**
+* Generated by Kubb (https://kubb.dev/).
+* Do not edit manually.
+*/
+
+import * as z from "zod";
+
+/**
+ * @description DNS target mode for public endpoints.
+ */
+export const PublicEndpointTargetSettingsSchema = z.union([z.object({
+    "mode": z.enum(["machineAddresses"])
+    }), z.object({
+    "cnameTarget": z.string().describe("DNS name or URL for the external load balancer."),
+"mode": z.enum(["loadBalancer"])
+    })]).describe("DNS target mode for public endpoints.")
+
+export type PublicEndpointTargetSettings = z.infer<typeof PublicEndpointTargetSettingsSchema>

package/src/generated/zod/resource-heartbeat-data-schema.ts

@@ -16,6 +16,7 @@ import { DaemonHeartbeatDataSchema } from "./daemon-heartbeat-data-schema.js";
 import { KubernetesClusterHeartbeatDataSchema } from "./kubernetes-cluster-heartbeat-data-schema.js";
 import { KvHeartbeatDataSchema } from "./kv-heartbeat-data-schema.js";
 import { NetworkHeartbeatDataSchema } from "./network-heartbeat-data-schema.js";
+import { PostgresHeartbeatDataSchema } from "./postgres-heartbeat-data-schema.js";
 import { QueueHeartbeatDataSchema } from "./queue-heartbeat-data-schema.js";
 import { RemoteStackManagementHeartbeatDataSchema } from "./remote-stack-management-heartbeat-data-schema.js";
 import { ServiceAccountHeartbeatDataSchema } from "./service-account-heartbeat-data-schema.js";
@@ -64,6 +65,11 @@ export const ResourceHeartbeatDataSchema = z.union([z.object({
                 return KvHeartbeatDataSchema
               },
 "resourceType": z.enum(["kv"])
+    }), z.object({
+    get "data"(){
+                return PostgresHeartbeatDataSchema
+              },
+"resourceType": z.enum(["postgres"])
     }), z.object({
     get "data"(){
                 return VaultHeartbeatDataSchema

package/src/generated/zod/resource-heartbeat-schema.ts

@@ -25,7 +25,7 @@ get "data"(){
 get "raw"(){
                 return z.array(RawHeartbeatSnippetSchema)
               },
-"resourceId": z.string(),
+"resourceId": z.string().describe("Alien resource id, such as the `alien.Container` or `alien.Storage`\nresource id from the stack."),
 get "resourceType"(){
                 return ResourceTypeSchema.describe("Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.")
               }

package/src/index.ts

@@ -8,6 +8,7 @@ export * from "./build.js"
 export * from "./artifact-registry.js"
 export * from "./vault.js"
 export * from "./kv.js"
+export * from "./postgres.js"
 export * from "./queue.js"
 export * from "./service-account.js"
 export * from "./stack.js"
@@ -29,6 +30,8 @@ export {
   HeartbeatsModeSchema,
   ResourceHeartbeatSchema,
   ResourceHeartbeatDataSchema,
+  ObservedInventoryBatchSchema,
+  ObservedResourceSampleSchema,
   HeartbeatBackendSchema,
   HeartbeatIssueSeveritySchema,
   KubernetesEventSnapshotSchema,
@@ -240,6 +243,8 @@ export type {
   HeartbeatsMode,
   ResourceHeartbeat,
   ResourceHeartbeatData,
+  ObservedInventoryBatch,
+  ObservedResourceSample,
   HeartbeatBackend,
   HeartbeatIssueSeverity,
   KubernetesEventSnapshot,

package/src/postgres.ts

@@ -0,0 +1,107 @@
+import {
+  type Postgres as PostgresConfig,
+  PostgresSchema,
+  type ResourceType,
+} from "./generated/index.js"
+import { Resource } from "./resource.js"
+
+export type { Postgres as PostgresConfig, PostgresOutputs } from "./generated/index.js"
+export { PostgresSchema as PostgresConfigSchema } from "./generated/index.js"
+
+/**
+ * Represents a managed PostgreSQL database. The target platform decides the backend;
+ * the database is private and reachable only by same-stack workloads.
+ */
+export class Postgres {
+  private _config: Partial<PostgresConfig> = {
+    version: "17",
+    storage: "20Gi",
+    highAvailability: false,
+  }
+
+  /**
+   * Creates a new Postgres builder.
+   * @param id ID of the database. A database of this name is created on the server.
+   */
+  constructor(id: string) {
+    this._config.id = id
+  }
+
+  /**
+   * Returns a ResourceType representing any postgres resource.
+   * Used for creating permission targets that apply to all postgres resources.
+   * @returns The "postgres" resource type.
+   */
+  public static any(): ResourceType {
+    return "postgres"
+  }
+
+  /**
+   * Sets the major engine version ("15" | "16" | "17"). Default `"17"`.
+   * The union narrows the generated schema's free-form string for authoring ergonomics;
+   * keep it in sync with the supported majors if the Rust `Postgres` resource adds one.
+   * @param value The major version.
+   * @returns The Postgres builder instance.
+   */
+  public version(value: "15" | "16" | "17"): this {
+    this._config.version = value
+    return this
+  }
+
+  /**
+   * Requests vCPUs (e.g. "0.5", "2"). On GCP and Azure, `cpu` and `memory` together pick the
+   * smallest tier that satisfies both. On AWS (Aurora Serverless v2) sizing comes from `memory`, so
+   * `cpu` is ignored.
+   * @param value The requested vCPUs.
+   * @returns The Postgres builder instance.
+   */
+  public cpu(value: string): this {
+    this._config.cpu = value
+    return this
+  }
+
+  /**
+   * Requests memory (e.g. "1Gi", "8Gi"). Drives the size on AWS (the ACU ceiling) and, together
+   * with `cpu`, the tier on GCP and Azure.
+   * @param value The requested memory.
+   * @returns The Postgres builder instance.
+   */
+  public memory(value: string): this {
+    this._config.memory = value
+    return this
+  }
+
+  /**
+   * Sets allocated storage (e.g. "100Gi"). Default `"20Gi"`. Grow-only.
+   * @param value The storage size.
+   * @returns The Postgres builder instance.
+   */
+  public storage(value: string): this {
+    this._config.storage = value
+    return this
+  }
+
+  /**
+   * Enables multi-AZ / regional / zone-redundant high availability. Default `false`.
+   * @param value Whether to enable HA.
+   * @returns The Postgres builder instance.
+   */
+  public highAvailability(value = true): this {
+    this._config.highAvailability = value
+    return this
+  }
+
+  /**
+   * Builds and validates the postgres configuration.
+   * @returns An immutable Resource representing the configured database.
+   * @throws Error if the configuration is invalid.
+   */
+  public build(): Resource {
+    const config = PostgresSchema.parse(this._config)
+
+    return new Resource({
+      type: "postgres",
+      ...config,
+    })
+  }
+}