@liorandb/studio 0.0.1

package/template/src/lib/lioran.ts

@@ -0,0 +1,252 @@
+import { LioranClient } from '@liorandb/driver';
+import { Database, Collection, Document } from '@/types';
+
+let clientInstance: LioranClient | null = null;
+
+export class LioranDBService {
+  private static client: LioranClient | null = null;
+
+  static async initialize(uri: string): Promise<void> {
+    try {
+      this.client = new LioranClient(uri);
+      await this.client.connect();
+    } catch (error) {
+      throw new Error(`Failed to connect to LioranDB: ${error}`);
+    }
+  }
+
+  static isConnected(): boolean {
+    return this.client !== null;
+  }
+
+  static getClient(): LioranClient | null {
+    return this.client;
+  }
+
+  static disconnect(): void {
+    this.client = null;
+  }
+
+  // Database Operations
+  static async listDatabases(): Promise<Database[]> {
+    if (!this.client) throw new Error('Client not connected');
+    try {
+      const dbs = await this.client.listDatabases();
+      return ((dbs as unknown) as string[]).map(name => ({ name }));
+    } catch (error) {
+      throw new Error(`Failed to list databases: ${error}`);
+    }
+  }
+
+  static async createDatabase(name: string): Promise<void> {
+    if (!this.client) throw new Error('Client not connected');
+    try {
+      await this.client.createDatabase(name);
+    } catch (error) {
+      throw new Error(`Failed to create database: ${error}`);
+    }
+  }
+
+  static async dropDatabase(name: string): Promise<void> {
+    if (!this.client) throw new Error('Client not connected');
+    try {
+      await this.client.dropDatabase(name);
+    } catch (error) {
+      throw new Error(`Failed to drop database: ${error}`);
+    }
+  }
+
+  static async renameDatabase(oldName: string, newName: string): Promise<void> {
+    if (!this.client) throw new Error('Client not connected');
+    try {
+      await this.client.renameDatabase(oldName, newName);
+    } catch (error) {
+      throw new Error(`Failed to rename database: ${error}`);
+    }
+  }
+
+  // Collection Operations
+  static async listCollections(dbName: string): Promise<Collection[]> {
+    if (!this.client) throw new Error('Client not connected');
+    try {
+      const db = this.client.db(dbName);
+      const collections = await db.listCollections();
+      return ((collections as unknown) as string[]).map(name => ({ name }));
+    } catch (error) {
+      throw new Error(`Failed to list collections: ${error}`);
+    }
+  }
+
+  static async createCollection(dbName: string, name: string): Promise<void> {
+    if (!this.client) throw new Error('Client not connected');
+    try {
+      const db = this.client.db(dbName);
+      await db.createCollection(name);
+    } catch (error) {
+      throw new Error(`Failed to create collection: ${error}`);
+    }
+  }
+
+  static async dropCollection(dbName: string, name: string): Promise<void> {
+    if (!this.client) throw new Error('Client not connected');
+    try {
+      const db = this.client.db(dbName);
+      await db.dropCollection(name);
+    } catch (error) {
+      throw new Error(`Failed to drop collection: ${error}`);
+    }
+  }
+
+  static async renameCollection(
+    dbName: string,
+    oldName: string,
+    newName: string
+  ): Promise<void> {
+    if (!this.client) throw new Error('Client not connected');
+    try {
+      const db = this.client.db(dbName);
+      await db.renameCollection(oldName, newName);
+    } catch (error) {
+      throw new Error(`Failed to rename collection: ${error}`);
+    }
+  }
+
+  // Document Operations
+  static async find(
+    dbName: string,
+    collectionName: string,
+    filter?: Record<string, any>,
+    limit: number = 100
+  ): Promise<{ documents: Document[]; count: number }> {
+    if (!this.client) throw new Error('Client not connected');
+    try {
+      const db = this.client.db(dbName);
+      const collection = db.collection(collectionName);
+      const documents = await collection.find(filter || {});
+      return {
+        documents: ((documents as unknown) as Document[]).slice(0, limit),
+        count: documents.length,
+      };
+    } catch (error) {
+      throw new Error(`Failed to find documents: ${error}`);
+    }
+  }
+
+  static async findOne(
+    dbName: string,
+    collectionName: string,
+    filter: Record<string, any>
+  ): Promise<Document | null> {
+    if (!this.client) throw new Error('Client not connected');
+    try {
+      const db = this.client.db(dbName);
+      const collection = db.collection(collectionName);
+      const doc = await collection.findOne(filter);
+      return ((doc as unknown) as Document) || null;
+    } catch (error) {
+      throw new Error(`Failed to find document: ${error}`);
+    }
+  }
+
+  static async insertOne(
+    dbName: string,
+    collectionName: string,
+    doc: Document
+  ): Promise<string> {
+    if (!this.client) throw new Error('Client not connected');
+    try {
+      const db = this.client.db(dbName);
+      const collection = db.collection(collectionName);
+      const { _id, ...docData } = doc;
+      const docToInsert = { ...docData, ...(typeof _id === 'string' || _id === undefined ? { _id } : {}) };
+      const result = await collection.insertOne(docToInsert as any);
+      return result as unknown as string;
+    } catch (error) {
+      throw new Error(`Failed to insert document: ${error}`);
+    }
+  }
+
+  static async insertMany(
+    dbName: string,
+    collectionName: string,
+    docs: Document[]
+  ): Promise<string[]> {
+    if (!this.client) throw new Error('Client not connected');
+    try {
+      const db = this.client.db(dbName);
+      const collection = db.collection(collectionName);
+      const cleanedDocs = docs.map(({ _id, ...docData }) => ({
+        ...docData,
+        ...(typeof _id === 'string' || _id === undefined ? { _id } : {})
+      }));
+      const result = await collection.insertMany(cleanedDocs as any);
+      return result as unknown as string[];
+    } catch (error) {
+      throw new Error(`Failed to insert documents: ${error}`);
+    }
+  }
+
+  static async updateMany(
+    dbName: string,
+    collectionName: string,
+    filter: Record<string, any>,
+    update: Record<string, any>
+  ): Promise<number> {
+    if (!this.client) throw new Error('Client not connected');
+    try {
+      const db = this.client.db(dbName);
+      const collection = db.collection(collectionName);
+      const result = await collection.updateMany(filter, update);
+      return result as unknown as number;
+    } catch (error) {
+      throw new Error(`Failed to update documents: ${error}`);
+    }
+  }
+
+  static async deleteMany(
+    dbName: string,
+    collectionName: string,
+    filter: Record<string, any>
+  ): Promise<number> {
+    if (!this.client) throw new Error('Client not connected');
+    try {
+      const db = this.client.db(dbName);
+      const collection = db.collection(collectionName);
+      const result = await collection.deleteMany(filter);
+      return result as unknown as number;
+    } catch (error) {
+      throw new Error(`Failed to delete documents: ${error}`);
+    }
+  }
+
+  static async count(
+    dbName: string,
+    collectionName: string,
+    filter?: Record<string, any>
+  ): Promise<number> {
+    if (!this.client) throw new Error('Client not connected');
+    try {
+      const db = this.client.db(dbName);
+      const collection = db.collection(collectionName);
+      const count = await collection.count(filter || {});
+      return count as unknown as number;
+    } catch (error) {
+      throw new Error(`Failed to count documents: ${error}`);
+    }
+  }
+
+  static async stats(
+    dbName: string,
+    collectionName: string
+  ): Promise<Record<string, any>> {
+    if (!this.client) throw new Error('Client not connected');
+    try {
+      const db = this.client.db(dbName);
+      const collection = db.collection(collectionName);
+      const stats = await collection.stats();
+      return stats as Record<string, any>;
+    } catch (error) {
+      throw new Error(`Failed to get collection stats: ${error}`);
+    }
+  }
+}

