@autobe/ui 0.29.2 → 0.30.0

package/src/components/events/AutoBeValidateEventMovie.tsx

@@ -1,7 +1,6 @@
 import {
+  AutoBeDatabaseValidateEvent,
   AutoBeInterfaceOperationReviewEvent,
-  AutoBePrismaInsufficientEvent,
-  AutoBePrismaValidateEvent,
   AutoBeRealizeAuthorizationValidateEvent,
   AutoBeRealizeValidateEvent,
   AutoBeTestValidateEvent,
@@ -12,8 +11,7 @@ import { EventCard, EventContent, EventHeader } from "./common";
 
 export interface IAutoBeValidateEventMovieProps {
   event:
-    | AutoBePrismaInsufficientEvent
-    | AutoBePrismaValidateEvent
+    | AutoBeDatabaseValidateEvent
     | AutoBeInterfaceOperationReviewEvent
     | AutoBeTestValidateEvent
     | AutoBeRealizeValidateEvent
@@ -63,7 +61,7 @@ interface IState {
 
 function getState(event: IAutoBeValidateEventMovieProps["event"]): IState {
   switch (event.type) {
-    case "prismaValidate":
+    case "databaseValidate":
       return {
         title: "Prisma Validation Failed",
         description: (
@@ -103,7 +101,7 @@ function getState(event: IAutoBeValidateEventMovieProps["event"]): IState {
             Test file validation completed.
             <br />
             <br />
-            <strong>File:</strong> {event.file.location}
+            <strong>Function:</strong> {event.function.location}
             <br />
             <strong>Status:</strong> {isTestSuccess ? "Success" : "Failed"}
             {!isTestSuccess && (
@@ -208,43 +206,6 @@ function getState(event: IAutoBeValidateEventMovieProps["event"]): IState {
         isSuccess: isAuthSuccess,
         step: event.step,
       };
-    case "prismaInsufficient":
-      return {
-        title: "Prisma Model Generation Insufficient",
-        description: (
-          <>
-            Prisma model generation was incomplete for the assigned component.
-            <br />
-            <br />
-            <strong>Component:</strong> {event.component.namespace}
-            <br />
-            <strong>Generated Models:</strong> {event.actual.length}
-            <br />
-            <strong>Missing Models:</strong> {event.missed.length}
-            <br />
-            <br />
-            {event.missed.length > 0 && (
-              <>
-                <strong>Missed Tables:</strong>
-                <br />
-                {event.missed.slice(0, 5).map((table: string, idx: number) => (
-                  <div key={idx} style={{ marginTop: "0.25rem" }}>
-                    • {table}
-                  </div>
-                ))}
-                {event.missed.length > 5 && (
-                  <div style={{ marginTop: "0.25rem" }}>
-                    ... and {event.missed.length - 5} more
-                  </div>
-                )}
-              </>
-            )}
-          </>
-        ),
-        isError: true,
-        isSuccess: false,
-        step: undefined, // prismaInsufficient doesn't have step
-      };
     case "interfaceOperationReview":
       return {
         title: "Interface Operations Review",
@@ -253,7 +214,9 @@ function getState(event: IAutoBeValidateEventMovieProps["event"]): IState {
             API operations are being reviewed for quality and consistency.
             <br />
             <br />
-            <strong>Operations Count:</strong> {event.operations.length}
+            <strong>Method:</strong> {event.operation.method.toUpperCase()}
+            <br />
+            <strong>Path:</strong> {event.operation.path}
             <br />
             <strong>Status:</strong> Review in progress
             <br />

package/src/components/events/README.md

@@ -23,11 +23,11 @@ import { AutoBeEventMovie } from "@autobe/ui/events";
 
 **Supported Event Types:**
 - **Message Events**: `userMessage`, `assistantMessage`
-- **Start Events**: `analyzeStart`, `prismaStart`, `interfaceStart`, `testStart`, `realizeStart`, `realizeTestStart`, `realizeAuthorizationStart`
-- **Scenario Events**: `analyzeScenario`, `prismaComponents`, `interfaceGroups`, `realizeTestReset`
-- **Progress Events**: `analyzeWrite`, `analyzeReview`, `interfaceEndpoints`, `prismaSchemas`, `prismaReview`, `interfaceOperations`, `interfaceOperationsReview`, `interfaceAuthorization`, `interfaceSchemas`, `interfaceSchemasReview`, `testWrite`, `testScenarios`, `realizeWrite`, `realizeAuthorizationWrite`, `realizeTestOperation`
-- **Validate Events**: `prismaInsufficient`, `prismaValidate`, `interfaceComplement`, `testValidate`, `realizeValidate`, `realizeAuthorizationValidate`
-- **Complete Events**: `analyzeComplete`, `prismaComplete`, `interfaceComplete`, `testComplete`, `realizeComplete`
+- **Start Events**: `analyzeStart`, `databaseStart`, `interfaceStart`, `testStart`, `realizeStart`, `realizeTestStart`, `realizeAuthorizationStart`
+- **Scenario Events**: `analyzeScenario`, `databaseComponent`, `interfaceGroups`, `realizeTestReset`
+- **Progress Events**: `analyzeWrite`, `analyzeReview`, `interfaceEndpoints`, `databaseSchema`, `databaseReview`, `interfaceOperations`, `interfaceOperationsReview`, `interfaceAuthorization`, `interfaceSchemas`, `interfaceSchemasReview`, `testWrite`, `testScenarios`, `realizeWrite`, `realizeAuthorizationWrite`, `realizeTestOperation`
+- **Validate Events**: `databaseInsufficient`, `databaseValidate`, `interfaceComplement`, `testValidate`, `realizeValidate`, `realizeAuthorizationValidate`
+- **Complete Events**: `analyzeComplete`, `databaseComplete`, `interfaceComplete`, `testComplete`, `realizeComplete`
 
 ## Individual Event Components
 

package/src/components/events/groups/CorrectEventGroup.tsx

@@ -1,5 +1,5 @@
 import {
-  AutoBePrismaCorrectEvent,
+  AutoBeDatabaseCorrectEvent,
   AutoBeRealizeAuthorizationCorrectEvent,
   AutoBeRealizeCorrectEvent,
   AutoBeTestCorrectEvent,
@@ -9,7 +9,7 @@ import { AutoBeCorrectEventMovie } from "../AutoBeCorrectEventMovie";
 import { CollapsibleEventGroup } from "../common/CollapsibleEventGroup";
 
 type CorrectEvent =
-  | AutoBePrismaCorrectEvent
+  | AutoBeDatabaseCorrectEvent
   | AutoBeTestCorrectEvent
   | AutoBeRealizeCorrectEvent
   | AutoBeRealizeAuthorizationCorrectEvent;
@@ -71,7 +71,7 @@ export const CorrectEventGroup = (props: ICorrectEventGroupProps) => {
       >
         {eventTypes.map((type) => {
           const typeDisplayNames = {
-            prismaCorrect: "🗄️ Database Schema",
+            databaseCorrect: "🗄️ Database Schema",
             testCorrect: "🧪 Test Suite",
             realizeCorrect: "⚙️ Implementation",
             realizeAuthorizationCorrect: "🔐 Authorization",

package/src/components/events/groups/ValidateEventGroup.tsx

@@ -1,7 +1,6 @@
 import {
+  AutoBeDatabaseValidateEvent,
   AutoBeInterfaceOperationReviewEvent,
-  AutoBePrismaInsufficientEvent,
-  AutoBePrismaValidateEvent,
   AutoBeRealizeAuthorizationValidateEvent,
   AutoBeRealizeValidateEvent,
   AutoBeTestValidateEvent,
@@ -11,8 +10,7 @@ import { AutoBeValidateEventMovie } from "../AutoBeValidateEventMovie";
 import { CollapsibleEventGroup } from "../common/CollapsibleEventGroup";
 
 export type ValidateEvent =
-  | AutoBePrismaInsufficientEvent
-  | AutoBePrismaValidateEvent
+  | AutoBeDatabaseValidateEvent
   | AutoBeInterfaceOperationReviewEvent
   | AutoBeTestValidateEvent
   | AutoBeRealizeValidateEvent
@@ -37,9 +35,8 @@ export const ValidateEventGroup = (props: IValidateEventGroupProps) => {
   // Calculate validation statistics
   const errorEvents = events.filter((event) => {
     switch (event.type) {
-      case "prismaValidate":
+      case "databaseValidate":
       case "realizeValidate":
-      case "prismaInsufficient":
         return true;
       case "testValidate":
       case "realizeAuthorizationValidate":

package/src/components/events/utils/eventGrouper.tsx

@@ -79,11 +79,10 @@ function groupEventsByCategory(events: AutoBeEvent[]) {
   events.forEach((event) => {
     switch (event.type) {
       // Validation events
-      case "prismaValidate":
+      case "databaseValidate":
       case "testValidate":
       case "realizeValidate":
       case "realizeAuthorizationValidate":
-      case "prismaInsufficient":
       case "interfaceOperationReview":
         grouped.validate.push(event);
         break;

package/src/components/upload/AutoBeChatUploadBox.tsx

@@ -1,8 +1,8 @@
-import { AutoBeUserMessageContent } from "@autobe/interface";
 import {
+  AutoBeUserConversateContent,
+  AutoBeUserImageConversateContent,
   AutoBeUserMessageAudioContent,
   AutoBeUserMessageFileContent,
-  AutoBeUserMessageImageContent,
 } from "@autobe/interface";
 import { ReactNode, RefObject, useEffect, useRef, useState } from "react";
 
@@ -20,7 +20,7 @@ export interface IAutoBeBucket {
   content:
     | AutoBeUserMessageAudioContent
     | AutoBeUserMessageFileContent
-    | AutoBeUserMessageImageContent;
+    | AutoBeUserImageConversateContent;
 }
 
 export interface IAutoBeChatUploadConfig {
@@ -72,13 +72,13 @@ export const AutoBeChatUploadBox = (props: AutoBeChatUploadBox.IProps) => {
       return;
     }
 
-    const messages = [
+    const messages: AutoBeUserConversateContent[] = [
       {
         type: "text",
         text: text.trim(),
       },
       ...buckets.map(({ content }) => content),
-    ] as AutoBeUserMessageContent[];
+    ];
 
     setEmptyText(false);
     setText("");
@@ -102,7 +102,8 @@ export const AutoBeChatUploadBox = (props: AutoBeChatUploadBox.IProps) => {
     const newFiles: IAutoBeBucket[] = [];
     const errorFileNames: string[] = [];
 
-    for (const file of fileList) {
+    const files = Array.from(fileList);
+    for (const file of files) {
       try {
         newFiles.push(
           await AutoBeFileUploader.compose(props.uploadConfig ?? {}, file),
@@ -412,7 +413,7 @@ export namespace AutoBeChatUploadBox {
   export interface IProps {
     listener: RefObject<IListener>;
     uploadConfig?: IAutoBeChatUploadConfig;
-    conversate: (messages: AutoBeUserMessageContent[]) => Promise<void>;
+    conversate: (messages: AutoBeUserConversateContent[]) => Promise<void>;
     setError: (error: Error) => void;
   }
   export interface IListener {

package/src/components/upload/AutoBeChatUploadSendButton.tsx

@@ -18,7 +18,7 @@ export const AutoBeChatUploadSendButton = (
   const baseStyles: React.CSSProperties = {
     padding: "6px",
     border: "none",
-    borderRadius: "50%", // 4px에서 50%로 변경하여 둥글게
+    borderRadius: "50%",
     backgroundColor: props.enabled ? "#1976d2" : "#e0e0e0",
     color: props.enabled ? "#ffffff" : "#9e9e9e",
     cursor: props.enabled ? "pointer" : "not-allowed",

package/src/context/AutoBeAgentContext.tsx

@@ -1,8 +1,4 @@
-import {
-  IAutoBeRpcListener,
-  IAutoBeRpcService,
-  IAutoBeTokenUsageJson,
-} from "@autobe/interface";
+import { IAutoBeRpcService, IAutoBeTokenUsageJson } from "@autobe/interface";
 import {
   ReactNode,
   createContext,
@@ -11,7 +7,6 @@ import {
   useEffect,
   useState,
 } from "react";
-import { Communicator } from "tgrid";
 
 import {
   AutoBeListener,
@@ -26,7 +21,6 @@ import { useSearchParams } from "./SearchParamsContext";
 export interface IAutoBeServiceData {
   service: IAutoBeRpcService;
   listener: AutoBeListener;
-  connector: Communicator<IAutoBeRpcListener, IAutoBeRpcService>;
   close: () => void | Promise<void>;
   sessionId: string;
 }
@@ -36,9 +30,9 @@ export type AutoBeServiceFactory = (
 ) => Promise<IAutoBeServiceData>;
 
 export type AutoBeConnectionStatus =
-  | "disconnected" // 연결되지 않음
-  | "connecting" // 연결 중
-  | "connected"; // 연결 완료 및 활성 상태
+  | "disconnected"
+  | "connecting"
+  | "connected";
 
 interface AutoBeAgentContextType {
   // Service state
@@ -113,13 +107,6 @@ export function AutoBeAgentProvider({
           ...config,
           sessionId: activeConversationId,
         });
-        newServiceData.connector.join().then(async () => {
-          const res = await serviceFactory({
-            ...config,
-            sessionId: activeConversationId,
-          });
-          setServiceInstance(res);
-        });
         setServiceInstance(newServiceData);
 
         setSearchParams((sp) => {

package/src/hooks/useSessionStorage.ts

@@ -0,0 +1,10 @@
+export const useSessionStorage = () => {
+  return {
+    getItem: (key: string): string => {
+      return sessionStorage.getItem(key) ?? "";
+    },
+    setItem: (key: string, value: string): void => {
+      sessionStorage.setItem(key, value);
+    },
+  };
+};

package/src/index.ts

@@ -6,3 +6,4 @@ export * from "./types";
 export * from "./context/AutoBeAgentContext";
 export * from "./context/AutoBeAgentSessionList";
 export * from "./context/SearchParamsContext";
+export * from "./strategy/AutoBeAgentSessionStorageStrategy";

package/src/strategy/AutoBeAgentSessionStorageStrategy.ts

@@ -0,0 +1,127 @@
+import { AutoBeEventSnapshot } from "@autobe/interface";
+
+import { useSessionStorage } from "../hooks/useSessionStorage";
+import {
+  IAutoBeAgentSession,
+  IAutoBeAgentSessionStorageStrategy,
+} from "../structure";
+
+const SESSION_KEY = "autobe_session_list";
+
+export class AutoBeAgentSessionStorageStrategy implements IAutoBeAgentSessionStorageStrategy {
+  appendEvent(): Promise<void> {
+    return Promise.resolve();
+  }
+  setTokenUsage(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  async getSession(
+    props: Pick<IAutoBeAgentSession, "id">,
+  ): Promise<IAutoBeAgentSession> {
+    const { getItem } = useSessionStorage();
+
+    const session = getItem(SESSION_KEY);
+    if (!session) {
+      throw new Error("Session not found");
+    }
+
+    const sessionList = JSON.parse(session);
+
+    if (sessionList instanceof Array === false) {
+      throw new Error("Session list is not an array");
+    }
+
+    const result = sessionList.find(
+      (s: IAutoBeAgentSession) => s.id === props.id,
+    );
+
+    return {
+      id: result.id,
+      title: result.participant.name,
+      history: result.histories,
+      tokenUsage: result.token_usage,
+      createdAt: new Date(result.created_at),
+      updatedAt: new Date(result.completed_at ?? result.created_at),
+      events: result.event_snapshots.map((event: AutoBeEventSnapshot) => ({
+        type: event.event.type,
+        events: [event.event],
+      })),
+    };
+  }
+
+  async getSessionList(): Promise<IAutoBeAgentSession[]> {
+    const { getItem } = useSessionStorage();
+    const sessionList = getItem(SESSION_KEY);
+    if (!sessionList) {
+      throw new Error("Session list not found");
+    }
+
+    const result = JSON.parse(sessionList);
+    if (result instanceof Array === false) {
+      throw new Error("Session list is not an array");
+    }
+
+    return result.map((session) => ({
+      id: session.id,
+      title: session.title ?? "Untitled",
+      history: [],
+      tokenUsage: session.token_usage,
+      createdAt: new Date(session.created_at),
+      updatedAt: new Date(session.completed_at ?? session.created_at),
+      completedAt: session.completed_at,
+      events: [],
+      phase: session.phase,
+      model: session.model,
+    }));
+  }
+
+  async deleteSession(props: Pick<IAutoBeAgentSession, "id">): Promise<void> {
+    const { getItem, setItem } = useSessionStorage();
+
+    const sessionList = getItem(SESSION_KEY);
+    if (!sessionList) {
+      throw new Error("Session list not found");
+    }
+
+    const result = JSON.parse(sessionList);
+    if (result instanceof Array === false) {
+      throw new Error("Session list is not an array");
+    }
+
+    setItem(
+      SESSION_KEY,
+      JSON.stringify(
+        result.filter((s: IAutoBeAgentSession) => s.id !== props.id),
+      ),
+    );
+  }
+
+  async appendHistory(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  async editSessionTitle(
+    props: Pick<IAutoBeAgentSession, "id" | "title">,
+  ): Promise<void> {
+    const { getItem, setItem } = useSessionStorage();
+
+    const sessionList = getItem(SESSION_KEY);
+    if (!sessionList) {
+      throw new Error("Session list not found");
+    }
+
+    const result = JSON.parse(sessionList);
+    if (result instanceof Array === false) {
+      throw new Error("Session list is not an array");
+    }
+
+    const session = result.find((s: IAutoBeAgentSession) => s.id === props.id);
+    if (!session) {
+      throw new Error("Session not found");
+    }
+
+    session.title = props.title;
+    setItem(SESSION_KEY, JSON.stringify(result));
+  }
+}

package/src/structure/AutoBeListener.ts

@@ -34,56 +34,110 @@ export class AutoBeListener {
         this.insert(event);
       },
 
+      // DESCRIBE
+      imageDescribeStart: async (event) => {
+        this.dict_.delete("imageDescribeDraft");
+        this.insert(event);
+      },
+      imageDescribeDraft: async (event) => {
+        this.insert(event);
+      },
+      imageDescribeComplete: async (event) => {
+        this.dict_.delete("imageDescribeDraft");
+        this.insert(event);
+      },
+
       // ANALYZE
       analyzeStart: async (event) => {
-        this.dict_.delete("analyzeWrite");
-        this.dict_.delete("analyzeReview");
+        this.dict_.delete("analyzeWriteModule");
+        this.dict_.delete("analyzeModuleReview");
+        this.dict_.delete("analyzeWriteUnit");
+        this.dict_.delete("analyzeUnitReview");
+        this.dict_.delete("analyzeWriteSection");
+        this.dict_.delete("analyzeSectionReview");
         this.insert(event);
       },
       analyzeScenario: async (event) => {
         this.accumulate(event);
       },
-      analyzeWrite: async (event) => {
+      analyzeWriteModule: async (event) => {
+        this.accumulate(event);
+      },
+      analyzeModuleReview: async (event) => {
+        this.accumulate(event);
+      },
+      analyzeWriteUnit: async (event) => {
+        this.accumulate(event);
+      },
+      analyzeUnitReview: async (event) => {
+        this.accumulate(event);
+      },
+      analyzeWriteSection: async (event) => {
+        this.accumulate(event);
+      },
+      analyzeSectionReview: async (event) => {
         this.accumulate(event);
       },
-      analyzeReview: async (event) => {
+      analyzeScenarioReview: async (event) => {
         this.accumulate(event);
       },
       analyzeComplete: async (event) => {
-        this.dict_.delete("analyzeWrite");
-        this.dict_.delete("analyzeReview");
+        this.dict_.delete("analyzeWriteModule");
+        this.dict_.delete("analyzeModuleReview");
+        this.dict_.delete("analyzeWriteUnit");
+        this.dict_.delete("analyzeUnitReview");
+        this.dict_.delete("analyzeWriteSection");
+        this.dict_.delete("analyzeSectionReview");
         this.state_.setAnalyze(event);
         this.insert(event);
       },
 
       // PRISMA
-      prismaStart: async (event) => {
-        this.dict_.delete("prismaSchema");
-        this.dict_.delete("prismaReview");
+      databaseStart: async (event) => {
+        this.dict_.delete("databaseAuthorizationReview");
+        this.dict_.delete("databaseComponent");
+        this.dict_.delete("databaseComponentReview");
+        this.dict_.delete("databaseSchema");
+        this.dict_.delete("databaseSchemaReview");
         this.insert(event);
       },
-      prismaComponent: async (event) => {
+      databaseGroup: async (event) => {
         this.insert(event);
       },
-      prismaSchema: async (event) => {
+      databaseGroupReview: async (event) => {
+        this.insert(event);
+      },
+      databaseAuthorization: async (event) => {
         this.accumulate(event);
       },
-      prismaInsufficient: async (event) => {
-        this.insert(event);
+      databaseAuthorizationReview: async (event) => {
+        this.accumulate(event);
+      },
+      databaseComponent: async (event) => {
+        this.accumulate(event);
+      },
+      databaseComponentReview: async (event) => {
+        this.accumulate(event);
       },
-      prismaReview: async (event) => {
+      databaseSchema: async (event) => {
         this.accumulate(event);
       },
-      prismaValidate: async (event) => {
+      databaseSchemaReview: async (event) => {
+        this.accumulate(event);
+      },
+      databaseValidate: async (event) => {
         this.insert(event);
       },
-      prismaCorrect: async (event) => {
+      databaseCorrect: async (event) => {
         this.insert(event);
       },
-      prismaComplete: async (event) => {
-        this.dict_.delete("prismaSchema");
-        this.dict_.delete("prismaReview");
-        this.state_.setPrisma(event);
+      databaseComplete: async (event) => {
+        this.dict_.delete("databaseAuthorizationReview");
+        this.dict_.delete("databaseComponent");
+        this.dict_.delete("databaseComponentReview");
+        this.dict_.delete("databaseSchema");
+        this.dict_.delete("databaseSchemaReview");
+        this.state_.setDatabase(event);
         this.insert(event);
       },
 
@@ -94,8 +148,10 @@ export class AutoBeListener {
         this.dict_.delete("interfaceOperation");
         this.dict_.delete("interfaceOperationReview");
         this.dict_.delete("interfaceSchema");
+        this.dict_.delete("interfaceSchemaCasting");
+        this.dict_.delete("interfaceSchemaRefine");
         this.dict_.delete("interfaceSchemaReview");
-        this.dict_.delete("interfaceComplement");
+        this.dict_.delete("interfaceSchemaComplement");
         this.dict_.delete("interfaceSchemaRename");
         this.dict_.delete("interfacePrerequisite");
         this.insert(event);
@@ -121,13 +177,19 @@ export class AutoBeListener {
       interfaceSchema: async (event) => {
         this.accumulate(event);
       },
+      interfaceSchemaCasting: async (event) => {
+        this.accumulate(event);
+      },
+      interfaceSchemaRefine: async (event) => {
+        this.accumulate(event);
+      },
       interfaceSchemaReview: async (event) => {
         this.accumulate(event);
       },
       interfaceSchemaRename: async (event) => {
         this.accumulate(event);
       },
-      interfaceComplement: async (event) => {
+      interfaceSchemaComplement: async (event) => {
         this.accumulate(event);
       },
       interfacePrerequisite: async (event) => {
@@ -139,9 +201,11 @@ export class AutoBeListener {
         this.dict_.delete("interfaceOperationReview");
         this.dict_.delete("interfaceAuthorization");
         this.dict_.delete("interfaceSchema");
+        this.dict_.delete("interfaceSchemaCasting");
+        this.dict_.delete("interfaceSchemaRefine");
         this.dict_.delete("interfaceSchemaReview");
         this.dict_.delete("interfaceSchemaRename");
-        this.dict_.delete("interfaceComplement");
+        this.dict_.delete("interfaceSchemaComplement");
         this.dict_.delete("interfacePrerequisite");
         this.state_.setInterface(event);
         this.insert(event);
@@ -184,10 +248,14 @@ export class AutoBeListener {
       //----
       // REALIZE-MAIN
       realizeStart: async (event) => {
+        this.dict_.delete("realizePlan");
         this.dict_.delete("realizeWrite");
         this.dict_.delete("realizeValidate");
         this.insert(event);
       },
+      realizePlan: async (event) => {
+        this.accumulate(event);
+      },
       realizeWrite: async (event) => {
         this.accumulate(event);
       },
@@ -199,6 +267,7 @@ export class AutoBeListener {
         this.accumulate(event);
       },
       realizeComplete: async (event) => {
+        this.dict_.delete("realizePlan");
         this.dict_.delete("realizeWrite");
         this.dict_.delete("realizeValidate");
         this.state_.setRealize(event);

package/src/structure/AutoBeListenerState.ts

@@ -1,21 +1,21 @@
 import {
   AutoBeAnalyzeCompleteEvent,
+  AutoBeDatabaseCompleteEvent,
   AutoBeInterfaceCompleteEvent,
-  AutoBePrismaCompleteEvent,
   AutoBeRealizeCompleteEvent,
   AutoBeTestCompleteEvent,
 } from "@autobe/interface";
 
 export class AutoBeListenerState {
   public analyze: AutoBeAnalyzeCompleteEvent | null;
-  public prisma: AutoBePrismaCompleteEvent | null;
+  public database: AutoBeDatabaseCompleteEvent | null;
   public interface: AutoBeInterfaceCompleteEvent | null;
   public test: AutoBeTestCompleteEvent | null;
   public realize: AutoBeRealizeCompleteEvent | null;
 
   public constructor() {
     this.analyze = null;
-    this.prisma = null;
+    this.database = null;
     this.interface = null;
     this.test = null;
     this.realize = null;
@@ -23,14 +23,14 @@ export class AutoBeListenerState {
 
   public setAnalyze(event: AutoBeAnalyzeCompleteEvent): void {
     this.analyze = event;
-    this.prisma = null;
+    this.database = null;
     this.interface = null;
     this.test = null;
     this.realize = null;
   }
 
-  public setPrisma(event: AutoBePrismaCompleteEvent): void {
-    this.prisma = event;
+  public setDatabase(event: AutoBeDatabaseCompleteEvent): void {
+    this.database = event;
     this.interface = null;
     this.test = null;
     this.realize = null;