Update database schema to use UUIDs for primary keys

Replit-Commit-Author: Agent
Replit-Commit-Session-Id: 9111ef36-26c8-4085-84ca-a35dc1fec1b5
Replit-Commit-Screenshot-Url: https://storage.googleapis.com/screenshot-production-us-central1/7083d608-d6d3-4a6a-9a27-6286c5109627/2d60e220-6e66-45ed-adb2-9f8462e97fd7.jpg

server/database-storage.ts

@@ -29,7 +29,7 @@ export class DatabaseStorage implements IStorage {
   }
 
   // User management
-  async getUser(id: number): Promise<User | undefined> {
+  async getUser(id: string): Promise<User | undefined> {
     const [user] = await db.select().from(users).where(eq(users.id, id));
     return user;
   }
@@ -49,7 +49,7 @@ export class DatabaseStorage implements IStorage {
     return newUser;
   }
 
-  async updateUser(id: number, userData: Partial<InsertUser>): Promise<User | undefined> {
+  async updateUser(id: string, userData: Partial<InsertUser>): Promise<User | undefined> {
     const [updatedUser] = await db.update(users)
       .set(userData)
       .where(eq(users.id, id))
@@ -57,13 +57,13 @@ export class DatabaseStorage implements IStorage {
     return updatedUser;
   }
 
-  async deleteUser(id: number): Promise<boolean> {
+  async deleteUser(id: string): Promise<boolean> {
     const result = await db.delete(users).where(eq(users.id, id)).returning();
     return result.length > 0;
   }
 
   // Organization management
-  async getOrganization(id: number): Promise<Organization | undefined> {
+  async getOrganization(id: string): Promise<Organization | undefined> {
     const [org] = await db.select().from(organizations).where(eq(organizations.id, id));
     return org;
   }
@@ -77,7 +77,7 @@ export class DatabaseStorage implements IStorage {
     return newOrg;
   }
 
-  async updateOrganization(id: number, orgData: Partial<InsertOrganization>): Promise<Organization | undefined> {
+  async updateOrganization(id: string, orgData: Partial<InsertOrganization>): Promise<Organization | undefined> {
     const [updatedOrg] = await db.update(organizations)
       .set(orgData)
       .where(eq(organizations.id, id))
@@ -85,18 +85,18 @@ export class DatabaseStorage implements IStorage {
     return updatedOrg;
   }
 
-  async deleteOrganization(id: number): Promise<boolean> {
+  async deleteOrganization(id: string): Promise<boolean> {
     const result = await db.delete(organizations).where(eq(organizations.id, id)).returning();
     return result.length > 0;
   }
 
   // Domain management
-  async getDomain(id: number): Promise<Domain | undefined> {
+  async getDomain(id: string): Promise<Domain | undefined> {
     const [domain] = await db.select().from(domains).where(eq(domains.id, id));
     return domain;
   }
 
-  async getDomainsByOrganization(organizationId: number): Promise<Domain[]> {
+  async getDomainsByOrganization(organizationId: string): Promise<Domain[]> {
     return await db.select()
       .from(domains)
       .where(eq(domains.organizationId, organizationId));

server/storage.ts

@@ -12,54 +12,54 @@ import { DatabaseStorage } from "./database-storage";
 
 export interface IStorage {
   // User management
-  getUser(id: number): Promise<User | undefined>;
+  getUser(id: string): Promise<User | undefined>;
   getUserByUsername(username: string): Promise<User | undefined>;
   getUserByEmail(email: string): Promise<User | undefined>;
   createUser(user: InsertUser): Promise<User>;
-  updateUser(id: number, user: Partial<InsertUser>): Promise<User | undefined>;
-  deleteUser(id: number): Promise<boolean>;
+  updateUser(id: string, user: Partial<InsertUser>): Promise<User | undefined>;
+  deleteUser(id: string): Promise<boolean>;
   
   // Organization management
-  getOrganization(id: number): Promise<Organization | undefined>;
+  getOrganization(id: string): Promise<Organization | undefined>;
   getOrganizations(): Promise<Organization[]>;
   createOrganization(org: InsertOrganization): Promise<Organization>;
-  updateOrganization(id: number, org: Partial<InsertOrganization>): Promise<Organization | undefined>;
-  deleteOrganization(id: number): Promise<boolean>;
+  updateOrganization(id: string, org: Partial<InsertOrganization>): Promise<Organization | undefined>;
+  deleteOrganization(id: string): Promise<boolean>;
   
   // Domain management
-  getDomain(id: number): Promise<Domain | undefined>;
-  getDomainsByOrganization(organizationId: number): Promise<Domain[]>;
+  getDomain(id: string): Promise<Domain | undefined>;
+  getDomainsByOrganization(organizationId: string): Promise<Domain[]>;
   getAllDomains(): Promise<Domain[]>;
   createDomain(domain: InsertDomain): Promise<Domain>;
-  updateDomain(id: number, domain: Partial<InsertDomain>): Promise<Domain | undefined>;
-  deleteDomain(id: number): Promise<boolean>;
+  updateDomain(id: string, domain: Partial<InsertDomain>): Promise<Domain | undefined>;
+  deleteDomain(id: string): Promise<boolean>;
   
   // DNS Record management
-  getDnsRecord(id: number): Promise<DnsRecord | undefined>;
-  getDnsRecordsByDomain(domainId: number): Promise<DnsRecord[]>;
+  getDnsRecord(id: string): Promise<DnsRecord | undefined>;
+  getDnsRecordsByDomain(domainId: string): Promise<DnsRecord[]>;
   createDnsRecord(record: InsertDnsRecord): Promise<DnsRecord>;
-  updateDnsRecord(id: number, record: Partial<InsertDnsRecord>): Promise<DnsRecord | undefined>;
-  deleteDnsRecord(id: number): Promise<boolean>;
+  updateDnsRecord(id: string, record: Partial<InsertDnsRecord>): Promise<DnsRecord | undefined>;
+  deleteDnsRecord(id: string): Promise<boolean>;
   
   // Provider management
-  getProvider(id: number): Promise<Provider | undefined>;
+  getProvider(id: string): Promise<Provider | undefined>;
   getProviders(): Promise<Provider[]>;
   createProvider(provider: InsertProvider): Promise<Provider>;
-  updateProvider(id: number, provider: Partial<InsertProvider>): Promise<Provider | undefined>;
-  deleteProvider(id: number): Promise<boolean>;
+  updateProvider(id: string, provider: Partial<InsertProvider>): Promise<Provider | undefined>;
+  deleteProvider(id: string): Promise<boolean>;
   
   // API Token management
-  getApiToken(id: number): Promise<ApiToken | undefined>;
+  getApiToken(id: string): Promise<ApiToken | undefined>;
   getApiTokenByToken(token: string): Promise<ApiToken | undefined>;
-  getApiTokensByOrganization(organizationId: number): Promise<ApiToken[]>;
+  getApiTokensByOrganization(organizationId: string): Promise<ApiToken[]>;
   createApiToken(token: InsertApiToken): Promise<ApiToken>;
-  updateApiToken(id: number, token: Partial<InsertApiToken>): Promise<ApiToken | undefined>;
-  deleteApiToken(id: number): Promise<boolean>;
+  updateApiToken(id: string, token: Partial<InsertApiToken>): Promise<ApiToken | undefined>;
+  deleteApiToken(id: string): Promise<boolean>;
   
   // DNS History
-  addDnsHistory(recordId: number, action: string, previousValue?: string, newValue?: string, userId?: number): Promise<DnsHistory>;
-  getDnsHistoryByRecord(recordId: number): Promise<DnsHistory[]>;
-  getDnsHistoryByDomain(domainId: number): Promise<DnsHistory[]>;
+  addDnsHistory(recordId: string, action: string, previousValue?: string, newValue?: string, userId?: string): Promise<DnsHistory>;
+  getDnsHistoryByRecord(recordId: string): Promise<DnsHistory[]>;
+  getDnsHistoryByDomain(domainId: string): Promise<DnsHistory[]>;
   
   // Session store
   sessionStore: any;