@flui-cloud/cli 0.0.1

package/lib/src/modules/common/dto/async-operation-response.dto.js

@@ -0,0 +1,65 @@
+"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.AsyncOperationResponseDto = void 0;
+const swagger_1 = require("@nestjs/swagger");
+/**
+ * Base DTO for async infrastructure operations
+ *
+ * Provides unified tracking interface for long-running operations across:
+ * - Cluster creation/deletion
+ * - Build agent provisioning
+ * - Server creation/deletion
+ * - Deployment operations
+ *
+ * This allows frontend to use a single component/hook for monitoring
+ * any async infrastructure operation via the operation_id.
+ */
+class AsyncOperationResponseDto {
+}
+exports.AsyncOperationResponseDto = AsyncOperationResponseDto;
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        description: 'Operation ID for tracking progress via /api/v1/infrastructure/operations/:id',
+        example: 'a7f8c3d2-1234-5678-90ab-cdef12345678',
+    }),
+    __metadata("design:type", String)
+], AsyncOperationResponseDto.prototype, "operation_id", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        description: 'Created resource ID (cluster/agent/server)',
+        example: 'b9e2d4f1-5678-1234-90ab-cdef87654321',
+    }),
+    __metadata("design:type", String)
+], AsyncOperationResponseDto.prototype, "resource_id", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        description: 'Initial operation status',
+        enum: ['pending'],
+        example: 'pending',
+    }),
+    __metadata("design:type", String)
+], AsyncOperationResponseDto.prototype, "status", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        description: 'Estimated time to complete the operation',
+        example: '5-10 minutes',
+    }),
+    __metadata("design:type", String)
+], AsyncOperationResponseDto.prototype, "estimated_duration", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        description: 'Timestamp when the operation was created',
+        type: Date,
+        example: '2025-11-09T10:30:00Z',
+    }),
+    __metadata("design:type", Date)
+], AsyncOperationResponseDto.prototype, "created_at", void 0);

package/lib/src/modules/common/dto/index.d.ts

@@ -0,0 +1 @@
+export * from './async-operation-response.dto';

package/lib/src/modules/common/dto/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./async-operation-response.dto"), exports);

package/lib/src/modules/common/services/label.service.d.ts

@@ -0,0 +1,70 @@
+export interface Label {
+    key: string;
+    value: string;
+}
+export type LabelArray = Label[];
+export interface GenerateLabelsConfig {
+    resourceType: 'server' | 'cluster-node' | 'ssh-key';
+    clusterId?: string;
+    clusterName?: string;
+    nodeId?: string;
+    nodeType?: 'master' | 'worker';
+    environment?: string;
+    sshKeyId?: string;
+    sshKeyName?: string;
+}
+export declare class LabelService {
+    private readonly logger;
+    private readonly FLUI_VERSION;
+    /**
+     * Generate standard Flui labels for a server/node
+     * @returns Array of label objects
+     */
+    generateServerLabels(config: GenerateLabelsConfig): LabelArray;
+    /**
+     * Convert label array to Record for provider compatibility
+     */
+    toRecord(labels: LabelArray): Record<string, string>;
+    /**
+     * Convert Record to label array
+     */
+    fromRecord(record: Record<string, string> | null | undefined): LabelArray;
+    /**
+     * Validate if a server is managed by Flui
+     */
+    isFluiManagedServer(labels: LabelArray | null | undefined): boolean;
+    /**
+     * Get label value by key
+     */
+    getLabelValue(labels: LabelArray, key: string): string | undefined;
+    /**
+     * Extract cluster info from labels
+     */
+    getClusterInfoFromLabels(labels: LabelArray): {
+        clusterId?: string;
+        clusterName?: string;
+        nodeId?: string;
+        nodeType?: string;
+    };
+    /**
+     * Generate standard Flui labels for an SSH key
+     * @returns Array of label objects
+     */
+    generateSSHKeyLabels(config: {
+        sshKeyId: string;
+        sshKeyName: string;
+        environment?: string;
+    }): LabelArray;
+    /**
+     * Validate if an SSH key is managed by Flui
+     */
+    isFluiManagedSSHKey(labels: LabelArray | Record<string, string> | null | undefined): boolean;
+    /**
+     * Extract SSH key info from labels
+     */
+    getSSHKeyInfoFromLabels(labels: LabelArray | Record<string, string>): {
+        sshKeyId?: string;
+        sshKeyName?: string;
+        environment?: string;
+    };
+}

