@agent-native/core 0.101.14 → 0.102.1

package/corpus/templates/tasks/server/custom-fields/store.ts

@@ -0,0 +1,425 @@
+import { and, asc, eq, inArray, max } from "drizzle-orm";
+
+import { caseById, chunk } from "../db/bulk-write.js";
+import { getDb } from "../db/index.js";
+import { createRecordId, timestamp } from "../db/record-utils.js";
+import { customFields } from "../db/schema.js";
+import type { DbHandle } from "../db/transaction.js";
+import { NotFoundError, UserInputError } from "../errors.js";
+import { requireUserEmail } from "../stored-items/store.js";
+import { removeTaskCardFieldId } from "../user-config/store.js";
+import {
+  canonicalizeFieldConfig,
+  isEmptyFieldValue,
+  normalizeFieldConfigInput,
+  normalizeFieldTitle,
+} from "./normalize.js";
+import {
+  parseFieldType,
+  parseFieldConfigShape,
+  parseField,
+  parseFieldValueShape,
+} from "./parse.js";
+import type {
+  FieldConfigInput,
+  FieldDefinition,
+  FieldType,
+  FieldValue,
+} from "./types.js";
+import { validateFieldConfig, validateFieldTitle } from "./validate.js";
+import {
+  deleteCustomFieldValues,
+  deleteCustomFieldValuesByFieldIds,
+  listCustomFieldValues,
+  updateCustomFieldValues,
+} from "./values/store.js";
+
+export { requireUserEmail };
+export type {
+  FieldConfig,
+  FieldDefinition,
+  FieldType,
+  FieldValue,
+  FieldValueInput,
+  SelectColorToken,
+  SelectOption,
+} from "./types.js";
+export type {
+  CurrencyConfigInput,
+  EmptyConfigInput,
+  FieldConfigInput,
+  NumericConfigInput,
+  PercentConfigInput,
+  SelectConfigInput,
+  SelectOptionInput,
+} from "./types.js";
+export { FIELD_TYPES, SELECT_COLOR_TOKENS } from "./types.js";
+export {
+  createCustomFieldActionSchema,
+  fieldConfigShapeSchema,
+  fieldValueInputSchema,
+  updateCustomFieldConfigActionSchema,
+} from "./schema.js";
+
+const SORT_GAP = 1000;
+
+export async function createCustomField(
+  input: {
+    ownerEmail: string;
+    title: string;
+    type: FieldType;
+    config?: unknown;
+    now?: string;
+  },
+  db: DbHandle = getDb(),
+): Promise<FieldDefinition> {
+  const createdAt = timestamp(input.now);
+  const type = parseFieldType(input.type);
+  validateFieldTitle(input.title);
+  const field = {
+    id: createRecordId("fld"),
+    title: normalizeFieldTitle(input.title),
+    type,
+    configJson: serializeFieldConfig(type, input.config),
+    sortOrder: await nextSortOrder(input.ownerEmail),
+    ownerEmail: input.ownerEmail,
+    createdAt,
+    updatedAt: createdAt,
+  };
+
+  await db.insert(customFields).values(field);
+  const created = await getCustomField({
+    ownerEmail: input.ownerEmail,
+    fieldId: field.id,
+  });
+  if (!created) throw new Error("Failed to create custom field.");
+  return created;
+}
+
+export async function getCustomField(
+  input: {
+    ownerEmail: string;
+    fieldId: string;
+  },
+  db: DbHandle = getDb(),
+): Promise<FieldDefinition | null> {
+  const [row] = await db
+    .select()
+    .from(customFields)
+    .where(
+      and(
+        eq(customFields.ownerEmail, input.ownerEmail),
+        eq(customFields.id, input.fieldId),
+      ),
+    )
+    .limit(1);
+  return row ? parseField(row) : null;
+}
+
+export async function listCustomFields(
+  input: {
+    ownerEmail: string;
+    fieldIds?: string[];
+  },
+  db: DbHandle = getDb(),
+): Promise<{ fields: FieldDefinition[] }> {
+  const fieldIds = input.fieldIds ? [...new Set(input.fieldIds)] : undefined;
+  if (fieldIds?.length === 0) return { fields: [] };
+
+  const conditions = [eq(customFields.ownerEmail, input.ownerEmail)];
+  if (fieldIds) conditions.push(inArray(customFields.id, fieldIds));
+
+  const rows = await db
+    .select()
+    .from(customFields)
+    .where(and(...conditions))
+    .orderBy(asc(customFields.sortOrder), asc(customFields.createdAt));
+  return { fields: rows.map(parseField) };
+}
+
+/**
+ * Title and config are per-field, so the bulk form takes one entry per field
+ * rather than a single patch applied across ids.
+ */
+export async function updateCustomFields(
+  input: {
+    ownerEmail: string;
+    entries: Array<{ fieldId: string; title?: string; config?: unknown }>;
+    now?: string;
+  },
+  db: DbHandle = getDb(),
+): Promise<FieldDefinition[]> {
+  if (input.entries.length === 0) return [];
+
+  const { fields: existing } = await listCustomFields(
+    {
+      ownerEmail: input.ownerEmail,
+      fieldIds: input.entries.map((entry) => entry.fieldId),
+    },
+    db,
+  );
+  const existingById = new Map(existing.map((field) => [field.id, field]));
+
+  const patches = input.entries.map((entry) => {
+    const field = existingById.get(entry.fieldId);
+    if (!field) throw new NotFoundError("Custom field not found.");
+
+    if (entry.title === undefined && entry.config === undefined) {
+      return { field, patch: null };
+    }
+
+    const patch: Partial<typeof customFields.$inferInsert> = {
+      updatedAt: timestamp(input.now),
+    };
+    if (entry.title !== undefined) {
+      validateFieldTitle(entry.title);
+      patch.title = normalizeFieldTitle(entry.title);
+    }
+    if (entry.config !== undefined) {
+      patch.configJson = serializeFieldConfig(field.type, entry.config);
+    }
+    return { field, patch, cleanup: entry.config !== undefined };
+  });
+
+  return db.transaction(async (tx) => {
+    const updated: FieldDefinition[] = [];
+
+    for (const { field, patch, cleanup } of patches) {
+      if (!patch) {
+        updated.push(field);
+        continue;
+      }
+
+      await tx
+        .update(customFields)
+        .set(patch)
+        .where(
+          and(
+            eq(customFields.ownerEmail, input.ownerEmail),
+            eq(customFields.id, field.id),
+          ),
+        );
+
+      const [updatedRow] = await tx
+        .select()
+        .from(customFields)
+        .where(
+          and(
+            eq(customFields.ownerEmail, input.ownerEmail),
+            eq(customFields.id, field.id),
+          ),
+        )
+        .limit(1);
+      if (!updatedRow) throw new NotFoundError("Custom field not found.");
+
+      const parsed = parseField(updatedRow);
+      if (cleanup) {
+        await cleanupValuesAfterConfigChange(parsed, tx);
+      }
+      updated.push(parsed);
+    }
+
+    return updated;
+  });
+}
+
+export async function updateCustomField(
+  input: {
+    ownerEmail: string;
+    fieldId: string;
+    title?: string;
+    config?: unknown;
+    now?: string;
+  },
+  db: DbHandle = getDb(),
+): Promise<FieldDefinition> {
+  const [field] = await updateCustomFields(
+    {
+      ownerEmail: input.ownerEmail,
+      entries: [
+        { fieldId: input.fieldId, title: input.title, config: input.config },
+      ],
+      now: input.now,
+    },
+    db,
+  );
+  if (!field) throw new NotFoundError("Custom field not found.");
+  return field;
+}
+
+async function cleanupValuesAfterConfigChange(
+  field: FieldDefinition,
+  db: DbHandle,
+): Promise<void> {
+  if (field.type !== "single_select" && field.type !== "multi_select") return;
+  const allowed = new Set(selectOptionIds(field));
+  const rows = await listCustomFieldValues(
+    { ownerEmail: field.ownerEmail, fieldIds: [field.id] },
+    db,
+  );
+
+  const staleIds: string[] = [];
+  const trimmed: Array<{ id: string; value: FieldValue }> = [];
+
+  for (const row of rows) {
+    // Read the raw shape rather than `parseStoredValue`: that validates against
+    // the new config and throws on exactly the removed options this cleans up.
+    const value = parseFieldValueShape(JSON.parse(row.valueJson));
+    if (isEmptyFieldValue(value)) {
+      staleIds.push(row.id);
+      continue;
+    }
+    if (field.type === "single_select") {
+      if (typeof value !== "string" || !allowed.has(value)) {
+        staleIds.push(row.id);
+      }
+      continue;
+    }
+
+    const nextValue = Array.isArray(value)
+      ? value.filter(
+          (optionId): optionId is string =>
+            typeof optionId === "string" && allowed.has(optionId),
+        )
+      : [];
+    if (nextValue.length === 0) {
+      staleIds.push(row.id);
+    } else if (!Array.isArray(value) || nextValue.length !== value.length) {
+      trimmed.push({ id: row.id, value: nextValue });
+    }
+  }
+
+  await deleteCustomFieldValues(
+    { ownerEmail: field.ownerEmail, ids: staleIds },
+    db,
+  );
+  await updateCustomFieldValues(
+    { ownerEmail: field.ownerEmail, entries: trimmed },
+    db,
+  );
+}
+
+function selectOptionIds(field: FieldDefinition) {
+  return field.type === "single_select" || field.type === "multi_select"
+    ? field.config.options.map((option) => option.id)
+    : [];
+}
+
+export async function deleteCustomFields(
+  input: {
+    ownerEmail: string;
+    fieldIds: string[];
+  },
+  db: DbHandle = getDb(),
+): Promise<{ ok: true; deletedValues: number }> {
+  const fieldIds = [...new Set(input.fieldIds)];
+  if (fieldIds.length === 0) return { ok: true, deletedValues: 0 };
+
+  const { fields: existing } = await listCustomFields(
+    { ownerEmail: input.ownerEmail, fieldIds },
+    db,
+  );
+  if (existing.length !== fieldIds.length) {
+    throw new NotFoundError("Custom field not found.");
+  }
+
+  const { deletedValues } = await db.transaction(async (tx) => {
+    const result = await deleteCustomFieldValuesByFieldIds(
+      { ownerEmail: input.ownerEmail, fieldIds },
+      tx,
+    );
+    await tx
+      .delete(customFields)
+      .where(
+        and(
+          eq(customFields.ownerEmail, input.ownerEmail),
+          inArray(customFields.id, fieldIds),
+        ),
+      );
+    return result;
+  });
+
+  for (const fieldId of fieldIds) {
+    await removeTaskCardFieldId({ ownerEmail: input.ownerEmail, fieldId });
+  }
+
+  return { ok: true, deletedValues };
+}
+
+export async function deleteCustomField(
+  input: {
+    ownerEmail: string;
+    fieldId: string;
+  },
+  db: DbHandle = getDb(),
+): Promise<{ ok: true; deletedValues: number }> {
+  return deleteCustomFields(
+    { ownerEmail: input.ownerEmail, fieldIds: [input.fieldId] },
+    db,
+  );
+}
+
+export async function reorderCustomFields(
+  input: {
+    ownerEmail: string;
+    fieldIds: string[];
+  },
+  db: DbHandle = getDb(),
+): Promise<{ fields: FieldDefinition[] }> {
+  const { fields: existing } = await listCustomFields({
+    ownerEmail: input.ownerEmail,
+  });
+  const existingIds = new Set(existing.map((field) => field.id));
+
+  if (new Set(input.fieldIds).size !== input.fieldIds.length) {
+    throw new UserInputError("fieldIds must not contain duplicates.");
+  }
+  if (input.fieldIds.length !== existingIds.size) {
+    throw new UserInputError("fieldIds must include every field exactly once.");
+  }
+  if (!input.fieldIds.every((fieldId) => existingIds.has(fieldId))) {
+    throw new UserInputError("fieldIds must match the current field list.");
+  }
+
+  const updatedAt = timestamp();
+  const entries = input.fieldIds.map((fieldId, index) => ({
+    id: fieldId,
+    value: index * SORT_GAP,
+  }));
+
+  await db.transaction(async (tx) => {
+    for (const group of chunk(entries)) {
+      await tx
+        .update(customFields)
+        .set({ sortOrder: caseById(customFields.id, group), updatedAt })
+        .where(
+          and(
+            eq(customFields.ownerEmail, input.ownerEmail),
+            inArray(
+              customFields.id,
+              group.map((entry) => entry.id),
+            ),
+          ),
+        );
+    }
+  });
+
+  return listCustomFields({ ownerEmail: input.ownerEmail });
+}
+
+function serializeFieldConfig<T extends FieldType>(type: T, config?: unknown) {
+  const shaped = parseFieldConfigShape(type, config ?? {});
+  validateFieldConfig(type, shaped);
+  return JSON.stringify(
+    canonicalizeFieldConfig(type, normalizeFieldConfigInput(type, shaped)),
+  );
+}
+
+async function nextSortOrder(ownerEmail: string) {
+  const db = getDb();
+  const [row] = await db
+    .select({ maxSortOrder: max(customFields.sortOrder) })
+    .from(customFields)
+    .where(eq(customFields.ownerEmail, ownerEmail));
+  return (row?.maxSortOrder ?? -SORT_GAP) + SORT_GAP;
+}

