@procedures/mongo 0.32.0 → 0.34.0

package/src/procedures/documents.aggregate.ts

@@ -3,7 +3,7 @@
  * Run an aggregation pipeline
  */
 
-import { createProcedure, zodAdapter, type Effects, type Procedure, type ProcedureContext } from "@procedures/client";
+import { createProcedure, type Effects, type Procedure, type ProcedureContext } from "@procedures/client";
 import { collectionFor, type ScopeInput } from "../scope.js";
 import { scopeFields, documentObject } from "./input-schemas.js";
 import { z } from "zod";
@@ -25,8 +25,7 @@ interface AggregateOutput {
 }
 
 // Schemas
-const aggregateInputSchema = zodAdapter<AggregateInput>(
-  z.object({
+const aggregateInputSchema: z.ZodType<AggregateInput> = z.object({
     ...scopeFields(),
     pipeline: z.array(documentObject()).describe("The aggregation stages, in order (for example [{ $match: {...} }, { $group: {...} }])"),
     options: z
@@ -36,13 +35,10 @@ const aggregateInputSchema = zodAdapter<AggregateInput>(
       })
       .optional()
       .describe("The options of the aggregation"),
-  })
-);
-const aggregateOutputSchema = zodAdapter<AggregateOutput>(
-  z.looseObject({
+  });
+const aggregateOutputSchema: z.ZodType<AggregateOutput> = z.looseObject({
     results: z.array(z.record(z.string(), z.unknown())).describe("The documents that the pipeline gave"),
-  })
-);
+  });
 
 /** The stages that write to a collection. A read-only procedure refuses them (CAP-2). */
 const WRITING_STAGES = ["$out", "$merge"];

package/src/procedures/documents.bulk.ts

@@ -10,7 +10,7 @@
  * of an update or a delete needs `confirm: true`, and an unknown field is an error.
  */
 
-import { createProcedure, zodAdapter, type Effects, type Procedure, type ProcedureContext } from "@procedures/client";
+import { createProcedure, type Effects, type Procedure, type ProcedureContext } from "@procedures/client";
 import type { AnyBulkWriteOperation, Document } from "mongodb";
 import { z } from "zod";
 import { collectionFor, copyScope, SCOPE_FIELDS, type ScopeInput } from "../scope.js";
@@ -148,8 +148,7 @@ const bulkInputSchema = described<BulkInput>(
     confirm: z.boolean().optional().describe("Set to true to use an empty filter, which matches every document, in an update or a delete"),
   })
 );
