typekro 0.22.1 → 0.24.0

package/dist/factories/clickhouse/compositions/clickhouse-operator-bootstrap.js

@@ -0,0 +1,137 @@
+import { kubernetesComposition } from '../../../core/composition/imperative.js';
+import { DEFAULT_FLUX_NAMESPACE } from '../../../core/config/defaults.js';
+import { setMetadataField } from '../../../core/metadata/index.js';
+import { Cel } from '../../../core/references/cel.js';
+import { singleton } from '../../../core/singleton/singleton.js';
+import { namespace } from '../../kubernetes/core/namespace.js';
+import { clickhouseOperatorHelmRelease, DEFAULT_CLICKHOUSE_OPERATOR_VERSION, DEFAULT_CLICKHOUSE_REPO_NAME, DEFAULT_CLICKHOUSE_REPO_URL, } from '../resources/helm.js';
+import { ClickHouseOperatorBootstrapConfigSchema, ClickHouseOperatorBootstrapStatusSchema, } from '../types.js';
+import { mapClickHouseOperatorConfigToHelmValues } from '../utils/helm-values-mapper.js';
+import { clickhouseHelmRepositoryBootstrap } from './clickhouse-helm-repository.js';
+/**
+ * Altinity clickhouse-operator Bootstrap Composition
+ *
+ * Deploys the OFFICIAL Altinity clickhouse-operator via HelmRepository and
+ * HelmRelease resources (chart `altinity-clickhouse-operator` 0.27.x from
+ * https://helm.altinity.com, Apache-2.0). Build-around: we wrap the official
+ * chart — never hand-rolled operator manifests.
+ *
+ * IMPORTANT — ONE OPERATOR PER CLUSTER: the operator is cluster-scoped and
+ * owns the ClickHouse CRDs (`clickhouseinstallations`,
+ * `clickhouseinstallationtemplates`, `clickhouseoperatorconfigurations` under
+ * `clickhouse.altinity.com/v1`; `clickhousekeeperinstallations` under
+ * `clickhouse-keeper.altinity.com/v1`). Install it exactly once; every
+ * `clickHouseInstallation()`/`clickHouseKeeperInstallation()` in the cluster
+ * is reconciled by that single install. The default `shared: true` tags the
+ * operator resources with `scopes: ['cluster']` so instance deletion leaves
+ * the shared operator intact.
+ *
+ * This composition:
+ * 1. Creates the target namespace
+ * 2. References the shared Altinity HelmRepository singleton
+ * 3. Creates a HelmRelease that installs the operator
+ *
+ * After the operator is running, use `clickHouseInstallation()` and
+ * `clickHouseKeeperInstallation()` to create ClickHouse resources.
+ *
+ * @example
+ * ```typescript
+ * const operatorFactory = clickhouseOperatorBootstrap.factory('kro', {
+ *   namespace: 'clickhouse-system',
+ *   waitForReady: true,
+ * });
+ *
+ * await operatorFactory.deploy({
+ *   name: 'clickhouse-operator',
+ *   namespace: 'clickhouse-system',
+ *   version: '0.27.1',
+ * });
+ * ```
+ */
+export const clickhouseOperatorBootstrap = kubernetesComposition({
+    name: 'clickhouse-operator-bootstrap',
+    kind: 'ClickHouseOperatorBootstrap',
+    spec: ClickHouseOperatorBootstrapConfigSchema,
+    status: ClickHouseOperatorBootstrapStatusSchema,
+}, (spec) => {
+    const resolvedNamespace = spec.namespace || 'clickhouse-system';
+    const resolvedVersion = spec.version || DEFAULT_CLICKHOUSE_OPERATOR_VERSION;
+    // Default to shared-lifecycle: the operator is one-per-cluster
+    // infrastructure (it owns the CRDs) and must survive individual consumer
+    // instance deletions. `shared: false` exists only for throwaway
+    // environments such as kind-cluster integration tests.
+    const isShared = spec.shared !== false;
+    // Map config to Helm values (metrics.enabled / crdHook.enabled /
+    // operator resources + customValues merged LAST). Fields are passed
+    // EXPLICITLY — spreading the schema proxy (`...spec`) enumerates proxy
+    // keys and leaks `__typekroSchemaKey` markers into the rendered values.
+    // In kro mode `spec.customValues` is a schema ref, so the mapper routes
+    // it through the graph-aware runtime values merge and the override map
+    // lands in the serialized HelmRelease values.
+    const helmValues = mapClickHouseOperatorConfigToHelmValues({
+        metrics: spec.metrics,
+        crdHook: spec.crdHook,
+        resources: spec.resources,
+        customValues: spec.customValues,
+    });
+    // Resources are _-prefixed because they're registered via side effects in
+    // the kubernetesComposition callback — the composition captures them
+    // automatically. They're referenced in the status return via their `id`.
+    const _clickhouseNamespace = namespace({
+        metadata: {
+            name: resolvedNamespace,
+            labels: {
+                'app.kubernetes.io/name': 'altinity-clickhouse-operator',
+                'app.kubernetes.io/instance': spec.name,
+                'app.kubernetes.io/version': resolvedVersion,
+                'app.kubernetes.io/managed-by': 'typekro',
+            },
+        },
+        id: 'clickhouseNamespace',
+    });
+    // The Altinity chart repository is one cluster-level Flux source shared
+    // by every consumer, so deploy it once via singleton(...) with a fixed
+    // identity (same rationale as the Dagster bootstrap: inlining it would
+    // make each instance's KRO ApplySet try to own the HelmRepository
+    // exclusively, breaking a second instance with an ApplySet reassignment
+    // error). The HelmRelease references the shared repository by the
+    // official `sourceRef` defaults.
+    const _clickhouseHelmRepository = singleton(clickhouseHelmRepositoryBootstrap, {
+        id: 'clickhouse-helm-repository',
+        spec: {
+            name: DEFAULT_CLICKHOUSE_REPO_NAME,
+            namespace: DEFAULT_FLUX_NAMESPACE,
+            url: DEFAULT_CLICKHOUSE_REPO_URL,
+        },
+    });
+    // Create HelmRelease for the operator itself.
+    const _helmRelease = clickhouseOperatorHelmRelease({
+        name: spec.name,
+        namespace: resolvedNamespace,
+        version: resolvedVersion,
+        values: helmValues,
+        id: 'clickhouseOperatorHelmRelease',
+    });
+    // Tag resources with 'cluster' scope so factory-level deleteInstance
+    // leaves the shared operator install intact for other consumers. Callers
+    // can explicitly tear down shared infra with
+    // `deleteInstance(name, { scopes: ['cluster'] })`.
+    if (isShared) {
+        setMetadataField(_clickhouseNamespace, 'scopes', ['cluster']);
+        setMetadataField(_helmRelease, 'scopes', ['cluster']);
+    }
+    // Status derived from HelmRelease conditions.
+    // Flux HelmRelease v2 uses conditions with type='Ready' for readiness;
+    // the release does not set `disableWait`, so helm-controller waits for
+    // the chart's workloads before reporting Ready (readiness is
+    // workload-aware, mirroring the cnpg/dagster bootstraps).
+    return {
+        ready: Cel.expr(_helmRelease.status.conditions, '.exists(c, c.type == "Ready" && c.status == "True")'),
+        // Two-state phase: nested ternaries with .exists() require repeating the
+        // full resource path in CEL, which Cel.expr(ref, operator) cannot
+        // express (same constraint as the cnpg bootstrap).
+        phase: Cel.expr(_helmRelease.status.conditions, '.exists(c, c.type == "Ready" && c.status == "True") ? "Ready" : "Installing"'),
+        version: resolvedVersion,
+    };
+});
+//# sourceMappingURL=clickhouse-operator-bootstrap.js.map

