@flui-cloud/cli 0.0.1

package/lib/src/modules/providers/interfaces/volume-export.interface.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Provider-side volume export primitive.
+ *
+ * One operation — `createExport` — moves data out of a live PVC into a sink.
+ * Two sink kinds are supported:
+ *
+ *   - `pvc-clone`   : sink is a fresh PVC in the same cluster (snapshot use case)
+ *   - `s3-archive`  : sink is an object-store bucket (backup / DR use case)
+ *
+ * Both are realised today via the universal copy-pod pattern (a Job that
+ * mounts source + target and streams data). Provider implementations may
+ * specialize a sink in the future (e.g. native CSI VolumeSnapshot when we
+ * eventually move PVCs off `local-path` onto a real CSI driver) without
+ * changing this contract.
+ *
+ * The user-facing surfaces ("snapshots", "backups") are thin services on
+ * top of this primitive — see VolumeSnapshotsService and VolumeBackupsService
+ * in the applications module.
+ */
+export type ExportSinkKind = 'pvc-clone' | 's3-archive';
+export interface VolumeExportCapabilities {
+    /**
+     * True when retaining many exports is cheap (incremental / dedup-friendly).
+     * Today both providers go through copy-pod, so `pvc-clone` retention is
+     * always full-volume billed. `s3-archive` via restic gets dedup for free.
+     */
+    pvcCloneSupportsCheapRetention: boolean;
+    s3ArchiveSupportsCheapRetention: boolean;
+    /**
+     * Approximate price for retaining an export, in EUR per GB per month.
+     * For pvc-clone this is the volume rate; for s3-archive this is the
+     * bucket rate (provider- and class-dependent).
+     */
+    pvcClonePricePerGbMonthEur: number | null;
+    s3ArchivePricePerGbMonthEur: number | null;
+}
+interface ExportInputBase {
+    /** Kubeconfig of the workload cluster where the source PVC lives. */
+    kubeconfig: string;
+    /** Namespace of the source PVC. */
+    namespace: string;
+    /** Source PVC name. */
+    sourcePvcName: string;
+    /** Logical export name (cluster-unique within the chosen sink space). */
+    exportName: string;
+    /**
+     * Labels applied to every Flui-managed resource the export materialises
+     * (the sink PVC, the copy Job, the S3 object metadata, …). Always
+     * populated by Flui with `flui.cloud/managed-by=flui-cloud`,
+     * `flui-app-id=<id>`, and a sink discriminator so the reaper can
+     * identify orphans.
+     */
+    labels: Record<string, string>;
+}
+export interface PvcCloneExportInput extends ExportInputBase {
+    sink: 'pvc-clone';
+    /** Storage class for the destination PVC. Defaults to the source's. */
+    destStorageClass?: string;
+}
+export interface S3ArchiveExportInput extends ExportInputBase {
+    sink: 's3-archive';
+    /** Destination bucket. Caller resolves credentials separately. */
+    bucket: string;
+    /** Object key prefix inside the bucket (e.g. `flui/<cluster>/<app>/<ts>/`). */
+    keyPrefix: string;
+    /** S3 endpoint URL (compatible with AWS, MinIO, R2, B2, …). */
+    endpoint: string;
+    /** Region. Empty string OK for non-AWS endpoints. */
+    region: string;
+    /** Access credentials. Read by the copy-pod via env vars only. */
+    accessKeyId: string;
+    secretAccessKey: string;
+}
+export type CreateExportInput = PvcCloneExportInput | S3ArchiveExportInput;
+export interface ExportResult {
+    /** Stable identifier of the export resource. For pvc-clone: clone PVC name. For s3-archive: full s3 URI of the manifest object. */
+    exportId: string;
+    /** Sink kind, mirrors the input. */
+    sink: ExportSinkKind;
+    /** Namespace of the source PVC (and of the clone PVC for pvc-clone). */
+    namespace: string;
+    /** Source PVC declared size in GB (spec.resources.requests.storage). */
+    sourceSizeGb: number;
+    /**
+     * Actual bytes written by the copy-pod / uploaded to S3, measured live
+     * during the export run. Reflects real on-disk / on-bucket usage —
+     * typically much smaller than `sourceSizeGb * 1e9`.
+     */
+    actualBytes?: number;
+    /** ISO 8601 timestamp. */
+    createdAt: string;
+    /** Provider-side ready state — true once the export can be restored from. */
+    ready: boolean;
+}
+export interface ListExportsInput {
+    kubeconfig: string;
+    /** Restrict to one sink kind. When omitted, all kinds are returned. */
+    sink?: ExportSinkKind;
+    namespace?: string;
+    /** Optional label selector (e.g. `flui-app-id=<id>`). */
+    labelSelector?: string;
+}
+export interface ExportSummary {
+    exportId: string;
+    sink: ExportSinkKind;
+    namespace: string;
+    sourcePvcName?: string;
+    appId?: string;
+    /** Source PVC declared size in GB (spec.resources.requests.storage). */
+    sizeGb?: number;
+    /** Actual on-disk / on-bucket bytes when known. */
+    actualBytes?: number;
+    createdAt: string;
+    ready: boolean;
+    labels: Record<string, string>;
+}
+export interface DeleteExportInput {
+    kubeconfig: string;
+    namespace: string;
+    exportId: string;
+    sink: ExportSinkKind;
+    ignoreNotFound?: boolean;
+    /**
+     * For s3-archive deletes: same S3 credentials needed to issue the
+     * DeleteObject calls. Caller resolves separately. Ignored for pvc-clone.
+     */
+    s3?: {
+        bucket: string;
+        endpoint: string;
+        region: string;
+        accessKeyId: string;
+        secretAccessKey: string;
+    };
+}
+export interface RestorePvcFromExportInput {
+    kubeconfig: string;
+    namespace: string;
+    exportId: string;
+    sink: ExportSinkKind;
+    /** Desired name of the new PVC. */
+    newPvcName: string;
+    /** Storage class for the new PVC. */
+    storageClassName: string;
+    /** Storage size for the new PVC (must be >= source size). */
+    sizeGb: number;
+    /** Optional node hint. */
+    preferredNode?: string;
+    /** Labels applied to the new PVC. */
+    labels: Record<string, string>;
+    /** Same shape as DeleteExportInput.s3, only required for sink=s3-archive. */
+    s3?: DeleteExportInput['s3'];
+}
+export interface IVolumeExport {
+    readonly capabilities: VolumeExportCapabilities;
+    createExport(input: CreateExportInput): Promise<ExportResult>;
+    listExports(input: ListExportsInput): Promise<ExportSummary[]>;
+    deleteExport(input: DeleteExportInput): Promise<void>;
+    restoreFromExport(input: RestorePvcFromExportInput): Promise<{
+        pvcName: string;
+    }>;
+}
+export {};

