dokploy/apps/dokploy/server/db/schema/domain.ts

import { domain } from "@/server/db/validations/domain";
import { relations } from "drizzle-orm";
import {
	boolean,
	integer,
	pgEnum,
	pgTable,
	serial,
	text,
} from "drizzle-orm/pg-core";
import { createInsertSchema } from "drizzle-zod";
import { nanoid } from "nanoid";
import { applications } from "./application";
import { compose } from "./compose";
import { certificateType } from "./shared";

export const domainType = pgEnum("domainType", ["compose", "application"]);

export const domains = pgTable("domain", {
	domainId: text("domainId")
		.notNull()
		.primaryKey()
		.$defaultFn(() => nanoid()),
	host: text("host").notNull(),
	https: boolean("https").notNull().default(false),
	port: integer("port").default(80),
	path: text("path").default("/"),
	serviceName: text("serviceName"),
	domainType: domainType("domainType").default("application"),
	uniqueConfigKey: serial("uniqueConfigKey"),
	createdAt: text("createdAt")
		.notNull()
		.$defaultFn(() => new Date().toISOString()),
	composeId: text("composeId").references(() => compose.composeId, {
		onDelete: "cascade",
	}),
	applicationId: text("applicationId").references(
		() => applications.applicationId,
		{ onDelete: "cascade" },
	),
	certificateType: certificateType("certificateType").notNull().default("none"),
});

export const domainsRelations = relations(domains, ({ one }) => ({
	application: one(applications, {
		fields: [domains.applicationId],
		references: [applications.applicationId],
	}),
	compose: one(compose, {
		fields: [domains.composeId],
		references: [compose.composeId],
	}),
}));

const createSchema = createInsertSchema(domains, domain._def.schema.shape);

export const apiCreateDomain = createSchema.pick({
	host: true,
	path: true,
	port: true,
	https: true,
	applicationId: true,
	certificateType: true,
	composeId: true,
	serviceName: true,
	domainType: true,
});

export const apiFindDomain = createSchema
	.pick({
		domainId: true,
	})
	.required();

export const apiFindDomainByApplication = createSchema.pick({
	applicationId: true,
});

export const apiFindDomainByCompose = createSchema.pick({
	composeId: true,
});

export const apiUpdateDomain = createSchema
	.pick({
		host: true,
		path: true,
		port: true,
		https: true,
		certificateType: true,
		serviceName: true,
		domainType: true,
	})
	.merge(createSchema.pick({ domainId: true }).required());