convex-verify 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,403 @@
+# convex-verify
+
+Type-safe verification and validation for Convex database operations.
+
+## Features
+
+- **Type-safe insert/patch** - Full TypeScript inference for your schema
+- **Default values** - Make fields optional in `insert()` with automatic defaults
+- **Protected columns** - Prevent accidental updates to critical fields in `patch()`
+- **Validation plugins** - Unique row/column enforcement, custom validators
+- **Extensible** - Create your own validation plugins
+
+## Installation
+
+```bash
+npm install convex-verify
+```
+
+**Peer Dependencies:**
+
+- `convex` >= 1.17.4
+
+## Quick Start
+
+```ts
+import {
+	defaultValuesConfig,
+	protectedColumnsConfig,
+	uniqueColumnConfig,
+	uniqueRowConfig,
+	verifyConfig,
+} from 'convex-verify';
+
+import schema from './schema';
+
+export const { insert, patch, dangerouslyPatch } = verifyConfig(schema, {
+	// Make fields optional with defaults
+	defaultValues: defaultValuesConfig(schema, () => ({
+		posts: { status: 'draft', views: 0 },
+	})),
+
+	// Prevent patching critical fields
+	protectedColumns: protectedColumnsConfig(schema, {
+		posts: ['authorId'],
+	}),
+
+	// Validation plugins
+	plugins: [
+		uniqueRowConfig(schema, {
+			posts: ['by_author_slug'],
+		}),
+		uniqueColumnConfig(schema, {
+			users: ['by_email', 'by_username'],
+		}),
+	],
+});
+```
+
+Then use in your mutations:
+
+```ts
+import { insert, patch } from './verify';
+
+export const createPost = mutation({
+	args: { title: v.string(), content: v.string() },
+	handler: async (ctx, args) => {
+		// status and views are optional - defaults are applied
+		return await insert(ctx, 'posts', {
+			title: args.title,
+			content: args.content,
+			authorId: ctx.auth.userId,
+		});
+	},
+});
+
+export const updatePost = mutation({
+	args: { id: v.id('posts'), title: v.string() },
+	handler: async (ctx, args) => {
+		// authorId is protected - TypeScript won't allow it here
+		await patch(ctx, 'posts', args.id, {
+			title: args.title,
+		});
+	},
+});
+```
+
+---
+
+## API Reference
+
+### `verifyConfig(schema, config)`
+
+Main configuration function that returns typed `insert`, `patch`, and `dangerouslyPatch` functions.
+
+```ts
+const { insert, patch, dangerouslyPatch, configs } = verifyConfig(schema, {
+  defaultValues?: DefaultValuesConfig,
+  protectedColumns?: ProtectedColumnsConfig,
+  plugins?: ValidatePlugin[],
+});
+```
+
+#### Returns
+
+| Function           | Description                                                                         |
+| ------------------ | ----------------------------------------------------------------------------------- |
+| `insert`           | Insert with default values applied and validation plugins run                       |
+| `patch`            | Patch with protected columns removed from type and validation plugins run           |
+| `dangerouslyPatch` | Patch with full access to all columns (bypasses protected columns type restriction) |
+| `configs`          | The original config object (for debugging)                                          |
+
+---
+
+## Transforms
+
+Transforms modify the input type of `insert()`.
+
+### `defaultValuesConfig(schema, config)`
+
+Makes specified fields optional in `insert()` by providing default values.
+
+```ts
+import { defaultValuesConfig } from 'convex-verify';
+// or
+import { defaultValuesConfig } from 'convex-verify/transforms';
+```
+
+#### Static Config
+
+```ts
+const defaults = defaultValuesConfig(schema, {
+	posts: { status: 'draft', views: 0 },
+	comments: { likes: 0 },
+});
+```
+
+#### Dynamic Config (Fresh Values)
+
+Use a function for values that should be generated fresh on each insert:
+
+```ts
+const defaults = defaultValuesConfig(schema, () => ({
+	posts: {
+		status: 'draft',
+		slug: generateRandomSlug(),
+		createdAt: Date.now(),
+	},
+}));
+```
+
+#### Async Config
+
+```ts
+const defaults = defaultValuesConfig(schema, async () => ({
+	posts: {
+		category: await fetchDefaultCategory(),
+	},
+}));
+```
+
+---
+
+## Configs
+
+Configs modify the input type of `patch()`.
+
+### `protectedColumnsConfig(schema, config)`
+
+Removes specified columns from the `patch()` input type, preventing accidental updates.
+
+```ts
+import { protectedColumnsConfig } from 'convex-verify';
+// or
+import { protectedColumnsConfig } from 'convex-verify/configs';
+```
+
+#### Example
+
+```ts
+const protected = protectedColumnsConfig(schema, {
+	posts: ['authorId', 'createdAt'],
+	comments: ['postId', 'authorId'],
+});
+```
+
+#### Bypassing Protection
+
+Use `dangerouslyPatch()` when you need to update protected columns:
+
+```ts
+// Regular patch - authorId not allowed
+await patch(ctx, 'posts', id, {
+	authorId: newAuthorId, // ❌ TypeScript error
+	title: 'New Title', // ✅ OK
+});
+
+// Dangerous patch - full access
+await dangerouslyPatch(ctx, 'posts', id, {
+	authorId: newAuthorId, // ✅ OK (bypasses protection)
+	title: 'New Title',
+});
+```
+
+**Note:** `dangerouslyPatch()` still runs validation plugins - only the type restriction is bypassed.
+
+---
+
+## Plugins
+
+Plugins validate data during `insert()` and `patch()` operations. They run after transforms and can throw errors to prevent the operation.
+
+### `uniqueRowConfig(schema, config)`
+
+Enforces uniqueness across multiple columns using composite indexes.
+
+```ts
+import { uniqueRowConfig } from 'convex-verify';
+// or
+import { uniqueRowConfig } from 'convex-verify/plugins';
+```
+
+#### Shorthand (Index Names)
+
+```ts
+const uniqueRows = uniqueRowConfig(schema, {
+	posts: ['by_author_slug'], // Unique author + slug combo
+	projects: ['by_org_slug'], // Unique org + slug combo
+});
+```
+
+#### With Options
+
+```ts
+const uniqueRows = uniqueRowConfig(schema, {
+	posts: [
+		{
+			index: 'by_author_slug',
+			identifiers: ['_id', 'authorId'], // Fields to check for "same document"
+		},
+	],
+});
+```
+
+### `uniqueColumnConfig(schema, config)`
+
+Enforces uniqueness on single columns using indexes.
+
+```ts
+import { uniqueColumnConfig } from 'convex-verify';
+// or
+import { uniqueColumnConfig } from 'convex-verify/plugins';
+```
+
+The column name is derived from the index name by removing `by_` prefix:
+
+- `by_username` → checks `username` column
+- `by_email` → checks `email` column
+
+#### Example
+
+```ts
+const uniqueColumns = uniqueColumnConfig(schema, {
+	users: ['by_username', 'by_email'],
+	organizations: ['by_slug'],
+});
+```
+
+#### With Options
+
+```ts
+const uniqueColumns = uniqueColumnConfig(schema, {
+	users: [
+		'by_username', // shorthand
+		{ index: 'by_email', identifiers: ['_id', 'clerkId'] }, // with options
+	],
+});
+```
+
+### `createValidatePlugin(name, config, handlers)`
+
+Create custom validation plugins.
+
+```ts
+import { createValidatePlugin } from 'convex-verify';
+// or
+import { createValidatePlugin } from 'convex-verify/core';
+```
+
+#### Example: Required Fields Plugin
+
+```ts
+const requiredFields = createValidatePlugin(
+	'requiredFields',
+	{ fields: ['title', 'content'] },
+	{
+		insert: (context, data) => {
+			for (const field of context.config.fields) {
+				if (!data[field]) {
+					throw new ConvexError({ message: `Missing required field: ${field}` });
+				}
+			}
+			return data;
+		},
+	}
+);
+```
+
+#### Example: Async Validation
+
+```ts
+const checkOwnership = createValidatePlugin(
+	'checkOwnership',
+	{},
+	{
+		patch: async (context, data) => {
+			const existing = await context.ctx.db.get(context.patchId);
+			const user = await getCurrentUser(context.ctx);
+
+			if (existing?.authorId !== user._id) {
+				throw new ConvexError({ message: 'Not authorized to edit this document' });
+			}
+			return data;
+		},
+	}
+);
+```
+
+#### Plugin Context
+
+Plugins receive a `ValidateContext` object:
+
+```ts
+type ValidateContext = {
+	ctx: GenericMutationCtx; // Convex mutation context
+	tableName: string; // Table being operated on
+	operation: 'insert' | 'patch';
+	patchId?: GenericId; // Document ID (patch only)
+	onFail?: OnFailCallback; // Callback for failure details
+	schema?: SchemaDefinition; // Schema reference
+};
+```
+
+---
+
+## Subpath Imports
+
+For smaller bundle sizes, you can import from specific subpaths:
+
+```ts
+// Import everything from root
+import { uniqueRowConfig, verifyConfig } from 'convex-verify';
+import { protectedColumnsConfig } from 'convex-verify/configs';
+// Or import from specific subpaths
+import { createValidatePlugin, verifyConfig } from 'convex-verify/core';
+import { uniqueColumnConfig, uniqueRowConfig } from 'convex-verify/plugins';
+import { defaultValuesConfig } from 'convex-verify/transforms';
+import { getTableIndexes } from 'convex-verify/utils';
+```
+
+---
+
+## Error Handling
+
+### `onFail` Callback
+
+All operations accept an optional `onFail` callback for handling validation failures:
+
+```ts
+await insert(ctx, 'posts', data, {
+	onFail: (args) => {
+		if (args.uniqueRow) {
+			console.log('Duplicate row:', args.uniqueRow.existingData);
+		}
+		if (args.uniqueColumn) {
+			console.log('Duplicate column:', args.uniqueColumn.conflictingColumn);
+		}
+	},
+});
+```
+
+### Error Types
+
+Validation plugins throw `ConvexError` with specific codes:
+
+- `UNIQUE_ROW_VERIFICATION_ERROR` - Duplicate row detected
+- `UNIQUE_COLUMN_VERIFICATION_ERROR` - Duplicate column value detected
+
+---
+
+## TypeScript
+
+This library is written in TypeScript and provides full type inference:
+
+- `insert()` types reflect optional fields from `defaultValues`
+- `patch()` types exclude protected columns
+- Plugin configs are type-checked against your schema
+- Index names are validated against your schema's indexes
+
+---
+
+## License
+
+MIT

