AI SDK provider

.env.example

@@ -19,4 +19,4 @@ POSTGRES_URL=****
 NEXT_PUBLIC_PROJECT_ID=
 NEXTAUTH_SECRET=
 
-SIWE_VERIFICATION_API=
+PATTERN_CORE_ENDPOINT=

app/(auth)/adapter.ts

@@ -0,0 +1,145 @@
+import { Ok, Err, Result } from 'ts-results-es';
+
+import { extractErrorMessageOrDefault } from '@/lib/utils';
+
+import {
+  ApiCreateProjectResponse,
+  ApiCreateWorkspaceResponse,
+  ApiListAllProjectsResponse,
+  ApiListAllWorkspacesResponse,
+} from './types';
+
+const patternCoreEndpoint = process.env.PATTERN_CORE_ENDPOINT;
+if (!patternCoreEndpoint) {
+  throw new Error('PATTERN_CORE_ENDPOINT is not set');
+}
+
+/**
+ * Get all workspaces
+ * @param accessToken
+ * @returns result containing all workspaces of current user
+ */
+export const getAllWorkspaces = async (
+  accessToken: string,
+): Promise<Result<ApiListAllWorkspacesResponse, string>> => {
+  try {
+    const allWorkspacesResponse = await fetch(
+      `${patternCoreEndpoint}/workspace`,
+      {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          'Content-Type': 'application/json',
+        },
+      },
+    );
+
+    if (allWorkspacesResponse.ok) {
+      const allWorkspaces: ApiListAllWorkspacesResponse = (
+        await allWorkspacesResponse.json()
+      ).data;
+
+      return Ok(allWorkspaces);
+    }
+    return Err(
+      `Fetching workspaces failed with error code ${allWorkspacesResponse.status}`,
+    );
+  } catch (error) {
+    return Err(extractErrorMessageOrDefault(error));
+  }
+};
+
+/**
+ * Create a workspace
+ * @param accessToken
+ * @returns result containing the created workspace
+ */
+export const createWorkspace = async (
+  accessToken: string,
+): Promise<Result<ApiCreateWorkspaceResponse, string>> => {
+  try {
+    const response = await fetch(`${patternCoreEndpoint}/workspace`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        name: 'Default Workspace',
+      }),
+    });
+
+    if (response.ok) {
+      const workspace: ApiCreateWorkspaceResponse = (await response.json())
+        .data;
+
+      return Ok(workspace);
+    }
+    return Err(`Creating workspace failed with error code ${response.status}`);
+  } catch (error) {
+    return Err(extractErrorMessageOrDefault(error));
+  }
+};
+
+/**
+ * Get all projects
+ * @param accessToken
+ * @returns result containing all projects of current user
+ */
+export const getAllProjects = async (
+  accessToken: string,
+): Promise<Result<ApiListAllProjectsResponse, string>> => {
+  try {
+    const allProjectsResponse = await fetch(`${patternCoreEndpoint}/project`, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+      },
+    });
+    if (allProjectsResponse.ok) {
+      const allProjects: ApiListAllProjectsResponse = (
+        await allProjectsResponse.json()
+      ).data;
+
+      return Ok(allProjects);
+    }
+    return Err(
+      `Fetching projects failed with error code ${allProjectsResponse.status}`,
+    );
+  } catch (error) {
+    return Err(extractErrorMessageOrDefault(error));
+  }
+};
+
+/**
+ * Create a project in a workspace
+ * @param accessToken
+ * @param workspaceId
+ * @returns result containing the created project
+ */
+export const createProjectInWorkspace = async (
+  accessToken: string,
+  workspaceId: string,
+): Promise<Result<ApiCreateProjectResponse, string>> => {
+  try {
+    const response = await fetch(`${patternCoreEndpoint}/project`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        name: 'Default Project',
+        workspace_id: workspaceId,
+      }),
+    });
+
+    if (response.ok) {
+      const project: ApiCreateProjectResponse = (await response.json()).data;
+
+      return Ok(project);
+    }
+    return Err(`Creating project failed with error code ${response.status}`);
+  } catch (error) {
+    return Err(extractErrorMessageOrDefault(error));
+  }
+};

app/(auth)/auth.config.ts

@@ -1,11 +1,15 @@
-import type { SIWESession } from '@reown/appkit-siwe';
+import { type SIWESession } from '@reown/appkit-siwe';
 import type { NextAuthConfig } from 'next-auth';
 
