@flaredev/cli 0.5.0 → 0.6.0

package/templates/app/lib/resource/rows.ts

@@ -0,0 +1,66 @@
+// This file is yours.
+//
+// Flare copies the code that turns a resource descriptor into a working endpoint into
+// your app rather than hiding it in node_modules, for the same reason shadcn/ui copies
+// a component: you cannot fix, read or reason about what you cannot see. Nothing here
+// is imported from the framework at runtime — change it, delete it, replace it.
+//
+// `flare diff` shows how your copy differs from the version Flare ships, and
+// `flare update` applies the parts you choose. Neither runs unless you ask.
+
+/**
+ * The handful of things a resource store needs a database to do.
+ *
+ * Everything that makes a Flare resource behave the way it does — validation, hooks,
+ * computed values, cursors, capped counts, the wording of a constraint error — lives in
+ * the store and is the same on every stack. What differs is how rows are actually read
+ * and written, and that is this interface: nine operations, described in the
+ * descriptor's terms rather than in SQL.
+ *
+ * Drizzle over SQLite is one implementation; Prisma over Postgres is another. A store
+ * built on either behaves identically, which is the whole point — the same descriptor
+ * has to mean the same thing on Cloudflare and on Vercel.
+ */
+
+export type Row = Record<string, unknown>;
+
+/** What a list needs, before it becomes SQL. */
+export interface RowsQuery {
+  /** Free-text search across the fields the descriptor marks searchable. */
+  search?: { term: string; fields: string[] };
+  /** field → value, or null for "is null". */
+  filters: Record<string, unknown>;
+  sort: { field: string; direction: "asc" | "desc" };
+  /**
+   * Keyset pagination: everything after (or before) this row, compared on
+   * `(sort field, id)` together so rows sharing a sort value are neither skipped nor
+   * repeated.
+   */
+  cursor?: { field: string; value: unknown; id: string; greaterThan: boolean };
+  limit: number;
+  /** Offset paging, for the page-number case. Never combined with a cursor. */
+  offset?: number;
+}
+
+/** A database refusing a write, in terms the store can turn into a message. */
+export type ConstraintHit =
+  | { kind: "unique"; column?: string }
+  | { kind: "foreignKey" }
+  | { kind: "check" };
+
+export interface ResourceRows {
+  /** The database handle a descriptor's hooks are given. Drizzle, or a Prisma client. */
+  readonly db: unknown;
+  find(query: RowsQuery): Promise<Row[]>;
+  /** How many rows match, giving up at `limit` so a huge table is never fully counted. */
+  countUpTo(query: Pick<RowsQuery, "search" | "filters">, limit: number): Promise<number>;
+  byId(id: string): Promise<Row | null>;
+  titles(ids: string[], titleField: string): Promise<{ id: string; title: unknown }[]>;
+  insert(values: Row): Promise<Row>;
+  /** The saved row, or null when there was nothing with that id. */
+  update(id: string, values: Row): Promise<Row | null>;
+  /** Whether a row was actually removed. */
+  remove(id: string): Promise<boolean>;
+  /** Recognise a constraint violation, or hand the error back by returning undefined. */
+  constraint(error: unknown): ConstraintHit | undefined;
+}

package/templates/app/lib/resource/store.ts