package/lib/src/modules/common/services/label.service.js

@@ -0,0 +1,128 @@
+"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 LabelService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LabelService = void 0;
+const common_1 = require("@nestjs/common");
+let LabelService = LabelService_1 = class LabelService {
+    constructor() {
+        this.logger = new common_1.Logger(LabelService_1.name);
+        this.FLUI_VERSION = '1.0.0';
+    }
+    /**
+     * Generate standard Flui labels for a server/node
+     * @returns Array of label objects
+     */
+    generateServerLabels(config) {
+        const labels = [
+            { key: 'managed-by', value: 'flui-cloud' },
+            // { key: 'flui-version', value: this.FLUI_VERSION }, // Removed - contains dots
+            { key: 'flui-resource-type', value: config.resourceType },
+            // { key: 'flui-created-at', value: new Date().toISOString() }, // Removed - contains colons and dots
+        ];
+        if (config.resourceType === 'cluster-node') {
+            if (!config.clusterId || !config.clusterName) {
+                throw new Error('clusterId and clusterName required for cluster nodes');
+            }
+            labels.push({ key: 'flui-cluster-id', value: config.clusterId }, { key: 'flui-cluster-name', value: config.clusterName });
+            if (config.nodeId) {
+                labels.push({ key: 'flui-node-id', value: config.nodeId });
+            }
+            if (config.nodeType) {
+                labels.push({ key: 'flui-node-type', value: config.nodeType });
+            }
+        }
+        if (config.environment) {
+            labels.push({ key: 'flui-environment', value: config.environment });
+        }
+        return labels;
+    }
+    /**
+     * Convert label array to Record for provider compatibility
+     */
+    toRecord(labels) {
+        return labels.reduce((acc, label) => {
+            acc[label.key] = label.value;
+            return acc;
+        }, {});
+    }
+    /**
+     * Convert Record to label array
+     */
+    fromRecord(record) {
+        if (!record)
+            return [];
+        return Object.entries(record).map(([key, value]) => ({ key, value }));
+    }
+    /**
+     * Validate if a server is managed by Flui
+     */
+    isFluiManagedServer(labels) {
+        if (!labels || labels.length === 0)
+            return false;
+        return labels.some((l) => l.key === 'managed-by' && l.value === 'flui-cloud');
+    }
+    /**
+     * Get label value by key
+     */
+    getLabelValue(labels, key) {
+        return labels.find((l) => l.key === key)?.value;
+    }
+    /**
+     * Extract cluster info from labels
+     */
+    getClusterInfoFromLabels(labels) {
+        return {
+            clusterId: this.getLabelValue(labels, 'flui-cluster-id'),
+            clusterName: this.getLabelValue(labels, 'flui-cluster-name'),
+            nodeId: this.getLabelValue(labels, 'flui-node-id'),
+            nodeType: this.getLabelValue(labels, 'flui-node-type'),
+        };
+    }
+    /**
+     * Generate standard Flui labels for an SSH key
+     * @returns Array of label objects
+     */
+    generateSSHKeyLabels(config) {
+        const labels = [
+            { key: 'managed-by', value: 'flui-cloud' },
+            { key: 'flui-resource-type', value: 'ssh-key' },
+            { key: 'flui-ssh-key-id', value: config.sshKeyId },
+            { key: 'flui-ssh-key-name', value: config.sshKeyName },
+        ];
+        if (config.environment) {
+            labels.push({ key: 'flui-environment', value: config.environment });
+        }
+        return labels;
+    }
+    /**
+     * Validate if an SSH key is managed by Flui
+     */
+    isFluiManagedSSHKey(labels) {
+        if (!labels)
+            return false;
+        const labelArray = Array.isArray(labels) ? labels : this.fromRecord(labels);
+        return (labelArray.some((l) => l.key === 'managed-by' && l.value === 'flui-cloud') &&
+            labelArray.some((l) => l.key === 'flui-resource-type' && l.value === 'ssh-key'));
+    }
+    /**
+     * Extract SSH key info from labels
+     */
+    getSSHKeyInfoFromLabels(labels) {
+        const labelArray = Array.isArray(labels) ? labels : this.fromRecord(labels);
+        return {
+            sshKeyId: this.getLabelValue(labelArray, 'flui-ssh-key-id'),
+            sshKeyName: this.getLabelValue(labelArray, 'flui-ssh-key-name'),
+            environment: this.getLabelValue(labelArray, 'flui-environment'),
+        };
+    }
+};
+exports.LabelService = LabelService;
+exports.LabelService = LabelService = LabelService_1 = __decorate([
+    (0, common_1.Injectable)()
+], LabelService);

