envio 3.14.0 → 3.14.1-resolvers.2

package/src/resolvers/ResolverQuery.res

@@ -0,0 +1,313 @@
+// Written against the entity table definitions rather than raw rows, so the
+// resolver path reads entities the way the indexer writes them: column names
+// come from the table's own field mapping, filter values are serialized with
+// each field's schema, and rows are decoded with `Table.pgRowsSchema`. A
+// `db.find` therefore hands back what a handler's `context.<Entity>.get` does,
+// BigInt and enum values included.
+//
+// The operator vocabulary is `getWhere`'s, so one filter syntax spans handlers
+// and resolvers. The translation is deliberately not shared with
+// `EntityFilter.parseGetWhereOrThrow`: that expands `_in` and `_gte` into a
+// disjunction for the load layer to memoize per value, which here would turn
+// one indexed query into several.
+
+type orderBy = {field: string, direction: string}
+
+type findOptions = {
+  entityConfig: Internal.entityConfig,
+  pgSchema: string,
+  where?: dict<unknown>,
+  orderBy?: array<orderBy>,
+  limit?: int,
+  offset?: int,
+}
+
+type query = {text: string, params: array<JSON.t>}
+
+let quoted = (~pgSchema, ~tableName) => `"${pgSchema}"."${tableName}"`
+
+let getQueryFieldOrThrow = (~table: Table.table, ~entityName, ~apiFieldName, ~where) =>
+  switch table->Table.queryFields->Dict.get(apiFieldName) {
+  | Some(queryField) => queryField
+  | None =>
+    JsError.throwWithMessage(
+      `Invalid field "${apiFieldName}" in db.find("${entityName}", { ${where}: ... }). The entity has no such field.`,
+    )
+  }
+
+let bindOrThrow = (
+  ~queryField: Table.queryField,
+  ~entityName,
+  ~apiFieldName,
+  ~operator,
+  ~value: unknown,
+  ~isArray,
+  ~params: array<JSON.t>,
+) => {
+  let json = try value->S.reverseConvertToJsonOrThrow(
+    isArray ? queryField.arrayFieldSchema : queryField.fieldSchema,
+  ) catch {
+  | exn =>
+    let reason = switch exn {
+    | JsExn(e) => e->JsExn.message->Option.getOr("it isn't the field's type")
+    | _ => "it isn't the field's type"
+    }
+    JsError.throwWithMessage(
+      `Invalid value for db.find("${entityName}", { where: { ${apiFieldName}: { ${operator}: ... } } }): ${reason}`,
+    )
+  }
+  params->Array.push(json)->ignore
+  `$${params->Array.length->Int.toString}`
+}
+
+let makeWhereCondition = (~table, ~entityName, ~where: dict<unknown>, ~params) => {
+  let apiFieldNames = where->Dict.keysToArray
+  if apiFieldNames->Array.length === 0 {
+    JsError.throwWithMessage(
+      `Empty where passed to db.find("${entityName}"). Drop it, or filter like { fieldName: { _eq: value } }.`,
+    )
+  }
+  apiFieldNames
+  ->Array.flatMap(apiFieldName => {
+    let queryField = getQueryFieldOrThrow(~table, ~entityName, ~apiFieldName, ~where="where")
+    let operators = where->Dict.getUnsafe(apiFieldName)
+    if operators->typeof !== #object || operators->Array.isArray || operators === %raw(`null`) {
+      JsError.throwWithMessage(
+        `Invalid value in db.find("${entityName}", { where: { ${apiFieldName}: ... } }). Provide an operator like { _eq: value }.`,
+      )
+    }
+    let operators = operators->(Utils.magic: unknown => dict<unknown>)
+    let operatorKeys = operators->Dict.keysToArray
+    if operatorKeys->Array.length === 0 {
+      JsError.throwWithMessage(
+        `Empty operator in db.find("${entityName}", { where: { ${apiFieldName}: {} } }). Valid operators are _eq, _gt, _lt, _gte, _lte, _in.`,
+      )
+    }
+    operatorKeys->Array.map(operator => {
+      let value = operators->Dict.getUnsafe(operator)
+      let bind = (~isArray=false) =>
+        bindOrThrow(~queryField, ~entityName, ~apiFieldName, ~operator, ~value, ~isArray, ~params)
+      let column = `"${queryField.pgDbFieldName}"`
+      switch operator {
+      | "_eq" => `${column} = ${bind()}`
+      | "_gt" => `${column} > ${bind()}`
+      | "_lt" => `${column} < ${bind()}`
+      | "_gte" => `${column} >= ${bind()}`
+      | "_lte" => `${column} <= ${bind()}`
+      | "_in" =>
+        if !(value->Array.isArray) {
+          JsError.throwWithMessage(
+            `Invalid value in db.find("${entityName}", { where: { ${apiFieldName}: { _in: ... } } }). _in takes an array.`,
+          )
+        }
+        `${column} = ANY(${bind(~isArray=true)})`
+      | _ =>
+        JsError.throwWithMessage(
+          `Invalid operator "${operator}" in db.find("${entityName}", { where: { ${apiFieldName}: { ${operator}: ... } } }). Valid operators are _eq, _gt, _lt, _gte, _lte, _in.`,
+        )
+      }
+    })
+  })
+  ->Array.join(" AND ")
+}
+
+let makeOrderByClause = (~table, ~entityName, ~orderBy: array<orderBy>) =>
+  switch orderBy {
+  | [] => ""
+  | orderBy =>
+    " ORDER BY " ++
+    orderBy
+    ->Array.map(({field, direction}) => {
+      let queryField = getQueryFieldOrThrow(
+        ~table,
+        ~entityName,
+        ~apiFieldName=field,
+        ~where="orderBy",
+      )
+      let direction = switch direction->String.toLowerCase {
+      | "asc" => "ASC"
+      | "desc" => "DESC"
+      | other =>
+        JsError.throwWithMessage(
+          `Invalid direction "${other}" in db.find("${entityName}", { orderBy: [{ field: "${field}" }] }). Use "asc" or "desc".`,
+        )
+      }
+      `"${queryField.pgDbFieldName}" ${direction}`
+    })
+    ->Array.join(", ")
+  }
+
+// Bound rather than spliced: a count reaching SQL as a parameter can't widen
+// the statement no matter where the resolver got it from.
+let makeBoundCount = (~keyword, ~entityName, ~count, ~params: array<JSON.t>) => {
+  if count < 0 || count->Int.toFloat->Math.trunc !== count->Int.toFloat {
+    JsError.throwWithMessage(
+      `Invalid ${keyword->String.toLowerCase} ${count->Int.toString} in db.find("${entityName}"). It must be a non-negative whole number.`,
+    )
+  }
+  params->Array.push(JSON.Encode.int(count))->ignore
+  ` ${keyword} $${params->Array.length->Int.toString}`
+}
+
+let makeFindQuery = (options: findOptions): query => {
+  let {entityConfig, pgSchema} = options
+  let table = entityConfig.table
+  let entityName = entityConfig.name
+  let params = []
+
+  let whereClause = switch options.where {
+  | None => ""
+  | Some(where) => " WHERE " ++ makeWhereCondition(~table, ~entityName, ~where, ~params)
+  }
+  let orderByClause = switch options.orderBy {
+  | None => ""
+  | Some(orderBy) => makeOrderByClause(~table, ~entityName, ~orderBy)
+  }
+  let limitClause = switch options.limit {
+  | None => ""
+  | Some(count) => makeBoundCount(~keyword="LIMIT", ~entityName, ~count, ~params)
+  }
+  let offsetClause = switch options.offset {
+  | None => ""
+  | Some(count) => makeBoundCount(~keyword="OFFSET", ~entityName, ~count, ~params)
+  }
+
+  {
+    text: `SELECT * FROM ${quoted(
+        ~pgSchema,
+        ~tableName=table.tableName,
+      )}${whereClause}${orderByClause}${limitClause}${offsetClause};`,
+    params,
+  }
+}
+
+// `id` alone identifies a row only on a cross-chain entity: a per-chain table
+// is keyed by (id, chain id), so a bare `get` there would answer with whichever
+// chain's row Postgres reached first.
+let makeGetQuery = (entityConfig: Internal.entityConfig, pgSchema: string, id: unknown): query => {
+  let table = entityConfig.table
+  let entityName = entityConfig.name
+  switch table->Table.getChainIdField {
+  | Some(_) =>
+    JsError.throwWithMessage(
+      `db.get("${entityName}", id) is ambiguous: the entity is per-chain, so the same id can exist on every chain. Use db.find("${entityName}", { where: { id: { _eq: id }, ${Config.chainIdFieldName}: { _eq: chainId } } }).`,
+    )
+  | None => ()
+  }
+  // Bound through the id field's own schema, like every other value: the
+  // loaders must not be the one place a value reaches SQL unconverted.
+  let params = []
+  let queryField = getQueryFieldOrThrow(
+    ~table,
+    ~entityName,
+    ~apiFieldName=Table.idFieldName,
+    ~where="where",
+  )
+  let placeholder = bindOrThrow(
+    ~queryField,
+    ~entityName,
+    ~apiFieldName=Table.idFieldName,
+    ~operator="_eq",
+    ~value=id,
+    ~isArray=false,
+    ~params,
+  )
+  {
+    text: `SELECT * FROM ${quoted(
+        ~pgSchema,
+        ~tableName=table.tableName,
+      )} WHERE "${queryField.pgDbFieldName}" = ${placeholder} LIMIT 1;`,
+    params,
+  }
+}
+
+let decodeRows = (entityConfig: Internal.entityConfig, rows: array<unknown>): array<unknown> =>
+  rows->S.parseOrThrow(entityConfig.table->Table.pgRowsSchema)
+
+type chainHeight = {
+  chainId: ChainId.t,
+  ecosystem: string,
+  startBlock: int,
+  endBlock: Null.t<int>,
+  sourceBlock: int,
+  bufferBlock: int,
+  progressBlock: int,
+  readyAt: Null.t<Date.t>,
+  isReady: bool,
+}
+
+// `envio_chains` is read by column rather than with `Table.pgRowsSchema`: the
+// table's BIGINT columns come back from the driver as strings, which is why
+// every other raw read of it casts on the way out. Only the watermark columns
+// are selected, so none of those are in the result at all.
+let chainColumns: array<InternalTable.Chains.field> = [
+  #id,
+  #ecosystem,
+  #start_block,
+  #end_block,
+  #source_block,
+  #buffer_block,
+  #progress_block,
+  #ready_at,
+]
+
+type chainRow = {
+  id: unknown,
+  ecosystem: string,
+  startBlock: int,
+  endBlock: option<int>,
+  sourceBlock: int,
+  bufferBlock: int,
+  progressBlock: int,
+  readyAt: option<Date.t>,
+}
+
+let chainRowsSchema = S.array(
+  S.object((s): chainRow => {
+    id: s.field((#id: InternalTable.Chains.field :> string), S.unknown),
+    ecosystem: s.field((#ecosystem: InternalTable.Chains.field :> string), S.string),
+    startBlock: s.field((#start_block: InternalTable.Chains.field :> string), S.int),
+    endBlock: s.field((#end_block: InternalTable.Chains.field :> string), S.null(S.int)),
+    sourceBlock: s.field((#source_block: InternalTable.Chains.field :> string), S.int),
+    bufferBlock: s.field((#buffer_block: InternalTable.Chains.field :> string), S.int),
+    progressBlock: s.field((#progress_block: InternalTable.Chains.field :> string), S.int),
+    readyAt: s.field(
+      (#ready_at: InternalTable.Chains.field :> string),
+      S.null(Utils.Schema.dbDate),
+    ),
+  }),
+)
+
+let makeChainHeightsQuery = (pgSchema: string): query => {
+  text: `SELECT ${chainColumns
+    ->Array.map(column => `"${(column :> string)}"`)
+    ->Array.join(", ")} FROM ${quoted(
+      ~pgSchema,
+      ~tableName=InternalTable.Chains.table.tableName,
+    )};`,
+  params: [],
+}
+
+let decodeChainHeights = (rows: array<unknown>): dict<chainHeight> => {
+  let heights = Dict.make()
+  rows
+  ->S.parseOrThrow(chainRowsSchema)
+  ->Array.forEach(row => {
+    let chainId = row.id->ChainId.normalizeOrThrow
+    heights->Dict.set(
+      chainId->ChainId.toString,
+      {
+        chainId,
+        ecosystem: row.ecosystem,
+        startBlock: row.startBlock,
+        endBlock: row.endBlock->Null.fromOption,
+        sourceBlock: row.sourceBlock,
+        bufferBlock: row.bufferBlock,
+        progressBlock: row.progressBlock,
+        readyAt: row.readyAt->Null.fromOption,
+        isReady: row.readyAt->Option.isSome,
+      },
+    )
+  })
+  heights
+}

package/src/resolvers/ResolverQuery.res.mjs

@@ -0,0 +1,220 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Table from "../db/Table.res.mjs";
+import * as Utils from "../Utils.res.mjs";
+import * as Config from "../Config.res.mjs";
+import * as ChainId from "../ChainId.res.mjs";
+import * as Stdlib_Null from "@rescript/runtime/lib/es6/Stdlib_Null.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as InternalTable from "../db/InternalTable.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+
+function quoted(pgSchema, tableName) {
+  return `"` + pgSchema + `"."` + tableName + `"`;
+}
+
+function getQueryFieldOrThrow(table, entityName, apiFieldName, where) {
+  let queryField = Table.queryFields(table)[apiFieldName];
+  if (queryField !== undefined) {
+    return queryField;
+  } else {
+    return Stdlib_JsError.throwWithMessage(`Invalid field "` + apiFieldName + `" in db.find("` + entityName + `", { ` + where + `: ... }). The entity has no such field.`);
+  }
+}
+
+function bindOrThrow(queryField, entityName, apiFieldName, operator, value, isArray, params) {
+  let json;
+  try {
+    json = S$RescriptSchema.reverseConvertToJsonOrThrow(value, isArray ? queryField.arrayFieldSchema : queryField.fieldSchema);
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    let reason = exn.RE_EXN_ID === "JsExn" ? Stdlib_Option.getOr(Stdlib_JsExn.message(exn._1), "it isn't the field's type") : "it isn't the field's type";
+    json = Stdlib_JsError.throwWithMessage(`Invalid value for db.find("` + entityName + `", { where: { ` + apiFieldName + `: { ` + operator + `: ... } } }): ` + reason);
+  }
+  params.push(json);
+  return `$` + params.length.toString();
+}
+
+function makeWhereCondition(table, entityName, where, params) {
+  let apiFieldNames = Object.keys(where);
+  if (apiFieldNames.length === 0) {
+    Stdlib_JsError.throwWithMessage(`Empty where passed to db.find("` + entityName + `"). Drop it, or filter like { fieldName: { _eq: value } }.`);
+  }
+  return apiFieldNames.flatMap(apiFieldName => {
+    let queryField = getQueryFieldOrThrow(table, entityName, apiFieldName, "where");
+    let operators = where[apiFieldName];
+    if (typeof operators !== "object" || Array.isArray(operators) || operators === null) {
+      Stdlib_JsError.throwWithMessage(`Invalid value in db.find("` + entityName + `", { where: { ` + apiFieldName + `: ... } }). Provide an operator like { _eq: value }.`);
+    }
+    let operatorKeys = Object.keys(operators);
+    if (operatorKeys.length === 0) {
+      Stdlib_JsError.throwWithMessage(`Empty operator in db.find("` + entityName + `", { where: { ` + apiFieldName + `: {} } }). Valid operators are _eq, _gt, _lt, _gte, _lte, _in.`);
+    }
+    return operatorKeys.map(operator => {
+      let value = operators[operator];
+      let bind = isArrayOpt => {
+        let isArray = isArrayOpt !== undefined ? isArrayOpt : false;
+        return bindOrThrow(queryField, entityName, apiFieldName, operator, value, isArray, params);
+      };
+      let column = `"` + queryField.pgDbFieldName + `"`;
+      switch (operator) {
+        case "_eq" :
+          return column + ` = ` + bind(undefined);
+        case "_gt" :
+          return column + ` > ` + bind(undefined);
+        case "_gte" :
+          return column + ` >= ` + bind(undefined);
+        case "_in" :
+          if (!Array.isArray(value)) {
+            Stdlib_JsError.throwWithMessage(`Invalid value in db.find("` + entityName + `", { where: { ` + apiFieldName + `: { _in: ... } } }). _in takes an array.`);
+          }
+          return column + ` = ANY(` + bind(true) + `)`;
+        case "_lt" :
+          return column + ` < ` + bind(undefined);
+        case "_lte" :
+          return column + ` <= ` + bind(undefined);
+        default:
+          return Stdlib_JsError.throwWithMessage(`Invalid operator "` + operator + `" in db.find("` + entityName + `", { where: { ` + apiFieldName + `: { ` + operator + `: ... } } }). Valid operators are _eq, _gt, _lt, _gte, _lte, _in.`);
+      }
+    });
+  }).join(" AND ");
+}
+
+function makeOrderByClause(table, entityName, orderBy) {
+  if (orderBy.length !== 0) {
+    return " ORDER BY " + orderBy.map(param => {
+      let field = param.field;
+      let queryField = getQueryFieldOrThrow(table, entityName, field, "orderBy");
+      let other = param.direction.toLowerCase();
+      let direction;
+      switch (other) {
+        case "asc" :
+          direction = "ASC";
+          break;
+        case "desc" :
+          direction = "DESC";
+          break;
+        default:
+          direction = Stdlib_JsError.throwWithMessage(`Invalid direction "` + other + `" in db.find("` + entityName + `", { orderBy: [{ field: "` + field + `" }] }). Use "asc" or "desc".`);
+      }
+      return `"` + queryField.pgDbFieldName + `" ` + direction;
+    }).join(", ");
+  } else {
+    return "";
+  }
+}
+
+function makeBoundCount(keyword, entityName, count, params) {
+  if (count < 0 || Math.trunc(count) !== count) {
+    Stdlib_JsError.throwWithMessage(`Invalid ` + keyword.toLowerCase() + ` ` + count.toString() + ` in db.find("` + entityName + `"). It must be a non-negative whole number.`);
+  }
+  params.push(count);
+  return ` ` + keyword + ` $` + params.length.toString();
+}
+
+function makeFindQuery(options) {
+  let entityConfig = options.entityConfig;
+  let table = entityConfig.table;
+  let entityName = entityConfig.name;
+  let params = [];
+  let where = options.where;
+  let whereClause = where !== undefined ? " WHERE " + makeWhereCondition(table, entityName, where, params) : "";
+  let orderBy = options.orderBy;
+  let orderByClause = orderBy !== undefined ? makeOrderByClause(table, entityName, orderBy) : "";
+  let count = options.limit;
+  let limitClause = count !== undefined ? makeBoundCount("LIMIT", entityName, count, params) : "";
+  let count$1 = options.offset;
+  let offsetClause = count$1 !== undefined ? makeBoundCount("OFFSET", entityName, count$1, params) : "";
+  return {
+    text: `SELECT * FROM ` + quoted(options.pgSchema, table.tableName) + whereClause + orderByClause + limitClause + offsetClause + `;`,
+    params: params
+  };
+}
+
+function makeGetQuery(entityConfig, pgSchema, id) {
+  let table = entityConfig.table;
+  let entityName = entityConfig.name;
+  let match = Table.getChainIdField(table);
+  if (match !== undefined) {
+    Stdlib_JsError.throwWithMessage(`db.get("` + entityName + `", id) is ambiguous: the entity is per-chain, so the same id can exist on every chain. Use db.find("` + entityName + `", { where: { id: { _eq: id }, ` + Config.chainIdFieldName + `: { _eq: chainId } } }).`);
+  }
+  let params = [];
+  let queryField = getQueryFieldOrThrow(table, entityName, Table.idFieldName, "where");
+  let placeholder = bindOrThrow(queryField, entityName, Table.idFieldName, "_eq", id, false, params);
+  return {
+    text: `SELECT * FROM ` + quoted(pgSchema, table.tableName) + ` WHERE "` + queryField.pgDbFieldName + `" = ` + placeholder + ` LIMIT 1;`,
+    params: params
+  };
+}
+
+function decodeRows(entityConfig, rows) {
+  return S$RescriptSchema.parseOrThrow(rows, Table.pgRowsSchema(entityConfig.table));
+}
+
+let chainColumns = [
+  "id",
+  "ecosystem",
+  "start_block",
+  "end_block",
+  "source_block",
+  "buffer_block",
+  "progress_block",
+  "ready_at"
+];
+
+let chainRowsSchema = S$RescriptSchema.array(S$RescriptSchema.object(s => ({
+  id: s.f("id", S$RescriptSchema.unknown),
+  ecosystem: s.f("ecosystem", S$RescriptSchema.string),
+  startBlock: s.f("start_block", S$RescriptSchema.int),
+  endBlock: s.f("end_block", S$RescriptSchema.$$null(S$RescriptSchema.int)),
+  sourceBlock: s.f("source_block", S$RescriptSchema.int),
+  bufferBlock: s.f("buffer_block", S$RescriptSchema.int),
+  progressBlock: s.f("progress_block", S$RescriptSchema.int),
+  readyAt: s.f("ready_at", S$RescriptSchema.$$null(Utils.Schema.dbDate))
+})));
+
+function makeChainHeightsQuery(pgSchema) {
+  return {
+    text: `SELECT ` + chainColumns.map(column => `"` + column + `"`).join(", ") + ` FROM ` + quoted(pgSchema, InternalTable.Chains.table.tableName) + `;`,
+    params: []
+  };
+}
+
+function decodeChainHeights(rows) {
+  let heights = {};
+  S$RescriptSchema.parseOrThrow(rows, chainRowsSchema).forEach(row => {
+    let chainId = ChainId.normalizeOrThrow(row.id);
+    heights[ChainId.toString(chainId)] = {
+      chainId: chainId,
+      ecosystem: row.ecosystem,
+      startBlock: row.startBlock,
+      endBlock: Stdlib_Null.fromOption(row.endBlock),
+      sourceBlock: row.sourceBlock,
+      bufferBlock: row.bufferBlock,
+      progressBlock: row.progressBlock,
+      readyAt: Stdlib_Null.fromOption(row.readyAt),
+      isReady: Stdlib_Option.isSome(row.readyAt)
+    };
+  });
+  return heights;
+}
+
+export {
+  quoted,
+  getQueryFieldOrThrow,
+  bindOrThrow,
+  makeWhereCondition,
+  makeOrderByClause,
+  makeBoundCount,
+  makeFindQuery,
+  makeGetQuery,
+  decodeRows,
+  chainColumns,
+  chainRowsSchema,
+  makeChainHeightsQuery,
+  decodeChainHeights,
+}
+/* chainRowsSchema Not a pure module */

package/src/resolvers/collisions.js

@@ -0,0 +1,108 @@
+// Names envio-serve derives from schema.graphql, which a custom resolver must
+// not squat.
+//
+// This mirrors the builder in envio-serve's `gql/schema_build.rs`: the two are
+// one contract, and drift shows up as a schema serve refuses to start on.
+// Serve does re-check at startup, deliberately -- but by then the user is
+// reading a deployment log, and the build is where they can act. Hence both,
+// as §6.1 asks.
+//
+// Not covered here: the `<scalar>_comparison_exp` types serve derives from
+// column types. Mapping an entity field's type to serve's scalar name is not
+// something this side can do without guessing, and serve's own check is the
+// backstop for it.
+
+const ROOT_AND_BUILTIN_TYPES = [
+  "query_root",
+  "subscription_root",
+  "order_by",
+  "cursor_ordering",
+  "Boolean",
+  "Float",
+  "ID",
+  "Int",
+  "String",
+];
+
+const rootFieldsOf = (entity) => [
+  [entity, `entity '${entity}'`],
+  [`${entity}_by_pk`, `the by-primary-key field of entity '${entity}'`],
+  [`${entity}_aggregate`, `the aggregate field of entity '${entity}'`],
+  [`${entity}_stream`, `the subscription stream of entity '${entity}'`],
+];
+
+const typesOf = (entity) =>
+  [
+    "",
+    "_aggregate",
+    "_aggregate_bool_exp",
+    "_aggregate_bool_exp_count",
+    "_aggregate_fields",
+    "_aggregate_order_by",
+    "_bool_exp",
+    "_order_by",
+    "_select_column",
+    "_stream_cursor_input",
+    "_stream_cursor_value_input",
+  ].map((suffix) => [
+    `${entity}${suffix}`,
+    suffix === ""
+      ? `the row type of entity '${entity}'`
+      : `a type generated for entity '${entity}'`,
+  ]);
+
+/** Every generated name, mapped to how it would read in an error. */
+export function reservedNames({ entities = [], enums = [] }) {
+  const rootFields = new Map();
+  const types = new Map();
+
+  for (const [name, describe] of ROOT_AND_BUILTIN_TYPES.map((name) => [
+    name,
+    "a built-in GraphQL type name",
+  ])) {
+    types.set(name, describe);
+  }
+  for (const name of enums) {
+    types.set(name, "an enum declared in schema.graphql");
+  }
+  for (const entity of entities) {
+    for (const [name, describe] of rootFieldsOf(entity)) {
+      rootFields.set(name, describe);
+    }
+    for (const [name, describe] of typesOf(entity)) {
+      types.set(name, describe);
+    }
+  }
+  return { rootFields, types };
+}
+
+/**
+ * Throws when a manifest declares a root field or type name envio-serve
+ * generates. Reports all of them at once: renaming one at a time through a
+ * build each is the slow way to find out there were three.
+ */
+export function checkCollisions(manifest, { entities, enums }) {
+  const reserved = reservedNames({ entities, enums });
+  const found = [];
+
+  for (const resolver of manifest.resolvers) {
+    const describe = reserved.rootFields.get(resolver.name);
+    if (describe !== undefined) {
+      found.push(`  - resolver '${resolver.name}' is ${describe}`);
+    }
+  }
+  for (const type of manifest.types) {
+    const describe = reserved.types.get(type.name);
+    if (describe !== undefined) {
+      found.push(`  - type '${type.name}' is ${describe}`);
+    }
+  }
+
+  if (found.length > 0) {
+    throw new Error(
+      `Custom resolvers collide with names envio-serve generates from schema.graphql:\n${found.join(
+        "\n"
+      )}\nRename them: envio-serve owns those names and refuses to start on an ambiguous schema.`
+    );
+  }
+}