package/dist/factories/clickhouse/compositions/clickhouse-operator-bootstrap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clickhouse-operator-bootstrap.js","sourceRoot":"","sources":["../../../../src/factories/clickhouse/compositions/clickhouse-operator-bootstrap.ts"],"names":[],"mappings":"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"}

package/dist/factories/clickhouse/compositions/index.d.ts

@@ -0,0 +1,4 @@
+export { CLICKHOUSE_DEFAULT_DATABASE, CLICKHOUSE_HTTP_PORT, CLICKHOUSE_KEEPER_PORT, CLICKHOUSE_NATIVE_PORT, clickHouseCluster, DEFAULT_USER_NETWORKS_IP, makeClickHouseCluster, } from './clickhouse-cluster.js';
+export { clickhouseHelmRepositoryBootstrap } from './clickhouse-helm-repository.js';
+export { clickhouseOperatorBootstrap } from './clickhouse-operator-bootstrap.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/factories/clickhouse/compositions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/factories/clickhouse/compositions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,EAC3B,oBAAoB,EACpB,sBAAsB,EACtB,sBAAsB,EACtB,iBAAiB,EACjB,wBAAwB,EACxB,qBAAqB,GACtB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,iCAAiC,EAAE,MAAM,iCAAiC,CAAC;AACpF,OAAO,EAAE,2BAA2B,EAAE,MAAM,oCAAoC,CAAC"}

