convex-helpers 0.1.22 → 0.1.24

package/README.md

@@ -83,6 +83,51 @@ server-side helpers in [server/sessions](./server/sessions.ts).
 
 See the associated [Stack post](https://stack.convex.dev/track-sessions-without-cookies) for more information.
 
+Example for a query (action & mutation are similar):
+
+In your React's root, add the `SessionProvider`:
+```js
+import { SessionProvider } from "convex-helpers/react/sessions";
+//...
+<ConvexProvider client={convex}>
+	<SessionProvider>
+		<App />
+	</SessionProvider>
+</ConvexProvider>
+```
+
+Pass the session ID from the client automatically to a server query:
+```js
+import {  useSessionQuery } from "convex-helpers/react/sessions";
+
+const results = useSessionQuery(api.myModule.mySessionQuery, { arg1: 1 });
+```
+
+Define a server query function in `convex/myModule.ts`:
+```js
+export const mySessionQuery = queryWithSession({
+	args: { arg1: v.number() },
+	handler: async (ctx, args) => {
+		// ctx.anonymousUser
+	}
+})
+```
+
+Using `customQuery` to make `queryWithSession`:
+```js
+import { customQuery } from "convex-helpers/server/customFunctions";
+import { SessionIdArg } from "convex-helpers/server/sessions";
+
+export const queryWithSession = customQuery(query, {
+	args: SessionIdArg,
+	input: async (ctx, { sessionId }) => {
+		const anonymousUser = await getAnonUser(ctx, sessionId);
+		return { ctx: { ...ctx, anonymousUser }, args: {} };
+	},
+});
+```
+**Note:** `getAnonUser` is some function you write to look up a user by session.
+
 ## Row-level security
 
 See the [Stack post on row-level security](https://stack.convex.dev/row-level-security)
@@ -136,6 +181,68 @@ export const myComplexQuery = zodQuery({
 })
 ```
 
+## Hono for advanced HTTP endpoint definitions
+
+[Hono](https://hono.dev/) is an optimized web framework you can use to define
+HTTP api endpoints easily
+([`httpAction` in Convex](https://docs.convex.dev/functions/http-actions)).
+
+See the [guide on Stack](https://stack.convex.dev/hono-with-convex) for tips on using Hono for HTTP endpoints.
+
+To use it, put this in your `convex/http.ts` file:
+```ts
+import {
+  Hono,
+  HonoWithConvex,
+  HttpRouterWithHono,
+} from "convex-helpers/server/hono";
+import { ActionCtx } from "./_generated/server";
+
+const app: HonoWithConvex<ActionCtx> = new Hono();
+
+// See the [guide on Stack](https://stack.convex.dev/hono-with-convex)
+// for tips on using Hono for HTTP endpoints.
+app.get("/", async (c) => {
+  return c.json("Hello world!");
+});
+
+export default new HttpRouterWithHono(app);
+```
+
+## CRUD utilities
+
+To generate a basic CRUD api for your tables, you can use this helper to define
+these functions for a given table:
+
+- `create`
+- `read`
+- `update`
+- `delete`
+- `paginate`
+
+**Note: I recommend only doing this for prototyping or [internal functions](https://docs.convex.dev/functions/internal-functions)**
+
+Example:
+```ts
+
+// in convex/users.ts
+import { crud } from "convex-helpers/server";
+import { internalMutation, internalQuery } from "../convex/_generated/server";
+
+const Users = Table("users", {...});
+
+export const { read, update } = crud(Users, internalQuery, internalMutation);
+
+// in convex/schema.ts
+import { Users } from "./users";
+export default defineSchema({users: Users.table});
+
+// in some file, in an action:
+const user = await ctx.runQuery(internal.users.read, { id: userId });
+
+await ctx.runMutation(internal.users.update, { status: "inactive" });
+```
+
 ## Validator utilities
 
 When using validators for defining database schema or function arguments,
@@ -145,18 +252,17 @@ these validators help:
 to avoid re-defining validators. To learn more about sharing validators, read
 [this article](https://stack.convex.dev/argument-validation-without-repetition),
 an extension of [this article](https://stack.convex.dev/types-cookbook).
-2. Make the validators look more like TypeScript types, even though they're
-runtime values.
-3. Add utilties for partial, pick and omit to match the TypeScript type
+2. Add utilties for partial, pick and omit to match the TypeScript type
 utilities.
-4. Add shorthand for a union of `literals`, a `nullable` field, a `deprecated`
+3. Add shorthand for a union of `literals`, a `nullable` field, a `deprecated`
 field, and `brandedString`. To learn more about branded strings see
 [this article](https://stack.convex.dev/using-branded-types-in-validators).
+4. Make the validators look more like TypeScript types, even though they're
+runtime values. (This is controvercial and not required to use the above).
 
 Example:
 ```js
 import { Table } from "convex-helpers/server";
-// Note some redefinitions in the import for even more terse definitions.
 import {
   literals, partial, deprecated, brandedString,
 } from "convex-helpers/validators";

package/dist/server/filter.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Defines a function `filter` that wraps a query, attaching a
+ * JavaScript/TypeScript function that filters results just like
+ * `db.query(...).filter(...)` but with more generality.
+ *
+ */
+import { DocumentByInfo, GenericTableInfo, Query } from "convex/server";
+export type Predicate<T extends GenericTableInfo> = (doc: DocumentByInfo<T>) => Promise<boolean> | boolean;
+type QueryTableInfo<Q> = Q extends Query<infer T> ? T : never;
+/**
+ * Applies a filter to a database query, just like `.filter((q) => ...)` but
+ * supporting arbitrary JavaScript/TypeScript.
+ * Performance is roughly the same as `.filter((q) => ...)`. If you want better
+ * performance, use an index to narrow down the results before filtering.
+ *
+ * Examples:
+ *
+ * // Full table scan, filtered to short messages.
+ * return await filter(
+ *  ctx.db.query("messages"),
+ *  async (message) => message.body.length < 10,
+ * ).collect();
+ *
+ * // Short messages by author, paginated.
+ * return await filter(
+ *  ctx.db.query("messages").withIndex("by_author, q=>q.eq("author", args.author)),
+ *  async (message) => message.body.length < 10,
+ * ).paginate(args.paginationOpts);
+ *
+ * // Same behavior as above: Short messages by author, paginated.
+ * // Note the filter can wrap any part of the query pipeline, and it is applied
+ * // at the end. This is how RowLevelSecurity works.
+ * const shortMessages = await filter(
+ *  ctx.db.query("messages"),
+ *  async (message) => message.body.length < 10,
+ * );
+ * return await shortMessages
+ *  .withIndex("by_author, q=>q.eq("author", args.author))
+ *  .paginate(args.paginationOpts);
+ *
+ * // Also works with `order()`, `take()`, `unique()`, and `first()`.
+ * return await filter(
+ *  ctx.db.query("messages").order("desc"),
+ *  async (message) => message.body.length < 10,
+ * ).first();
+ *
+ * @param query The query to filter.
+ * @param predicate Async function to run on each document before it is yielded
+ *  from the query pipeline.
+ * @returns A new query with the filter applied.
+ */
+export declare function filter<Q extends Query<GenericTableInfo>>(query: Q, predicate: Predicate<QueryTableInfo<Q>>): Q;
+export {};

package/dist/server/filter.js

@@ -0,0 +1,136 @@
+/**
+ * Defines a function `filter` that wraps a query, attaching a
+ * JavaScript/TypeScript function that filters results just like
+ * `db.query(...).filter(...)` but with more generality.
+ *
+ */
+async function asyncFilter(arr, predicate) {
+    const results = await Promise.all(arr.map(predicate));
+    return arr.filter((_v, index) => results[index]);
+}
+class QueryWithFilter {
+    // q actually is only guaranteed to implement OrderedQuery<T>,
+    // but we forward all QueryInitializer methods to it and if they fail they fail.
+    q;
+    p;
+    iterator;
+    constructor(q, p) {
+        this.q = q;
+        this.p = p;
+    }
+    filter(predicate) {
+        return new QueryWithFilter(this.q.filter(predicate), this.p);
+    }
+    order(order) {
+        return new QueryWithFilter(this.q.order(order), this.p);
+    }
+    async paginate(paginationOpts) {
+        const result = await this.q.paginate(paginationOpts);
+        return { ...result, page: await asyncFilter(result.page, this.p) };
+    }
+    async collect() {
+        const results = await this.q.collect();
+        return await asyncFilter(results, this.p);
+    }
+    async take(n) {
+        const results = [];
+        for await (const result of this) {
+            results.push(result);
+            if (results.length >= n) {
+                break;
+            }
+        }
+        return results;
+    }
+    async first() {
+        for await (const result of this) {
+            return result;
+        }
+        return null;
+    }
+    async unique() {
+        let uniqueResult = null;
+        for await (const result of this) {
+            if (uniqueResult === null) {
+                uniqueResult = result;
+            }
+            else {
+                throw new Error("not unique");
+            }
+        }
+        return uniqueResult;
+    }
+    [Symbol.asyncIterator]() {
+        this.iterator = this.q[Symbol.asyncIterator]();
+        return this;
+    }
+    async next() {
+        for (;;) {
+            const { value, done } = await this.iterator.next();
+            if (value && (await this.p(value))) {
+                return { value, done };
+            }
+            if (done) {
+                return { value: null, done: true };
+            }
+        }
+    }
+    return() {
+        return this.iterator.return();
+    }
+    // Implement the remainder of QueryInitializer.
+    fullTableScan() {
+        return new QueryWithFilter(this.q.fullTableScan(), this.p);
+    }
+    withIndex(indexName, indexRange) {
+        return new QueryWithFilter(this.q.withIndex(indexName, indexRange), this.p);
+    }
+    withSearchIndex(indexName, searchFilter) {
+        return new QueryWithFilter(this.q.withSearchIndex(indexName, searchFilter), this.p);
+    }
+}
+/**
+ * Applies a filter to a database query, just like `.filter((q) => ...)` but
+ * supporting arbitrary JavaScript/TypeScript.
+ * Performance is roughly the same as `.filter((q) => ...)`. If you want better
+ * performance, use an index to narrow down the results before filtering.
+ *
+ * Examples:
+ *
+ * // Full table scan, filtered to short messages.
+ * return await filter(
+ *  ctx.db.query("messages"),
+ *  async (message) => message.body.length < 10,
+ * ).collect();
+ *
+ * // Short messages by author, paginated.
+ * return await filter(
+ *  ctx.db.query("messages").withIndex("by_author, q=>q.eq("author", args.author)),
+ *  async (message) => message.body.length < 10,
+ * ).paginate(args.paginationOpts);
+ *
+ * // Same behavior as above: Short messages by author, paginated.
+ * // Note the filter can wrap any part of the query pipeline, and it is applied
+ * // at the end. This is how RowLevelSecurity works.
+ * const shortMessages = await filter(
+ *  ctx.db.query("messages"),
+ *  async (message) => message.body.length < 10,
+ * );
+ * return await shortMessages
+ *  .withIndex("by_author, q=>q.eq("author", args.author))
+ *  .paginate(args.paginationOpts);
+ *
+ * // Also works with `order()`, `take()`, `unique()`, and `first()`.
+ * return await filter(
+ *  ctx.db.query("messages").order("desc"),
+ *  async (message) => message.body.length < 10,
+ * ).first();
+ *
+ * @param query The query to filter.
+ * @param predicate Async function to run on each document before it is yielded
+ *  from the query pipeline.
+ * @returns A new query with the filter applied.
+ */
+export function filter(query, predicate) {
+    return new QueryWithFilter(query, predicate);
+}

package/dist/server/hono.d.ts

@@ -0,0 +1,105 @@
+/**
+ * This file contains a helper class for integrating Convex with Hono.
+ *
+ * See the [guide on Stack](https://stack.convex.dev/hono-with-convex)
+ * for tips on using Hono for HTTP endpoints.
+ *
+ * To use this helper, create a new Hono app in convex/http.ts like so:
+ * ```ts
+ * import {
+ *   Hono,
+ *   HonoWithConvex,
+ *   HttpRouterWithHono,
+ * } from "convex-helpers/server/hono";
+ * import { ActionCtx } from "./_generated/server";
+ *
+ * const app: HonoWithConvex<ActionCtx> = new Hono();
+ *
+ * app.get("/", async (c) => {
+ *   return c.json("Hello world!");
+ * });
+ *
+ * export default new HttpRouterWithHono(app);
+ * ```
+ */
+import { HttpRouter, PublicHttpAction, RoutableMethod, GenericActionCtx } from "convex/server";
+import { Hono } from "hono";
+export { Hono };
+/**
+ * Hono uses the `FetchEvent` type internally, which has to do with service workers
+ * and isn't included in the Convex tsconfig.
+ *
+ * As a workaround, define this type here so Hono + Convex compiles.
+ */
+declare global {
+    type FetchEvent = any;
+}
+/**
+ * A type representing a Hono app with `c.env` containing Convex's
+ * `HttpEndpointCtx` (e.g. `c.env.runQuery` is valid).
+ */
+export type HonoWithConvex<ActionCtx extends GenericActionCtx<any>> = Hono<{
+    Bindings: {
+        [Name in keyof ActionCtx]: ActionCtx[Name];
+    };
+}>;
+/**
+ * An implementation of the Convex `HttpRouter` that integrates with Hono by
+ * overridding `getRoutes` and `lookup`.
+ *
+ * This defers all routing and request handling to the provided Hono app, and
+ * passes along the Convex `HttpEndpointCtx` to the Hono handlers as part of
+ * `env`.
+ *
+ * It will attempt to log each request with the most specific Hono route it can
+ * find. For example,
+ *
+ * ```
+ * app.on("GET", "*", ...)
+ * app.on("GET", "/profile/:userId", ...)
+ *
+ * const http = new HttpRouterWithHono(app);
+ * http.lookup("/profile/abc", "GET") // [handler, "GET", "/profile/:userId"]
+ * ```
+ *
+ * An example `convex/http.ts` file would look like this:
+ * ```
+ * const app: HonoWithConvex = new Hono();
+ *
+ * // add Hono routes on `app`
+ *
+ * export default new HttpRouterWithHono(app);
+ * ```
+ */
+export declare class HttpRouterWithHono<ActionCtx extends GenericActionCtx<any>> extends HttpRouter {
+    private _app;
+    private _handler;
+    private _handlerInfoCache;
+    constructor(app: HonoWithConvex<ActionCtx>);
+    /**
+     * Returns a list of routed HTTP endpoints.
+     *
+     * These are used to populate the list of routes shown in the Functions page of the Convex dashboard.
+     *
+     * @returns - an array of [path, method, endpoint] tuples.
+     */
+    getRoutes: () => [string, "GET" | "POST" | "PUT" | "DELETE" | "OPTIONS" | "PATCH", (...args: any) => any][];
+    /**
+     * Returns the appropriate HTTP endpoint and its routed request path and method.
+     *
+     * The path and method returned are used for logging and metrics, and should
+     * match up with one of the routes returned by `getRoutes`.
+     *
+     * For example,
+     *
+     * ```js
+     * http.route({ pathPrefix: "/profile/", method: "GET", handler: getProfile});
+     *
+     * http.lookup("/profile/abc", "GET") // returns [getProfile, "GET", "/profile/*"]
+     *```
+     *
+     * @returns - a tuple [PublicHttpEndpoint, method, path] or null.
+     */
+    lookup: (path: string, method: RoutableMethod | "HEAD") => readonly [PublicHttpAction, "GET" | "POST" | "PUT" | "DELETE" | "OPTIONS" | "PATCH", string];
+}
+export declare function normalizeMethod(method: RoutableMethod | "HEAD"): RoutableMethod;

package/dist/server/hono.js

@@ -0,0 +1,154 @@
+/**
+ * This file contains a helper class for integrating Convex with Hono.
+ *
+ * See the [guide on Stack](https://stack.convex.dev/hono-with-convex)
+ * for tips on using Hono for HTTP endpoints.
+ *
+ * To use this helper, create a new Hono app in convex/http.ts like so:
+ * ```ts
+ * import {
+ *   Hono,
+ *   HonoWithConvex,
+ *   HttpRouterWithHono,
+ * } from "convex-helpers/server/hono";
+ * import { ActionCtx } from "./_generated/server";
+ *
+ * const app: HonoWithConvex<ActionCtx> = new Hono();
+ *
+ * app.get("/", async (c) => {
+ *   return c.json("Hello world!");
+ * });
+ *
+ * export default new HttpRouterWithHono(app);
+ * ```
+ */
+import { httpActionGeneric, HttpRouter, ROUTABLE_HTTP_METHODS, } from "convex/server";
+import { Hono } from "hono";
+export { Hono };
+/**
+ * An implementation of the Convex `HttpRouter` that integrates with Hono by
+ * overridding `getRoutes` and `lookup`.
+ *
+ * This defers all routing and request handling to the provided Hono app, and
+ * passes along the Convex `HttpEndpointCtx` to the Hono handlers as part of
+ * `env`.
+ *
+ * It will attempt to log each request with the most specific Hono route it can
+ * find. For example,
+ *
+ * ```
+ * app.on("GET", "*", ...)
+ * app.on("GET", "/profile/:userId", ...)
+ *
+ * const http = new HttpRouterWithHono(app);
+ * http.lookup("/profile/abc", "GET") // [handler, "GET", "/profile/:userId"]
+ * ```
+ *
+ * An example `convex/http.ts` file would look like this:
+ * ```
+ * const app: HonoWithConvex = new Hono();
+ *
+ * // add Hono routes on `app`
+ *
+ * export default new HttpRouterWithHono(app);
+ * ```
+ */
+export class HttpRouterWithHono extends HttpRouter {
+    _app;
+    _handler;
+    _handlerInfoCache;
+    constructor(app) {
+        super();
+        this._app = app;
+        // Single Convex httpEndpoint handler that just forwards the request to the
+        // Hono framework
+        this._handler = httpActionGeneric(async (ctx, request) => {
+            return await app.fetch(request, ctx);
+        });
+        this._handlerInfoCache = new Map();
+    }
+    /**
+     * Returns a list of routed HTTP endpoints.
+     *
+     * These are used to populate the list of routes shown in the Functions page of the Convex dashboard.
+     *
+     * @returns - an array of [path, method, endpoint] tuples.
+     */
+    getRoutes = () => {
+        const convexRoutes = [];
+        // Likely a better way to do this, but hono will have multiple handlers with the same
+        // name (i.e. for middleware), so de-duplicate so we don't show multiple routes in the dashboard.
+        const seen = new Set();
+        this._app.routes.forEach((route) => {
+            // Hono uses "ALL" in its router, which is not supported by the Convex router.
+            // Expand this into a route for every routable method supported by Convex.
+            if (route.method === "ALL") {
+                for (const method of ROUTABLE_HTTP_METHODS) {
+                    const name = `${method} ${route.path}`;
+                    if (!seen.has(name)) {
+                        seen.add(name);
+                        convexRoutes.push([route.path, method, route.handler]);
+                    }
+                }
+            }
+            else {
+                const name = `${route.method} ${route.path}`;
+                if (!seen.has(name)) {
+                    seen.add(name);
+                    convexRoutes.push([
+                        route.path,
+                        route.method,
+                        route.handler,
+                    ]);
+                }
+            }
+        });
+        return convexRoutes;
+    };
+    /**
+     * Returns the appropriate HTTP endpoint and its routed request path and method.
+     *
+     * The path and method returned are used for logging and metrics, and should
+     * match up with one of the routes returned by `getRoutes`.
+     *
+     * For example,
+     *
+     * ```js
+     * http.route({ pathPrefix: "/profile/", method: "GET", handler: getProfile});
+     *
+     * http.lookup("/profile/abc", "GET") // returns [getProfile, "GET", "/profile/*"]
+     *```
+     *
+     * @returns - a tuple [PublicHttpEndpoint, method, path] or null.
+     */
+    lookup = (path, method) => {
+        const match = this._app.router.match(method, path);
+        if (match === null) {
+            return [this._handler, normalizeMethod(method), path];
+        }
+        // There might be multiple handlers for a route (in the case of middleware),
+        // so choose the most specific one for the purposes of logging
+        const handlersAndRoutes = match[0];
+        const mostSpecificHandler = handlersAndRoutes[handlersAndRoutes.length - 1][0][0];
+        // On the first request let's populate a lookup from handler to info
+        if (this._handlerInfoCache.size === 0) {
+            for (const r of this._app.routes) {
+                this._handlerInfoCache.set(r.handler, {
+                    method: normalizeMethod(method),
+                    path: r.path,
+                });
+            }
+        }
+        const info = this._handlerInfoCache.get(mostSpecificHandler);
+        if (info) {
+            return [this._handler, info.method, info.path];
+        }
+        return [this._handler, normalizeMethod(method), path];
+    };
+}
+export function normalizeMethod(method) {
+    // HEAD is handled by Convex by running GET and stripping the body.
+    if (method === "HEAD")
+        return "GET";
+    return method;
+}

package/dist/server/index.d.ts

@@ -1,4 +1,5 @@
-import { Validator } from "convex/values";
+import { QueryBuilder, MutationBuilder, GenericDataModel, WithoutSystemFields, DocumentByName, RegisteredMutation, RegisteredQuery, FunctionVisibility, paginationOptsValidator, PaginationResult } from "convex/server";
+import { GenericId, Infer, ObjectType, Validator } from "convex/values";
 import { Expand } from "..";
 /**
  * Define a table with system fields _id and _creationTime. This also returns
@@ -16,21 +17,22 @@ import { Expand } from "..";
  * }
  */
 export declare function Table<T extends Record<string, Validator<any, any, any>>, TableName extends string>(name: TableName, fields: T): {
+    name: TableName;
     table: import("convex/server").TableDefinition<import("convex/dist/cjs-types/type_utils").Expand<import("convex/dist/cjs-types/server/system_fields").SystemFields & import("convex/dist/cjs-types/type_utils").Expand<{ [Property_1 in { [Property in keyof T]: T[Property]["isOptional"] extends true ? Property : never; }[keyof T]]?: T[Property_1]["type"] | undefined; } & { [Property_2 in Exclude<keyof T, { [Property in keyof T]: T[Property]["isOptional"] extends true ? Property : never; }[keyof T]>]: T[Property_2]["type"]; }>>, "_creationTime" | ({ [Property_3 in keyof T]: Property_3 | `${Property_3 & string}.${T[Property_3]["fieldPaths"]}`; }[keyof T] & string), {}, {}, {}>;
     doc: import("convex/dist/cjs-types/values/validator").ObjectValidator<Expand<T & {
-        _id: Validator<import("convex/values").GenericId<TableName>, false, never>;
+        _id: Validator<GenericId<TableName>, false, never>;
         _creationTime: Validator<number, false, never>;
     }>>;
     withoutSystemFields: T;
     withSystemFields: Expand<T & {
-        _id: Validator<import("convex/values").GenericId<TableName>, false, never>;
+        _id: Validator<GenericId<TableName>, false, never>;
         _creationTime: Validator<number, false, never>;
     }>;
     systemFields: {
-        _id: Validator<import("convex/values").GenericId<TableName>, false, never>;
+        _id: Validator<GenericId<TableName>, false, never>;
         _creationTime: Validator<number, false, never>;
     };
-    _id: Validator<import("convex/values").GenericId<TableName>, false, never>;
+    _id: Validator<GenericId<TableName>, false, never>;
 };
 /**
  *
@@ -44,3 +46,51 @@ export declare function missingEnvVariableUrl(envVarName: string, whereToGet: st
  * @returns The deployment name, like "screaming-lemur-123"
  */
 export declare function deploymentName(): string | undefined;
+/**
+ * Create CRUD operations for a table.
+ * You can expose these operations in your API. For example, in convex/users.ts:
+ *
+ * ```ts
+ * // in convex/users.ts
+ * import { crud } from "convex-helpers/server";
+ * import { query, mutation } from "./convex/_generated/server";
+ *
+ * const Users = Table("users", {
+ *  name: v.string(),
+ *  ///...
+ * });
+ *
+ * export const { create, read, paginate, update, destroy } =
+ *   crud(Users, query, mutation);
+ * ```
+ *
+ * Then from a client, you can access `api.users.create`.
+ *
+ * @param table The table to create CRUD operations for.
+ * Of type returned from Table() in "convex-helpers/server".
+ * @param query The query to use - use internalQuery or query from
+ * "./convex/_generated/server" or a customQuery.
+ * @param mutation The mutation to use - use internalMutation or mutation from
+ * "./convex/_generated/server" or a customMutation.
+ * @returns An object with create, read, update, and delete functions.
+ */
+export declare function crud<Fields extends Record<string, Validator<any, any, any>>, TableName extends string, DataModel extends GenericDataModel, QueryVisibility extends FunctionVisibility, MutationVisibility extends FunctionVisibility>(table: {
+    name: TableName;
+    _id: Validator<GenericId<TableName>>;
+    withoutSystemFields: Fields;
+}, query: QueryBuilder<DataModel, QueryVisibility>, mutation: MutationBuilder<DataModel, MutationVisibility>): {
+    create: RegisteredMutation<MutationVisibility, ObjectType<Fields>, Promise<DocumentByName<DataModel, TableName>>>;
+    read: RegisteredQuery<QueryVisibility, {
+        id: GenericId<TableName>;
+    }, Promise<DocumentByName<DataModel, TableName> | null>>;
+    paginate: RegisteredQuery<QueryVisibility, {
+        paginationOpts: Infer<typeof paginationOptsValidator>;
+    }, Promise<PaginationResult<DocumentByName<DataModel, TableName>>>>;
+    update: RegisteredMutation<MutationVisibility, {
+        id: GenericId<TableName>;
+        patch: Partial<WithoutSystemFields<DocumentByName<DataModel, TableName>>>;
+    }, Promise<void>>;
+    destroy: RegisteredMutation<MutationVisibility, {
+        id: GenericId<TableName>;
+    }, Promise<DocumentByName<DataModel, TableName> | null>>;
+};