@geekmidas/cli 1.5.0 → 1.6.0

package/src/deploy/dokploy-api.ts

@@ -154,6 +154,13 @@ export class DokployApi {
 		});
 	}
 
+	/**
+	 * Delete a project and all its resources
+	 */
+	async deleteProject(projectId: string): Promise<void> {
+		await this.post('project.remove', { projectId });
+	}
+
 	// ============================================
 	// Environment endpoints
 	// ============================================
@@ -315,6 +322,13 @@ export class DokployApi {
 		await this.post('application.deploy', { applicationId });
 	}
 
+	/**
+	 * Delete an application
+	 */
+	async deleteApplication(applicationId: string): Promise<void> {
+		await this.post('application.remove', { applicationId });
+	}
+
 	// ============================================
 	// Registry endpoints
 	// ============================================
@@ -505,6 +519,13 @@ export class DokployApi {
 		await this.post('postgres.update', { postgresId, ...updates });
 	}
 
+	/**
+	 * Delete a Postgres database
+	 */
+	async deletePostgres(postgresId: string): Promise<void> {
+		await this.post('postgres.remove', { postgresId });
+	}
+
 	// ============================================
 	// Redis endpoints
 	// ============================================
@@ -626,6 +647,13 @@ export class DokployApi {
 		await this.post('redis.update', { redisId, ...updates });
 	}
 
+	/**
+	 * Delete a Redis instance
+	 */
+	async deleteRedis(redisId: string): Promise<void> {
+		await this.post('redis.remove', { redisId });
+	}
+
 	// ============================================
 	// Domain endpoints
 	// ============================================
@@ -704,6 +732,144 @@ export class DokployApi {
 			serverId,
 		});
 	}
+
+	// ============================================
+	// Destination endpoints (backup storage)
+	// ============================================
+
+	/**
+	 * List all backup destinations
+	 */
+	async listDestinations(): Promise<DokployDestination[]> {
+		return this.get<DokployDestination[]>('destination.all');
+	}
+
+	/**
+	 * Get a destination by ID
+	 */
+	async getDestination(destinationId: string): Promise<DokployDestination> {
+		return this.get<DokployDestination>(
+			`destination.one?destinationId=${destinationId}`,
+		);
+	}
+
+	/**
+	 * Create a new S3 backup destination
+	 */
+	async createDestination(
+		options: DokployDestinationCreate,
+	): Promise<DokployDestination> {
+		return this.post<DokployDestination>('destination.create', { ...options });
+	}
+
+	/**
+	 * Find a destination by name
+	 */
+	async findDestinationByName(
+		name: string,
+	): Promise<DokployDestination | undefined> {
+		const destinations = await this.listDestinations();
+		return destinations.find((d) => d.name === name);
+	}
+
+	/**
+	 * Find or create a destination by name
+	 */
+	async findOrCreateDestination(
+		name: string,
+		options: Omit<DokployDestinationCreate, 'name'>,
+	): Promise<{ destination: DokployDestination; created: boolean }> {
+		const existing = await this.findDestinationByName(name);
+		if (existing) {
+			return { destination: existing, created: false };
+		}
+		const destination = await this.createDestination({ name, ...options });
+		return { destination, created: true };
+	}
+
+	/**
+	 * Update a destination
+	 */
+	async updateDestination(
+		destinationId: string,
+		updates: Partial<DokployDestinationCreate>,
+	): Promise<void> {
+		await this.post('destination.update', { destinationId, ...updates });
+	}
+
+	/**
+	 * Delete a destination
+	 */
+	async deleteDestination(destinationId: string): Promise<void> {
+		await this.post('destination.remove', { destinationId });
+	}
+
+	/**
+	 * Test connection to a destination
+	 */
+	async testDestinationConnection(
+		destinationId: string,
+	): Promise<{ success: boolean }> {
+		return this.post<{ success: boolean }>('destination.testConnection', {
+			destinationId,
+		});
+	}
+
+	// ============================================
+	// Backup endpoints (scheduled backups)
+	// ============================================
+
+	/**
+	 * Create a backup schedule for postgres
+	 */
+	async createPostgresBackup(
+		options: DokployBackupCreate,
+	): Promise<DokployBackup> {
+		return this.post<DokployBackup>('backup.create', {
+			...options,
+			databaseType: 'postgres',
+		});
+	}
+
+	/**
+	 * List backups for a postgres database
+	 */
+	async listPostgresBackups(postgresId: string): Promise<DokployBackup[]> {
+		return this.get<DokployBackup[]>(
+			`backup.all?postgresId=${postgresId}&databaseType=postgres`,
+		);
+	}
+
+	/**
+	 * Get a backup by ID
+	 */
+	async getBackup(backupId: string): Promise<DokployBackup> {
+		return this.get<DokployBackup>(`backup.one?backupId=${backupId}`);
+	}
+
+	/**
+	 * Update a backup schedule
+	 */
+	async updateBackup(
+		backupId: string,
+		updates: Partial<DokployBackupUpdate>,
+	): Promise<void> {
+		await this.post('backup.update', { backupId, ...updates });
+	}
+
+	/**
+	 * Delete a backup schedule
+	 */
+	async deleteBackup(backupId: string): Promise<void> {
+		await this.post('backup.remove', { backupId });
+	}
+
+	/**
+	 * Trigger a manual backup run
+	 */
+	async runBackupManually(backupId: string): Promise<void> {
+		await this.post('backup.manualBackup', { backupId });
+	}
 }
 
 // ============================================
