@flui-cloud/cli 0.0.1

package/lib/src/modules/infrastructure/clusters/entities/cluster.entity.js

@@ -0,0 +1,199 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterEntity = exports.ClusterType = exports.ClusterStatus = void 0;
+const typeorm_1 = require("typeorm");
+const uuid_1 = require("uuid");
+const cluster_node_entity_1 = require("./cluster-node.entity");
+const hostname_mode_enum_1 = require("../../../dns/enums/hostname-mode.enum");
+var ClusterStatus;
+(function (ClusterStatus) {
+    ClusterStatus["CREATING"] = "creating";
+    ClusterStatus["READY"] = "ready";
+    ClusterStatus["SCALING"] = "scaling";
+    ClusterStatus["STOPPED"] = "stopped";
+    ClusterStatus["ERROR"] = "error";
+    ClusterStatus["DELETING"] = "deleting";
+    ClusterStatus["DELETION_FAILED"] = "deletion_failed";
+    ClusterStatus["DELETED"] = "deleted";
+})(ClusterStatus || (exports.ClusterStatus = ClusterStatus = {}));
+var ClusterType;
+(function (ClusterType) {
+    ClusterType["OBSERVABILITY"] = "observability";
+    ClusterType["WORKLOAD"] = "workload";
+})(ClusterType || (exports.ClusterType = ClusterType = {}));
+let ClusterEntity = class ClusterEntity {
+    generateId() {
+        if (!this.id) {
+            this.id = (0, uuid_1.v4)();
+        }
+    }
+};
+exports.ClusterEntity = ClusterEntity;
+__decorate([
+    (0, typeorm_1.PrimaryColumn)('uuid'),
+    __metadata("design:type", String)
+], ClusterEntity.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.BeforeInsert)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], ClusterEntity.prototype, "generateId", null);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], ClusterEntity.prototype, "name", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], ClusterEntity.prototype, "provider", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], ClusterEntity.prototype, "region", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], ClusterEntity.prototype, "nodeSize", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', default: 0 }),
+    __metadata("design:type", Number)
+], ClusterEntity.prototype, "nodeCount", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ default: false }),
+    __metadata("design:type", Boolean)
+], ClusterEntity.prototype, "autoscalingEnabled", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: true }),
+    __metadata("design:type", Number)
+], ClusterEntity.prototype, "minNodes", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: true }),
+    __metadata("design:type", Number)
+], ClusterEntity.prototype, "maxNodes", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: true }),
+    __metadata("design:type", Number)
+], ClusterEntity.prototype, "scaleUpMemoryPct", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: true }),
+    __metadata("design:type", Number)
+], ClusterEntity.prototype, "scaleUpCpuPct", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: true }),
+    __metadata("design:type", Number)
+], ClusterEntity.prototype, "cooldownSeconds", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'text' }),
+    __metadata("design:type", String)
+], ClusterEntity.prototype, "k3sTokenEncrypted", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], ClusterEntity.prototype, "k3sVersion", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], ClusterEntity.prototype, "masterNodeId", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], ClusterEntity.prototype, "masterIpAddress", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], ClusterEntity.prototype, "masterPrivateIp", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'boolean', default: true }),
+    __metadata("design:type", Boolean)
+], ClusterEntity.prototype, "sharedStorageEnabled", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', nullable: true }),
+    __metadata("design:type", String)
+], ClusterEntity.prototype, "sharedStorageVolumeId", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: true }),
+    __metadata("design:type", Number)
+], ClusterEntity.prototype, "sharedStorageVolumeSizeGb", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'text', nullable: true }),
+    __metadata("design:type", String)
+], ClusterEntity.prototype, "kubeconfigEncrypted", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'enum',
+        enum: ClusterStatus,
+        default: ClusterStatus.CREATING,
+    }),
+    __metadata("design:type", String)
+], ClusterEntity.prototype, "status", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'enum',
+        enum: ClusterType,
+        default: ClusterType.WORKLOAD,
+    }),
+    __metadata("design:type", String)
+], ClusterEntity.prototype, "clusterType", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'enum',
+        enum: hostname_mode_enum_1.HostnameMode,
+        default: hostname_mode_enum_1.HostnameMode.IP,
+    }),
+    __metadata("design:type", String)
+], ClusterEntity.prototype, "endpointHostnameMode", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', length: 30, nullable: true }),
+    __metadata("design:type", String)
+], ClusterEntity.prototype, "nipHostnameToken", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'json', default: '{}' }),
+    __metadata("design:type", Object)
+], ClusterEntity.prototype, "metadata", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'json', nullable: true }),
+    __metadata("design:type", Array)
+], ClusterEntity.prototype, "sshKeyIds", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], ClusterEntity.prototype, "image", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: true }),
+    __metadata("design:type", Number)
+], ClusterEntity.prototype, "diskSizeGb", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], ClusterEntity.prototype, "bootstrapKeyId", void 0);
+__decorate([
+    (0, typeorm_1.CreateDateColumn)({ type: 'timestamptz' }),
+    __metadata("design:type", Date)
+], ClusterEntity.prototype, "createdAt", void 0);
+__decorate([
+    (0, typeorm_1.UpdateDateColumn)({ type: 'timestamptz' }),
+    __metadata("design:type", Date)
+], ClusterEntity.prototype, "updatedAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'timestamptz', nullable: true }),
+    __metadata("design:type", Date)
+], ClusterEntity.prototype, "deletedAt", void 0);
+__decorate([
+    (0, typeorm_1.OneToMany)(() => cluster_node_entity_1.ClusterNodeEntity, (node) => node.cluster, {
+        cascade: true,
+    }),
+    __metadata("design:type", Array)
+], ClusterEntity.prototype, "nodes", void 0);
+exports.ClusterEntity = ClusterEntity = __decorate([
+    (0, typeorm_1.Entity)('infrastructure_clusters')
+], ClusterEntity);