+import { fetchSessionPrerequisites } from './service';
+
 declare module 'next-auth' {
   interface Session extends SIWESession {
     address: string;
     chainId: number;
     accessToken: string;
+    workspaceId: string;
+    projectId: string;
   }
   interface User {
     accessToken: string;
@@ -43,7 +47,7 @@ export const authConfig = {
       }
       return token;
     },
-    session({ session, token }) {
+    async session({ session, token }) {
       if (!token.sub) {
         return session;
       }
@@ -59,6 +63,20 @@ export const authConfig = {
         session.address = address;
         session.chainId = Number.parseInt(chainId, 10);
         session.accessToken = wrappedJWT;
+
+        const sessionPrerequisitesResult =
+          await fetchSessionPrerequisites(wrappedJWT);
+
+        if (sessionPrerequisitesResult.isErr()) {
+          throw new Error(
+            'Cannot fetch session prerequisites (default workspace and project)',
+            { cause: sessionPrerequisitesResult.error },
+          );
+        }
+
+        const [workspaceId, projectId] = sessionPrerequisitesResult.value;
+        session.workspaceId = workspaceId;
+        session.projectId = projectId;
       }
 
       return session;

app/(auth)/auth.ts

@@ -23,10 +23,11 @@ if (!projectId) {
   throw new Error('NEXT_PUBLIC_PROJECT_ID is not set');
 }
 
-const siweVerificationApi = process.env.SIWE_VERIFICATION_API;
-if (!siweVerificationApi) {
-  throw new Error('SIWE_VERIFICATION_API is not set');
+const patternCoreEndpoint = process.env.PATTERN_CORE_ENDPOINT;
+if (!patternCoreEndpoint) {
+  throw new Error('PATTERN_CORE_ENDPOINT is not set');
 }
+const siweVerificationApi = `${patternCoreEndpoint}/auth/verify`;
 
 const providers = [
   credentialsProvider({

app/(auth)/service.ts

@@ -0,0 +1,62 @@
+import { Err, Ok, Result } from 'ts-results-es';
+
+import {
+  createProjectInWorkspace,
+  createWorkspace,
+  getAllProjects,
+  getAllWorkspaces,
+} from './adapter';
+
+const patternCoreEndpoint = process.env.PATTERN_CORE_ENDPOINT;
+if (!patternCoreEndpoint) {
+  throw new Error('PATTERN_CORE_ENDPOINT is not set');
+}
+
+/**
+ * Checks if the default workspace and project exist, if not, creates them
+ * @param accessToken
+ * @returns result containing default workspace and project ids
+ */
+export const fetchSessionPrerequisites = async (
+  accessToken: string,
+): Promise<Result<[string, string], string>> => {
+  const allWorkspacesResult = await getAllWorkspaces(accessToken);
+  if (allWorkspacesResult.isErr()) {
+    return Err(allWorkspacesResult.error);
+  }
+
+  const allWorkspaces = allWorkspacesResult.value;
+  let workspace = allWorkspaces[0];
+
+  if (!workspace) {
+    const createWorkspaceResult = await createWorkspace(accessToken);
+    if (createWorkspaceResult.isErr()) {
+      return Err(createWorkspaceResult.error);
+    }
+
+    workspace = createWorkspaceResult.value;
+  }
+
+  const allProjectsResult = await getAllProjects(accessToken);
+  if (allProjectsResult.isErr()) {
+    return Err(allProjectsResult.error);
+  }
+
+  const allProjects = allProjectsResult.value;
+  let project = allProjects.find(
+    (project) => project.workspace_id === workspace.id,
+  );
+  if (!project) {
+    const createProjectResult = await createProjectInWorkspace(
+      accessToken,
+      workspace.id,
+    );
+    if (createProjectResult.isErr()) {
+      return Err(createProjectResult.error);
+    }
+
+    project = createProjectResult.value;
+  }
+
+  return Ok([workspace.id, project.id]);
+};

app/(auth)/types.ts

@@ -0,0 +1,16 @@
+export interface Workspace {
+  id: string;
+  name: string;
+}
+
+export interface Project {
+  id: string;
+  name: string;
+  workspace_id: string;
+}
+
+export type ApiListAllWorkspacesResponse = Workspace[];
+export type ApiCreateWorkspaceResponse = Workspace;
+
+export type ApiListAllProjectsResponse = Project[];
+export type ApiCreateProjectResponse = Project;