typekro 0.4.0 → 0.7.0

package/dist/factories/valkey/compositions/valkey-bootstrap.js

@@ -0,0 +1,105 @@
+import { kubernetesComposition } from '../../../core/composition/imperative.js';
+import { DEFAULT_FLUX_NAMESPACE } from '../../../core/config/defaults.js';
+import { Cel } from '../../../core/references/cel.js';
+import { namespace } from '../../kubernetes/core/namespace.js';
+import { DEFAULT_VALKEY_REPO_NAME, DEFAULT_VALKEY_VERSION, valkeyHelmRelease, valkeyHelmRepository, } from '../resources/helm.js';
+import { ValkeyBootstrapConfigSchema, ValkeyBootstrapStatusSchema, } from '../types.js';
+import { mapValkeyConfigToHelmValues } from '../utils/helm-values-mapper.js';
+/**
+ * Strips the '-chart' suffix from a Hyperspike version tag for labeling.
+ * The Helm chart version (e.g. 'v0.0.61-chart') differs from the app version
+ * ('v0.0.61'). Labels should use the app version per k8s well-known labels spec.
+ */
+function stripChartSuffix(version) {
+    return version.replace(/-chart$/, '');
+}
+/**
+ * Hyperspike Valkey Operator Bootstrap Composition
+ *
+ * Deploys the Hyperspike Valkey operator via HelmRepository and HelmRelease.
+ * The operator manages Valkey clusters as Kubernetes-native resources.
+ *
+ * This composition:
+ * 1. Creates the target namespace
+ * 2. Creates a HelmRepository pointing to the Hyperspike OCI registry
+ * 3. Creates a HelmRelease that installs the operator
+ *
+ * After the operator is running, use the `valkey()` factory to create
+ * Valkey cluster resources.
+ *
+ * @example
+ * ```typescript
+ * // 'kro' = KRO mode (continuous reconciliation via ResourceGraphDefinition)
+ * // 'direct' = Direct mode (immediate apply, no KRO controller needed)
+ * const factory = valkeyBootstrap.factory('kro', {
+ *   namespace: 'valkey-operator-system',
+ *   waitForReady: true,
+ * });
+ *
+ * await factory.deploy({
+ *   name: 'valkey-operator',
+ *   namespace: 'valkey-operator-system',
+ * });
+ * ```
+ */
+export const valkeyBootstrap = kubernetesComposition({
+    name: 'valkey-bootstrap',
+    kind: 'ValkeyBootstrap',
+    spec: ValkeyBootstrapConfigSchema,
+    status: ValkeyBootstrapStatusSchema,
+}, (spec) => {
+    const resolvedNamespace = spec.namespace || 'valkey-operator-system';
+    const resolvedVersion = spec.version || DEFAULT_VALKEY_VERSION;
+    const appVersion = stripChartSuffix(resolvedVersion);
+    const helmValues = mapValkeyConfigToHelmValues({
+        ...spec,
+        namespace: resolvedNamespace,
+        version: resolvedVersion,
+    });
+    // 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 _valkeyNamespace = namespace({
+        metadata: {
+            name: resolvedNamespace,
+            labels: {
+                'app.kubernetes.io/name': 'valkey-operator',
+                'app.kubernetes.io/instance': spec.name,
+                'app.kubernetes.io/version': appVersion,
+                'app.kubernetes.io/managed-by': 'typekro',
+            },
+        },
+        id: 'valkeyNamespace',
+    });
+    // OCI HelmRepositories don't have status in Flux, which can cause the deploy
+    // engine to block waiting for readiness. Create both resources but don't depend
+    // on the repository readiness — Flux handles the OCI → chart resolution internally.
+    const _helmRepository = valkeyHelmRepository({
+        name: DEFAULT_VALKEY_REPO_NAME,
+        namespace: DEFAULT_FLUX_NAMESPACE,
+        id: 'valkeyHelmRepository',
+    });
+    const _helmRelease = valkeyHelmRelease({
+        name: spec.name,
+        namespace: resolvedNamespace,
+        version: resolvedVersion,
+        values: helmValues,
+        repositoryName: DEFAULT_VALKEY_REPO_NAME,
+        id: 'valkeyHelmRelease',
+    });
+    // Status derived from HelmRelease conditions.
+    return {
+        ready: Cel.expr(_helmRelease.status.conditions, '.exists(c, c.type == "Ready" && c.status == "True")'),
+        // Phase cannot distinguish Failed from Installing due to a CEL evaluator
+        // limitation (#48). Use the `failed` field for failure detection.
+        phase: Cel.expr(_helmRelease.status.conditions, '.exists(c, c.type == "Ready" && c.status == "True") ? "Ready" : "Installing"'),
+        // Separate failed boolean — workaround for the nested CEL ternary limitation.
+        // True when the Ready condition is explicitly False (not just absent/Unknown).
+        failed: Cel.expr(_helmRelease.status.conditions, '.exists(c, c.type == "Ready" && c.status == "False")'),
+        // Static version from deploy-time config, not derived from live HelmRelease
+        // status. If the operator is upgraded out-of-band (e.g. Flux automation),
+        // this value will not reflect the running version.
+        version: appVersion,
+    };
+});
+//# sourceMappingURL=valkey-bootstrap.js.map