package/dist/factories/clickhouse/compositions/index.js

@@ -0,0 +1,4 @@
+export { CLICKHOUSE_DEFAULT_DATABASE, CLICKHOUSE_HTTP_PORT, CLICKHOUSE_KEEPER_PORT, CLICKHOUSE_NATIVE_PORT, clickHouseCluster, DEFAULT_USER_NETWORKS_IP, makeClickHouseCluster, } from './clickhouse-cluster.js';
+export { clickhouseHelmRepositoryBootstrap } from './clickhouse-helm-repository.js';
+export { clickhouseOperatorBootstrap } from './clickhouse-operator-bootstrap.js';
+//# sourceMappingURL=index.js.map

package/dist/factories/clickhouse/compositions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/factories/clickhouse/compositions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,EAC3B,oBAAoB,EACpB,sBAAsB,EACtB,sBAAsB,EACtB,iBAAiB,EACjB,wBAAwB,EACxB,qBAAqB,GACtB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,iCAAiC,EAAE,MAAM,iCAAiC,CAAC;AACpF,OAAO,EAAE,2BAA2B,EAAE,MAAM,oCAAoC,CAAC"}

package/dist/factories/clickhouse/index.d.ts

@@ -0,0 +1,70 @@
+/**
+ * ClickHouse (Altinity clickhouse-operator) Integration for TypeKro
+ *
+ * Provides type-safe factories for managing ClickHouse clusters on Kubernetes
+ * using the OFFICIAL Altinity clickhouse-operator (build-around: the official
+ * `altinity-clickhouse-operator` chart from https://helm.altinity.com,
+ * Apache-2.0 — never hand-rolled manifests).
+ *
+ * ONE OPERATOR PER CLUSTER: the operator is cluster-scoped and owns the
+ * ClickHouse CRDs; install exactly one `clickhouseOperatorBootstrap` per
+ * cluster and point every CHI/CHK at it.
+ *
+ * BUILD-TIME vs RUNTIME: topology (`zones`/`replicas`/`shards`/keeper
+ * presence/user names) is fixed at CONSTRUCTION time via
+ * `makeClickHouseCluster(topology)`; everything else (name, namespace,
+ * version, storage, credentials, keeper host) is proxy-safe RUNTIME spec.
+ *
+ * ## Compositions
+ * - `makeClickHouseCluster(topology)` — build-time topology constructor;
+ *   returns a composition whose runtime spec is fully schema-ref safe and
+ *   whose status exposes the typed connection contract
+ * - `clickHouseCluster` — the default single-node topology
+ * - `clickhouseOperatorBootstrap` — complete operator deployment
+ *   (namespace + shared Helm repo singleton + release)
+ * - `clickhouseHelmRepositoryBootstrap` — shared HelmRepository singleton owner
+ *
+ * ## Resources
+ * - `clickHouseInstallation()` — LOW-LEVEL typed CHI (concrete topology only;
+ *   zone-pinned replica layout, SigNoz-compatible `cluster` name default)
+ * - `clickHouseKeeperInstallation()` — typed CHK (coordination service)
+ * - `clickhouseHelmRepository()` — Altinity Helm chart repository
+ * - `clickhouseOperatorHelmRelease()` — operator installation via Helm
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   clickhouseOperatorBootstrap,
+ *   makeClickHouseCluster,
+ * } from 'typekro/clickhouse';
+ *
+ * // Install the operator (once per cluster)
+ * const operatorFactory = clickhouseOperatorBootstrap.factory('kro', {
+ *   namespace: 'clickhouse-system',
+ * });
+ * await operatorFactory.deploy({ name: 'clickhouse-operator' });
+ *
+ * // Fix the topology at construction, deploy with runtime spec
+ * const clickhouse = makeClickHouseCluster({
+ *   zones: ['us-east-2a', 'us-east-2b'],
+ *   replicas: 2,
+ *   users: [{ name: 'signoz' }],
+ * });
+ * await clickhouse.factory('kro', { namespace: 'observability' }).deploy({
+ *   name: 'signoz-clickhouse',
+ *   namespace: 'observability',
+ *   version: '25.12.5',
+ *   storage: { size: '100Gi', storageClassName: 'gp3-expandable' },
+ *   keeper: { host: 'keeper-signoz.observability.svc.cluster.local' },
+ *   users: { signoz: { passwordSha256Hex: '<sha256-hex>' } },
+ * });
+ * ```
+ *
+ * @see https://github.com/Altinity/clickhouse-operator
+ * @module
+ */
+export * from './compositions/index.js';
+export * from './resources/index.js';
+export * from './types.js';
+export * from './utils/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/factories/clickhouse/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/factories/clickhouse/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC"}