@@ -0,0 +1,342 @@
+// This file is yours.
+//
+// Flare copies the code that turns a resource descriptor into a working endpoint into
+// your app rather than hiding it in node_modules, for the same reason shadcn/ui copies
+// a component: you cannot fix, read or reason about what you cannot see. Nothing here
+// is imported from the framework at runtime — change it, delete it, replace it.
+//
+// `flare diff` shows how your copy differs from the version Flare ships, and
+// `flare update` applies the parts you choose. Neither runs unless you ask.
+
+import { columnName, storedFields, type Resource } from "@flaredev/core";
+import { createValidators } from "@flaredev/core";
+import { encodeCursor, isSearchable, parseListQuery, type QueryIssue } from "./query";
+import type { ResourceRows, Row } from "./rows";
+
+
+export type ResourceAction = "list" | "read" | "create" | "update" | "delete";
+
+export interface FieldIssue {
+  /** Dotted field path; "" for the whole body (e.g. unknown keys). */
+  path: string;
+  message: string;
+}
+
+export type Failure = {
+  ok: false;
+  status: 400 | 404 | 409 | 422;
+  error: string;
+  /** Validation issues per field. */
+  issues?: FieldIssue[];
+  /** Invalid query parameters. */
+  queryIssues?: QueryIssue[];
+  /** Field that caused a conflict (e.g. a unique violation). */
+  field?: string;
+};
+
+export type Result<T> = { ok: true; data: T } | Failure;
+
+/**
+ * How far a list will count before it answers "at least this many". Counting a million
+ * rows took 900ms even with an index; counting the first 10,000 takes a few.
+ */
+export const COUNT_LIMIT = 10_000;
+
+/** Dates are stored as milliseconds, and a cursor has to compare the way the column does. */
+function toCursorValue(value: unknown): string | number | boolean | null {
+  if (value instanceof Date) return value.getTime();
+  if (value === null || value === undefined) return null;
+  if (typeof value === "object") return String(value);
+  return value as string | number | boolean;
+}
+
+export interface ListResult<T = Record<string, unknown>> {
+  data: T[];
+  meta: {
+    page: number;
+    perPage: number;
+    /** Rows matching the query, counted up to `COUNT_LIMIT`. */
+    total: number;
+    totalPages: number;
+    /**
+     * Whether `total` is the real number. Counting every row of a large table on every
+     * page load is the single most expensive thing a list does, so the count stops at
+     * `COUNT_LIMIT` and says so; past that, the list pages by cursor.
+     */
+    exactTotal: boolean;
+    /** Carry on from the end of this page, and from its start, without an offset. */
+    nextCursor?: string;
+    prevCursor?: string;
+  };
+}
+
+export interface ChangeEvent {
+  /** Resource name, e.g. "Deal". */
+  resource: string;
+  action: "create" | "update" | "delete";
+  id: string;
+}
+
+export interface ResourceStoreOptions {
+  resource: Resource;
+  /**
+   * Who is making the write, for the descriptor's hooks. The dashboard and the API both
+   * know; a seed doesn't, and passes nothing.
+   */
+  currentUser?: () => Promise<{ id: string; email: string; role?: string | null } | null> | { id: string; email: string; role?: string | null } | null;
+  /**
+   * Where rows come from: `drizzleRows(table, getDb)` on Cloudflare,
+   * `prismaRows(prisma.model, prisma)` on Next.js, or anything else implementing
+   * {@link ResourceRows} — an in-memory fake in a test, an HTTP API, another database.
+   *
+   * Passed in rather than chosen here on purpose: the adapter is visible at every call
+   * site, and this file never has to know which stack it is on.
+   */
+  rows: ResourceRows;
+  /**
+   * Called after a write succeeds, for cache invalidation. Runs before the
+   * operation returns, so a caller that revalidates tags can't hand back a
+   * response the cache would then contradict. Failures are logged, not thrown:
+   * the write already happened.
+   */
+  onChange?: (event: ChangeEvent) => void | Promise<void>;
+}
+
+/**
+ * CRUD operations for one resource, driven by its descriptor. Shared by the REST
+ * handlers and the admin's server actions, so validation, constraint handling, and
+ * search behave identically everywhere. Operations never throw for expected failures;
+ * they return `{ ok: false, status, error }`.
+ */
+export function createResourceStore(options: ResourceStoreOptions) {
+  const { resource, rows } = options;
+  const validators = createValidators(resource);
+  const fields = storedFields(resource);
+
+  // Drizzle can say up front whether the table matches the descriptor; a Prisma client
+  // can't be asked the same question without a round trip, so that check stays here.
+  const columns = "columns" in rows ? (rows.columns as Record<string, { name: string }>) : undefined;
+  if (columns) {
+    for (const key of ["id", "createdAt", "updatedAt", ...fields.map(([key]) => key)]) {
+      if (!columns[key]) {
+        throw new Error(`Resource "${resource.name}": table has no column for "${key}". Run \`flare sync-types\` and create a migration.`);
+      }
+    }
+  }
+  /** A column name from a constraint error back to the field that owns it. */
+  const keyForColumn = (name: string): string | undefined =>
+    columns
+      ? Object.entries(columns).find(([, column]) => column.name === name)?.[0]
+      : ["id", "createdAt", "updatedAt", ...fields.map(([key]) => key)].find((key) => columnName(key) === name || key === name);
+
+  const fail = (status: Failure["status"], error: string, extra: Partial<Failure> = {}): Failure => ({ ok: false, status, error, ...extra });
+
+  /** The same wording whichever database refused the write. */
+  function constraintFailure(error: unknown, action: ResourceAction): Failure | undefined {
+    const hit = rows.constraint(error);
+    if (!hit) return undefined;
+    if (hit.kind === "unique") {
+      const key = hit.column ? keyForColumn(hit.column) : undefined;
+      const label = key ? (resource.fields[key]?.label ?? key) : "Value";
+      return fail(409, `${label} is already taken.`, key ? { field: key } : {});
+    }
+    if (hit.kind === "foreignKey") {
+      return action === "delete"
+        ? fail(409, `This ${resource.label.toLowerCase()} is still referenced by other records.`)
+        : fail(422, "A related record doesn't exist.");
+    }
+    return fail(422, "A value is outside its allowed options.");
+  }
+
+  async function guarded<T>(action: ResourceAction, work: () => Promise<Result<T>>): Promise<Result<T>> {
+    try {
+      return await work();
+    } catch (error) {
+      const failure = constraintFailure(error, action);
+      if (failure) return failure;
+      throw error;
+    }
+  }
+
+  /** Announce a successful write. A broken listener must not turn a completed write into an error. */
+  async function announce(action: ChangeEvent["action"], result: Result<{ id?: unknown }>): Promise<void> {
+    if (!options.onChange || !result.ok) return;
+    try {
+      await options.onChange({ resource: resource.name, action, id: String(result.data.id) });
+    } catch (error) {
+      console.error(`[flare] ${resource.name} ${action} cache invalidation failed:`, error);
+    }
+  }
+
+  /** Run a write, then announce it before handing the result back. */
+  async function writing<T extends { id?: unknown }>(
+    action: ChangeEvent["action"],
+    work: () => Promise<Result<T>>,
+  ): Promise<Result<T>> {
+    const result = await guarded(action, work);
+    await announce(action, result);
+    return result;
+  }
+
+  const invalid = (issues: { path: PropertyKey[]; message: string }[]) =>
+    fail(422, "Validation failed.", { issues: issues.map((issue) => ({ path: issue.path.map(String).join("."), message: issue.message })) });
+
+  const notFound = () => fail(404, `${resource.label} not found.`);
+
+  const computed = Object.entries(resource.computed ?? {});
+  /** Add the descriptor's computed values to a row on its way out. */
+  const withComputed = (row: Record<string, unknown>): Record<string, unknown> => {
+    if (computed.length === 0) return row;
+    const result = { ...row };
+    for (const [key, compute] of computed) {
+      try {
+        result[key] = compute(row);
+      } catch {
+        // A computed value that throws shouldn't take the record with it.
+        result[key] = null;
+      }
+    }
+    return result;
+  };
+
+  const hooks = resource.hooks ?? {};
+  const hookContext = async () => ({ db: rows.db, user: (await options.currentUser?.()) ?? null });
+
+  return {
+    resource,
+
+    /** `params`: page, perPage, sort, q, filter[field], cursor (as parsed by parseListQuery). */
+    async list(params: URLSearchParams): Promise<Result<ListResult>> {
+      const parsed = parseListQuery(resource, params);
+      if ("issues" in parsed) return fail(400, "Invalid query.", { queryIssues: parsed.issues });
+      const { page, perPage, sort, q, filters, cursor } = parsed.query;
+
+      const searchable = fields.filter(([, def]) => isSearchable(def)).map(([key]) => key);
+      const matching = { search: q ? { term: q, fields: searchable } : undefined, filters };
+
+      // Reading backwards from a "previous page" cursor means flipping the order and
+      // flipping the rows back afterwards.
+      const backwards = cursor?.direction === "before";
+      const descending = backwards ? sort.direction === "asc" : sort.direction === "desc";
+
+      const [found, counting] = await Promise.all([
+        // One row past the limit is enough to know there's more without counting it all.
+        rows.find({
+          ...matching,
+          sort: { field: sort.field, direction: descending ? "desc" : "asc" },
+          cursor: cursor ? { field: sort.field, value: cursor.value, id: cursor.id, greaterThan: !descending } : undefined,
+          limit: perPage + 1,
+          offset: cursor ? undefined : (page - 1) * perPage,
+        }),
+        rows.countUpTo(matching, COUNT_LIMIT + 1),
+      ]);
+
+      // The extra row only tells us another page exists; it isn't part of this one.
+      const hasMore = found.length > perPage;
+      const page_ = (hasMore ? found.slice(0, perPage) : found).map(withComputed);
+      if (backwards) page_.reverse();
+
+      const exactTotal = counting <= COUNT_LIMIT;
+      const total = exactTotal ? counting : COUNT_LIMIT;
+
+      const first = page_[0];
+      const last = page_[page_.length - 1];
+      const moreAfter = backwards ? true : hasMore;
+      const moreBefore = backwards ? hasMore : Boolean(cursor) || page > 1;
+      const cursorFor = (row: Record<string, unknown> | undefined, direction: "after" | "before") =>
+        row ? encodeCursor({ value: toCursorValue(row[sort.field]), id: String(row.id), direction }) : undefined;
+
+      return {
+        ok: true,
+        data: {
+          data: page_,
+          meta: {
+            page,
+            perPage,
+            total,
+            totalPages: Math.max(1, Math.ceil(total / perPage)),
+            exactTotal,
+            nextCursor: moreAfter ? cursorFor(last, "after") : undefined,
+            prevCursor: moreBefore ? cursorFor(first, "before") : undefined,
+          },
+        },
+      };
+    },
+
+    async get(id: string): Promise<Result<Record<string, unknown>>> {
+      const record = await rows.byId(id);
+      return record ? { ok: true, data: withComputed(record) } : notFound();
+    },
+
+    /** Title-field values for a set of ids (for showing relations). Missing ids are omitted. */
+    async titles(ids: string[]): Promise<Record<string, string>> {
+      const unique = [...new Set(ids.filter(Boolean))];
+      if (unique.length === 0) return {};
+      const found = await rows.titles(unique, resource.titleField);
+      return Object.fromEntries(found.map((row) => [row.id, row.title == null ? row.id : String(row.title)]));
+    },
+
+    create(raw: unknown): Promise<Result<Record<string, unknown>>> {
+      return writing("create", async () => {
+        const context = await hookContext();
+        // The hook runs first so it can fill in what the caller couldn't know — an order
+        // number, a slug, a tenant — and whatever it returns is validated like any input.
+        const supplied = hooks.beforeCreate ? await hooks.beforeCreate({ ...((raw ?? {}) as object) }, context) : raw;
+        const result = validators.create.safeParse(supplied);
+        if (!result.success) return invalid(result.error.issues);
+        const input = result.data as Record<string, unknown>;
+        const now = new Date();
+        const record = await rows.insert({ ...input, id: crypto.randomUUID(), createdAt: now, updatedAt: now });
+        const saved = withComputed(record);
+        await hooks.afterCreate?.(saved, context);
+        return { ok: true, data: saved };
+      });
+    },
+
+    /** Partial update (PATCH semantics). */
+    update(id: string, raw: unknown): Promise<Result<Record<string, unknown>>> {
+      return writing("update", async () => {
+        const context = await hookContext();
+        const current = hooks.beforeUpdate || hooks.afterUpdate ? await rows.byId(id) : null;
+        const supplied = hooks.beforeUpdate ? await hooks.beforeUpdate({ ...((raw ?? {}) as object) }, { ...context, id, current }) : raw;
+        const result = validators.update.safeParse(supplied);
+        if (!result.success) return invalid(result.error.issues);
+        const input = result.data as Record<string, unknown>;
+        const record = await rows.update(id, { ...input, updatedAt: new Date() });
+        if (!record) return notFound();
+        const saved = withComputed(record);
+        await hooks.afterUpdate?.(saved, { ...context, previous: current });
+        return { ok: true, data: saved };
+      });
+    },
+
+    /** Full replacement (PUT semantics): omitted fields go back to their default, or null when optional. */
+    replace(id: string, input: unknown): Promise<Result<Record<string, unknown>>> {
+      const result = validators.create.safeParse(input);
+      if (!result.success) return Promise.resolve(invalid(result.error.issues));
+      return writing("update", async () => {
+        const values: Row = {};
+        for (const [key, def] of fields) {
+          values[key] = "default" in def && def.default !== undefined ? def.default : def.required ? undefined : null;
+        }
+        Object.assign(values, result.data, { updatedAt: new Date() });
+        const record = await rows.update(id, values);
+        return record ? { ok: true, data: withComputed(record) } : notFound();
+      });
+    },
+
+    delete(id: string): Promise<Result<{ id: string }>> {
+      return writing("delete", async () => {
+        const context = await hookContext();
+        if (hooks.beforeDelete) {
+          await hooks.beforeDelete({ ...context, id, current: await rows.byId(id) });
+        }
+        if (!(await rows.remove(id))) return notFound();
+        await hooks.afterDelete?.({ ...context, id });
+        return { ok: true, data: { id } };
+      });
+    },
+  };
+}
+
+export type ResourceStore = ReturnType<typeof createResourceStore>;

