feat(libsql): add support for libsql database backups and restores

- Updated backup and restore functionalities to include support for the 'libsql' database type.
- Enhanced the backup process with new methods for running and restoring libsql backups.
- Modified existing components and schemas to accommodate libsql, including updates to the database type enumerations and backup schemas.
- Removed obsolete bottomless replication features from the libsql schema.
- Updated related UI components to reflect changes in backup handling for libsql.

packages/server/src/db/schema/backups.ts

@@ -15,6 +15,7 @@ import { generateAppName } from ".";
 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 { mysql } from "./mysql";
@@ -26,6 +27,7 @@ export const databaseType = pgEnum("databaseType", [
 	"mysql",
 	"mongo",
 	"web-server",
+	"libsql",
 ]);
 
 export const backupType = pgEnum("backupType", ["database", "compose"]);
@@ -74,6 +76,12 @@ export const backups = pgTable("backup", {
 	mongoId: text("mongoId").references((): AnyPgColumn => mongo.mongoId, {
 		onDelete: "cascade",
 	}),
+	libsqlId: text("libsqlId").references(
+		(): AnyPgColumn => libsql.libsqlId,
+		{
+			onDelete: "cascade",
+		},
+	),
 	userId: text("userId").references(() => user.id),
 	// Only for compose backups
 	metadata: jsonb("metadata").$type<
@@ -118,6 +126,10 @@ export const backupsRelations = relations(backups, ({ one, many }) => ({
 		fields: [backups.mongoId],
 		references: [mongo.mongoId],
 	}),
+	libsql: one(libsql, {
+		fields: [backups.libsqlId],
+		references: [libsql.libsqlId],
+	}),
 	user: one(user, {
 		fields: [backups.userId],
 		references: [user.id],
@@ -137,11 +149,12 @@ const createSchema = createInsertSchema(backups, {
 	database: z.string().min(1),
 	schedule: z.string(),
 	keepLatestCount: z.number().optional(),
-	databaseType: z.enum(["postgres", "mariadb", "mysql", "mongo", "web-server"]),
+	databaseType: z.enum(["postgres", "mariadb", "mysql", "mongo", "web-server", "libsql"]),
 	postgresId: z.string().optional(),
 	mariadbId: z.string().optional(),
 	mysqlId: z.string().optional(),
 	mongoId: z.string().optional(),
+	libsqlId: z.string().optional(),
 	userId: z.string().optional(),
 	metadata: z.any().optional(),
 });
@@ -157,6 +170,7 @@ export const apiCreateBackup = createSchema.pick({
 	mysqlId: true,
 	postgresId: true,
 	mongoId: true,
+	libsqlId: true,
 	databaseType: true,
 	userId: true,
 	backupType: true,
@@ -192,7 +206,7 @@ export const apiUpdateBackup = createSchema
 
 export const apiRestoreBackup = z.object({
 	databaseId: z.string(),
-	databaseType: z.enum(["postgres", "mysql", "mariadb", "mongo", "web-server"]),
+	databaseType: z.enum(["postgres", "mysql", "mariadb", "mongo", "web-server", "libsql"]),
 	backupType: z.enum(["database", "compose"]),
 	databaseName: z.string().min(1),
 	backupFile: z.string().min(1),

packages/server/src/db/schema/libsql.ts

@@ -3,7 +3,7 @@ import { boolean, integer, json, pgTable, text } from "drizzle-orm/pg-core";
 import { createInsertSchema } from "drizzle-zod";
 import { nanoid } from "nanoid";
 import { z } from "zod";
-import { destinations } from "./destination";
+import { backups } from "./backups";
 import { environments } from "./environment";
 import { mounts } from "./mount";
 import { server } from "./server";
@@ -43,14 +43,6 @@ export const libsql = pgTable("libsql", {
 	sqldNode: sqldNode("sqldNode").notNull().default("primary"),
 	sqldPrimaryUrl: text("sqldPrimaryUrl"),
 	enableNamespaces: boolean("enableNamespaces").notNull().default(false),
-	enableBottomlessReplication: boolean("enableBottomlessReplication")
-		.notNull()
-		.default(false),
-	bottomlessReplicationDestinationId: text(
-		"bottomlessReplicationDestinationId",
-	).references(() => destinations.destinationId, {
-		onDelete: "set null",
-	}),
 	dockerImage: text("dockerImage").notNull(),
 	command: text("command"),
 	env: text("env"),
@@ -92,16 +84,12 @@ export const libsqlRelations = relations(libsql, ({ one, many }) => ({
 		fields: [libsql.environmentId],
 		references: [environments.environmentId],
 	}),
-	//backups: many(backups),
+	backups: many(backups),
 	mounts: many(mounts),
 	server: one(server, {
 		fields: [libsql.serverId],
 		references: [server.serverId],
 	}),
-	bottomlessReplicationDestination: one(destinations, {
-		fields: [libsql.bottomlessReplicationDestinationId],
-		references: [destinations.destinationId],
-	}),
 }));
 
 const createSchema = createInsertSchema(libsql, {
@@ -119,9 +107,7 @@ const createSchema = createInsertSchema(libsql, {
 	sqldNode: z.enum(sqldNode.enumValues),
 	sqldPrimaryUrl: z.string().nullable(),
 	enableNamespaces: z.boolean().default(false),
-	enableBottomlessReplication: z.boolean().default(false),
-	bottomlessReplicationDestinationId: z.string().nullable(),
-	dockerImage: z.string().default("ghcr.io/tursodatabase/libsql-server:latest"),
+	dockerImage: z.string().default("ghcr.io/tursodatabase/libsql-server:v0.24.32"),
 	command: z.string().optional(),
 	env: z.string().optional(),
 	memoryReservation: z.string().optional(),