@c15t/backend 1.5.0 → 1.6.0

package/src/v2/db/registry/utils/generate-id.test.ts

@@ -0,0 +1,217 @@
+import { randomBytes } from 'node:crypto';
+import type { InferFumaDB } from 'fumadb';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { DB } from '~/v2/db/schema';
+import { generateUniqueId } from './generate-id';
+
+type MockDB = ReturnType<InferFumaDB<typeof DB>['orm']>;
+
+// Define regex patterns at the top level for performance
+const SUBJECT_ID_PATTERN = /^sub_[A-Za-z0-9]+$/;
+const CONSENT_ID_PATTERN = /^cns_[A-Za-z0-9]+$/;
+const DOMAIN_ID_PATTERN = /^dom_[A-Za-z0-9]+$/;
+
+describe('generateUniqueId', () => {
+	afterEach(() => {
+		vi.clearAllMocks();
+	});
+
+	// Ensure crypto.getRandomValues exists in Node/Vitest environments
+	// that may not provide a Web Crypto global by default.
+	if (
+		!(globalThis as { crypto?: { getRandomValues?: unknown } }).crypto
+			?.getRandomValues
+	) {
+		(
+			globalThis as {
+				crypto: { getRandomValues: (a: Uint8Array) => Uint8Array };
+			}
+		).crypto = {
+			getRandomValues: (array: Uint8Array) => {
+				const bytes = randomBytes(array.length);
+				array.set(bytes);
+				return array;
+			},
+		};
+	}
+
+	it('should return unique ID on first attempt when no collision exists', async () => {
+		const mockDb = {
+			findFirst: vi.fn().mockResolvedValue(null), // No existing record found
+		} as unknown as MockDB;
+
+		const result = await generateUniqueId(mockDb, 'subject');
+
+		expect(mockDb.findFirst).toHaveBeenCalledTimes(1);
+		expect(mockDb.findFirst).toHaveBeenCalledWith('subject', {
+			where: expect.any(Function),
+		});
+		expect(result).toMatch(SUBJECT_ID_PATTERN); // Should have 'sub_' prefix
+		expect(result.length).toBeGreaterThan(4); // Should be longer than just prefix
+	});
+
+	it('should retry when ID collision occurs and return unique ID on second attempt', async () => {
+		const mockExistingRecord = { id: 'mock_existing' };
+		const mockDb = {
+			findFirst: vi
+				.fn()
+				.mockResolvedValueOnce(mockExistingRecord) // First call returns existing record
+				.mockResolvedValueOnce(null), // Second call returns null (unique)
+		} as unknown as MockDB;
+
+		const result = await generateUniqueId(mockDb, 'consent');
+
+		expect(mockDb.findFirst).toHaveBeenCalledTimes(2);
+		expect(result).toMatch(CONSENT_ID_PATTERN); // Should have 'cns_' prefix
+	});
+
+	it('should handle multiple collisions before finding unique ID', async () => {
+		const mockExistingRecord = { id: 'mock_existing' };
+		const mockDb = {
+			findFirst: vi
+				.fn()
+				.mockResolvedValueOnce(mockExistingRecord) // First collision
+				.mockResolvedValueOnce(mockExistingRecord) // Second collision
+				.mockResolvedValueOnce(mockExistingRecord) // Third collision
+				.mockResolvedValueOnce(null), // Finally unique
+		} as unknown as MockDB;
+
+		const result = await generateUniqueId(mockDb, 'domain');
+
+		expect(mockDb.findFirst).toHaveBeenCalledTimes(4);
+		expect(result).toMatch(DOMAIN_ID_PATTERN); // Should have 'dom_' prefix
+	});
+
+	it('should work with different model types and use correct prefixes', async () => {
+		const mockDb = {
+			findFirst: vi.fn().mockResolvedValue(null),
+		} as unknown as MockDB;
+
+		const testCases = [
+			{ model: 'auditLog' as const, expectedPrefix: 'log_' },
+			{ model: 'consent' as const, expectedPrefix: 'cns_' },
+			{ model: 'consentPolicy' as const, expectedPrefix: 'pol_' },
+			{ model: 'consentPurpose' as const, expectedPrefix: 'pur_' },
+			{ model: 'consentRecord' as const, expectedPrefix: 'rec_' },
+			{ model: 'domain' as const, expectedPrefix: 'dom_' },
+			{ model: 'subject' as const, expectedPrefix: 'sub_' },
+		];
+
+		for (const { model, expectedPrefix } of testCases) {
+			const result = await generateUniqueId(mockDb, model);
+			expect(result).toMatch(
+				new RegExp(
+					`^${expectedPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}[A-Za-z0-9]+$`
+				)
+			);
+		}
+
+		expect(mockDb.findFirst).toHaveBeenCalledTimes(testCases.length);
+	});
+
+	it('should call findFirst with correct where clause function', async () => {
+		const mockDb = {
+			findFirst: vi.fn().mockResolvedValue(null),
+		} as unknown as MockDB;
+
+		await generateUniqueId(mockDb, 'subject');
+
+		const mockFindFirst = vi.mocked(mockDb.findFirst);
+		const [model, options] = mockFindFirst.mock.calls[0] as [
+			string,
+			{ where: (builder: unknown) => void },
+		];
+		expect(mockFindFirst.mock.calls).toHaveLength(1);
+		expect(model).toBe('subject');
+		expect(options).toHaveProperty('where');
+		expect(typeof options.where).toBe('function');
+
+		// Test the where function behavior
+		const mockBuilder = vi.fn();
+		options.where(mockBuilder);
+		expect(mockBuilder).toHaveBeenCalledWith(
+			'id',
+			'=',
+			expect.stringMatching(SUBJECT_ID_PATTERN)
+		);
+	});
+
+	it('should generate different IDs on subsequent calls', async () => {
+		const mockDb = {
+			findFirst: vi.fn().mockResolvedValue(null),
+		} as unknown as MockDB;
+
+		const id1 = await generateUniqueId(mockDb, 'subject');
+		const id2 = await generateUniqueId(mockDb, 'subject');
+		const id3 = await generateUniqueId(mockDb, 'subject');
+
+		expect(id1).not.toBe(id2);
+		expect(id2).not.toBe(id3);
+		expect(id1).not.toBe(id3);
+
+		// All should have the same prefix
+		expect(id1).toMatch(SUBJECT_ID_PATTERN);
+		expect(id2).toMatch(SUBJECT_ID_PATTERN);
+		expect(id3).toMatch(SUBJECT_ID_PATTERN);
+	});
+
+	it('should throw an error when max retries is exceeded', async () => {
+		const mockExistingRecord = { id: 'mock_existing' };
+		const mockLogger = {
+			error: vi.fn(),
+			debug: vi.fn(),
+			info: vi.fn(),
+			success: vi.fn(),
+			warn: vi.fn(),
+		};
+		const mockCtx = { logger: mockLogger };
+
+		const mockDb = {
+			findFirst: vi.fn().mockResolvedValue(mockExistingRecord), // Always return a collision
+		} as unknown as MockDB;
+
+		// Use a small maxRetries value for faster test execution
+		await expect(
+			generateUniqueId(mockDb, 'subject', mockCtx, { maxRetries: 3 })
+		).rejects.toThrow(
+			'Failed to generate unique ID for subject after 3 attempts'
+		);
+
+		// Should have attempted exactly maxRetries times
+		expect(mockDb.findFirst).toHaveBeenCalledTimes(3);
+		expect(mockLogger.error).toHaveBeenCalledWith(
+			'ID generation failed',
+			expect.objectContaining({ model: 'subject', maxRetries: 3 })
+		);
+	});
+
+	it('should respect custom retry options', async () => {
+		const mockExistingRecord = { id: 'mock_existing' };
+		const mockDb = {
+			findFirst: vi
+				.fn()
+				.mockResolvedValueOnce(mockExistingRecord) // First call returns existing record
+				.mockResolvedValueOnce(null), // Second call returns null (unique)
+		} as unknown as MockDB;
+
+		// Mock the setTimeout function directly
+		const originalSetTimeout = global.setTimeout;
+		global.setTimeout = vi.fn((callback) => {
+			// Execute callback immediately
+			callback();
+			return 1; // Return a timeout ID
+		}) as any;
+
+		try {
+			const result = await generateUniqueId(mockDb, 'subject', undefined, {
+				baseDelay: 100,
+			});
+
+			expect(mockDb.findFirst).toHaveBeenCalledTimes(2);
+			expect(result).toMatch(SUBJECT_ID_PATTERN);
+		} finally {
+			// Restore original setTimeout
+			global.setTimeout = originalSetTimeout;
+		}
+	});
+});

