Skip to content

Modern Docker Management, Designed for Everyone

7.8 KB
Raw Blame
import { toast } from 'svelte-sonner';
import { parseDocument } from 'yaml';
import { z } from 'zod/v4';

import { arcaneButtonVariants, actionConfigs } from '#lib/components/arcane-button/variants.js';
import { m } from '#lib/paraglide/messages.js';
import { templateService } from '#lib/services/template-service.js';
import userStore from '#lib/stores/user-store.svelte.js';
import type { ProjectEditorLayout } from '#lib/types/auth.js';
import type { Template } from '#lib/types/swarm.js';
import { handleApiResultWithCallbacks } from '#lib/utils/api.js';
import { tryCatch } from '#lib/utils/try-catch.js';

export type ConvertedDockerRun = {
	dockerCompose: string;
	envVars: string;
	serviceName: string;
};

type ComposeFieldAccessors = {
	getName: () => string | undefined;
	setName: (value: string) => void;
	setComposeContent: (value: string) => void;
	setEnvContent: (value: string) => void;
};

type ComposeFormInputs = {
	name: { value: string };
	composeContent: { value: string };
	envContent: { value: string };
};

type ComposeFieldKey = keyof ComposeFormInputs;
type ComposeFieldSetter = (key: ComposeFieldKey, value: string) => void;

export const templateBtnClass = arcaneButtonVariants({
	tone: actionConfigs.template?.tone ?? 'outline-primary',
	size: 'default',
	hoverEffect: 'none'
});

// Shared file-tree ResizableSplit preset for the compose editor pages
// (project detail + new project); size binding and persistKey stay per-page.
export const composeTreeSplitProps = {
	variant: 'flush',
	firstClass: 'bg-muted/20 border-border flex min-h-0 flex-col border-b lg:border-r lg:border-b-0',
	secondClass: 'flex min-h-0 flex-col',
	minSize: 200,
	maxSize: 480,
	minSecondSize: 360,
	defaultRatio: 0.22,
	stackBelow: 1024
} as const;

export type ProjectEditorLayoutMode = Exclude<ProjectEditorLayout, 'auto'>;

export function projectEditorLayoutPreference(): ProjectEditorLayout {
	const value = userStore.current?.preferences?.defaultProjectEditorLayout;
	return value === 'classic' || value === 'tree' ? value : 'auto';
}

export function resolveProjectEditorLayout(autoLayout: ProjectEditorLayoutMode): ProjectEditorLayoutMode {
	const preference = projectEditorLayoutPreference();
	return preference === 'auto' ? autoLayout : preference;
}

export function templateNameSlug(name: string): string {
	return name.toLowerCase().replace(/[^a-z0-9-_]/g, '-');
}

// Returns the normalized top-level `name:` from compose YAML content, or null
// when the key is absent or unusable. Interpolated names (containing `${`)
// and unparseable content are treated as absent, mirroring the backend's
// ComposeContentProjectName so the name lock engages identically on both sides.
export function extractComposeYamlName(content: string): string | null {
	if (!content?.trim()) return null;
	try {
		const doc = parseDocument(content);
		if (doc.errors.length > 0) return null;
		const raw = doc.get('name', false);
		if (typeof raw !== 'string' || raw.includes('${')) return null;
		const normalized = raw
			.trim()
			.toLowerCase()
			.replace(/[^a-z0-9_-]/g, '')
			.replace(/^[_-]+/, '');
		return normalized || null;
	} catch {
		return null;
	}
}

export function createComposeEditorSchema(nameRequiredMessage: string) {
	return z.object({
		name: z
			.string()
			.min(1, nameRequiredMessage)
			.regex(/^[a-z0-9-_]+$/i, m.compose_project_name_invalid()),
		composeContent: z.string().min(1, m.compose_content_is_required()),
		envContent: z.string().optional().default('')
	});
}

function createComposeFieldAccessors(
	getInputs: () => ComposeFormInputs,
	setInputValue: ComposeFieldSetter
): ComposeFieldAccessors {
	return {
		getName: () => getInputs().name.value,
		setName: (value: string) => setInputValue('name', value),
		setComposeContent: (value: string) => setInputValue('composeContent', value),
		setEnvContent: (value: string) => setInputValue('envContent', value)
	};
}