package/dist/factories/clickhouse/index.js

@@ -0,0 +1,70 @@
+/**
+ * ClickHouse (Altinity clickhouse-operator) Integration for TypeKro
+ *
+ * Provides type-safe factories for managing ClickHouse clusters on Kubernetes
+ * using the OFFICIAL Altinity clickhouse-operator (build-around: the official
+ * `altinity-clickhouse-operator` chart from https://helm.altinity.com,
+ * Apache-2.0 — never hand-rolled manifests).
+ *
+ * ONE OPERATOR PER CLUSTER: the operator is cluster-scoped and owns the
+ * ClickHouse CRDs; install exactly one `clickhouseOperatorBootstrap` per
+ * cluster and point every CHI/CHK at it.
+ *
+ * BUILD-TIME vs RUNTIME: topology (`zones`/`replicas`/`shards`/keeper
+ * presence/user names) is fixed at CONSTRUCTION time via
+ * `makeClickHouseCluster(topology)`; everything else (name, namespace,
+ * version, storage, credentials, keeper host) is proxy-safe RUNTIME spec.
+ *
+ * ## Compositions
+ * - `makeClickHouseCluster(topology)` — build-time topology constructor;
+ *   returns a composition whose runtime spec is fully schema-ref safe and
+ *   whose status exposes the typed connection contract
+ * - `clickHouseCluster` — the default single-node topology
+ * - `clickhouseOperatorBootstrap` — complete operator deployment
+ *   (namespace + shared Helm repo singleton + release)
+ * - `clickhouseHelmRepositoryBootstrap` — shared HelmRepository singleton owner
+ *
+ * ## Resources
+ * - `clickHouseInstallation()` — LOW-LEVEL typed CHI (concrete topology only;
+ *   zone-pinned replica layout, SigNoz-compatible `cluster` name default)
+ * - `clickHouseKeeperInstallation()` — typed CHK (coordination service)
+ * - `clickhouseHelmRepository()` — Altinity Helm chart repository
+ * - `clickhouseOperatorHelmRelease()` — operator installation via Helm
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   clickhouseOperatorBootstrap,
+ *   makeClickHouseCluster,
+ * } from 'typekro/clickhouse';
+ *
+ * // Install the operator (once per cluster)
+ * const operatorFactory = clickhouseOperatorBootstrap.factory('kro', {
+ *   namespace: 'clickhouse-system',
+ * });
+ * await operatorFactory.deploy({ name: 'clickhouse-operator' });
+ *
+ * // Fix the topology at construction, deploy with runtime spec
+ * const clickhouse = makeClickHouseCluster({
+ *   zones: ['us-east-2a', 'us-east-2b'],
+ *   replicas: 2,
+ *   users: [{ name: 'signoz' }],
+ * });
+ * await clickhouse.factory('kro', { namespace: 'observability' }).deploy({
+ *   name: 'signoz-clickhouse',
+ *   namespace: 'observability',
+ *   version: '25.12.5',
+ *   storage: { size: '100Gi', storageClassName: 'gp3-expandable' },
+ *   keeper: { host: 'keeper-signoz.observability.svc.cluster.local' },
+ *   users: { signoz: { passwordSha256Hex: '<sha256-hex>' } },
+ * });
+ * ```
+ *
+ * @see https://github.com/Altinity/clickhouse-operator
+ * @module
+ */
+export * from './compositions/index.js';
+export * from './resources/index.js';
+export * from './types.js';
+export * from './utils/index.js';
+//# sourceMappingURL=index.js.map

package/dist/factories/clickhouse/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/factories/clickhouse/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC"}

package/dist/factories/clickhouse/resources/helm.d.ts