package/dist/factories/valkey/compositions/valkey-bootstrap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"valkey-bootstrap.js","sourceRoot":"","sources":["../../../../src/factories/valkey/compositions/valkey-bootstrap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,yCAAyC,CAAC;AAChF,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,EAAE,GAAG,EAAE,MAAM,iCAAiC,CAAC;AACtD,OAAO,EAAE,SAAS,EAAE,MAAM,oCAAoC,CAAC;AAC/D,OAAO,EACL,wBAAwB,EACxB,sBAAsB,EACtB,iBAAiB,EACjB,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAEL,2BAA2B,EAC3B,2BAA2B,GAC5B,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,2BAA2B,EAAE,MAAM,gCAAgC,CAAC;AAE7E;;;;GAIG;AACH,SAAS,gBAAgB,CAAC,OAAe;IACvC,OAAO,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;AACxC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,qBAAqB,CAClD;IACE,IAAI,EAAE,kBAAkB;IACxB,IAAI,EAAE,iBAAiB;IACvB,IAAI,EAAE,2BAA2B;IACjC,MAAM,EAAE,2BAA2B;CACpC,EACD,CAAC,IAA2B,EAAE,EAAE;IAC9B,MAAM,iBAAiB,GAAG,IAAI,CAAC,SAAS,IAAI,wBAAwB,CAAC;IACrE,MAAM,eAAe,GAAG,IAAI,CAAC,OAAO,IAAI,sBAAsB,CAAC;IAC/D,MAAM,UAAU,GAAG,gBAAgB,CAAC,eAAe,CAAC,CAAC;IAErD,MAAM,UAAU,GAAG,2BAA2B,CAAC;QAC7C,GAAG,IAAI;QACP,SAAS,EAAE,iBAAiB;QAC5B,OAAO,EAAE,eAAe;KACzB,CAAC,CAAC;IAEH,8EAA8E;IAC9E,gFAAgF;IAChF,0DAA0D;IAC1D,MAAM,gBAAgB,GAAG,SAAS,CAAC;QACjC,QAAQ,EAAE;YACR,IAAI,EAAE,iBAAiB;YACvB,MAAM,EAAE;gBACN,wBAAwB,EAAE,iBAAiB;gBAC3C,4BAA4B,EAAE,IAAI,CAAC,IAAI;gBACvC,2BAA2B,EAAE,UAAU;gBACvC,8BAA8B,EAAE,SAAS;aAC1C;SACF;QACD,EAAE,EAAE,iBAAiB;KACtB,CAAC,CAAC;IAEH,6EAA6E;IAC7E,gFAAgF;IAChF,oFAAoF;IACpF,MAAM,eAAe,GAAG,oBAAoB,CAAC;QAC3C,IAAI,EAAE,wBAAwB;QAC9B,SAAS,EAAE,sBAAsB;QACjC,EAAE,EAAE,sBAAsB;KAC3B,CAAC,CAAC;IAEH,MAAM,YAAY,GAAG,iBAAiB,CAAC;QACrC,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,SAAS,EAAE,iBAAiB;QAC5B,OAAO,EAAE,eAAe;QACxB,MAAM,EAAE,UAAU;QAClB,cAAc,EAAE,wBAAwB;QACxC,EAAE,EAAE,mBAAmB;KACxB,CAAC,CAAC;IAEH,8CAA8C;IAC9C,OAAO;QACL,KAAK,EAAE,GAAG,CAAC,IAAI,CACb,YAAY,CAAC,MAAM,CAAC,UAAU,EAC9B,qDAAqD,CACtD;QACD,yEAAyE;QACzE,kEAAkE;QAClE,KAAK,EAAE,GAAG,CAAC,IAAI,CACb,YAAY,CAAC,MAAM,CAAC,UAAU,EAC9B,8EAA8E,CAC/E;QACD,8EAA8E;QAC9E,+EAA+E;QAC/E,MAAM,EAAE,GAAG,CAAC,IAAI,CACd,YAAY,CAAC,MAAM,CAAC,UAAU,EAC9B,sDAAsD,CACvD;QACD,4EAA4E;QAC5E,0EAA0E;QAC1E,mDAAmD;QACnD,OAAO,EAAE,UAAU;KACpB,CAAC;AACJ,CAAC,CACF,CAAC"}

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