-const bulkOutputSchema = zodAdapter<BulkOutput>(
-  z.looseObject({
+const bulkOutputSchema: z.ZodType<BulkOutput> = z.looseObject({
     ok: z.boolean().describe("True when the server confirmed the writes"),
     insertedCount: z.number().describe("The number of inserted documents"),
     matchedCount: z.number().describe("The number of documents that the updates matched"),
@@ -158,8 +157,7 @@ const bulkOutputSchema = zodAdapter<BulkOutput>(
     upsertedCount: z.number().describe("The number of documents that an upsert made"),
     insertedIds: z.record(z.string(), z.string()).describe("The ids of the inserted documents, as text, by the index of their operation"),
     upsertedIds: z.record(z.string(), z.string()).describe("The ids of the upserted documents, as text, by the index of their operation"),
-  })
-);
+  });
 
 export const bulkProcedure: Procedure<
   BulkInput,

package/src/procedures/documents.count.ts

@@ -3,7 +3,7 @@
  * Count documents matching a filter
  */
 
-import { createProcedure, zodAdapter, type Effects, type Procedure, type ProcedureContext } from "@procedures/client";
+import { createProcedure, type Effects, type Procedure, type ProcedureContext } from "@procedures/client";
 import { collectionFor, type ScopeInput } from "../scope.js";
 import { scopeFields, documentObject } from "./input-schemas.js";
 import { z } from "zod";
@@ -19,17 +19,13 @@ interface CountOutput {
 }
 
 // Schemas
-const countInputSchema = zodAdapter<CountInput>(
-  z.object({
+const countInputSchema: z.ZodType<CountInput> = z.object({
     ...scopeFields(),
     query: documentObject().optional().describe("The filter of the documents to count (default: all documents)"),
-  })
-);
-const countOutputSchema = zodAdapter<CountOutput>(
-  z.looseObject({
+  });
+const countOutputSchema: z.ZodType<CountOutput> = z.looseObject({
     count: z.number().describe("The number of documents that match"),
-  })
-);
+  });
 
 export const countProcedure: Procedure<
   CountInput,

package/src/procedures/documents.delete.ts

@@ -3,7 +3,7 @@
  * Delete documents matching a filter
  */
 
-import { createProcedure, type Effects, type Procedure, type ProcedureContext, zodAdapter } from "@procedures/client";
+import { createProcedure, type Effects, type Procedure, type ProcedureContext } from "@procedures/client";
 import { collectionFor } from "../scope.js";
 import { described, scopeFields, targetFields } from "./input-schemas.js";
 import { z } from "zod";
@@ -23,12 +23,10 @@ const deleteInputSchema = described<DeleteInput>(
   (data: unknown) => parseTarget("mongo.documents.delete", data).target,
   z.object({ ...scopeFields(), ...targetFields() })
 );
-const deleteOutputSchema = zodAdapter<DeleteOutput>(
-  z.looseObject({
+const deleteOutputSchema: z.ZodType<DeleteOutput> = z.looseObject({
     acknowledged: z.boolean().describe("True when the server confirmed the write"),
     deletedCount: z.number().describe("The number of deleted documents"),
-  })
-);
+  });
 
 export const deleteProcedure: Procedure<
   DeleteInput,

package/src/procedures/documents.distinct.ts

@@ -3,7 +3,7 @@
  * The distinct values of one field in the documents that match a filter
  */
 
-import { createProcedure, zodAdapter, type Effects, type Procedure, type ProcedureContext } from "@procedures/client";
+import { createProcedure, type Effects, type Procedure, type ProcedureContext } from "@procedures/client";
 import { collectionFor, type ScopeInput } from "../scope.js";
 import { scopeFields, documentObject } from "./input-schemas.js";
 import { z } from "zod";
@@ -22,18 +22,14 @@ interface DistinctOutput {
 }
 
 // Schemas
-const distinctInputSchema = zodAdapter<DistinctInput>(
-  z.object({
+const distinctInputSchema: z.ZodType<DistinctInput> = z.object({
     ...scopeFields(),
     field: z.string().min(1).describe('The field, with dots for an embedded field (for example "address.city")'),
     query: documentObject().optional().describe("The filter of the documents (default: all documents)"),
-  })
-);
-const distinctOutputSchema = zodAdapter<DistinctOutput>(
-  z.looseObject({
+  });
+const distinctOutputSchema: z.ZodType<DistinctOutput> = z.looseObject({
     values: z.array(z.unknown()).describe("The distinct values of the field. An array field gives each of its elements."),
-  })
-);
+  });
 
 export const distinctProcedure: Procedure<
   DistinctInput,

package/src/procedures/documents.explain.ts

@@ -7,7 +7,7 @@
  * the verbosity `executionStats` runs the plan.
  */
 
-import { createProcedure, zodAdapter, type Effects, type Procedure, type ProcedureContext } from "@procedures/client";
+import { createProcedure, type Effects, type Procedure, type ProcedureContext } from "@procedures/client";
 import type { Document, ExplainVerbosityLike, FindOptions } from "mongodb";
 import { z } from "zod";
 import { collectionFor, copyScope, SCOPE_FIELDS, type ScopeInput } from "../scope.js";
@@ -108,12 +108,10 @@ const explainInputSchema = described<ExplainInput>(
       .describe("queryPlanner (the default): the plan only. executionStats and allPlansExecution also run the plan."),
   })
 );
-const explainOutputSchema = zodAdapter<ExplainOutput>(
-  z.looseObject({
+const explainOutputSchema: z.ZodType<ExplainOutput> = z.looseObject({
     operation: z.enum(["find", "aggregate"]).describe("The operation that the server explained"),
     plan: z.record(z.string(), z.unknown()).describe("The explain document of the server (queryPlanner, and executionStats with that verbosity)"),
-  })
-);
+  });
 
 export const explainProcedure: Procedure<
   ExplainInput,

package/src/procedures/documents.find.ts

@@ -8,7 +8,6 @@ import {
   type Effects,
   type Procedure,
   type ProcedureContext,
-  zodAdapter,
 } from "@procedures/client";
 import { collectionFor, copyScope, type ScopeInput } from "../scope.js";
 import { described, documentObject, scopeFields } from "./input-schemas.js";
@@ -86,8 +85,7 @@ const findInputSchema = described<FindInput>(
     limit: z.number().int().min(1).optional().describe("The number of documents on a page"),
   })
 );
-const findOutputSchema = zodAdapter<FindOutput>(
-  z.looseObject({
+const findOutputSchema: z.ZodType<FindOutput> = z.looseObject({
     documents: z.array(z.record(z.string(), z.unknown())).describe("The documents of the page"),
     pagination: z.looseObject({
       page: z.number().describe("The page, from 1"),
@@ -97,8 +95,7 @@ const findOutputSchema = zodAdapter<FindOutput>(
       hasNext: z.boolean().describe("True when a next page exists"),
       hasPrev: z.boolean().describe("True when a previous page exists"),
     }).describe("The page of the result"),
-  })
-);
+  });
 
 export const findProcedure: Procedure<
   FindInput,

package/src/procedures/documents.get.ts

@@ -8,7 +8,6 @@ import {
   type Effects,
   type Procedure,
   type ProcedureContext,
-  zodAdapter,
 } from "@procedures/client";
 import { collectionFor, copyScope, type ScopeInput } from "../scope.js";
 import { described, idTypeField, scopeFields } from "./input-schemas.js";
@@ -70,11 +69,9 @@ const getInputSchema = described<GetInput>(
     idType: idTypeField(),
   })
 );