package/src/v2/db/registry/utils/generate-id.ts

@@ -0,0 +1,134 @@
+import baseX from 'base-x';
+import type { InferFumaDB } from 'fumadb';
+import type { DB } from '~/v2/db/schema';
+import type { C15TContext } from '~/v2/types';
+
+type Tables = InferFumaDB<typeof DB>['schemas'][-1]['tables'];
+
+const prefixes: Record<keyof Tables, string> = {
+	auditLog: 'log',
+	consent: 'cns',
+	consentPolicy: 'pol',
+	consentPurpose: 'pur',
+	consentRecord: 'rec',
+	domain: 'dom',
+	subject: 'sub',
+} as const;
+
+const b58 = baseX('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');
+
+/**
+ * Creates time-ordered, prefixed, base58-encoded identifiers that:
+ * - Start with the provided prefix for clear identification
+ * - Embed a timestamp for chronological ordering
+ * - Include random data for uniqueness
+ */
+function generateId(model: keyof typeof prefixes): string {
+	const buf = crypto.getRandomValues(new Uint8Array(20));
+	const prefix = prefixes[model];
+
+	const EPOCH_TIMESTAMP = 1_700_000_000_000;
+
+	const t = Date.now() - EPOCH_TIMESTAMP;
+
+	// Use 8 bytes for the timestamp (0..7) and shift accordingly:
+	const high = Math.floor(t / 0x100000000);
+	const low = t >>> 0;
+	buf[0] = (high >>> 24) & 255;
+	buf[1] = (high >>> 16) & 255;
+	buf[2] = (high >>> 8) & 255;
+	buf[3] = high & 255;
+	buf[4] = (low >>> 24) & 255;
+	buf[5] = (low >>> 16) & 255;
+	buf[6] = (low >>> 8) & 255;
+	buf[7] = low & 255;
+
+	return `${prefix}_${b58.encode(buf)}`;
+}
+
+/**
+ * Generates a unique ID for the specified model with conflict handling
+ *
+ * @param db - Database ORM instance
+ * @param model - The model/table name to generate ID for
+ * @param ctx - Application context containing logger (optional)
+ * @param options - Configuration options for ID generation
+ * @returns Promise resolving to a unique ID
+ *
+ * @throws {Error} When max retry attempts are exceeded
+ */
+export async function generateUniqueId(
+	db: ReturnType<InferFumaDB<typeof DB>['orm']>,
+	model: keyof Tables,
+	ctx?: Partial<C15TContext> | undefined,
+	options: {
+		/** Maximum number of retry attempts (default: 10) */
+		maxRetries?: number;
+		/** Current retry attempt (used internally) */
+		attempt?: number;
+		/** Base delay for exponential backoff in ms (default: 5) */
+		baseDelay?: number;
+	} = {}
+): Promise<string> {
+	const { maxRetries = 10, attempt = 0, baseDelay = 5 } = options;
+
+	// Check if we've exceeded the maximum retry attempts
+	if (attempt >= maxRetries) {
+		const error = new Error(
+			`Failed to generate unique ID for ${model} after ${maxRetries} attempts`
+		);
+		ctx?.logger?.error?.('ID generation failed', { model, maxRetries });
+		throw error;
+	}
+
+	const id = generateId(model);
+
+	try {
+		const existing = await db.findFirst(model, {
+			where: (b) => b('id', '=', id),
+		});
+
+		if (existing) {
+			ctx?.logger?.debug?.('ID conflict detected', {
+				id,
+				model,
+				attempt: attempt + 1,
+				maxRetries,
+			});
+
+			// Implement exponential backoff
+			const delay = Math.min(baseDelay * 2 ** attempt, 1000);
+
+			// Wait before retrying to reduce contention in high-volume scenarios
+			await new Promise((resolve) => setTimeout(resolve, delay));
+
+			return generateUniqueId(db, model, ctx, {
+				maxRetries,
+				attempt: attempt + 1,
+				baseDelay,
+			});
+		}
+
+		return id;
+	} catch (error) {
+		ctx?.logger?.error?.('Error checking ID uniqueness', {
+			error: (error as Error).message,
+			model,
+			attempt,
+		});
+
+		// If database error occurs, retry with backoff
+		if (attempt < maxRetries - 1) {
+			const delay = Math.min(baseDelay * 2 ** attempt, 2000);
+			await new Promise((resolve) => setTimeout(resolve, delay));
+
+			return generateUniqueId(db, model, ctx, {
+				maxRetries,
+				attempt: attempt + 1,
+				baseDelay,
+			});
+		}
+
+		throw error;
+	}
+}