package/corpus/templates/tasks/server/custom-fields/task-fields.ts

@@ -0,0 +1,104 @@
+import type { StoredCustomFieldValue } from "../db/schema.js";
+import { NotFoundError } from "../errors.js";
+import { getTask, type Task } from "../tasks/store.js";
+import { parseStoredValue } from "./parse.js";
+import { listCustomFields } from "./store.js";
+import type { FieldDefinition, FieldValue } from "./types.js";
+import { listCustomFieldValues } from "./values/store.js";
+
+export type TaskFieldValue = FieldDefinition & {
+  value: FieldValue | null;
+};
+
+export type TaskWithFields = Task & { fields: TaskFieldValue[] };
+
+function fieldsById(fields: FieldDefinition[]) {
+  return new Map(fields.map((field) => [field.id, field]));
+}
+
+function valuesByFieldId(
+  rows: StoredCustomFieldValue[],
+  fieldsByIdMap: Map<string, FieldDefinition>,
+): Map<string, FieldValue | null> {
+  return new Map(
+    rows.map((row) => {
+      const field = fieldsByIdMap.get(row.fieldId);
+      if (!field) throw new Error("Custom field not found.");
+      return [row.fieldId, parseStoredValue(field, row)] as const;
+    }),
+  );
+}
+
+function valuesByTaskId(
+  rows: StoredCustomFieldValue[],
+  fieldsByIdMap: Map<string, FieldDefinition>,
+): Map<string, Map<string, FieldValue | null>> {
+  const result = new Map<string, Map<string, FieldValue | null>>();
+  for (const row of rows) {
+    let values = result.get(row.taskId);
+    if (!values) {
+      values = new Map();
+      result.set(row.taskId, values);
+    }
+    const field = fieldsByIdMap.get(row.fieldId);
+    if (!field) throw new Error("Custom field not found.");
+    values.set(row.fieldId, parseStoredValue(field, row));
+  }
+  return result;
+}
+
+function buildTaskFieldValues(
+  fields: FieldDefinition[],
+  valuesByFieldIdMap: Map<string, FieldValue | null>,
+): TaskFieldValue[] {
+  return fields.map((field) => ({
+    ...field,
+    value: valuesByFieldIdMap.get(field.id) ?? null,
+  }));
+}
+
+export async function listTaskFieldValues(input: {
+  ownerEmail: string;
+  taskId: string;
+}): Promise<TaskFieldValue[]> {
+  const task = await getTask({
+    ownerEmail: input.ownerEmail,
+    id: input.taskId,
+  });
+  if (!task) throw new NotFoundError("Task not found.");
+
+  const [{ fields }, rows] = await Promise.all([
+    listCustomFields({ ownerEmail: input.ownerEmail }),
+    listCustomFieldValues({
+      ownerEmail: input.ownerEmail,
+      taskIds: [input.taskId],
+    }),
+  ]);
+  const fieldsByIdMap = fieldsById(fields);
+  return buildTaskFieldValues(fields, valuesByFieldId(rows, fieldsByIdMap));
+}
+
+export async function attachFieldsToTasks(
+  ownerEmail: string,
+  tasks: Task[],
+): Promise<TaskWithFields[]> {
+  if (tasks.length === 0) return [];
+
+  const [{ fields }, rows] = await Promise.all([
+    listCustomFields({ ownerEmail }),
+    listCustomFieldValues({
+      ownerEmail,
+      taskIds: tasks.map((task) => task.id),
+    }),
+  ]);
+  const fieldsByIdMap = fieldsById(fields);
+  const valuesByTaskIdMap = valuesByTaskId(rows, fieldsByIdMap);
+
+  return tasks.map((task) => ({
+    ...task,
+    fields: buildTaskFieldValues(
+      fields,
+      valuesByTaskIdMap.get(task.id) ?? new Map(),
+    ),
+  }));
+}