@@ -0,0 +1,62 @@
+/**
+ * ClickHouse Operator Helm Resource Factories
+ *
+ * Wrappers around the generic Helm factories with Altinity-specific defaults.
+ * Used by the `clickhouseOperatorBootstrap` composition to install the
+ * OFFICIAL Altinity clickhouse-operator (build-around: we wrap the official
+ * chart rather than hand-rolling operator manifests).
+ *
+ * Chart: `altinity-clickhouse-operator` from https://helm.altinity.com
+ * (Apache-2.0). The operator is cluster-scoped and owns the ClickHouse CRDs —
+ * exactly ONE install per cluster.
+ */
+import type { Composable, Enhanced } from '../../../core/types/index.js';
+import { type HelmRepositorySpec, type HelmRepositoryStatus } from '../../helm/helm-repository.js';
+import type { HelmReleaseSpec, HelmReleaseStatus } from '../../helm/types.js';
+import type { ClickHouseHelmRepositoryConfig, ClickHouseOperatorHelmReleaseConfig } from '../types.js';
+/** Official Altinity Helm chart repository URL. */
+export declare const DEFAULT_CLICKHOUSE_REPO_URL = "https://helm.altinity.com";
+/** Default Flux HelmRepository name for the Altinity chart repository. */
+export declare const DEFAULT_CLICKHOUSE_REPO_NAME = "altinity";
+/** Official operator chart name. */
+export declare const CLICKHOUSE_OPERATOR_CHART_NAME = "altinity-clickhouse-operator";
+/** Default altinity-clickhouse-operator chart version. */
+export declare const DEFAULT_CLICKHOUSE_OPERATOR_VERSION = "0.27.1";
+/**
+ * Create a Flux HelmRepository for the official Altinity chart repository.
+ *
+ * @param config - Repository configuration with Altinity defaults
+ * @returns Enhanced HelmRepository resource
+ *
+ * @example
+ * ```typescript
+ * const repo = clickhouseHelmRepository({
+ *   name: 'altinity',
+ *   namespace: 'flux-system',
+ *   id: 'clickhouseHelmRepository',
+ * });
+ * ```
+ */
+export declare function clickhouseHelmRepository(config: Composable<ClickHouseHelmRepositoryConfig>): Enhanced<HelmRepositorySpec, HelmRepositoryStatus>;
+/**
+ * Create a Flux HelmRelease for the Altinity clickhouse-operator.
+ *
+ * IMPORTANT: the operator owns the ClickHouse CRDs and watches cluster-wide —
+ * install exactly ONE release per cluster (enforced by convention via the
+ * `shared` default in `clickhouseOperatorBootstrap`).
+ *
+ * @param config - Release configuration with Altinity defaults
+ * @returns Enhanced HelmRelease resource
+ *
+ * @example
+ * ```typescript
+ * const release = clickhouseOperatorHelmRelease({
+ *   name: 'clickhouse-operator',
+ *   namespace: 'clickhouse-system',
+ *   version: '0.27.1',
+ *   id: 'clickhouseOperatorHelmRelease',
+ * });
+ * ```
+ */
+export declare function clickhouseOperatorHelmRelease(config: Composable<ClickHouseOperatorHelmReleaseConfig>): Enhanced<HelmReleaseSpec, HelmReleaseStatus>;
+//# sourceMappingURL=helm.d.ts.map

package/dist/factories/clickhouse/resources/helm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helm.d.ts","sourceRoot":"","sources":["../../../../src/factories/clickhouse/resources/helm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAEzE,OAAO,EAGL,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EAC1B,MAAM,+BAA+B,CAAC;AAEvC,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC9E,OAAO,KAAK,EACV,8BAA8B,EAC9B,mCAAmC,EACpC,MAAM,aAAa,CAAC;AAErB,mDAAmD;AACnD,eAAO,MAAM,2BAA2B,8BAA8B,CAAC;AAEvE,0EAA0E;AAC1E,eAAO,MAAM,4BAA4B,aAAa,CAAC;AAEvD,oCAAoC;AACpC,eAAO,MAAM,8BAA8B,iCAAiC,CAAC;AAE7E,0DAA0D;AAC1D,eAAO,MAAM,mCAAmC,WAAW,CAAC;AAE5D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,UAAU,CAAC,8BAA8B,CAAC,GACjD,QAAQ,CAAC,kBAAkB,EAAE,oBAAoB,CAAC,CAgBpD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,UAAU,CAAC,mCAAmC,CAAC,GACtD,QAAQ,CAAC,eAAe,EAAE,iBAAiB,CAAC,CAqB9C"}

package/dist/factories/clickhouse/resources/helm.js

