chore(release): 1.2.4-rc.1

This commit is contained in:
Théo LAGACHE
2026-01-28 15:54:03 +01:00
parent 4942591d7f
commit 2a6d631719
34 changed files with 329 additions and 331 deletions
@@ -0,0 +1,51 @@
"use client";
import {
Dialog,
DialogContent,
DialogHeader,
DialogTitle,
DialogTrigger,
} from "@/components/ui/dialog";
import {ProjectForm} from "@/features/projects/components/project.form";
import {useState} from "react";
import {Button} from "@/components/ui/button";
import {Plus} from "lucide-react";
import {DatabaseWith} from "@/db/schema/07_database";
import {Organization} from "@/db/schema/03_organization";
import {ProjectWith} from "@/db/schema/06_project";
type ProjectDialogProps = {
children?: React.ReactNode;
databases: DatabaseWith[];
organization: Organization;
project?: ProjectWith;
};
export const ProjectDialog = ({children, databases, organization, project}: ProjectDialogProps) => {
const [open, setOpen] = useState(false);
const isEdit = !!project;
return (
<Dialog open={open} onOpenChange={setOpen}>
<DialogTrigger asChild>
{children ? children : <Button><Plus className="mr-2 h-4 w-4"/> Create Project</Button>}
</DialogTrigger>
<DialogContent>
<DialogHeader>
<DialogTitle>{isEdit ? `Edit ${project.name}` : "Create new project"}</DialogTitle>
</DialogHeader>
<ProjectForm
onSuccess={() => setOpen(false)}
databases={databases}
organization={organization}
defaultValues={project ? {
...project,
databases: project.databases.map(db => db.id)
} : undefined}
projectId={project?.id}
/>
</DialogContent>
</Dialog>
);
};
@@ -0,0 +1,135 @@
"use client";
import { FormControl, FormDescription, FormField, FormItem, FormLabel, FormMessage, useZodForm } from "@/components/ui/form";
import { Input } from "@/components/ui/input";
import { Form } from "@/components/ui/form";
import { Button } from "@/components/ui/button";
import { useMutation } from "@tanstack/react-query";
import { ProjectSchema, ProjectType } from "@/features/projects/projects.schema";
import { createProjectAction, updateProjectAction } from "@/features/projects/projects.action";
import { useRouter } from "next/navigation";
import { MultiSelect } from "@/components/wrappers/common/multiselect/multi-select";
import { toast } from "sonner";
import {DatabaseWith} from "@/db/schema/07_database";
import {Organization} from "@/db/schema/03_organization";
export type projectFormProps = {
defaultValues?: ProjectType;
databases: DatabaseWith[];
organization: Organization;
projectId?: string;
onSuccess?: (data: any) => void;
};
export const ProjectForm = (props: projectFormProps) => {
const router = useRouter();
const isCreate = !Boolean(props.defaultValues);
const formatDatabasesList = (databases: DatabaseWith[]) => {
return databases.map((database) => ({
value: database.id,
label: `${database.name} | ${database.agent?.name}`,
}));
};
const formatDefaultDatabases = (databases: string[]): string[] => {
return databases;
};
const formattedDefaultValues = {
...props.defaultValues,
databases: !isCreate ? formatDefaultDatabases(props.defaultValues?.databases ?? []) : [],
};
const form = useZodForm({
schema: ProjectSchema,
defaultValues: formattedDefaultValues,
});
const mutation = useMutation({
mutationFn: async (values: ProjectType) => {
if (!isCreate && !props.projectId) {
throw new Error("Project ID is required for updates");
}
const project = isCreate
? await createProjectAction({
data: values,
organizationId: props.organization.id,
})
: await updateProjectAction({
data: values,
organizationId: props.organization.id,
projectId: props.projectId!,
});
if (project && project.data) {
if (project.data.success) {
project.data.actionSuccess && toast.success(project.data.actionSuccess.message);
router.refresh();
if (props.onSuccess) {
props.onSuccess(project.data.value);
} else {
router.push(`/dashboard/projects/${project.data.value!.id}`);
}
} else {
project.data.actionError && toast.error(project.data.actionError.message || "Unknown error occurred.");
router.refresh();
}
} else {
toast.error("Failed to process request. No response received.");
router.refresh();
}
},
});
return (
<Form
form={form}
className="flex flex-col gap-4"
onSubmit={async (values) => {
await mutation.mutateAsync(values);
}}
>
<FormField
control={form.control}
name="name"
render={({ field }) => (
<FormItem>
<FormLabel>Name</FormLabel>
<FormControl>
<Input placeholder="Project 1" {...field} value={field.value ?? ""} />
</FormControl>
<FormMessage />
</FormItem>
)}
/>
<FormField
control={form.control}
name="databases"
render={({ field }) => (
<FormItem>
<FormLabel>Databases</FormLabel>
<FormControl>
<MultiSelect
options={formatDatabasesList(props.databases)}
onValueChange={field.onChange}
defaultValue={field.value ?? []}
placeholder="Select databases"
variant="inverted"
animation={2}
// maxCount={100}
/>
</FormControl>
<FormDescription>Select databases you want to add to this project</FormDescription>
<FormMessage />
</FormItem>
)}
/>
<div className="flex justify-end">
<Button type="submit">
{isCreate ? "Create" : "Update"}
</Button>
</div>
</Form>
);
};
+150
View File
@@ -0,0 +1,150 @@
"use server";
import {userAction} from "@/lib/safe-actions/actions";
import {ProjectSchema} from "@/features/projects/projects.schema";
import {z} from "zod";
import {ServerActionResult} from "@/types/action-type";
import {db} from "@/db";
import {and, eq, inArray} from "drizzle-orm";
import {Project} from "@/db/schema/06_project";
import * as drizzleDb from "@/db";
import {Database} from "@/db/schema/07_database";
import {slugify} from "@/utils/slugify";
export const createProjectAction = userAction
.schema(
z.object({
data: ProjectSchema,
organizationId: z.string(),
})
)
.action(async ({parsedInput}): Promise<ServerActionResult<Project>> => {
try {
const slug = slugify(parsedInput.data.name);
const existingProject = await db.query.project.findFirst({
where: and(eq(drizzleDb.schemas.project.name, parsedInput.data.name)),
})
if (existingProject) {
return {
success: false,
actionError: {
message: "A project with this name already exists.",
status: 400,
messageParams: {projectName: parsedInput.data.name},
},
};
}
const [createdProject] = await db
.insert(drizzleDb.schemas.project)
.values({
name: parsedInput.data.name,
slug: slug,
organizationId: parsedInput.organizationId,
})
.returning();
if (parsedInput.data.databases.length > 0) {
await db
.update(drizzleDb.schemas.database)
.set({projectId: createdProject.id})
.where(inArray(drizzleDb.schemas.database.id, parsedInput.data.databases));
}
return {
success: true,
value: createdProject,
actionSuccess: {
message: "Project has been successfully created.",
messageParams: {projectName: parsedInput.data.name},
},
};
} catch (error) {
return {
success: false,
actionError: {
message: "Failed to create project.",
status: 500,
cause: error instanceof Error ? error.message : "Unknown error",
messageParams: {projectName: parsedInput.data.name},
},
};
}
});
export const updateProjectAction = userAction
.schema(
z.object({
data: ProjectSchema,
organizationId: z.string(),
projectId: z.string(),
})
)
.action(async ({parsedInput}): Promise<ServerActionResult<Project>> => {
try {
const existing = await db.query.project.findFirst({
where: eq(drizzleDb.schemas.project.id, parsedInput.projectId),
with: {
databases: true,
},
});
if (!existing) {
throw new Error("Project not found.");
}
const existingDbIds = existing.databases.map((db: Database) => db.id);
const newDbIds = parsedInput.data.databases;
const databasesToAdd = newDbIds.filter((id) => !existingDbIds.includes(id));
const databasesToRemove = existingDbIds.filter((id: string) => !newDbIds.includes(id));
if (databasesToAdd.length > 0) {
await db.update(drizzleDb.schemas.database).set({projectId: parsedInput.projectId}).where(inArray(drizzleDb.schemas.database.id, databasesToAdd));
}
if (databasesToRemove.length > 0) {
await db.update(drizzleDb.schemas.database).set({
projectId: null,
backupPolicy: null
}).where(inArray(drizzleDb.schemas.database.id, databasesToRemove));
await db.delete(drizzleDb.schemas.retentionPolicy)
.where(inArray(drizzleDb.schemas.retentionPolicy.databaseId, databasesToRemove)).execute();
await db.delete(drizzleDb.schemas.alertPolicy)
.where(inArray(drizzleDb.schemas.alertPolicy.databaseId, databasesToRemove)).execute();
}
const [updatedProject] = await db
.update(drizzleDb.schemas.project)
.set({
name: parsedInput.data.name,
})
.where(eq(drizzleDb.schemas.project.id, parsedInput.projectId))
.returning();
return {
success: true,
value: updatedProject,
actionSuccess: {
message: "Project has been successfully updated.",
messageParams: {projectName: parsedInput.data.name},
},
};
} catch (error) {
return {
success: false,
actionError: {
message: "Failed to update project.",
status: 500,
cause: error instanceof Error ? error.message : "Unknown error",
messageParams: {projectName: parsedInput.data.name},
},
};
}
});
+8
View File
@@ -0,0 +1,8 @@
import { z } from "zod";
export const ProjectSchema = z.object({
name: z.string().nonempty("Name is required"),
databases: z.array(z.string()),
});
export type ProjectType = z.infer<typeof ProjectSchema>;