package/lib/src/modules/providers/interfaces/volume-export.interface.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Provider-side volume export primitive.
+ *
+ * One operation — `createExport` — moves data out of a live PVC into a sink.
+ * Two sink kinds are supported:
+ *
+ *   - `pvc-clone`   : sink is a fresh PVC in the same cluster (snapshot use case)
+ *   - `s3-archive`  : sink is an object-store bucket (backup / DR use case)
+ *
+ * Both are realised today via the universal copy-pod pattern (a Job that
+ * mounts source + target and streams data). Provider implementations may
+ * specialize a sink in the future (e.g. native CSI VolumeSnapshot when we
+ * eventually move PVCs off `local-path` onto a real CSI driver) without
+ * changing this contract.
+ *
+ * The user-facing surfaces ("snapshots", "backups") are thin services on
+ * top of this primitive — see VolumeSnapshotsService and VolumeBackupsService
+ * in the applications module.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/modules/providers/interfaces/volume-operations.interface.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Provider-side volume operations: snapshot creation, listing, deletion, and
+ * restore-to-new-PVC. Abstracts over the asymmetry between providers that
+ * support native CSI VolumeSnapshot (Scaleway, OVH, IONOS) and those that
+ * don't (Hetzner — see csi-driver issue #88, no snapshot/clone support).
+ *
+ * The user-facing terminology is uniform ("snapshot"), but on providers
+ * without native support the implementation may degrade to a labeled PVC
+ * clone via the copy-pod pattern (a Job that mounts source + dest PVC and
+ * tars data across).
+ *
+ * The capabilities object lets higher-level services (CLI, cost estimator,
+ * migration orchestrator) decide which operations to expose and how much
+ * they will cost.
+ */
+export interface VolumeOperationsCapabilities {
+    /**
+     * True when the storage backend supports cheap retention of snapshots as a
+     * separate object (e.g. Scaleway Block Storage Snapshots at ~€0.032/GB-mo).
+     * False on providers where a "snapshot" is a full PVC clone billed at the
+     * full volume rate (e.g. Hetzner). When false, snapshot CLI commands
+     * should warn the user about the per-snapshot cost and the orchestrator
+     * should prefer one-shot migration over keeping snapshots around.
+     */
+    supportsSnapshotRetention: boolean;
+    /**
+     * True when the CSI driver implements the standard
+     * `snapshot.storage.k8s.io/v1` VolumeSnapshot API. False on Hetzner.
+     * Drives the migration strategy selection: CSI snapshot vs copy-pod.
+     */
+    supportsCsiSnapshot: boolean;
+    /**
+     * True when the only viable migration strategy is the universal copy-pod
+     * fallback (a Job that copies bytes between PVCs). Mutually exclusive
+     * with supportsCsiSnapshot in the current design.
+     */
+    requiresCopyPodFallback: boolean;
+    /**
+     * Approximate price for retaining a snapshot, in EUR per GB per month.
+     * Null when retention is not supported (snapshot price equals volume
+     * price in that case — surfaced separately by the cost estimator).
+     */
+    snapshotCostPerGbMonthEur: number | null;
+}
+export interface CreateSnapshotInput {
+    /** Kubeconfig of the workload cluster where the source PVC lives. */
+    kubeconfig: string;
+    /** Namespace of the source PVC. */
+    namespace: string;
+    /** Source PVC name (the live volume to be snapshotted). */
+    sourcePvcName: string;
+    /** Desired snapshot resource name (cluster-unique within namespace). */
+    snapshotName: string;
+    /**
+     * Labels applied to the snapshot resource. Always populated by Flui with
+     * `flui.cloud/managed-by=flui-cloud`, `flui-app-id=<id>`,
+     * `flui.cloud/created-by=<job-id>` so the reaper can identify orphans.
+     */
+    labels: Record<string, string>;
+}
+export interface SnapshotResult {
+    /**
+     * Unique identifier of the created snapshot resource. On providers with
+     * CSI snapshot this is the VolumeSnapshot name; on copy-pod fallback it
+     * is the cloned PVC name.
+     */
+    snapshotId: string;
+    /** Provider implementation discriminant: 'csi-snapshot' | 'pvc-clone'. */
+    kind: SnapshotKind;
+    /** Namespace where the snapshot resource lives. */
+    namespace: string;
+    /** Size of the source PVC in GB at snapshot time. Used for cost reporting. */
+    sourceSizeGb: number;
+    /** Snapshot creation timestamp (ISO 8601). */
+    createdAt: string;
+    /** Provider-side ready state — true once the snapshot can be used to provision a new PVC. */
+    ready: boolean;
+}
+export type SnapshotKind = 'csi-snapshot' | 'pvc-clone';
+export interface ListSnapshotsInput {
+    kubeconfig: string;
+    /** Optional namespace filter. When omitted, lists across all namespaces. */
+    namespace?: string;
+    /**
+     * Optional label selector to narrow the list (e.g. `flui-app-id=<id>` for
+     * per-app listing).
+     */
+    labelSelector?: string;
+}
+export interface SnapshotSummary {
+    snapshotId: string;
+    kind: SnapshotKind;
+    namespace: string;
+    /** Source PVC name, when known from labels or annotations. */
+    sourcePvcName?: string;
+    /** flui-app-id label value, when present. */
+    appId?: string;
+    /** Size of the snapshot data in GB (best-effort; for csi-snapshot this is the restoreSize). */
+    sizeGb?: number;
+    /** Snapshot creation timestamp (ISO 8601). */
+    createdAt: string;
+    /** Whether the snapshot is currently usable to provision a new PVC. */
+    ready: boolean;
+    /** All labels on the snapshot resource. */
+    labels: Record<string, string>;
+}
+export interface CreatePvcFromSnapshotInput {
+    kubeconfig: string;
+    namespace: string;
+    /** Source snapshot to restore from. */
+    snapshotId: string;
+    /** Desired name of the new PVC. */
+    newPvcName: string;
+    /** Storage class for the new PVC. */
+    storageClassName: string;
+    /** Storage size for the new PVC (must be >= source snapshot size). */
+    sizeGb: number;
+    /**
+     * Optional node hint. The orchestrator typically wants the new PVC to
+     * bind to a specific node (the migration target). The implementation may
+     * use this hint via WaitForFirstConsumer + a same-node placeholder pod.
+     */
+    preferredNode?: string;
+    /**
+     * Labels applied to the new PVC. Same convention as snapshot labels.
+     */
+    labels: Record<string, string>;
+}
+export interface DeleteSnapshotInput {
+    kubeconfig: string;
+    namespace: string;
+    snapshotId: string;
+    /** When true, ignore "not found" and return success. */
+    ignoreNotFound?: boolean;
+}
+/**
+ * Provider-side volume operations contract. Each cloud provider that hosts
+ * Flui workload clusters provides an implementation. The orchestrator
+ * consumes this interface only — it does not branch on provider type.
+ */
+export interface IVolumeOperations {
+    readonly capabilities: VolumeOperationsCapabilities;
+    createSnapshot(input: CreateSnapshotInput): Promise<SnapshotResult>;
+    deleteSnapshot(input: DeleteSnapshotInput): Promise<void>;
+    listSnapshots(input: ListSnapshotsInput): Promise<SnapshotSummary[]>;
+    createPvcFromSnapshot(input: CreatePvcFromSnapshotInput): Promise<{
+        pvcName: string;
+    }>;
+}