package/lib/src/modules/infrastructure/clusters/entities/node-billable-interval.entity.d.ts

@@ -0,0 +1,17 @@
+import { NodeType } from './cluster-node.entity';
+export declare class NodeBillableIntervalEntity {
+    id: string;
+    generateId(): void;
+    clusterId: string;
+    nodeId: string;
+    serverName: string;
+    providerResourceId?: string;
+    provider: string;
+    region: string;
+    location?: string;
+    serverType: string;
+    nodeType: NodeType;
+    startedAt: Date;
+    endedAt?: Date | null;
+    metadata: Record<string, any>;
+}

package/lib/src/modules/infrastructure/clusters/entities/node-billable-interval.entity.js

@@ -0,0 +1,86 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeBillableIntervalEntity = void 0;
+const typeorm_1 = require("typeorm");
+const uuid_1 = require("uuid");
+const cluster_node_entity_1 = require("./cluster-node.entity");
+let NodeBillableIntervalEntity = class NodeBillableIntervalEntity {
+    generateId() {
+        if (!this.id) {
+            this.id = (0, uuid_1.v4)();
+        }
+    }
+};
+exports.NodeBillableIntervalEntity = NodeBillableIntervalEntity;
+__decorate([
+    (0, typeorm_1.PrimaryColumn)('uuid'),
+    __metadata("design:type", String)
+], NodeBillableIntervalEntity.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.BeforeInsert)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], NodeBillableIntervalEntity.prototype, "generateId", null);
+__decorate([
+    (0, typeorm_1.Column)('uuid'),
+    __metadata("design:type", String)
+], NodeBillableIntervalEntity.prototype, "clusterId", void 0);
+__decorate([
+    (0, typeorm_1.Column)('uuid'),
+    __metadata("design:type", String)
+], NodeBillableIntervalEntity.prototype, "nodeId", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], NodeBillableIntervalEntity.prototype, "serverName", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], NodeBillableIntervalEntity.prototype, "providerResourceId", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], NodeBillableIntervalEntity.prototype, "provider", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], NodeBillableIntervalEntity.prototype, "region", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], NodeBillableIntervalEntity.prototype, "location", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], NodeBillableIntervalEntity.prototype, "serverType", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'enum', enum: cluster_node_entity_1.NodeType }),
+    __metadata("design:type", String)
+], NodeBillableIntervalEntity.prototype, "nodeType", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'timestamptz' }),
+    __metadata("design:type", Date)
+], NodeBillableIntervalEntity.prototype, "startedAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'timestamptz', nullable: true }),
+    __metadata("design:type", Date)
+], NodeBillableIntervalEntity.prototype, "endedAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'json', default: '{}' }),
+    __metadata("design:type", Object)
+], NodeBillableIntervalEntity.prototype, "metadata", void 0);
+exports.NodeBillableIntervalEntity = NodeBillableIntervalEntity = __decorate([
+    (0, typeorm_1.Entity)('infrastructure_node_billable_intervals'),
+    (0, typeorm_1.Index)(['clusterId', 'startedAt']),
+    (0, typeorm_1.Index)(['nodeId', 'endedAt'])
+], NodeBillableIntervalEntity);