@@ -0,0 +1,50 @@
+/**
+ * Hyperspike Valkey Operator Integration for TypeKro
+ *
+ * Provides type-safe factories for managing Valkey clusters on Kubernetes
+ * using the Hyperspike Valkey operator.
+ *
+ * ## Resources
+ * - `valkey()` — Valkey cluster (sharded with optional replicas)
+ * - `valkeyHelmRepository()` — Helm chart repository (OCI)
+ * - `valkeyHelmRelease()` — Operator installation via Helm
+ *
+ * ## Compositions
+ * - `valkeyBootstrap` — Complete operator deployment (namespace + Helm repo + release)
+ *
+ * @example
+ * ```typescript
+ * import { valkeyBootstrap, valkey } from 'typekro/valkey';
+ *
+ * // Install the operator
+ * const operatorFactory = valkeyBootstrap.factory('kro', {
+ *   namespace: 'valkey-operator-system',
+ * });
+ * await operatorFactory.deploy({
+ *   name: 'valkey-operator',
+ *   namespace: 'valkey-operator-system',
+ * });
+ *
+ * // Create a Valkey cluster
+ * const cache = valkey({
+ *   name: 'app-cache',
+ *   namespace: 'default',
+ *   spec: {
+ *     shards: 3,
+ *     replicas: 1,
+ *     storage: {
+ *       resources: { requests: { storage: '10Gi' } },
+ *     },
+ *   },
+ *   id: 'appCache',
+ * });
+ * ```
+ *
+ * @see https://github.com/hyperspike/valkey-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/valkey/index.d.ts.map

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

package/dist/factories/valkey/index.js

@@ -0,0 +1,50 @@
+/**
+ * Hyperspike Valkey Operator Integration for TypeKro
+ *
+ * Provides type-safe factories for managing Valkey clusters on Kubernetes
+ * using the Hyperspike Valkey operator.
+ *
+ * ## Resources
+ * - `valkey()` — Valkey cluster (sharded with optional replicas)
+ * - `valkeyHelmRepository()` — Helm chart repository (OCI)
+ * - `valkeyHelmRelease()` — Operator installation via Helm
+ *
+ * ## Compositions
+ * - `valkeyBootstrap` — Complete operator deployment (namespace + Helm repo + release)
+ *
+ * @example
+ * ```typescript
+ * import { valkeyBootstrap, valkey } from 'typekro/valkey';
+ *
+ * // Install the operator
+ * const operatorFactory = valkeyBootstrap.factory('kro', {
+ *   namespace: 'valkey-operator-system',
+ * });
+ * await operatorFactory.deploy({
+ *   name: 'valkey-operator',
+ *   namespace: 'valkey-operator-system',
+ * });
+ *
+ * // Create a Valkey cluster
+ * const cache = valkey({
+ *   name: 'app-cache',
+ *   namespace: 'default',
+ *   spec: {
+ *     shards: 3,
+ *     replicas: 1,
+ *     storage: {
+ *       resources: { requests: { storage: '10Gi' } },
+ *     },
+ *   },
+ *   id: 'appCache',
+ * });
+ * ```
+ *
+ * @see https://github.com/hyperspike/valkey-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/valkey/index.js.map

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

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

@@ -0,0 +1,53 @@
+/**
+ * Hyperspike Valkey Operator Helm Resource Factories
+ *
+ * Wrappers around the generic Helm factories with Valkey-specific defaults.
+ * Used by the valkeyBootstrap composition to install the operator.
+ *
+ * Note: The Hyperspike operator uses an OCI registry (ghcr.io), not a
+ * traditional Helm chart repository. Flux HelmRepository supports OCI
+ * via `type: oci` in the spec.
+ */
+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 { ValkeyHelmReleaseConfig, ValkeyHelmRepositoryConfig } from '../types.js';
+/** Default OCI registry URL for the Hyperspike charts. */
+export declare const DEFAULT_VALKEY_REPO_URL = "oci://ghcr.io/hyperspike";
+/** Default chart version (Hyperspike uses 'v{version}-chart' tag format). */
+export declare const DEFAULT_VALKEY_VERSION = "v0.0.61-chart";
+/** Default HelmRepository resource name. */
+export declare const DEFAULT_VALKEY_REPO_NAME = "valkey-operator-repo";
+/**
+ * Create a HelmRepository for the Hyperspike Valkey operator OCI registry.
+ *
+ * @param config - Repository configuration with Valkey-specific defaults
+ * @returns Enhanced HelmRepository resource
+ *
+ * @example
+ * ```typescript
+ * const repo = valkeyHelmRepository({
+ *   name: 'valkey-operator-repo',
+ *   namespace: 'flux-system',
+ *   id: 'valkeyHelmRepository',
+ * });
+ * ```
+ */
+export declare function valkeyHelmRepository(config: Composable<ValkeyHelmRepositoryConfig>): Enhanced<HelmRepositorySpec, HelmRepositoryStatus>;
+/**
+ * Create a HelmRelease for the Hyperspike Valkey operator.
+ *
+ * @param config - Release configuration with Valkey-specific defaults
+ * @returns Enhanced HelmRelease resource
+ *
+ * @example
+ * ```typescript
+ * const release = valkeyHelmRelease({
+ *   name: 'valkey-operator',
+ *   namespace: 'valkey-operator-system',
+ *   id: 'valkeyHelmRelease',
+ * });
+ * ```
+ */
+export declare function valkeyHelmRelease(config: Composable<ValkeyHelmReleaseConfig>): Enhanced<HelmReleaseSpec, HelmReleaseStatus>;
+//# sourceMappingURL=helm.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"helm.d.ts","sourceRoot":"","sources":["../../../../src/factories/valkey/resources/helm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AACzE,OAAO,EAGL,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EAC1B,MAAM,+BAA+B,CAAC;AAEvC,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE9E,OAAO,KAAK,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC;AAEvF,0DAA0D;AAC1D,eAAO,MAAM,uBAAuB,6BAA6B,CAAC;AAElE,6EAA6E;AAC7E,eAAO,MAAM,sBAAsB,kBAAkB,CAAC;AAEtD,4CAA4C;AAC5C,eAAO,MAAM,wBAAwB,yBAAyB,CAAC;AAE/D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,UAAU,CAAC,0BAA0B,CAAC,GAC7C,QAAQ,CAAC,kBAAkB,EAAE,oBAAoB,CAAC,CAWpD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,UAAU,CAAC,uBAAuB,CAAC,GAC1C,QAAQ,CAAC,eAAe,EAAE,iBAAiB,CAAC,CAuB9C"}

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