package/lib/src/modules/providers/interfaces/volume-operations.interface.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Provider-side volume operations: snapshot creation, listing, deletion, and
+ * restore-to-new-PVC. Abstracts over the asymmetry between providers that
+ * support native CSI VolumeSnapshot (Scaleway, OVH, IONOS) and those that
+ * don't (Hetzner — see csi-driver issue #88, no snapshot/clone support).
+ *
+ * The user-facing terminology is uniform ("snapshot"), but on providers
+ * without native support the implementation may degrade to a labeled PVC
+ * clone via the copy-pod pattern (a Job that mounts source + dest PVC and
+ * tars data across).
+ *
+ * The capabilities object lets higher-level services (CLI, cost estimator,
+ * migration orchestrator) decide which operations to expose and how much
+ * they will cost.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/modules/providers/mappers/node-size.mapper.d.ts

@@ -0,0 +1,20 @@
+import { NodeSizeDto } from '../dto/node-size.dto';
+import { ListServerTypes200ResponseServerTypesInner } from '../../../modules/providers/implementations/hetzner/generated';
+export declare class NodeSizeMapper {
+    /**
+     * Maps Hetzner ServerType to NodeSizeDto
+     */
+    mapHetznerServerTypeToDto(serverType: ListServerTypes200ResponseServerTypesInner): NodeSizeDto;
+    /**
+     * Maps Hetzner price data to NodeSizePriceDto
+     */
+    private mapPrice;
+    /**
+     * Maps Hetzner location data to NodeSizeLocationDto
+     */
+    private mapLocation;
+    /**
+     * Maps multiple Hetzner ServerTypes to DTOs
+     */
+    mapHetznerServerTypesToDtos(serverTypes: ListServerTypes200ResponseServerTypesInner[]): NodeSizeDto[];
+}