package/templates/next/app/dashboard/actions.ts

@@ -2,7 +2,7 @@
 
 import { revalidatePath } from "next/cache";
 import { createObjectKey, fileKeyPrefix, fileMaxBytes, matchesContentType, mimeTypesFor, type FileField } from "@flaredev/core";
-import type { FieldIssue } from "@flaredev/core/server";
+import type { FieldIssue } from "@/lib/resource/store";
 import { diffFields, recordAudit } from "@/lib/audit";
 import { listViews, MAX_VIEWS } from "@/lib/views";
 import { prisma } from "@/lib/db";

package/templates/next/lib/dashboard.ts

@@ -1,7 +1,7 @@
 import { headers } from "next/headers";
 import { notFound, redirect } from "next/navigation";
 import { allowedActions, can, columnName, type Policy, type PolicyAction, type Resource } from "@flaredev/core";
-import { createResourceStore, prismaRows, type PrismaDelegate, type ResourceStore } from "@flaredev/core/server";
+import { createResourceStore, prismaRows, type PrismaDelegate, type ResourceStore } from "@/lib/resource";
 import { prisma } from "@/lib/db";
 import { policies } from "@/policies";
 import { resourceTables } from "@/resources/server";

package/templates/next/lib/resource/index.ts

@@ -0,0 +1,14 @@
+// The resource engine, in your app.
+//
+// Re-exported from one place so a route reads `from "@/lib/resource"`. Every file
+// behind it is in this folder and is yours to change.
+//
+// This is the Next.js stack, so the row adapter is Prisma over Postgres. The
+// Cloudflare stack has drizzle-rows.ts here instead. Both implement ResourceRows,
+// which is the whole contract — about fifty lines in rows.ts, and the reason a
+// descriptor doesn't care which database it is on.
+export * from "./rows";
+export * from "./query";
+export * from "./store";
+export * from "./handlers";
+export * from "./prisma-rows";

