feat: add libsql database

2026-06-13 19:09:49 +00:00 · 2025-09-13 10:11:43 +02:00
parent 24729f35ec
commit 4b1f359cb6
53 changed files with 2942 additions and 486 deletions
@@ -11,8 +11,6 @@
 </div>
 <br />

-
-
 <div align="center" markdown="1">
   <sup>Special thanks to:</sup>
   <br>
@@ -22,20 +20,19 @@
   </a>

 ### [Tuple, the premier screen sharing app for developers](https://tuple.app/dokploy)
+
 [Available for MacOS & Windows](https://tuple.app/dokploy)<br>

 </div>

-
 Dokploy is a free, self-hostable Platform as a Service (PaaS) that simplifies the deployment and management of applications and databases.

-
 ## ✨ Features

 Dokploy includes multiple features to make your life easier.

 - **Applications**: Deploy any type of application (Node.js, PHP, Python, Go, Ruby, etc.).
- **Databases**: Create and manage databases with support for MySQL, PostgreSQL, MongoDB, MariaDB, and Redis.
+- **Databases**: Create and manage databases with support for MySQL, PostgreSQL, MongoDB, MariaDB, libsql, and Redis.
 - **Backups**: Automate backups for databases to an external storage destination.
 - **Docker Compose**: Native support for Docker Compose to manage complex applications.
 - **Multi Node**: Scale applications to multiple nodes using Docker Swarm to manage the cluster.
@@ -105,9 +102,10 @@ For detailed documentation, visit [docs.dokploy.com](https://docs.dokploy.com).

 <div>

-  <a href="https://cloudblast.io/?ref=dokploy"><img src="https://cloudblast.io/img/logo-icon.193cf13e.svg" width="250px" alt="Cloudblast.io"/></a>
+<a href="https://cloudblast.io/?ref=dokploy"><img src="https://cloudblast.io/img/logo-icon.193cf13e.svg" width="250px" alt="Cloudblast.io"/></a>
+
+<a href="https://synexa.ai/?ref=dokploy"><img src=".github/sponsors/synexa.png" width="65px" alt="Synexa"/></a>

-  <a href="https://synexa.ai/?ref=dokploy"><img src=".github/sponsors/synexa.png" width="65px" alt="Synexa"/></a>
 </div>

 ### Community Backers 🤝
@@ -182,32 +182,41 @@ type AddSwarmSettings = z.infer<typeof addSwarmSettings>;

 interface Props {
 	id: string;
-	type: "postgres" | "mariadb" | "mongo" | "mysql" | "redis" | "application";
+	type:
+		| "application"
+		| "libsql"
+		| "mariadb"
+		| "mongo"
+		| "mysql"
+		| "postgres"
+		| "redis";
 }

 export const AddSwarmSettings = ({ id, type }: Props) => {
 	const queryMap = {
+		application: () =>
+			api.application.one.useQuery({ applicationId: id }, { enabled: !!id }),
+		libsql: () => api.libsql.one.useQuery({ libsqlId: id }, { enabled: !!id }),
+		mariadb: () =>
+			api.mariadb.one.useQuery({ mariadbId: id }, { enabled: !!id }),
+		mongo: () => api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id }),
+		mysql: () => api.mysql.one.useQuery({ mysqlId: id }, { enabled: !!id }),
 		postgres: () =>
 			api.postgres.one.useQuery({ postgresId: id }, { enabled: !!id }),
 		redis: () => api.redis.one.useQuery({ redisId: id }, { enabled: !!id }),
-		mysql: () => api.mysql.one.useQuery({ mysqlId: id }, { enabled: !!id }),
-		mariadb: () =>
-			api.mariadb.one.useQuery({ mariadbId: id }, { enabled: !!id }),
-		application: () =>
-			api.application.one.useQuery({ applicationId: id }, { enabled: !!id }),
-		mongo: () => api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id }),
 	};
 	const { data, refetch } = queryMap[type]
 		? queryMap[type]()
 		: api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id });

 	const mutationMap = {
+		application: () => api.application.update.useMutation(),
+		libsql: () => api.libsql.update.useMutation(),
+		mariadb: () => api.mariadb.update.useMutation(),
+		mongo: () => api.mongo.update.useMutation(),
+		mysql: () => api.mysql.update.useMutation(),
 		postgres: () => api.postgres.update.useMutation(),
 		redis: () => api.redis.update.useMutation(),
-		mysql: () => api.mysql.update.useMutation(),
-		mariadb: () => api.mariadb.update.useMutation(),
-		application: () => api.application.update.useMutation(),
-		mongo: () => api.mongo.update.useMutation(),
 	};

 	const { mutateAsync, isError, error, isLoading } = mutationMap[type]