package/lib/src/modules/providers/mappers/node-size.mapper.js

@@ -0,0 +1,75 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeSizeMapper = void 0;
+const common_1 = require("@nestjs/common");
+let NodeSizeMapper = class NodeSizeMapper {
+    /**
+     * Maps Hetzner ServerType to NodeSizeDto
+     */
+    mapHetznerServerTypeToDto(serverType) {
+        return {
+            id: serverType.id.toString(),
+            name: serverType.name,
+            description: serverType.description,
+            cores: serverType.cores,
+            memory: serverType.memory,
+            disk: serverType.disk,
+            storageType: serverType.storage_type,
+            cpuType: serverType.cpu_type,
+            architecture: serverType.architecture,
+            deprecated: serverType.deprecated,
+            bareMetal: false,
+            managedFirewall: true,
+            supportsHourlyBilling: true,
+            prices: serverType.prices.map((price) => this.mapPrice(price)),
+            locations: serverType.locations?.map((loc) => this.mapLocation(loc)) || [],
+        };
+    }
+    /**
+     * Maps Hetzner price data to NodeSizePriceDto
+     */
+    mapPrice(price) {
+        return {
+            location: price.location,
+            priceHourly: {
+                net: price.price_hourly.net,
+                gross: price.price_hourly.gross,
+            },
+            priceMonthly: {
+                net: price.price_monthly.net,
+                gross: price.price_monthly.gross,
+            },
+        };
+    }
+    /**
+     * Maps Hetzner location data to NodeSizeLocationDto
+     */
+    mapLocation(location) {
+        return {
+            id: location.id,
+            name: location.name,
+            deprecation: location.deprecation
+                ? {
+                    unavailable_after: location.deprecation.unavailable_after,
+                    announced: location.deprecation.announced,
+                }
+                : null,
+        };
+    }
+    /**
+     * Maps multiple Hetzner ServerTypes to DTOs
+     */
+    mapHetznerServerTypesToDtos(serverTypes) {
+        return serverTypes.map((st) => this.mapHetznerServerTypeToDto(st));
+    }
+};
+exports.NodeSizeMapper = NodeSizeMapper;
+exports.NodeSizeMapper = NodeSizeMapper = __decorate([
+    (0, common_1.Injectable)()
+], NodeSizeMapper);