@@ -0,0 +1,94 @@
+/**
+ * ClickHouse Operator Helm Resource Factories
+ *
+ * Wrappers around the generic Helm factories with Altinity-specific defaults.
+ * Used by the `clickhouseOperatorBootstrap` composition to install the
+ * OFFICIAL Altinity clickhouse-operator (build-around: we wrap the official
+ * chart rather than hand-rolling operator manifests).
+ *
+ * Chart: `altinity-clickhouse-operator` from https://helm.altinity.com
+ * (Apache-2.0). The operator is cluster-scoped and owns the ClickHouse CRDs —
+ * exactly ONE install per cluster.
+ */
+import { DEFAULT_FLUX_NAMESPACE } from '../../../core/config/defaults.js';
+import { setMetadataField } from '../../../core/metadata/resource-metadata.js';
+import { helmRelease } from '../../helm/helm-release.js';
+import { createHelmRepositoryReadinessEvaluator, helmRepository, } from '../../helm/helm-repository.js';
+import { createLabeledHelmReleaseEvaluator } from '../../helm/readiness-evaluators.js';
+/** Official Altinity Helm chart repository URL. */
+export const DEFAULT_CLICKHOUSE_REPO_URL = 'https://helm.altinity.com';
+/** Default Flux HelmRepository name for the Altinity chart repository. */
+export const DEFAULT_CLICKHOUSE_REPO_NAME = 'altinity';
+/** Official operator chart name. */
+export const CLICKHOUSE_OPERATOR_CHART_NAME = 'altinity-clickhouse-operator';
+/** Default altinity-clickhouse-operator chart version. */
+export const DEFAULT_CLICKHOUSE_OPERATOR_VERSION = '0.27.1';
+/**
+ * Create a Flux HelmRepository for the official Altinity chart repository.
+ *
+ * @param config - Repository configuration with Altinity defaults
+ * @returns Enhanced HelmRepository resource
+ *
+ * @example
+ * ```typescript
+ * const repo = clickhouseHelmRepository({
+ *   name: 'altinity',
+ *   namespace: 'flux-system',
+ *   id: 'clickhouseHelmRepository',
+ * });
+ * ```
+ */
+export function clickhouseHelmRepository(config) {
+    const repo = helmRepository({
+        name: config.name || DEFAULT_CLICKHOUSE_REPO_NAME,
+        namespace: config.namespace || DEFAULT_FLUX_NAMESPACE,
+        url: config.url || DEFAULT_CLICKHOUSE_REPO_URL,
+        interval: config.interval || '5m',
+        ...(config.id && { id: config.id }),
+    }).withReadinessEvaluator(createHelmRepositoryReadinessEvaluator('ClickHouse'));
+    // The chart repository is one cluster-level Flux source shared by every
+    // consumer — never torn down with an individual instance.
+    setMetadataField(repo, 'scopes', ['cluster']);
+    return repo;
+}
+/**
+ * Create a Flux HelmRelease for the Altinity clickhouse-operator.
+ *
+ * IMPORTANT: the operator owns the ClickHouse CRDs and watches cluster-wide —
+ * install exactly ONE release per cluster (enforced by convention via the
+ * `shared` default in `clickhouseOperatorBootstrap`).
+ *
+ * @param config - Release configuration with Altinity defaults
+ * @returns Enhanced HelmRelease resource
+ *
+ * @example
+ * ```typescript
+ * const release = clickhouseOperatorHelmRelease({
+ *   name: 'clickhouse-operator',
+ *   namespace: 'clickhouse-system',
+ *   version: '0.27.1',
+ *   id: 'clickhouseOperatorHelmRelease',
+ * });
+ * ```
+ */
+export function clickhouseOperatorHelmRelease(config) {
+    // Pass values directly — the core proxy system handles serialization.
+    return helmRelease({
+        name: config.name,
+        namespace: config.namespace || 'clickhouse-system',
+        chart: {
+            repository: DEFAULT_CLICKHOUSE_REPO_URL,
+            name: CLICKHOUSE_OPERATOR_CHART_NAME,
+            version: config.version || DEFAULT_CLICKHOUSE_OPERATOR_VERSION,
+        },
+        sourceRef: {
+            name: config.repositoryName || DEFAULT_CLICKHOUSE_REPO_NAME,
+            namespace: DEFAULT_FLUX_NAMESPACE,
+            kind: 'HelmRepository',
+        },
+        driftDetection: { mode: 'enabled' },
+        values: config.values || {},
+        ...(config.id && { id: config.id }),
+    }).withReadinessEvaluator(createLabeledHelmReleaseEvaluator('ClickHouse'));
+}
+//# sourceMappingURL=helm.js.map