function applyTemplateToComposeFields(template: Template, fields: ComposeFieldAccessors) {
	fields.setComposeContent(template.content ?? '');
	fields.setEnvContent(template.envContent ?? '');

	if (!fields.getName()?.trim()) {
		fields.setName(templateNameSlug(template.name));
	}
	toast.success(m.compose_template_loaded({ name: template.name }));
}

function applyConvertedDockerRunToComposeFields(data: ConvertedDockerRun, fields: ComposeFieldAccessors) {
	fields.setComposeContent(data.dockerCompose);
	fields.setEnvContent(data.envVars);
	if (!fields.getName()?.trim()) {
		fields.setName(templateNameSlug(data.serviceName));
	}
}

function createComposeFieldHandlers(fields: ComposeFieldAccessors, closeTemplateDialog: () => void) {
	return {
		handleTemplateSelect(template: Template) {
			closeTemplateDialog();
			applyTemplateToComposeFields(template, fields);
		},
		handleDockerRunConverted(data: ConvertedDockerRun) {
			applyConvertedDockerRunToComposeFields(data, fields);
		}
	};
}

type ValidatedComposeTemplate = {
	name: string;
	composeContent: string;
	envContent?: string;
};

type SubmitComposeResourceOptions<TResult> = {
	validate: () => ValidatedComposeTemplate | undefined | false | null;
	setLoading: (value: boolean) => void;
	submit: (payload: ValidatedComposeTemplate) => Promise<TResult>;
	failureMessage: (name: string) => string;
	onSuccess: (result: TResult, payload: ValidatedComposeTemplate) => void | Promise<void>;
};

type CreateComposeTemplateOptions = {
	validate: () => ValidatedComposeTemplate | undefined | false | null;
	setLoading: (value: boolean) => void;
	beforeValidate?: () => boolean;
};

type CreateComposeTemplateWithValidationOptions = Omit<CreateComposeTemplateOptions, 'beforeValidate'> & {
	hasEditorErrors?: () => boolean;
};

type CreateComposeTemplateDialogFlowOptions = CreateComposeTemplateWithValidationOptions & {
	getInputs: () => ComposeFormInputs;
	setInputValue: ComposeFieldSetter;
	closeTemplateDialog: () => void;
};

async function createComposeTemplate({ validate, setLoading, beforeValidate }: CreateComposeTemplateOptions) {
	if (beforeValidate && !beforeValidate()) return;

	const validated = validate();
	if (!validated) return;

	const { name, composeContent, envContent } = validated;

	setLoading(true);
	await handleApiResultWithCallbacks({
		result: await tryCatch(
			templateService.createTemplate({
				name,
				content: composeContent,
				envContent
			})
		),
		message: m.common_create_failed({ resource: `${m.resource_template()} "${name}"` }),
		setLoadingState: setLoading,
		onSuccess: async () => {
			toast.success(m.common_create_success({ resource: `${m.resource_template()} "${name}"` }));
		}
	});
}

export async function submitComposeResourceForm<TResult>({
	validate,
	setLoading,
	submit,
	failureMessage,
	onSuccess
}: SubmitComposeResourceOptions<TResult>) {
	const validated = validate();
	if (!validated) return;

	setLoading(true);
	await handleApiResultWithCallbacks({
		result: await tryCatch((async () => await submit(validated))()),
		message: failureMessage(validated.name),
		setLoadingState: setLoading,
		onSuccess: async (result) => {
			await onSuccess(result, validated);
		}
	});
}

async function createComposeTemplateWithValidation({
	validate,
	setLoading,
	hasEditorErrors
}: CreateComposeTemplateWithValidationOptions) {
	await createComposeTemplate({
		validate,
		setLoading,
		beforeValidate: hasEditorErrors
			? () => {
					if (!hasEditorErrors()) return true;
					toast.error(m.templates_validation_error());
					return false;
				}
			: undefined
	});
}

export function createComposeTemplateDialogFlow({
	getInputs,
	setInputValue,
	closeTemplateDialog,
	validate,
	setLoading,
	hasEditorErrors
}: CreateComposeTemplateDialogFlowOptions) {
	return {
		composeHandlers: createComposeFieldHandlers(createComposeFieldAccessors(getInputs, setInputValue), closeTemplateDialog),
		handleCreateTemplate: () => createComposeTemplateWithValidation({ validate, setLoading, hasEditorErrors })
	};
}