update database

apps/storybook/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acme/storybook",
-  "version": "0.2.0",
+  "version": "1.0.0",
   "private": true,
   "type": "module",
   "scripts": {

apps/storybook/src/stories/custom/crud-item.stories.tsx

@@ -49,7 +49,7 @@ export const Settings: Story = {
 export const TreeItem: Story = {
   args: {
     id: "test-id",
-    username: "John Doe",
+    lastEditedBy: "John Doe",
     label: "Folder",
     icon: { type: "lucide", name: "folder" },
     onClick: () => alert(`Clicked item`),

apps/storybook/src/stories/notion/settings-panel/index.stories.tsx

@@ -16,12 +16,6 @@ export default meta;
 type Story = StoryObj<typeof meta>;
 
 const mockSettings: SettingsStore = {
-  user: {
-    id: "1",
-    name: "John Doe",
-    email: "[email protected]",
-    imageUrl: "https://github.com/shadcn.png",
-  },
   workspace: {
     id: "fake-workspace-id-12345",
     name: "John's Private",
@@ -32,6 +26,8 @@ const mockSettings: SettingsStore = {
     avatarUrl: "https://github.com/shadcn.png",
     preferredName: "John Doe",
     email: "[email protected]",
+    id: "fake-account-id-123",
+    name: "John Wick",
   },
 };
 

apps/storybook/src/stories/notion/settings-panel/settings.tsx

@@ -14,8 +14,8 @@ const Panel = () => {
   const { data, isOpen, setClose } = useModal<SettingsStore>();
   const props: SettingsPanelProps = {
     settings: data,
-    onUpdate: async ({ user, account }) => {
-      console.log(`mutating`, { user, account });
+    onUpdate: async ({ account }) => {
+      console.log(`mutating`, { account });
     },
   };
 

apps/storybook/src/stories/notion/workspace-provider/utils.ts

@@ -1,30 +1,41 @@
 import type { UserState, Workspace } from "@acme/ui/notion";
 
-const createWorkspaceData = (
-  name: string,
-  id: number | string,
-  user: UserState,
-): Workspace => ({
-  id: `dummy-workspace-${id}`,
-  name,
-  icon: "🎑",
-  owner: user.name,
-  ownerId: user.id,
-  members: [],
-});
-
 export const user: UserState = {
   id: "dummy-user",
   name: "Steve",
   email: "[email protected]",
-  isDarkMode: false,
-  profilePicture: {
-    url: "",
-  },
 };
 export const workspaces: Workspace[] = [
-  createWorkspaceData("Steve's Workspace", `personal`, user),
-  createWorkspaceData("Workspace 1", 1, user),
-  createWorkspaceData("Workspace 2", 2, user),
-  createWorkspaceData("Workspace 3", 3, user),
+  {
+    id: "dummy-workspace-personal",
+    name: "John's Workspace",
+    icon: { type: "lucide", name: "activity", color: "#CB912F" },
+    members: 1,
+    plan: "Education Plus Plan",
+    role: "owner",
+  },
+  {
+    id: "dummy-workspace-1",
+    name: "Workspace 1",
+    icon: { type: "lucide", name: "briefcase", color: "#337EA9" },
+    members: 3,
+    plan: "Free Plan",
+    role: "owner",
+  },
+  {
+    id: "dummy-workspace-2",
+    name: "Workspace 2",
+    icon: { type: "emoji", emoji: "🎨" },
+    members: 2,
+    plan: "Business Plan",
+    role: "member",
+  },
+  {
+    id: "dummy-workspace-3",
+    name: "Workspace 3",
+    icon: { type: "emoji", emoji: "🚧" },
+    members: 8,
+    plan: "Enterprise Plan",
+    role: "guest",
+  },
 ];

apps/worxpace/next.config.js

@@ -36,6 +36,10 @@ const config = {
         protocol: "https",
         hostname: "files.edgestore.dev",
       },
+      {
+        protocol: "https",
+        hostname: "www.notion.so",
+      },
     ],
   },
   webpack: (config, { isServer }) => {

apps/worxpace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acme/worxpace",
-  "version": "0.3.1",
+  "version": "1.0.0",
   "private": true,
   "type": "module",
   "scripts": {

apps/worxpace/src/actions/archive-document.ts

@@ -1,39 +1,49 @@
 "use server";
 
 import { revalidatePath } from "next/cache";
+import type { MutationFetcher } from "swr/mutation";
 
-import type { Document, ENTITY_TYPE } from "@acme/prisma";
+import type { ENTITY_TYPE } from "@acme/prisma";
 import { type Modified } from "@acme/ui/lib";
 import { DeleteDocument, type DeleteDocumentInput } from "@acme/validators";
 
 import {
+  account,
   auditLogs,
   createMutationFetcher,
   documents,
   fetchClient,
   UnauthorizedError,
-  type Action,
+  type DetailedDocument,
+  type DocumentsKey,
 } from "~/lib";
 
-const handler: Action<DeleteDocumentInput, Modified<Document>> = async (
-  _key,
-  { arg },
-) => {
-  try {
-    const { userId, orgId } = fetchClient();
-    const result = await documents.archive({ ...arg, userId, orgId });
-    /** Activity Log */
-    const type = result.item.type.toUpperCase() as ENTITY_TYPE;
-    await auditLogs.create(
-      { title: result.item.title, entityId: arg.id, type },
-      "DELETE",
-    );
-    revalidatePath(`/documents/${arg.id}`);
-    return result;
-  } catch (error) {
-    if (error instanceof UnauthorizedError) throw error;
-    throw new Error("Failed to archive document.");
-  }
-};
+const handler = createMutationFetcher(
+  DeleteDocument,
+  async (workspaceId, { arg }) => {
+    try {
+      const { clerkId } = fetchClient();
+      const inWorkspace = await account.isInWorkspace({ clerkId, workspaceId });
+      if (!inWorkspace) throw new UnauthorizedError();
+      const result = await documents.archive(arg);
+      /** Activity Log */
+      const type = result.item.type.toUpperCase() as ENTITY_TYPE;
+      await auditLogs.create({
+        entity: { title: result.item.title, entityId: arg.id, type },
+        action: "DELETE",
+        accountId: arg.accountId,
+      });
+      revalidatePath(`/documents/${arg.id}`);
+      return result;
+    } catch (error) {
+      if (error instanceof UnauthorizedError) throw error;
+      throw new Error("Failed to archive document.");
+    }
+  },
+);
 
-export const archiveDocument = createMutationFetcher(DeleteDocument, handler);
+export const archiveDocument: MutationFetcher<
+  Modified<DetailedDocument>,
+  DocumentsKey,
+  DeleteDocumentInput
+> = ({ workspaceId }, data) => handler(workspaceId, data);

apps/worxpace/src/actions/copy-card.ts

@@ -1,6 +1,7 @@
 "use server";
 
 import { revalidatePath } from "next/cache";
+import type { MutationFetcher } from "swr/mutation";
 
 import type { Card } from "@acme/prisma";
 import { CopyCard, type CopyCardInput } from "@acme/validators";
@@ -11,31 +12,36 @@ import {
   fetchClient,
   kanban,
   UnauthorizedError,
-  type Action,
+  type KanbanKey,
 } from "~/lib";
 
-const handler: Action<CopyCardInput, Card> = async (_key, { arg }) => {
-  const { src, dest, boardId } = arg;
+const handler = createMutationFetcher(CopyCard, async (_key, { arg }) => {
+  const { src, dest, boardId, accountId } = arg;
   try {
     fetchClient();
     const srcCard = await kanban.getCard(src.id);
     if (!srcCard) throw new Error("Not found");
 
     const result = await kanban.createCard({
+      accountId,
       ...dest,
       description: srcCard.description,
     });
     /** Activity Log */
-    await auditLogs.create(
-      { entityId: boardId, title: dest.title, type: "ITEM" },
-      "CREATE",
-    );
+    await auditLogs.create({
+      entity: { entityId: boardId, title: dest.title, type: "ITEM" },
+      action: "CREATE",
+      accountId,
+    });
     revalidatePath(`/kanban/${boardId}`);
     return result;
   } catch (error) {
     if (error instanceof UnauthorizedError) throw error;
     throw new Error("Failed to copy card.");
   }
-};
+});
 
-export const copyCard = createMutationFetcher(CopyCard, handler);
+export const copyCard: MutationFetcher<Card, KanbanKey, CopyCardInput> = (
+  { boardId },
+  data,
+) => handler(boardId, data);

apps/worxpace/src/actions/copy-list.ts

@@ -1,6 +1,7 @@
 "use server";
 
 import { revalidatePath } from "next/cache";
+import type { MutationFetcher } from "swr/mutation";
 
 import type { List } from "@acme/prisma";
 import { CopyList, type CopyListInput } from "@acme/validators";
@@ -11,11 +12,11 @@ import {
   fetchClient,
   kanban,
   UnauthorizedError,
-  type Action,
+  type KanbanKey,
 } from "~/lib";
 
-const handler: Action<CopyListInput, List> = async (_key, { arg }) => {
-  const { boardId, srcId, destId } = arg;
+const handler = createMutationFetcher(CopyList, async (_key, { arg }) => {
+  const { boardId, srcId, destId, accountId } = arg;
   try {
     fetchClient();
     const srcList = await kanban.getListById({ boardId, id: srcId });
@@ -32,6 +33,7 @@ const handler: Action<CopyListInput, List> = async (_key, { arg }) => {
         : undefined;
     const result = await kanban.createList(
       {
+        accountId,
         id: destId,
         title: `${srcList.title} Copy`,
         order: numLists + 1,
@@ -40,16 +42,20 @@ const handler: Action<CopyListInput, List> = async (_key, { arg }) => {
       cards,
     );
     /** Activity Log */
-    await auditLogs.create(
-      { title: result.title, entityId: boardId, type: "LIST" },
-      "CREATE",
-    );
+    await auditLogs.create({
+      entity: { title: result.title, entityId: boardId, type: "LIST" },
+      action: "CREATE",
+      accountId,
+    });
     revalidatePath(`/kanban/${boardId}`);
     return result;
   } catch (error) {
     if (error instanceof UnauthorizedError) throw error;
     throw new Error("Failed to copy list.");
   }
-};
+});
 
-export const copyList = createMutationFetcher(CopyList, handler);
+export const copyList: MutationFetcher<List, KanbanKey, CopyListInput> = (
+  { boardId },
+  data,
+) => handler(boardId, data);

apps/worxpace/src/actions/create-account.ts

@@ -0,0 +1,28 @@
+"use server";
+
+import type { MutationFetcher } from "swr/mutation";
+
+import type { Account } from "@acme/prisma";
+import { CreateAccount, type CreateAccountInput } from "@acme/validators";
+
+import { account, createMutationFetcher, UnauthorizedError } from "~/lib";
+
+const handler = createMutationFetcher(
+  CreateAccount,
+  async (clerkId, { arg }) => {
+    try {
+      const data = await account.get(clerkId);
+      if (data) return data;
+      return await account.create(arg);
+    } catch (error) {
+      if (error instanceof UnauthorizedError) throw error;
+      throw new Error("Failed to create account.");
+    }
+  },
+);
+
+export const createAccount: MutationFetcher<
+  Account,
+  { type: "settings"; clerkId: string },
+  CreateAccountInput
+> = ({ clerkId }, data) => handler(clerkId, data);

apps/worxpace/src/actions/create-card.ts

@@ -1,6 +1,7 @@
 "use server";
 
 import { revalidatePath } from "next/cache";
+import type { MutationFetcher } from "swr/mutation";
 
 import type { Card } from "@acme/prisma";
 import { CreateCard, type CreateCardInput } from "@acme/validators";
@@ -11,25 +12,29 @@ import {
   fetchClient,
   kanban,
   UnauthorizedError,
-  type Action,
+  type KanbanKey,
 } from "~/lib";
 
-const handler: Action<CreateCardInput, Card> = async (_key, { arg }) => {
-  const { boardId, ...info } = arg;
+const handler = createMutationFetcher(CreateCard, async (_key, { arg }) => {
+  const { boardId, ...data } = arg;
   try {
     fetchClient();
-    const result = await kanban.createCard(info);
+    const result = await kanban.createCard(data);
     /** Activity Log */
-    await auditLogs.create(
-      { title: arg.title, entityId: boardId, type: "ITEM" },
-      "CREATE",
-    );
+    await auditLogs.create({
+      entity: { title: arg.title, entityId: boardId, type: "ITEM" },
+      action: "CREATE",
+      accountId: data.accountId,
+    });
     revalidatePath(`/kanban/${boardId}`);
     return result;
   } catch (error) {
     if (error instanceof UnauthorizedError) throw error;
     throw new Error("Failed to create card.");
   }
-};
+});
 
-export const createCard = createMutationFetcher(CreateCard, handler);
+export const createCard: MutationFetcher<Card, KanbanKey, CreateCardInput> = (
+  { boardId },
+  data,
+) => handler(boardId, data);