Skip to content

armgit / crm

Public Imported from GitHub
0

Comp AI CRM is an open source, CRM designed for AI agents. Agentic-first CRM.

TypeScript
7.9 KB
Raw Blame
import {
	columnFor,
	FieldValueError,
	type FieldValueJson,
	type FieldValueWrite,
	recordColumn,
	typeLabel,
} from "./fields-shape";
import { Prisma } from "./generated/prisma/client";
import type { FieldEntity, FieldType } from "./generated/prisma/enums";
import type {
	FieldDefinitionModel,
	FieldOptionModel,
	FieldValueModel,
} from "./generated/prisma/models";

export * from "./fields-shape";

export type FieldDefinitionWithOptions = FieldDefinitionModel & {
	options: FieldOptionModel[];
};

export type SerializedFieldOption = {
	id: string;
	label: string;
	position: number;
};

export type SerializedField = {
	id: string;
	entity: FieldEntity;
	key: string;
	label: string;
	type: FieldType;
	typeLabel: string;
	agentFilled: boolean;
	agentBrief: string | null;
	required: boolean;
	showOnSheet: boolean;
	showOnTable: boolean;
	showOnFilter: boolean;
	position: number;
	archived: boolean;
	options: SerializedFieldOption[];
};

export function serializeField(
	definition: FieldDefinitionWithOptions,
): SerializedField {
	return {
		id: definition.id,
		entity: definition.entity,
		key: definition.key,
		label: definition.label,
		type: definition.type,
		typeLabel: typeLabel(definition.type),
		agentFilled: definition.agentFilled,
		agentBrief: definition.agentBrief,
		required: definition.required,
		showOnSheet: definition.showOnSheet,
		showOnTable: definition.showOnTable,
		showOnFilter: definition.showOnFilter,
		position: definition.position,
		archived: definition.archivedAt !== null,
		options: definition.options
			.filter((option) => option.archivedAt === null)
			.sort((left, right) => left.position - right.position)
			.map((option) => ({
				id: option.id,
				label: option.label,
				position: option.position,
			})),
	};
}

export function serializeFieldFor(
	definition: FieldDefinitionWithOptions,
	value: FieldValueJson,
): SerializedField {
	const field = serializeField(definition);

	if (definition.type !== "SELECT" || typeof value !== "string") return field;
	if (field.options.some((option) => option.id === value)) return field;

	const retired = definition.options.find((option) => option.id === value);
	if (!retired) return field;

	return {
		...field,
		options: [
			...field.options,
			{ id: retired.id, label: retired.label, position: retired.position },
		].sort((left, right) => left.position - right.position),
	};
}

const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
const ISO_DATE_TIME =
	/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d{1,3})?)?(Z|[+-]\d{2}:\d{2})?$/;

export function coerceValue(
	definition: FieldDefinitionWithOptions,
	input: unknown,
): FieldValueWrite {
	const blank =
		input === null ||
		input === undefined ||
		(typeof input === "string" && input.trim() === "");

	if (blank) {
		if (definition.required) {
			throw new FieldValueError(
				definition.key,
				`${definition.label} cannot be empty.`,
			);
		}

		return { [columnFor(definition.type)]: null };
	}

	switch (definition.type) {
		case "CHECKBOX": {
			if (typeof input === "boolean") return { bool: input };
			if (input === "true" || input === "false") {
				return { bool: input === "true" };
			}
			throw new FieldValueError(
				definition.key,
				`${definition.label} takes true or false.`,
			);
		}

		case "NUMBER": {
			const parsed =
				typeof input === "number" ? input : Number(String(input).trim());

			if (!Number.isFinite(parsed)) {
				throw new FieldValueError(
					definition.key,
					`${definition.label} takes a number.`,
				);
			}

			return { number: new Prisma.Decimal(parsed) };
		}

		case "DATE": {
			const raw = String(input).trim();
			const dateOnly = ISO_DATE.test(raw);

			if (!dateOnly && !ISO_DATE_TIME.test(raw)) {
				throw new FieldValueError(
					definition.key,
					`${definition.label} takes a date like 2027-03-31.`,
				);
			}

			const parsed = new Date(dateOnly ? `${raw}T00:00:00.000Z` : raw);

			if (Number.isNaN(parsed.getTime())) {
				throw new FieldValueError(
					definition.key,
					`${definition.label} takes a date like 2027-03-31.`,
				);
			}

			return { date: parsed };
		}

		case "SELECT": {
			const raw = String(input).trim();
			const option = definition.options.find(
				(entry) =>
					entry.archivedAt === null &&
					(entry.id === raw || entry.label.toLowerCase() === raw.toLowerCase()),
			);

			if (!option) {
				throw new FieldValueError(
					definition.key,
					`${definition.label} has no option "${raw}".`,
				);
			}

			return { optionId: option.id };
		}

		case "USER":
			return { userId: String(input).trim() };

		default:
			return { text: String(input).trim() };
	}
}