package/corpus/templates/tasks/server/custom-fields/types.ts

@@ -0,0 +1,98 @@
+export type FieldDefinitionBase = {
+  id: string;
+  title: string;
+  sortOrder: number;
+  ownerEmail: string;
+  createdAt: string;
+  updatedAt: string;
+};
+
+/* Configs: */
+
+export type NumericFieldConfig = {
+  precision?: number;
+  positiveOnly?: boolean;
+};
+export type CurrencyFieldConfig = { symbol: string; precision?: number };
+
+export const SELECT_COLOR_TOKENS = [
+  "red",
+  "orange",
+  "yellow",
+  "green",
+  "blue",
+  "purple",
+  "pink",
+  "gray",
+] as const;
+export type SelectColorToken = (typeof SELECT_COLOR_TOKENS)[number];
+
+export type SelectOption = {
+  id: string;
+  name: string;
+  color?: SelectColorToken;
+  sortOrder: number;
+};
+export type SelectFieldConfig = { options: SelectOption[] };
+
+export type EmptyFieldConfig = Record<string, never>;
+
+export const FIELD_TYPES = [
+  "text",
+  "rich_text",
+  "number",
+  "percent",
+  "currency",
+  "single_select",
+  "multi_select",
+  "date",
+] as const;
+export type FieldType = (typeof FIELD_TYPES)[number];
+
+export type EmptyConfigInput = EmptyFieldConfig;
+export type SelectOptionInput = {
+  id?: string;
+  name: string;
+  color?: SelectColorToken;
+  sortOrder?: number;
+};
+export type SelectConfigInput = { options: SelectOptionInput[] };
+export type NumericConfigInput = NumericFieldConfig;
+export type PercentConfigInput = { precision?: number };
+export type CurrencyConfigInput = {
+  symbol?: string;
+  precision?: number;
+};
+
+export type FieldConfigInputMap = {
+  text: EmptyFieldConfig;
+  rich_text: EmptyFieldConfig;
+  date: EmptyFieldConfig;
+  number: NumericConfigInput;
+  percent: PercentConfigInput;
+  currency: CurrencyConfigInput;
+  single_select: SelectConfigInput;
+  multi_select: SelectConfigInput;
+};
+
+export type FieldConfigInput<T extends FieldType = FieldType> =
+  FieldConfigInputMap[T];
+
+/* Field Definition: */
+
+export type FieldDefinition = FieldDefinitionBase &
+  (
+    | { type: "text"; config: EmptyFieldConfig }
+    | { type: "rich_text"; config: EmptyFieldConfig }
+    | { type: "date"; config: EmptyFieldConfig }
+    | { type: "number"; config: NumericFieldConfig }
+    | { type: "percent"; config: NumericFieldConfig }
+    | { type: "currency"; config: CurrencyFieldConfig }
+    | { type: "single_select"; config: SelectFieldConfig }
+    | { type: "multi_select"; config: SelectFieldConfig }
+  );
+
+export type FieldConfig = FieldDefinition["config"];
+
+export type FieldValue = string | number | string[];
+export type FieldValueInput = FieldValue | null;