@stigmer/mcp-server 3.11.1-dev.20260812192248 → 3.12.0

package/src/domains/records/tools.ts

@@ -1,210 +0,0 @@
-// MCP tools for the Datastore record domain — the five agent-facing
-// record tools of DD-005: 1:1 projections of the record RPCs, with the
-// records-own error mapper (errors.ts) and honest MCP annotations (the
-// bridge's first use of annotations; the platform's own connect-time
-// classifier honors destructiveHint fail-closed for external clients,
-// while the runner-synthesized attachment is approval-free by
-// construction and never passes through that classifier).
-//
-// Two audiences, one definition (registered per roster):
-//   - "agent" (the records-only roster the runner-synthesized
-//     attachment connects to): NO `org` argument — a session-bound
-//     caller's org is server-derived from the session, and an explicit
-//     org is rejected (T05 R3), so offering the argument would only
-//     invite rejected calls.
-//   - "direct" (the main roster external MCP clients see): optional
-//     `org`, which cloud direct principals must name (their credential
-//     carries no ambient org — the DD-006 session-14 amendment). OSS
-//     resolves an empty org to the local system org.
-// `partition` is deliberately NOT a tool argument for either audience
-// (DD-010: never from tool arguments); partition-explicit work is the
-// console/CLI/SDK surface.
-
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
-
-import { resolveToken, type BackendTarget } from "../client.js";
-import {
-  deleteRecord,
-  describeDatastore,
-  findRecords,
-  insertRecord,
-  updateRecord,
-  type ConditionArg,
-} from "./calls.js";
-import { recordResult } from "./errors.js";
-
-/** Which roster the tools are being registered on (see file header). */
-export type RecordToolAudience = "agent" | "direct";
-
-const ENCODINGS =
-  "Field value encodings: date YYYY-MM-DD, time HH:MM[:SS], timestamp RFC 3339 UTC " +
-  "(e.g. 2026-07-21T04:30:00Z).";
-
-const scalar = z.union([z.string(), z.number(), z.boolean()]);
-
-const conditionShape = z.object({
-  field: z
-    .string()
-    .describe("Declared field name, or a filterable system field (id, created_at, updated_at)."),
-  op: z
-    .enum(["eq", "neq", "gt", "gte", "lt", "lte", "in", "not_in", "is_null", "not_null"])
-    .describe(
-      "Comparison operator. eq/neq/in/not_in for string and enum fields; " +
-        "gt/gte/lt/lte for numeric and temporal fields; is_null/not_null for optional fields.",
-    ),
-  value: scalar
-    .nullable()
-    .optional()
-    .describe("Comparison value for scalar operators, in the field's canonical encoding."),
-  values: z.array(scalar).optional().describe("Comparison values for in / not_in."),
-});
-
-/** Register the five record tools for one audience; returns the tool names. */
-export function registerRecordTools(
-  server: McpServer,
-  target: BackendTarget,
-  audience: RecordToolAudience,
-): string[] {
-  // The org argument exists only on the direct roster (file header).
-  const orgShape: { org?: z.ZodOptional<z.ZodString> } = {};
-  if (audience === "direct") {
-    orgShape.org = z
-      .string()
-      .optional()
-      .describe(
-        "Organization that owns the datastore. Required on Stigmer Cloud; " +
-          "omit against a local backend.",
-      );
-  }
-
-  server.registerTool(
-    "describe_datastore",
-    {
-      description:
-        "Describe a datastore: its collections, field declarations and encodings, constraint " +
-        "messages, data partitions, and the verbs you are allowed to use per collection " +
-        "(empty access means you are not allowed to touch that collection). A read verb may " +
-        "carry readable_fields: reads then return only those fields, and only they may appear " +
-        "in filter conditions and order_by (empty readable_fields means every field). Call " +
-        `this before the first record operation against an unfamiliar datastore. ${ENCODINGS}`,
-      inputSchema: {
-        datastore: z.string().describe("Datastore slug (e.g. clinic)."),
-        ...orgShape,
-      },
-      annotations: { readOnlyHint: true },
-    },
-    (args, extra) =>
-      recordResult(`datastore "${args.datastore}"`, () =>
-        describeDatastore(target.serverAddress, resolveToken(extra, target.apiKey), args),
-      ),
-  );
-
-  server.registerTool(
-    "find_records",
-    {
-      description:
-        "Find records in a datastore collection with a typed filter (conditions are AND-combined). " +
-        "Returns records plus total/limit/offset for paging. Results are ordered by created_at " +
-        "descending unless order_by is given. Records carry only the fields your grant allows " +
-        "(describe_datastore lists them as readable_fields); conditions and order_by on other " +
-        `fields are rejected. ${ENCODINGS}`,
-      inputSchema: {
-        datastore: z.string().describe("Datastore slug (e.g. clinic)."),
-        ...orgShape,
-        collection: z.string().describe("Collection to query (e.g. bookings)."),
-        conditions: z
-          .array(conditionShape)
-          .optional()
-          .describe("Filter conditions, AND-combined. Omit to list all readable records."),
-        order_by: z
-          .object({
-            field: z.string().describe("Field to sort by."),
-            direction: z.enum(["asc", "desc"]).optional().describe("Sort direction (default asc)."),
-          })
-          .optional()
-          .describe("Sort order. Omit for created_at descending with id tiebreak."),
-        limit: z.number().int().optional().describe("Page size (default 25, max 100)."),
-        offset: z.number().int().optional().describe("Records to skip for paging."),
-      },
-      annotations: { readOnlyHint: true },
-    },
-    (args, extra) =>
-      recordResult(`records in "${args.datastore}/${args.collection}"`, () =>
-        findRecords(target.serverAddress, resolveToken(extra, target.apiKey), {
-          ...args,
-          conditions: args.conditions as ConditionArg[] | undefined,
-        }),
-      ),
-  );
-
-  server.registerTool(
-    "insert_record",
-    {
-      description:
-        "Insert one record into a datastore collection. System fields (id, created_at, " +
-        "updated_at, created_by) are server-stamped — never include them. Declared constraints " +
-        "are enforced by the store; a violation returns the constraint's message verbatim " +
-        "(e.g. a taken slot returns ALREADY_EXISTS — pick another, do not retry the same one). " +
-        `When uncertain whether a record already exists, find first. ${ENCODINGS}`,
-      inputSchema: {
-        datastore: z.string().describe("Datastore slug (e.g. clinic)."),
-        ...orgShape,
-        collection: z.string().describe("Collection to insert into (e.g. bookings)."),
-        record: z
-          .record(z.unknown())
-          .describe("Declared fields for the new record, in canonical encodings."),
-      },
-    },
-    (args, extra) =>
-      recordResult(`record in "${args.datastore}/${args.collection}"`, () =>
-        insertRecord(target.serverAddress, resolveToken(extra, target.apiKey), args),
-      ),
-  );
-
-  server.registerTool(
-    "update_record",
-    {
-      description:
-        "Update one record by id with a partial merge: only the supplied fields change, and an " +
-        "explicit null clears a field. Constraints are re-evaluated on the merged result. " +
-        `Returns the full updated record. ${ENCODINGS}`,
-      inputSchema: {
-        datastore: z.string().describe("Datastore slug (e.g. clinic)."),
-        ...orgShape,
-        collection: z.string().describe("Collection holding the record."),
-        id: z.string().describe("Record id (from a previous find or insert)."),
-        fields: z
-          .record(z.unknown())
-          .describe("Fields to merge. Explicit null clears a field; omitted fields keep their values."),
-      },
-      annotations: { idempotentHint: true },
-    },
-    (args, extra) =>
-      recordResult(`record "${args.id}" in "${args.datastore}/${args.collection}"`, () =>
-        updateRecord(target.serverAddress, resolveToken(extra, target.apiKey), args),
-      ),
-  );
-
-  server.registerTool(
-    "delete_record",
-    {
-      description:
-        "Delete one record by id. Returns the deleted record. Record tools never delete " +
-        "collections or datastores.",
-      inputSchema: {
-        datastore: z.string().describe("Datastore slug (e.g. clinic)."),
-        ...orgShape,
-        collection: z.string().describe("Collection holding the record."),
-        id: z.string().describe("Record id (from a previous find or insert)."),
-      },
-      annotations: { destructiveHint: true, idempotentHint: true },
-    },
-    (args, extra) =>
-      recordResult(`record "${args.id}" in "${args.datastore}/${args.collection}"`, () =>
-        deleteRecord(target.serverAddress, resolveToken(extra, target.apiKey), args),
-      ),
-  );
-
-  return ["describe_datastore", "find_records", "insert_record", "update_record", "delete_record"];
-}