@@ -262,11 +271,12 @@ export const AddSwarmSettings = ({ id, type }: Props) => {
 	const onSubmit = async (data: AddSwarmSettings) => {
 		await mutateAsync({
 			applicationId: id || "",
-			postgresId: id || "",
-			redisId: id || "",
-			mysqlId: id || "",
+			libsqlId: id || "",
 			mariadbId: id || "",
 			mongoId: id || "",
+			mysqlId: id || "",
+			postgresId: id || "",
+			redisId: id || "",
 			healthCheckSwarm: data.healthCheckSwarm,
 			restartPolicySwarm: data.restartPolicySwarm,
 			placementSwarm: data.placementSwarm,
@@ -37,7 +37,14 @@ import { AddSwarmSettings } from "./modify-swarm-settings";

 interface Props {
 	id: string;
-	type: "postgres" | "mariadb" | "mongo" | "mysql" | "redis" | "application";
+	type:
+		| "application"
+		| "libsql"
+		| "mariadb"
+		| "mongo"
+		| "mysql"
+		| "postgres"
+		| "redis";
 }

 const AddRedirectchema = z.object({
@@ -49,15 +56,16 @@ type AddCommand = z.infer<typeof AddRedirectchema>;

 export const ShowClusterSettings = ({ id, type }: Props) => {
 	const queryMap = {
+		application: () =>
+			api.application.one.useQuery({ applicationId: id }, { enabled: !!id }),
+		libsql: () => api.libsql.one.useQuery({ libsqlId: id }, { enabled: !!id }),
+		mariadb: () =>
+			api.mariadb.one.useQuery({ mariadbId: id }, { enabled: !!id }),
+		mongo: () => api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id }),
+		mysql: () => api.mysql.one.useQuery({ mysqlId: id }, { enabled: !!id }),
 		postgres: () =>
 			api.postgres.one.useQuery({ postgresId: id }, { enabled: !!id }),
 		redis: () => api.redis.one.useQuery({ redisId: id }, { enabled: !!id }),
-		mysql: () => api.mysql.one.useQuery({ mysqlId: id }, { enabled: !!id }),
-		mariadb: () =>
-			api.mariadb.one.useQuery({ mariadbId: id }, { enabled: !!id }),
-		application: () =>
-			api.application.one.useQuery({ applicationId: id }, { enabled: !!id }),
-		mongo: () => api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id }),
 	};
 	const { data, refetch } = queryMap[type]
 		? queryMap[type]()
@@ -65,12 +73,13 @@ export const ShowClusterSettings = ({ id, type }: Props) => {
 	const { data: registries } = api.registry.all.useQuery();

 	const mutationMap = {
+		application: () => api.application.update.useMutation(),
+		libsql: () => api.libsql.update.useMutation(),
+		mariadb: () => api.mariadb.update.useMutation(),
+		mongo: () => api.mongo.update.useMutation(),
+		mysql: () => api.mysql.update.useMutation(),
 		postgres: () => api.postgres.update.useMutation(),
 		redis: () => api.redis.update.useMutation(),
-		mysql: () => api.mysql.update.useMutation(),
-		mariadb: () => api.mariadb.update.useMutation(),
-		application: () => api.application.update.useMutation(),
-		mongo: () => api.mongo.update.useMutation(),
 	};

 	const { mutateAsync, isLoading } = mutationMap[type]
@@ -105,11 +114,12 @@ export const ShowClusterSettings = ({ id, type }: Props) => {
 	const onSubmit = async (data: AddCommand) => {
 		await mutateAsync({
 			applicationId: id || "",
-			postgresId: id || "",
-			redisId: id || "",
-			mysqlId: id || "",
+			libsqlId: id || "",
 			mariadbId: id || "",
 			mongoId: id || "",
+			mysqlId: id || "",
+			postgresId: id || "",
+			redisId: id || "",
 			...(type === "application"
 				? {
 						registryId:
@@ -38,12 +38,13 @@ const addResourcesSchema = z.object({
 });

 export type ServiceType =
-	| "postgres"
-	| "mongo"
-	| "redis"
-	| "mysql"
+	| "application"
+	| "libsql"
 	| "mariadb"
-	| "application";
+	| "mongo"
+	| "mysql"
+	| "postgres"
+	| "redis";

 interface Props {
 	id: string;
@@ -53,27 +54,29 @@ interface Props {
 type AddResources = z.infer<typeof addResourcesSchema>;
 export const ShowResources = ({ id, type }: Props) => {
 	const queryMap = {
+		application: () =>
+			api.application.one.useQuery({ applicationId: id }, { enabled: !!id }),
+		libsql: () => api.libsql.one.useQuery({ libsqlId: id }, { enabled: !!id }),
+		mariadb: () =>
+			api.mariadb.one.useQuery({ mariadbId: id }, { enabled: !!id }),
+		mongo: () => api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id }),
+		mysql: () => api.mysql.one.useQuery({ mysqlId: id }, { enabled: !!id }),
 		postgres: () =>
 			api.postgres.one.useQuery({ postgresId: id }, { enabled: !!id }),
 		redis: () => api.redis.one.useQuery({ redisId: id }, { enabled: !!id }),
-		mysql: () => api.mysql.one.useQuery({ mysqlId: id }, { enabled: !!id }),
-		mariadb: () =>
-			api.mariadb.one.useQuery({ mariadbId: id }, { enabled: !!id }),
-		application: () =>
-			api.application.one.useQuery({ applicationId: id }, { enabled: !!id }),
-		mongo: () => api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id }),
 	};
 	const { data, refetch } = queryMap[type]
 		? queryMap[type]()
 		: api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id });

 	const mutationMap = {
+		application: () => api.application.update.useMutation(),
+		libsql: () => api.libsql.update.useMutation(),
+		mariadb: () => api.mariadb.update.useMutation(),
+		mongo: () => api.mongo.update.useMutation(),
+		mysql: () => api.mysql.update.useMutation(),
 		postgres: () => api.postgres.update.useMutation(),
 		redis: () => api.redis.update.useMutation(),
-		mysql: () => api.mysql.update.useMutation(),
-		mariadb: () => api.mariadb.update.useMutation(),
-		application: () => api.application.update.useMutation(),
-		mongo: () => api.mongo.update.useMutation(),
 	};

 	const { mutateAsync, isLoading } = mutationMap[type]
@@ -103,12 +106,13 @@ export const ShowResources = ({ id, type }: Props) => {

 	const onSubmit = async (formData: AddResources) => {
 		await mutateAsync({
+			applicationId: id || "",
+			libsqlId: id || "",
+			mariadbId: id || "",
 			mongoId: id || "",
+			mysqlId: id || "",
 			postgresId: id || "",
 			redisId: id || "",
-			mysqlId: id || "",
-			mariadbId: id || "",
-			applicationId: id || "",
 			cpuLimit: formData.cpuLimit || null,
 			cpuReservation: formData.cpuReservation || null,
 			memoryLimit: formData.memoryLimit || null,
@@ -34,13 +34,13 @@ interface Props {
 	serviceId: string;
 	serviceType:
 		| "application"
-		| "postgres"
-		| "redis"
-		| "mongo"
-		| "redis"
-		| "mysql"
+		| "compose"
+		| "libsql"
 		| "mariadb"
-		| "compose";
+		| "mongo"
+		| "mysql"
+		| "postgres"
+		| "redis";
 	refetch: () => void;
 	children?: React.ReactNode;
 }
@@ -22,23 +22,25 @@ interface Props {

 export const ShowVolumes = ({ id, type }: Props) => {
 	const queryMap = {
+		application: () =>
+			api.application.one.useQuery({ applicationId: id }, { enabled: !!id }),
+		compose: () =>
+			api.compose.one.useQuery({ composeId: id }, { enabled: !!id }),
+		libsql: () => api.libsql.one.useQuery({ libsqlId: id }, { enabled: !!id }),
+		mariadb: () =>
+			api.mariadb.one.useQuery({ mariadbId: id }, { enabled: !!id }),
+		mongo: () => api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id }),
+		mysql: () => api.mysql.one.useQuery({ mysqlId: id }, { enabled: !!id }),
 		postgres: () =>
 			api.postgres.one.useQuery({ postgresId: id }, { enabled: !!id }),
 		redis: () => api.redis.one.useQuery({ redisId: id }, { enabled: !!id }),
-		mysql: () => api.mysql.one.useQuery({ mysqlId: id }, { enabled: !!id }),
-		mariadb: () =>
-			api.mariadb.one.useQuery({ mariadbId: id }, { enabled: !!id }),
-		application: () =>
-			api.application.one.useQuery({ applicationId: id }, { enabled: !!id }),
-		mongo: () => api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id }),
-		compose: () =>
-			api.compose.one.useQuery({ composeId: id }, { enabled: !!id }),
 	};
 	const { data, refetch } = queryMap[type]
 		? queryMap[type]()
 		: api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id });
 	const { mutateAsync: deleteVolume, isLoading: isRemoving } =
 		api.mounts.remove.useMutation();
+
 	return (
 		<Card className="bg-background">
 			<CardHeader className="flex flex-row justify-between flex-wrap gap-4">
@@ -61,13 +61,13 @@ interface Props {
 	refetch: () => void;
 	serviceType:
 		| "application"
-		| "postgres"
-		| "redis"
-		| "mongo"
-		| "redis"
-		| "mysql"
+		| "compose"
+		| "libsql"
 		| "mariadb"
-		| "compose";
+		| "mongo"
+		| "mysql"
+		| "postgres"
+		| "redis";
 }

 export const UpdateVolume = ({
@@ -247,7 +247,7 @@ export const UpdateVolume = ({
 										control={form.control}
 										name="content"
 										render={({ field }) => (
-											<FormItem className="max-w-full max-w-[45rem]">
+											<FormItem className="w-full max-w-[45rem]">
 												<FormLabel>Content</FormLabel>
 												<FormControl>
 													<FormControl>
@@ -55,6 +55,7 @@ export const DeleteService = ({ id, type }: Props) => {
 		mysql: () => api.mysql.one.useQuery({ mysqlId: id }, { enabled: !!id }),
 		mariadb: () =>
 			api.mariadb.one.useQuery({ mariadbId: id }, { enabled: !!id }),
+		libsql: () => api.libsql.one.useQuery({ libsqlId: id }, { enabled: !!id }),
 		application: () =>
 			api.application.one.useQuery({ applicationId: id }, { enabled: !!id }),
 		mongo: () => api.mongo.one.useQuery({ mongoId: id }, { enabled: !!id }),
@@ -70,6 +71,7 @@ export const DeleteService = ({ id, type }: Props) => {
 		redis: () => api.redis.remove.useMutation(),
 		mysql: () => api.mysql.remove.useMutation(),
 		mariadb: () => api.mariadb.remove.useMutation(),
+		libsql: () => api.libsql.remove.useMutation(),
 		application: () => api.application.delete.useMutation(),
 		mongo: () => api.mongo.remove.useMutation(),
 		compose: () => api.compose.delete.useMutation(),
@@ -96,6 +98,7 @@ export const DeleteService = ({ id, type }: Props) => {
 				redisId: id || "",
 				mysqlId: id || "",
 				mariadbId: id || "",
+				libsqlId: id || "",
 				applicationId: id || "",
 				composeId: id || "",
 				deleteVolumes,
@@ -0,0 +1,258 @@
+import { zodResolver } from "@hookform/resolvers/zod";
+import Link from "next/link";
+import { useEffect, useState } from "react";
+import { useForm } from "react-hook-form";
+import { toast } from "sonner";
+import { z } from "zod";
+import { AlertBlock } from "@/components/shared/alert-block";
+import { ToggleVisibilityInput } from "@/components/shared/toggle-visibility-input";
+import { Button } from "@/components/ui/button";
+import {
+	Card,
+	CardContent,
+	CardDescription,
+	CardHeader,
+	CardTitle,
+} from "@/components/ui/card";
+import {
+	Form,
+	FormControl,
+	FormField,
+	FormItem,
+	FormLabel,
+	FormMessage,
+} from "@/components/ui/form";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { api } from "@/utils/api";
+
+const createDockerProviderSchema = (sqldNode?: string) =>
+	z
+		.object({
+			externalPort: z.preprocess((a) => {
+				if (a !== null) {
+					const parsed = Number.parseInt(z.string().parse(a), 10);
+					return Number.isNaN(parsed) ? null : parsed;
+				}
+				return null;
+			}, z
+				.number()
+				.gte(0, "Range must be 0 - 65535")
+				.lte(65535, "Range must be 0 - 65535")
+				.nullable()),
+			externalGRPCPort: z.preprocess((a) => {
+				if (a !== null) {
+					const parsed = Number.parseInt(z.string().parse(a), 10);
+					return Number.isNaN(parsed) ? null : parsed;
+				}
+				return null;
+			}, z
+				.number()
+				.gte(0, "Range must be 0 - 65535")
+				.lte(65535, "Range must be 0 - 65535")
+				.nullable()),
+		})
+		.superRefine((data, ctx) => {
+			if (data.externalPort === null && data.externalGRPCPort === null) {
+				ctx.addIssue({
+					code: z.ZodIssueCode.custom,
+					message: "Either externalPort or externalGRPCPort must be provided.",
+					path: ["externalPort", "externalGRPCPort"],
+				});
+			}
+			if (sqldNode === "replica" && data.externalGRPCPort !== null) {
+				ctx.addIssue({
+					code: z.ZodIssueCode.custom,
+					message: "externalGRPCPort cannot be set when sqldNode is 'replica'",
+					path: ["externalGRPCPort"],
+				});
+			}
+		});
+
+interface Props {
+	libsqlId: string;
+}
+export const ShowExternalLibsqlCredentials = ({ libsqlId }: Props) => {
+	const { data: ip } = api.settings.getIp.useQuery();
+	const { data, refetch } = api.libsql.one.useQuery({ libsqlId });
+	const { mutateAsync, isLoading } = api.libsql.saveExternalPorts.useMutation();
+	const [connectionUrl, setConnectionUrl] = useState("");
+	const [connectionGRPCUrl, setGRPCConnectionUrl] = useState("");
+	const getIp = data?.server?.ipAddress || ip;
+
+	const DockerProviderSchema = createDockerProviderSchema(data?.sqldNode);
+	type DockerProvider = z.infer<typeof DockerProviderSchema>;
+
+	const form = useForm<DockerProvider>({
+		defaultValues: {},
+		resolver: zodResolver(DockerProviderSchema),
+	});
+
+	useEffect(() => {
+		const fieldsToUpdate: Partial<DockerProvider> = {};
+
+		if (data?.externalGRPCPort !== undefined) {
+			fieldsToUpdate.externalGRPCPort = data.externalGRPCPort;
+		}
+
+		if (data?.externalPort !== undefined) {
+			fieldsToUpdate.externalPort = data.externalPort;
+		}
+
+		if (Object.keys(fieldsToUpdate).length > 0) {
+			form.reset(fieldsToUpdate);
+		}
+	}, [form.reset, data, form]);
+
+	const onSubmit = async (values: DockerProvider) => {
+		await mutateAsync({
+			externalPort: values.externalPort,
+			externalGRPCPort: values.externalGRPCPort,
+			libsqlId,
+		})
+			.then(async () => {
+				toast.success("External port/ports updated");
+				await refetch();
+			})
+			.catch(() => {
+				toast.error("Error saving the external port/ports");
+			});
+	};
+
+	useEffect(() => {
+		const buildConnectionUrl = () => {
+			const port = form.watch("externalPort") || data?.externalPort;
+
+			return `https://${data?.databaseUser}:${data?.databasePassword}@${getIp}:${port}`;
+		};
+
+		setConnectionUrl(buildConnectionUrl());
+
+		const buildGRPCConnectionUrl = () => {
+			if (data?.sqldNode === "replica") return "";
+			const port = form.watch("externalGRPCPort") || data?.externalGRPCPort;
+
+			return `https://${data?.databaseUser}:${data?.databasePassword}@${getIp}:${port}`;
+		};
+
+		setGRPCConnectionUrl(buildGRPCConnectionUrl());
+	}, [
+		data?.appName,
+		data?.externalGRPCPort,
+		data?.databasePassword,
+		form,
+		data?.databaseUser,
+		getIp,
+	]);
+
+	return (
+		<>
+			<div className="flex w-full flex-col gap-5 ">
+				<Card className="bg-background">
+					<CardHeader>
+						<CardTitle className="text-xl">External Credentials</CardTitle>
+						<CardDescription>
+							In order to make the database reachable through the internet, you
+							must set a port and ensure that the port is not being used by
+							another application or database
+						</CardDescription>
+					</CardHeader>
+					<CardContent className="flex w-full flex-col gap-4">
+						{!getIp && (
+							<AlertBlock type="warning">
+								You need to set an IP address in your{" "}
+								<Link
+									href="/dashboard/settings/server"
+									className="text-primary"
+								>
+									{data?.serverId
+										? "Remote Servers -> Server -> Edit Server -> Update IP Address"
+										: "Web Server -> Server -> Update Server IP"}
+								</Link>{" "}
+								to fix the database url connection.
+							</AlertBlock>
+						)}
+						<Form {...form}>
+							<form
+								onSubmit={form.handleSubmit(onSubmit)}
+								className="flex flex-col gap-4"
+							>
+								<div className="grid md:grid-cols-2 gap-4 ">
+									<div className="md:col-span-2 space-y-4">
+										<FormField
+											control={form.control}
+											name="externalPort"
+											render={({ field }) => {
+												return (
+													<FormItem>
+														<FormLabel>External Port (Internet)</FormLabel>
+														<FormControl>
+															<Input
+																placeholder="8080"
+																{...field}
+																value={field.value || ""}
+															/>
+														</FormControl>
+														<FormMessage />
+													</FormItem>
+												);
+											}}
+										/>
+									</div>
+									{!!data?.externalPort && (
+										<div className="md:col-span-2">
+											<Label>External Host</Label>
+											<ToggleVisibilityInput value={connectionUrl} disabled />
+										</div>
+									)}
+									{data?.sqldNode !== "replica" && (
+										<>
+											<div className="md:col-span-2 space-y-4">
+												<FormField
+													control={form.control}
+													name="externalGRPCPort"
+													render={({ field }) => {
+														return (
+															<FormItem>
+																<FormLabel>
+																	External GRPC Port (Internet)
+																</FormLabel>
+																<FormControl>
+																	<Input
+																		placeholder="5001"
+																		{...field}
+																		value={field.value || ""}
+																	/>
+																</FormControl>
+																<FormMessage />
+															</FormItem>
+														);
+													}}
+												/>
+											</div>
+											{!!data?.externalGRPCPort && (
+												<div className="md:col-span-2">
+													<Label>External GRPC Host</Label>
+													<ToggleVisibilityInput
+														value={connectionGRPCUrl}
+														disabled
+													/>
+												</div>
+											)}
+										</>
+									)}
+								</div>
+
+								<div className="flex justify-end">
+									<Button type="submit" isLoading={isLoading}>
+										Save
+									</Button>
+								</div>
+							</form>
+						</Form>
+					</CardContent>
+				</Card>
+			</div>
+		</>
+	);
+};
@@ -0,0 +1,268 @@
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+import { Ban, CheckCircle2, RefreshCcw, Rocket, Terminal } from "lucide-react";
+import { useState } from "react";
+import { toast } from "sonner";
+import { DialogAction } from "@/components/shared/dialog-action";
+import { DrawerLogs } from "@/components/shared/drawer-logs";
+import { Button } from "@/components/ui/button";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import {
+	Tooltip,
+	TooltipContent,
+	TooltipProvider,
+	TooltipTrigger,
+} from "@/components/ui/tooltip";
+import { api } from "@/utils/api";
+import { type LogLine, parseLogs } from "../../docker/logs/utils";
+import { DockerTerminalModal } from "../../settings/web-server/docker-terminal-modal";
+
+interface Props {
+	libsqlId: string;
+}
+
+export const ShowGeneralLibsql = ({ libsqlId }: Props) => {
+	const { data, refetch } = api.libsql.one.useQuery(
+		{
+			libsqlId,
+		},
+		{ enabled: !!libsqlId },
+	);
+
+	const { mutateAsync: reload, isLoading: isReloading } =
+		api.libsql.reload.useMutation();
+
+	const { mutateAsync: start, isLoading: isStarting } =
+		api.libsql.start.useMutation();
+
+	const { mutateAsync: stop, isLoading: isStopping } =
+		api.libsql.stop.useMutation();
+
+	const [isDrawerOpen, setIsDrawerOpen] = useState(false);
+	const [filteredLogs, setFilteredLogs] = useState<LogLine[]>([]);
+	const [isDeploying, setIsDeploying] = useState(false);
+	api.libsql.deployWithLogs.useSubscription(
+		{
+			libsqlId: libsqlId,
+		},
+		{
+			enabled: isDeploying,
+			onData(log) {
+				if (!isDrawerOpen) {
+					setIsDrawerOpen(true);
+				}
+
+				if (log === "Deployment completed successfully!") {
+					setIsDeploying(false);
+				}
+				const parsedLogs = parseLogs(log);
+				setFilteredLogs((prev) => [...prev, ...parsedLogs]);
+			},
+			onError(error) {
+				console.error("Deployment logs error:", error);
+				setIsDeploying(false);
+			},
+		},
+	);
+
+	return (
+		<>
+			<div className="flex w-full flex-col gap-5 ">
+				<Card className="bg-background">
+					<CardHeader>
+						<CardTitle className="text-xl">Deploy Settings</CardTitle>
+					</CardHeader>
+					<CardContent className="flex flex-row gap-4 flex-wrap">
+						<TooltipProvider delayDuration={0}>
+							<DialogAction
+								title="Deploy Libsql"
+								description="Are you sure you want to deploy this Libsql?"
+								type="default"
+								onClick={async () => {
+									setIsDeploying(true);
+									await new Promise((resolve) => setTimeout(resolve, 1000));
+									refetch();
+								}}
+							>
+								<Button
+									variant="default"
+									isLoading={data?.applicationStatus === "running"}
+									className="flex items-center gap-1.5 focus-visible:ring-2 focus-visible:ring-offset-2"
+								>
+									<Tooltip>
+										<TooltipTrigger asChild>
+											<div className="flex items-center">
+												<Rocket className="size-4 mr-1" />
+												Deploy
+											</div>
+										</TooltipTrigger>
+										<TooltipPrimitive.Portal>
+											<TooltipContent sideOffset={5} className="z-[60]">
+												<p>Downloads and sets up the Libsql database</p>
+											</TooltipContent>
+										</TooltipPrimitive.Portal>
+									</Tooltip>
+								</Button>
+							</DialogAction>
+						</TooltipProvider>
+						<TooltipProvider delayDuration={0}>
+							<DialogAction
+								title="Reload Libsql"
+								description="Are you sure you want to reload this libsql?"
+								type="default"
+								onClick={async () => {
+									await reload({
+										libsqlId: libsqlId,
+										appName: data?.appName || "",
+									})
+										.then(() => {
+											toast.success("Libsql reloaded successfully");
+											refetch();
+										})
+										.catch(() => {
+											toast.error("Error reloading Libsql");
+										});
+								}}
+							>
+								<Button
+									variant="secondary"
+									isLoading={isReloading}
+									className="flex items-center gap-1.5 focus-visible:ring-2 focus-visible:ring-offset-2"
+								>
+									<Tooltip>
+										<TooltipTrigger asChild>
+											<div className="flex items-center">
+												<RefreshCcw className="size-4 mr-1" />
+												Reload
+											</div>
+										</TooltipTrigger>
+										<TooltipPrimitive.Portal>
+											<TooltipContent sideOffset={5} className="z-[60]">
+												<p>Restart the Libsql service without rebuilding</p>
+											</TooltipContent>
+										</TooltipPrimitive.Portal>
+									</Tooltip>
+								</Button>
+							</DialogAction>
+						</TooltipProvider>
+						{data?.applicationStatus === "idle" ? (
+							<TooltipProvider delayDuration={0}>
+								<DialogAction
+									title="Start Libsql"
+									description="Are you sure you want to start this Libsql?"
+									type="default"
+									onClick={async () => {
+										await start({
+											libsqlId: libsqlId,
+										})
+											.then(() => {
+												toast.success("Libsql started successfully");
+												refetch();
+											})
+											.catch(() => {
+												toast.error("Error starting Libsql");
+											});
+									}}
+								>
+									<Button
+										variant="secondary"
+										isLoading={isStarting}
+										className="flex items-center gap-1.5 focus-visible:ring-2 focus-visible:ring-offset-2"
+									>
+										<Tooltip>
+											<TooltipTrigger asChild>
+												<div className="flex items-center">
+													<CheckCircle2 className="size-4 mr-1" />
+													Start
+												</div>
+											</TooltipTrigger>
+											<TooltipPrimitive.Portal>
+												<TooltipContent sideOffset={5} className="z-[60]">
+													<p>
+														Start the Libsql database (requires a previous
+														successful setup)
+													</p>
+												</TooltipContent>
+											</TooltipPrimitive.Portal>
+										</Tooltip>
+									</Button>
+								</DialogAction>
+							</TooltipProvider>
+						) : (
+							<TooltipProvider delayDuration={0}>
+								<DialogAction
+									title="Stop Libsql"
+									description="Are you sure you want to stop this Libsql?"
+									onClick={async () => {
+										await stop({
+											libsqlId: libsqlId,
+										})
+											.then(() => {
+												toast.success("Libsql stopped successfully");
+												refetch();
+											})
+											.catch(() => {
+												toast.error("Error stopping Libsql");
+											});
+									}}
+								>
+									<Button
+										variant="destructive"
+										isLoading={isStopping}
+										className="flex items-center gap-1.5 focus-visible:ring-2 focus-visible:ring-offset-2"
+									>
+										<Tooltip>
+											<TooltipTrigger asChild>
+												<div className="flex items-center">
+													<Ban className="size-4 mr-1" />
+													Stop
+												</div>
+											</TooltipTrigger>
+											<TooltipPrimitive.Portal>
+												<TooltipContent sideOffset={5} className="z-[60]">
+													<p>Stop the currently running Libsql database</p>
+												</TooltipContent>
+											</TooltipPrimitive.Portal>
+										</Tooltip>
+									</Button>
+								</DialogAction>
+							</TooltipProvider>
+						)}
+						<DockerTerminalModal
+							appName={data?.appName || ""}
+							serverId={data?.serverId || ""}
+						>
+							<Button
+								variant="outline"
+								className="flex items-center gap-1.5 focus-visible:ring-2 focus-visible:ring-offset-2"
+							>
+								<Tooltip>
+									<TooltipTrigger asChild>
+										<div className="flex items-center">
+											<Terminal className="size-4 mr-1" />
+											Open Terminal
+										</div>
+									</TooltipTrigger>
+									<TooltipPrimitive.Portal>
+										<TooltipContent sideOffset={5} className="z-[60]">
+											<p>Open a terminal to the Libsql container</p>
+										</TooltipContent>
+									</TooltipPrimitive.Portal>
+								</Tooltip>
+							</Button>
+						</DockerTerminalModal>
+					</CardContent>
+				</Card>
+				<DrawerLogs
+					isOpen={isDrawerOpen}
+					onClose={() => {
+						setIsDrawerOpen(false);
+						setFilteredLogs([]);
+						setIsDeploying(false);
+						refetch();
+					}}
+					filteredLogs={filteredLogs}
+				/>
+			</div>
+		</>
+	);
+};
@@ -0,0 +1,92 @@
+import { ToggleVisibilityInput } from "@/components/shared/toggle-visibility-input";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import {
+	Select,
+	SelectContent,
+	SelectItem,
+	SelectTrigger,
+	SelectValue,
+} from "@/components/ui/select";
+import { api } from "@/utils/api";
+
+interface Props {
+	libsqlId: string;
+}
+export const ShowInternalLibsqlCredentials = ({ libsqlId }: Props) => {
+	const { data } = api.libsql.one.useQuery({ libsqlId });
+	return (
+		<>
+			<div className="flex w-full flex-col gap-5 ">
+				<Card className="bg-background">
+					<CardHeader>
+						<CardTitle className="text-xl">Internal Credentials</CardTitle>
+					</CardHeader>
+					<CardContent className="flex w-full flex-row gap-4">
+						<div className="grid w-full md:grid-cols-2 gap-4 md:gap-8">
+							<div className="flex flex-col gap-2">
+								<Label>User</Label>
+								<Input disabled value={data?.databaseUser} />
+							</div>
+							<div className="flex flex-col gap-2">
+								<Label>Sqld Node</Label>
+								<Select value={data?.sqldNode} disabled>
+									<SelectTrigger>
+										<SelectValue placeholder="Select Node type" />
+									</SelectTrigger>
+									<SelectContent>
+										{["primary", "replica"].map((node) => (
+											<SelectItem key={node} value={node}>
+												{node.charAt(0).toUpperCase() + node.slice(1)}
+											</SelectItem>
+										))}
+									</SelectContent>
+								</Select>
+							</div>
+							<div className="flex flex-col gap-2">
+								<Label>Password</Label>
+								<div className="flex flex-row gap-4">
+									<ToggleVisibilityInput
+										disabled
+										value={data?.databasePassword}
+									/>
+								</div>
+							</div>
+
+							<div className="flex flex-row gap-2">
+								<div className="w-full flex flex-col gap-2">
+									<Label>Internal Port (Container)</Label>
+									<Input disabled value="8080" />
+								</div>
+								<div className="w-full flex flex-col gap-2">
+									<Label>Internal GRPC Port (Container)</Label>
+									<Input disabled value="5001" />
+								</div>
+							</div>
+							<div className="flex flex-col gap-2">
+								<Label>Internal Host</Label>
+								<Input disabled value={data?.appName} />
+							</div>
+
+							<div className="flex flex-col gap-2 md:col-span-2">
+								<Label>Internal Connection URL </Label>
+								<ToggleVisibilityInput
+									disabled
+									value={`http://${data?.databaseUser}:${data?.databasePassword}@${data?.appName}:8080`}
+								/>
+							</div>
+							<div className="flex flex-col gap-2 md:col-span-2">
+								<Label>Internal Replication Connection URL </Label>
+								<ToggleVisibilityInput
+									disabled
+									value={`http://${data?.databaseUser}:${data?.databasePassword}@${data?.appName}:5001`}
+								/>
+							</div>
+						</div>
+					</CardContent>
+				</Card>
+			</div>
+		</>
+	);
+};
@@ -0,0 +1,163 @@
+import { zodResolver } from "@hookform/resolvers/zod";
+import { PenBoxIcon } from "lucide-react";
+import { useEffect } from "react";
+import { useForm } from "react-hook-form";
+import { toast } from "sonner";
+import { z } from "zod";
+import { AlertBlock } from "@/components/shared/alert-block";
+import { Button } from "@/components/ui/button";
+import {
+	Dialog,
+	DialogContent,
+	DialogDescription,
+	DialogFooter,
+	DialogHeader,
+	DialogTitle,
+	DialogTrigger,
+} from "@/components/ui/dialog";
+import {
+	Form,
+	FormControl,
+	FormField,
+	FormItem,
+	FormLabel,
+	FormMessage,
+} from "@/components/ui/form";
+import { Input } from "@/components/ui/input";
+import { Textarea } from "@/components/ui/textarea";
+import { api } from "@/utils/api";
+
+const updateLibsqlSchema = z.object({
+	name: z.string().min(1, {
+		message: "Name is required",
+	}),
+	description: z.string().optional(),
+});
+
+type UpdateLibsql = z.infer<typeof updateLibsqlSchema>;
+
+interface Props {
+	libsqlId: string;
+}
+
+export const UpdateLibsql = ({ libsqlId }: Props) => {
+	const utils = api.useUtils();
+	const { mutateAsync, error, isError, isLoading } =
+		api.libsql.update.useMutation();
+	const { data } = api.libsql.one.useQuery(
+		{
+			libsqlId,
+		},
+		{
+			enabled: !!libsqlId,
+		},
+	);
+	const form = useForm<UpdateLibsql>({
+		defaultValues: {
+			description: data?.description ?? "",
+			name: data?.name ?? "",
+		},
+		resolver: zodResolver(updateLibsqlSchema),
+	});
+	useEffect(() => {
+		if (data) {
+			form.reset({
+				description: data.description ?? "",
+				name: data.name,
+			});
+		}
+	}, [data, form, form.reset]);
+
+	const onSubmit = async (formData: UpdateLibsql) => {
+		await mutateAsync({
+			name: formData.name,
+			libsqlId: libsqlId,
+			description: formData.description || "",
+		})
+			.then(() => {
+				toast.success("Libsql updated successfully");
+				utils.libsql.one.invalidate({
+					libsqlId: libsqlId,
+				});
+			})
+			.catch(() => {
+				toast.error("Error updating the Libsql");
+			})
+			.finally(() => {});
+	};
+
+	return (
+		<Dialog>
+			<DialogTrigger asChild>
+				<Button
+					variant="ghost"
+					size="icon"
+					className="group hover:bg-blue-500/10 "
+				>
+					<PenBoxIcon className="size-3.5  text-primary group-hover:text-blue-500" />
+				</Button>
+			</DialogTrigger>
+			<DialogContent className="sm:max-w-lg">
+				<DialogHeader>
+					<DialogTitle>Modify Libsql</DialogTitle>
+					<DialogDescription>Update the Libsql data</DialogDescription>
+				</DialogHeader>
+				{isError && <AlertBlock type="error">{error?.message}</AlertBlock>}
+
+				<div className="grid gap-4">
+					<div className="grid items-center gap-4">
+						<Form {...form}>
+							<form
+								onSubmit={form.handleSubmit(onSubmit)}
+								id="hook-form-update-libsql"
+								className="grid w-full gap-4 "
+							>
+								<FormField
+									control={form.control}
+									name="name"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Name</FormLabel>
+											<FormControl>
+												<Input placeholder="Vandelay Industries" {...field} />
+											</FormControl>
+
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+								<FormField
+									control={form.control}
+									name="description"
+									render={({ field }) => (
+										<FormItem>
+											<FormLabel>Description</FormLabel>
+											<FormControl>
+												<Textarea
+													placeholder="Description about your project..."
+													className="resize-none"
+													{...field}
+												/>
+											</FormControl>
+
+											<FormMessage />
+										</FormItem>
+									)}
+								/>
+								<DialogFooter>
+									<Button
+										isLoading={isLoading}
+										form="hook-form-update-libsql"
+										type="submit"
+									>
+										Update
+									</Button>
+								</DialogFooter>
+							</form>
+						</Form>
+					</div>
+				</div>
+			</DialogContent>
+		</Dialog>
+	);
+};
@@ -34,6 +34,7 @@ export const ShowCustomCommand = ({ id, type }: Props) => {
 			api.postgres.one.useQuery({ postgresId: id }, { enabled: !!id }),
 		redis: () => api.redis.one.useQuery({ redisId: id }, { enabled: !!id }),
 		mysql: () => api.mysql.one.useQuery({ mysqlId: id }, { enabled: !!id }),
+		libsql: () => api.libsql.one.useQuery({ libsqlId: id }, { enabled: !!id }),
 		mariadb: () =>
 			api.mariadb.one.useQuery({ mariadbId: id }, { enabled: !!id }),
 		application: () =>
@@ -48,6 +49,7 @@ export const ShowCustomCommand = ({ id, type }: Props) => {
 		postgres: () => api.postgres.update.useMutation(),
 		redis: () => api.redis.update.useMutation(),
 		mysql: () => api.mysql.update.useMutation(),
+		libsql: () => api.libsql.update.useMutation(),
 		mariadb: () => api.mariadb.update.useMutation(),
 		application: () => api.application.update.useMutation(),
 		mongo: () => api.mongo.update.useMutation(),
@@ -80,6 +82,7 @@ export const ShowCustomCommand = ({ id, type }: Props) => {
 			postgresId: id || "",
 			redisId: id || "",
 			mysqlId: id || "",
+			libsqlId: id || "",
 			mariadbId: id || "",
 			dockerImage: formData?.dockerImage,
 			command: formData?.command,
@@ -5,6 +5,7 @@ import { useForm } from "react-hook-form";
 import { toast } from "sonner";
 import { z } from "zod";
 import {
+	LibsqlIcon,
 	MariadbIcon,
 	MongodbIcon,
 	MysqlIcon,
@@ -55,8 +56,9 @@ import { api } from "@/utils/api";
 type DbType = typeof mySchema._type.type;

 const dockerImageDefaultPlaceholder: Record<DbType, string> = {
-	mongo: "mongo:6",
+	libsql: "ghcr.io/tursodatabase/libsql-server:latest",
 	mariadb: "mariadb:11",
+	mongo: "mongo:6",
 	mysql: "mysql:8",
 	postgres: "postgres:15",
 	redis: "redis:7",
@@ -66,8 +68,9 @@ const databasesUserDefaultPlaceholder: Record<
 	Exclude<DbType, "redis">,
 	string
 > = {
-	mongo: "mongo",
+	libsql: "libsql",
 	mariadb: "mariadb",
+	mongo: "mongo",
 	mysql: "mysql",
 	postgres: "postgres",
 };
@@ -97,9 +100,34 @@ const baseDatabaseSchema = z.object({
 const mySchema = z.discriminatedUnion("type", [
 	z
 		.object({
-			type: z.literal("postgres"),
-			databaseName: z.string().default("postgres"),
-			databaseUser: z.string().default("postgres"),
+			type: z.literal("libsql"),
+			dockerImage: z
+				.string()
+				.default("ghcr.io/tursodatabase/libsql-server:latest"),
+			databasePassword: z
+				.string()
+				.regex(/^[a-zA-Z0-9@#%^&*()_+\-=[\]{}|;:,.<>?~`]*$/, {
+					message:
+						"Password contains invalid characters. Please avoid: $ ! ' \" \\ / and space characters for database compatibility",
+				}),
+			databaseUser: z.string().default("libsql"),
+			sqldNode: z.enum(["primary", "replica"]).default("primary"),
+			sqldPrimaryUrl: z.string().optional(),
+		})
+		.merge(baseDatabaseSchema),
+	z
+		.object({
+			type: z.literal("mariadb"),
+			dockerImage: z.string().default("mariadb:4"),
+			databaseRootPassword: z
+				.string()
+				.regex(/^[a-zA-Z0-9@#%^&*()_+\-=[\]{}|;:,.<>?~`]*$/, {
+					message:
+						"Password contains invalid characters. Please avoid: $ ! ' \" \\ / and space characters for database compatibility",
+				})
+				.optional(),
+			databaseUser: z.string().default("mariadb"),
+			databaseName: z.string().default("mariadb"),
 		})
 		.merge(baseDatabaseSchema),
 	z
@@ -109,11 +137,6 @@ const mySchema = z.discriminatedUnion("type", [
 			replicaSets: z.boolean().default(false),
 		})
 		.merge(baseDatabaseSchema),
-	z
-		.object({
-			type: z.literal("redis"),
-		})
-		.merge(baseDatabaseSchema),
 	z
 		.object({
 			type: z.literal("mysql"),
@@ -130,17 +153,14 @@ const mySchema = z.discriminatedUnion("type", [
 		.merge(baseDatabaseSchema),
 	z
 		.object({
-			type: z.literal("mariadb"),
-			dockerImage: z.string().default("mariadb:4"),
-			databaseRootPassword: z
-				.string()
-				.regex(/^[a-zA-Z0-9@#%^&*()_+\-=[\]{}|;:,.<>?~`]*$/, {
-					message:
-						"Password contains invalid characters. Please avoid: $ ! ' \" \\ / and space characters for database compatibility",
-				})
-				.optional(),
-			databaseUser: z.string().default("mariadb"),
-			databaseName: z.string().default("mariadb"),
+			type: z.literal("postgres"),
+			databaseName: z.string().default("postgres"),
+			databaseUser: z.string().default("postgres"),
+		})
+		.merge(baseDatabaseSchema),
+	z
+		.object({
+			type: z.literal("redis"),
 		})
 		.merge(baseDatabaseSchema),
 ]);
@@ -166,6 +186,10 @@ const databasesMap = {
 		icon: <RedisIcon />,
 		label: "Redis",
 	},
+	libsql: {
+		icon: <LibsqlIcon />,
+		label: "Libsql",
+	},
 };

 type AddDatabase = z.infer<typeof mySchema>;
@@ -181,11 +205,12 @@ export const AddDatabase = ({ environmentId, projectName }: Props) => {
 	const slug = slugify(projectName);
 	const { data: isCloud } = api.settings.isCloud.useQuery();
 	const { data: servers } = api.server.withSSHKey.useQuery();
-	const postgresMutation = api.postgres.create.useMutation();
-	const mongoMutation = api.mongo.create.useMutation();
-	const redisMutation = api.redis.create.useMutation();
+	const libsqlMutation = api.libsql.create.useMutation();
 	const mariadbMutation = api.mariadb.create.useMutation();
+	const mongoMutation = api.mongo.create.useMutation();
 	const mysqlMutation = api.mysql.create.useMutation();
+	const postgresMutation = api.postgres.create.useMutation();
+	const redisMutation = api.redis.create.useMutation();

 	// Get environment data to extract projectId
 	const { data: environment } = api.environment.one.useQuery({ environmentId });
@@ -210,13 +235,15 @@ export const AddDatabase = ({ environmentId, projectName }: Props) => {
 		},
 		resolver: zodResolver(mySchema),
 	});
+	const sqldNode = form.watch("sqldNode");
 	const type = form.watch("type");
 	const activeMutation = {
-		postgres: postgresMutation,
-		mongo: mongoMutation,
-		redis: redisMutation,
+		libsql: libsqlMutation,
 		mariadb: mariadbMutation,
+		mongo: mongoMutation,
 		mysql: mysqlMutation,
+		postgres: postgresMutation,
+		redis: redisMutation,
 	};

 	const onSubmit = async (data: AddDatabase) => {
@@ -233,12 +260,22 @@ export const AddDatabase = ({ environmentId, projectName }: Props) => {
 			description: data.description,
 		};

-		if (data.type === "postgres") {
-			promise = postgresMutation.mutateAsync({
+		if (data.type === "libsql") {
+			promise = libsqlMutation.mutateAsync({
+				...commonParams,
+				sqldNode: data.sqldNode,
+				sqldPrimaryUrl: data.sqldPrimaryUrl,
+				databasePassword: data.databasePassword,
+				databaseUser:
+					data.databaseUser || databasesUserDefaultPlaceholder[data.type],
+				serverId: data.serverId === "dokploy" ? null : data.serverId,
+			});
+		} else if (data.type === "mariadb") {
+			promise = mariadbMutation.mutateAsync({
 				...commonParams,
 				databasePassword: data.databasePassword,
-				databaseName: data.databaseName || "postgres",
-
+				databaseRootPassword: data.databaseRootPassword || "",
+				databaseName: data.databaseName || "mariadb",
 				databaseUser:
 					data.databaseUser || databasesUserDefaultPlaceholder[data.type],
 				serverId: data.serverId === "dokploy" ? null : data.serverId,
@@ -252,22 +289,6 @@ export const AddDatabase = ({ environmentId, projectName }: Props) => {
 				serverId: data.serverId === "dokploy" ? null : data.serverId,
 				replicaSets: data.replicaSets,
 			});
-		} else if (data.type === "redis") {
-			promise = redisMutation.mutateAsync({
-				...commonParams,
-				databasePassword: data.databasePassword,
-				serverId: data.serverId === "dokploy" ? null : data.serverId,
-			});
-		} else if (data.type === "mariadb") {
-			promise = mariadbMutation.mutateAsync({
-				...commonParams,
-				databasePassword: data.databasePassword,
-				databaseRootPassword: data.databaseRootPassword || "",
-				databaseName: data.databaseName || "mariadb",
-				databaseUser:
-					data.databaseUser || databasesUserDefaultPlaceholder[data.type],
-				serverId: data.serverId === "dokploy" ? null : data.serverId,
-			});
 		} else if (data.type === "mysql") {
 			promise = mysqlMutation.mutateAsync({
 				...commonParams,
@@ -278,6 +299,21 @@ export const AddDatabase = ({ environmentId, projectName }: Props) => {
 				serverId: data.serverId === "dokploy" ? null : data.serverId,
 				databaseRootPassword: data.databaseRootPassword || "",
 			});
+		} else if (data.type === "postgres") {
+			promise = postgresMutation.mutateAsync({
+				...commonParams,
+				databasePassword: data.databasePassword,
+				databaseName: data.databaseName || "postgres",
+				databaseUser:
+					data.databaseUser || databasesUserDefaultPlaceholder[data.type],
+				serverId: data.serverId === "dokploy" ? null : data.serverId,
+			});
+		} else if (data.type === "redis") {
+			promise = redisMutation.mutateAsync({
+				...commonParams,
+				databasePassword: data.databasePassword,
+				serverId: data.serverId === "dokploy" ? null : data.serverId,
+			});
 		}

 		if (promise) {
@@ -305,6 +341,7 @@ export const AddDatabase = ({ environmentId, projectName }: Props) => {
 				});
 		}
 	};
+
 	return (
 		<Dialog open={visible} onOpenChange={setVisible}>
 			<DialogTrigger className="w-full">
@@ -506,8 +543,8 @@ export const AddDatabase = ({ environmentId, projectName }: Props) => {
 										</FormItem>
 									)}
 								/>
-								{(type === "mysql" ||
-									type === "mariadb" ||
+								{(type === "mariadb" ||
+									type === "mysql" ||
 									type === "postgres") && (
 									<FormField
 										control={form.control}
@@ -524,10 +561,66 @@ export const AddDatabase = ({ environmentId, projectName }: Props) => {
 										)}
 									/>
 								)}
-								{(type === "mysql" ||
+
+								{type === "libsql" && (
+									<FormField
+										control={form.control}
+										name="sqldNode"
+										render={({ field }) => (
+											<FormItem>
+												<FormLabel>Sqld Node</FormLabel>
+												<Select
+													onValueChange={field.onChange}
+													defaultValue={field.value || "primary"}
+												>
+													<SelectTrigger>
+														<SelectValue
+															placeholder={
+																!isCloud ? "Dokploy" : "Select a Server"
+															}
+														/>
+													</SelectTrigger>
+													<SelectContent>
+														<SelectGroup>
+															{["primary", "replica"].map((node) => (
+																<SelectItem key={node} value={node}>
+																	{node.charAt(0).toUpperCase() + node.slice(1)}
+																</SelectItem>
+															))}
+														</SelectGroup>
+													</SelectContent>
+												</Select>
+												<FormMessage />
+											</FormItem>
+										)}
+									/>
+								)}
+								{type === "libsql" && sqldNode === "replica" && (
+									<FormField
+										control={form.control}
+										name="sqldPrimaryUrl"
+										render={({ field }) => (
+											<FormItem>
+												<FormLabel>Sqld Primary URL</FormLabel>
+												<FormControl>
+													<Input
+														placeholder={"https://<host>:<port>"}
+														autoComplete="off"
+														{...field}
+													/>
+												</FormControl>
+
+												<FormMessage />
+											</FormItem>
+										)}
+									/>
+								)}
+
+								{(type === "libsql" ||
 									type === "mariadb" ||
-									type === "postgres" ||
-									type === "mongo") && (
+									type === "mongo" ||
+									type === "mysql" ||
+									type === "postgres") && (
 									<FormField
 										control={form.control}
 										name="databaseUser"
@@ -567,7 +660,7 @@ export const AddDatabase = ({ environmentId, projectName }: Props) => {
 										</FormItem>
 									)}
 								/>
-								{(type === "mysql" || type === "mariadb") && (
+								{(type === "mariadb" || type === "mysql") && (
 									<FormField
 										control={form.control}
 										name="databaseRootPassword"
@@ -29,13 +29,14 @@ export type Services = {
 	serverId?: string | null;
 	name: string;
 	type:
-		| "mariadb"
 		| "application"
-		| "postgres"
-		| "mysql"
+		| "compose"
+		| "libsql"
+		| "mariadb"
 		| "mongo"
-		| "redis"
-		| "compose";
+		| "mysql"
+		| "postgres"
+		| "redis";
 	description?: string | null;
 	id: string;
 	createdAt: string;
@@ -14,6 +14,7 @@ import { useEffect, useMemo, useState } from "react";
 import { toast } from "sonner";
 import { BreadcrumbSidebar } from "@/components/shared/breadcrumb-sidebar";
 import { DateTooltip } from "@/components/shared/date-tooltip";
+import { FocusShortcutInput } from "@/components/shared/focus-shortcut-input";
 import { StatusTooltip } from "@/components/shared/status-tooltip";
 import {
 	AlertDialog,
@@ -44,7 +45,6 @@ import {
 	DropdownMenuSeparator,
 	DropdownMenuTrigger,
 } from "@/components/ui/dropdown-menu";
-import { FocusShortcutInput } from "@/components/shared/focus-shortcut-input";
 import {
 	Select,
 	SelectContent,
@@ -192,26 +192,27 @@ export const ShowProjects = () => {
 												.map(
 													(env) =>
 														env.applications.length === 0 &&
+														env.compose.length === 0 &&
+														env.libsql.length === 0 &&
 														env.mariadb.length === 0 &&
 														env.mongo.length === 0 &&
 														env.mysql.length === 0 &&
 														env.postgres.length === 0 &&
-														env.redis.length === 0 &&
-														env.applications.length === 0 &&
-														env.compose.length === 0,
+														env.redis.length === 0,
 												)
 												.every(Boolean);

 											const totalServices = project?.environments
 												.map(
 													(env) =>
+														env.applications.length +
+														env.compose.length +
+														env.libsql.length +
 														env.mariadb.length +
 														env.mongo.length +
 														env.mysql.length +
 														env.postgres.length +
-														env.redis.length +
-														env.applications.length +
-														env.compose.length,
+														env.redis.length,
 												)
 												.reduce((acc, curr) => acc + curr, 0);

@@ -291,7 +292,7 @@ export const ShowProjects = () => {
 																				)}
 																			</DropdownMenuGroup>
 																		)}
-																		{/* 
+																		{/*
 																		{project.compose.length > 0 && (
 																			<DropdownMenuGroup>
 																				<DropdownMenuLabel>
@@ -17,17 +17,18 @@ import { api } from "@/utils/api";

 interface Props {
 	id: string;
-	type: "postgres" | "mysql" | "mariadb" | "mongo" | "redis";
+	type: "libsql" | "mariadb" | "mongo" | "mysql" | "postgres" | "redis";
 }

 export const RebuildDatabase = ({ id, type }: Props) => {
 	const utils = api.useUtils();

 	const mutationMap = {
-		postgres: () => api.postgres.rebuild.useMutation(),
-		mysql: () => api.mysql.rebuild.useMutation(),
+		libsql: () => api.libsql.rebuild.useMutation(),
 		mariadb: () => api.mariadb.rebuild.useMutation(),
 		mongo: () => api.mongo.rebuild.useMutation(),
+		mysql: () => api.mysql.rebuild.useMutation(),
+		postgres: () => api.postgres.rebuild.useMutation(),
 		redis: () => api.redis.rebuild.useMutation(),
 	};

@@ -36,10 +37,11 @@ export const RebuildDatabase = ({ id, type }: Props) => {
 	const handleRebuild = async () => {
 		try {
 			await mutateAsync({
-				postgresId: type === "postgres" ? id : "",
-				mysqlId: type === "mysql" ? id : "",
+				libsqlId: type === "libsql" ? id : "",
 				mariadbId: type === "mariadb" ? id : "",
 				mongoId: type === "mongo" ? id : "",
+				mysqlId: type === "mysql" ? id : "",
+				postgresId: type === "postgres" ? id : "",
 				redisId: type === "redis" ? id : "",
 			});
 			toast.success("Database rebuilt successfully");
@@ -6,7 +6,7 @@ import { RebuildDatabase } from "./rebuild-database";

 interface Props {
 	id: string;
-	type: "postgres" | "mysql" | "mariadb" | "mongo" | "redis";
+	type: "libsql" | "mariadb" | "mongo" | "mysql" | "postgres" | "redis";
 }

 export const ShowDatabaseAdvancedSettings = ({ id, type }: Props) => {
@@ -156,6 +156,61 @@ export const RedisIcon = ({ className }: Props) => {
 	);
 };

+export const LibsqlIcon = ({ className }: Props) => {
+	return (
+		<svg
+			aria-label="libsql"
+			height="35"
+			width="35"
+			viewBox="0 0 217.2 217.2"
+			className={className}
+		>
+			<path
+				style={{ fill: "#72f5cf", strokeWidth: "0px" }}
+				d="M118,87.2c.7,0,1.3,0,1.9.3.4.1.8.3,1.2.5.2.1.4.2.6.3.4.3.7.5,1.1.9l5.2,5.2c2.7,2.7,2.7,7,0,9.7l-95.1,95.1c-1.3,1.3-3.1,2-4.8,2s-3.5-.7-4.8-2l-5.2-5.2c-2.7-2.7-2.7-7,0-9.7l85.1-85.1,10-10c.3-.3.7-.6,1.1-.9.2-.1.4-.2.6-.3.4-.2.8-.4,1.2-.5.6-.2,1.3-.3,1.9-.3M118,71.2c-2.2,0-4.4.3-6.5.9-1.4.4-2.8,1-4.1,1.7-.7.4-1.3.7-2,1.2-1.3.8-2.5,1.8-3.6,2.9l-10,10L6.7,173c-8.9,8.9-8.9,23.4,0,32.3l5.2,5.2c4.3,4.3,10.1,6.7,16.2,6.7s11.8-2.4,16.2-6.7l95.1-95.1c4.3-4.3,6.7-10.1,6.7-16.2s-2.4-11.8-6.7-16.2l-5.2-5.2c-1.1-1.1-2.3-2.1-3.6-2.9-.6-.4-1.3-.8-1.9-1.2-1.3-.7-2.7-1.3-4.1-1.7-2.1-.6-4.3-.9-6.5-.9h0Z"
+			/>
+			<g>
+				<path
+					style={{ fill: "#72f5cf", strokeWidth: "0px" }}
+					d="M119.4,16c.3,0,.6,0,.9,0l66.5,3.8c5.8.3,10.3,4.9,10.7,10.7l3.8,66.5c.3,4.4-1.4,8.7-4.5,11.8l-79.7,79.7c-3,3-6.9,4.5-11,4.5s-3.3-.3-4.9-.8l-49.9-16.5c-4.7-1.5-8.3-5.2-9.8-9.8l-16.5-49.9c-1.8-5.6-.4-11.7,3.8-15.8L108.4,20.5c2.9-2.9,6.9-4.5,11-4.5M119.4,0c-8.4,0-16.3,3.3-22.3,9.2L17.4,88.9c-8.5,8.5-11.4,20.8-7.6,32.1l16.5,49.9c3.1,9.4,10.6,16.9,20,20l49.9,16.5c3.2,1.1,6.5,1.6,9.9,1.6,8.4,0,16.3-3.3,22.3-9.2l79.7-79.7c6.3-6.3,9.7-15.1,9.2-24.1l-3.8-66.5c-.8-13.9-11.9-24.9-25.7-25.7L121.2,0c-.6,0-1.2,0-1.8,0h0Z"
+				/>
+				<path
+					style={{ fill: "#a8f7d9", strokeWidth: "0px" }}
+					d="M24.9,116.1l16.5,49.9c1.5,4.7,5.2,8.3,9.8,9.8l49.9,16.5c5.6,1.8,11.7.4,15.8-3.8l79.7-79.7c3.1-3.1,4.8-7.4,4.5-11.8l-3.8-66.5c-.3-5.8-4.9-10.3-10.7-10.7l-66.5-3.8c-4.4-.3-8.7,1.4-11.8,4.5L28.7,100.3c-4.1,4.1-5.6,10.3-3.8,15.8Z"
+				/>
+				<path
+					style={{ fill: "#141b1f", strokeWidth: "0px" }}
+					d="M119.4,16c.3,0,.6,0,.9,0l66.5,3.8c5.8.3,10.3,4.9,10.7,10.7l3.8,66.5c.3,4.4-1.4,8.7-4.5,11.8l-79.7,79.7c-3,3-6.9,4.5-11,4.5s-3.3-.3-4.9-.8l-49.9-16.5c-4.7-1.5-8.3-5.2-9.8-9.8l-16.5-49.9c-1.8-5.6-.4-11.7,3.8-15.8L108.4,20.5c2.9-2.9,6.9-4.5,11-4.5M119.4,6c-6.8,0-13.2,2.7-18,7.5L21.6,93.2c-6.8,6.8-9.2,16.8-6.2,26l16.5,49.9c2.5,7.6,8.6,13.7,16.2,16.2l49.9,16.5c2.6.9,5.3,1.3,8,1.3,6.8,0,13.2-2.7,18-7.5l79.7-79.7c5.1-5.1,7.8-12.2,7.4-19.5l-3.8-66.5c-.6-10.8-9.3-19.5-20.1-20.1l-66.5-3.8c-.5,0-1,0-1.5,0h0Z"
+				/>
+				<path
+					style={{ fill: "#141b1f", strokeWidth: "0px" }}
+					d="M136.7,173.7l6.9-6.9c-.2-.1-.4-.2-.6-.3l-27.6-9.1-6.9,6.9,28.3,9.3Z"
+				/>
+				<path
+					style={{ fill: "#141b1f", strokeWidth: "0px" }}
+					d="M166.5,143.9l6.9-6.9c-.2-.1-.4-.2-.6-.3l-27.6-9.1-6.9,6.9,28.3,9.3Z"
+				/>
+				<path
+					style={{ fill: "#141b1f", strokeWidth: "0px" }}
+					d="M43.5,80.5l6.9-6.9c.1.2.2.4.3.6l9.1,27.6-6.9,6.9-9.3-28.3Z"
+				/>
+				<path
+					style={{ fill: "#141b1f", strokeWidth: "0px" }}
+					d="M73.3,50.7l6.9-6.9c.1.2.2.4.3.6l9.1,27.6-6.9,6.9-9.3-28.3Z"
+				/>
+			</g>
+			<path
+				style={{ fill: "#79ac91", strokeWidth: "0px" }}
+				d="M130.6,101.5l-97.7,97.7c-2.7,2.7-7,2.7-9.7,0l-5.2-5.2c-2.7-2.7-2.7-7,0-9.7l97.7-97.7c1.5-1.5,3.4-2.4,5.5-2.6l7.9-.8c2.8-.3,5.1,2.1,4.9,4.9l-.8,7.9c-.2,2.1-1.1,4-2.6,5.5Z"
+			/>
+			<path
+				style={{ fill: "#141b1f", strokeWidth: "0px" }}
+				d="M129.5,83.3c2.6,0,4.7,2.2,4.4,4.9l-.8,7.9c-.2,2.1-1.1,4-2.6,5.5l-97.7,97.7c-1.3,1.3-3.1,2-4.8,2s-3.5-.7-4.8-2l-5.2-5.2c-2.7-2.7-2.7-7,0-9.7l97.7-97.7c1.5-1.5,3.4-2.4,5.5-2.6l7.9-.8c.1,0,.3,0,.4,0M129.5,73.3h0c-.5,0-.9,0-1.4,0l-7.9.8c-4.4.4-8.5,2.4-11.5,5.5L10.9,177.3c-6.6,6.6-6.6,17.3,0,23.8l5.2,5.2c3.2,3.2,7.4,4.9,11.9,4.9s8.7-1.8,11.9-4.9l97.7-97.7c3.1-3.1,5-7.2,5.5-11.5l.8-7.9c.4-4-.9-8.1-3.7-11.1-2.7-3-6.6-4.7-10.7-4.7h0Z"
+			/>
+		</svg>
+	);
+};
+
 export const GitlabIcon = ({ className }: Props) => {
 	return (
 		<svg
@@ -6,11 +6,12 @@ import { useCallback, useEffect, useState } from "react";
 const PAGES = [
 	"compose",
 	"application",
-	"postgres",
-	"redis",
-	"mysql",
+	"libsql",
 	"mariadb",
 	"mongodb",
+	"mysql",
+	"postgres",
+	"redis",
 ] as const;
 type Page = (typeof PAGES)[number];

@@ -63,11 +64,12 @@ const REDIS_SHORTCUTS: Shortcuts = {
 const SHORTCUTS: ShortcutsDictionary = {
 	application: APPLICATION_SHORTCUTS,
 	compose: COMPOSE_SHORTCUTS,
-	postgres: POSTGRES_SHORTCUTS,
-	redis: REDIS_SHORTCUTS,
-	mysql: POSTGRES_SHORTCUTS,
+	libsql: POSTGRES_SHORTCUTS,
 	mariadb: POSTGRES_SHORTCUTS,
 	mongodb: POSTGRES_SHORTCUTS,
+	mysql: POSTGRES_SHORTCUTS,
+	postgres: POSTGRES_SHORTCUTS,
+	redis: REDIS_SHORTCUTS,
 };

 /**
@@ -35,6 +35,7 @@ import { AdvancedEnvironmentSelector } from "@/components/dashboard/project/adva
 import { DuplicateProject } from "@/components/dashboard/project/duplicate-project";
 import { ProjectEnvironment } from "@/components/dashboard/projects/project-environment";
 import {
+	LibsqlIcon,
 	MariadbIcon,
 	MongodbIcon,
 	MysqlIcon,
@@ -46,6 +47,7 @@ import { AlertBlock } from "@/components/shared/alert-block";
 import { BreadcrumbSidebar } from "@/components/shared/breadcrumb-sidebar";
 import { DateTooltip } from "@/components/shared/date-tooltip";
 import { DialogAction } from "@/components/shared/dialog-action";
+import { FocusShortcutInput } from "@/components/shared/focus-shortcut-input";
 import { StatusTooltip } from "@/components/shared/status-tooltip";
 import { Button } from "@/components/ui/button";
 import {
@@ -95,20 +97,20 @@ import {
 import { cn } from "@/lib/utils";
 import { appRouter } from "@/server/api/root";
 import { api } from "@/utils/api";
-import { FocusShortcutInput } from "@/components/shared/focus-shortcut-input";

 export type Services = {
 	appName: string;
 	serverId?: string | null;
 	name: string;
 	type:
-		| "mariadb"
 		| "application"
-		| "postgres"
-		| "mysql"
+		| "compose"
+		| "libsql"
+		| "mariadb"
 		| "mongo"
-		| "redis"
-		| "compose";
+		| "mysql"
+		| "postgres"
+		| "redis";
 	description?: string | null;
 	id: string;
 	createdAt: string;
@@ -137,24 +139,36 @@ export const extractServicesFromEnvironment = (
 			serverId: item.serverId,
 		})) || [];

-	const mariadb: Services[] =
-		environment.mariadb?.map((item) => ({
+	const compose: Services[] =
+		environment.compose?.map((item) => ({
 			appName: item.appName,
 			name: item.name,
-			type: "mariadb",
-			id: item.mariadbId,
+			type: "compose",
+			id: item.composeId,
+			createdAt: item.createdAt,
+			status: item.composeStatus,
+			description: item.description,
+			serverId: item.serverId,
+		})) || [];
+
+	const libsql: Services[] =
+		environment.libsql?.map((item) => ({
+			appName: item.appName,
+			name: item.name,
+			type: "libsql",
+			id: item.libsqlId,
 			createdAt: item.createdAt,
 			status: item.applicationStatus,
 			description: item.description,
 			serverId: item.serverId,
 		})) || [];

-	const postgres: Services[] =
-		environment.postgres?.map((item) => ({
+	const mariadb: Services[] =
+		environment.mariadb?.map((item) => ({
 			appName: item.appName,
 			name: item.name,
-			type: "postgres",
-			id: item.postgresId,
+			type: "mariadb",
+			id: item.mariadbId,
 			createdAt: item.createdAt,
 			status: item.applicationStatus,
 			description: item.description,
@@ -173,18 +187,6 @@ export const extractServicesFromEnvironment = (
 			serverId: item.serverId,
 		})) || [];

-	const redis: Services[] =
-		environment.redis?.map((item) => ({
-			appName: item.appName,
-			name: item.name,
-			type: "redis",
-			id: item.redisId,
-			createdAt: item.createdAt,
-			status: item.applicationStatus,
-			description: item.description,
-			serverId: item.serverId,
-		})) || [];
-
 	const mysql: Services[] =
 		environment.mysql?.map((item) => ({
 			appName: item.appName,
@@ -197,26 +199,39 @@ export const extractServicesFromEnvironment = (
 			serverId: item.serverId,
 		})) || [];

-	const compose: Services[] =
-		environment.compose?.map((item) => ({
+	const postgres: Services[] =
+		environment.postgres?.map((item) => ({
 			appName: item.appName,
 			name: item.name,
-			type: "compose",
-			id: item.composeId,
+			type: "postgres",
+			id: item.postgresId,
 			createdAt: item.createdAt,
-			status: item.composeStatus,
+			status: item.applicationStatus,
+			description: item.description,
+			serverId: item.serverId,
+		})) || [];
+
+	const redis: Services[] =
+		environment.redis?.map((item) => ({
+			appName: item.appName,
+			name: item.name,
+			type: "redis",
+			id: item.redisId,
+			createdAt: item.createdAt,
+			status: item.applicationStatus,
 			description: item.description,
 			serverId: item.serverId,
 		})) || [];

 	allServices.push(
 		...applications,
-		...mysql,
-		...redis,
-		...mongo,
-		...postgres,
-		...mariadb,
 		...compose,
+		...libsql,
+		...mariadb,
+		...mongo,
+		...mysql,
+		...postgres,
+		...redis,
 	);

 	allServices.sort((a, b) => {
@@ -291,25 +306,27 @@ const EnvironmentPage = (

 	const emptyServices =
 		!currentEnvironment ||
-		((currentEnvironment.mariadb?.length || 0) === 0 &&
+		((currentEnvironment.applications?.length || 0) === 0 &&
+			(currentEnvironment.compose?.length || 0) === 0 &&
+			(currentEnvironment.libsql?.length || 0) === 0 &&
+			(currentEnvironment.mariadb?.length || 0) === 0 &&
 			(currentEnvironment.mongo?.length || 0) === 0 &&
 			(currentEnvironment.mysql?.length || 0) === 0 &&
 			(currentEnvironment.postgres?.length || 0) === 0 &&
-			(currentEnvironment.redis?.length || 0) === 0 &&
-			(currentEnvironment.applications?.length || 0) === 0 &&
-			(currentEnvironment.compose?.length || 0) === 0);
+			(currentEnvironment.redis?.length || 0) === 0);

 	const applications = extractServicesFromEnvironment(currentEnvironment);

 	const [searchQuery, setSearchQuery] = useState("");
 	const serviceTypes = [
 		{ value: "application", label: "Application", icon: GlobeIcon },
-		{ value: "postgres", label: "PostgreSQL", icon: PostgresqlIcon },
+		{ value: "compose", label: "Compose", icon: CircuitBoard },
+		{ value: "libsql", label: "Libsql", icon: LibsqlIcon },
 		{ value: "mariadb", label: "MariaDB", icon: MariadbIcon },
 		{ value: "mongo", label: "MongoDB", icon: MongodbIcon },
 		{ value: "mysql", label: "MySQL", icon: MysqlIcon },
+		{ value: "postgres", label: "PostgreSQL", icon: PostgresqlIcon },
 		{ value: "redis", label: "Redis", icon: RedisIcon },
-		{ value: "compose", label: "Compose", icon: CircuitBoard },
 	];

 	const [selectedTypes, setSelectedTypes] = useState<string[]>([]);
@@ -336,14 +353,6 @@ const EnvironmentPage = (
 		);
 	};

-	const composeActions = {
-		start: api.compose.start.useMutation(),
-		stop: api.compose.stop.useMutation(),
-		move: api.compose.move.useMutation(),
-		delete: api.compose.delete.useMutation(),
-		deploy: api.compose.deploy.useMutation(),
-	};
-
 	const applicationActions = {
 		start: api.application.start.useMutation(),
 		stop: api.application.stop.useMutation(),
@@ -352,20 +361,20 @@ const EnvironmentPage = (
 		deploy: api.application.deploy.useMutation(),
 	};

-	const postgresActions = {
-		start: api.postgres.start.useMutation(),
-		stop: api.postgres.stop.useMutation(),
-		move: api.postgres.move.useMutation(),
-		delete: api.postgres.remove.useMutation(),
-		deploy: api.postgres.deploy.useMutation(),
+	const composeActions = {
+		start: api.compose.start.useMutation(),
+		stop: api.compose.stop.useMutation(),
+		move: api.compose.move.useMutation(),
+		delete: api.compose.delete.useMutation(),
+		deploy: api.compose.deploy.useMutation(),
 	};

-	const mysqlActions = {
-		start: api.mysql.start.useMutation(),
-		stop: api.mysql.stop.useMutation(),
-		move: api.mysql.move.useMutation(),
-		delete: api.mysql.remove.useMutation(),
-		deploy: api.mysql.deploy.useMutation(),
+	const libsqlActions = {
+		start: api.libsql.start.useMutation(),
+		stop: api.libsql.stop.useMutation(),
+		move: api.libsql.move.useMutation(),
+		delete: api.libsql.remove.useMutation(),
+		deploy: api.libsql.deploy.useMutation(),
 	};

 	const mariadbActions = {
@@ -376,14 +385,6 @@ const EnvironmentPage = (
 		deploy: api.mariadb.deploy.useMutation(),
 	};

-	const redisActions = {
-		start: api.redis.start.useMutation(),
-		stop: api.redis.stop.useMutation(),
-		move: api.redis.move.useMutation(),
-		delete: api.redis.remove.useMutation(),
-		deploy: api.redis.deploy.useMutation(),
-	};
-
 	const mongoActions = {
 		start: api.mongo.start.useMutation(),
 		stop: api.mongo.stop.useMutation(),
@@ -392,6 +393,30 @@ const EnvironmentPage = (
 		deploy: api.mongo.deploy.useMutation(),
 	};

+	const mysqlActions = {
+		start: api.mysql.start.useMutation(),
+		stop: api.mysql.stop.useMutation(),
+		move: api.mysql.move.useMutation(),
+		delete: api.mysql.remove.useMutation(),
+		deploy: api.mysql.deploy.useMutation(),
+	};
+
+	const postgresActions = {
+		start: api.postgres.start.useMutation(),
+		stop: api.postgres.stop.useMutation(),
+		move: api.postgres.move.useMutation(),
+		delete: api.postgres.remove.useMutation(),
+		deploy: api.postgres.deploy.useMutation(),
+	};
+
+	const redisActions = {
+		start: api.redis.start.useMutation(),
+		stop: api.redis.stop.useMutation(),
+		move: api.redis.move.useMutation(),
+		delete: api.redis.remove.useMutation(),
+		deploy: api.redis.deploy.useMutation(),
+	};
+
 	const handleBulkStart = async () => {
 		let success = 0;
 		setIsBulkActionLoading(true);
@@ -409,20 +434,23 @@ const EnvironmentPage = (
 					case "compose":
 						await composeActions.start.mutateAsync({ composeId: serviceId });
 						break;
-					case "postgres":
-						await postgresActions.start.mutateAsync({ postgresId: serviceId });
-						break;
-					case "mysql":
-						await mysqlActions.start.mutateAsync({ mysqlId: serviceId });
+					case "libsql":
+						await libsqlActions.start.mutateAsync({ libsqlId: serviceId });
 						break;
 					case "mariadb":
 						await mariadbActions.start.mutateAsync({ mariadbId: serviceId });
 						break;
+					case "mongo":
+						await mongoActions.start.mutateAsync({ mongoId: serviceId });
+						break;
+					case "mysql":
+						await mysqlActions.start.mutateAsync({ mysqlId: serviceId });
+						break;
 					case "redis":
 						await redisActions.start.mutateAsync({ redisId: serviceId });
 						break;
-					case "mongo":
-						await mongoActions.start.mutateAsync({ mongoId: serviceId });
+					case "postgres":
+						await postgresActions.start.mutateAsync({ postgresId: serviceId });
 						break;
 				}
 				success++;
@@ -456,21 +484,24 @@ const EnvironmentPage = (
 					case "compose":
 						await composeActions.stop.mutateAsync({ composeId: serviceId });
 						break;
-					case "postgres":
-						await postgresActions.stop.mutateAsync({ postgresId: serviceId });
-						break;
-					case "mysql":
-						await mysqlActions.stop.mutateAsync({ mysqlId: serviceId });
+					case "libsql":
+						await libsqlActions.stop.mutateAsync({ libsqlId: serviceId });
 						break;
 					case "mariadb":
 						await mariadbActions.stop.mutateAsync({ mariadbId: serviceId });
 						break;
-					case "redis":
-						await redisActions.stop.mutateAsync({ redisId: serviceId });
-						break;
 					case "mongo":
 						await mongoActions.stop.mutateAsync({ mongoId: serviceId });
 						break;
+					case "mysql":
+						await mysqlActions.stop.mutateAsync({ mysqlId: serviceId });
+						break;
+					case "postgres":
+						await postgresActions.stop.mutateAsync({ postgresId: serviceId });
+						break;
+					case "redis":
+						await redisActions.stop.mutateAsync({ redisId: serviceId });
+						break;
 				}
 				success++;
 			} catch {
@@ -517,15 +548,9 @@ const EnvironmentPage = (
 							targetEnvironmentId: selectedTargetEnvironment,
 						});
 						break;
-					case "postgres":
-						await postgresActions.move.mutateAsync({
-							postgresId: serviceId,
-							targetEnvironmentId: selectedTargetEnvironment,
-						});
-						break;
-					case "mysql":
-						await mysqlActions.move.mutateAsync({
-							mysqlId: serviceId,
+					case "libsql":
+						await libsqlActions.move.mutateAsync({
+							libsqlId: serviceId,
 							targetEnvironmentId: selectedTargetEnvironment,
 						});
 						break;
@@ -535,18 +560,30 @@ const EnvironmentPage = (
 							targetEnvironmentId: selectedTargetEnvironment,
 						});
 						break;
-					case "redis":
-						await redisActions.move.mutateAsync({
-							redisId: serviceId,
-							targetEnvironmentId: selectedTargetEnvironment,
-						});
-						break;
 					case "mongo":
 						await mongoActions.move.mutateAsync({
 							mongoId: serviceId,
 							targetEnvironmentId: selectedTargetEnvironment,
 						});
 						break;
+					case "mysql":
+						await mysqlActions.move.mutateAsync({
+							mysqlId: serviceId,
+							targetEnvironmentId: selectedTargetEnvironment,
+						});
+						break;
+					case "postgres":
+						await postgresActions.move.mutateAsync({
+							postgresId: serviceId,
+							targetEnvironmentId: selectedTargetEnvironment,
+						});
+						break;
+					case "redis":
+						await redisActions.move.mutateAsync({
+							redisId: serviceId,
+							targetEnvironmentId: selectedTargetEnvironment,
+						});
+						break;
 				}
 				await utils.environment.one.invalidate({
 					environmentId,
@@ -591,14 +628,9 @@ const EnvironmentPage = (
 							deleteVolumes,
 						});
 						break;
-					case "postgres":
-						await postgresActions.delete.mutateAsync({
-							postgresId: serviceId,
-						});
-						break;
-					case "mysql":
-						await mysqlActions.delete.mutateAsync({
-							mysqlId: serviceId,
+					case "libsql":
+						await libsqlActions.delete.mutateAsync({
+							libsqlId: serviceId,
 						});
 						break;
 					case "mariadb":
@@ -606,16 +638,26 @@ const EnvironmentPage = (
 							mariadbId: serviceId,
 						});
 						break;
-					case "redis":
-						await redisActions.delete.mutateAsync({
-							redisId: serviceId,
-						});
-						break;
 					case "mongo":
 						await mongoActions.delete.mutateAsync({
 							mongoId: serviceId,
 						});
 						break;
+					case "mysql":
+						await mysqlActions.delete.mutateAsync({
+							mysqlId: serviceId,
+						});
+						break;
+					case "postgres":
+						await postgresActions.delete.mutateAsync({
+							postgresId: serviceId,
+						});
+						break;
+					case "redis":
+						await redisActions.delete.mutateAsync({
+							redisId: serviceId,
+						});
+						break;
 				}
 				await utils.environment.one.invalidate({
 					environmentId,
@@ -657,14 +699,9 @@ const EnvironmentPage = (
 							composeId: serviceId,
 						});
 						break;
-					case "postgres":
-						await postgresActions.deploy.mutateAsync({
-							postgresId: serviceId,
-						});
-						break;
-					case "mysql":
-						await mysqlActions.deploy.mutateAsync({
-							mysqlId: serviceId,
+					case "libsql":
+						await libsqlActions.deploy.mutateAsync({
+							libsqlId: serviceId,
 						});
 						break;
 					case "mariadb":
@@ -672,16 +709,26 @@ const EnvironmentPage = (
 							mariadbId: serviceId,
 						});
 						break;
-					case "redis":
-						await redisActions.deploy.mutateAsync({
-							redisId: serviceId,
-						});
-						break;
 					case "mongo":
 						await mongoActions.deploy.mutateAsync({
 							mongoId: serviceId,
 						});
 						break;
+					case "mysql":
+						await mysqlActions.deploy.mutateAsync({
+							mysqlId: serviceId,
+						});
+						break;
+					case "postgres":
+						await postgresActions.deploy.mutateAsync({
+							postgresId: serviceId,
+						});
+						break;
+					case "redis":
+						await redisActions.deploy.mutateAsync({
+							redisId: serviceId,
+						});
+						break;
 				}
 				success++;
 			} catch (error) {
@@ -1363,11 +1410,14 @@ const EnvironmentPage = (
 																	</div>

 																	<span className="text-sm font-medium text-muted-foreground self-start">
-																		{service.type === "postgres" && (
-																			<PostgresqlIcon className="h-7 w-7" />
+																		{service.type === "application" && (
+																			<GlobeIcon className="h-6 w-6" />
 																		)}
-																		{service.type === "redis" && (
-																			<RedisIcon className="h-7 w-7" />
+																		{service.type === "compose" && (
+																			<CircuitBoard className="h-6 w-6" />
+																		)}
+																		{service.type === "libsql" && (
+																			<LibsqlIcon className="h-7 w-7" />
 																		)}
 																		{service.type === "mariadb" && (
 																			<MariadbIcon className="h-7 w-7" />
@@ -1378,11 +1428,11 @@ const EnvironmentPage = (
 																		{service.type === "mysql" && (
 																			<MysqlIcon className="h-7 w-7" />
 																		)}
-																		{service.type === "application" && (
-																			<GlobeIcon className="h-6 w-6" />
+																		{service.type === "postgres" && (
+																			<PostgresqlIcon className="h-7 w-7" />
 																		)}
-																		{service.type === "compose" && (
-																			<CircuitBoard className="h-6 w-6" />
+																		{service.type === "redis" && (
+																			<RedisIcon className="h-7 w-7" />
 																		)}
 																	</span>
 																</div>
@@ -0,0 +1,361 @@
+import { validateRequest } from "@dokploy/server/lib/auth";
+import { createServerSideHelpers } from "@trpc/react-query/server";
+import { HelpCircle, ServerOff } from "lucide-react";
+import type {
+	GetServerSidePropsContext,
+	InferGetServerSidePropsType,
+} from "next";
+import Head from "next/head";
+import Link from "next/link";
+import { useRouter } from "next/router";
+import { type ReactElement, useState } from "react";
+import superjson from "superjson";
+import { ShowEnvironment } from "@/components/dashboard/application/environment/show-enviroment";
+import { ShowDockerLogs } from "@/components/dashboard/application/logs/show";
+import { DeleteService } from "@/components/dashboard/compose/delete-service";
+import { ShowExternalLibsqlCredentials } from "@/components/dashboard/libsql/general/show-external-libsql-credentials";
+import { ShowGeneralLibsql } from "@/components/dashboard/libsql/general/show-general-libsql";
+import { ShowInternalLibsqlCredentials } from "@/components/dashboard/libsql/general/show-internal-libsql-credentials";
+import { UpdateLibsql } from "@/components/dashboard/libsql/update-libsql";
+import { ContainerFreeMonitoring } from "@/components/dashboard/monitoring/free/container/show-free-container-monitoring";
+import { ContainerPaidMonitoring } from "@/components/dashboard/monitoring/paid/container/show-paid-container-monitoring";
+import { ShowDatabaseAdvancedSettings } from "@/components/dashboard/shared/show-database-advanced-settings";
+import { LibsqlIcon } from "@/components/icons/data-tools-icons";
+import { DashboardLayout } from "@/components/layouts/dashboard-layout";
+import { BreadcrumbSidebar } from "@/components/shared/breadcrumb-sidebar";
+import { StatusTooltip } from "@/components/shared/status-tooltip";
+import { Badge } from "@/components/ui/badge";
+import {
+	Card,
+	CardContent,
+	CardDescription,
+	CardHeader,
+	CardTitle,
+} from "@/components/ui/card";
+import { Label } from "@/components/ui/label";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import {
+	Tooltip,
+	TooltipContent,
+	TooltipProvider,
+	TooltipTrigger,
+} from "@/components/ui/tooltip";
+import { UseKeyboardNav } from "@/hooks/use-keyboard-nav";
+import { cn } from "@/lib/utils";
+import { appRouter } from "@/server/api/root";
+import { api } from "@/utils/api";
+
+type TabState = "projects" | "monitoring" | "settings" | "backups" | "advanced";
+
+const Libsql = (
+	props: InferGetServerSidePropsType<typeof getServerSideProps>,
+) => {
+	const [_toggleMonitoring, _setToggleMonitoring] = useState(false);
+
+	const { libsqlId, activeTab } = props;
+	const router = useRouter();
+	const { projectId, environmentId } = router.query;
+	const [tab, setSab] = useState<TabState>(activeTab);
+	const { data } = api.libsql.one.useQuery({ libsqlId });
+	const { data: auth } = api.user.get.useQuery();
+
+	const { data: isCloud } = api.settings.isCloud.useQuery();
+
+	return (
+		<div className="pb-10">
+			<UseKeyboardNav forPage="libsql" />
+			<BreadcrumbSidebar
+				list={[
+					{ name: "Projects", href: "/dashboard/projects" },
+					{
+						name: data?.environment?.project?.name || "",
+					},
+					{
+						name: data?.environment?.name || "",
+						href: `/dashboard/project/${projectId}/environment/${environmentId}`,
+					},
+					{
+						name: data?.name || "",
+					},
+				]}
+			/>
+			<div className="flex flex-col gap-4">
+				<Head>
+					<title>
+						Database: {data?.name} - {data?.environment?.project?.name} |
+						Dokploy
+					</title>
+				</Head>
+				<Card className="h-full bg-sidebar  p-2.5 rounded-xl w-full">
+					<div className="rounded-xl bg-background shadow-md ">
+						<CardHeader className="flex flex-row justify-between items-center">
+							<div className="flex flex-col">
+								<CardTitle className="text-xl flex flex-row gap-2">
+									<div className="relative flex flex-row gap-4">
+										<div className="absolute -right-1  -top-2">
+											<StatusTooltip status={data?.applicationStatus} />
+										</div>
+
+										<LibsqlIcon className="h-6 w-6 text-muted-foreground" />
+									</div>
+									{data?.name}
+								</CardTitle>
+								{data?.description && (
+									<CardDescription>{data?.description}</CardDescription>
+								)}
+
+								<span className="text-sm text-muted-foreground">
+									{data?.appName}
+								</span>
+							</div>
+							<div className="flex flex-col h-fit w-fit gap-2">
+								<div className="flex flex-row h-fit w-fit gap-2">
+									<Badge
+										variant={
+											!data?.serverId
+												? "default"
+												: data?.server?.serverStatus === "active"
+													? "default"
+													: "destructive"
+										}
+									>
+										{data?.server?.name || "Dokploy Server"}
+									</Badge>
+									{data?.server?.serverStatus === "inactive" && (
+										<TooltipProvider delayDuration={0}>
+											<Tooltip>
+												<TooltipTrigger asChild>
+													<Label className="break-all w-fit flex flex-row gap-1 items-center">
+														<HelpCircle className="size-4 text-muted-foreground" />
+													</Label>
+												</TooltipTrigger>
+												<TooltipContent
+													className="z-[999] w-[300px]"
+													align="start"
+													side="top"
+												>
+													<span>
+														You cannot, deploy this application because the
+														server is inactive, please upgrade your plan to add
+														more servers.
+													</span>
+												</TooltipContent>
+											</Tooltip>
+										</TooltipProvider>
+									)}
+								</div>
+								<div className="flex flex-row gap-2 justify-end">
+									<UpdateLibsql libsqlId={libsqlId} />
+									{(auth?.role === "owner" || auth?.canDeleteServices) && (
+										<DeleteService id={libsqlId} type="libsql" />
+									)}
+								</div>
+							</div>
+						</CardHeader>
+						<CardContent className="space-y-2 py-8 border-t">
+							{data?.server?.serverStatus === "inactive" ? (
+								<div className="flex h-[55vh] border-2 rounded-xl border-dashed p-4">
+									<div className="max-w-3xl mx-auto flex flex-col items-center justify-center self-center gap-3">
+										<ServerOff className="size-10 text-muted-foreground self-center" />
+										<span className="text-center text-base text-muted-foreground">
+											This service is hosted on the server {data.server.name},
+											but this server has been disabled because your current
+											plan doesn't include enough servers. Please purchase more
+											servers to regain access to this application.
+										</span>
+										<span className="text-center text-base text-muted-foreground">
+											Go to{" "}
+											<Link
+												href="/dashboard/settings/billing"
+												className="text-primary"
+											>
+												Billing
+											</Link>
+										</span>
+									</div>
+								</div>
+							) : (
+								<Tabs
+									value={tab}
+									defaultValue="general"
+									className="w-full"
+									onValueChange={(e) => {
+										setSab(e as TabState);
+										const newPath = `/dashboard/project/${projectId}/environment/${environmentId}/services/libsql/${libsqlId}?tab=${e}`;
+
+										router.push(newPath, undefined, { shallow: true });
+									}}
+								>
+									<div className="flex flex-row items-center justify-between w-full gap-4 overflow-x-scroll">
+										<TabsList
+											className={cn(
+												"md:grid md:w-fit max-md:overflow-y-scroll justify-start",
+												isCloud && data?.serverId
+													? "md:grid-cols-6"
+													: data?.serverId
+														? "md:grid-cols-5"
+														: "md:grid-cols-6",
+											)}
+										>
+											<TabsTrigger value="general">General</TabsTrigger>
+											<TabsTrigger value="environment">Environment</TabsTrigger>
+											<TabsTrigger value="logs">Logs</TabsTrigger>
+											{((data?.serverId && isCloud) || !data?.server) && (
+												<TabsTrigger value="monitoring">Monitoring</TabsTrigger>
+											)}
+											<TabsTrigger value="backups">Backups</TabsTrigger>
+											<TabsTrigger value="advanced">Advanced</TabsTrigger>
+										</TabsList>
+									</div>
+
+									<TabsContent value="general">
+										<div className="flex flex-col gap-4 pt-2.5">
+											<ShowGeneralLibsql libsqlId={libsqlId} />
+											<ShowInternalLibsqlCredentials libsqlId={libsqlId} />
+											<ShowExternalLibsqlCredentials libsqlId={libsqlId} />
+										</div>
+									</TabsContent>
+									<TabsContent value="environment">
+										<div className="flex flex-col gap-4 pt-2.5">
+											<ShowEnvironment id={libsqlId} type="libsql" />
+										</div>
+									</TabsContent>
+									<TabsContent value="monitoring">
+										<div className="pt-2.5">
+											<div className="flex flex-col gap-4 border rounded-lg p-6">
+												{data?.serverId && isCloud ? (
+													<ContainerPaidMonitoring
+														appName={data?.appName || ""}
+														baseUrl={`${data?.serverId ? `http://${data?.server?.ipAddress}:${data?.server?.metricsConfig?.server?.port}` : "http://localhost:4500"}`}
+														token={
+															data?.server?.metricsConfig?.server?.token || ""
+														}
+													/>
+												) : (
+													<>
+														{/* {monitoring?.enabledFeatures && (
+															<div className="flex flex-row border w-fit p-4 rounded-lg items-center gap-2">
+																<Label className="text-muted-foreground">
+																	Change Monitoring
+																</Label>
+																<Switch
+																	checked={toggleMonitoring}
+																	onCheckedChange={setToggleMonitoring}
+																/>
+															</div>
+														)}
+
+														{toggleMonitoring ? (
+															<ContainerPaidMonitoring
+																appName={data?.appName || ""}
+																baseUrl={`http://${monitoring?.serverIp}:${monitoring?.metricsConfig?.server?.port}`}
+																token={
+																	monitoring?.metricsConfig?.server?.token || ""
+																}
+															/>
+														) : (
+															<div> */}
+														<ContainerFreeMonitoring
+															appName={data?.appName || ""}
+														/>
+														{/* </div> */}
+														{/* )} */}
+													</>
+												)}
+											</div>
+										</div>
+									</TabsContent>
+									<TabsContent value="logs">
+										<div className="flex flex-col gap-4  pt-2.5">
+											<ShowDockerLogs
+												serverId={data?.serverId || ""}
+												appName={data?.appName || ""}
+											/>
+										</div>
+									</TabsContent>
+									<TabsContent value="advanced">
+										<div className="flex flex-col gap-4 pt-2.5">
+											<ShowDatabaseAdvancedSettings
+												id={libsqlId}
+												type="libsql"
+											/>
+										</div>
+									</TabsContent>
+								</Tabs>
+							)}
+						</CardContent>
+					</div>
+				</Card>
+			</div>
+		</div>
+	);
+};
+
+export default Libsql;
+Libsql.getLayout = (page: ReactElement) => {
+	return <DashboardLayout>{page}</DashboardLayout>;
+};
+
+export async function getServerSideProps(
+	ctx: GetServerSidePropsContext<{
+		libsqlId: string;
+		activeTab: TabState;
+		environmentId: string;
+	}>,
+) {
+	const { query, params, req, res } = ctx;
+	const activeTab = query.tab;
+
+	const { user, session } = await validateRequest(req);
+	if (!user) {
+		return {
+			redirect: {
+				permanent: true,
+				destination: "/",
+			},
+		};
+	}
+	// Fetch data from external API
+	const helpers = createServerSideHelpers({
+		router: appRouter,
+		ctx: {
+			req: req as any,
+			res: res as any,
+			db: null as any,
+			session: session as any,
+			user: user as any,
+		},
+		transformer: superjson,
+	});
+
+	if (typeof params?.libsqlId === "string") {
+		try {
+			await helpers.libsql.one.fetch({
+				libsqlId: params?.libsqlId,
+			});
+			await helpers.settings.isCloud.prefetch();
+			return {
+				props: {
+					trpcState: helpers.dehydrate(),
+					libsqlId: params?.libsqlId,
+					activeTab: (activeTab || "general") as TabState,
+					environmentId: params?.environmentId,
+				},
+			};
+		} catch {
+			return {
+				redirect: {
+					permanent: false,
+					destination: "/dashboard/projects",
+				},
+			};
+		}
+	}
+
+	return {
+		redirect: {
+			permanent: false,
+			destination: "/",
+		},
+	};
+}
@@ -16,6 +16,7 @@ import { gitProviderRouter } from "./routers/git-provider";
 import { giteaRouter } from "./routers/gitea";
 import { githubRouter } from "./routers/github";
 import { gitlabRouter } from "./routers/gitlab";
+import { libsqlRouter } from "./routers/libsql";
 import { mariadbRouter } from "./routers/mariadb";
 import { mongoRouter } from "./routers/mongo";
 import { mountRouter } from "./routers/mount";
@@ -47,45 +48,46 @@ import { volumeBackupsRouter } from "./routers/volume-backups";

 export const appRouter = createTRPCRouter({
 	admin: adminRouter,
-	docker: dockerRouter,
-	project: projectRouter,
+	ai: aiRouter,
 	application: applicationRouter,
-	mysql: mysqlRouter,
-	postgres: postgresRouter,
-	redis: redisRouter,
-	mongo: mongoRouter,
-	mariadb: mariadbRouter,
-	compose: composeRouter,
-	user: userRouter,
-	domain: domainRouter,
-	destination: destinationRouter,
 	backup: backupRouter,
-	deployment: deploymentRouter,
-	previewDeployment: previewDeploymentRouter,
-	mounts: mountRouter,
-	certificates: certificateRouter,
-	settings: settingsRouter,
-	security: securityRouter,
-	redirects: redirectsRouter,
-	port: portRouter,
-	registry: registryRouter,
-	cluster: clusterRouter,
-	notification: notificationRouter,
-	sshKey: sshRouter,
-	gitProvider: gitProviderRouter,
-	gitea: giteaRouter,
 	bitbucket: bitbucketRouter,
-	gitlab: gitlabRouter,
+	certificates: certificateRouter,
+	cluster: clusterRouter,
+	compose: composeRouter,
+	deployment: deploymentRouter,
+	destination: destinationRouter,
+	docker: dockerRouter,
+	domain: domainRouter,
+	environment: environmentRouter,
+	gitea: giteaRouter,
+	gitProvider: gitProviderRouter,
 	github: githubRouter,
+	gitlab: gitlabRouter,
+	libsql: libsqlRouter,
+	mariadb: mariadbRouter,
+	mongo: mongoRouter,
+	mounts: mountRouter,
+	mysql: mysqlRouter,
+	notification: notificationRouter,
+	organization: organizationRouter,
+	port: portRouter,
+	postgres: postgresRouter,
+	previewDeployment: previewDeploymentRouter,
+	project: projectRouter,
+	redirects: redirectsRouter,
+	redis: redisRouter,
+	registry: registryRouter,
+	rollback: rollbackRouter,
+	schedule: scheduleRouter,
+	security: securityRouter,
 	server: serverRouter,
+	settings: settingsRouter,
+	sshKey: sshRouter,
 	stripe: stripeRouter,
 	swarm: swarmRouter,
-	ai: aiRouter,
-	organization: organizationRouter,
-	schedule: scheduleRouter,
-	rollback: rollbackRouter,
+	user: userRouter,
 	volumeBackups: volumeBackupsRouter,
-	environment: environmentRouter,
 });

 // export type definition of API
@@ -29,6 +29,12 @@ const filterEnvironmentServices = (
 	applications: environment.applications.filter((app: any) =>
 		accessedServices.includes(app.applicationId),
 	),
+	compose: environment.compose.filter((comp: any) =>
+		accessedServices.includes(comp.composeId),
+	),
+	libsql: environment.libsql.filter((db: any) =>
+		accessedServices.includes(db.libsqlId),
+	),
 	mariadb: environment.mariadb.filter((db: any) =>
 		accessedServices.includes(db.mariadbId),
 	),
@@ -44,9 +50,6 @@ const filterEnvironmentServices = (
 	redis: environment.redis.filter((db: any) =>
 		accessedServices.includes(db.redisId),
 	),
-	compose: environment.compose.filter((comp: any) =>
-		accessedServices.includes(comp.composeId),
-	),
 });

 export const environmentRouter = createTRPCRouter({
@@ -0,0 +1,437 @@
+import {
+	addNewService,
+	checkServiceAccess,
+	createLibsql,
+	createMount,
+	deployLibsql,
+	findEnvironmentById,
+	findLibsqlById,
+	findProjectById,
+	IS_CLOUD,
+	rebuildDatabase,
+	removeLibsqlById,
+	removeService,
+	startService,
+	startServiceRemote,
+	stopService,
+	stopServiceRemote,
+	updateLibsqlById,
+} from "@dokploy/server";
+import { TRPCError } from "@trpc/server";
+import { observable } from "@trpc/server/observable";
+import { eq } from "drizzle-orm";
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure } from "@/server/api/trpc";
+import { db } from "@/server/db";
+import {
+	apiChangeLibsqlStatus,
+	apiCreateLibsql,
+	apiDeployLibsql,
+	apiFindOneLibsql,
+	apiRebuildLibsql,
+	apiResetLibsql,
+	apiSaveEnvironmentVariablesLibsql,
+	apiSaveExternalPortsLibsql,
+	apiUpdateLibsql,
+	libsql as libsqlTable,
+} from "@/server/db/schema";
+export const libsqlRouter = createTRPCRouter({
+	create: protectedProcedure
+		.input(apiCreateLibsql)
+		.mutation(async ({ input, ctx }) => {
+			try {
+				// Get project from environment
+				const environment = await findEnvironmentById(input.environmentId);
+				const project = await findProjectById(environment.projectId);
+
+				if (ctx.user.role === "member") {
+					await checkServiceAccess(
+						ctx.user.id,
+						project.projectId,
+						ctx.session.activeOrganizationId,
+						"create",
+					);
+				}
+
+				if (IS_CLOUD && !input.serverId) {
+					throw new TRPCError({
+						code: "UNAUTHORIZED",
+						message: "You need to use a server to create a Libsql",
+					});
+				}
+
+				if (project.organizationId !== ctx.session.activeOrganizationId) {
+					throw new TRPCError({
+						code: "UNAUTHORIZED",
+						message: "You are not authorized to access this project",
+					});
+				}
+				const newLibsql = await createLibsql({
+					...input,
+				});
+				if (ctx.user.role === "member") {
+					await addNewService(
+						ctx.user.id,
+						newLibsql.libsqlId,
+						project.organizationId,
+					);
+				}
+
+				await createMount({
+					serviceId: newLibsql.libsqlId,
+					serviceType: "libsql",
+					volumeName: `${newLibsql.appName}-data`,
+					mountPath: "/var/lib/sqld",
+					type: "volume",
+				});
+
+				return true;
+			} catch (error) {
+				if (error instanceof TRPCError) {
+					throw error;
+				}
+				throw error;
+			}
+		}),
+	one: protectedProcedure
+		.input(apiFindOneLibsql)
+		.query(async ({ input, ctx }) => {
+			if (ctx.user.role === "member") {
+				await checkServiceAccess(
+					ctx.user.id,
+					input.libsqlId,
+					ctx.session.activeOrganizationId,
+					"access",
+				);
+			}
+			const libsql = await findLibsqlById(input.libsqlId);
+			if (
+				libsql.environment.project.organizationId !==
+				ctx.session.activeOrganizationId
+			) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to access this Libsql",
+				});
+			}
+			return libsql;
+		}),
+
+	start: protectedProcedure
+		.input(apiFindOneLibsql)
+		.mutation(async ({ input, ctx }) => {
+			const service = await findLibsqlById(input.libsqlId);
+			if (
+				service.environment.project.organizationId !==
+				ctx.session.activeOrganizationId
+			) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to start this Libsql",
+				});
+			}
+			if (service.serverId) {
+				await startServiceRemote(service.serverId, service.appName);
+			} else {
+				await startService(service.appName);
+			}
+			await updateLibsqlById(input.libsqlId, {
+				applicationStatus: "done",
+			});
+
+			return service;
+		}),
+	stop: protectedProcedure
+		.input(apiFindOneLibsql)
+		.mutation(async ({ input }) => {
+			const libsql = await findLibsqlById(input.libsqlId);
+
+			if (libsql.serverId) {
+				await stopServiceRemote(libsql.serverId, libsql.appName);
+			} else {
+				await stopService(libsql.appName);
+			}
+			await updateLibsqlById(input.libsqlId, {
+				applicationStatus: "idle",
+			});
+
+			return libsql;
+		}),
+	saveExternalPorts: protectedProcedure
+		.input(apiSaveExternalPortsLibsql)
+		.mutation(async ({ input, ctx }) => {
+			const libsql = await findLibsqlById(input.libsqlId);
+			if (
+				libsql.environment.project.organizationId !==
+				ctx.session.activeOrganizationId
+			) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to save this external port",
+				});
+			}
+			if (libsql.sqldNode === "replica" && input.externalGRPCPort !== null) {
+				throw new TRPCError({
+					code: "BAD_REQUEST",
+					message: "externalGRPCPort cannot be set when sqldNode is 'replica'",
+				});
+			}
+			await updateLibsqlById(input.libsqlId, {
+				externalPort: input.externalPort,
+				externalGRPCPort: input.externalGRPCPort,
+			});
+			await deployLibsql(input.libsqlId);
+			return libsql;
+		}),
+	deploy: protectedProcedure
+		.input(apiDeployLibsql)
+		.mutation(async ({ input, ctx }) => {
+			const libsql = await findLibsqlById(input.libsqlId);
+			if (
+				libsql.environment.project.organizationId !==
+				ctx.session.activeOrganizationId
+			) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to deploy this Libsql",
+				});
+			}
+
+			return deployLibsql(input.libsqlId);
+		}),
+	deployWithLogs: protectedProcedure
+		.meta({
+			openapi: {
+				path: "/deploy/libsql-with-logs",
+				method: "POST",
+				override: true,
+				enabled: false,
+			},
+		})
+		.input(apiDeployLibsql)
+		.subscription(async ({ input, ctx }) => {
+			const libsql = await findLibsqlById(input.libsqlId);
+			if (
+				libsql.environment.project.organizationId !==
+				ctx.session.activeOrganizationId
+			) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to deploy this Libsql",
+				});
+			}
+
+			return observable<string>((emit) => {
+				deployLibsql(input.libsqlId, (log) => {
+					emit.next(log);
+				});
+			});
+		}),
+	changeStatus: protectedProcedure
+		.input(apiChangeLibsqlStatus)
+		.mutation(async ({ input, ctx }) => {
+			const libsql = await findLibsqlById(input.libsqlId);
+			if (
+				libsql.environment.project.organizationId !==
+				ctx.session.activeOrganizationId
+			) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to change this Libsql status",
+				});
+			}
+			await updateLibsqlById(input.libsqlId, {
+				applicationStatus: input.applicationStatus,
+			});
+			return libsql;
+		}),
+	remove: protectedProcedure
+		.input(apiFindOneLibsql)
+		.mutation(async ({ input, ctx }) => {
+			if (ctx.user.role === "member") {
+				await checkServiceAccess(
+					ctx.user.id,
+					input.libsqlId,
+					ctx.session.activeOrganizationId,
+					"delete",
+				);
+			}
+
+			const libsql = await findLibsqlById(input.libsqlId);
+			if (
+				libsql.environment.project.organizationId !==
+				ctx.session.activeOrganizationId
+			) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to delete this Libsql",
+				});
+			}
+
+			const cleanupOperations = [
+				async () => await removeService(libsql?.appName, libsql.serverId),
+				async () => await removeLibsqlById(input.libsqlId),
+			];
+
+			for (const operation of cleanupOperations) {
+				try {
+					await operation();
+				} catch (_) {}
+			}
+
+			return libsql;
+		}),
+	saveEnvironment: protectedProcedure
+		.input(apiSaveEnvironmentVariablesLibsql)
+		.mutation(async ({ input, ctx }) => {
+			const libsql = await findLibsqlById(input.libsqlId);
+			if (
+				libsql.environment.project.organizationId !==
+				ctx.session.activeOrganizationId
+			) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to save this environment",
+				});
+			}
+			const service = await updateLibsqlById(input.libsqlId, {
+				env: input.env,
+			});
+
+			if (!service) {
+				throw new TRPCError({
+					code: "BAD_REQUEST",
+					message: "Error adding environment variables",
+				});
+			}
+
+			return true;
+		}),
+	reload: protectedProcedure
+		.input(apiResetLibsql)
+		.mutation(async ({ input, ctx }) => {
+			const libsql = await findLibsqlById(input.libsqlId);
+			if (
+				libsql.environment.project.organizationId !==
+				ctx.session.activeOrganizationId
+			) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to reload this Libsql",
+				});
+			}
+			if (libsql.serverId) {
+				await stopServiceRemote(libsql.serverId, libsql.appName);
+			} else {
+				await stopService(libsql.appName);
+			}
+			await updateLibsqlById(input.libsqlId, {
+				applicationStatus: "idle",
+			});
+
+			if (libsql.serverId) {
+				await startServiceRemote(libsql.serverId, libsql.appName);
+			} else {
+				await startService(libsql.appName);
+			}
+			await updateLibsqlById(input.libsqlId, {
+				applicationStatus: "done",
+			});
+			return true;
+		}),
+	update: protectedProcedure
+		.input(apiUpdateLibsql)
+		.mutation(async ({ input, ctx }) => {
+			const { libsqlId, ...rest } = input;
+			const libsql = await findLibsqlById(libsqlId);
+			if (
+				libsql.environment.project.organizationId !==
+				ctx.session.activeOrganizationId
+			) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to update this Libsql",
+				});
+			}
+			const service = await updateLibsqlById(libsqlId, {
+				...rest,
+			});
+
+			if (!service) {
+				throw new TRPCError({
+					code: "BAD_REQUEST",
+					message: "Update: Error updating Libsql",
+				});
+			}
+
+			return true;
+		}),
+	move: protectedProcedure
+		.input(
+			z.object({
+				libsqlId: z.string(),
+				targetEnvironmentId: z.string(),
+			}),
+		)
+		.mutation(async ({ input, ctx }) => {
+			const libsql = await findLibsqlById(input.libsqlId);
+			if (
+				libsql.environment.project.organizationId !==
+				ctx.session.activeOrganizationId
+			) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to move this libsql",
+				});
+			}
+
+			const targetEnvironment = await findEnvironmentById(
+				input.targetEnvironmentId,
+			);
+			if (
+				targetEnvironment.project.organizationId !==
+				ctx.session.activeOrganizationId
+			) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to move to this environment",
+				});
+			}
+
+			// Update the libsql's projectId
+			const updatedLibsql = await db
+				.update(libsqlTable)
+				.set({
+					environmentId: input.targetEnvironmentId,
+				})
+				.where(eq(libsqlTable.libsqlId, input.libsqlId))
+				.returning()
+				.then((res) => res[0]);
+
+			if (!updatedLibsql) {
+				throw new TRPCError({
+					code: "INTERNAL_SERVER_ERROR",
+					message: "Failed to move libsql",
+				});
+			}
+
+			return updatedLibsql;
+		}),
+	rebuild: protectedProcedure
+		.input(apiRebuildLibsql)
+		.mutation(async ({ input, ctx }) => {
+			const libsql = await findLibsqlById(input.libsqlId);
+			if (
+				libsql.environment.project.organizationId !==
+				ctx.session.activeOrganizationId
+			) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to rebuild this MariaDB database",
+				});
+			}
+
+			await rebuildDatabase(libsql.libsqlId, "libsql");
+			return true;
+		}),
+});
@@ -5,8 +5,8 @@ import {
 	createMount,
 	deployMariadb,
 	findBackupsByDbId,
-	findMariadbById,
 	findEnvironmentById,
+	findMariadbById,
 	findProjectById,
 	IS_CLOUD,
 	rebuildDatabase,
@@ -5,8 +5,8 @@ import {
 	createMount,
 	deployMongo,
 	findBackupsByDbId,
-	findMongoById,
 	findEnvironmentById,
+	findMongoById,
 	findProjectById,
 	IS_CLOUD,
 	rebuildDatabase,
@@ -5,6 +5,7 @@ import {
 	createBackup,
 	createCompose,
 	createDomain,
+	createLibsql,
 	createMariadb,
 	createMongo,
 	createMount,
@@ -20,6 +21,7 @@ import {
 	findApplicationById,
 	findComposeById,
 	findEnvironmentById,
+	findLibsqlById,
 	findMariadbById,
 	findMemberById,
 	findMongoById,
@@ -45,6 +47,7 @@ import {
 	applications,
 	compose,
 	environments,
+	libsql,
 	mariadb,
 	mongo,
 	mysql,
@@ -133,6 +136,9 @@ export const projectRouter = createTRPCRouter({
 										accessedServices,
 									),
 								},
+								libsql: {
+									where: buildServiceFilter(libsql.libsqlId, accessedServices),
+								},
 								mariadb: {
 									where: buildServiceFilter(
 										mariadb.mariadbId,
@@ -214,6 +220,13 @@ export const projectRouter = createTRPCRouter({
 								),
 								with: { domains: true },
 							},
+							compose: {
+								where: buildServiceFilter(compose.composeId, accessedServices),
+								with: { domains: true },
+							},
+							libsql: {
+								where: buildServiceFilter(libsql.libsqlId, accessedServices),
+							},
 							mariadb: {
 								where: buildServiceFilter(mariadb.mariadbId, accessedServices),
 							},
@@ -232,10 +245,6 @@ export const projectRouter = createTRPCRouter({
 							redis: {
 								where: buildServiceFilter(redis.redisId, accessedServices),
 							},
-							compose: {
-								where: buildServiceFilter(compose.composeId, accessedServices),
-								with: { domains: true },
-							},
 						},
 					},
 				},
@@ -252,16 +261,17 @@ export const projectRouter = createTRPCRouter({
 								domains: true,
 							},
 						},
-						mariadb: true,
-						mongo: true,
-						mysql: true,
-						postgres: true,
-						redis: true,
 						compose: {
 							with: {
 								domains: true,
 							},
 						},
+						libsql: true,
+						mariadb: true,
+						mongo: true,
+						mysql: true,
+						postgres: true,
+						redis: true,
 					},
 				},
 			},
@@ -332,12 +342,13 @@ export const projectRouter = createTRPCRouter({
 							id: z.string(),
 							type: z.enum([
 								"application",
-								"postgres",
+								"compose",
+								"libsql",
 								"mariadb",
 								"mongo",
 								"mysql",
+								"postgres",
 								"redis",
-								"compose",
 							]),
 						}),
 					)
@@ -471,21 +482,27 @@ export const projectRouter = createTRPCRouter({

 								break;
 							}
-							case "postgres": {
-								const { postgresId, mounts, backups, appName, ...postgres } =
-									await findPostgresById(id);
+							case "compose": {
+								const {
+									composeId,
+									mounts,
+									domains,
+									appName,
+									refreshToken,
+									...compose
+								} = await findComposeById(id);

 								const newAppName = appName.substring(
 									0,
 									appName.lastIndexOf("-"),
 								);

-								const newPostgres = await createPostgres({
-									...postgres,
+								const newCompose = await createCompose({
+									...compose,
 									appName: newAppName,
 									name: input.duplicateInSameProject
-										? `${postgres.name} (copy)`
-										: postgres.name,
+										? `${compose.name} (copy)`
+										: compose.name,
 									environmentId: targetProject?.environmentId || "",
 								});

@@ -493,18 +510,49 @@ export const projectRouter = createTRPCRouter({
 									const { mountId, ...rest } = mount;
 									await createMount({
 										...rest,
-										serviceId: newPostgres.postgresId,
-										serviceType: "postgres",
+										serviceId: newCompose.composeId,
+										serviceType: "compose",
 									});
 								}

-								for (const backup of backups) {
-									const { backupId, ...rest } = backup;
-									await createBackup({
+								for (const domain of domains) {
+									const { domainId, ...rest } = domain;
+									await createDomain({
 										...rest,
-										postgresId: newPostgres.postgresId,
+										composeId: newCompose.composeId,
+										domainType: "compose",
 									});
 								}
+
+								break;
+							}
+							case "libsql": {
+								const { libsqlId, mounts, appName, ...libsql } =
+									await findLibsqlById(id);
+
+								const newAppName = appName.substring(
+									0,
+									appName.lastIndexOf("-"),
+								);
+
+								const newLibsql = await createLibsql({
+									...libsql,
+									appName: newAppName,
+									name: input.duplicateInSameProject
+										? `${libsql.name} (copy)`
+										: libsql.name,
+									environmentId: targetProject?.environmentId || "",
+								});
+
+								for (const mount of mounts) {
+									const { mountId, ...rest } = mount;
+									await createMount({
+										...rest,
+										serviceId: newLibsql.libsqlId,
+										serviceType: "libsql",
+									});
+								}
+
 								break;
 							}
 							case "mariadb": {
@@ -615,6 +663,42 @@ export const projectRouter = createTRPCRouter({
 								}
 								break;
 							}
+							case "postgres": {
+								const { postgresId, mounts, backups, appName, ...postgres } =
+									await findPostgresById(id);
+
+								const newAppName = appName.substring(
+									0,
+									appName.lastIndexOf("-"),
+								);
+
+								const newPostgres = await createPostgres({
+									...postgres,
+									appName: newAppName,
+									name: input.duplicateInSameProject
+										? `${postgres.name} (copy)`
+										: postgres.name,
+									environmentId: targetProject?.environmentId || "",
+								});
+
+								for (const mount of mounts) {
+									const { mountId, ...rest } = mount;
+									await createMount({
+										...rest,
+										serviceId: newPostgres.postgresId,
+										serviceType: "postgres",
+									});
+								}
+
+								for (const backup of backups) {
+									const { backupId, ...rest } = backup;
+									await createBackup({
+										...rest,
+										postgresId: newPostgres.postgresId,
+									});
+								}
+								break;
+							}
 							case "redis": {
 								const { redisId, mounts, appName, ...redis } =
 									await findRedisById(id);
@@ -642,50 +726,6 @@ export const projectRouter = createTRPCRouter({
 									});
 								}

-								break;
-							}
-							case "compose": {
-								const {
-									composeId,
-									mounts,
-									domains,
-									appName,
-									refreshToken,
-									...compose
-								} = await findComposeById(id);
-
-								const newAppName = appName.substring(
-									0,
-									appName.lastIndexOf("-"),
-								);
-
-								const newCompose = await createCompose({
-									...compose,
-									appName: newAppName,
-									name: input.duplicateInSameProject
-										? `${compose.name} (copy)`
-										: compose.name,
-									environmentId: targetProject?.environmentId || "",
-								});
-
-								for (const mount of mounts) {
-									const { mountId, ...rest } = mount;
-									await createMount({
-										...rest,
-										serviceId: newCompose.composeId,
-										serviceType: "compose",
-									});
-								}
-
-								for (const domain of domains) {
-									const { domainId, ...rest } = domain;
-									await createDomain({
-										...rest,
-										composeId: newCompose.composeId,
-										domainType: "compose",
-									});
-								}
-
 								break;
 							}
 						}
@@ -20,7 +20,6 @@ import { gitlab } from "./gitlab";
 import { mounts } from "./mount";
 import { ports } from "./port";
 import { previewDeployments } from "./preview-deployments";
-import { projects } from "./project";
 import { redirects } from "./redirects";
 import { registry } from "./registry";
 import { security } from "./security";
@@ -12,7 +12,6 @@ import { gitea } from "./gitea";
 import { github } from "./github";
 import { gitlab } from "./gitlab";
 import { mounts } from "./mount";
-import { projects } from "./project";
 import { schedules } from "./schedule";
 import { server } from "./server";
 import { applicationStatus, triggerType } from "./shared";
@@ -5,6 +5,7 @@ import { nanoid } from "nanoid";
 import { z } from "zod";
 import { applications } from "./application";
 import { compose } from "./compose";
+import { libsql } from "./libsql";
 import { mariadb } from "./mariadb";
 import { mongo } from "./mongo";
 import { mysql } from "./mysql";
@@ -36,12 +37,13 @@ export const environmentRelations = relations(
 			references: [projects.projectId],
 		}),
 		applications: many(applications),
-		mariadb: many(mariadb),
-		postgres: many(postgres),
-		mysql: many(mysql),
-		redis: many(redis),
-		mongo: many(mongo),
 		compose: many(compose),
+		libsql: many(libsql),
+		mariadb: many(mariadb),
+		mongo: many(mongo),
+		mysql: many(mysql),
+		postgres: many(postgres),
+		redis: many(redis),
 	}),
 );

@@ -13,6 +13,7 @@ export * from "./git-provider";
 export * from "./gitea";
 export * from "./github";
 export * from "./gitlab";
+export * from "./libsql";
 export * from "./mariadb";
 export * from "./mongo";
 export * from "./mount";
@@ -0,0 +1,222 @@
+import { relations } from "drizzle-orm";
+import { integer, json, pgTable, text } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+import { environments } from "./environment";
+import { mounts } from "./mount";
+import { server } from "./server";
+import {
+	applicationStatus,
+	type HealthCheckSwarm,
+	HealthCheckSwarmSchema,
+	type LabelsSwarm,
+	LabelsSwarmSchema,
+	type NetworkSwarm,
+	NetworkSwarmSchema,
+	type PlacementSwarm,
+	PlacementSwarmSchema,
+	type RestartPolicySwarm,
+	RestartPolicySwarmSchema,
+	type ServiceModeSwarm,
+	ServiceModeSwarmSchema,
+	sqldNode,
+	type UpdateConfigSwarm,
+	UpdateConfigSwarmSchema,
+} from "./shared";
+import { generateAppName } from "./utils";
+
+export const libsql = pgTable("libsql", {
+	libsqlId: text("libsqlId")
+		.notNull()
+		.primaryKey()
+		.$defaultFn(() => nanoid()),
+	name: text("name").notNull(),
+	appName: text("appName")
+		.notNull()
+		.$defaultFn(() => generateAppName("libsql"))
+		.unique(),
+	description: text("description"),
+	databaseUser: text("databaseUser").notNull(),
+	databasePassword: text("databasePassword").notNull(),
+	sqldNode: sqldNode("sqldNode").notNull().default("primary"),
+	sqldPrimaryUrl: text("sqldPrimaryUrl"),
+	dockerImage: text("dockerImage").notNull(),
+	command: text("command"),
+	env: text("env"),
+	// RESOURCES
+	memoryReservation: text("memoryReservation"),
+	memoryLimit: text("memoryLimit"),
+	cpuReservation: text("cpuReservation"),
+	cpuLimit: text("cpuLimit"),
+	//
+	externalPort: integer("externalPort"),
+	externalGRPCPort: integer("externalGRPCPort"),
+	applicationStatus: applicationStatus("applicationStatus")
+		.notNull()
+		.default("idle"),
+	healthCheckSwarm: json("healthCheckSwarm").$type<HealthCheckSwarm>(),
+	restartPolicySwarm: json("restartPolicySwarm").$type<RestartPolicySwarm>(),
+	placementSwarm: json("placementSwarm").$type<PlacementSwarm>(),
+	updateConfigSwarm: json("updateConfigSwarm").$type<UpdateConfigSwarm>(),
+	rollbackConfigSwarm: json("rollbackConfigSwarm").$type<UpdateConfigSwarm>(),
+	modeSwarm: json("modeSwarm").$type<ServiceModeSwarm>(),
+	labelsSwarm: json("labelsSwarm").$type<LabelsSwarm>(),
+	networkSwarm: json("networkSwarm").$type<NetworkSwarm[]>(),
+	replicas: integer("replicas").default(1).notNull(),
+	createdAt: text("createdAt")
+		.notNull()
+		.$defaultFn(() => new Date().toISOString()),
+
+	environmentId: text("environmentId")
+		.notNull()
+		.references(() => environments.environmentId, { onDelete: "cascade" }),
+	serverId: text("serverId").references(() => server.serverId, {
+		onDelete: "cascade",
+	}),
+});
+
+export const libsqlRelations = relations(libsql, ({ one, many }) => ({
+	environment: one(environments, {
+		fields: [libsql.environmentId],
+		references: [environments.environmentId],
+	}),
+	//backups: many(backups),
+	mounts: many(mounts),
+	server: one(server, {
+		fields: [libsql.serverId],
+		references: [server.serverId],
+	}),
+}));
+
+const createSchema = createInsertSchema(libsql, {
+	libsqlId: z.string(),
+	name: z.string().min(1),
+	appName: z.string().min(1),
+	createdAt: z.string(),
+	databaseUser: z.string().min(1),
+	databasePassword: z
+		.string()
+		.regex(/^[a-zA-Z0-9@#%^&*()_+\-=[\]{}|;:,.<>?~`]*$/, {
+			message:
+				"Password contains invalid characters. Please avoid: $ ! ' \" \\ / and space characters for database compatibility",
+		}),
+	sqldNode: z.enum(sqldNode.enumValues),
+	sqldPrimaryUrl: z.string().optional(),
+	dockerImage: z.string().default("ghcr.io/tursodatabase/libsql-server:latest"),
+	command: z.string().optional(),
+	env: z.string().optional(),
+	memoryReservation: z.string().optional(),
+	memoryLimit: z.string().optional(),
+	cpuReservation: z.string().optional(),
+	cpuLimit: z.string().optional(),
+	environmentId: z.string(),
+	applicationStatus: z.enum(["idle", "running", "done", "error"]),
+	externalPort: z.number(),
+	externalGRPCPort: z.number(),
+	description: z.string().optional(),
+	serverId: z.string().optional(),
+	healthCheckSwarm: HealthCheckSwarmSchema.nullable(),
+	restartPolicySwarm: RestartPolicySwarmSchema.nullable(),
+	placementSwarm: PlacementSwarmSchema.nullable(),
+	updateConfigSwarm: UpdateConfigSwarmSchema.nullable(),
+	rollbackConfigSwarm: UpdateConfigSwarmSchema.nullable(),
+	modeSwarm: ServiceModeSwarmSchema.nullable(),
+	labelsSwarm: LabelsSwarmSchema.nullable(),
+	networkSwarm: NetworkSwarmSchema.nullable(),
+});
+
+export const apiCreateLibsql = createSchema
+	.pick({
+		name: true,
+		appName: true,
+		dockerImage: true,
+		environmentId: true,
+		description: true,
+		databaseUser: true,
+		databasePassword: true,
+		sqldNode: true,
+		sqldPrimaryUrl: true,
+		serverId: true,
+	})
+	.required()
+	.superRefine((data, ctx) => {
+		if (data.sqldNode === "replica" && !data.sqldPrimaryUrl) {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				path: ["sqldPrimaryUrl"],
+				message: "sqldPrimaryUrl is required when sqldNode is 'replica'.",
+			});
+		}
+		if (data.sqldNode !== "replica" && data.sqldPrimaryUrl) {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				path: ["sqldPrimaryUrl"],
+				message:
+					"sqldPrimaryUrl should not be provided when sqldNode is not 'replica'.",
+			});
+		}
+	});
+
+export const apiFindOneLibsql = createSchema
+	.pick({
+		libsqlId: true,
+	})
+	.required();
+
+export const apiChangeLibsqlStatus = createSchema
+	.pick({
+		libsqlId: true,
+		applicationStatus: true,
+	})
+	.required();
+
+export const apiSaveEnvironmentVariablesLibsql = createSchema
+	.pick({
+		libsqlId: true,
+		env: true,
+	})
+	.required();
+
+export const apiSaveExternalPortsLibsql = createSchema
+	.pick({
+		libsqlId: true,
+		externalPort: true,
+		externalGRPCPort: true,
+	})
+	.required({ libsqlId: true })
+	.superRefine((data, ctx) => {
+		if (data.externalPort === null && data.externalGRPCPort === null) {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				message: "Either externalPort or externalGRPCPort must be provided.",
+				path: ["externalPort", "externalGRPCPort"],
+			});
+		}
+	});
+
+export const apiDeployLibsql = createSchema
+	.pick({
+		libsqlId: true,
+	})
+	.required();
+
+export const apiResetLibsql = createSchema
+	.pick({
+		libsqlId: true,
+		appName: true,
+	})
+	.required();
+
+export const apiUpdateLibsql = createSchema
+	.partial()
+	.extend({
+		libsqlId: z.string().min(1),
+	})
+	.omit({ serverId: true });
+
+export const apiRebuildLibsql = createSchema
+	.pick({
+		libsqlId: true,
+	})
+	.required();
@@ -5,6 +5,7 @@ import { nanoid } from "nanoid";
 import { z } from "zod";
 import { applications } from "./application";
 import { compose } from "./compose";