package/dist/configs/index.d.mts

@@ -0,0 +1,51 @@
+import { SchemaDefinition, GenericSchema, DataModelFromSchemaDefinition, WithoutSystemFields } from 'convex/server';
+import { k as DMGeneric } from '../types-_64SXyva.mjs';
+
+/**
+ * Config data type for protected columns.
+ * Maps table names to arrays of column names that should be protected from patching.
+ */
+type ProtectedColumnsConfigData<DM extends DMGeneric> = {
+    [K in keyof DM]?: (keyof WithoutSystemFields<DM[K]['document']>)[];
+};
+/**
+ * Creates a protected columns config.
+ *
+ * Protected columns are removed from the patch() input type,
+ * preventing accidental updates to critical fields like foreign keys.
+ * Use dangerouslyPatch() to bypass this protection when needed.
+ *
+ * @param schema - Your Convex schema definition
+ * @param config - Object mapping table names to arrays of protected column names
+ * @returns Config object for use with verifyConfig
+ *
+ * @example
+ * ```ts
+ * const protectedColumns = protectedColumnsConfig(schema, {
+ *   posts: ['authorId', 'createdAt'],
+ *   comments: ['postId', 'authorId'],
+ * });
+ *
+ * // In verifyConfig:
+ * const { patch, dangerouslyPatch } = verifyConfig(schema, {
+ *   protectedColumns,
+ * });
+ *
+ * // patch() won't allow authorId
+ * await patch(ctx, 'posts', id, {
+ *   authorId: '...',  // TS Error - property doesn't exist
+ *   title: 'new',     // OK
+ * });
+ *
+ * // dangerouslyPatch() allows all columns
+ * await dangerouslyPatch(ctx, 'posts', id, {
+ *   authorId: '...',  // OK - bypasses protection
+ * });
+ * ```
+ */
+declare const protectedColumnsConfig: <S extends SchemaDefinition<GenericSchema, boolean>, DataModel extends DataModelFromSchemaDefinition<S>, const C extends ProtectedColumnsConfigData<DataModel>>(_schema: S, config: C) => {
+    _type: "protectedColumns";
+    config: C;
+};
+
+export { type ProtectedColumnsConfigData, protectedColumnsConfig };