package/dist/factories/clickhouse/resources/helm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helm.js","sourceRoot":"","sources":["../../../../src/factories/clickhouse/resources/helm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,EAAE,gBAAgB,EAAE,MAAM,6CAA6C,CAAC;AAE/E,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EACL,sCAAsC,EACtC,cAAc,GAGf,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,iCAAiC,EAAE,MAAM,oCAAoC,CAAC;AAOvF,mDAAmD;AACnD,MAAM,CAAC,MAAM,2BAA2B,GAAG,2BAA2B,CAAC;AAEvE,0EAA0E;AAC1E,MAAM,CAAC,MAAM,4BAA4B,GAAG,UAAU,CAAC;AAEvD,oCAAoC;AACpC,MAAM,CAAC,MAAM,8BAA8B,GAAG,8BAA8B,CAAC;AAE7E,0DAA0D;AAC1D,MAAM,CAAC,MAAM,mCAAmC,GAAG,QAAQ,CAAC;AAE5D;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,wBAAwB,CACtC,MAAkD;IAElD,MAAM,IAAI,GAAG,cAAc,CAAC;QAC1B,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,4BAA4B;QACjD,SAAS,EAAE,MAAM,CAAC,SAAS,IAAI,sBAAsB;QACrD,GAAG,EAAE,MAAM,CAAC,GAAG,IAAI,2BAA2B;QAC9C,QAAQ,EAAE,MAAM,CAAC,QAAQ,IAAI,IAAI;QACjC,GAAG,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC;KACpC,CAAC,CAAC,sBAAsB,CACvB,sCAAsC,CAAC,YAAY,CAAC,CACC,CAAC;IAExD,wEAAwE;IACxE,0DAA0D;IAC1D,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC;IAE9C,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,6BAA6B,CAC3C,MAAuD;IAEvD,sEAAsE;IACtE,OAAO,WAAW,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC,IAAI;QACjB,SAAS,EAAE,MAAM,CAAC,SAAS,IAAI,mBAAmB;QAClD,KAAK,EAAE;YACL,UAAU,EAAE,2BAA2B;YACvC,IAAI,EAAE,8BAA8B;YACpC,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,mCAAmC;SAC/D;QACD,SAAS,EAAE;YACT,IAAI,EAAE,MAAM,CAAC,cAAc,IAAI,4BAA4B;YAC3D,SAAS,EAAE,sBAAsB;YACjC,IAAI,EAAE,gBAAgB;SACvB;QACD,cAAc,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE;QACnC,MAAM,EAAE,MAAM,CAAC,MAAM,IAAI,EAAE;QAC3B,GAAG,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC;KACpC,CAAC,CAAC,sBAAsB,CACvB,iCAAiC,CAAC,YAAY,CAAC,CACA,CAAC;AACpD,CAAC"}

package/dist/factories/clickhouse/resources/index.d.ts

@@ -0,0 +1,4 @@
+export * from './helm.js';
+export * from './installation.js';
+export * from './keeper.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/factories/clickhouse/resources/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/factories/clickhouse/resources/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC"}

package/dist/factories/clickhouse/resources/index.js

@@ -0,0 +1,4 @@
+export * from './helm.js';
+export * from './installation.js';
+export * from './keeper.js';
+//# sourceMappingURL=index.js.map

package/dist/factories/clickhouse/resources/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/factories/clickhouse/resources/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC"}

package/dist/factories/clickhouse/resources/installation.d.ts

