@geekmidas/cli 1.5.0 → 1.5.1

package/dist/index.mjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env -S npx tsx
 import { __require } from "./chunk-Duj1WY3L.mjs";
-import { getAppBuildOrder, getDependencyEnvVars, getDeployTargetError, isDeployTargetSupported } from "./workspace-BW2iU37P.mjs";
-import { getAppNameFromCwd, loadAppConfig, loadConfig, loadWorkspaceConfig, parseModuleConfig } from "./config-DfCJ29PQ.mjs";
+import { getAppBuildOrder, getDependencyEnvVars, getDeployTargetError, isDeployTargetSupported } from "./workspace-Dy8k7Wru.mjs";
+import { getAppNameFromCwd, loadAppConfig, loadConfig, loadWorkspaceConfig, parseModuleConfig } from "./config-dLNQIvDR.mjs";
 import { getCredentialsPath, getDokployCredentials, getDokployRegistryId, getDokployToken, removeDokployCredentials, storeDokployCredentials, storeDokployRegistryId } from "./credentials-s1kLcIzK.mjs";
-import { ConstructGenerator, EndpointGenerator, OPENAPI_OUTPUT_PATH, generateOpenApi, openapiCommand, resolveOpenApiConfig } from "./openapi-BcSjLfWq.mjs";
+import { ConstructGenerator, EndpointGenerator, OPENAPI_OUTPUT_PATH, generateOpenApi, openapiCommand, resolveOpenApiConfig } from "./openapi-CMTyaIJJ.mjs";
 import { getKeyPath, maskPassword, readStageSecrets, secretsExist, setCustomSecret, toEmbeddableSecrets, writeStageSecrets } from "./storage-DmCbr6DI.mjs";
-import { DokployApi } from "./dokploy-api-z0833e7r.mjs";
+import { DokployApi } from "./dokploy-api-2ldYoN3i.mjs";
 import { encryptSecrets } from "./encryption-BOH5M-f-.mjs";
 import { CachedStateProvider } from "./CachedStateProvider-BDq5WqSy.mjs";
 import { generateReactQueryCommand } from "./openapi-react-query-DaTMSPD5.mjs";
@@ -32,7 +32,7 @@ import prompts from "prompts";
 
 //#region package.json
 var name = "@geekmidas/cli";
-var version = "1.4.0";
+var version = "1.5.0";
 var description = "CLI tools for building Lambda handlers, server applications, and generating OpenAPI specs";
 var private$1 = false;
 var type = "module";