package/lib/src/modules/dns/entities/app-endpoint.entity.d.ts

@@ -0,0 +1,57 @@
+import { ClusterEntity } from '../../infrastructure/clusters/entities/cluster.entity';
+import { ClusterDnsZoneEntity } from './cluster-dns-zone.entity';
+import { WildcardCertificateEntity } from './wildcard-certificate.entity';
+import { SanCertificateEntity } from './san-certificate.entity';
+import { ApplicationEntity } from '../../applications/entities/application.entity';
+import { DnsRecordType } from '../../providers/interfaces/dns-provider.interface';
+import { CertificateStatus } from '../../providers/interfaces/certificate-provider.interface';
+import { CertificateProvider } from '../../providers/enums/certificate-provider.enum';
+import { ReconciliationStatus } from '../../infrastructure/shared/enums/reconciliation-status.enum';
+import { EndpointType } from '../enums/endpoint-type.enum';
+import { CertChallenge } from '../enums/cert-challenge.enum';
+import { HostnameMode } from '../enums/hostname-mode.enum';
+export declare class AppEndpointEntity {
+    id: string;
+    clusterId: string;
+    cluster: ClusterEntity;
+    clusterDnsZoneId: string;
+    clusterDnsZone: ClusterDnsZoneEntity;
+    applicationId: string;
+    application: ApplicationEntity;
+    /**
+     * Discriminator. `public` (default) is the legacy endpoint with public DNS
+     * + per-app cert + Ingress. `internal` is reachable only via the
+     * cluster-wide ForwardAuth gateway: the DNS A record is the cluster-wide
+     * `*.internal.<zone>` wildcard (not created per-app), and the Ingress
+     * carries the auth-url annotation pointing to /authz/internal-app.
+     */
+    endpointType: EndpointType;
+    certChallenge: CertChallenge;
+    hostnameMode: HostnameMode;
+    fqdn: string;
+    serviceName: string;
+    k8sServiceName: string;
+    k8sNamespace: string;
+    k8sServicePort: number;
+    dnsRecordType: DnsRecordType;
+    dnsRecordValue: string;
+    dnsRecordId: string;
+    certificateProvider: CertificateProvider;
+    certificateRequired: boolean;
+    certificateStatus: CertificateStatus;
+    certificateMessage: string;
+    certificateExpiresAt: Date;
+    wildcardCertificateId: string | null;
+    wildcardCertificate: WildcardCertificateEntity | null;
+    tlsSecretName: string | null;
+    sanCertificateId: string | null;
+    sanCertificate: SanCertificateEntity | null;
+    reconciliationStatus: ReconciliationStatus;
+    lastReconciliationAt: Date;
+    lastSyncedAt: Date | null;
+    syncedDomain: string | null;
+    errorMessage: string;
+    metadata: Record<string, string>;
+    createdAt: Date;
+    updatedAt: Date;
+}

package/lib/src/modules/dns/entities/app-endpoint.entity.js