package/src/v2/db/registry/utils.ts

@@ -0,0 +1,134 @@
+import baseX from 'base-x';
+import type { InferFumaDB } from 'fumadb';
+import type { DB } from '~/v2/db/schema';
+import type { C15TContext } from '~/v2/types';
+
+type Tables = InferFumaDB<typeof DB>['schemas'][-1]['tables'];
+
+const prefixes: Record<keyof Tables, string> = {
+	auditLog: 'log',
+	consent: 'cns',
+	consentPolicy: 'pol',
+	consentPurpose: 'pur',
+	consentRecord: 'rec',
+	domain: 'dom',
+	subject: 'sub',
+} as const;
+
+const b58 = baseX('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');
+
+/**
+ * Creates time-ordered, prefixed, base58-encoded identifiers that:
+ * - Start with the provided prefix for clear identification
+ * - Embed a timestamp for chronological ordering
+ * - Include random data for uniqueness
+ */
+function generateId(model: keyof typeof prefixes): string {
+	const buf = crypto.getRandomValues(new Uint8Array(20));
+	const prefix = prefixes[model];
+
+	const EPOCH_TIMESTAMP = 1_700_000_000_000;
+
+	const t = Date.now() - EPOCH_TIMESTAMP;
+
+	// Use 8 bytes for the timestamp (0..7) and shift accordingly:
+	const high = Math.floor(t / 0x100000000);
+	const low = t >>> 0;
+	buf[0] = (high >>> 24) & 255;
+	buf[1] = (high >>> 16) & 255;
+	buf[2] = (high >>> 8) & 255;
+	buf[3] = high & 255;
+	buf[4] = (low >>> 24) & 255;
+	buf[5] = (low >>> 16) & 255;
+	buf[6] = (low >>> 8) & 255;
+	buf[7] = low & 255;
+
+	return `${prefix}_${b58.encode(buf)}`;
+}
+
+/**
+ * Generates a unique ID for the specified model with conflict handling
+ *
+ * @param db - Database ORM instance
+ * @param model - The model/table name to generate ID for
+ * @param ctx - Application context containing logger (optional)
+ * @param options - Configuration options for ID generation
+ * @returns Promise resolving to a unique ID
+ *
+ * @throws {Error} When max retry attempts are exceeded
+ */
+export async function generateUniqueId(
+	db: ReturnType<InferFumaDB<typeof DB>['orm']>,
+	model: keyof Tables,
+	ctx?: Partial<C15TContext> | undefined,
+	options: {
+		/** Maximum number of retry attempts (default: 10) */
+		maxRetries?: number;
+		/** Current retry attempt (used internally) */
+		attempt?: number;
+		/** Base delay for exponential backoff in ms (default: 5) */
+		baseDelay?: number;
+	} = {}
+): Promise<string> {
+	const { maxRetries = 10, attempt = 0, baseDelay = 5 } = options;
+
+	// Check if we've exceeded the maximum retry attempts
+	if (attempt >= maxRetries) {
+		const error = new Error(
+			`Failed to generate unique ID for ${model} after ${maxRetries} attempts`
+		);
+		ctx?.logger?.error?.('ID generation failed', { model, maxRetries });
+		throw error;
+	}
+
+	const id = generateId(model);
+
+	try {
+		const existing = await db.findFirst(model, {
+			where: (b) => b('id', '=', id),
+		});
+
+		if (existing) {
+			ctx?.logger?.debug?.('ID conflict detected', {
+				id,
+				model,
+				attempt: attempt + 1,
+				maxRetries,
+			});
+
+			// Implement exponential backoff
+			const delay = Math.min(baseDelay * 2 ** attempt, 1000);
+
+			// Wait before retrying to reduce contention in high-volume scenarios
+			await new Promise((resolve) => setTimeout(resolve, delay));
+
+			return generateUniqueId(db, model, ctx, {
+				maxRetries,
+				attempt: attempt + 1,
+				baseDelay,
+			});
+		}
+
+		return id;
+	} catch (error) {
+		ctx?.logger?.error?.('Error checking ID uniqueness', {
+			error: (error as Error).message,
+			model,
+			attempt,
+		});
+
+		// If database error occurs, retry with backoff
+		if (attempt < maxRetries - 1) {
+			const delay = Math.min(baseDelay * 2 ** attempt, 2000);
+			await new Promise((resolve) => setTimeout(resolve, delay));
+
+			return generateUniqueId(db, model, ctx, {
+				maxRetries,
+				attempt: attempt + 1,
+				baseDelay,
+			});
+		}
+
+		throw error;
+	}
+}