@@ -0,0 +1,82 @@
+/**
+ * Hyperspike Valkey Operator Helm Resource Factories
+ *
+ * Wrappers around the generic Helm factories with Valkey-specific defaults.
+ * Used by the valkeyBootstrap composition to install the operator.
+ *
+ * Note: The Hyperspike operator uses an OCI registry (ghcr.io), not a
+ * traditional Helm chart repository. Flux HelmRepository supports OCI
+ * via `type: oci` in the spec.
+ */
+import { DEFAULT_FLUX_NAMESPACE } from '../../../core/config/defaults.js';
+import { createHelmRepositoryReadinessEvaluator, helmRepository, } from '../../helm/helm-repository.js';
+import { createLabeledHelmReleaseEvaluator } from '../../helm/readiness-evaluators.js';
+import { helmRelease } from '../../helm/helm-release.js';
+/** Default OCI registry URL for the Hyperspike charts. */
+export const DEFAULT_VALKEY_REPO_URL = 'oci://ghcr.io/hyperspike';
+/** Default chart version (Hyperspike uses 'v{version}-chart' tag format). */
+export const DEFAULT_VALKEY_VERSION = 'v0.0.61-chart';
+/** Default HelmRepository resource name. */
+export const DEFAULT_VALKEY_REPO_NAME = 'valkey-operator-repo';
+/**
+ * Create a HelmRepository for the Hyperspike Valkey operator OCI registry.
+ *
+ * @param config - Repository configuration with Valkey-specific defaults
+ * @returns Enhanced HelmRepository resource
+ *
+ * @example
+ * ```typescript
+ * const repo = valkeyHelmRepository({
+ *   name: 'valkey-operator-repo',
+ *   namespace: 'flux-system',
+ *   id: 'valkeyHelmRepository',
+ * });
+ * ```
+ */
+export function valkeyHelmRepository(config) {
+    return helmRepository({
+        name: config.name || DEFAULT_VALKEY_REPO_NAME,
+        namespace: config.namespace || DEFAULT_FLUX_NAMESPACE,
+        url: config.url || DEFAULT_VALKEY_REPO_URL,
+        type: 'oci',
+        interval: config.interval || '5m',
+        ...(config.id && { id: config.id }),
+    }).withReadinessEvaluator(createHelmRepositoryReadinessEvaluator('Valkey'));
+}
+/**
+ * Create a HelmRelease for the Hyperspike Valkey operator.
+ *
+ * @param config - Release configuration with Valkey-specific defaults
+ * @returns Enhanced HelmRelease resource
+ *
+ * @example
+ * ```typescript
+ * const release = valkeyHelmRelease({
+ *   name: 'valkey-operator',
+ *   namespace: 'valkey-operator-system',
+ *   id: 'valkeyHelmRelease',
+ * });
+ * ```
+ */
+export function valkeyHelmRelease(config) {
+    // Pass values directly — the core proxy system handles serialization.
+    // chart.repository is used for chart identification; sourceRef is what Flux
+    // actually uses to resolve the chart. Both are required by the helmRelease factory.
+    return helmRelease({
+        name: config.name,
+        namespace: config.namespace || 'valkey-operator-system',
+        chart: {
+            repository: DEFAULT_VALKEY_REPO_URL,
+            name: 'valkey-operator',
+            version: config.version || DEFAULT_VALKEY_VERSION,
+        },
+        sourceRef: {
+            name: config.repositoryName || DEFAULT_VALKEY_REPO_NAME,
+            namespace: DEFAULT_FLUX_NAMESPACE,
+            kind: 'HelmRepository',
+        },
+        values: config.values || {},
+        ...(config.id && { id: config.id }),
+    }).withReadinessEvaluator(createLabeledHelmReleaseEvaluator('Valkey'));
+}
+//# sourceMappingURL=helm.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"helm.js","sourceRoot":"","sources":["../../../../src/factories/valkey/resources/helm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAE1E,OAAO,EACL,sCAAsC,EACtC,cAAc,GAGf,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,iCAAiC,EAAE,MAAM,oCAAoC,CAAC;AAEvF,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAGzD,0DAA0D;AAC1D,MAAM,CAAC,MAAM,uBAAuB,GAAG,0BAA0B,CAAC;AAElE,6EAA6E;AAC7E,MAAM,CAAC,MAAM,sBAAsB,GAAG,eAAe,CAAC;AAEtD,4CAA4C;AAC5C,MAAM,CAAC,MAAM,wBAAwB,GAAG,sBAAsB,CAAC;AAE/D;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,oBAAoB,CAClC,MAA8C;IAE9C,OAAO,cAAc,CAAC;QACpB,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,wBAAwB;QAC7C,SAAS,EAAE,MAAM,CAAC,SAAS,IAAI,sBAAsB;QACrD,GAAG,EAAE,MAAM,CAAC,GAAG,IAAI,uBAAuB;QAC1C,IAAI,EAAE,KAAK;QACX,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,QAAQ,CAAC,CACK,CAAC;AAC1D,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,iBAAiB,CAC/B,MAA2C;IAE3C,sEAAsE;IAEtE,4EAA4E;IAC5E,oFAAoF;IACpF,OAAO,WAAW,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC,IAAI;QACjB,SAAS,EAAE,MAAM,CAAC,SAAS,IAAI,wBAAwB;QACvD,KAAK,EAAE;YACL,UAAU,EAAE,uBAAuB;YACnC,IAAI,EAAE,iBAAiB;YACvB,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,sBAAsB;SAClD;QACD,SAAS,EAAE;YACT,IAAI,EAAE,MAAM,CAAC,cAAc,IAAI,wBAAwB;YACvD,SAAS,EAAE,sBAAsB;YACjC,IAAI,EAAE,gBAAgB;SACvB;QACD,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,QAAQ,CAAC,CACI,CAAC;AACpD,CAAC"}

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

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

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

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

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

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

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

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

