export command

eslint.config.js

@@ -35,6 +35,7 @@ export default [
 				RequestInit: 'readonly',
 				fetch: 'readonly',
 				process: 'readonly',
+				console: true,
 			},
 		},
 	},

source/commands/env/export/components/ExportContent.tsx

@@ -0,0 +1,114 @@
+import React from 'react';
+import { useApiKeyApi } from '../../../../hooks/useApiKeyApi.js';
+import { useAuth } from '../../../../components/AuthProvider.js';
+import { ExportOptions } from '../types.js';
+import { ExportStatus } from './ExportStatus.js';
+import { useExport } from './hooks/useExport.js';
+import fs from 'node:fs/promises';
+
+export const ExportContent: React.FC<{ options: ExportOptions }> = ({
+	options: { key: apiKey, file },
+}) => {
+	const { validateApiKeyScope } = useApiKeyApi();
+	const { authToken } = useAuth();
+	const key = apiKey || authToken;
+	const { state, setState, exportConfig } = useExport(key);
+
+	React.useEffect(() => {
+		let isSubscribed = true;
+
+		const runExport = async () => {
+			if (!key) {
+				setState({
+					status: '',
+					error: 'No API key provided. Please provide a key or login first.',
+					isComplete: true,
+					warnings: [],
+				});
+				return;
+			}
+
+			try {
+				setState(prev => ({ ...prev, status: 'Validating API key...' }));
+				const {
+					valid,
+					error: scopeError,
+					scope,
+				} = await validateApiKeyScope(key, 'environment');
+
+				if (!valid || scopeError || !scope) {
+					setState({
+						status: '',
+						error: `Invalid API key: ${scopeError || 'No scope found'}`,
+						isComplete: true,
+						warnings: [],
+					});
+					return;
+				}
+
+				// Normalize the environment_id and project_id to match ExportScope
+				const normalizedScope = {
+					...scope,
+					environment_id: scope.environment_id || undefined,
+					project_id: scope.project_id || undefined,
+				};
+
+				if (!isSubscribed) return;
+
+				setState(prev => ({
+					...prev,
+					status: 'Initializing export...',
+				}));
+
+				const { hcl, warnings } = await exportConfig(normalizedScope);
+
+				if (!isSubscribed) return;
+
+				if (file) {
+					setState(prev => ({ ...prev, status: 'Saving to file...' }));
+					try {
+						await fs.writeFile(file, hcl);
+					} catch (error) {
+						const errorMessage =
+							error instanceof Error ? error.message : String(error);
+						setState({
+							status: '',
+							error: `Failed to export configuration: ${errorMessage}`,
+							isComplete: true,
+							warnings: [],
+						});
+						return;
+					}
+				} else {
+					console.log(hcl);
+				}
+
+				if (!isSubscribed) return;
+
+				setState({
+					status: '',
+					error: null,
+					isComplete: true,
+					warnings,
+				});
+			} catch (err) {
+				if (!isSubscribed) return;
+				const errorMsg = err instanceof Error ? err.message : String(err);
+				setState({
+					status: '',
+					error: `Failed to export configuration: ${errorMsg}`,
+					isComplete: true,
+					warnings: [],
+				});
+			}
+		};
+
+		runExport();
+
+		return () => {
+			isSubscribed = false;
+		};
+	}, [key, file, validateApiKeyScope]);
+
+	return <ExportStatus state={state} file={file} />;
+};

source/commands/env/export/components/ExportStatus.tsx