package/lib/src/modules/providers/mappers/pricing.mapper.d.ts

@@ -0,0 +1,14 @@
+import { PricingDto } from '../dto/pricing.dto';
+import { CloudProvider } from '../enums/cloud-provider.enum';
+import { GetPricing200ResponsePricing } from '../../../modules/providers/implementations/hetzner/generated';
+export declare class PricingMapper {
+    /**
+     * Maps Hetzner pricing data to PricingDto
+     * Optionally filters by region and nodeSize
+     */
+    mapHetznerPricingToDto(pricing: GetPricing200ResponsePricing, provider: CloudProvider, regionFilter?: string, nodeSizeFilter?: string): PricingDto;
+    /**
+     * Maps a single server type pricing
+     */
+    private mapServerTypePricing;
+}

package/lib/src/modules/providers/mappers/pricing.mapper.js

@@ -0,0 +1,60 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PricingMapper = void 0;
+const common_1 = require("@nestjs/common");
+let PricingMapper = class PricingMapper {
+    /**
+     * Maps Hetzner pricing data to PricingDto
+     * Optionally filters by region and nodeSize
+     */
+    mapHetznerPricingToDto(pricing, provider, regionFilter, nodeSizeFilter) {
+        let serverTypes = pricing.server_types;
+        // Filter by nodeSize (server type name)
+        if (nodeSizeFilter) {
+            serverTypes = serverTypes.filter((st) => st.name.toLowerCase() === nodeSizeFilter.toLowerCase());
+        }
+        // Map server types and optionally filter prices by region
+        const mappedServerTypes = serverTypes.map((st) => this.mapServerTypePricing(st, regionFilter));
+        return {
+            provider: provider.toLowerCase(),
+            currency: pricing.currency,
+            vatRate: pricing.vat_rate,
+            serverTypes: mappedServerTypes,
+        };
+    }
+    /**
+     * Maps a single server type pricing
+     */
+    mapServerTypePricing(serverType, regionFilter) {
+        let prices = serverType.prices;
+        // Filter by region/location
+        if (regionFilter) {
+            prices = prices.filter((p) => p.location.toLowerCase() === regionFilter.toLowerCase());
+        }
+        return {
+            id: serverType.id.toString(),
+            name: serverType.name,
+            prices: prices.map((price) => ({
+                location: price.location,
+                priceHourly: {
+                    net: price.price_hourly.net,
+                    gross: price.price_hourly.gross,
+                },
+                priceMonthly: {
+                    net: price.price_monthly.net,
+                    gross: price.price_monthly.gross,
+                },
+            })),
+        };
+    }
+};
+exports.PricingMapper = PricingMapper;
+exports.PricingMapper = PricingMapper = __decorate([
+    (0, common_1.Injectable)()
+], PricingMapper);

