@c15t/backend 1.8.0 → 2.0.0-rc.1

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

@@ -1,217 +0,0 @@
-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

@@ -1,134 +0,0 @@
-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

@@ -1,134 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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>;