package/src/v2/db/schema/1.0.0/audit-log.ts

@@ -0,0 +1,32 @@
+import { column, idColumn, table } from 'fumadb/schema';
+import { z } from 'zod';
+
+export const auditLogTable = table('auditLog', {
+	id: idColumn('id', 'varchar(255)'),
+	entityType: column('entityType', 'string'),
+	entityId: column('entityId', 'string'),
+	actionType: column('actionType', 'string'),
+	subjectId: column('subjectId', 'string').nullable(),
+	ipAddress: column('ipAddress', 'string').nullable(),
+	userAgent: column('userAgent', 'string').nullable(),
+	changes: column('changes', 'json').nullable(),
+	metadata: column('metadata', 'json').nullable(),
+	createdAt: column('createdAt', 'timestamp').defaultTo$('now'),
+	eventTimezone: column('eventTimezone', 'string').defaultTo$(() => 'UTC'),
+});
+
+export const auditLogSchema = z.object({
+	id: z.string(),
+	entityType: z.string(),
+	entityId: z.string(),
+	actionType: z.string(),
+	subjectId: z.string().optional(),
+	ipAddress: z.string().optional(),
+	userAgent: z.string().optional(),
+	changes: z.record(z.string(), z.unknown()).optional(),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+	createdAt: z.date().prefault(() => new Date()),
+	eventTimezone: z.string().prefault('UTC'),
+});
+
+export type AuditLog = z.infer<typeof auditLogSchema>;