@@ -0,0 +1,205 @@
+"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.AppEndpointEntity = void 0;
+const typeorm_1 = require("typeorm");
+const cluster_entity_1 = require("../../infrastructure/clusters/entities/cluster.entity");
+const cluster_dns_zone_entity_1 = require("./cluster-dns-zone.entity");
+const wildcard_certificate_entity_1 = require("./wildcard-certificate.entity");
+const san_certificate_entity_1 = require("./san-certificate.entity");
+const application_entity_1 = require("../../applications/entities/application.entity");
+const dns_provider_interface_1 = require("../../providers/interfaces/dns-provider.interface");
+const certificate_provider_interface_1 = require("../../providers/interfaces/certificate-provider.interface");
+const certificate_provider_enum_1 = require("../../providers/enums/certificate-provider.enum");
+const reconciliation_status_enum_1 = require("../../infrastructure/shared/enums/reconciliation-status.enum");
+const endpoint_type_enum_1 = require("../enums/endpoint-type.enum");
+const cert_challenge_enum_1 = require("../enums/cert-challenge.enum");
+const hostname_mode_enum_1 = require("../enums/hostname-mode.enum");
+let AppEndpointEntity = class AppEndpointEntity {
+};
+exports.AppEndpointEntity = AppEndpointEntity;
+__decorate([
+    (0, typeorm_1.PrimaryGeneratedColumn)('uuid'),
+    __metadata("design:type", String)
+], AppEndpointEntity.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'uuid' }),
+    __metadata("design:type", String)
+], AppEndpointEntity.prototype, "clusterId", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => cluster_entity_1.ClusterEntity, { onDelete: 'CASCADE' }),
+    (0, typeorm_1.JoinColumn)({ name: 'clusterId' }),
+    __metadata("design:type", cluster_entity_1.ClusterEntity)
+], AppEndpointEntity.prototype, "cluster", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'uuid', nullable: true }),
+    __metadata("design:type", String)
+], AppEndpointEntity.prototype, "clusterDnsZoneId", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => cluster_dns_zone_entity_1.ClusterDnsZoneEntity, (zone) => zone.endpoints, {
+        nullable: true,
+    }),
+    (0, typeorm_1.JoinColumn)({ name: 'clusterDnsZoneId' }),
+    __metadata("design:type", cluster_dns_zone_entity_1.ClusterDnsZoneEntity)
+], AppEndpointEntity.prototype, "clusterDnsZone", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'uuid', nullable: true }),
+    __metadata("design:type", String)
+], AppEndpointEntity.prototype, "applicationId", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => application_entity_1.ApplicationEntity, { nullable: true, onDelete: 'SET NULL' }),
+    (0, typeorm_1.JoinColumn)({ name: 'applicationId' }),
+    __metadata("design:type", application_entity_1.ApplicationEntity)
+], AppEndpointEntity.prototype, "application", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'enum',
+        enum: endpoint_type_enum_1.EndpointType,
+        default: endpoint_type_enum_1.EndpointType.PUBLIC,
+    }),
+    __metadata("design:type", String)
+], AppEndpointEntity.prototype, "endpointType", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'enum',
+        enum: cert_challenge_enum_1.CertChallenge,
+        default: cert_challenge_enum_1.CertChallenge.HTTP_01,
+    }),
+    __metadata("design:type", String)
+], AppEndpointEntity.prototype, "certChallenge", 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)
+], AppEndpointEntity.prototype, "hostnameMode", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar' }),
+    __metadata("design:type", String)
+], AppEndpointEntity.prototype, "fqdn", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar' }),
+    __metadata("design:type", String)
+], AppEndpointEntity.prototype, "serviceName", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar' }),
+    __metadata("design:type", String)
+], AppEndpointEntity.prototype, "k8sServiceName", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar' }),
+    __metadata("design:type", String)
+], AppEndpointEntity.prototype, "k8sNamespace", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int' }),
+    __metadata("design:type", Number)
+], AppEndpointEntity.prototype, "k8sServicePort", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'enum', enum: dns_provider_interface_1.DnsRecordType, default: dns_provider_interface_1.DnsRecordType.A }),
+    __metadata("design:type", String)
+], AppEndpointEntity.prototype, "dnsRecordType", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', nullable: true }),
+    __metadata("design:type", String)
+], AppEndpointEntity.prototype, "dnsRecordValue", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', nullable: true }),
+    __metadata("design:type", String)
+], AppEndpointEntity.prototype, "dnsRecordId", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'enum', enum: certificate_provider_enum_1.CertificateProvider, nullable: true }),
+    __metadata("design:type", String)
+], AppEndpointEntity.prototype, "certificateProvider", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'boolean', default: true }),
+    __metadata("design:type", Boolean)
+], AppEndpointEntity.prototype, "certificateRequired", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'enum', enum: certificate_provider_interface_1.CertificateStatus, nullable: true }),
+    __metadata("design:type", String)
+], AppEndpointEntity.prototype, "certificateStatus", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'text', nullable: true }),
+    __metadata("design:type", String)
+], AppEndpointEntity.prototype, "certificateMessage", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'timestamptz', nullable: true }),
+    __metadata("design:type", Date)
+], AppEndpointEntity.prototype, "certificateExpiresAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'uuid', nullable: true }),
+    __metadata("design:type", String)
+], AppEndpointEntity.prototype, "wildcardCertificateId", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => wildcard_certificate_entity_1.WildcardCertificateEntity, {
+        nullable: true,
+        onDelete: 'SET NULL',
+    }),
+    (0, typeorm_1.JoinColumn)({ name: 'wildcardCertificateId' }),
+    __metadata("design:type", wildcard_certificate_entity_1.WildcardCertificateEntity)
+], AppEndpointEntity.prototype, "wildcardCertificate", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', nullable: true }),
+    __metadata("design:type", String)
+], AppEndpointEntity.prototype, "tlsSecretName", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'uuid', nullable: true }),
+    __metadata("design:type", String)
+], AppEndpointEntity.prototype, "sanCertificateId", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => san_certificate_entity_1.SanCertificateEntity, {
+        nullable: true,
+        onDelete: 'SET NULL',
+    }),
+    (0, typeorm_1.JoinColumn)({ name: 'sanCertificateId' }),
+    __metadata("design:type", san_certificate_entity_1.SanCertificateEntity)
+], AppEndpointEntity.prototype, "sanCertificate", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'enum',
+        enum: reconciliation_status_enum_1.ReconciliationStatus,
+        default: reconciliation_status_enum_1.ReconciliationStatus.PENDING,
+    }),
+    __metadata("design:type", String)
+], AppEndpointEntity.prototype, "reconciliationStatus", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'timestamptz', nullable: true }),
+    __metadata("design:type", Date)
+], AppEndpointEntity.prototype, "lastReconciliationAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'timestamptz', nullable: true }),
+    __metadata("design:type", Date)
+], AppEndpointEntity.prototype, "lastSyncedAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', nullable: true }),
+    __metadata("design:type", String)
+], AppEndpointEntity.prototype, "syncedDomain", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'text', nullable: true }),
+    __metadata("design:type", String)
+], AppEndpointEntity.prototype, "errorMessage", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'jsonb', nullable: true }),
+    __metadata("design:type", Object)
+], AppEndpointEntity.prototype, "metadata", void 0);
+__decorate([
+    (0, typeorm_1.CreateDateColumn)({ type: 'timestamptz' }),
+    __metadata("design:type", Date)
+], AppEndpointEntity.prototype, "createdAt", void 0);
+__decorate([
+    (0, typeorm_1.UpdateDateColumn)({ type: 'timestamptz' }),
+    __metadata("design:type", Date)
+], AppEndpointEntity.prototype, "updatedAt", void 0);
+exports.AppEndpointEntity = AppEndpointEntity = __decorate([
+    (0, typeorm_1.Entity)('app_endpoints'),
+    (0, typeorm_1.Index)(['fqdn'], { unique: true })
+], AppEndpointEntity);

