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>;
+  updateUser(id: string, user: Partial<InsertUser>): Promise<User | undefined>;
-  deleteUser(id: number): Promise<boolean>;
+  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>;
+  updateOrganization(id: string, org: Partial<InsertOrganization>): Promise<Organization | undefined>;
-  deleteOrganization(id: number): Promise<boolean>;
+  deleteOrganization(id: string): Promise<boolean>;
   
   // Domain management
-  getDomain(id: number): Promise<Domain | undefined>;
+  getDomain(id: string): Promise<Domain | undefined>;
-  getDomainsByOrganization(organizationId: number): Promise<Domain[]>;
+  getDomainsByOrganization(organizationId: string): Promise<Domain[]>;
   getAllDomains(): Promise<Domain[]>;
   createDomain(domain: InsertDomain): Promise<Domain>;
-  updateDomain(id: number, domain: Partial<InsertDomain>): Promise<Domain | undefined>;
+  updateDomain(id: string, domain: Partial<InsertDomain>): Promise<Domain | undefined>;
-  deleteDomain(id: number): Promise<boolean>;
+  deleteDomain(id: string): Promise<boolean>;
   
   // DNS Record management
-  getDnsRecord(id: number): Promise<DnsRecord | undefined>;
+  getDnsRecord(id: string): Promise<DnsRecord | undefined>;
-  getDnsRecordsByDomain(domainId: number): Promise<DnsRecord[]>;
+  getDnsRecordsByDomain(domainId: string): Promise<DnsRecord[]>;
   createDnsRecord(record: InsertDnsRecord): Promise<DnsRecord>;
-  updateDnsRecord(id: number, record: Partial<InsertDnsRecord>): Promise<DnsRecord | undefined>;
+  updateDnsRecord(id: string, record: Partial<InsertDnsRecord>): Promise<DnsRecord | undefined>;
-  deleteDnsRecord(id: number): Promise<boolean>;
+  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>;
+  updateProvider(id: string, provider: Partial<InsertProvider>): Promise<Provider | undefined>;
-  deleteProvider(id: number): Promise<boolean>;
+  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>;
+  updateApiToken(id: string, token: Partial<InsertApiToken>): Promise<ApiToken | undefined>;
-  deleteApiToken(id: number): Promise<boolean>;
+  deleteApiToken(id: string): Promise<boolean>;
   
   // DNS History
-  addDnsHistory(recordId: number, action: string, previousValue?: string, newValue?: string, userId?: number): Promise<DnsHistory>;
+  addDnsHistory(recordId: string, action: string, previousValue?: string, newValue?: string, userId?: string): Promise<DnsHistory>;
-  getDnsHistoryByRecord(recordId: number): Promise<DnsHistory[]>;
+  getDnsHistoryByRecord(recordId: string): Promise<DnsHistory[]>;
-  getDnsHistoryByDomain(domainId: number): Promise<DnsHistory[]>;
+  getDnsHistoryByDomain(domainId: string): Promise<DnsHistory[]>;
   
   // Session store
   sessionStore: any;

shared/schema.ts

@@ -1,24 +1,24 @@
-import { pgTable, text, serial, integer, boolean, timestamp, jsonb, foreignKey, unique } from "drizzle-orm/pg-core";
+import { pgTable, text, uuid, integer, serial, boolean, timestamp, jsonb, foreignKey, unique } from "drizzle-orm/pg-core";
 import { createInsertSchema } from "drizzle-zod";
 import { z } from "zod";
 import { relations } from "drizzle-orm";
 
 // Users & Authentication
 export const organizations = pgTable("organizations", {
-  id: serial("id").primaryKey(),
+  id: uuid("id").defaultRandom().primaryKey(),
   name: text("name").notNull(),
   isActive: boolean("is_active").default(true).notNull(),
   createdAt: timestamp("created_at").defaultNow().notNull(),
 });
 
 export const users = pgTable("users", {
-  id: serial("id").primaryKey(),
+  id: uuid("id").defaultRandom().primaryKey(),
   username: text("username").notNull().unique(),
   password: text("password").notNull(),
   email: text("email").notNull().unique(),
   fullName: text("full_name"),
   role: text("role").default("user").notNull(),
-  organizationId: integer("organization_id").references(() => organizations.id, { onDelete: "set null" }),
+  organizationId: uuid("organization_id").references(() => organizations.id, { onDelete: "set null" }),
   createdAt: timestamp("created_at").defaultNow().notNull(),
 });
 
@@ -33,7 +33,7 @@ export const usersRelations = relations(users, ({ one }) => ({
 
 // DNS Management
 export const providers = pgTable("providers", {
-  id: serial("id").primaryKey(),
+  id: uuid("id").defaultRandom().primaryKey(),
   name: text("name").notNull(),
   type: text("type").notNull(),
   credentials: jsonb("credentials"),
@@ -42,18 +42,18 @@ export const providers = pgTable("providers", {
 });
 
 export const domains = pgTable("domains", {
-  id: serial("id").primaryKey(),
+  id: uuid("id").defaultRandom().primaryKey(),
   name: text("name").notNull(),
-  organizationId: integer("organization_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+  organizationId: uuid("organization_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
-  providerId: integer("provider_id").notNull().references(() => providers.id, { onDelete: "cascade" }),
+  providerId: uuid("provider_id").notNull().references(() => providers.id, { onDelete: "cascade" }),
   isActive: boolean("is_active").default(true).notNull(),
   lastUpdated: timestamp("last_updated"),
   createdAt: timestamp("created_at").defaultNow().notNull(),
 });
 
 export const dnsRecords = pgTable("dns_records", {
-  id: serial("id").primaryKey(),
+  id: uuid("id").defaultRandom().primaryKey(),
-  domainId: integer("domain_id").notNull().references(() => domains.id, { onDelete: "cascade" }),
+  domainId: uuid("domain_id").notNull().references(() => domains.id, { onDelete: "cascade" }),
   name: text("name").notNull(),
   type: text("type").notNull(),
   content: text("content").notNull(),
@@ -67,23 +67,23 @@ export const dnsRecords = pgTable("dns_records", {
 });
 
 export const dnsHistory = pgTable("dns_history", {
-  id: serial("id").primaryKey(),
+  id: uuid("id").defaultRandom().primaryKey(),
-  recordId: integer("record_id").notNull().references(() => dnsRecords.id, { onDelete: "cascade" }),
+  recordId: uuid("record_id").notNull().references(() => dnsRecords.id, { onDelete: "cascade" }),
   action: text("action").notNull(),
   previousValue: text("previous_value"),
   newValue: text("new_value"),
-  userId: integer("user_id").references(() => users.id, { onDelete: "set null" }),
+  userId: uuid("user_id").references(() => users.id, { onDelete: "set null" }),
   timestamp: timestamp("timestamp").defaultNow().notNull(),
 });
 
 // API Tokens
 export const apiTokens = pgTable("api_tokens", {
-  id: serial("id").primaryKey(),
+  id: uuid("id").defaultRandom().primaryKey(),
   name: text("name").notNull(),
   token: text("token").notNull().unique(),
-  organizationId: integer("organization_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+  organizationId: uuid("organization_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
   permissions: text("permissions").array(),
-  createdBy: integer("created_by").notNull().references(() => users.id, { onDelete: "cascade" }),
+  createdBy: uuid("created_by").notNull().references(() => users.id, { onDelete: "cascade" }),
   isActive: boolean("is_active").default(true).notNull(),
   createdAt: timestamp("created_at").defaultNow().notNull(),
   expiresAt: timestamp("expires_at"),