package/dist/factories/valkey/resources/valkey.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Hyperspike Valkey Cluster Factory
+ *
+ * Creates a Valkey CRD resource representing a Valkey cluster
+ * managed by the Hyperspike operator.
+ */
+import type { Composable, Enhanced } from '../../../core/types/index.js';
+import type { ValkeyConfig, ValkeyStatus } from '../types.js';
+/**
+ * Hyperspike Valkey Cluster Factory
+ *
+ * Creates a Valkey cluster managed by the Hyperspike operator. Supports
+ * sharded clusters with optional replication, TLS, external access via
+ * Envoy proxy or LoadBalancer, and Prometheus monitoring.
+ *
+ * @param config - Valkey cluster configuration following hyperspike.io/v1 API
+ * @returns Enhanced Valkey resource with readiness evaluation
+ *
+ * @example
+ * ```typescript
+ * const cache = valkey({
+ *   name: 'app-cache',
+ *   namespace: 'default',
+ *   spec: {
+ *     shards: 3,
+ *     replicas: 1,
+ *     storage: {
+ *       spec: {
+ *         storageClassName: 'gp3',
+ *         resources: { requests: { storage: '10Gi' } },
+ *       },
+ *     },
+ *     resources: {
+ *       requests: { cpu: '250m', memory: '512Mi' },
+ *       limits: { cpu: '1', memory: '2Gi' },
+ *     },
+ *     prometheus: true,
+ *   },
+ *   id: 'appCache',
+ * });
+ * ```
+ */
+declare function createValkeyResource(config: Composable<ValkeyConfig>): Enhanced<ValkeyConfig['spec'], ValkeyStatus>;
+export declare const valkey: typeof createValkeyResource;
+export {};
+//# sourceMappingURL=valkey.d.ts.map