package/dist/configs/index.d.ts

@@ -0,0 +1,51 @@
+import { SchemaDefinition, GenericSchema, DataModelFromSchemaDefinition, WithoutSystemFields } from 'convex/server';
+import { k as DMGeneric } from '../types-_64SXyva.js';
+
+/**
+ * Config data type for protected columns.
+ * Maps table names to arrays of column names that should be protected from patching.
+ */
+type ProtectedColumnsConfigData<DM extends DMGeneric> = {
+    [K in keyof DM]?: (keyof WithoutSystemFields<DM[K]['document']>)[];
+};
+/**
+ * Creates a protected columns config.
+ *
+ * Protected columns are removed from the patch() input type,
+ * preventing accidental updates to critical fields like foreign keys.
+ * Use dangerouslyPatch() to bypass this protection when needed.
+ *
+ * @param schema - Your Convex schema definition
+ * @param config - Object mapping table names to arrays of protected column names
+ * @returns Config object for use with verifyConfig
+ *
+ * @example
+ * ```ts
+ * const protectedColumns = protectedColumnsConfig(schema, {
+ *   posts: ['authorId', 'createdAt'],
+ *   comments: ['postId', 'authorId'],
+ * });
+ *
+ * // In verifyConfig:
+ * const { patch, dangerouslyPatch } = verifyConfig(schema, {
+ *   protectedColumns,
+ * });
+ *
+ * // patch() won't allow authorId
+ * await patch(ctx, 'posts', id, {
+ *   authorId: '...',  // TS Error - property doesn't exist
+ *   title: 'new',     // OK
+ * });
+ *
+ * // dangerouslyPatch() allows all columns
+ * await dangerouslyPatch(ctx, 'posts', id, {
+ *   authorId: '...',  // OK - bypasses protection
+ * });
+ * ```
+ */
+declare const protectedColumnsConfig: <S extends SchemaDefinition<GenericSchema, boolean>, DataModel extends DataModelFromSchemaDefinition<S>, const C extends ProtectedColumnsConfigData<DataModel>>(_schema: S, config: C) => {
+    _type: "protectedColumns";
+    config: C;
+};
+
+export { type ProtectedColumnsConfigData, protectedColumnsConfig };