package/template/src/lib/utils.ts

@@ -0,0 +1,66 @@
+export function parseConnectionUri(uri: string): {
+  username: string;
+  password: string;
+  host: string;
+  port: number;
+} {
+  const regex = /^lioran:\/\/([^:]+):([^@]+)@([^:]+):(\d+)$/;
+  const match = uri.match(regex);
+
+  if (!match) {
+    throw new Error('Invalid connection URI format. Expected: lioran://username:password@host:port');
+  }
+
+  return {
+    username: match[1],
+    password: match[2],
+    host: match[3],
+    port: parseInt(match[4], 10),
+  };
+}
+
+export function formatConnectionUri(
+  username: string,
+  password: string,
+  host: string,
+  port: number
+): string {
+  return `lioran://${username}:${password}@${host}:${port}`;
+}
+
+export function formatDate(date: Date | string): string {
+  const d = typeof date === 'string' ? new Date(date) : date;
+  return d.toLocaleString();
+}
+
+export function formatBytes(bytes: number): string {
+  if (bytes === 0) return '0 Bytes';
+  const k = 1024;
+  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + ' ' + sizes[i];
+}
+
+export function formatJSON(obj: any, indent: number = 2): string {
+  return JSON.stringify(obj, null, indent);
+}
+
+export function copyToClipboard(text: string): Promise<void> {
+  if (navigator?.clipboard) {
+    return navigator.clipboard.writeText(text);
+  } else {
+    return new Promise((resolve, reject) => {
+      const textarea = document.createElement('textarea');
+      textarea.value = text;
+      document.body.appendChild(textarea);
+      textarea.select();
+      try {
+        document.execCommand('copy');
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+      document.body.removeChild(textarea);
+    });
+  }
+}

package/template/src/store/auth.ts

@@ -0,0 +1,66 @@
+import { create } from 'zustand';
+import { AuthState } from '@/types';
+
+interface AuthStore extends AuthState {
+  setLoggedIn: (loggedIn: boolean, token?: string, uri?: string) => void;
+  setToken: (token: string | null) => void;
+  setConnectionUri: (uri: string | null) => void;
+  setError: (error: string | null) => void;
+  setLoading: (loading: boolean) => void;
+  logout: () => void;
+  loadFromStorage: () => void;
+}
+
+export const useAuthStore = create<AuthStore>((set) => ({
+  isLoggedIn: false,
+  token: null,
+  connectionUri: null,
+  error: null,
+  isLoading: false,
+
+  setLoggedIn: (loggedIn, token, uri) => {
+    set({ isLoggedIn: loggedIn, token, connectionUri: uri });
+    if (loggedIn && token && uri) {
+      if (typeof window !== 'undefined') {
+        localStorage.setItem('liorandb_token', token);
+        localStorage.setItem('liorandb_uri', uri);
+      }
+    }
+  },
+
+  setToken: (token) => set({ token }),
+
+  setConnectionUri: (uri) => set({ connectionUri: uri }),
+
+  setError: (error) => set({ error }),
+
+  setLoading: (loading) => set({ isLoading: loading }),
+
+  logout: () => {
+    set({
+      isLoggedIn: false,
+      token: null,
+      connectionUri: null,
+      error: null,
+    });
+    if (typeof window !== 'undefined') {
+      localStorage.removeItem('liorandb_token');
+      localStorage.removeItem('liorandb_uri');
+    }
+  },
+
+  loadFromStorage: () => {
+    if (typeof window === 'undefined') return;
+    
+    const token = localStorage.getItem('liorandb_token');
+    const uri = localStorage.getItem('liorandb_uri');
+    
+    if (token && uri) {
+      set({
+        isLoggedIn: true,
+        token,
+        connectionUri: uri,
+      });
+    }
+  },
+}));

package/template/src/store/index.ts

@@ -0,0 +1,125 @@
+import { create } from 'zustand';
+import { Database, Collection, Document, QueryResult, StoreState } from '@/types';
+
+interface AppStore extends StoreState {
+  // Auth actions
+  setLoggedIn: (loggedIn: boolean, token?: string, uri?: string) => void;
+  setToken: (token: string | null) => void;
+  setConnectionUri: (uri: string | null) => void;
+  logout: () => void;
+  
+  // Navigation actions
+  setCurrentDatabase: (db: string | null) => void;
+  setSelectedCollection: (col: string | null) => void;
+  
+  // Data actions
+  setDatabases: (databases: Database[]) => void;
+  setCollections: (dbName: string, collections: Collection[]) => void;
+  setDocuments: (documents: Document[]) => void;
+  setQueryResults: (results: QueryResult | null) => void;
+  
+  // UI actions
+  setLoading: (loading: boolean) => void;
+  setError: (error: string | null) => void;
+  setSuccessMessage: (message: string | null) => void;
+  
+  // Storage
+  loadFromStorage: () => void;
+}
+
+export const useAppStore = create<AppStore>((set) => ({
+  // Auth
+  isLoggedIn: false,
+  token: null,
+  connectionUri: null,
+  
+  // Navigation
+  currentDatabase: null,
+  selectedCollection: null,
+  
+  // Data
+  databases: [],
+  collections: {},
+  documents: [],
+  queryResults: null,
+  
+  // UI State
+  isLoading: false,
+  error: null,
+  successMessage: null,
+
+  // Auth actions
+  setLoggedIn: (loggedIn, token, uri) => {
+    set({ isLoggedIn: loggedIn, token, connectionUri: uri });
+    if (loggedIn && token && uri && typeof window !== 'undefined') {
+      localStorage.setItem('liorandb_token', token);
+      localStorage.setItem('liorandb_uri', uri);
+    }
+  },
+
+  setToken: (token) => set({ token }),
+
+  setConnectionUri: (uri) => set({ connectionUri: uri }),
+
+  logout: () => {
+    set({
+      isLoggedIn: false,
+      token: null,
+      connectionUri: null,
+      databases: [],
+      collections: {},
+      documents: [],
+      queryResults: null,
+      currentDatabase: null,
+      selectedCollection: null,
+    });
+    if (typeof window !== 'undefined') {
+      localStorage.removeItem('liorandb_token');
+      localStorage.removeItem('liorandb_uri');
+    }
+  },
+  
+  // Navigation actions
+  setCurrentDatabase: (db) => set({ currentDatabase: db, selectedCollection: null }),
+  
+  setSelectedCollection: (col) => set({ selectedCollection: col }),
+  
+  // Data actions
+  setDatabases: (databases) => set({ databases }),
+  
+  setCollections: (dbName, collections) => {
+    set((state) => ({
+      collections: {
+        ...state.collections,
+        [dbName]: collections,
+      },
+    }));
+  },
+  
+  setDocuments: (documents) => set({ documents }),
+  
+  setQueryResults: (results) => set({ queryResults: results }),
+  
+  // UI actions
+  setLoading: (loading) => set({ isLoading: loading }),
+  
+  setError: (error) => set({ error }),
+  
+  setSuccessMessage: (message) => set({ successMessage: message }),
+  
+  // Storage
+  loadFromStorage: () => {
+    if (typeof window === 'undefined') return;
+    
+    const token = localStorage.getItem('liorandb_token');
+    const uri = localStorage.getItem('liorandb_uri');
+    
+    if (token && uri) {
+      set({
+        isLoggedIn: true,
+        token,
+        connectionUri: uri,
+      });
+    }
+  },
+}));

package/template/src/types/index.ts

@@ -0,0 +1,63 @@
+export interface ConnectionConfig {
+  uri: string;
+  username: string;
+  host: string;
+  port: number;
+}
+
+export interface AuthState {
+  isLoggedIn: boolean;
+  token: string | null;
+  connectionUri: string | null;
+  error: string | null;
+  isLoading: boolean;
+}
+
+export interface Database {
+  name: string;
+  sizeOnDisk?: number;
+  empty?: boolean;
+}
+
+export interface Collection {
+  name: string;
+  type?: string;
+  count?: number;
+}
+
+export interface Document {
+  _id?: string | Record<string, any>;
+  [key: string]: any;
+}
+
+export interface StoredDocument extends Document {
+  _id: string | Record<string, any>;
+}
+
+export interface QueryResult {
+  data: Document[];
+  count: number;
+  executionTime: number;
+}
+
+export interface StoreState {
+  // Auth
+  isLoggedIn: boolean;
+  token: string | null;
+  connectionUri: string | null;
+  
+  // Navigation
+  currentDatabase: string | null;
+  selectedCollection: string | null;
+  
+  // Data
+  databases: Database[];
+  collections: Record<string, Collection[]>;
+  documents: Document[];
+  queryResults: QueryResult | null;
+  
+  // UI State
+  isLoading: boolean;
+  error: string | null;
+  successMessage: string | null;
+}

package/template/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    "**/*.mts"
+  ],
+  "exclude": ["node_modules"]
+}