package/dist/factories/valkey/resources/valkey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valkey.d.ts","sourceRoot":"","sources":["../../../../src/factories/valkey/resources/valkey.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAkB,MAAM,8BAA8B,CAAC;AAEzF,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAsD9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,iBAAS,oBAAoB,CAC3B,MAAM,EAAE,UAAU,CAAC,YAAY,CAAC,GAC/B,QAAQ,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC,CAsC9C;AAED,eAAO,MAAM,MAAM,6BAAuB,CAAC"}

package/dist/factories/valkey/resources/valkey.js

@@ -0,0 +1,123 @@
+/**
+ * Hyperspike Valkey Cluster Factory
+ *
+ * Creates a Valkey CRD resource representing a Valkey cluster
+ * managed by the Hyperspike operator.
+ */
+import { createConditionBasedReadinessEvaluator } from '../../../core/readiness/index.js';
+import { createResource } from '../../shared.js';
+/** Base condition-based evaluator for Valkey Ready condition. */
+const baseValkeyEvaluator = createConditionBasedReadinessEvaluator({ kind: 'Valkey' });
+/**
+ * Valkey Readiness Evaluator
+ *
+ * Checks the standard Ready condition first. If status has a top-level
+ * `ready` boolean (Hyperspike pattern), uses that as a fast path.
+ * Falls back to condition-based evaluation for detailed state.
+ */
+function valkeyReadinessEvaluator(liveResource) {
+    const resource = liveResource;
+    const status = resource?.status;
+    if (!status) {
+        return {
+            ready: false,
+            message: 'Valkey cluster has no status yet',
+            reason: 'StatusMissing',
+        };
+    }
+    // Fast path: Hyperspike reports a top-level ready boolean
+    if (status.ready === true) {
+        return {
+            ready: true,
+            message: 'Valkey cluster is ready',
+            reason: 'Ready',
+        };
+    }
+    if (status.ready === false) {
+        // Check conditions for a more specific reason
+        const readyCondition = status.conditions?.find((c) => c.type === 'Ready');
+        if (readyCondition) {
+            return {
+                ready: false,
+                message: readyCondition.message || 'Valkey cluster is not ready',
+                reason: readyCondition.reason || 'NotReady',
+            };
+        }
+        return {
+            ready: false,
+            message: 'Valkey cluster is not ready',
+            reason: 'NotReady',
+        };
+    }
+    // Fall back to condition-based evaluation
+    return baseValkeyEvaluator(liveResource);
+}
+/**
+ * Hyperspike Valkey Cluster Factory
+ *
+ * Creates a Valkey cluster managed by the Hyperspike operator. Supports
+ * sharded clusters with optional replication, TLS, external access via
+ * Envoy proxy or LoadBalancer, and Prometheus monitoring.
+ *
+ * @param config - Valkey cluster configuration following hyperspike.io/v1 API
+ * @returns Enhanced Valkey resource with readiness evaluation
+ *
+ * @example
+ * ```typescript
+ * const cache = valkey({
+ *   name: 'app-cache',
+ *   namespace: 'default',
+ *   spec: {
+ *     shards: 3,
+ *     replicas: 1,
+ *     storage: {
+ *       spec: {
+ *         storageClassName: 'gp3',
+ *         resources: { requests: { storage: '10Gi' } },
+ *       },
+ *     },
+ *     resources: {
+ *       requests: { cpu: '250m', memory: '512Mi' },
+ *       limits: { cpu: '1', memory: '2Gi' },
+ *     },
+ *     prometheus: true,
+ *   },
+ *   id: 'appCache',
+ * });
+ * ```
+ */
+function createValkeyResource(config) {
+    // Map the user-facing `shards` field to the CRD's `nodes` JSON tag.
+    // The Hyperspike CRD Go type uses `Nodes int32 \`json:"nodes"\``
+    // but we expose it as `shards` for clarity.
+    const spec = config.spec;
+    const crdSpec = {};
+    for (const [key, value] of Object.entries(spec)) {
+        if (key === 'shards') {
+            crdSpec.nodes = value;
+        }
+        else {
+            crdSpec[key] = value;
+        }
+    }
+    return createResource({
+        apiVersion: 'hyperspike.io/v1',
+        kind: 'Valkey',
+        metadata: {
+            name: config.name,
+            ...(config.namespace && { namespace: config.namespace }),
+            // Labels must be non-empty: the Hyperspike operator's labels() function
+            // panics on nil map assignment when metadata.labels is absent.
+            // https://github.com/hyperspike/valkey-operator/blob/v0.0.61/internal/controller/valkey_controller.go#L250
+            labels: {
+                'app.kubernetes.io/name': 'valkey',
+                'app.kubernetes.io/instance': config.name,
+                'app.kubernetes.io/managed-by': 'typekro',
+            },
+        },
+        spec: crdSpec,
+        ...(config.id && { id: config.id }),
+    }, { scope: 'namespaced' }).withReadinessEvaluator(valkeyReadinessEvaluator);
+}
+export const valkey = createValkeyResource;
+//# sourceMappingURL=valkey.js.map