export function readValue(
	definition: FieldDefinitionWithOptions,
	row: FieldValueModel | undefined,
): FieldValueJson {
	if (!row) return null;

	switch (definition.type) {
		case "CHECKBOX":
			return row.bool ?? null;
		case "NUMBER":
			return row.number === null ? null : Number(row.number);
		case "DATE":
			return row.date === null ? null : row.date.toISOString();
		case "SELECT":
			return row.optionId ?? null;
		case "USER":
			return row.userId ?? null;
		default:
			return row.text ?? null;
	}
}

export type RecordField = SerializedField & { value: FieldValueJson };

export function attachValues(
	definitions: FieldDefinitionWithOptions[],
	rows: FieldValueModel[],
): RecordField[] {
	const byField = new Map(rows.map((row) => [row.fieldId, row]));

	return definitions
		.filter((definition) => definition.archivedAt === null)
		.sort((left, right) => left.position - right.position)
		.map((definition) => {
			const value = readValue(definition, byField.get(definition.id));

			return { ...serializeFieldFor(definition, value), value };
		});
}

export type FieldWriter = {
	fieldValue: {
		deleteMany(args: { where: Record<string, unknown> }): Promise<unknown>;
		upsert(args: {
			where: Record<string, unknown>;
			create: Record<string, unknown>;
			update: Record<string, unknown>;
		}): Promise<unknown>;
	};
	user: {
		findMany(args: {
			where: { id: { in: string[] } };
			select: { id: true };
		}): Promise<{ id: string }[]>;
	};
};

export async function writeValues(
	tx: FieldWriter,
	entity: FieldEntity,
	recordId: string,
	definitions: FieldDefinitionWithOptions[],
	values: Record<string, unknown>,
): Promise<void> {
	const column = recordColumn(entity);
	const byKey = new Map(
		definitions
			.filter((definition) => definition.archivedAt === null)
			.map((definition) => [definition.key, definition]),
	);

	const writes = Object.entries(values).map(([key, input]) => {
		const definition = byKey.get(key);

		if (!definition) {
			throw new FieldValueError(key, `There is no field called "${key}".`);
		}

		const data = coerceValue(definition, input);

		return { definition, data, stored: data[columnFor(definition.type)] };
	});

	await assertUsersExist(tx, writes);

	for (const { definition, data, stored } of writes) {
		if (stored === null || stored === undefined) {
			await tx.fieldValue.deleteMany({
				where: { fieldId: definition.id, [column]: recordId },
			});
			continue;
		}

		await tx.fieldValue.upsert({
			where: {
				[`fieldId_${column}`]: { fieldId: definition.id, [column]: recordId },
			},
			create: { fieldId: definition.id, [column]: recordId, ...data },
			update: data,
		});
	}
}

type PendingWrite = {
	definition: FieldDefinitionWithOptions;
	stored: unknown;
};

async function assertUsersExist(
	tx: FieldWriter,
	writes: PendingWrite[],
): Promise<void> {
	const wanted = writes.filter(
		(write): write is PendingWrite & { stored: string } =>
			write.definition.type === "USER" && typeof write.stored === "string",
	);

	if (wanted.length === 0) return;

	const known = await tx.user.findMany({
		where: { id: { in: [...new Set(wanted.map((write) => write.stored))] } },
		select: { id: true },
	});

	const found = new Set(known.map((row) => row.id));

	for (const write of wanted) {
		if (!found.has(write.stored)) {
			throw new FieldValueError(
				write.definition.key,
				`${write.definition.label} takes someone who works here.`,
			);
		}
	}
}