package/lib/src/modules/providers/provider-core.module.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Shared provider core module — contains only components with no storage dependencies.
+ * Used by both ProvidersModule (API) and CliProvidersModule (CLI).
+ *
+ * @Global() makes NodeSizeMapper, PricingMapper, LabelService (via CommonModule),
+ * CacheService, and ConfigService available to all provider implementation modules
+ * (HetznerProviderModule, ContaboProviderModule, etc.) without explicit imports.
+ *
+ * Does NOT include cloud provider services (Hetzner, Contabo) because they depend
+ * on ICredentialProvider which differs between API (DB) and CLI (file).
+ */
+export declare class ProviderCoreModule {
+}

package/lib/src/modules/providers/provider-core.module.js

@@ -0,0 +1,59 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderCoreModule = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const common_module_1 = require("../common/common.module");
+const certificate_provider_factory_1 = require("./core/factories/certificate-provider.factory");
+const tokens_1 = require("./core/tokens");
+const certificate_provider_enum_1 = require("./enums/certificate-provider.enum");
+const node_size_mapper_1 = require("./mappers/node-size.mapper");
+const pricing_mapper_1 = require("./mappers/pricing.mapper");
+const acme_certificate_service_1 = require("./services/acme-certificate.service");
+/**
+ * Shared provider core module — contains only components with no storage dependencies.
+ * Used by both ProvidersModule (API) and CliProvidersModule (CLI).
+ *
+ * @Global() makes NodeSizeMapper, PricingMapper, LabelService (via CommonModule),
+ * CacheService, and ConfigService available to all provider implementation modules
+ * (HetznerProviderModule, ContaboProviderModule, etc.) without explicit imports.
+ *
+ * Does NOT include cloud provider services (Hetzner, Contabo) because they depend
+ * on ICredentialProvider which differs between API (DB) and CLI (file).
+ */
+let ProviderCoreModule = class ProviderCoreModule {
+};
+exports.ProviderCoreModule = ProviderCoreModule;
+exports.ProviderCoreModule = ProviderCoreModule = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({
+        imports: [config_1.ConfigModule, common_module_1.CommonModule],
+        providers: [
+            node_size_mapper_1.NodeSizeMapper,
+            pricing_mapper_1.PricingMapper,
+            acme_certificate_service_1.AcmeCertificateService,
+            {
+                provide: tokens_1.CERTIFICATE_PROVIDER_REGISTRY,
+                useFactory: (service) => [
+                    { provider: certificate_provider_enum_1.CertificateProvider.LETS_ENCRYPT, service },
+                    { provider: certificate_provider_enum_1.CertificateProvider.LETS_ENCRYPT_STAGING, service },
+                ],
+                inject: [acme_certificate_service_1.AcmeCertificateService],
+            },
+            certificate_provider_factory_1.CertificateProviderFactory,
+        ],
+        exports: [
+            common_module_1.CommonModule,
+            node_size_mapper_1.NodeSizeMapper,
+            pricing_mapper_1.PricingMapper,
+            acme_certificate_service_1.AcmeCertificateService,
+            certificate_provider_factory_1.CertificateProviderFactory,
+        ],
+    })
+], ProviderCoreModule);

package/lib/src/modules/providers/providers.module.d.ts

@@ -0,0 +1,2 @@
+export declare class ProvidersModule {
+}