-const getOutputSchema = zodAdapter<GetOutput>(
-  z.looseObject({
+const getOutputSchema: z.ZodType<GetOutput> = z.looseObject({
     document: z.record(z.string(), z.unknown()).nullable().describe("The document, or null when no document has the id"),
-  })
-);
+  });
 
 export const getProcedure: Procedure<
   GetInput,

package/src/procedures/documents.insert.ts

@@ -3,7 +3,7 @@
  * Insert one or more documents
  */
 
-import { createProcedure, zodAdapter, type Effects, type Procedure, type ProcedureContext } from "@procedures/client";
+import { createProcedure, type Effects, type Procedure, type ProcedureContext } from "@procedures/client";
 import { collectionFor, type ScopeInput } from "../scope.js";
 import { scopeFields, documentObject } from "./input-schemas.js";
 import { z } from "zod";
@@ -22,21 +22,17 @@ interface InsertOutput {
 }
 
 // Schemas
-const insertInputSchema = zodAdapter<InsertInput>(
-  z.object({
+const insertInputSchema: z.ZodType<InsertInput> = z.object({
     ...scopeFields(),
     documents: z
       .union([documentObject(), z.array(documentObject())])
       .describe("One document, or a list of documents"),
-  })
-);
-const insertOutputSchema = zodAdapter<InsertOutput>(
-  z.looseObject({
+  });
+const insertOutputSchema: z.ZodType<InsertOutput> = z.looseObject({
     acknowledged: z.boolean().describe("True when the server confirmed the write"),
     insertedIds: z.array(z.string()).describe("The ids of the new documents, as text"),
     insertedCount: z.number().describe("The number of new documents"),
-  })
-);
+  });
 
 export const insertProcedure: Procedure<
   InsertInput,

package/src/procedures/documents.update.ts

@@ -3,7 +3,7 @@
  * Update documents matching a filter
  */
 
-import { createProcedure, type Effects, type Procedure, type ProcedureContext, zodAdapter } from "@procedures/client";
+import { createProcedure, type Effects, type Procedure, type ProcedureContext } from "@procedures/client";
 import { collectionFor } from "../scope.js";
 import { described, documentObject, scopeFields, targetFields } from "./input-schemas.js";
 import { z } from "zod";
@@ -53,15 +53,13 @@ const updateInputSchema = described<UpdateInput>(
     upsert: z.boolean().optional().describe("Insert a document when none matches"),
   })
 );
-const updateOutputSchema = zodAdapter<UpdateOutput>(
-  z.looseObject({
+const updateOutputSchema: z.ZodType<UpdateOutput> = z.looseObject({
     acknowledged: z.boolean().describe("True when the server confirmed the write"),
     matchedCount: z.number().describe("The number of documents that matched"),
     modifiedCount: z.number().describe("The number of documents that changed"),
     upsertedId: z.string().nullable().describe("The id of the new document of an upsert, as text, or null"),
     upsertedCount: z.number().describe("The number of documents that an upsert made"),
-  })
-);
+  });
 
 export const updateProcedure: Procedure<
   UpdateInput,

package/src/procedures/indexes.create.ts

@@ -3,7 +3,7 @@
  * Create an index on a collection
  */
 
-import { createProcedure, zodAdapter, type Effects, type Procedure, type ProcedureContext } from "@procedures/client";
+import { createProcedure, type Effects, type Procedure, type ProcedureContext } from "@procedures/client";
 import { collectionFor, type ScopeInput } from "../scope.js";
 import { scopeFields } from "./input-schemas.js";
 import { z } from "zod";
@@ -22,8 +22,7 @@ interface CreateIndexOutput {
 }
 
 // Schemas
-const createIndexInputSchema = zodAdapter<CreateIndexInput>(
-  z.object({
+const createIndexInputSchema: z.ZodType<CreateIndexInput> = z.object({
     ...scopeFields(),
     keys: z
       .record(z.string(), z.union([z.literal(1), z.literal(-1), z.literal("text"), z.literal("2dsphere")]))
@@ -36,14 +35,11 @@ const createIndexInputSchema = zodAdapter<CreateIndexInput>(
       })
       .optional()
       .describe("The options of the index"),
-  })
-);
-const createIndexOutputSchema = zodAdapter<CreateIndexOutput>(
-  z.looseObject({
+  });
+const createIndexOutputSchema: z.ZodType<CreateIndexOutput> = z.looseObject({
     acknowledged: z.boolean().describe("True when the server confirmed the write"),
     indexName: z.string().describe("The name of the new index"),
-  })
-);
+  });
 
 export const createIndexProcedure: Procedure<
   CreateIndexInput,