@@ -78,7 +78,9 @@ var repository = {
 };
 var dependencies = {
 	"@apidevtools/swagger-parser": "^10.1.0",
+	"@aws-sdk/client-iam": "~3.971.0",
 	"@aws-sdk/client-route-53": "~3.971.0",
+	"@aws-sdk/client-s3": "~3.971.0",
 	"@aws-sdk/client-ssm": "~3.971.0",
 	"@aws-sdk/credential-providers": "~3.971.0",
 	"@geekmidas/constructs": "workspace:~",
@@ -132,7 +134,7 @@ const logger$11 = console;
 * Validate Dokploy token by making a test API call
 */
 async function validateDokployToken(endpoint, token) {
-	const { DokployApi: DokployApi$1 } = await import("./dokploy-api-DSJYNx88.mjs");
+	const { DokployApi: DokployApi$1 } = await import("./dokploy-api-C93pveuy.mjs");
 	const api = new DokployApi$1({
 		baseUrl: endpoint,
 		token
@@ -417,7 +419,7 @@ var FunctionGenerator = class extends ConstructGenerator {
 		const importPath = relativePath.replace(/\.ts$/, ".js");
 		const relativeEnvParserPath = relative(dirname(handlerPath), context.envParserPath);
 		const relativeLoggerPath = relative(dirname(handlerPath), context.loggerPath);
-		const content = `import { AWSLambdaFunction } from '@geekmidas/constructs/functions';
+		const content = `import { AWSLambdaFunction } from '@geekmidas/constructs/aws';
 import { ${exportName} } from '${importPath}';
 import ${context.envParserImportPattern} from '${relativeEnvParserPath}';
 import ${context.loggerImportPattern} from '${relativeLoggerPath}';
@@ -2176,6 +2178,41 @@ function isDnsVerified(state, hostname, serverIp) {
 	const record = state?.dnsVerified?.[hostname];
 	return record?.serverIp === serverIp;
 }
+/**
+* Get the key for a DNS record in state
+*/
+function getDnsRecordKey(name$1, type$1) {
+	return `${name$1}:${type$1}`;
+}
+/**
+* Set a created DNS record in state (mutates state)
+*/
+function setDnsRecord(state, record) {
+	if (!state.dnsRecords) state.dnsRecords = {};
+	const key = getDnsRecordKey(record.name, record.type);
+	state.dnsRecords[key] = {
+		...record,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+/**
+* Get backup state from state
+*/
+function getBackupState(state) {
+	return state?.backups;
+}
+/**
+* Set backup state (mutates state)
+*/
+function setBackupState(state, backupState) {
+	state.backups = backupState;
+}
+/**
+* Set postgres backup ID in state (mutates state)
+*/
+function setPostgresBackupId(state, backupId) {
+	if (state.backups) state.backups.postgresBackupId = backupId;
+}
 
 //#endregion
 //#region src/deploy/dns/DnsProvider.ts
@@ -2183,7 +2220,7 @@ function isDnsVerified(state, hostname, serverIp) {
 * Check if value is a DnsProvider implementation.
 */
 function isDnsProvider(value) {
-	return typeof value === "object" && value !== null && typeof value.name === "string" && typeof value.getRecords === "function" && typeof value.upsertRecords === "function";
+	return typeof value === "object" && value !== null && typeof value.name === "string" && typeof value.getRecords === "function" && typeof value.upsertRecords === "function" && typeof value.deleteRecords === "function";
 }
 /**
 * Create a DNS provider based on configuration.
@@ -2199,11 +2236,11 @@ async function createDnsProvider(options) {
 	if (isDnsProvider(config$1.provider)) return config$1.provider;
 	const provider = config$1.provider;
 	if (provider === "hostinger") {
-		const { HostingerProvider } = await import("./HostingerProvider-B9N-TKbp.mjs");
+		const { HostingerProvider } = await import("./HostingerProvider-402UdK89.mjs");
 		return new HostingerProvider();
 	}
 	if (provider === "route53") {
-		const { Route53Provider } = await import("./Route53Provider-C8mS0zY6.mjs");
+		const { Route53Provider } = await import("./Route53Provider-DbBo7Uz5.mjs");
 		const route53Config = config$1;
 		return new Route53Provider({
 			region: route53Config.region,
@@ -2414,8 +2451,13 @@ async function createDnsRecordsForDomain(records, rootDomain, providerConfig) {
 * Supports both legacy single-domain format and new multi-domain format:
 * - Legacy: { provider: 'hostinger', domain: 'example.com' }
 * - Multi:  { 'example.com': { provider: 'hostinger' }, 'example.dev': { provider: 'route53' } }
+*
+* @param appHostnames - Map of app names to hostnames
+* @param dnsConfig - DNS configuration (legacy or multi-domain)
+* @param dokployEndpoint - Dokploy server endpoint to resolve IP from
+* @param state - Optional state to save created records for later deletion
 */
-async function orchestrateDns(appHostnames, dnsConfig, dokployEndpoint) {
+async function orchestrateDns(appHostnames, dnsConfig, dokployEndpoint, state) {
 	if (!dnsConfig) return null;
 	const normalizedConfig = normalizeDnsConfig(dnsConfig);
 	logger$6.log("\n🌐 Setting up DNS records...");
@@ -2461,6 +2503,15 @@ async function orchestrateDns(appHostnames, dnsConfig, dokployEndpoint) {
 			logger$6.log(`   ⚠ ${failed} record(s) failed for ${rootDomain}`);
 			hasFailures = true;
 		}
+		if (state) {
+			for (const record of domainRecords) if (record.created || record.existed) setDnsRecord(state, {
+				domain: rootDomain,
+				name: record.subdomain,
+				type: record.type,
+				value: record.value,
+				ttl: "ttl" in providerConfig && providerConfig.ttl ? providerConfig.ttl : 300
+			});
+		}
 		printDnsRecordsTable(domainRecords, rootDomain);
 		if (providerConfig.provider === "manual" || failed > 0) printDnsRecordsSimple(domainRecords.filter((r) => !r.created && !r.existed), rootDomain);
 	}
@@ -5008,27 +5059,40 @@ async function initializePostgresUsers(api, postgres, serverHostname, users) {
 		for (const user of users) {
 			const schemaName = user.usePublicSchema ? "public" : user.name;
 			logger$1.log(`   Creating user "${user.name}" with schema "${schemaName}"...`);
-			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 $$;
-			`);
-			if (user.usePublicSchema) await client.query(`
+			if (user.usePublicSchema) {
+				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 await client.query(`
+			} else {
+				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}";
 				`);
+			}
 			logger$1.log(`   ✓ User "${user.name}" configured`);
 		}
 	} finally {
@@ -5534,6 +5598,36 @@ async function workspaceDeployCommand(workspace, options) {
 			await initializePostgresUsers(api, provisionedPostgres, serverHostname, usersToCreate);
 		}
 	}
+	if (workspace.deploy?.backups && provisionedPostgres) {
+		logger$1.log("\n💾 Provisioning backup destination...");
+		const { provisionBackupDestination } = await import("./backup-provisioner-BIArpmTr.mjs");
+		const backupState = await provisionBackupDestination({
+			api,
+			projectId: project.projectId,
+			projectName: workspace.name,
+			stage,
+			config: workspace.deploy.backups,
+			existingState: getBackupState(state),
+			logger: logger$1
+		});
+		setBackupState(state, backupState);
+		if (!backupState.postgresBackupId) {
+			const backupSchedule = workspace.deploy.backups.schedule ?? "0 2 * * *";
+			const backupRetention = workspace.deploy.backups.retention ?? 30;
+			logger$1.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$1.log(`   ✓ Postgres backup schedule created (${backupSchedule})`);
+		} else logger$1.log("   ✓ Using existing postgres backup schedule");
+	}
 	const publicUrls = {};
 	const results = [];
 	const dokployConfig = workspace.deploy.dokploy;
@@ -6275,10 +6369,10 @@ const GEEKMIDAS_VERSIONS = {
 	"@geekmidas/cache": "~1.0.0",
 	"@geekmidas/client": "~1.0.0",
 	"@geekmidas/cloud": "~1.0.0",
-	"@geekmidas/constructs": "~1.0.0",
+	"@geekmidas/constructs": "~1.0.4",
 	"@geekmidas/db": "~1.0.0",
 	"@geekmidas/emailkit": "~1.0.0",
-	"@geekmidas/envkit": "~1.0.0",
+	"@geekmidas/envkit": "~1.0.1",
 	"@geekmidas/errors": "~1.0.0",
 	"@geekmidas/events": "~1.0.0",
 	"@geekmidas/logger": "~1.0.0",