@@ -835,6 +1001,77 @@ export interface DokployDomain extends DokployDomainCreate {
 	createdAt?: string;
 }
 
+// ============================================
+// Destination types (backup storage)
+// ============================================
+
+export interface DokployDestination {
+	destinationId: string;
+	name: string;
+	accessKey: string;
+	bucket: string;
+	region: string;
+	endpoint: string | null;
+	createdAt?: string;
+}
+
+export interface DokployDestinationCreate {
+	/** User-friendly name for the destination */
+	name: string;
+	/** S3 access key ID */
+	accessKey: string;
+	/** S3 secret access key */
+	secretAccessKey: string;
+	/** S3 bucket name */
+	bucket: string;
+	/** AWS region (e.g., 'us-east-1') */
+	region: string;
+	/** Optional endpoint for S3-compatible services */
+	endpoint?: string;
+}
+
+// ============================================
+// Backup types (scheduled backups)
+// ============================================
+
+export type DokployDatabaseType = 'postgres' | 'mysql' | 'mariadb' | 'mongo';
+
+export interface DokployBackup {
+	backupId: string;
+	schedule: string;
+	prefix: string;
+	enabled: boolean;
+	destinationId: string;
+	postgresId?: string;
+	databaseType: DokployDatabaseType;
+	keepLatestCount: number | null;
+	createdAt?: string;
+}
+
+export interface DokployBackupCreate {
+	/** Cron schedule (e.g., '0 2 * * *' for 2 AM daily) */
+	schedule: string;
+	/** Backup file prefix (e.g., 'production/postgres') */
+	prefix: string;
+	/** Destination ID for backup storage */
+	destinationId: string;
+	/** Database name to backup */
+	database: string;
+	/** Postgres instance ID */
+	postgresId: string;
+	/** Enable/disable backup (default: true) */
+	enabled?: boolean;
+	/** Number of backups to keep (default: keep all) */
+	keepLatestCount?: number;
+}
+
+export interface DokployBackupUpdate {
+	schedule?: string;
+	prefix?: string;
+	enabled?: boolean;
+	keepLatestCount?: number;
+}
+
 /**
  * Create a Dokploy API client from stored credentials or environment
  */

package/src/deploy/index.ts

@@ -88,10 +88,13 @@ import {
 	createEmptyState,
 	getAllAppCredentials,
 	getApplicationId,
+	getBackupState,
 	getPostgresId,
 	getRedisId,
 	setAppCredentials,
 	setApplicationId,
+	setBackupState,
+	setPostgresBackupId,
 	setPostgresId,
 	setRedisId,
 } from './state.js';
@@ -325,29 +328,39 @@ async function initializePostgresUsers(
 				`   Creating user "${user.name}" with schema "${schemaName}"...`,
 			);
 