package/lib/src/modules/infrastructure/clusters/entities/volume-billable-interval.entity.d.ts

@@ -0,0 +1,18 @@
+export declare enum VolumeBillableKind {
+    SHARED_STORAGE = "shared-storage",
+    APP_VOLUME = "app-volume",
+    SNAPSHOT = "snapshot"
+}
+export declare class VolumeBillableIntervalEntity {
+    id: string;
+    generateId(): void;
+    clusterId: string;
+    volumeProviderId: string;
+    provider: string;
+    region: string;
+    kind: VolumeBillableKind;
+    sizeGb: number;
+    startedAt: Date;
+    endedAt?: Date | null;
+    metadata: Record<string, any>;
+}

package/lib/src/modules/infrastructure/clusters/entities/volume-billable-interval.entity.js

@@ -0,0 +1,79 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VolumeBillableIntervalEntity = exports.VolumeBillableKind = void 0;
+const typeorm_1 = require("typeorm");
+const uuid_1 = require("uuid");
+var VolumeBillableKind;
+(function (VolumeBillableKind) {
+    VolumeBillableKind["SHARED_STORAGE"] = "shared-storage";
+    VolumeBillableKind["APP_VOLUME"] = "app-volume";
+    VolumeBillableKind["SNAPSHOT"] = "snapshot";
+})(VolumeBillableKind || (exports.VolumeBillableKind = VolumeBillableKind = {}));
+let VolumeBillableIntervalEntity = class VolumeBillableIntervalEntity {
+    generateId() {
+        if (!this.id) {
+            this.id = (0, uuid_1.v4)();
+        }
+    }
+};
+exports.VolumeBillableIntervalEntity = VolumeBillableIntervalEntity;
+__decorate([
+    (0, typeorm_1.PrimaryColumn)('uuid'),
+    __metadata("design:type", String)
+], VolumeBillableIntervalEntity.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.BeforeInsert)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], VolumeBillableIntervalEntity.prototype, "generateId", null);
+__decorate([
+    (0, typeorm_1.Column)('uuid'),
+    __metadata("design:type", String)
+], VolumeBillableIntervalEntity.prototype, "clusterId", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], VolumeBillableIntervalEntity.prototype, "volumeProviderId", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], VolumeBillableIntervalEntity.prototype, "provider", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], VolumeBillableIntervalEntity.prototype, "region", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'enum', enum: VolumeBillableKind }),
+    __metadata("design:type", String)
+], VolumeBillableIntervalEntity.prototype, "kind", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", Number)
+], VolumeBillableIntervalEntity.prototype, "sizeGb", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'timestamptz' }),
+    __metadata("design:type", Date)
+], VolumeBillableIntervalEntity.prototype, "startedAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'timestamptz', nullable: true }),
+    __metadata("design:type", Date)
+], VolumeBillableIntervalEntity.prototype, "endedAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'json', default: '{}' }),
+    __metadata("design:type", Object)
+], VolumeBillableIntervalEntity.prototype, "metadata", void 0);
+exports.VolumeBillableIntervalEntity = VolumeBillableIntervalEntity = __decorate([
+    (0, typeorm_1.Entity)('infrastructure_volume_billable_intervals'),
+    (0, typeorm_1.Index)(['clusterId', 'startedAt']),
+    (0, typeorm_1.Index)(['volumeProviderId', 'endedAt'])
+], VolumeBillableIntervalEntity);

package/lib/src/modules/infrastructure/clusters/services/billing-intervals.service.d.ts