package/templates/next/lib/resource/prisma-rows.ts

@@ -0,0 +1,169 @@
+// This file is yours.
+//
+// Flare copies the code that turns a resource descriptor into a working endpoint into
+// your app rather than hiding it in node_modules, for the same reason shadcn/ui copies
+// a component: you cannot fix, read or reason about what you cannot see. Nothing here
+// is imported from the framework at runtime — change it, delete it, replace it.
+//
+// `flare diff` shows how your copy differs from the version Flare ships, and
+// `flare update` applies the parts you choose. Neither runs unless you ask.
+
+/**
+ * {@link ResourceRows} over Prisma and Postgres — the Next.js stack's half.
+ *
+ * The same nine operations the Drizzle adapter implements, expressed as Prisma queries.
+ * Everything a resource *means* — validation, hooks, computed values, the capped count,
+ * the wording of a unique-constraint error — stays in the store and is shared, so a
+ * descriptor behaves the same on either stack.
+ *
+ * Nothing here imports `@prisma/client`: a generated client is app-specific and this
+ * package can't depend on one. The delegate is described structurally instead, which is
+ * also what makes it easy to test without a database.
+ */
+import type { ConstraintHit, ResourceRows, Row, RowsQuery } from "./rows";
+
+/**
+ * The part of a Prisma model delegate a resource store uses.
+ *
+ * The arguments are loose on purpose. Prisma generates a precise argument type per
+ * model — `Prisma.ProductFindManyArgs` and so on — and describing them here would mean
+ * reproducing Prisma's generics for a client this package can't import. The queries are
+ * all built in this file, so there is exactly one place to get them right.
+ */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export interface PrismaDelegate {
+  findMany(args: any): Promise<any[]>;
+  findUnique(args: any): Promise<any>;
+  count(args: any): Promise<number>;
+  create(args: any): Promise<any>;
+  update(args: any): Promise<any>;
+  delete(args: any): Promise<any>;
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */
+
+/** Prisma's "no record matched" — an expected outcome here, not an error. */
+const NOT_FOUND = "P2025";
+
+const codeOf = (error: unknown): string | undefined =>
+  typeof error === "object" && error !== null && "code" in error ? String((error as { code: unknown }).code) : undefined;
+
+/**
+ * Which column a unique violation was about.
+ *
+ * Prisma reports this two different ways. Without a driver adapter it is `meta.target`,
+ * a list of field names. With one — which Prisma 7 requires for SQL databases — the
+ * driver's own error is passed through instead, and the only clue is the name of the
+ * index Postgres rejected: `products_sku_key`, which is `<table>_<column>_key`.
+ *
+ * Getting this right is what puts "Sku is already taken" under the SKU field instead of
+ * a bare "Value is already taken" at the top of the form.
+ */
+function uniqueColumn(error: unknown): string | undefined {
+  const meta = (error as { meta?: Record<string, unknown> }).meta;
+  if (!meta) return undefined;
+
+  const target = meta.target;
+  if (Array.isArray(target) && target.length > 0) return String(target[0]);
+  if (typeof target === "string") return fromIndexName(target);
+
+  const cause = (meta.driverAdapterError as { cause?: { constraint?: { index?: string; fields?: string[] } } } | undefined)?.cause;
+  const constraint = cause?.constraint;
+  if (constraint?.fields?.length) return constraint.fields[0];
+  if (constraint?.index) return fromIndexName(constraint.index);
+  return undefined;
+}
+
+/** `products_sku_key` → `sku`; anything else is handed back unchanged. */
+function fromIndexName(name: string): string {
+  const match = /^.*?_(.+)_key$/.exec(name);
+  return match ? match[1]! : name;
+}
+
+export function prismaRows(delegate: PrismaDelegate, client: unknown): ResourceRows {
+  /** The search and filter half of a where clause — everything but the cursor. */
+  function matching(query: Pick<RowsQuery, "search" | "filters">): Record<string, unknown> {
+    const where: Record<string, unknown> = { ...query.filters };
+    if (query.search && query.search.fields.length > 0) {
+      // Insensitive on purpose: SQLite's LIKE is case-insensitive for ASCII, so this is
+      // what keeps search behaving the same on both stacks.
+      where.OR = query.search.fields.map((field) => ({ [field]: { contains: query.search!.term, mode: "insensitive" } }));
+    }
+    return where;
+  }
+
+  return {
+    db: client,
+
+    async find(query) {
+      const where = matching(query);
+      if (query.cursor) {
+        const { field, value, id, greaterThan } = query.cursor;
+        const op = greaterThan ? "gt" : "lt";
+        // (sort, id) as one comparison, so rows sharing a sort value are neither skipped
+        // nor repeated. AND-ed with the filters rather than replacing them.
+        const keyset = [{ [field]: { [op]: value } }, { AND: [{ [field]: value }, { id: { [op]: id } }] }];
+        where.AND = [...((where.AND as unknown[]) ?? []), { OR: keyset }];
+      }
+      return delegate.findMany({
+        where,
+        orderBy: [{ [query.sort.field]: query.sort.direction }, { id: query.sort.direction }],
+        take: query.limit,
+        ...(query.offset ? { skip: query.offset } : {}),
+      });
+    },
+
+    countUpTo(query, limit) {
+      // Prisma's count takes `take`, so a huge table is never counted in full.
+      return delegate.count({ where: matching(query), take: limit });
+    },
+
+    byId(id) {
+      return delegate.findUnique({ where: { id } });
+    },
+
+    async titles(ids, titleField) {
+      const rows = await delegate.findMany({ where: { id: { in: ids } }, select: { id: true, [titleField]: true } });
+      return rows.map((row) => ({ id: String(row.id), title: row[titleField] }));
+    },
+
+    insert(values) {
+      return delegate.create({ data: values });
+    },
+
+    async update(id, values) {
+      try {
+        return await delegate.update({ where: { id }, data: values });
+      } catch (error) {
+        if (codeOf(error) === NOT_FOUND) return null;
+        throw error;
+      }
+    },
+
+    async remove(id) {
+      try {
+        await delegate.delete({ where: { id } });
+        return true;
+      } catch (error) {
+        if (codeOf(error) === NOT_FOUND) return false;
+        throw error;
+      }
+    },
+
+    constraint(error): ConstraintHit | undefined {
+      switch (codeOf(error)) {
+        case "P2002":
+          return { kind: "unique", column: uniqueColumn(error) };
+        case "P2003":
+        case "P2014":
+          return { kind: "foreignKey" };
+        // A value outside its type, too long for its column, or null where it can't be.
+        case "P2000":
+        case "P2011":
+        case "P2020":
+          return { kind: "check" };
+        default:
+          return undefined;
+      }
+    },
+  };
+}