package/dist/factories/valkey/resources/valkey.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"valkey.js","sourceRoot":"","sources":["../../../../src/factories/valkey/resources/valkey.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,sCAAsC,EAAE,MAAM,kCAAkC,CAAC;AAE1F,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGjD,iEAAiE;AACjE,MAAM,mBAAmB,GAAG,sCAAsC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;AAEvF;;;;;;GAMG;AACH,SAAS,wBAAwB,CAAC,YAAqB;IACrD,MAAM,QAAQ,GAAG,YAA4D,CAAC;IAC9E,MAAM,MAAM,GAAG,QAAQ,EAAE,MAAM,CAAC;IAEhC,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,OAAO;YACL,KAAK,EAAE,KAAK;YACZ,OAAO,EAAE,kCAAkC;YAC3C,MAAM,EAAE,eAAe;SACxB,CAAC;IACJ,CAAC;IAED,0DAA0D;IAC1D,IAAI,MAAM,CAAC,KAAK,KAAK,IAAI,EAAE,CAAC;QAC1B,OAAO;YACL,KAAK,EAAE,IAAI;YACX,OAAO,EAAE,yBAAyB;YAClC,MAAM,EAAE,OAAO;SAChB,CAAC;IACJ,CAAC;IAED,IAAI,MAAM,CAAC,KAAK,KAAK,KAAK,EAAE,CAAC;QAC3B,8CAA8C;QAC9C,MAAM,cAAc,GAAG,MAAM,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC;QAC1E,IAAI,cAAc,EAAE,CAAC;YACnB,OAAO;gBACL,KAAK,EAAE,KAAK;gBACZ,OAAO,EAAE,cAAc,CAAC,OAAO,IAAI,6BAA6B;gBAChE,MAAM,EAAE,cAAc,CAAC,MAAM,IAAI,UAAU;aAC5C,CAAC;QACJ,CAAC;QACD,OAAO;YACL,KAAK,EAAE,KAAK;YACZ,OAAO,EAAE,6BAA6B;YACtC,MAAM,EAAE,UAAU;SACnB,CAAC;IACJ,CAAC;IAED,0CAA0C;IAC1C,OAAO,mBAAmB,CAAC,YAAY,CAAC,CAAC;AAC3C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,SAAS,oBAAoB,CAC3B,MAAgC;IAEhC,oEAAoE;IACpE,iEAAiE;IACjE,4CAA4C;IAC5C,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;IACzB,MAAM,OAAO,GAA4B,EAAE,CAAC;IAC5C,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QAChD,IAAI,GAAG,KAAK,QAAQ,EAAE,CAAC;YACrB,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC;QACxB,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;QACvB,CAAC;IACH,CAAC;IAED,OAAO,cAAc,CACnB;QACE,UAAU,EAAE,kBAAkB;QAC9B,IAAI,EAAE,QAAQ;QACd,QAAQ,EAAE;YACR,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,GAAG,CAAC,MAAM,CAAC,SAAS,IAAI,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,CAAC;YACxD,wEAAwE;YACxE,+DAA+D;YAC/D,2GAA2G;YAC3G,MAAM,EAAE;gBACN,wBAAwB,EAAE,QAAQ;gBAClC,4BAA4B,EAAE,MAAM,CAAC,IAAI;gBACzC,8BAA8B,EAAE,SAAS;aAC1C;SACF;QACD,IAAI,EAAE,OAAsB;QAC5B,GAAG,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC;KACpC,EACD,EAAE,KAAK,EAAE,YAAY,EAAE,CACxB,CAAC,sBAAsB,CAAC,wBAAwB,CAGhD,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,MAAM,MAAM,GAAG,oBAAoB,CAAC"}