ta_data_mas 0.0.2

package/apps/web/src/features/auth/server.schema.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+import { AUTH_INTENT } from "./constants";
+import { loginSchema, registerSchema } from "./client.schema";
+
+export const authServerSchema = z.discriminatedUnion("intent", [
+  z.object({ intent: z.literal(AUTH_INTENT.LOGIN), ...loginSchema.shape }),
+  z.object({
+    intent: z.literal(AUTH_INTENT.REGISTER),
+    ...registerSchema.shape,
+  }),
+]);

package/apps/web/src/features/auth/sign-out.ts

@@ -0,0 +1,17 @@
+"use server";
+
+import { redirect } from "next/navigation";
+import { cookies } from "next/headers";
+import { COOKIE_KEYS } from "@apiDatabase/constants";
+
+export async function signOut() {
+  await fetch(`${process.env.API_URL}/auth/logout`, {
+    method: "POST",
+  });
+
+  const cookieStore = await cookies();
+  cookieStore.delete(COOKIE_KEYS.ACCESS_TOKEN);
+  cookieStore.delete(COOKIE_KEYS.REFRESH_TOKEN);
+
+  redirect("/login");
+}

package/apps/web/src/features/members/action.ts

@@ -0,0 +1,66 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { membersServerSchema } from "./server.schema";
+import { MEMBERS_INTENT } from "./constants";
+import { COOKIE_KEYS } from "@apiDatabase/constants";
+import { retrieveTokenFromCookie } from "@/server-utils/utils";
+import apiClient from "@/lib/axios";
+
+export type MembersActionState = {
+  error?: string;
+  success?: string;
+};
+
+export async function membersAction(
+  { slug }: { slug: string },
+  _prev: MembersActionState,
+  formData: FormData,
+): Promise<MembersActionState> {
+  const raw = Object.fromEntries(formData);
+  const parsed = membersServerSchema.safeParse(raw);
+
+  if (!parsed.success) {
+    return { error: parsed.error.flatten().formErrors[0] ?? "Invalid input" };
+  }
+
+  const token = await retrieveTokenFromCookie();
+  const { intent, ...data } = parsed.data;
+
+  try {
+    switch (intent) {
+      case MEMBERS_INTENT.INVITE: {
+        await apiClient.post(
+          `/orgs/${slug}/members/invite`,
+          { email: (data as { email: string }).email },
+          { headers: { Cookie: `${COOKIE_KEYS.ACCESS_TOKEN}=${token}` } },
+        );
+        revalidatePath(`/organizations/${slug}/settings/members`);
+        return { success: "Invite sent!" };
+      }
+
+      case MEMBERS_INTENT.UPDATE_ROLE: {
+        const { memberId, role } = data as { memberId: string; role: string };
+        await apiClient.patch(
+          `/orgs/${slug}/members/${memberId}/role`,
+          { role },
+          { headers: { Cookie: `${COOKIE_KEYS.ACCESS_TOKEN}=${token}` } },
+        );
+        revalidatePath(`/organizations/${slug}/settings/members`);
+        return { success: "Role updated" };
+      }
+
+      case MEMBERS_INTENT.REMOVE: {
+        const { memberId } = data as { memberId: string };
+        await apiClient.delete(`/orgs/${slug}/members/${memberId}`, {
+          headers: { Cookie: `${COOKIE_KEYS.ACCESS_TOKEN}=${token}` },
+        });
+        revalidatePath(`/organizations/${slug}/settings/members`);
+        return { success: "Member removed" };
+      }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  } catch (err: any) {
+    return { error: err.response?.data?.message ?? "Something went wrong" };
+  }
+}

package/apps/web/src/features/members/client.schema.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+import { ORG_ROLES } from "@apiDatabase/constants";
+import type { InviteMemberInput, UpdateRoleInput } from "@apiDatabase/types";
+
+export const inviteSchema = z.object({
+  email: z.string().email("Invalid email"),
+}) satisfies z.ZodType<InviteMemberInput>;
+
+export const updateRoleSchema = z.object({
+  role: z.enum([ORG_ROLES.ADMIN, ORG_ROLES.DEVELOPER]),
+}) satisfies z.ZodType<UpdateRoleInput>;

package/apps/web/src/features/members/constants.ts

@@ -0,0 +1,8 @@
+export const MEMBERS_INTENT = {
+  INVITE: "INVITE",
+  UPDATE_ROLE: "UPDATE_ROLE",
+  REMOVE: "REMOVE",
+} as const;
+
+export type MembersIntent =
+  (typeof MEMBERS_INTENT)[keyof typeof MEMBERS_INTENT];

package/apps/web/src/features/members/members-client.tsx

@@ -0,0 +1,198 @@
+"use client";
+
+import { useActionState } from "react";
+import { Avatar, AvatarFallback } from "@/components/ui/avatar";
+import { Button } from "@/components/ui/button";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { Field, FieldError, FieldGroup } from "@/components/ui/field";
+import { Input } from "@/components/ui/input";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { ORG_ROLES } from "@apiDatabase/constants";
+import { OrgMemberWithUser, OrgRole } from "@apiDatabase/types";
+import { membersAction } from "./action";
+import { Controller, useForm } from "react-hook-form";
+import z from "zod";
+import { inviteSchema } from "./client.schema";
+import { zodResolver } from "@hookform/resolvers/zod";
+import { MEMBERS_INTENT } from "./constants";
+import { Badge } from "@/components/ui/badge";
+
+interface MembersClientProps {
+  slug: string;
+  members: OrgMemberWithUser[];
+  currentUserRole: OrgRole;
+}
+
+export function MembersClient({
+  currentUserRole,
+  members,
+  slug,
+}: MembersClientProps) {
+  const isAdmin = currentUserRole === ORG_ROLES.ADMIN;
+  const boundAction = membersAction.bind(null, { slug });
+  const [state, formAction, isPending] = useActionState(boundAction, {});
+
+  const form = useForm<z.infer<typeof inviteSchema>>({
+    resolver: zodResolver(inviteSchema),
+    defaultValues: { email: "" },
+  });
+
+  return (
+    <div className="space-y-6">
+      {/* ── Invite form — admin only ─────────────────────────────── */}
+      {isAdmin && (
+        <Card>
+          <CardHeader>
+            <CardTitle className="text-base">Invite a member</CardTitle>
+          </CardHeader>
+          <CardContent>
+            {state.error && (
+              <p className="text-sm text-destructive mb-3">{state.error}</p>
+            )}
+            {state.success && (
+              <p className="text-sm text-green-600 mb-3">{state.success}</p>
+            )}
+            <form
+              action={formAction}
+              noValidate
+              onSubmitCapture={async (e) => {
+                const ok = await form.trigger(undefined, { shouldFocus: true });
+                if (!ok) e.preventDefault();
+              }}
+              className="flex gap-2"
+            >
+              <FieldGroup className="flex-1">
+                <Controller
+                  name="email"
+                  control={form.control}
+                  render={({ field, fieldState }) => (
+                    <Field data-invalid={fieldState.invalid}>
+                      <Input
+                        {...field}
+                        type="email"
+                        placeholder="colleague@example.com"
+                        aria-invalid={fieldState.invalid}
+                      />
+                      {fieldState.invalid && (
+                        <FieldError errors={[fieldState.error]} />
+                      )}
+                    </Field>
+                  )}
+                />
+              </FieldGroup>
+              <Button
+                type="submit"
+                name="intent"
+                value={MEMBERS_INTENT.INVITE}
+                disabled={isPending}
+              >
+                Send invite
+              </Button>
+            </form>
+          </CardContent>
+        </Card>
+      )}
+
+      {/* ── Members list ─────────────────────────────────────────── */}
+      <Card>
+        <CardHeader>
+          <CardTitle className="text-base">
+            {members.length} {members.length === 1 ? "member" : "members"}
+          </CardTitle>
+        </CardHeader>
+        <CardContent className="divide-y divide-border">
+          {members.map((member) => (
+            <div
+              key={member.id}
+              className="flex items-center justify-between py-3 first:pt-0 last:pb-0"
+            >
+              <div className="flex items-center gap-3">
+                <Avatar className="size-8">
+                  <AvatarFallback>
+                    {(member.user.name ?? member.user.email)
+                      .charAt(0)
+                      .toUpperCase()}
+                  </AvatarFallback>
+                </Avatar>
+                <div>
+                  <p className="text-sm font-medium">
+                    {member.user.name ?? "—"}
+                  </p>
+                  <p className="text-xs text-muted-foreground">
+                    {member.user.email}
+                  </p>
+                </div>
+              </div>
+
+              <div className="flex items-center gap-2">
+                {/* role badge / selector */}
+                {isAdmin ? (
+                  <form action={formAction}>
+                    <input type="hidden" name="memberId" value={member.id} />
+                    <Select
+                      name="role"
+                      defaultValue={member.role}
+                      onValueChange={(value) => {
+                        const form = document.createElement("form");
+                        // handled by the select's own form submission below
+                      }}
+                    >
+                      <SelectTrigger className="h-7 text-xs w-28">
+                        <SelectValue />
+                      </SelectTrigger>
+                      <SelectContent>
+                        <SelectItem value={ORG_ROLES.ADMIN}>Admin</SelectItem>
+                        <SelectItem value={ORG_ROLES.DEVELOPER}>
+                          Developer
+                        </SelectItem>
+                      </SelectContent>
+                    </Select>
+                    <Button
+                      type="submit"
+                      name="intent"
+                      value={MEMBERS_INTENT.UPDATE_ROLE}
+                      size="sm"
+                      variant="ghost"
+                      className="h-7 text-xs"
+                      disabled={isPending}
+                    >
+                      Save
+                    </Button>
+                  </form>
+                ) : (
+                  <Badge variant="secondary" className="capitalize">
+                    {member.role}
+                  </Badge>
+                )}
+
+                {/* remove button — admin only, can't remove self */}
+                {isAdmin && (
+                  <form action={formAction}>
+                    <input type="hidden" name="memberId" value={member.id} />
+                    <Button
+                      type="submit"
+                      name="intent"
+                      value={MEMBERS_INTENT.REMOVE}
+                      size="sm"
+                      variant="ghost"
+                      className="h-7 text-xs text-destructive hover:text-destructive"
+                      disabled={isPending}
+                    >
+                      Remove
+                    </Button>
+                  </form>
+                )}
+              </div>
+            </div>
+          ))}
+        </CardContent>
+      </Card>
+    </div>
+  );
+}

package/apps/web/src/features/members/members-helpers.server.ts

@@ -0,0 +1,21 @@
+import { redirect } from "next/navigation";
+import apiClient from "@/lib/axios";
+import { retrieveTokenFromCookie } from "@/server-utils/utils";
+import { COOKIE_KEYS } from "@apiDatabase/constants";
+import type { OrgMemberWithUser } from "@apiDatabase/types";
+
+export async function retrieveMembersFromApi(
+  slug: string,
+): Promise<OrgMemberWithUser[]> {
+  const token = await retrieveTokenFromCookie();
+
+  try {
+    const { data } = await apiClient.get<OrgMemberWithUser[]>(
+      `/orgs/${slug}/members`,
+      { headers: { Cookie: `${COOKIE_KEYS.ACCESS_TOKEN}=${token}` } },
+    );
+    return data;
+  } catch {
+    redirect("/organizations");
+  }
+}

package/apps/web/src/features/members/server.schema.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import { MEMBERS_INTENT } from "./constants";
+import { inviteSchema, updateRoleSchema } from "./client.schema";
+
+export const membersServerSchema = z.discriminatedUnion("intent", [
+  z.object({
+    intent: z.literal(MEMBERS_INTENT.INVITE),
+    ...inviteSchema.shape,
+  }),
+  z.object({
+    intent: z.literal(MEMBERS_INTENT.UPDATE_ROLE),
+    memberId: z.string(),
+    ...updateRoleSchema.shape,
+  }),
+  z.object({
+    intent: z.literal(MEMBERS_INTENT.REMOVE),
+    memberId: z.string(),
+  }),
+]);

package/apps/web/src/features/organization/action.ts

@@ -0,0 +1,45 @@
+"use server";
+
+import { redirect } from "next/navigation";
+import { revalidatePath } from "next/cache";
+import { COOKIE_KEYS } from "@apiDatabase/constants";
+import apiClient from "@/lib/axios";
+import { retrieveTokenFromCookie } from "@/server-utils/utils";
+import { ORGANIZATION_INTENT } from "./constants";
+import { organizationServerSchema } from "./server.schema";
+
+export type OrganizationActionState = {
+  error?: string;
+};
+
+export async function organizationAction(
+  _prev: OrganizationActionState,
+  formData: FormData,
+): Promise<OrganizationActionState> {
+  const raw = Object.fromEntries(formData);
+  const parsed = organizationServerSchema.safeParse(raw);
+
+  if (!parsed.success) {
+    return { error: parsed.error.flatten().formErrors[0] ?? "Invalid input" };
+  }
+
+  const token = await retrieveTokenFromCookie();
+
+  let slug: string;
+
+  try {
+    const { data } = await apiClient.post<{ slug: string }>(
+      "/orgs",
+      { name: parsed.data.name },
+      { headers: { Cookie: `${COOKIE_KEYS.ACCESS_TOKEN}=${token}` } },
+    );
+
+    slug = data.slug;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  } catch (err: any) {
+    return { error: err.response?.data?.message ?? "Something went wrong" };
+  }
+
+  revalidatePath("/organizations");
+  redirect(`/organizations/${slug}/projects`);
+}

package/apps/web/src/features/organization/client.schema.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+
+export const createOrgSchema = z.object({
+  name: z.string().min(2, "Name must be at least 2 characters"),
+});

package/apps/web/src/features/organization/constants.tsx

@@ -0,0 +1,3 @@
+export const ORGANIZATION_INTENT = {
+  CREATE: "create",
+} as const;

package/apps/web/src/features/organization/create-org-form.tsx

@@ -0,0 +1,66 @@
+"use client";
+
+import { useActionState } from "react";
+import { zodResolver } from "@hookform/resolvers/zod";
+import { Controller, useForm } from "react-hook-form";
+import type { z } from "zod";
+import { Button } from "@/components/ui/button";
+import {
+  Field,
+  FieldError,
+  FieldGroup,
+  FieldLabel,
+} from "@/components/ui/field";
+import { Input } from "@/components/ui/input";
+import { organizationAction } from "./action";
+import { createOrgSchema } from "./client.schema";
+import { ORGANIZATION_INTENT } from "./constants";
+
+type CreateOrgValues = z.infer<typeof createOrgSchema>;
+
+export function CreateOrgForm() {
+  const [state, formAction, isPending] = useActionState(organizationAction, {});
+  const form = useForm<CreateOrgValues>({
+    resolver: zodResolver(createOrgSchema),
+    defaultValues: { name: "" },
+  });
+
+  return (
+    <form
+      action={formAction}
+      noValidate
+      onSubmitCapture={async (e) => {
+        const ok = await form.trigger(undefined, { shouldFocus: true });
+        if (!ok) e.preventDefault();
+      }}
+      className="max-w-md space-y-4"
+    >
+      <input type="hidden" name="intent" value={ORGANIZATION_INTENT.CREATE} />
+
+      {state.error && <p className="text-sm text-destructive">{state.error}</p>}
+
+      <FieldGroup>
+        <Controller
+          name="name"
+          control={form.control}
+          render={({ field, fieldState }) => (
+            <Field data-invalid={fieldState.invalid}>
+              <FieldLabel htmlFor="name">Organization name</FieldLabel>
+              <Input
+                id="name"
+                placeholder="My Company"
+                {...field}
+                name="name"
+              />
+              {fieldState.invalid && <FieldError errors={[fieldState.error]} />}
+            </Field>
+          )}
+        />
+      </FieldGroup>
+
+      <Button type="submit" disabled={isPending}>
+        {isPending ? "Creating…" : "Create organization"}
+      </Button>
+    </form>
+  );
+}

package/apps/web/src/features/organization/organization-helpers.server.ts

@@ -0,0 +1,35 @@
+import { redirect } from "next/navigation";
+import apiClient from "@/lib/axios";
+import { retrieveTokenFromCookie } from "@/server-utils/utils";
+import { COOKIE_KEYS } from "@apiDatabase/constants";
+import type { OrganizationWithMeta } from "@apiDatabase/types";
+
+export async function retrieveMyOrganizationsFromApi(): Promise<
+  OrganizationWithMeta[]
+> {
+  const token = await retrieveTokenFromCookie();
+
+  try {
+    const { data } = await apiClient.get<OrganizationWithMeta[]>("/orgs", {
+      headers: {
+        Cookie: `${COOKIE_KEYS.ACCESS_TOKEN}=${token}`,
+      },
+    });
+    return data;
+  } catch {
+    redirect("/login");
+  }
+}
+
+export async function retrieveOrganizationBySlugFromApi(slug: string) {
+  const token = await retrieveTokenFromCookie();
+
+  try {
+    const { data } = await apiClient.get(`/orgs/${slug}`, {
+      headers: { Cookie: `${COOKIE_KEYS.ACCESS_TOKEN}=${token}` },
+    });
+    return data;
+  } catch {
+    redirect("/organizations");
+  }
+}

package/apps/web/src/features/organization/server.schema.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import { ORGANIZATION_INTENT } from "./constants";
+import { createOrgSchema } from "./client.schema";
+
+export const organizationServerSchema = z.discriminatedUnion("intent", [
+  z.object({
+    intent: z.literal(ORGANIZATION_INTENT.CREATE),
+    ...createOrgSchema.shape,
+  }),
+]);

package/apps/web/src/features/project-auth/project-auth-action.ts

@@ -0,0 +1,78 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { COOKIE_KEYS } from "@apiDatabase/constants";
+import apiClient from "@/lib/axios";
+import { retrieveTokenFromCookie } from "@/server-utils/utils";
+import { PROJECT_AUTH_INTENT } from "./project-auth-constants";
+import { projectAuthServerSchema } from "./project-auth-server.schema";
+
+export type ProjectAuthActionState = {
+  error?: string;
+  success?: string;
+};
+
+export async function projectAuthAction(
+  {
+    orgSlug,
+    projectSlug,
+  }: {
+    orgSlug: string;
+    projectSlug: string;
+  },
+  _prev: ProjectAuthActionState,
+  formData: FormData,
+): Promise<ProjectAuthActionState> {
+  const raw = Object.fromEntries(formData);
+  const parsed = projectAuthServerSchema.safeParse(raw);
+
+  if (!parsed.success) {
+    return { error: parsed.error.flatten().formErrors[0] ?? "Invalid input" };
+  }
+
+  const token = await retrieveTokenFromCookie();
+  const { intent, ...data } = parsed.data;
+
+  try {
+    switch (intent) {
+      case PROJECT_AUTH_INTENT.SAVE_GOOGLE: {
+        await apiClient.post(
+          `/orgs/${orgSlug}/projects/${projectSlug}/auth/settings`,
+          data,
+          { headers: { Cookie: `${COOKIE_KEYS.ACCESS_TOKEN}=${token}` } },
+        );
+        revalidatePath(
+          `/organizations/${orgSlug}/${projectSlug}/auth/providers`,
+        );
+        return { success: "Google settings saved" };
+      }
+
+      case PROJECT_AUTH_INTENT.SAVE_GITHUB: {
+        await apiClient.post(
+          `/orgs/${orgSlug}/projects/${projectSlug}/auth/settings`,
+          data,
+          { headers: { Cookie: `${COOKIE_KEYS.ACCESS_TOKEN}=${token}` } },
+        );
+        revalidatePath(
+          `/organizations/${orgSlug}/${projectSlug}/auth/providers`,
+        );
+        return { success: "GitHub settings saved" };
+      }
+
+      case PROJECT_AUTH_INTENT.SAVE_SITE_URL: {
+        await apiClient.post(
+          `/orgs/${orgSlug}/projects/${projectSlug}/auth/settings`,
+          data,
+          { headers: { Cookie: `${COOKIE_KEYS.ACCESS_TOKEN}=${token}` } },
+        );
+        revalidatePath(
+          `/organizations/${orgSlug}/${projectSlug}/auth/url-configuration`,
+        );
+        return { success: "Site URL saved" };
+      }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  } catch (err: any) {
+    return { error: err.response?.data?.message ?? "Something went wrong" };
+  }
+}

package/apps/web/src/features/project-auth/project-auth-client.schema.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+
+export const googleOAuthSchema = z.object({
+  googleClientId: z.string().min(1, "Client ID is required"),
+  googleClientSecret: z.string().min(1, "Client secret is required"),
+});
+
+export const githubOAuthSchema = z.object({
+  githubClientId: z.string().min(1, "Client ID is required"),
+  githubClientSecret: z.string().min(1, "Client secret is required"),
+});
+
+export const siteUrlSchema = z.object({
+  siteUrl: z
+    .string()
+    .min(1, "Site URL is required")
+    .url("Must be a valid URL (include https://)"),
+});

package/apps/web/src/features/project-auth/project-auth-constants.ts

@@ -0,0 +1,8 @@
+export const PROJECT_AUTH_INTENT = {
+  SAVE_GOOGLE: "SAVE_GOOGLE",
+  SAVE_GITHUB: "SAVE_GITHUB",
+  SAVE_SITE_URL: "SAVE_SITE_URL",
+} as const;
+
+export type ProjectAuthIntent =
+  (typeof PROJECT_AUTH_INTENT)[keyof typeof PROJECT_AUTH_INTENT];

package/apps/web/src/features/project-auth/project-auth-helpers.server.ts

@@ -0,0 +1,39 @@
+import { redirect } from "next/navigation";
+import apiClient from "@/lib/axios";
+import { retrieveTokenFromCookie } from "@/server-utils/utils";
+import { COOKIE_KEYS } from "@apiDatabase/constants";
+import type { ProjectAuthUser, ProjectOAuthSettings } from "@apiDatabase/types";
+
+export async function retrieveProjectAuthUsersFromApi(
+  orgSlug: string,
+  projectSlug: string,
+): Promise<ProjectAuthUser[]> {
+  const token = await retrieveTokenFromCookie();
+
+  try {
+    const { data } = await apiClient.get<ProjectAuthUser[]>(
+      `/orgs/${orgSlug}/projects/${projectSlug}/auth/users`,
+      { headers: { Cookie: `${COOKIE_KEYS.ACCESS_TOKEN}=${token}` } },
+    );
+    return data;
+  } catch {
+    redirect(`/organizations/${orgSlug}/projects`);
+  }
+}
+
+export async function retrieveOAuthSettingsFromApi(
+  orgSlug: string,
+  projectSlug: string,
+): Promise<ProjectOAuthSettings> {
+  const token = await retrieveTokenFromCookie();
+
+  try {
+    const { data } = await apiClient.get<ProjectOAuthSettings>(
+      `/orgs/${orgSlug}/projects/${projectSlug}/auth/settings`,
+      { headers: { Cookie: `${COOKIE_KEYS.ACCESS_TOKEN}=${token}` } },
+    );
+    return data;
+  } catch {
+    redirect(`/organizations/${orgSlug}/projects`);
+  }
+}