@@ -0,0 +1,48 @@
+import { Repository } from 'typeorm';
+import { NodeBillableIntervalEntity } from '../entities/node-billable-interval.entity';
+import { VolumeBillableIntervalEntity, VolumeBillableKind } from '../entities/volume-billable-interval.entity';
+import { ClusterEntity } from '../entities/cluster.entity';
+import { NodeType } from '../entities/cluster-node.entity';
+interface OpenNodeIntervalInput {
+    clusterId: string;
+    nodeId: string;
+    serverName: string;
+    providerResourceId?: string;
+    provider: string;
+    region: string;
+    location?: string;
+    serverType: string;
+    nodeType: NodeType;
+    startedAt?: Date;
+    metadata?: Record<string, any>;
+}
+interface OpenVolumeIntervalInput {
+    clusterId: string;
+    volumeProviderId: string;
+    provider: string;
+    region: string;
+    kind: VolumeBillableKind;
+    sizeGb: number;
+    startedAt?: Date;
+    metadata?: Record<string, any>;
+}
+export declare class BillingIntervalsService {
+    private readonly nodeIntervalRepo;
+    private readonly volumeIntervalRepo;
+    private readonly logger;
+    constructor(nodeIntervalRepo: Repository<NodeBillableIntervalEntity>, volumeIntervalRepo: Repository<VolumeBillableIntervalEntity>);
+    openNodeInterval(input: OpenNodeIntervalInput): Promise<void>;
+    closeNodeIntervals(nodeId: string, at?: Date): Promise<void>;
+    openVolumeInterval(input: OpenVolumeIntervalInput): Promise<void>;
+    closeVolumeIntervals(volumeProviderId: string, at?: Date): Promise<void>;
+    /**
+     * Backfill: for every node and shared volume of every cluster without an
+     * open interval, open one starting at the resource's createdAt. Idempotent —
+     * called on app startup so pre-existing clusters become billable.
+     */
+    backfillFromClusters(clusters: ClusterEntity[]): Promise<{
+        nodes: number;
+        volumes: number;
+    }>;
+}
+export {};

package/lib/src/modules/infrastructure/clusters/services/billing-intervals.service.js

@@ -0,0 +1,159 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var BillingIntervalsService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BillingIntervalsService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const node_billable_interval_entity_1 = require("../entities/node-billable-interval.entity");
+const volume_billable_interval_entity_1 = require("../entities/volume-billable-interval.entity");
+const cluster_node_entity_1 = require("../entities/cluster-node.entity");
+let BillingIntervalsService = BillingIntervalsService_1 = class BillingIntervalsService {
+    constructor(nodeIntervalRepo, volumeIntervalRepo) {
+        this.nodeIntervalRepo = nodeIntervalRepo;
+        this.volumeIntervalRepo = volumeIntervalRepo;
+        this.logger = new common_1.Logger(BillingIntervalsService_1.name);
+    }
+    async openNodeInterval(input) {
+        try {
+            await this.closeNodeIntervals(input.nodeId, input.startedAt ?? new Date());
+            const entity = this.nodeIntervalRepo.create({
+                clusterId: input.clusterId,
+                nodeId: input.nodeId,
+                serverName: input.serverName,
+                providerResourceId: input.providerResourceId,
+                provider: input.provider,
+                region: input.region,
+                location: input.location,
+                serverType: input.serverType,
+                nodeType: input.nodeType,
+                startedAt: input.startedAt ?? new Date(),
+                endedAt: null,
+                metadata: input.metadata ?? {},
+            });
+            await this.nodeIntervalRepo.save(entity);
+        }
+        catch (err) {
+            this.logger.warn(`openNodeInterval failed for node ${input.nodeId}: ${err.message}`);
+        }
+    }
+    async closeNodeIntervals(nodeId, at = new Date()) {
+        try {
+            await this.nodeIntervalRepo.update({ nodeId, endedAt: (0, typeorm_2.IsNull)() }, { endedAt: at });
+        }
+        catch (err) {
+            this.logger.warn(`closeNodeIntervals failed for node ${nodeId}: ${err.message}`);
+        }
+    }
+    async openVolumeInterval(input) {
+        try {
+            await this.closeVolumeIntervals(input.volumeProviderId, input.startedAt ?? new Date());
+            const entity = this.volumeIntervalRepo.create({
+                clusterId: input.clusterId,
+                volumeProviderId: input.volumeProviderId,
+                provider: input.provider,
+                region: input.region,
+                kind: input.kind,
+                sizeGb: input.sizeGb,
+                startedAt: input.startedAt ?? new Date(),
+                endedAt: null,
+                metadata: input.metadata ?? {},
+            });
+            await this.volumeIntervalRepo.save(entity);
+        }
+        catch (err) {
+            this.logger.warn(`openVolumeInterval failed for volume ${input.volumeProviderId}: ${err.message}`);
+        }
+    }
+    async closeVolumeIntervals(volumeProviderId, at = new Date()) {
+        try {
+            await this.volumeIntervalRepo.update({ volumeProviderId, endedAt: (0, typeorm_2.IsNull)() }, { endedAt: at });
+        }
+        catch (err) {
+            this.logger.warn(`closeVolumeIntervals failed for ${volumeProviderId}: ${err.message}`);
+        }
+    }
+    /**
+     * Backfill: for every node and shared volume of every cluster without an
+     * open interval, open one starting at the resource's createdAt. Idempotent —
+     * called on app startup so pre-existing clusters become billable.
+     */
+    async backfillFromClusters(clusters) {
+        let nodesOpened = 0;
+        let volumesOpened = 0;
+        for (const cluster of clusters) {
+            for (const node of cluster.nodes ?? []) {
+                const existing = await this.nodeIntervalRepo.findOne({
+                    where: { nodeId: node.id },
+                });
+                if (existing)
+                    continue;
+                try {
+                    await this.nodeIntervalRepo.save(this.nodeIntervalRepo.create({
+                        clusterId: cluster.id,
+                        nodeId: node.id,
+                        serverName: node.serverName,
+                        providerResourceId: node.providerResourceId,
+                        provider: cluster.provider,
+                        region: cluster.region,
+                        serverType: cluster.nodeSize,
+                        nodeType: node.nodeType,
+                        startedAt: node.createdAt,
+                        endedAt: null,
+                        metadata: { backfilled: true },
+                    }));
+                    nodesOpened++;
+                }
+                catch (err) {
+                    this.logger.warn(`backfill node ${node.id} failed: ${err.message}`);
+                }
+            }
+            if (cluster.sharedStorageVolumeId) {
+                const existingVol = await this.volumeIntervalRepo.findOne({
+                    where: { volumeProviderId: cluster.sharedStorageVolumeId },
+                });
+                if (!existingVol) {
+                    try {
+                        await this.volumeIntervalRepo.save(this.volumeIntervalRepo.create({
+                            clusterId: cluster.id,
+                            volumeProviderId: cluster.sharedStorageVolumeId,
+                            provider: cluster.provider,
+                            region: cluster.region,
+                            kind: volume_billable_interval_entity_1.VolumeBillableKind.SHARED_STORAGE,
+                            sizeGb: cluster.sharedStorageVolumeSizeGb ?? 0,
+                            startedAt: cluster.createdAt,
+                            endedAt: null,
+                            metadata: { backfilled: true },
+                        }));
+                        volumesOpened++;
+                    }
+                    catch (err) {
+                        this.logger.warn(`backfill volume ${cluster.sharedStorageVolumeId} failed: ${err.message}`);
+                    }
+                }
+            }
+        }
+        return { nodes: nodesOpened, volumes: volumesOpened };
+    }
+};
+exports.BillingIntervalsService = BillingIntervalsService;
+exports.BillingIntervalsService = BillingIntervalsService = BillingIntervalsService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(node_billable_interval_entity_1.NodeBillableIntervalEntity)),
+    __param(1, (0, typeorm_1.InjectRepository)(volume_billable_interval_entity_1.VolumeBillableIntervalEntity)),
+    __metadata("design:paramtypes", [typeorm_2.Repository,
+        typeorm_2.Repository])
+], BillingIntervalsService);
+void cluster_node_entity_1.NodeType;