+import { libsql } from "./libsql";
 import { mariadb } from "./mariadb";
 import { mongo } from "./mongo";
 import { mysql } from "./mysql";
@@ -13,12 +14,13 @@ import { redis } from "./redis";

 export const serviceType = pgEnum("serviceType", [
 	"application",
-	"postgres",
-	"mysql",
+	"compose",
+	"libsql",
 	"mariadb",
 	"mongo",
+	"mysql",
+	"postgres",
 	"redis",
-	"compose",
 ]);

 export const mountType = pgEnum("mountType", ["bind", "volume", "file"]);
@@ -39,7 +41,10 @@ export const mounts = pgTable("mount", {
 		() => applications.applicationId,
 		{ onDelete: "cascade" },
 	),
-	postgresId: text("postgresId").references(() => postgres.postgresId, {
+	composeId: text("composeId").references(() => compose.composeId, {
+		onDelete: "cascade",
+	}),
+	libsqlId: text("libsqlId").references(() => libsql.libsqlId, {
 		onDelete: "cascade",
 	}),
 	mariadbId: text("mariadbId").references(() => mariadb.mariadbId, {
@@ -51,10 +56,10 @@ export const mounts = pgTable("mount", {
 	mysqlId: text("mysqlId").references(() => mysql.mysqlId, {
 		onDelete: "cascade",
 	}),
-	redisId: text("redisId").references(() => redis.redisId, {
+	postgresId: text("postgresId").references(() => postgres.postgresId, {
 		onDelete: "cascade",
 	}),
-	composeId: text("composeId").references(() => compose.composeId, {
+	redisId: text("redisId").references(() => redis.redisId, {
 		onDelete: "cascade",
 	}),
 });
@@ -64,9 +69,13 @@ export const MountssRelations = relations(mounts, ({ one }) => ({
 		fields: [mounts.applicationId],
 		references: [applications.applicationId],
 	}),
-	postgres: one(postgres, {
-		fields: [mounts.postgresId],
-		references: [postgres.postgresId],
+	compose: one(compose, {
+		fields: [mounts.composeId],
+		references: [compose.composeId],
+	}),
+	libsql: one(libsql, {
+		fields: [mounts.libsqlId],
+		references: [libsql.libsqlId],
 	}),
 	mariadb: one(mariadb, {
 		fields: [mounts.mariadbId],
@@ -80,14 +89,14 @@ export const MountssRelations = relations(mounts, ({ one }) => ({
 		fields: [mounts.mysqlId],
 		references: [mysql.mysqlId],
 	}),
+	postgres: one(postgres, {
+		fields: [mounts.postgresId],
+		references: [postgres.postgresId],
+	}),
 	redis: one(redis, {
 		fields: [mounts.redisId],
 		references: [redis.redisId],
 	}),
-	compose: one(compose, {
-		fields: [mounts.composeId],
-		references: [compose.composeId],
-	}),
 }));

 const createSchema = createInsertSchema(mounts, {
@@ -102,12 +111,13 @@ const createSchema = createInsertSchema(mounts, {
 	serviceType: z
 		.enum([
 			"application",
-			"postgres",
-			"mysql",
+			"compose",
+			"libsql",
 			"mariadb",
 			"mongo",
+			"mysql",
+			"postgres",
 			"redis",
-			"compose",
 		])
 		.default("application"),
 });
@@ -5,7 +5,6 @@ import { nanoid } from "nanoid";
 import { z } from "zod";
 import { environments } from "./environment";
 import { mounts } from "./mount";
-import { projects } from "./project";
 import { server } from "./server";
 import {
 	applicationStatus,
@@ -15,6 +15,7 @@ import { applications } from "./application";
 import { certificates } from "./certificate";
 import { compose } from "./compose";
 import { deployments } from "./deployment";
+import { libsql } from "./libsql";
 import { mariadb } from "./mariadb";
 import { mongo } from "./mongo";
 import { mysql } from "./mysql";
@@ -97,24 +98,25 @@ export const server = pgTable("server", {
 });

 export const serverRelations = relations(server, ({ one, many }) => ({
-	deployments: many(deployments),
-	sshKey: one(sshKeys, {
-		fields: [server.sshKeyId],
-		references: [sshKeys.sshKeyId],
-	}),
 	applications: many(applications),
+	certificates: many(certificates),
 	compose: many(compose),
-	redis: many(redis),
+	deployments: many(deployments),
+	libsql: many(libsql),
 	mariadb: many(mariadb),
 	mongo: many(mongo),
 	mysql: many(mysql),
-	postgres: many(postgres),
-	certificates: many(certificates),
 	organization: one(organization, {
 		fields: [server.organizationId],
 		references: [organization.id],
 	}),
+	postgres: many(postgres),
+	redis: many(redis),
 	schedules: many(schedules),
+	sshKey: one(sshKeys, {
+		fields: [server.sshKeyId],
+		references: [sshKeys.sshKeyId],
+	}),
 }));

 const createSchema = createInsertSchema(server, {
@@ -16,6 +16,8 @@ export const certificateType = pgEnum("certificateType", [

 export const triggerType = pgEnum("triggerType", ["push", "tag"]);

+export const sqldNode = pgEnum("sqldNode", ["primary", "replica"]);
+
 export interface HealthCheckSwarm {
 	Test?: string[] | undefined;
 	Interval?: number | undefined;
@@ -7,6 +7,7 @@ import { applications } from "./application";
 import { compose } from "./compose";
 import { deployments } from "./deployment";
 import { destinations } from "./destination";
+import { libsql } from "./libsql";
 import { mariadb } from "./mariadb";
 import { mongo } from "./mongo";
 import { serviceType } from "./mount";
@@ -53,6 +54,9 @@ export const volumeBackups = pgTable("volume_backup", {
 	redisId: text("redisId").references(() => redis.redisId, {
 		onDelete: "cascade",
 	}),
+	libsqlId: text("libsqlId").references(() => libsql.libsqlId, {
+		onDelete: "cascade",
+	}),
 	composeId: text("composeId").references(() => compose.composeId, {
 		onDelete: "cascade",
 	}),
@@ -93,6 +97,10 @@ export const volumeBackupsRelations = relations(
 			fields: [volumeBackups.redisId],
 			references: [redis.redisId],
 		}),
+		libsql: one(libsql, {
+			fields: [volumeBackups.libsqlId],
+			references: [libsql.libsqlId],
+		}),
 		compose: one(compose, {
 			fields: [volumeBackups.composeId],
 			references: [compose.composeId],
@@ -21,6 +21,7 @@ export * from "./services/git-provider";
 export * from "./services/gitea";
 export * from "./services/github";
 export * from "./services/gitlab";
+export * from "./services/libsql";
 export * from "./services/mariadb";
 export * from "./services/mongo";
 export * from "./services/mount";
@@ -76,7 +77,6 @@ export * from "./utils/builders/nixpacks";
 export * from "./utils/builders/paketo";
 export * from "./utils/builders/static";
 export * from "./utils/builders/utils";
-
 export * from "./utils/cluster/upload";
 export * from "./utils/databases/rebuild";
 export * from "./utils/docker/collision";
@@ -35,13 +35,14 @@ export const findEnvironmentById = async (environmentId: string) => {
 		where: eq(environments.environmentId, environmentId),
 		with: {
 			applications: true,
+			compose: true,
+			libsql: true,
 			mariadb: true,
 			mongo: true,
 			mysql: true,
 			postgres: true,
-			redis: true,
-			compose: true,
 			project: true,
+			redis: true,
 		},
 	});
 	if (!environment) {
@@ -59,13 +60,14 @@ export const findEnvironmentsByProjectId = async (projectId: string) => {
 		orderBy: asc(environments.createdAt),
 		with: {
 			applications: true,
+			compose: true,
+			libsql: true,
 			mariadb: true,
 			mongo: true,
 			mysql: true,
 			postgres: true,
-			redis: true,
-			compose: true,
 			project: true,
+			redis: true,
 		},
 	});
 	return projectEnvironments;
@@ -0,0 +1,160 @@
+import { db } from "@dokploy/server/db";
+import {
+	type apiCreateLibsql,
+	buildAppName,
+	libsql,
+} from "@dokploy/server/db/schema";
+import { generatePassword } from "@dokploy/server/templates";
+import { buildLibsql } from "@dokploy/server/utils/databases/libsql";
+import { pullImage } from "@dokploy/server/utils/docker/utils";
+import { execAsyncRemote } from "@dokploy/server/utils/process/execAsync";
+import { TRPCError } from "@trpc/server";
+import { eq } from "drizzle-orm";
+import { validUniqueServerAppName } from "./project";
+
+export type Libsql = typeof libsql.$inferSelect;
+
+export const createLibsql = async (input: typeof apiCreateLibsql._type) => {
+	const appName = buildAppName("libsql", input.appName);
+
+	const valid = await validUniqueServerAppName(input.appName);
+	if (!valid) {
+		throw new TRPCError({
+			code: "CONFLICT",
+			message: "Service with this 'AppName' already exists",
+		});
+	}
+
+	const newLibsql = await db
+		.insert(libsql)
+		.values({
+			...input,
+			databasePassword: input.databasePassword
+				? input.databasePassword
+				: generatePassword(),
+			appName,
+		})
+		.returning()
+		.then((value) => value[0]);
+
+	if (!newLibsql) {
+		throw new TRPCError({
+			code: "BAD_REQUEST",
+			message: "Error input: Inserting libsql database",
+		});
+	}
+
+	return newLibsql;
+};
+
+// https://github.com/drizzle-team/drizzle-orm/discussions/1483#discussioncomment-7523881
+export const findLibsqlById = async (libsqlId: string) => {
+	const result = await db.query.libsql.findFirst({
+		where: eq(libsql.libsqlId, libsqlId),
+		with: {
+			environment: {
+				with: {
+					project: true,
+				},
+			},
+			mounts: true,
+			server: true,
+			// backups: {
+			// 	with: {
+			// 		destination: true,
+			// 		deployments: true,
+			// 	},
+			// },
+		},
+	});
+	if (!result) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Libsql not found",
+		});
+	}
+	return result;
+};
+
+export const updateLibsqlById = async (
+	libsqlId: string,
+	libsqlData: Partial<Libsql>,
+) => {
+	const { appName, ...rest } = libsqlData;
+	const result = await db
+		.update(libsql)
+		.set({
+			...rest,
+		})
+		.where(eq(libsql.libsqlId, libsqlId))
+		.returning();
+
+	return result[0];
+};
+
+export const removeLibsqlById = async (libsqlId: string) => {
+	const result = await db
+		.delete(libsql)
+		.where(eq(libsql.libsqlId, libsqlId))
+		.returning();
+
+	return result[0];
+};
+
+// export const findLibsqlByBackupId = async (backupId: string) => {
+// 	const result = await db
+// 		.select({
+// 			...getTableColumns(libsql),
+// 		})
+// 		.from(libsql)
+// 		.innerJoin(backups, eq(libsql.libsqlId, backups.libsqlId))
+// 		.where(eq(backups.backupId, backupId))
+// 		.limit(1);
+//
+// 	if (!result || !result[0]) {
+// 		throw new TRPCError({
+// 			code: "NOT_FOUND",
+// 			message: "Libsql not found",
+// 		});
+// 	}
+// 	return result[0];
+// };
+
+export const deployLibsql = async (
+	libsqlId: string,
+	onData?: (data: any) => void,
+) => {
+	const libsql = await findLibsqlById(libsqlId);
+	try {
+		await updateLibsqlById(libsqlId, {
+			applicationStatus: "running",
+		});
+		onData?.("Starting libsql deployment...");
+		if (libsql.serverId) {
+			await execAsyncRemote(
+				libsql.serverId,
+				`docker pull ${libsql.dockerImage}`,
+				onData,
+			);
+		} else {
+			await pullImage(libsql.dockerImage, onData);
+		}
+
+		await buildLibsql(libsql);
+		await updateLibsqlById(libsqlId, {
+			applicationStatus: "done",
+		});
+		onData?.("Deployment completed successfully!");
+	} catch (error) {
+		onData?.(`Error: ${error}`);
+		await updateLibsqlById(libsqlId, {
+			applicationStatus: "error",
+		});
+
+		throw new TRPCError({
+			code: "INTERNAL_SERVER_ERROR",
+			message: `Error on deploy libsql${error}`,
+		});
+	}
+	return libsql;
+};
@@ -31,8 +31,11 @@ export const createMount = async (input: typeof apiCreateMount._type) => {
 				...(input.serviceType === "application" && {
 					applicationId: serviceId,
 				}),
-				...(input.serviceType === "postgres" && {
-					postgresId: serviceId,
+				...(input.serviceType === "compose" && {
+					composeId: serviceId,
+				}),
+				...(input.serviceType === "libsql" && {
+					libsqlId: serviceId,
 				}),
 				...(input.serviceType === "mariadb" && {
 					mariadbId: serviceId,
@@ -43,12 +46,12 @@ export const createMount = async (input: typeof apiCreateMount._type) => {
 				...(input.serviceType === "mysql" && {
 					mysqlId: serviceId,
 				}),
+				...(input.serviceType === "postgres" && {
+					postgresId: serviceId,
+				}),
 				...(input.serviceType === "redis" && {
 					redisId: serviceId,
 				}),
-				...(input.serviceType === "compose" && {
-					composeId: serviceId,
-				}),
 			})
 			.returning()
 			.then((value) => value[0]);
@@ -114,7 +117,16 @@ export const findMountById = async (mountId: string) => {
 					},
 				},
 			},
-			postgres: {
+			compose: {
+				with: {
+					environment: {
+						with: {
+							project: true,
+						},
+					},
+				},
+			},
+			libsql: {
 				with: {
 					environment: {
 						with: {
@@ -150,7 +162,7 @@ export const findMountById = async (mountId: string) => {
 					},
 				},
 			},
-			redis: {
+			postgres: {
 				with: {
 					environment: {
 						with: {
@@ -159,7 +171,7 @@ export const findMountById = async (mountId: string) => {
 					},
 				},
 			},
-			compose: {
+			redis: {
 				with: {
 					environment: {
 						with: {
@@ -185,8 +197,11 @@ export const findMountOrganizationId = async (mountId: string) => {
 	if (mount.application) {
 		return mount.application.environment.project.organizationId;
 	}
-	if (mount.postgres) {
-		return mount.postgres.environment.project.organizationId;
+	if (mount.compose) {
+		return mount.compose.environment.project.organizationId;
+	}
+	if (mount.libsql) {
+		return mount.libsql.environment.project.organizationId;
 	}
 	if (mount.mariadb) {
 		return mount.mariadb.environment.project.organizationId;
@@ -197,13 +212,13 @@ export const findMountOrganizationId = async (mountId: string) => {
 	if (mount.mysql) {
 		return mount.mysql.environment.project.organizationId;
 	}
+	if (mount.postgres) {
+		return mount.postgres.environment.project.organizationId;
+	}
 	if (mount.redis) {
 		return mount.redis.environment.project.organizationId;
 	}

-	if (mount.compose) {
-		return mount.compose.environment.project.organizationId;
-	}
 	return null;
 };

@@ -247,8 +262,8 @@ export const findMountsByApplicationId = async (
 		case "application":
 			sqlChunks.push(eq(mounts.applicationId, serviceId));
 			break;
-		case "postgres":
-			sqlChunks.push(eq(mounts.postgresId, serviceId));
+		case "libsql":
+			sqlChunks.push(eq(mounts.libsqlId, serviceId));
 			break;
 		case "mariadb":
 			sqlChunks.push(eq(mounts.mariadbId, serviceId));
@@ -259,6 +274,9 @@ export const findMountsByApplicationId = async (
 		case "mysql":
 			sqlChunks.push(eq(mounts.mysqlId, serviceId));
 			break;
+		case "postgres":
+			sqlChunks.push(eq(mounts.postgresId, serviceId));
+			break;
 		case "redis":
 			sqlChunks.push(eq(mounts.redisId, serviceId));
 			break;
@@ -334,10 +352,14 @@ export const getBaseFilesPath = async (mountId: string) => {
 		const { APPLICATIONS_PATH } = paths(!!mount.application.serverId);
 		absoluteBasePath = path.resolve(APPLICATIONS_PATH);
 		appName = mount.application.appName;
-	} else if (mount.serviceType === "postgres" && mount.postgres) {
-		const { APPLICATIONS_PATH } = paths(!!mount.postgres.serverId);
+	} else if (mount.serviceType === "compose" && mount.compose) {
+		const { COMPOSE_PATH } = paths(!!mount.compose.serverId);
+		appName = mount.compose.appName;
+		absoluteBasePath = path.resolve(COMPOSE_PATH);
+	} else if (mount.serviceType === "libsql" && mount.libsql) {
+		const { APPLICATIONS_PATH } = paths(!!mount.libsql.serverId);
 		absoluteBasePath = path.resolve(APPLICATIONS_PATH);
-		appName = mount.postgres.appName;
+		appName = mount.libsql.appName;
 	} else if (mount.serviceType === "mariadb" && mount.mariadb) {
 		const { APPLICATIONS_PATH } = paths(!!mount.mariadb.serverId);
 		absoluteBasePath = path.resolve(APPLICATIONS_PATH);
@@ -350,14 +372,14 @@ export const getBaseFilesPath = async (mountId: string) => {
 		const { APPLICATIONS_PATH } = paths(!!mount.mysql.serverId);
 		absoluteBasePath = path.resolve(APPLICATIONS_PATH);
 		appName = mount.mysql.appName;
+	} else if (mount.serviceType === "postgres" && mount.postgres) {
+		const { APPLICATIONS_PATH } = paths(!!mount.postgres.serverId);
+		absoluteBasePath = path.resolve(APPLICATIONS_PATH);
+		appName = mount.postgres.appName;
 	} else if (mount.serviceType === "redis" && mount.redis) {
 		const { APPLICATIONS_PATH } = paths(!!mount.redis.serverId);
 		absoluteBasePath = path.resolve(APPLICATIONS_PATH);
 		appName = mount.redis.appName;
-	} else if (mount.serviceType === "compose" && mount.compose) {
-		const { COMPOSE_PATH } = paths(!!mount.compose.serverId);
-		appName = mount.compose.appName;
-		absoluteBasePath = path.resolve(COMPOSE_PATH);
 	}
 	directoryPath = path.join(absoluteBasePath, appName, "files");

@@ -369,8 +391,11 @@ export const getServerId = async (mount: MountNested) => {
 	if (mount.serviceType === "application" && mount?.application?.serverId) {
 		return mount.application.serverId;
 	}
-	if (mount.serviceType === "postgres" && mount?.postgres?.serverId) {
-		return mount.postgres.serverId;
+	if (mount.serviceType === "compose" && mount?.compose?.serverId) {
+		return mount.compose.serverId;
+	}
+	if (mount.serviceType === "libsql" && mount?.libsql?.serverId) {
+		return mount.libsql.serverId;
 	}
 	if (mount.serviceType === "mariadb" && mount?.mariadb?.serverId) {
 		return mount.mariadb.serverId;
@@ -381,12 +406,12 @@ export const getServerId = async (mount: MountNested) => {
 	if (mount.serviceType === "mysql" && mount?.mysql?.serverId) {
 		return mount.mysql.serverId;
 	}
+	if (mount.serviceType === "postgres" && mount?.postgres?.serverId) {
+		return mount.postgres.serverId;
+	}
 	if (mount.serviceType === "redis" && mount?.redis?.serverId) {
 		return mount.redis.serverId;
 	}
-	if (mount.serviceType === "compose" && mount?.compose?.serverId) {
-		return mount.compose.serverId;
-	}

 	return null;
 };
@@ -2,6 +2,7 @@ import { db } from "@dokploy/server/db";
 import {
 	type apiCreateProject,
 	applications,
+	libsql,
 	mariadb,
 	mongo,
 	mysql,
@@ -52,12 +53,13 @@ export const findProjectById = async (projectId: string) => {
 			environments: {
 				with: {
 					applications: true,
+					compose: true,
+					libsql: true,
 					mariadb: true,
 					mongo: true,
 					mysql: true,
 					postgres: true,
 					redis: true,
-					compose: true,
 				},
 			},
 		},
@@ -103,6 +105,9 @@ export const validUniqueServerAppName = async (appName: string) => {
 			applications: {
 				where: eq(applications.appName, appName),
 			},
+			libsql: {
+				where: eq(libsql.appName, appName),
+			},
 			mariadb: {
 				where: eq(mariadb.appName, appName),
 			},
@@ -125,6 +130,7 @@ export const validUniqueServerAppName = async (appName: string) => {
 	const nonEmptyProjects = query.filter(
 		(project) =>
 			project.applications.length > 0 ||
+			project.libsql.length > 0 ||
 			project.mariadb.length > 0 ||
 			project.mongo.length > 0 ||
 			project.mysql.length > 0 ||
@@ -79,11 +79,12 @@ export const haveActiveServices = async (serverId: string) => {
 		with: {
 			applications: true,
 			compose: true,
-			redis: true,
+			libsql: true,
 			mariadb: true,
 			mongo: true,
 			mysql: true,
 			postgres: true,
+			redis: true,
 		},
 	});

@@ -94,11 +95,12 @@ export const haveActiveServices = async (serverId: string) => {
 	const total =
 		currentServer?.applications?.length +
 		currentServer?.compose?.length +
-		currentServer?.redis?.length +
+		currentServer?.libsql?.length +
 		currentServer?.mariadb?.length +
 		currentServer?.mongo?.length +
 		currentServer?.mysql?.length +
-		currentServer?.postgres?.length;
+		currentServer?.postgres?.length +
+		currentServer?.redis?.length;

 	if (total === 0) {
 		return false;
@@ -13,13 +13,14 @@ export const findVolumeBackupById = async (volumeBackupId: string) => {
 		where: eq(volumeBackups.volumeBackupId, volumeBackupId),
 		with: {
 			application: true,
-			postgres: true,
-			mysql: true,
-			mariadb: true,
-			mongo: true,
-			redis: true,
 			compose: true,
 			destination: true,
+			libsql: true,
+			mariadb: true,
+			mongo: true,
+			mysql: true,
+			postgres: true,
+			redis: true,
 		},
 	});

@@ -3,8 +3,8 @@ import {
 	createDeploymentBackup,
 	updateDeploymentStatus,
 } from "@dokploy/server/services/deployment";
-import type { Mariadb } from "@dokploy/server/services/mariadb";
 import { findEnvironmentById } from "@dokploy/server/services/environment";
+import type { Mariadb } from "@dokploy/server/services/mariadb";
 import { findProjectById } from "@dokploy/server/services/project";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
@@ -3,8 +3,8 @@ import {
 	createDeploymentBackup,
 	updateDeploymentStatus,
 } from "@dokploy/server/services/deployment";
-import type { Mongo } from "@dokploy/server/services/mongo";
 import { findEnvironmentById } from "@dokploy/server/services/environment";
+import type { Mongo } from "@dokploy/server/services/mongo";
 import { findProjectById } from "@dokploy/server/services/project";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
@@ -3,8 +3,8 @@ import {
 	createDeploymentBackup,
 	updateDeploymentStatus,
 } from "@dokploy/server/services/deployment";
-import type { MySql } from "@dokploy/server/services/mysql";
 import { findEnvironmentById } from "@dokploy/server/services/environment";
+import type { MySql } from "@dokploy/server/services/mysql";
 import { findProjectById } from "@dokploy/server/services/project";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
@@ -3,8 +3,8 @@ import {
 	createDeploymentBackup,
 	updateDeploymentStatus,
 } from "@dokploy/server/services/deployment";
-import type { Postgres } from "@dokploy/server/services/postgres";
 import { findEnvironmentById } from "@dokploy/server/services/environment";
+import type { Postgres } from "@dokploy/server/services/postgres";
 import { findProjectById } from "@dokploy/server/services/project";
 import { sendDatabaseBackupNotifications } from "../notifications/database-backup";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
@@ -0,0 +1,138 @@
+import type { InferResultType } from "@dokploy/server/types/with";
+import type { CreateServiceOptions, PortConfig } from "dockerode";
+import {
+	calculateResources,
+	generateBindMounts,
+	generateConfigContainer,
+	generateFileMounts,
+	generateVolumeMounts,
+	prepareEnvironmentVariables,
+} from "../docker/utils";
+import { getRemoteDocker } from "../servers/remote-docker";
+
+export type LibsqlNested = InferResultType<
+	"libsql",
+	{ mounts: true; environment: { with: { project: true } } }
+>;
+export const buildLibsql = async (libsql: LibsqlNested) => {
+	const {
+		appName,
+		env,
+		externalPort,
+		externalGRPCPort,
+		dockerImage,
+		memoryLimit,
+		memoryReservation,
+		databaseUser,
+		databasePassword,
+		sqldNode,
+		sqldPrimaryUrl,
+		cpuLimit,
+		cpuReservation,
+		command,
+		mounts,
+	} = libsql;
+
+	const basicAuth = Buffer.from(
+		`${databaseUser}:${databasePassword}`,
+		"utf-8",
+	).toString("base64");
+
+	const defaultLibsqlEnv = `SQLD_NODE="${sqldNode}"\nSQLD_HTTP_AUTH="basic:${basicAuth}"${
+		env ? `\n${env}` : ""
+	}${sqldNode === "replica" ? `\nSQLD_PRIMARY_URL="${sqldPrimaryUrl}"` : ""}`;
+
+	const {
+		HealthCheck,
+		RestartPolicy,
+		Placement,
+		Labels,
+		Mode,
+		RollbackConfig,
+		UpdateConfig,
+		Networks,
+	} = generateConfigContainer(libsql);
+	const resources = calculateResources({
+		memoryLimit,
+		memoryReservation,
+		cpuLimit,
+		cpuReservation,
+	});
+	const envVariables = prepareEnvironmentVariables(
+		defaultLibsqlEnv,
+		libsql.environment.project.env,
+		libsql.environment.env,
+	);
+	const volumesMount = generateVolumeMounts(mounts);
+	const bindsMount = generateBindMounts(mounts);
+	const filesMount = generateFileMounts(appName, libsql);
+
+	const docker = await getRemoteDocker(libsql.serverId);
+
+	const settings: CreateServiceOptions = {
+		Name: appName,
+		TaskTemplate: {
+			ContainerSpec: {
+				HealthCheck,
+				Image: dockerImage,
+				Env: envVariables,
+				Mounts: [...volumesMount, ...bindsMount, ...filesMount],
+				...(command
+					? {
+							Command: ["/bin/sh"],
+							Args: ["-c", command],
+						}
+					: {}),
+				Labels,
+			},
+			Networks,
+			RestartPolicy,
+			Placement,
+			Resources: {
+				...resources,
+			},
+		},
+		Mode,
+		RollbackConfig,
+		EndpointSpec: {
+			Mode: "dnsrr",
+			Ports: [
+				...(externalPort
+					? [
+							{
+								Protocol: "tcp",
+								TargetPort: 8080,
+								PublishedPort: externalPort,
+								PublishMode: "host",
+							} as PortConfig,
+						]
+					: []),
+				...(externalGRPCPort
+					? [
+							{
+								Protocol: "tcp",
+								TargetPort: 5001,
+								PublishedPort: externalGRPCPort,
+								PublishMode: "host",
+							} as PortConfig,
+						]
+					: []),
+			],
+		},
+		UpdateConfig,
+	};
+	try {
+		const service = docker.getService(appName);
+		const inspect = await service.inspect();
+		await service.update({
+			version: Number.parseInt(inspect.Version.Index),
+			...settings,
+			TaskTemplate: {
+				...settings.TaskTemplate,
+				ForceUpdate: inspect.Spec.TaskTemplate.ForceUpdate + 1,
+			},
+		});
+	} catch {
+		await docker.createService(settings);
+	}
+};
@@ -1,11 +1,13 @@
 import { db } from "@dokploy/server/db";
 import {
+	libsql,
 	mariadb,
 	mongo,
 	mysql,
 	postgres,
 	redis,
 } from "@dokploy/server/db/schema";
+import { deployLibsql } from "@dokploy/server/services/libsql";
 import { deployMariadb } from "@dokploy/server/services/mariadb";
 import { deployMongo } from "@dokploy/server/services/mongo";
 import { deployMySql } from "@dokploy/server/services/mysql";
@@ -15,7 +17,13 @@ import { eq } from "drizzle-orm";
 import { removeService } from "../docker/utils";
 import { execAsync, execAsyncRemote } from "../process/execAsync";

-type DatabaseType = "postgres" | "mysql" | "mariadb" | "mongo" | "redis";
+type DatabaseType =
+	| "libsql"
+	| "mariadb"
+	| "mongo"
+	| "mysql"
+	| "postgres"
+	| "redis";

 export const rebuildDatabase = async (
 	databaseId: string,
@@ -41,31 +49,25 @@ export const rebuildDatabase = async (
 		}
 	}

-	if (type === "postgres") {
-		await deployPostgres(databaseId);
-	} else if (type === "mysql") {
-		await deployMySql(databaseId);
+	if (type === "libsql") {
+		await deployLibsql(databaseId);
 	} else if (type === "mariadb") {
 		await deployMariadb(databaseId);
 	} else if (type === "mongo") {
 		await deployMongo(databaseId);
+	} else if (type === "mysql") {
+		await deployMySql(databaseId);
+	} else if (type === "postgres") {
+		await deployPostgres(databaseId);
 	} else if (type === "redis") {
 		await deployRedis(databaseId);
 	}
 };

 const findDatabaseById = async (databaseId: string, type: DatabaseType) => {
-	if (type === "postgres") {
-		return await db.query.postgres.findFirst({
-			where: eq(postgres.postgresId, databaseId),
-			with: {
-				mounts: true,
-			},
-		});
-	}
-	if (type === "mysql") {
-		return await db.query.mysql.findFirst({
-			where: eq(mysql.mysqlId, databaseId),
+	if (type === "libsql") {
+		return await db.query.libsql.findFirst({
+			where: eq(libsql.libsqlId, databaseId),
 			with: {
 				mounts: true,
 			},
@@ -87,6 +89,22 @@ const findDatabaseById = async (databaseId: string, type: DatabaseType) => {
 			},
 		});
 	}
+	if (type === "mysql") {
+		return await db.query.mysql.findFirst({
+			where: eq(mysql.mysqlId, databaseId),
+			with: {
+				mounts: true,
+			},
+		});
+	}
+	if (type === "postgres") {
+		return await db.query.postgres.findFirst({
+			where: eq(postgres.postgresId, databaseId),
+			with: {
+				mounts: true,
+			},
+		});
+	}
 	if (type === "redis") {
 		return await db.query.redis.findFirst({
 			where: eq(redis.redisId, databaseId),
@@ -6,6 +6,7 @@ import type { Compose } from "@dokploy/server/services/compose";
 import type { ContainerInfo, ResourceRequirements } from "dockerode";
 import { parse } from "dotenv";
 import type { ApplicationNested } from "../builders";
+import type { LibsqlNested } from "../databases/libsql";
 import type { MariadbNested } from "../databases/mariadb";
 import type { MongoNested } from "../databases/mongo";
 import type { MysqlNested } from "../databases/mysql";
@@ -472,6 +473,7 @@ export const generateFileMounts = (
 	appName: string,
 	service:
 		| ApplicationNested
+		| LibsqlNested
 		| MongoNested
 		| MariadbNested
 		| MysqlNested
@@ -1,15 +1,15 @@
-import { findVolumeBackupById } from "@dokploy/server/services/volume-backups";
-import { scheduledJobs, scheduleJob } from "node-schedule";
 import {
 	createDeploymentVolumeBackup,
 	updateDeploymentStatus,
 } from "@dokploy/server/services/deployment";
+import { findVolumeBackupById } from "@dokploy/server/services/volume-backups";
 import {
 	execAsync,
 	execAsyncRemote,
 } from "@dokploy/server/utils/process/execAsync";
-import { backupVolume } from "./backup";
+import { scheduledJobs, scheduleJob } from "node-schedule";
 import { getS3Credentials, normalizeS3Path } from "../backups/utils";
+import { backupVolume } from "./backup";

 export const scheduleVolumeBackup = async (volumeBackupId: string) => {
 	const volumeBackup = await findVolumeBackupById(volumeBackupId);