@@ -0,0 +1,57 @@
+import React from 'react';
+import { Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { ExportState } from '../types.js';
+
+interface ExportStatusProps {
+	state: ExportState;
+	file?: string;
+}
+
+export const ExportStatus: React.FC<ExportStatusProps> = ({ state, file }) => {
+	if (state.error) {
+		return (
+			<>
+				<Text color="red">Error: {state.error}</Text>
+				{state.warnings.length > 0 && (
+					<>
+						<Text color="yellow">Warnings:</Text>
+						{state.warnings.map((warning, i) => (
+							<Text key={i} color="yellow">
+								- {warning}
+							</Text>
+						))}
+					</>
+				)}
+			</>
+		);
+	}
+
+	if (!state.isComplete) {
+		return (
+			<>
+				<Text>
+					<Spinner type="dots" />{' '}
+					{state.status || 'Exporting environment configuration...'}
+				</Text>
+			</>
+		);
+	}
+
+	return (
+		<>
+			<Text color="green">Export completed successfully!</Text>
+			{file && <Text>HCL content has been saved to: {file}</Text>}
+			{state.warnings.length > 0 && (
+				<>
+					<Text color="yellow">Warnings during export:</Text>
+					{state.warnings.map((warning, i) => (
+						<Text key={i} color="yellow">
+							- {warning}
+						</Text>
+					))}
+				</>
+			)}
+		</>
+	);
+};

source/commands/env/export/components/hooks/PermitSDK.ts

@@ -0,0 +1,13 @@
+import { Permit } from 'permitio';
+import React from 'react';
+
+export const PermitSDK = (token: string) => {
+	return React.useMemo(
+		() =>
+			new Permit({
+				token,
+				pdp: 'http://localhost:7766',
+			}),
+		[token],
+	);
+};

source/commands/env/export/components/hooks/useExport.ts

@@ -0,0 +1,70 @@
+import { useState } from 'react';
+import { PermitSDK } from './PermitSDK.js';
+import { ExportState } from '../../types.js';
+import { createWarningCollector, generateProviderBlock } from '../../utils.js';
+import { ResourceGenerator } from '../../generators/ResourceGenerator.js';
+import { RoleGenerator } from '../../generators/RoleGenerator.js';
+import { UserAttributesGenerator } from '../../generators/UserAttributesGenerator.js';
+import { RelationGenerator } from '../../generators/RelationGenerator.js';
+import { ConditionSetGenerator } from '../../generators/ConditionSetGenerator.js';
+
+// Define a type for the `scope` parameter
+interface ExportScope {
+	environment_id?: string;
+	project_id?: string;
+	organization_id?: string;
+}
+
+export const useExport = (apiKey: string) => {
+	const [state, setState] = useState<ExportState>({
+		status: '',
+		isComplete: false,
+		error: null,
+		warnings: [],
+	});
+
+	const permit = PermitSDK(apiKey);
+
+	const exportConfig = async (scope: ExportScope) => {
+		try {
+			const warningCollector = createWarningCollector();
+
+			let hcl = `# Generated by Permit CLI
+# Environment: ${scope?.environment_id || 'unknown'}
+# Project: ${scope?.project_id || 'unknown'}
+# Organization: ${scope?.organization_id || 'unknown'}
+${generateProviderBlock(apiKey)}`;
+
+			const generators = [
+				new ResourceGenerator(permit, warningCollector),
+				new RoleGenerator(permit, warningCollector),
+				new UserAttributesGenerator(permit, warningCollector),
+				new RelationGenerator(permit, warningCollector),
+				new ConditionSetGenerator(permit, warningCollector),
+			];
+
+			for (const generator of generators) {
+				setState(prev => ({
+					...prev,
+					status: `Exporting ${generator.name}...`,
+				}));
+
+				const generatedHCL = await generator.generateHCL();
+				if (generatedHCL) {
+					hcl += generatedHCL;
+				}
+			}
+
+			return { hcl, warnings: warningCollector.getWarnings() };
+		} catch (error) {
+			console.error('Export error:', error);
+			throw error;
+		}
+	};
+
+	return {
+		state,
+		setState,
+		exportConfig,
+	};
+};

source/commands/env/export/generators/ConditionSetGenerator.ts

@@ -0,0 +1,62 @@
+import { Permit } from 'permitio';
+import { HCLGenerator, WarningCollector } from '../types.js';
+import { createSafeId } from '../utils.js';
+
+export class ConditionSetGenerator implements HCLGenerator {
+	name = 'condition sets';
+
+	constructor(
+		private permit: Permit,
+		private warningCollector: WarningCollector,
+	) {}
+
+	async generateHCL(): Promise<string> {
+		try {
+			const conditionSets = await this.permit.api.conditionSets.list();
+			if (
+				!conditionSets ||
+				!Array.isArray(conditionSets) ||
+				conditionSets.length === 0
+			) {
+				return '';
+			}
+
+			let hcl = '\n# Condition Sets\n';
+
+			for (const set of conditionSets) {
+				try {
+					const isResourceSet = set.type === 'resourceset';
+					const resourceType = isResourceSet ? 'resource_set' : 'user_set';
+
+					// Handle conditions - ensure they are properly stringified
+					const conditions =
+						typeof set.conditions === 'string'
+							? set.conditions
+							: JSON.stringify(set.conditions || '');
+
+					hcl += `resource "permitio_${resourceType}" "${createSafeId(set.key)}" {
+  key = "${set.key}"
+  name = "${set.name}"${
+		set.description ? `\n  description = "${set.description}"` : ''
+	}
+  conditions = ${conditions}${
+		set.resource ? `\n  resource = "${set.resource}"` : ''
+	}
+}\n`;
+				} catch (setError) {
+					this.warningCollector.addWarning(
+						`Failed to export condition set ${set.key}: ${setError}`,
+					);
+					continue;
+				}
+			}
+
+			return hcl;
+		} catch (error) {
+			this.warningCollector.addWarning(
+				`Failed to export condition sets: ${error}`,
+			);
+			return '';
+		}
+	}
+}