package/src/v2/db/schema/1.0.0/consent-policy.ts

@@ -0,0 +1,41 @@
+import { column, idColumn, table } from 'fumadb/schema';
+import { z } from 'zod';
+
+export const consentPolicyTable = table('consentPolicy', {
+	id: idColumn('id', 'varchar(255)'),
+	version: column('version', 'string'),
+	type: column('type', 'string'),
+	name: column('name', 'string'),
+	effectiveDate: column('effectiveDate', 'timestamp'),
+	expirationDate: column('expirationDate', 'timestamp').nullable(),
+	content: column('content', 'string'),
+	contentHash: column('contentHash', 'string'),
+	isActive: column('isActive', 'bool').defaultTo$(() => true),
+	createdAt: column('createdAt', 'timestamp').defaultTo$('now'),
+});
+
+export const PolicyTypeSchema = z.enum([
+	'cookie_banner',
+	'privacy_policy',
+	'dpa',
+	'terms_and_conditions',
+	'marketing_communications',
+	'age_verification',
+	'other',
+]);
+
+export const consentPolicySchema = z.object({
+	id: z.string(),
+	version: z.string(),
+	type: PolicyTypeSchema,
+	name: z.string(),
+	effectiveDate: z.date(),
+	expirationDate: z.date().nullish(),
+	content: z.string(),
+	contentHash: z.string(),
+	isActive: z.boolean().prefault(true),
+	createdAt: z.date().prefault(() => new Date()),
+});
+
+export type ConsentPolicy = z.infer<typeof consentPolicySchema>;
+export type PolicyType = z.infer<typeof PolicyTypeSchema>;

package/src/v2/db/schema/1.0.0/consent-purpose.ts

@@ -0,0 +1,30 @@
+import { column, idColumn, table } from 'fumadb/schema';
+import { z } from 'zod';
+
+export const consentPurposeTable = table('consentPurpose', {
+	id: idColumn('id', 'varchar(255)'),
+	code: column('code', 'string'),
+	name: column('name', 'string'),
+	description: column('description', 'string'),
+	isEssential: column('isEssential', 'bool'),
+	dataCategory: column('dataCategory', 'string').nullable(),
+	legalBasis: column('legalBasis', 'string').nullable(),
+	isActive: column('isActive', 'bool').defaultTo$(() => true),
+	createdAt: column('createdAt', 'timestamp').defaultTo$('now'),
+	updatedAt: column('updatedAt', 'timestamp').defaultTo$('now'),
+});
+
+export const consentPurposeSchema = z.object({
+	id: z.string(),
+	code: z.string(),
+	name: z.string(),
+	description: z.string(),
+	isEssential: z.boolean(),
+	dataCategory: z.string().nullish(),
+	legalBasis: z.string().nullish(),
+	isActive: z.boolean().prefault(true),
+	createdAt: z.date().prefault(() => new Date()),
+	updatedAt: z.date().prefault(() => new Date()),
+});
+
+export type ConsentPurpose = z.infer<typeof consentPurposeSchema>;