@@ -0,0 +1,83 @@
+/**
+ * ClickHouseInstallation (CHI) Factory
+ *
+ * Compiles a high-level typed config into a `clickhouse.altinity.com/v1`
+ * ClickHouseInstallation managed by the Altinity clickhouse-operator.
+ *
+ * THE POINT of this typed factory is the zone-pinned layout: the operator's
+ * `podDistribution` supports only the `kubernetes.io/hostname` topologyKey
+ * (Altinity/clickhouse-operator#772), so per-zone spreading must be compiled
+ * as a per-replica `layout.replicas:` list with zone-pinned pod templates.
+ * On EKS, EBS volumes are zonal — a replica rescheduled into another AZ
+ * strands its PVC (production incident) — so `zones` should be set for any
+ * multi-replica production CHI.
+ *
+ * CHI shape follows the official examples
+ * (docs/chi-examples/01-simple-layout-01-1shard-1repl.yaml and
+ * 14-zones-distribution-01.yaml in the operator repo).
+ */
+import type { Composable, Enhanced, ResourceStatus } from '../../../core/types/index.js';
+import type { ClickHouseInstallationConfig, ClickHouseInstallationSpec, ClickHouseInstallationStatus } from '../types.js';
+/**
+ * Known CHI/CHK reconcile status strings.
+ *
+ * Source: clickhouse-operator `pkg/apis/clickhouse.altinity.com/v1/type_status.go`
+ * (StatusInProgress/StatusCompleted/StatusAborted/StatusTerminating). The
+ * operator writes them to `status.status`; `Completed` means the installation
+ * is fully reconciled.
+ */
+export declare const CHI_STATUS: {
+    readonly IN_PROGRESS: "InProgress";
+    readonly COMPLETED: "Completed";
+    readonly ABORTED: "Aborted";
+    readonly TERMINATING: "Terminating";
+};
+/**
+ * CHI/CHK Readiness Evaluator
+ *
+ * Keys off the operator-reported `status.status` reconcile state (see
+ * CHI_STATUS). Unlike condition-based CRDs, the clickhouse-operator reports a
+ * single status string plus host progress counters.
+ */
+export declare function chiReadinessEvaluator(liveResource: unknown): ResourceStatus;
+/**
+ * Default logical cluster name.
+ *
+ * SIGNOZ COMPATIBILITY: SigNoz's ClickHouse migrations hardcode the cluster
+ * name `cluster`, so a CHI consumed by SigNoz MUST keep this default.
+ */
+export declare const DEFAULT_CHI_CLUSTER_NAME = "cluster";
+/**
+ * ClickHouseInstallation Factory (LOW-LEVEL, concrete topology)
+ *
+ * Creates a ClickHouse cluster managed by the Altinity clickhouse-operator.
+ *
+ * BUILD-TIME topology fields (`shards`, `replicas`, `zones`, user names) must
+ * be concrete JS values — the factory throws loudly if any receives a schema
+ * reference (the compiler enumerates templates/replica entries from them).
+ * Prefer `makeClickHouseCluster()` in compositions: it fixes the topology at
+ * construction time and exposes only proxy-safe runtime spec.
+ *
+ * @param config - High-level installation configuration
+ * @returns Enhanced ClickHouseInstallation resource with readiness evaluation
+ *
+ * @example
+ * ```typescript
+ * const chi = clickHouseInstallation({
+ *   name: 'signoz-clickhouse',
+ *   namespace: 'observability',
+ *   version: '25.12.5',                     // SigNoz-coupled server version
+ *   shards: 1,
+ *   replicas: 2,
+ *   zones: ['us-east-2a', 'us-east-2b'],    // zone-pinned replicas (EBS is zonal)
+ *   storage: { size: '100Gi', storageClassName: 'gp3-expandable' },
+ *   users: [{ name: 'signoz', passwordSha256Hex: '...', networksIp: ['::/0'] }],
+ *   keeper: { host: 'keeper-signoz.observability.svc.cluster.local' },
+ *   id: 'signozClickhouse',
+ * });
+ * ```
+ */
+declare function createClickHouseInstallationResource(config: Composable<ClickHouseInstallationConfig>): Enhanced<ClickHouseInstallationSpec, ClickHouseInstallationStatus>;
+export declare const clickHouseInstallation: typeof createClickHouseInstallationResource;
+export {};
+//# sourceMappingURL=installation.d.ts.map

package/dist/factories/clickhouse/resources/installation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"installation.d.ts","sourceRoot":"","sources":["../../../../src/factories/clickhouse/resources/installation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAGzF,OAAO,KAAK,EAEV,4BAA4B,EAC5B,0BAA0B,EAC1B,4BAA4B,EAC7B,MAAM,aAAa,CAAC;AAIrB;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU;;;;;CAKb,CAAC;AAEX;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,OAAO,GAAG,cAAc,CAoD3E;AAKD;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,YAAY,CAAC;AA6LlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,iBAAS,oCAAoC,CAC3C,MAAM,EAAE,UAAU,CAAC,4BAA4B,CAAC,GAC/C,QAAQ,CAAC,0BAA0B,EAAE,4BAA4B,CAAC,CAmBpE;AAED,eAAO,MAAM,sBAAsB,6CAAuC,CAAC"}