package/src/gen/datastore.ts

@@ -1,264 +0,0 @@
-// Code generated by stigmer-codegen --target=mcp-ts. DO NOT EDIT.
-//
-// Flattened apply-input zod schema + toProto bridge for the Datastore resource.
-// Source proto package: ai.stigmer.agentic.datastore.v1
-
-import { generateSlug, visibilityFromString, enumFromString } from "./apply-runtime.js";
-import { create, fromJson, type JsonValue } from "@bufbuild/protobuf";
-import { ValueSchema } from "@bufbuild/protobuf/wkt";
-import { DatastoreSchema, type Datastore } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/api_pb";
-import { DatastoreSpecSchema, DatastoreRoleSchema, ChannelSenderSubjectSchema, DatastoreSubjectSchema, DatastoreRoleBindingSchema, DatastoreAuthorizationSchema, FieldDeclarationSchema, FieldType, UniqueWhereSchema, UniqueConstraintSchema, CheckConstraintSchema, ExistsConstraintSchema, DatastoreGrantSchema, DatastoreVerb, DatastoreGrantScope, CollectionDeclarationSchema } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/spec_pb";
-import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/metadata_pb";
-import { ApiResourceRefSchema } from "@stigmer/protos/ai/stigmer/iam/iampolicy/v1/spec_pb";
-import { z } from "zod";
-
-/** DatastoreSpec declares typed record collections with constraints and role-aware access grants. */
-export const DatastoreInputShape = {
-  name: z.string().describe("Human-readable name of the resource."),
-  slug: z.string().optional().describe("URL-friendly identifier (lowercase alphanumeric with hyphens). Auto-generated from name if omitted."),
-  org: z.string().describe("Organization that owns this resource (e.g. acme)."),
-  visibility: z.string().optional().describe("Resource visibility: PRIVATE or PUBLIC. Omit to leave unchanged on updates."),
-  labels: z.record(z.string()).optional().describe("Key-value labels for organization and filtering."),
-  tags: z.array(z.string()).optional().describe("Tags for categorization and discovery."),
-  description: z.string().optional().describe("Human-readable description of what this datastore holds."),
-  timezone: z.string().optional().describe("IANA timezone (e.g. 'Asia/Kolkata') for constraint evaluation. Bound as the constant 'tz' in check and exists constraint expressions. Optional; when unset, expressions that reference 'tz' are rejected at apply time."),
-  authorization: z.lazy(() => DatastoreAuthorizationInputSchema).optional().describe("Record-layer authorization: roles, subject bindings, and the default role for unbound callers."),
-  collections: z.array(z.lazy(() => CollectionDeclarationInputSchema)).optional().describe("Record collections declared by this datastore."),
-} as const;
-
-export const DatastoreInputSchema = z.object(DatastoreInputShape);
-export type DatastoreInput = z.infer<typeof DatastoreInputSchema>;
-
-const DatastoreRoleInputSchema = z.object({
-  name: z.string().describe("Role name, referenced by bindings, grants, and default_role."),
-});
-type DatastoreRoleInput = z.infer<typeof DatastoreRoleInputSchema>;
-
-const ChannelSenderSubjectInputSchema = z.object({
-  sender_kind: z.string().describe("Sender identity namespace. Must be a namespace the platform's channel brokers can stamp — today 'whatsapp_phone'; unrecognized namespaces are refused at apply time (they could never match)."),
-  value: z.string().describe("Sender identity value within the namespace, in the exact wire shape the channel broker stamps. For 'whatsapp_phone' this is Meta's wa_id: DIGITS ONLY, no '+', no separators (e.g. '919800000001' — NOT the '+'-prefixed E.164 form). Apply-time validation refuses any other shape, because subject matching is exact string equality and a mis-shaped value would bind and silently never match."),
-});
-type ChannelSenderSubjectInput = z.infer<typeof ChannelSenderSubjectInputSchema>;
-
-const ApiResourceRefInputSchema = z.object({
-  kind: z.string().describe("Type of the API resource being referenced This should be the resource kind as defined in ApiResourceKind enum. Examples: 'identity_account', 'team', 'organization', 'environment', 'cloud_resource', 'service', etc."),
-  id: z.string().describe("Unique identifier of the resource This is the resource's ID field (e.g., ia-01HQUSER123, tm-01HQTEAM456)"),
-  relation: z.string().optional().describe("Optional relation qualifier for the resource reference. Used when the reference needs additional context about the relationship. Primary use case: For team principals, this specifies the relation of the user to the team (e.g., 'member', 'admin'). Example: principal { kind: 'team', id: 'tm-123', relation: 'member' } means 'members of team tm-123' This field qualifies HOW the principal relates to this resource reference, NOT the permission being granted (that's IamPolicySpec.relation)."),
-});
-type ApiResourceRefInput = z.infer<typeof ApiResourceRefInputSchema>;
-
-const DatastoreSubjectInputSchema = z.object({
-  channel_sender: z.lazy(() => ChannelSenderSubjectInputSchema).optional().describe("Channel sender identity, matched against the session metadata stamped by the channel broker."),
-  principal: z.lazy(() => ApiResourceRefInputSchema).optional().describe("Platform principal (an identity account today; teams later without schema change)."),
-});
-type DatastoreSubjectInput = z.infer<typeof DatastoreSubjectInputSchema>;
-
-const DatastoreRoleBindingInputSchema = z.object({
-  subject: z.lazy(() => DatastoreSubjectInputSchema).describe("The caller identity this binding matches."),
-  role: z.string().describe("Name of a declared role."),
-});
-type DatastoreRoleBindingInput = z.infer<typeof DatastoreRoleBindingInputSchema>;
-
-const DatastoreAuthorizationInputSchema = z.object({
-  roles: z.array(z.lazy(() => DatastoreRoleInputSchema)).optional().describe("Role names referenced by bindings and grants (e.g. 'admin', 'patient')."),
-  bindings: z.array(z.lazy(() => DatastoreRoleBindingInputSchema)).optional().describe("Subject-to-role bindings."),
-  default_role: z.string().optional().describe("Role an unbound caller resolves to. Applies to channel senders with no binding and platform principals with no binding. When empty, unbound callers are denied every verb."),
-});
-type DatastoreAuthorizationInput = z.infer<typeof DatastoreAuthorizationInputSchema>;
-
-const FieldDeclarationInputSchema = z.object({
-  name: z.string().describe("Field name, unique within the collection. Format: lowercase snake_case. The record envelope's system field names (id, created_at, updated_at, created_by), 'org', and 'partition' are reserved."),
-  type: z.string().describe("Value type for this field. Allowed values: string, integer, number, bool, timestamp, date, time, json."),
-  required: z.boolean().optional().describe("Whether a value must be present on every record. Absent optional fields evaluate as null in constraint expressions."),
-  default: z.unknown().optional().describe("Default value applied when the field is absent on insert."),
-  enum_values: z.array(z.string()).optional().describe("Allowed values for string fields. Declaring enum_values on a non-string field is rejected."),
-  description: z.string().optional().describe("Human-readable description, surfaced to agents via describe_datastore."),
-});
-type FieldDeclarationInput = z.infer<typeof FieldDeclarationInputSchema>;
-
-const UniqueWhereInputSchema = z.object({
-  field: z.string().describe("Declared field the condition tests."),
-  equals: z.unknown().describe("Value the field must equal for the constraint to apply."),
-});
-type UniqueWhereInput = z.infer<typeof UniqueWhereInputSchema>;
-
-const UniqueConstraintInputSchema = z.object({
-  name: z.string().describe("Constraint name, unique within the collection."),
-  fields: z.array(z.string()).optional().describe("Declared fields whose combined values must be unique."),
-  where: z.lazy(() => UniqueWhereInputSchema).optional().describe("Limits the constraint to records matching this condition (e.g. only 'status == 'confirmed'' bookings must be unique per slot)."),
-  message: z.string().describe("Error message returned on violation, written to be relayed to an end user by an agent (e.g. 'that slot is already booked')."),
-});
-type UniqueConstraintInput = z.infer<typeof UniqueConstraintInputSchema>;
-
-const CheckConstraintInputSchema = z.object({
-  name: z.string().describe("Constraint name, unique within the collection."),
-  expression: z.string().describe("CEL expression that must evaluate true for the record to be written."),
-  when: z.string().optional().describe("Optional CEL gate: the check applies only when this evaluates true."),
-  message: z.string().describe("Error message returned on violation, written to be relayed to an end user by an agent."),
-});
-type CheckConstraintInput = z.infer<typeof CheckConstraintInputSchema>;
-
-const ExistsConstraintInputSchema = z.object({
-  name: z.string().describe("Constraint name, unique within the collection."),
-  collection: z.string().describe("Target collection in the same datastore."),
-  where: z.string().describe("CEL condition matching candidate ('this') against target records ('that')."),
-  when: z.string().optional().describe("Optional CEL gate: the constraint applies only when this evaluates true."),
-  message: z.string().describe("Error message returned on violation, written to be relayed to an end user by an agent."),
-});
-type ExistsConstraintInput = z.infer<typeof ExistsConstraintInputSchema>;
-
-const DatastoreGrantInputSchema = z.object({
-  role: z.string().describe("Name of a declared role."),
-  verbs: z.array(z.string()).optional().describe("Verbs granted to the role on this collection. Allowed values: read, insert, update, delete."),
-  scope: z.string().optional().describe("Row scope of the grant. Defaults to all records. 'own' limits update and delete (and read) to records whose server-stamped created_by matches the caller. Allowed values: all, own."),
-  read_fields: z.array(z.string()).optional().describe("Field allowlist for the read verb: when set, reads by this role return only these fields, and filter conditions and order_by may reference only these fields. Empty means every field is readable. Entries name declared fields of the collection, or 'created_by' to expose the attribution subject. The system fields id, created_at, and updated_at are always readable."),
-});
-type DatastoreGrantInput = z.infer<typeof DatastoreGrantInputSchema>;
-
-const CollectionDeclarationInputSchema = z.object({
-  name: z.string().describe("Collection name, unique within the datastore. Format: lowercase snake_case (e.g. 'bookings', 'schedule_exceptions')."),
-  description: z.string().optional().describe("Human-readable description of what records in this collection represent."),
-  fields: z.array(z.lazy(() => FieldDeclarationInputSchema)).optional().describe("Typed field declarations for records in this collection."),
-  uniques: z.array(z.lazy(() => UniqueConstraintInputSchema)).optional().describe("Uniqueness constraints, enforced by substrate indexes."),
-  checks: z.array(z.lazy(() => CheckConstraintInputSchema)).optional().describe("Single-record check constraints, evaluated on every insert and update."),
-  exists: z.array(z.lazy(() => ExistsConstraintInputSchema)).optional().describe("Cross-collection constraints requiring a matching record to exist."),
-  not_exists: z.array(z.lazy(() => ExistsConstraintInputSchema)).optional().describe("Cross-collection constraints requiring no matching record to exist."),
-  grants: z.array(z.lazy(() => DatastoreGrantInputSchema)).optional().describe("Per-role access grants for records in this collection. Deny by default: a role with no grant on a collection has no access to it."),
-});
-type CollectionDeclarationInput = z.infer<typeof CollectionDeclarationInputSchema>;
-
-
-/** Build the fully-formed Datastore proto from the flat MCP apply input. */
-export function datastoreInputToProto(input: DatastoreInput): Datastore {
-  const slug = input.slug && input.slug.length > 0 ? input.slug : generateSlug(input.name);
-  const spec = create(DatastoreSpecSchema);
-  if (input.description !== undefined) spec.description = input.description;
-  if (input.timezone !== undefined) spec.timezone = input.timezone;
-  if (input.authorization !== undefined) spec.authorization = datastoreAuthorizationInputToProto(input.authorization);
-  if (input.collections !== undefined) spec.collections = input.collections.map(collectionDeclarationInputToProto);
-  return Object.assign(create(DatastoreSchema), {
-    apiVersion: "agentic.stigmer.ai/v1",
-    kind: "Datastore",
-    metadata: Object.assign(create(ApiResourceMetadataSchema), {
-      name: input.name,
-      slug,
-      org: input.org,
-      ...(input.visibility !== undefined && { visibility: visibilityFromString(input.visibility) }),
-      ...(input.labels !== undefined && { labels: input.labels }),
-      ...(input.tags !== undefined && { tags: input.tags }),
-    }),
-    spec,
-  }) as Datastore;
-}
-
-function datastoreRoleInputToProto(input: DatastoreRoleInput) {
-  const result = create(DatastoreRoleSchema);
-  if (input.name !== undefined) result.name = input.name;
-  return result;
-}
-
-function channelSenderSubjectInputToProto(input: ChannelSenderSubjectInput) {
-  const result = create(ChannelSenderSubjectSchema);
-  if (input.sender_kind !== undefined) result.senderKind = input.sender_kind;
-  if (input.value !== undefined) result.value = input.value;
-  return result;
-}
-
-function apiResourceRefInputToProto(input: ApiResourceRefInput) {
-  const result = create(ApiResourceRefSchema);
-  if (input.kind !== undefined) result.kind = input.kind;
-  if (input.id !== undefined) result.id = input.id;
-  if (input.relation !== undefined) result.relation = input.relation;
-  return result;
-}
-
-function datastoreSubjectInputToProto(input: DatastoreSubjectInput) {
-  const result = create(DatastoreSubjectSchema);
-  if (input.channel_sender !== undefined) result.kind = { case: "channelSender", value: channelSenderSubjectInputToProto(input.channel_sender) };
-  if (input.principal !== undefined) result.kind = { case: "principal", value: apiResourceRefInputToProto(input.principal) };
-  return result;
-}
-
-function datastoreRoleBindingInputToProto(input: DatastoreRoleBindingInput) {
-  const result = create(DatastoreRoleBindingSchema);
-  if (input.subject !== undefined) result.subject = datastoreSubjectInputToProto(input.subject);
-  if (input.role !== undefined) result.role = input.role;
-  return result;
-}
-
-function datastoreAuthorizationInputToProto(input: DatastoreAuthorizationInput) {
-  const result = create(DatastoreAuthorizationSchema);
-  if (input.roles !== undefined) result.roles = input.roles.map(datastoreRoleInputToProto);
-  if (input.bindings !== undefined) result.bindings = input.bindings.map(datastoreRoleBindingInputToProto);
-  if (input.default_role !== undefined) result.defaultRole = input.default_role;
-  return result;
-}
-
-function fieldDeclarationInputToProto(input: FieldDeclarationInput) {
-  const result = create(FieldDeclarationSchema);
-  if (input.name !== undefined) result.name = input.name;
-  result.type = enumFromString(FieldType, input.type) as FieldType;
-  if (input.required !== undefined) result.required = input.required;
-  if (input.default !== undefined) result.default = fromJson(ValueSchema, input.default as JsonValue);
-  if (input.enum_values !== undefined) result.enumValues = input.enum_values;
-  if (input.description !== undefined) result.description = input.description;
-  return result;
-}
-
-function uniqueWhereInputToProto(input: UniqueWhereInput) {
-  const result = create(UniqueWhereSchema);
-  if (input.field !== undefined) result.field = input.field;
-  if (input.equals !== undefined) result.equals = fromJson(ValueSchema, input.equals as JsonValue);
-  return result;
-}
-
-function uniqueConstraintInputToProto(input: UniqueConstraintInput) {
-  const result = create(UniqueConstraintSchema);
-  if (input.name !== undefined) result.name = input.name;
-  if (input.fields !== undefined) result.fields = input.fields;
-  if (input.where !== undefined) result.where = uniqueWhereInputToProto(input.where);
-  if (input.message !== undefined) result.message = input.message;
-  return result;
-}
-
-function checkConstraintInputToProto(input: CheckConstraintInput) {
-  const result = create(CheckConstraintSchema);
-  if (input.name !== undefined) result.name = input.name;
-  if (input.expression !== undefined) result.expression = input.expression;
-  if (input.when !== undefined) result.when = input.when;
-  if (input.message !== undefined) result.message = input.message;
-  return result;
-}
-
-function existsConstraintInputToProto(input: ExistsConstraintInput) {
-  const result = create(ExistsConstraintSchema);
-  if (input.name !== undefined) result.name = input.name;
-  if (input.collection !== undefined) result.collection = input.collection;
-  if (input.where !== undefined) result.where = input.where;
-  if (input.when !== undefined) result.when = input.when;
-  if (input.message !== undefined) result.message = input.message;
-  return result;
-}
-
-function datastoreGrantInputToProto(input: DatastoreGrantInput) {
-  const result = create(DatastoreGrantSchema);
-  if (input.role !== undefined) result.role = input.role;
-  if (input.verbs !== undefined) result.verbs = input.verbs.map((v) => enumFromString(DatastoreVerb, v) as DatastoreVerb);
-  result.scope = enumFromString(DatastoreGrantScope, input.scope) as DatastoreGrantScope;
-  if (input.read_fields !== undefined) result.readFields = input.read_fields;
-  return result;
-}
-
-function collectionDeclarationInputToProto(input: CollectionDeclarationInput) {
-  const result = create(CollectionDeclarationSchema);
-  if (input.name !== undefined) result.name = input.name;
-  if (input.description !== undefined) result.description = input.description;
-  if (input.fields !== undefined) result.fields = input.fields.map(fieldDeclarationInputToProto);
-  if (input.uniques !== undefined) result.uniques = input.uniques.map(uniqueConstraintInputToProto);
-  if (input.checks !== undefined) result.checks = input.checks.map(checkConstraintInputToProto);
-  if (input.exists !== undefined) result.exists = input.exists.map(existsConstraintInputToProto);
-  if (input.not_exists !== undefined) result.notExists = input.not_exists.map(existsConstraintInputToProto);
-  if (input.grants !== undefined) result.grants = input.grants.map(datastoreGrantInputToProto);
-  return result;
-}
-