package/src/v2/db/schema/1.0.0/consent-record.ts

@@ -0,0 +1,22 @@
+import { column, idColumn, table } from 'fumadb/schema';
+import { z } from 'zod';
+
+export const consentRecordTable = table('consentRecord', {
+	id: idColumn('id', 'varchar(255)'),
+	subjectId: column('subjectId', 'string'),
+	consentId: column('consentId', 'string').nullable(),
+	actionType: column('actionType', 'string'),
+	details: column('details', 'json').nullable(),
+	createdAt: column('createdAt', 'timestamp').defaultTo$('now'),
+});
+
+export const consentRecordSchema = z.object({
+	id: z.string(),
+	subjectId: z.string(),
+	consentId: z.string().nullish(),
+	actionType: z.string(),
+	details: z.record(z.string(), z.unknown()).nullish(),
+	createdAt: z.date().prefault(() => new Date()),
+});
+
+export type ConsentRecord = z.infer<typeof consentRecordSchema>;

package/src/v2/db/schema/1.0.0/consent.ts

@@ -0,0 +1,38 @@
+import { column, idColumn, table } from 'fumadb/schema';
+import { z } from 'zod';
+
+export const consentTable = table('consent', {
+	id: idColumn('id', 'varchar(255)'),
+	subjectId: column('subjectId', 'string'),
+	domainId: column('domainId', 'string'),
+	policyId: column('policyId', 'string').nullable(),
+	purposeIds: column('purposeIds', 'json'),
+	metadata: column('metadata', 'json').nullable(),
+	ipAddress: column('ipAddress', 'string').nullable(),
+	userAgent: column('userAgent', 'string').nullable(),
+	status: column('status', 'string').defaultTo$(() => 'active'),
+	withdrawalReason: column('withdrawalReason', 'string').nullable(),
+	givenAt: column('givenAt', 'timestamp').defaultTo$('now'),
+	validUntil: column('validUntil', 'timestamp').nullable(),
+	isActive: column('isActive', 'bool').defaultTo$(() => true),
+});
+
+export const consentStatusSchema = z.enum(['active', 'withdrawn', 'expired']);
+
+export const consentSchema = z.object({
+	id: z.string(),
+	subjectId: z.string(),
+	domainId: z.string(),
+	purposeIds: z.array(z.string()),
+	metadata: z.record(z.string(), z.unknown()).nullish(),
+	policyId: z.string().optional(),
+	ipAddress: z.string().nullish(),
+	userAgent: z.string().nullish(),
+	status: consentStatusSchema.prefault('active'),
+	withdrawalReason: z.string().nullish(),
+	givenAt: z.date().prefault(() => new Date()),
+	validUntil: z.date().nullish(),
+	isActive: z.boolean().prefault(true),
+});
+
+export type Consent = z.infer<typeof consentSchema>;

package/src/v2/db/schema/1.0.0/domain.ts

@@ -0,0 +1,26 @@
+import { column, idColumn, table } from 'fumadb/schema';
+import { z } from 'zod';
+
+export const domainTable = table('domain', {
+	id: idColumn('id', 'varchar(255)'),
+	name: column('name', 'string').unique(),
+	description: column('description', 'string').nullable(),
+	allowedOrigins: column('allowedOrigins', 'json').nullable(),
+	isVerified: column('isVerified', 'bool').defaultTo$(() => true),
+	isActive: column('isActive', 'bool').defaultTo$(() => true),
+	createdAt: column('createdAt', 'timestamp').defaultTo$('now'),
+	updatedAt: column('updatedAt', 'timestamp').defaultTo$('now'),
+});
+
+export const domainSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	description: z.string().nullish(),
+	allowedOrigins: z.array(z.string()).nullish(),
+	isVerified: z.boolean().prefault(true),
+	isActive: z.boolean().prefault(true),
+	createdAt: z.date().prefault(() => new Date()),
+	updatedAt: z.date().prefault(() => new Date()),
+});
+
+export type Domain = z.infer<typeof domainSchema>;