package/dist/configs/index.js

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/configs/index.ts
+var configs_exports = {};
+__export(configs_exports, {
+  protectedColumnsConfig: () => protectedColumnsConfig
+});
+module.exports = __toCommonJS(configs_exports);
+
+// src/configs/protectedColumnsConfig.ts
+var protectedColumnsConfig = (_schema, config) => {
+  return {
+    _type: "protectedColumns",
+    config
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  protectedColumnsConfig
+});
+//# sourceMappingURL=index.js.map

package/dist/configs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/configs/index.ts","../../src/configs/protectedColumnsConfig.ts"],"sourcesContent":["export { protectedColumnsConfig } from './protectedColumnsConfig';\nexport type { ProtectedColumnsConfigData } from './protectedColumnsConfig';\n","import {\n\tDataModelFromSchemaDefinition,\n\tGenericSchema,\n\tSchemaDefinition,\n\tWithoutSystemFields,\n} from 'convex/server';\n\nimport { DMGeneric } from '../core/types';\n\n/**\n * Config data type for protected columns.\n * Maps table names to arrays of column names that should be protected from patching.\n */\nexport type ProtectedColumnsConfigData<DM extends DMGeneric> = {\n\t[K in keyof DM]?: (keyof WithoutSystemFields<DM[K]['document']>)[];\n};\n\n/**\n * Creates a protected columns config.\n *\n * Protected columns are removed from the patch() input type,\n * preventing accidental updates to critical fields like foreign keys.\n * Use dangerouslyPatch() to bypass this protection when needed.\n *\n * @param schema - Your Convex schema definition\n * @param config - Object mapping table names to arrays of protected column names\n * @returns Config object for use with verifyConfig\n *\n * @example\n * ```ts\n * const protectedColumns = protectedColumnsConfig(schema, {\n *   posts: ['authorId', 'createdAt'],\n *   comments: ['postId', 'authorId'],\n * });\n *\n * // In verifyConfig:\n * const { patch, dangerouslyPatch } = verifyConfig(schema, {\n *   protectedColumns,\n * });\n *\n * // patch() won't allow authorId\n * await patch(ctx, 'posts', id, {\n *   authorId: '...',  // TS Error - property doesn't exist\n *   title: 'new',     // OK\n * });\n *\n * // dangerouslyPatch() allows all columns\n * await dangerouslyPatch(ctx, 'posts', id, {\n *   authorId: '...',  // OK - bypasses protection\n * });\n * ```\n */\nexport const protectedColumnsConfig = <\n\tS extends SchemaDefinition<GenericSchema, boolean>,\n\tDataModel extends DataModelFromSchemaDefinition<S>,\n\tconst C extends ProtectedColumnsConfigData<DataModel>,\n>(\n\t_schema: S,\n\tconfig: C\n) => {\n\treturn {\n\t\t_type: 'protectedColumns' as const,\n\t\tconfig,\n\t};\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACoDO,IAAM,yBAAyB,CAKrC,SACA,WACI;AACJ,SAAO;AAAA,IACN,OAAO;AAAA,IACP;AAAA,EACD;AACD;","names":[]}

package/dist/configs/index.mjs

@@ -0,0 +1,11 @@
+// src/configs/protectedColumnsConfig.ts
+var protectedColumnsConfig = (_schema, config) => {
+  return {
+    _type: "protectedColumns",
+    config
+  };
+};
+export {
+  protectedColumnsConfig
+};
+//# sourceMappingURL=index.mjs.map

package/dist/configs/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/configs/protectedColumnsConfig.ts"],"sourcesContent":["import {\n\tDataModelFromSchemaDefinition,\n\tGenericSchema,\n\tSchemaDefinition,\n\tWithoutSystemFields,\n} from 'convex/server';\n\nimport { DMGeneric } from '../core/types';\n\n/**\n * Config data type for protected columns.\n * Maps table names to arrays of column names that should be protected from patching.\n */\nexport type ProtectedColumnsConfigData<DM extends DMGeneric> = {\n\t[K in keyof DM]?: (keyof WithoutSystemFields<DM[K]['document']>)[];\n};\n\n/**\n * Creates a protected columns config.\n *\n * Protected columns are removed from the patch() input type,\n * preventing accidental updates to critical fields like foreign keys.\n * Use dangerouslyPatch() to bypass this protection when needed.\n *\n * @param schema - Your Convex schema definition\n * @param config - Object mapping table names to arrays of protected column names\n * @returns Config object for use with verifyConfig\n *\n * @example\n * ```ts\n * const protectedColumns = protectedColumnsConfig(schema, {\n *   posts: ['authorId', 'createdAt'],\n *   comments: ['postId', 'authorId'],\n * });\n *\n * // In verifyConfig:\n * const { patch, dangerouslyPatch } = verifyConfig(schema, {\n *   protectedColumns,\n * });\n *\n * // patch() won't allow authorId\n * await patch(ctx, 'posts', id, {\n *   authorId: '...',  // TS Error - property doesn't exist\n *   title: 'new',     // OK\n * });\n *\n * // dangerouslyPatch() allows all columns\n * await dangerouslyPatch(ctx, 'posts', id, {\n *   authorId: '...',  // OK - bypasses protection\n * });\n * ```\n */\nexport const protectedColumnsConfig = <\n\tS extends SchemaDefinition<GenericSchema, boolean>,\n\tDataModel extends DataModelFromSchemaDefinition<S>,\n\tconst C extends ProtectedColumnsConfigData<DataModel>,\n>(\n\t_schema: S,\n\tconfig: C\n) => {\n\treturn {\n\t\t_type: 'protectedColumns' as const,\n\t\tconfig,\n\t};\n};\n"],"mappings":";AAoDO,IAAM,yBAAyB,CAKrC,SACA,WACI;AACJ,SAAO;AAAA,IACN,OAAO;AAAA,IACP;AAAA,EACD;AACD;","names":[]}

package/dist/core/index.d.mts

@@ -0,0 +1,58 @@
+import { SchemaDefinition, GenericSchema, DataModelFromSchemaDefinition, TableNamesInDataModel, DocumentByName, GenericMutationCtx, WithoutSystemFields } from 'convex/server';
+import { GenericId } from 'convex/values';
+import { a as ValidatePlugin } from '../plugin-mHMV2-SG.mjs';
+export { V as ValidateContext, b as ValidatePluginRecord, c as createValidatePlugin, i as isValidatePlugin, r as runValidatePlugins } from '../plugin-mHMV2-SG.mjs';
+import { V as VerifyConfigInput, H as HasKey, M as MakeOptional, b as OptionalKeysForTable, a as OnFailCallback, d as ProtectedKeysForTable } from '../types-_64SXyva.mjs';
+export { B as BaseConfigReturn, k as DMGeneric, D as DefaultValuesConfigData, l as DefaultValuesInput, E as ExtractDefaultValuesConfig, c as ExtractProtectedColumnsConfig, I as IndexConfigBaseOptions, j as IndexConfigEntry, N as NormalizedIndexConfig, O as OnFailArgs, P as Prettify, m as ProtectedColumnsInput, g as UniqueColumnConfigData, h as UniqueColumnConfigEntry, i as UniqueColumnConfigOptions, U as UniqueRowConfigData, e as UniqueRowConfigEntry, f as UniqueRowConfigOptions, n as normalizeIndexConfigEntry } from '../types-_64SXyva.mjs';
+
+/**
+ * Extended config input that includes optional validate plugins
+ */
+type VerifyConfigInputWithPlugins = VerifyConfigInput & {
+    /**
+     * Validate plugins to run after transforms.
+     * These plugins can validate data but don't affect input types.
+     */
+    plugins?: ValidatePlugin[];
+};
+/**
+ * Configure type-safe insert and patch functions with validation and transforms.
+ *
+ * @param schema - Your Convex schema definition
+ * @param configs - Configuration object with transforms, configs, and plugins
+ * @returns Object with `insert`, `patch`, and `dangerouslyPatch` functions
+ *
+ * @example
+ * ```ts
+ * import { verifyConfig, defaultValuesConfig, protectedColumnsConfig, uniqueRowConfig } from 'convex-verify';
+ * import schema from './schema';
+ *
+ * export const { insert, patch, dangerouslyPatch } = verifyConfig(schema, {
+ *   defaultValues: defaultValuesConfig(schema, () => ({
+ *     posts: { status: 'draft', views: 0 },
+ *   })),
+ *   protectedColumns: protectedColumnsConfig(schema, {
+ *     posts: ['authorId'],
+ *   }),
+ *   plugins: [
+ *     uniqueRowConfig(schema, {
+ *       posts: ['by_slug'],
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+declare const verifyConfig: <S extends SchemaDefinition<GenericSchema, boolean>, DataModel extends DataModelFromSchemaDefinition<S>, const VC extends VerifyConfigInputWithPlugins>(_schema: S, configs: VC) => {
+    insert: <const TN extends TableNamesInDataModel<DataModel>, const D extends DocumentByName<DataModel, TN>>(ctx: Omit<GenericMutationCtx<DataModel>, never>, tableName: TN, data: HasKey<VC, "defaultValues"> extends true ? MakeOptional<WithoutSystemFields<D>, OptionalKeysForTable<VC, TN> & keyof WithoutSystemFields<D>> : WithoutSystemFields<D>, options?: {
+        onFail?: OnFailCallback<D>;
+    }) => Promise<GenericId<TN>>;
+    patch: <const TN extends TableNamesInDataModel<DataModel>, const D_1 extends DocumentByName<DataModel, TN>>(ctx: Omit<GenericMutationCtx<DataModel>, never>, tableName: TN, id: GenericId<TN>, data: HasKey<VC, "protectedColumns"> extends true ? Omit<Partial<WithoutSystemFields<D_1>>, ProtectedKeysForTable<VC, TN> & keyof WithoutSystemFields<D_1>> : Partial<WithoutSystemFields<D_1>>, options?: {
+        onFail?: OnFailCallback<D_1>;
+    }) => Promise<void>;
+    dangerouslyPatch: <const TN extends TableNamesInDataModel<DataModel>, const D_2 extends DocumentByName<DataModel, TN>>(ctx: Omit<GenericMutationCtx<DataModel>, never>, tableName: TN, id: GenericId<TN>, data: Partial<WithoutSystemFields<D_2>>, options?: {
+        onFail?: OnFailCallback<D_2>;
+    }) => Promise<void>;
+    configs: VC;
+};
+
+export { HasKey, MakeOptional, OnFailCallback, OptionalKeysForTable, ProtectedKeysForTable, ValidatePlugin, VerifyConfigInput, verifyConfig };