-			// Create or update user (handles existing users)
-			await client.query(`
-				DO $$ BEGIN
-					IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname = '${user.name}') THEN
-						CREATE USER "${user.name}" WITH PASSWORD '${user.password}';
-					ELSE
-						ALTER USER "${user.name}" WITH PASSWORD '${user.password}';
-					END IF;
-				END $$;
-			`);
-
+			// Create or update user with all settings in one DO block
+			// This avoids "tuple already updated by self" errors from multiple ALTER USER calls
 			if (user.usePublicSchema) {
 				// API uses public schema
+				await client.query(`
+					DO $$ BEGIN
+						IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname = '${user.name}') THEN
+							CREATE USER "${user.name}" WITH PASSWORD '${user.password}';
+						ELSE
+							ALTER USER "${user.name}" WITH PASSWORD '${user.password}';
+						END IF;
+					END $$;
+				`);
 				await client.query(`
 					GRANT ALL ON SCHEMA public TO "${user.name}";
 					ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON TABLES TO "${user.name}";
 					ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON SEQUENCES TO "${user.name}";
 				`);
 			} else {
-				// Other apps get their own schema
+				// Other apps get their own schema - combine user creation and search_path in one block
+				await client.query(`
+					DO $$ BEGIN
+						IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname = '${user.name}') THEN
+							CREATE USER "${user.name}" WITH PASSWORD '${user.password}';
+						ELSE
+							ALTER USER "${user.name}" WITH PASSWORD '${user.password}';
+						END IF;
+						-- Set search_path in same transaction to avoid tuple conflict
+						ALTER USER "${user.name}" SET search_path TO "${schemaName}";
+					END $$;
+				`);
 				await client.query(`
 					CREATE SCHEMA IF NOT EXISTS "${schemaName}" AUTHORIZATION "${user.name}";
-					ALTER USER "${user.name}" SET search_path TO "${schemaName}";
 					GRANT USAGE ON SCHEMA "${schemaName}" TO "${user.name}";
 					GRANT ALL ON ALL TABLES IN SCHEMA "${schemaName}" TO "${user.name}";
 					ALTER DEFAULT PRIVILEGES IN SCHEMA "${schemaName}" GRANT ALL ON TABLES TO "${user.name}";
@@ -1249,6 +1262,51 @@ export async function workspaceDeployCommand(
 		}
 	}
 
+	// ==================================================================
+	// Provision backup destination if configured
+	// ==================================================================
+	if (workspace.deploy?.backups && provisionedPostgres) {
+		logger.log('\n💾 Provisioning backup destination...');
+
+		const { provisionBackupDestination } = await import(
+			'./backup-provisioner.js'
+		);
+
+		const backupState = await provisionBackupDestination({
+			api,
+			projectId: project.projectId,
+			projectName: workspace.name,
+			stage,
+			config: workspace.deploy.backups,
+			existingState: getBackupState(state),
+			logger,
+		});
+
+		// Save backup state
+		setBackupState(state, backupState);
+
+		// Create backup schedule for postgres if not already configured
+		if (!backupState.postgresBackupId) {
+			const backupSchedule = workspace.deploy.backups.schedule ?? '0 2 * * *';
+			const backupRetention = workspace.deploy.backups.retention ?? 30;
+
+			logger.log('   Creating postgres backup schedule...');
+			const backup = await api.createPostgresBackup({
+				schedule: backupSchedule,
+				prefix: `${stage}/postgres`,
+				destinationId: backupState.destinationId,
+				database: provisionedPostgres.databaseName,
+				postgresId: provisionedPostgres.postgresId,
+				enabled: true,
+				keepLatestCount: backupRetention,
+			});
+			setPostgresBackupId(state, backup.backupId);
+			logger.log(`   ✓ Postgres backup schedule created (${backupSchedule})`);
+		} else {
+			logger.log('   ✓ Using existing postgres backup schedule');
+		}
+	}
+
 	// Track deployed app public URLs for frontend builds
 	const publicUrls: Record<string, string> = {};
 	const results: AppDeployResult[] = [];

package/src/deploy/state.ts

@@ -24,6 +24,48 @@ export interface DnsVerificationRecord {
 	verifiedAt: string;
 }
 
+/**
+ * A DNS record that was created during deploy
+ */
+export interface CreatedDnsRecord {
+	/** The domain this record belongs to (e.g., 'example.com') */
+	domain: string;
+	/** Record name/subdomain (e.g., 'api' or '@' for root) */
+	name: string;
+	/** Record type (A, CNAME, etc.) */
+	type: string;
+	/** Record value (IP address, hostname, etc.) */
+	value: string;
+	/** TTL in seconds */
+	ttl: number;
+	/** When this record was created */
+	createdAt: string;
+}
+
+/**
+ * Backup destination state
+ */
+export interface BackupState {
+	/** S3 bucket name for backups */
+	bucketName: string;
+	/** S3 bucket ARN */
+	bucketArn: string;
+	/** IAM user name created for backup access */
+	iamUserName: string;
+	/** IAM access key ID */
+	iamAccessKeyId: string;
+	/** IAM secret access key */
+	iamSecretAccessKey: string;
+	/** Dokploy destination ID */
+	destinationId: string;
+	/** Dokploy backup schedule ID for postgres (if configured) */
+	postgresBackupId?: string;
+	/** AWS region where bucket was created */
+	region: string;
+	/** Timestamp when backup was configured */
+	createdAt: string;
+}
+
 /**
  * State for a single stage deployment
  */
@@ -44,6 +86,10 @@ export interface DokployStageState {
 	generatedSecrets?: Record<string, Record<string, string>>;
 	/** DNS verification state per hostname */
 	dnsVerified?: Record<string, DnsVerificationRecord>;
+	/** DNS records created during deploy (keyed by "name:type", e.g., "api:A") */
+	dnsRecords?: Record<string, CreatedDnsRecord>;
+	/** Backup destination state */
+	backups?: BackupState;
 	lastDeployedAt: string;
 }
 
@@ -309,3 +355,128 @@ export function getAllDnsVerifications(
 ): Record<string, DnsVerificationRecord> {
 	return state?.dnsVerified ?? {};
 }
+
+// ============================================================================
+// DNS Records
+// ============================================================================
+
+/**
+ * Get the key for a DNS record in state
+ */
+function getDnsRecordKey(name: string, type: string): string {
+	return `${name}:${type}`;
+}
+
+/**
+ * Get a created DNS record from state
+ */
+export function getDnsRecord(
+	state: DokployStageState | null,
+	name: string,
+	type: string,
+): CreatedDnsRecord | undefined {
+	return state?.dnsRecords?.[getDnsRecordKey(name, type)];
+}
+
+/**
+ * Set a created DNS record in state (mutates state)
+ */
+export function setDnsRecord(
+	state: DokployStageState,
+	record: Omit<CreatedDnsRecord, 'createdAt'>,
+): void {
+	if (!state.dnsRecords) {
+		state.dnsRecords = {};
+	}
+	const key = getDnsRecordKey(record.name, record.type);
+	state.dnsRecords[key] = {
+		...record,
+		createdAt: new Date().toISOString(),
+	};
+}
+
+/**
+ * Remove a DNS record from state (mutates state)
+ */
+export function removeDnsRecord(
+	state: DokployStageState,
+	name: string,
+	type: string,
+): void {
+	if (state.dnsRecords) {
+		delete state.dnsRecords[getDnsRecordKey(name, type)];
+	}
+}
+
+/**
+ * Get all created DNS records from state
+ */
+export function getAllDnsRecords(
+	state: DokployStageState | null,
+): CreatedDnsRecord[] {
+	if (!state?.dnsRecords) {
+		return [];
+	}
+	return Object.values(state.dnsRecords);
+}
+
+/**
+ * Clear all DNS records from state (mutates state)
+ */
+export function clearDnsRecords(state: DokployStageState): void {
+	state.dnsRecords = {};
+	state.dnsVerified = {};
+}
+
+// ============================================================================
+// Backup State
+// ============================================================================
+
+/**
+ * Get backup state from state
+ */
+export function getBackupState(
+	state: DokployStageState | null,
+): BackupState | undefined {
+	return state?.backups;
+}
+
+/**
+ * Set backup state (mutates state)
+ */
+export function setBackupState(
+	state: DokployStageState,
+	backupState: BackupState,
+): void {
+	state.backups = backupState;
+}
+
+/**
+ * Get backup destination ID from state
+ */
+export function getBackupDestinationId(
+	state: DokployStageState | null,
+): string | undefined {
+	return state?.backups?.destinationId;
+}
+
+/**
+ * Get postgres backup ID from state
+ */
+export function getPostgresBackupId(
+	state: DokployStageState | null,
+): string | undefined {
+	return state?.backups?.postgresBackupId;
+}
+
+/**
+ * Set postgres backup ID in state (mutates state)
+ */
+export function setPostgresBackupId(
+	state: DokployStageState,
+	backupId: string,
+): void {
+	if (state.backups) {
+		state.backups.postgresBackupId = backupId;
+	}
+}