package/lib/src/modules/infrastructure/clusters/services/cluster-capacity.service.d.ts

@@ -0,0 +1,23 @@
+import { Repository } from 'typeorm';
+import { ClusterEntity } from '../entities/cluster.entity';
+import { ClusterNodeEntity } from '../entities/cluster-node.entity';
+import { KubernetesService } from '../../shared/services/kubernetes.service';
+import { EncryptionService } from '../../../shared/encryption/services/encryption.service';
+import { ProviderFactory } from '../../../providers/services/provider.factory';
+import { ClusterCapacityPlanDto } from '../dto/cluster-capacity-plan.dto';
+import { ClusterStorageService } from './cluster-storage.service';
+export declare class ClusterCapacityService {
+    private readonly clusterRepository;
+    private readonly nodeRepository;
+    private readonly kubernetesService;
+    private readonly encryptionService;
+    private readonly providerFactory;
+    private readonly clusterStorageService;
+    private readonly logger;
+    constructor(clusterRepository: Repository<ClusterEntity>, nodeRepository: Repository<ClusterNodeEntity>, kubernetesService: KubernetesService, encryptionService: EncryptionService, providerFactory: ProviderFactory, clusterStorageService: ClusterStorageService);
+    getPlan(clusterId: string): Promise<ClusterCapacityPlanDto>;
+    private buildCandidates;
+    private pickFirstMonthlyPrice;
+    private parseMonthly;
+    private buildMessage;
+}