package/src/procedures/indexes.drop.ts

@@ -3,7 +3,7 @@
  * Drop an index from a collection
  */
 
-import { createProcedure, zodAdapter, type Effects, type Procedure, type ProcedureContext } from "@procedures/client";
+import { createProcedure, type Effects, type Procedure, type ProcedureContext } from "@procedures/client";
 import { collectionFor, type ScopeInput } from "../scope.js";
 import { scopeFields } from "./input-schemas.js";
 import { z } from "zod";
@@ -18,17 +18,13 @@ interface DropIndexOutput {
 }
 
 // Schemas
-const dropIndexInputSchema = zodAdapter<DropIndexInput>(
-  z.object({
+const dropIndexInputSchema: z.ZodType<DropIndexInput> = z.object({
     ...scopeFields(),
     indexName: z.string().min(1).describe("The name of the index to drop"),
-  })
-);
-const dropIndexOutputSchema = zodAdapter<DropIndexOutput>(
-  z.looseObject({
+  });
+const dropIndexOutputSchema: z.ZodType<DropIndexOutput> = z.looseObject({
     acknowledged: z.boolean().describe("True when the server confirmed the write"),
-  })
-);
+  });
 
 export const dropIndexProcedure: Procedure<
   DropIndexInput,

package/src/procedures/indexes.list.ts

@@ -3,7 +3,7 @@
  * List indexes on a collection
  */
 
-import { createProcedure, zodAdapter, type Effects, type Procedure, type ProcedureContext } from "@procedures/client";
+import { createProcedure, type Effects, type Procedure, type ProcedureContext } from "@procedures/client";
 import { collectionFor, type ScopeInput } from "../scope.js";
 import { scopeFields } from "./input-schemas.js";
 import { z } from "zod";
@@ -18,11 +18,8 @@ interface ListIndexesOutput {
 }
 
 // Schemas
-const listIndexesInputSchema = zodAdapter<ListIndexesInput>(
-  z.object({ ...scopeFields() })
-);
-const listIndexesOutputSchema = zodAdapter<ListIndexesOutput>(
-  z.looseObject({
+const listIndexesInputSchema: z.ZodType<ListIndexesInput> = z.object({ ...scopeFields() });
+const listIndexesOutputSchema: z.ZodType<ListIndexesOutput> = z.looseObject({
     indexes: z
       .array(
         z.looseObject({
@@ -33,8 +30,7 @@ const listIndexesOutputSchema = zodAdapter<ListIndexesOutput>(
         })
       )
       .describe("The indexes of the collection"),
-  })
-);
+  });
 
 export const listIndexesProcedure: Procedure<
   ListIndexesInput,

package/src/procedures/watch.ts

@@ -7,7 +7,7 @@
  * needs a replica set or a sharded cluster: a server without one refuses it.
  */
 
-import { createProcedure, zodAdapter, type Effects, type Procedure, type ProcedureContext } from "@procedures/client";
+import { createProcedure, type Effects, type Procedure, type ProcedureContext } from "@procedures/client";
 import type { ChangeStream, ChangeStreamOptions, Document } from "mongodb";
 import { z } from "zod";
 import { collectionFor, databaseFor, copyScope, SCOPE_FIELDS, type ScopeInput } from "../scope.js";
@@ -149,8 +149,7 @@ const watchInputSchema = described<WatchInput>(
     resumeAfter: z.string().min(1).optional().describe("The resume token of an earlier change: the stream starts after it"),
   })
 );
-const watchOutputSchema = zodAdapter<WatchChange>(
-  z.looseObject({
+const watchOutputSchema: z.ZodType<WatchChange> = z.looseObject({
     operationType: z.string().describe("insert, update, replace, delete, drop, rename, dropDatabase or invalidate"),
     ns: z.looseObject({ db: z.string(), coll: z.string().optional() }).optional().describe("The database and the collection of the change"),
     documentKey: z.record(z.string(), z.unknown()).optional().describe("The _id of the changed document"),
@@ -158,8 +157,7 @@ const watchOutputSchema = zodAdapter<WatchChange>(
     updateDescription: z.record(z.string(), z.unknown()).optional().describe("The changed and removed fields of an update"),
     wallTime: z.string().optional().describe("The time of the change on the server (ISO 8601), from MongoDB 6.0"),
     resumeToken: z.string().describe("The resume token of the change: resumeAfter takes it"),
-  })
-);
+  });
 
 export const watchProcedure: Procedure<
   WatchInput,