package/lib/src/modules/dns/entities/cluster-dns-zone.entity.d.ts

@@ -0,0 +1,21 @@
+import { ClusterEntity } from '../../infrastructure/clusters/entities/cluster.entity';
+import { DnsZoneEntity } from './dns-zone.entity';
+import { CertificateProvider } from '../../providers/enums/certificate-provider.enum';
+import { ReconciliationStatus } from '../../infrastructure/shared/enums/reconciliation-status.enum';
+import { AppEndpointEntity } from './app-endpoint.entity';
+export declare class ClusterDnsZoneEntity {
+    id: string;
+    clusterId: string;
+    cluster: ClusterEntity;
+    dnsZoneId: string;
+    dnsZone: DnsZoneEntity;
+    certificateProvider: CertificateProvider;
+    acmeEmail: string;
+    wildcardCertificate: boolean;
+    reconciliationStatus: ReconciliationStatus;
+    lastReconciliationAt: Date;
+    errorMessage: string;
+    createdAt: Date;
+    updatedAt: Date;
+    endpoints: AppEndpointEntity[];
+}

package/lib/src/modules/dns/entities/cluster-dns-zone.entity.js

@@ -0,0 +1,88 @@
+"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.ClusterDnsZoneEntity = void 0;
+const typeorm_1 = require("typeorm");
+const cluster_entity_1 = require("../../infrastructure/clusters/entities/cluster.entity");
+const dns_zone_entity_1 = require("./dns-zone.entity");
+const certificate_provider_enum_1 = require("../../providers/enums/certificate-provider.enum");
+const reconciliation_status_enum_1 = require("../../infrastructure/shared/enums/reconciliation-status.enum");
+const app_endpoint_entity_1 = require("./app-endpoint.entity");
+let ClusterDnsZoneEntity = class ClusterDnsZoneEntity {
+};
+exports.ClusterDnsZoneEntity = ClusterDnsZoneEntity;
+__decorate([
+    (0, typeorm_1.PrimaryGeneratedColumn)('uuid'),
+    __metadata("design:type", String)
+], ClusterDnsZoneEntity.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'uuid', unique: true }),
+    __metadata("design:type", String)
+], ClusterDnsZoneEntity.prototype, "clusterId", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => cluster_entity_1.ClusterEntity, { onDelete: 'CASCADE' }),
+    (0, typeorm_1.JoinColumn)({ name: 'clusterId' }),
+    __metadata("design:type", cluster_entity_1.ClusterEntity)
+], ClusterDnsZoneEntity.prototype, "cluster", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'uuid' }),
+    __metadata("design:type", String)
+], ClusterDnsZoneEntity.prototype, "dnsZoneId", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => dns_zone_entity_1.DnsZoneEntity, (zone) => zone.clusterAssignments, {
+        eager: true,
+    }),
+    (0, typeorm_1.JoinColumn)({ name: 'dnsZoneId' }),
+    __metadata("design:type", dns_zone_entity_1.DnsZoneEntity)
+], ClusterDnsZoneEntity.prototype, "dnsZone", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'enum', enum: certificate_provider_enum_1.CertificateProvider, nullable: true }),
+    __metadata("design:type", String)
+], ClusterDnsZoneEntity.prototype, "certificateProvider", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'varchar', nullable: true }),
+    __metadata("design:type", String)
+], ClusterDnsZoneEntity.prototype, "acmeEmail", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'boolean', default: true }),
+    __metadata("design:type", Boolean)
+], ClusterDnsZoneEntity.prototype, "wildcardCertificate", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: 'enum',
+        enum: reconciliation_status_enum_1.ReconciliationStatus,
+        default: reconciliation_status_enum_1.ReconciliationStatus.PENDING,
+    }),
+    __metadata("design:type", String)
+], ClusterDnsZoneEntity.prototype, "reconciliationStatus", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'timestamptz', nullable: true }),
+    __metadata("design:type", Date)
+], ClusterDnsZoneEntity.prototype, "lastReconciliationAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'text', nullable: true }),
+    __metadata("design:type", String)
+], ClusterDnsZoneEntity.prototype, "errorMessage", void 0);
+__decorate([
+    (0, typeorm_1.CreateDateColumn)({ type: 'timestamptz' }),
+    __metadata("design:type", Date)
+], ClusterDnsZoneEntity.prototype, "createdAt", void 0);
+__decorate([
+    (0, typeorm_1.UpdateDateColumn)({ type: 'timestamptz' }),
+    __metadata("design:type", Date)
+], ClusterDnsZoneEntity.prototype, "updatedAt", void 0);
+__decorate([
+    (0, typeorm_1.OneToMany)(() => app_endpoint_entity_1.AppEndpointEntity, (endpoint) => endpoint.clusterDnsZone),
+    __metadata("design:type", Array)
+], ClusterDnsZoneEntity.prototype, "endpoints", void 0);
+exports.ClusterDnsZoneEntity = ClusterDnsZoneEntity = __decorate([
+    (0, typeorm_1.Entity)('cluster_dns_zones')
+], ClusterDnsZoneEntity);

package/lib/src/modules/dns/entities/dns-zone.entity.d.ts

@@ -0,0 +1,12 @@
+import { DnsProvider } from '../../providers/enums/dns-provider.enum';
+import { ClusterDnsZoneEntity } from './cluster-dns-zone.entity';
+export declare class DnsZoneEntity {
+    id: string;
+    providerZoneId: string;
+    zoneName: string;
+    dnsProvider: DnsProvider;
+    description: string;
+    createdAt: Date;
+    updatedAt: Date;
+    clusterAssignments: ClusterDnsZoneEntity[];
+}