kitcn 0.23.0 → 0.25.0

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { C as createSystemFields, S as TableName, _ as getSchemaRelations, a as generateMeta, b as OrmSchemaExtensions, d as loadBabelParser, f as loadClackPrompts, g as isColorEnabled, h as highlighter, i as resolveConfiguredBackend, l as createProjectJiti, m as loadEsbuild, n as withLocalCodegenEnv, o as getConvexConfig, p as loadDotenv, r as loadCliConfig, s as logger, t as getLocalBackendEnvVars, u as CRPC_BUILDER_STUB_SOURCE, v as Columns, x as RlsPolicies, y as EnableRLS } from "./local-env-yFKub75x.mjs";
+import { C as Columns, D as TableName, E as RlsPolicies, O as createSystemFields, S as getRankIndexes, T as OrmSchemaExtensions, _ as loadEsbuild, a as generateMeta, b as getAggregateIndexes, c as resolveSchemaDefaultExport, f as createProjectJiti, g as loadDotenv, h as loadClackPrompts, i as resolveConfiguredBackend, l as schemaDeclaresAggregateIndexes, m as loadBabelParser, n as withLocalCodegenEnv, o as getConvexConfig, p as CRPC_BUILDER_STUB_SOURCE, r as loadCliConfig, s as collectSchemaTables, t as getLocalBackendEnvVars, u as logger, v as highlighter, w as EnableRLS, x as getIndexes, y as isColorEnabled } from "./local-env-Du24tdbp.mjs";
 import { createRequire } from "node:module";
 import fs, { existsSync, readFileSync } from "node:fs";
 import path, { basename, delimiter, dirname, extname, isAbsolute, join, posix, relative, resolve } from "node:path";
@@ -12,21 +12,6 @@ import { diffWords, structuredPatch } from "diff";
 import { parseEnv } from "node:util";
 import { createServer } from "node:http";
 
-//#region src/orm/index-utils.ts
-function getIndexes(table) {
-	const indexes = table.getIndexes?.();
-	return Array.isArray(indexes) ? indexes : [];
-}
-function getAggregateIndexes(table) {
-	const indexes = table.getAggregateIndexes?.();
-	return Array.isArray(indexes) ? indexes : [];
-}
-function getRankIndexes(table) {
-	const indexes = table.getRankIndexes?.();
-	return Array.isArray(indexes) ? indexes : [];
-}
-
-//#endregion
 //#region src/orm/mutation-utils.ts
 const UTF8_ENCODER = new TextEncoder();
 function getTableName(table) {
@@ -2506,7 +2491,7 @@ function QueryProvider({ children }: { children: ReactNode }) {
 const FUNCTIONS_DIR_IMPORT_PLACEHOLDER$5 = "__KITCN_FUNCTIONS_DIR__";
 const PLUGIN_CONFIG_IMPORT_PLACEHOLDER$1 = "__KITCN_PLUGIN_CONFIG_IMPORT__";
 const PLUGIN_SCHEMA_IMPORT_PLACEHOLDER$1 = "__KITCN_PLUGIN_SCHEMA_IMPORT__";
-const PROJECT_CRPC_IMPORT_PLACEHOLDER$3 = "__KITCN_PROJECT_CRPC_IMPORT__";
+const PROJECT_CRPC_IMPORT_PLACEHOLDER$4 = "__KITCN_PROJECT_CRPC_IMPORT__";
 const PROJECT_SHARED_API_IMPORT_PLACEHOLDER = "__KITCN_PROJECT_SHARED_API_IMPORT__";
 const PROJECT_GET_ENV_IMPORT_PLACEHOLDER$2 = "__KITCN_PROJECT_GET_ENV_IMPORT__";
 
@@ -2536,7 +2521,7 @@ const INIT_HTTP_IMPORT_MARKER = "// __KITCN_HTTP_IMPORTS__";
 const INIT_HTTP_ROUTE_MARKER = "  // __KITCN_HTTP_ROUTES__";
 const INIT_HTTP_TEMPLATE = `import { createHttpRouter } from 'kitcn/server';
 import { Hono } from 'hono';
-import { router } from '${PROJECT_CRPC_IMPORT_PLACEHOLDER$3}';
+import { router } from '${PROJECT_CRPC_IMPORT_PLACEHOLDER$4}';
 ${INIT_HTTP_IMPORT_MARKER}
 
 const app = new Hono();
@@ -2849,7 +2834,7 @@ function resolveRelativeImportPath(filePath, targetFilePath) {
 	return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
 }
 function renderInitTemplateContent(params) {
-	return params.template.replaceAll(FUNCTIONS_DIR_IMPORT_PLACEHOLDER$5, resolveRelativeImportPath(params.filePath, params.functionsDir)).replaceAll(PROJECT_CRPC_IMPORT_PLACEHOLDER$3, resolveRelativeImportPath(params.filePath, params.crpcFilePath));
+	return params.template.replaceAll(FUNCTIONS_DIR_IMPORT_PLACEHOLDER$5, resolveRelativeImportPath(params.filePath, params.functionsDir)).replaceAll(PROJECT_CRPC_IMPORT_PLACEHOLDER$4, resolveRelativeImportPath(params.filePath, params.crpcFilePath));
 }
 
 //#endregion
@@ -3424,7 +3409,7 @@ const resolvePluginScaffoldFiles = (templates, roots, functionsDir, existingTemp
 	const lockfilePath = normalizeLockfileScaffoldPath(mappedLockfilePath) ?? normalizePath$2(relative(process.cwd(), join(rootDir, template.path)));
 	const filePath = resolve(process.cwd(), lockfilePath);
 	const getEnvImportPath = resolveProjectGetEnvImportPrefix(filePath, roots.envFilePath);
-	const content = template.content.replaceAll(FUNCTIONS_DIR_IMPORT_PLACEHOLDER$5, resolveFunctionsDirImportPrefix(filePath, functionsDir)).replaceAll(PROJECT_CRPC_IMPORT_PLACEHOLDER$3, resolveProjectCrpcImportPrefix(filePath, roots.crpcFilePath)).replaceAll(PROJECT_SHARED_API_IMPORT_PLACEHOLDER, resolveProjectSharedApiImportPrefix(filePath, roots.sharedApiFilePath)).replaceAll(PROJECT_GET_ENV_IMPORT_PLACEHOLDER$2, `import { getEnv } from '${getEnvImportPath}';`).replaceAll(PLUGIN_CONFIG_IMPORT_PLACEHOLDER$1, resolvePluginConfigImportPrefix(filePath, roots.libRootDir)).replaceAll(PLUGIN_SCHEMA_IMPORT_PLACEHOLDER$1, resolvePluginSchemaImportPrefix(filePath, roots.libRootDir));
+	const content = template.content.replaceAll(FUNCTIONS_DIR_IMPORT_PLACEHOLDER$5, resolveFunctionsDirImportPrefix(filePath, functionsDir)).replaceAll(PROJECT_CRPC_IMPORT_PLACEHOLDER$4, resolveProjectCrpcImportPrefix(filePath, roots.crpcFilePath)).replaceAll(PROJECT_SHARED_API_IMPORT_PLACEHOLDER, resolveProjectSharedApiImportPrefix(filePath, roots.sharedApiFilePath)).replaceAll(PROJECT_GET_ENV_IMPORT_PLACEHOLDER$2, `import { getEnv } from '${getEnvImportPath}';`).replaceAll(PLUGIN_CONFIG_IMPORT_PLACEHOLDER$1, resolvePluginConfigImportPrefix(filePath, roots.libRootDir)).replaceAll(PLUGIN_SCHEMA_IMPORT_PLACEHOLDER$1, resolvePluginSchemaImportPrefix(filePath, roots.libRootDir));
 	if (!(descriptor.key === "auth" && preset === "convex") && (template.target === "functions" || template.target === "lib") && content.includes("process.env")) throw new Error(`Scaffold template "${descriptor.key}/${template.id}" contains process.env. Use getEnv() instead.`);
 	return {
 		templateId: template.id,
@@ -6776,10 +6761,46 @@ const authRegistryItem = defineInternalRegistryItem({
 	}
 });
 
+//#endregion
+//#region src/cli/registry/items/ratelimit/ratelimit-functions.template.ts
+const PROJECT_CRPC_IMPORT_PLACEHOLDER$3 = "__KITCN_PROJECT_CRPC_IMPORT__";
+const RATELIMIT_FUNCTIONS_TEMPLATE = `import { cleanupRatelimitState } from "kitcn/ratelimit";
+import { z } from "zod";
+import { privateMutation } from "${PROJECT_CRPC_IMPORT_PLACEHOLDER$3}";
+
+const DEFAULT_BATCH_SIZE = 500;
+
+export const cleanup = privateMutation
+  .input(
+    z.object({
+      olderThanMs: z.number().positive(),
+      limit: z.number().int().min(1).max(1000).optional(),
+    })
+  )
+  .output(
+    z.object({
+      deleted: z.number(),
+      hasMore: z.boolean(),
+    })
+  )
+  .mutation(async ({ ctx, input }) =>
+    cleanupRatelimitState(ctx.db, {
+      before: Date.now() - input.olderThanMs,
+      limit: input.limit ?? DEFAULT_BATCH_SIZE,
+    })
+  );
+`;
+
 //#endregion
 //#region src/cli/registry/items/ratelimit/ratelimit-plugin.template.ts
 const FUNCTIONS_DIR_IMPORT_PLACEHOLDER$4 = "__KITCN_FUNCTIONS_DIR__";
-const RATELIMIT_PLUGIN_TEMPLATE = `import { MINUTE, Ratelimit, RatelimitPlugin } from "kitcn/ratelimit";
+const RATELIMIT_PLUGIN_TEMPLATE = `import {
+  type LimitRequest,
+  MINUTE,
+  Ratelimit,
+  RatelimitPlugin,
+  SECOND,
+} from "kitcn/ratelimit";
 import type { MutationCtx } from "${FUNCTIONS_DIR_IMPORT_PLACEHOLDER$4}/generated/server";
 
 const fixed = (rate: number) => Ratelimit.fixedWindow(rate, MINUTE);
@@ -6790,6 +6811,11 @@ export const ratelimitBuckets = {
     free: fixed(60),
     premium: fixed(200),
   },
+  interactive: {
+    public: Ratelimit.fixedWindow(3, 30 * SECOND),
+    free: Ratelimit.fixedWindow(3, 30 * SECOND),
+    premium: Ratelimit.fixedWindow(3, 30 * SECOND),
+  },
 } as const;
 
 type RatelimitTier = keyof (typeof ratelimitBuckets)["default"];
@@ -6829,14 +6855,38 @@ async function getRequestSignals(ctx: RatelimitCtx) {
   };
 }
 
+/**
+ * The identifier is the rate-limit partition key: everything that resolves to
+ * the same string shares one budget and one \`ratelimitState\` document.
+ *
+ * Unauthenticated traffic is keyed by request IP so one visitor cannot spend
+ * every other visitor's budget. Calls without request metadata all fall back
+ * to one key.
+ */
+function getRequestIdentifier(
+  user: RatelimitUser | null,
+  signals: LimitRequest | undefined
+) {
+  if (user) {
+    return user.id;
+  }
+
+  return signals?.ip ? \`ip:\${signals.ip}\` : "ip:unknown";
+}
+
 export const ratelimit = RatelimitPlugin.configure({
   buckets: ratelimitBuckets,
   getBucket: ({ meta }: { meta: RatelimitMeta }) => meta.ratelimit ?? "default",
   getUser: ({ ctx }: { ctx: RatelimitCtx }) => ctx.user ?? null,
-  getIdentifier: ({ user }: { user: RatelimitUser | null }) =>
-    user?.id ?? "anonymous",
   getTier: getUserTier,
   getSignals: ({ ctx }: { ctx: RatelimitCtx }) => getRequestSignals(ctx),
+  getIdentifier: ({
+    user,
+    signals,
+  }: {
+    user: RatelimitUser | null;
+    signals: LimitRequest | undefined;
+  }) => getRequestIdentifier(user, signals),
   prefix: ({ bucket, tier }) => \`ratelimit:\${bucket}:\${tier}\`,
   failureMode: "closed",
   enableProtection: true,
@@ -6869,6 +6919,7 @@ export const ratelimitStateTable = convexTable(
   (t) => [
     index("by_name_key_shard").on(t.name, t.key, t.shard),
     index("by_name_key").on(t.name, t.key),
+    index("by_ts").on(t.ts),
   ],
 );
 
@@ -6909,18 +6960,28 @@ export function ratelimitExtension() {
 
 //#endregion
 //#region src/cli/registry/items/ratelimit/ratelimit-item.ts
-const RATELIMIT_FILES = [createRegistryFile({
-	id: "ratelimit-schema",
-	path: "schema.ts",
-	target: "lib",
-	content: RATELIMIT_SCHEMA_TEMPLATE
-}), createRegistryFile({
-	id: "ratelimit-plugin",
-	path: "plugin.ts",
-	target: "lib",
-	content: RATELIMIT_PLUGIN_TEMPLATE,
-	requires: ["ratelimit-schema"]
-})];
+const RATELIMIT_FILES = [
+	createRegistryFile({
+		id: "ratelimit-schema",
+		path: "schema.ts",
+		target: "lib",
+		content: RATELIMIT_SCHEMA_TEMPLATE
+	}),
+	createRegistryFile({
+		id: "ratelimit-functions",
+		path: "ratelimit.ts",
+		target: "functions",
+		content: RATELIMIT_FUNCTIONS_TEMPLATE,
+		requires: ["ratelimit-schema"]
+	}),
+	createRegistryFile({
+		id: "ratelimit-plugin",
+		path: "plugin.ts",
+		target: "lib",
+		content: RATELIMIT_PLUGIN_TEMPLATE,
+		requires: ["ratelimit-schema"]
+	})
+];
 function buildRatelimitCrpcRegistrationPlanFile(params) {
 	const crpcPath = getCrpcFilePath(params.config);
 	const baselineCrpcSource = renderInitTemplateContent({
@@ -6966,7 +7027,7 @@ const ratelimitRegistryItem = defineInternalRegistryItem({
 		presets: [{
 			name: "server-first",
 			description: "Scaffold a reusable ratelimit plugin and auto-register schema extension.",
-			registryDependencies: ["ratelimit-schema", "ratelimit-plugin"]
+			registryDependencies: RATELIMIT_FILES.map((file) => file.meta.id)
 		}, {
 			name: "schema-only",
 			description: "Only register ratelimit extension in schema.",
@@ -11971,6 +12032,10 @@ function normalizeStringList(values) {
 	if (!Array.isArray(values)) return [];
 	return [...new Set(values.filter((value) => typeof value === "string"))].sort();
 }
+function normalizeOrderedStringList(values) {
+	if (!Array.isArray(values)) return [];
+	return [...new Set(values.filter((value) => typeof value === "string"))];
+}
 function readOptionalCliFlagValue(args, flag) {
 	for (let i = 0; i < args.length; i += 1) {
 		const arg = args[i];
@@ -11986,24 +12051,6 @@ function readOptionalCliFlagValue(args, flag) {
 		}
 	}
 }
-function resolveSchemaDefaultExport(schemaModule) {
-	const schemaValue = schemaModule.default !== void 0 ? schemaModule.default : schemaModule;
-	if (!schemaValue || typeof schemaValue !== "object") return null;
-	return schemaValue;
-}
-function collectSchemaTables(schemaValue) {
-	const allTables = /* @__PURE__ */ new Set();
-	const relations = getSchemaRelations(schemaValue);
-	if (relations && typeof relations === "object" && !Array.isArray(relations)) for (const relationConfig of Object.values(relations)) {
-		const table = relationConfig?.table;
-		if (table) allTables.add(table);
-	}
-	const tables = schemaValue.tables;
-	if (tables && typeof tables === "object" && !Array.isArray(tables)) {
-		for (const table of Object.values(tables)) if (table) allTables.add(table);
-	}
-	return [...allTables];
-}
 function buildAggregateFingerprintPayload(tables) {
 	return tables.map((table) => getTableConfig(table)).map((tableConfig) => ({
 		tableName: tableConfig.name,
@@ -12015,18 +12062,60 @@ function buildAggregateFingerprintPayload(tables) {
 			avgFields: normalizeStringList(index.avgFields),
 			minFields: normalizeStringList(index.minFields),
 			maxFields: normalizeStringList(index.maxFields)
+		})).sort((a, b) => a.name.localeCompare(b.name)),
+		rankIndexes: tableConfig.rankIndexes.map((index) => ({
+			name: index.name,
+			partitionFields: normalizeOrderedStringList(index.partitionFields),
+			orderFields: (index.orderFields ?? []).map((field) => `${field.field}:${field.direction}`),
+			sumField: index.sumField ?? ""
 		})).sort((a, b) => a.name.localeCompare(b.name))
 	})).sort((a, b) => a.tableName.localeCompare(b.tableName));
 }
-async function computeAggregateIndexFingerprint(functionsDir) {
+async function loadBackendSchemaValue(functionsDir) {
 	const schemaPath = join(functionsDir, "schema.ts");
 	if (!fs.existsSync(schemaPath)) return null;
 	const schemaModule = await createProjectJiti().import(schemaPath);
 	if (!schemaModule || typeof schemaModule !== "object") return null;
-	const schemaValue = resolveSchemaDefaultExport(schemaModule);
+	return resolveSchemaDefaultExport(schemaModule);
+}
+/**
+* Whether the deployed ORM can serve the aggregate procedures at all.
+*
+* `kitcn codegen` registers `aggregateCapability()` only for schemas that
+* declare an `aggregateIndex`/`rankIndex`, so calling `aggregateBackfill`
+* against a schema without one is a guaranteed error rather than a no-op.
+*
+* No schema file means no ORM and no aggregate procedures to call. A schema
+* that exists but fails to load is treated as using them, so a real backfill
+* is never skipped over a transient load error.
+*/
+async function backendUsesAggregateIndexes() {
+	try {
+		const { functionsDir } = getConvexConfig();
+		const schemaValue = await loadBackendSchemaValue(functionsDir);
+		if (!schemaValue) return false;
+		return schemaDeclaresAggregateIndexes(schemaValue);
+	} catch {
+		return true;
+	}
+}
+/**
+* Whether the deployed ORM registered `migrationCapability()`. Codegen keys
+* that off the generated manifest, so the flows key off the same file.
+*/
+function backendUsesMigrations() {
+	try {
+		const { functionsDir } = getConvexConfig();
+		return fs.existsSync(join(functionsDir, "migrations", "manifest.ts"));
+	} catch {
+		return true;
+	}
+}
+async function computeAggregateIndexFingerprint(functionsDir) {
+	const schemaValue = await loadBackendSchemaValue(functionsDir);
 	if (!schemaValue) return null;
 	const tables = collectSchemaTables(schemaValue);
-	if (tables.length === 0) return null;
+	if (tables.length === 0 || !schemaDeclaresAggregateIndexes(schemaValue)) return null;
 	const payload = buildAggregateFingerprintPayload(tables);
 	return createHash("sha256").update(JSON.stringify(payload)).digest("hex");
 }
@@ -12924,7 +13013,8 @@ async function runAggregateBackfillFlow(params) {
 	const { execaFn, backendAdapter, backfillConfig, mode, targetArgs, env, signal, context } = params;
 	if (signal?.aborted) return 0;
 	if (backfillConfig.enabled === "off") return 0;
-	const kickoff = await runBackendFunction(execaFn, backendAdapter, "generated/server:aggregateBackfill", {
+	if (!await backendUsesAggregateIndexes()) return 0;
+	const kickoff = await runBackendFunction(execaFn, backendAdapter, "generated/aggregate:aggregateBackfill", {
 		mode,
 		batchSize: backfillConfig.batchSize
 	}, targetArgs, {
@@ -12957,7 +13047,7 @@ async function runAggregateBackfillFlow(params) {
 	const deadline = Date.now() + backfillConfig.timeoutMs;
 	let lastProgress = "";
 	while (!signal?.aborted) {
-		const statusResult = await runBackendFunction(execaFn, backendAdapter, "generated/server:aggregateBackfillStatus", {}, targetArgs, {
+		const statusResult = await runBackendFunction(execaFn, backendAdapter, "generated/aggregate:aggregateBackfillStatus", {}, targetArgs, {
 			echoOutput: false,
 			env
 		});
@@ -12991,7 +13081,7 @@ async function runAggregateBackfillFlow(params) {
 }
 async function runAggregatePruneFlow(params) {
 	const { execaFn, backendAdapter, targetArgs, env } = params;
-	const result = await runBackendFunction(execaFn, backendAdapter, "generated/server:aggregateBackfill", { mode: "prune" }, targetArgs, {
+	const result = await runBackendFunction(execaFn, backendAdapter, "generated/aggregate:aggregateBackfill", { mode: "prune" }, targetArgs, {
 		echoOutput: false,
 		env
 	});
@@ -13102,6 +13192,7 @@ export const migration = defineMigration({
 async function runMigrationFlow(params) {
 	const { execaFn, backendAdapter, migrationConfig, targetArgs, env, signal, context, direction, steps, to } = params;
 	if (signal?.aborted || migrationConfig.enabled === "off") return 0;
+	if (!backendUsesMigrations()) return 0;
 	const kickoff = await runBackendFunction(execaFn, backendAdapter, "generated/server:migrationRun", {
 		direction,
 		batchSize: migrationConfig.batchSize,
@@ -15318,6 +15409,10 @@ const handleMigrateCommand = async (argv, deps = {}) => {
 			to
 		});
 	}
+	if (!backendUsesMigrations()) {
+		logger.info("No migrations manifest. Run `kitcn migrate create <name>` to add one.");
+		return 0;
+	}
 	if (migrateArgs.subcommand === "status") return (await runBackendFunction(execaFn, backendAdapter, "generated/server:migrationStatus", {}, targetArgs, { env: commandEnv })).exitCode;
 	let runId;
 	const cancelArgs = [];

package/dist/{convex-plugin-D8B0oCFq.js → convex-plugin-DfOhBU9g.js}

@@ -1,4 +1,4 @@
-import { r as omit } from "./upstream-BR6sBLg3.js";
+import { r as omit } from "./upstream-BCgGZX6q.js";
 import { createAuthEndpoint, createAuthMiddleware, sessionMiddleware } from "better-auth/api";
 import { bearer } from "better-auth/plugins/bearer";
 import { jwt } from "better-auth/plugins/jwt";

package/dist/{create-schema-orm-B3f2Kc8O.js → create-schema-orm-Bu2JCiBS.js}

@@ -1,4 +1,4 @@
-import { augmentBetterAuthTables, indexFields } from "./create-schema-BXrKE2YY.js";
+import { augmentBetterAuthTables, indexFields } from "./create-schema-BRFjdgRr.js";
 
 //#region src/auth/create-schema-orm.ts
 const specialFields = (tables) => Object.fromEntries(Object.entries(tables).map(([key, table]) => {

package/dist/crpc/index.d.ts

@@ -1,5 +1,5 @@
-import { A as DataTransformer, F as decodeWire, I as defaultCRPCTransformer, L as encodeWire, M as WireCodec, N as createTaggedTransformer, O as CombinedDataTransformer, P as dateWireCodec, R as getTransformer, a as HttpProcedureCall, c as InferHttpInput, i as HttpErrorCode, j as DataTransformerOptions, k as DATE_CODEC_TAG, l as InferHttpOutput, n as HttpClientError, o as HttpRouteInfo, r as HttpClientFromRouter, s as HttpRouteMap, t as HttpClient, u as isHttpClientError, z as identityTransformer } from "../http-types-BoSDAh4Y.js";
-import { A as HttpInputArgs, C as ReservedMutationOptions, D as VanillaMutation, E as VanillaAction, F as replaceUrlParam, M as RESERVED_KEYS, N as buildSearchParams, O as HttpClientOptions, P as executeHttpRequest, S as ReservedInfiniteQueryOptions, T as StaticQueryOptsParam, _ as IsPaginated, a as BaseInfiniteQueryOptsParam, b as PaginatedFnMeta, c as ConvexMutationKey, d as ConvexQueryMeta, f as EmptyObject, g as InfiniteQueryInput, h as FnMeta, i as BaseConvexQueryOptions, j as HttpProxyBaseOptions, k as HttpFormValue, l as ConvexQueryHookOptions, m as FUNC_REF_SYMBOL, n as BaseConvexActionOptions, o as ConvexActionKey, p as ExtractPaginatedItem, r as BaseConvexInfiniteQueryOptions, s as ConvexInfiniteQueryMeta, t as AuthType, u as ConvexQueryKey, v as Meta, w as ReservedQueryOptions, x as PaginationOpts, y as MutationVariables } from "../types-C0Xl7P8K.js";
+import { B as dateWireCodec, F as DATE_CODEC_TAG, G as identityTransformer, H as defaultCRPCTransformer, I as DataTransformer, L as DataTransformerOptions, P as CombinedDataTransformer, R as WireCodec, U as encodeWire, V as decodeWire, W as getTransformer, a as HttpErrorCode, c as HttpQueryKey, d as HttpRouteMap, f as InferHttpInput, g as isHttpClientError, h as buildHttpQueryPrefixKey, i as HttpClientFromRouter, l as HttpQueryPrefixKey, m as buildHttpQueryKey, n as HttpClient, o as HttpMutationKey, p as InferHttpOutput, r as HttpClientError, s as HttpProcedureCall, t as HTTP_DEFAULT_STALE_TIME, u as HttpRouteInfo, z as createTaggedTransformer } from "../http-types-90mapMP9.js";
+import { A as HttpInputArgs, C as ReservedMutationOptions, D as VanillaMutation, E as VanillaAction, F as replaceUrlParam, M as RESERVED_KEYS, N as buildSearchParams, O as HttpClientOptions, P as executeHttpRequest, S as ReservedInfiniteQueryOptions, T as StaticQueryOptsParam, _ as IsPaginated, a as BaseInfiniteQueryOptsParam, b as PaginatedFnMeta, c as ConvexMutationKey, d as ConvexQueryMeta, f as EmptyObject, g as InfiniteQueryInput, h as FnMeta, i as BaseConvexQueryOptions, j as HttpProxyBaseOptions, k as HttpFormValue, l as ConvexQueryHookOptions, m as FUNC_REF_SYMBOL, n as BaseConvexActionOptions, o as ConvexActionKey, p as ExtractPaginatedItem, r as BaseConvexInfiniteQueryOptions, s as ConvexInfiniteQueryMeta, t as AuthType, u as ConvexQueryKey, v as Meta, w as ReservedQueryOptions, x as PaginationOpts, y as MutationVariables } from "../types-In-ZZOsd.js";
 import { FunctionArgs, FunctionReference } from "convex/server";
 
 //#region src/crpc/auth-error.d.ts
@@ -102,4 +102,4 @@ declare function convexAction<T extends FunctionReference<'action'>>(funcRef: T,
  */
 declare function convexInfiniteQueryOptions<T extends FunctionReference<'query'>>(funcRef: T, args: Record<string, unknown> | 'skip', opts?: BaseInfiniteQueryOptsParam<T> & Record<string, unknown>, meta?: Meta): BaseConvexInfiniteQueryOptions<T> & Record<string, unknown>;
 //#endregion
-export { AuthMutationError, AuthType, BaseConvexActionOptions, BaseConvexInfiniteQueryOptions, BaseConvexQueryOptions, BaseInfiniteQueryOptsParam, CRPCClientError, CombinedDataTransformer, ConvexActionKey, ConvexInfiniteQueryMeta, ConvexMutationKey, ConvexQueryHookOptions, ConvexQueryKey, ConvexQueryMeta, DATE_CODEC_TAG, DataTransformer, DataTransformerOptions, EmptyObject, ExtractPaginatedItem, FUNC_REF_SYMBOL, FnMeta, HttpClient, HttpClientError, HttpClientFromRouter, HttpClientOptions, HttpErrorCode, HttpFormValue, HttpInputArgs, HttpProcedureCall, HttpProxyBaseOptions, HttpRouteInfo, HttpRouteMap, InferHttpInput, InferHttpOutput, InfiniteQueryInput, IsPaginated, Meta, MutationVariables, PaginatedFnMeta, PaginationOpts, RESERVED_KEYS, ReservedInfiniteQueryOptions, ReservedMutationOptions, ReservedQueryOptions, StaticQueryOptsParam, VanillaAction, VanillaMutation, WireCodec, buildSearchParams, convexAction, convexInfiniteQueryOptions, convexQuery, createTaggedTransformer, dateWireCodec, decodeWire, defaultCRPCTransformer, defaultIsUnauthorized, encodeWire, executeHttpRequest, getTransformer, identityTransformer, isAuthMutationError, isCRPCClientError, isCRPCError, isCRPCErrorCode, isHttpClientError, replaceUrlParam };
+export { AuthMutationError, AuthType, BaseConvexActionOptions, BaseConvexInfiniteQueryOptions, BaseConvexQueryOptions, BaseInfiniteQueryOptsParam, CRPCClientError, CombinedDataTransformer, ConvexActionKey, ConvexInfiniteQueryMeta, ConvexMutationKey, ConvexQueryHookOptions, ConvexQueryKey, ConvexQueryMeta, DATE_CODEC_TAG, DataTransformer, DataTransformerOptions, EmptyObject, ExtractPaginatedItem, FUNC_REF_SYMBOL, FnMeta, HTTP_DEFAULT_STALE_TIME, HttpClient, HttpClientError, HttpClientFromRouter, HttpClientOptions, HttpErrorCode, HttpFormValue, HttpInputArgs, HttpMutationKey, HttpProcedureCall, HttpProxyBaseOptions, HttpQueryKey, HttpQueryPrefixKey, HttpRouteInfo, HttpRouteMap, InferHttpInput, InferHttpOutput, InfiniteQueryInput, IsPaginated, Meta, MutationVariables, PaginatedFnMeta, PaginationOpts, RESERVED_KEYS, ReservedInfiniteQueryOptions, ReservedMutationOptions, ReservedQueryOptions, StaticQueryOptsParam, VanillaAction, VanillaMutation, WireCodec, buildHttpQueryKey, buildHttpQueryPrefixKey, buildSearchParams, convexAction, convexInfiniteQueryOptions, convexQuery, createTaggedTransformer, dateWireCodec, decodeWire, defaultCRPCTransformer, defaultIsUnauthorized, encodeWire, executeHttpRequest, getTransformer, identityTransformer, isAuthMutationError, isCRPCClientError, isCRPCError, isCRPCErrorCode, isHttpClientError, replaceUrlParam };

package/dist/crpc/index.js

@@ -1,6 +1,6 @@
-import { a as isCRPCErrorCode, i as isCRPCError, n as defaultIsUnauthorized, r as isCRPCClientError, t as CRPCClientError } from "../error-Bvo7YEhk.js";
-import { a as defaultCRPCTransformer, c as identityTransformer, i as decodeWire, n as createTaggedTransformer, o as encodeWire, r as dateWireCodec, s as getTransformer, t as DATE_CODEC_TAG } from "../transformer-yZuBWo8v.js";
-import { a as buildSearchParams, c as HttpClientError, i as RESERVED_KEYS, l as isHttpClientError, n as convexInfiniteQueryOptions, o as executeHttpRequest, r as convexQuery, s as replaceUrlParam, t as convexAction } from "../query-options-C_eBSIXG.js";
+import { a as isCRPCErrorCode, i as isCRPCError, n as defaultIsUnauthorized, r as isCRPCClientError, t as CRPCClientError } from "../error-CMLeCadS.js";
+import { a as defaultCRPCTransformer, c as identityTransformer, i as decodeWire, n as createTaggedTransformer, o as encodeWire, r as dateWireCodec, s as getTransformer, t as DATE_CODEC_TAG } from "../transformer-D8wO-kEj.js";
+import { a as buildSearchParams, c as HTTP_DEFAULT_STALE_TIME, d as buildHttpQueryPrefixKey, f as isHttpClientError, i as RESERVED_KEYS, l as HttpClientError, n as convexInfiniteQueryOptions, o as executeHttpRequest, r as convexQuery, s as replaceUrlParam, t as convexAction, u as buildHttpQueryKey } from "../query-options-DUiOj01a.js";
 
 //#region src/crpc/auth-error.ts
 /**
@@ -40,4 +40,4 @@ function isAuthMutationError(error) {
 const FUNC_REF_SYMBOL = Symbol.for("convex.funcRef");
 
 //#endregion
-export { AuthMutationError, CRPCClientError, DATE_CODEC_TAG, FUNC_REF_SYMBOL, HttpClientError, RESERVED_KEYS, buildSearchParams, convexAction, convexInfiniteQueryOptions, convexQuery, createTaggedTransformer, dateWireCodec, decodeWire, defaultCRPCTransformer, defaultIsUnauthorized, encodeWire, executeHttpRequest, getTransformer, identityTransformer, isAuthMutationError, isCRPCClientError, isCRPCError, isCRPCErrorCode, isHttpClientError, replaceUrlParam };
+export { AuthMutationError, CRPCClientError, DATE_CODEC_TAG, FUNC_REF_SYMBOL, HTTP_DEFAULT_STALE_TIME, HttpClientError, RESERVED_KEYS, buildHttpQueryKey, buildHttpQueryPrefixKey, buildSearchParams, convexAction, convexInfiniteQueryOptions, convexQuery, createTaggedTransformer, dateWireCodec, decodeWire, defaultCRPCTransformer, defaultIsUnauthorized, encodeWire, executeHttpRequest, getTransformer, identityTransformer, isAuthMutationError, isCRPCClientError, isCRPCError, isCRPCErrorCode, isHttpClientError, replaceUrlParam };

package/dist/{customFunctions-DxEEO4Dq.js → customFunctions-BbhgdRGl.js}

@@ -1,5 +1,5 @@
-import { i as pick, r as omit } from "./upstream-BR6sBLg3.js";
-import { t as addFieldsToValidator } from "./validators-C7LelqTN.js";
+import { i as pick, r as omit } from "./upstream-BCgGZX6q.js";
+import { t as addFieldsToValidator } from "./validators-Dmbhsd3U.js";
 
 //#region src/internal/upstream/server/customFunctions.ts
 /**

package/dist/definitions-D9vhJ6OV.js

@@ -0,0 +1,215 @@
+import { A as integer, C as index, I as ConvexColumnBuilder, L as entityKind, M as custom, O as text, t as convexTable } from "./table-rmJm5Qio.js";
+import { t as defineSchemaExtension } from "./extensions-DzjCJXYl.js";
+import { v } from "convex/values";
+
+//#region src/orm/builders/boolean.ts
+/**
+* Boolean column builder class
+* Compiles to v.boolean() or v.optional(v.boolean())
+*/
+var ConvexBooleanBuilder = class extends ConvexColumnBuilder {
+	static [entityKind] = "ConvexBooleanBuilder";
+	constructor(name) {
+		super(name, "boolean", "ConvexBoolean");
+	}
+	/**
+	* Expose Convex validator for schema integration
+	*/
+	get convexValidator() {
+		if (this.config.notNull) return v.boolean();
+		return v.optional(v.union(v.null(), v.boolean()));
+	}
+	/**
+	* Compile to Convex validator
+	* .notNull() → v.boolean()
+	* nullable → v.optional(v.boolean())
+	*/
+	build() {
+		return this.convexValidator;
+	}
+};
+function boolean(name) {
+	return new ConvexBooleanBuilder(name ?? "");
+}
+
+//#endregion
+//#region src/orm/migrations/schema.ts
+const MIGRATION_STATE_TABLE = "migration_state";
+const MIGRATION_RUN_TABLE = "migration_run";
+const migrationStateTable = convexTable(MIGRATION_STATE_TABLE, {
+	migrationId: text().notNull(),
+	checksum: text().notNull(),
+	applied: boolean().notNull(),
+	status: text().notNull(),
+	direction: text(),
+	runId: text(),
+	cursor: text(),
+	processed: integer().notNull(),
+	startedAt: integer(),
+	updatedAt: integer().notNull(),
+	completedAt: integer(),
+	lastError: text(),
+	writeMode: text().notNull()
+}, (t) => [index("by_migration_id").on(t.migrationId), index("by_status").on(t.status)]);
+const migrationRunTable = convexTable(MIGRATION_RUN_TABLE, {
+	runId: text().notNull(),
+	direction: text().notNull(),
+	status: text().notNull(),
+	dryRun: boolean().notNull(),
+	allowDrift: boolean().notNull(),
+	migrationIds: custom(v.array(v.string())).notNull(),
+	currentIndex: integer().notNull(),
+	startedAt: integer().notNull(),
+	updatedAt: integer().notNull(),
+	completedAt: integer(),
+	cancelRequested: boolean().notNull(),
+	lastError: text()
+}, (t) => [index("by_run_id").on(t.runId), index("by_status").on(t.status)]);
+const migrationStorageTables = {
+	[MIGRATION_STATE_TABLE]: migrationStateTable,
+	[MIGRATION_RUN_TABLE]: migrationRunTable
+};
+const MIGRATION_STORAGE_TABLE_NAMES = new Set([MIGRATION_STATE_TABLE, MIGRATION_RUN_TABLE]);
+function migrationExtension() {
+	return defineSchemaExtension("migration", migrationStorageTables);
+}
+function injectMigrationStorageTables(schema) {
+	const merged = { ...schema };
+	for (const [tableName, tableDef] of Object.entries(migrationStorageTables)) {
+		if (tableName in schema && schema[tableName] !== tableDef) throw new Error(`defineSchema cannot inject internal table '${tableName}' because the name is already in use.`);
+		merged[tableName] = tableDef;
+	}
+	return merged;
+}
+
+//#endregion
+//#region src/orm/migrations/definitions.ts
+const MIGRATION_ID_RE = /^[a-zA-Z0-9_:-]+$/;
+const FUNCTION_SOURCE_WHITESPACE_RE = /\s+/g;
+const FUNCTION_SOURCE_PUNCTUATION_SPACE_RE = /\s*([{}();,:])\s*/g;
+function defineMigration(migration) {
+	validateMigrationId(migration.id);
+	validateMigrationStep("up", migration.up);
+	if (migration.down) validateMigrationStep("down", migration.down);
+	return migration;
+}
+function defineMigrationSet(migrations) {
+	const normalized = [...migrations].map((migration) => {
+		const defined = defineMigration(migration);
+		return {
+			...defined,
+			checksum: defined.checksum ?? computeMigrationChecksum(defined)
+		};
+	});
+	normalized.sort((a, b) => a.id.localeCompare(b.id));
+	const byId = {};
+	for (const migration of normalized) {
+		if (byId[migration.id]) throw new Error(`defineMigrationSet received duplicate migration id '${migration.id}'.`);
+		byId[migration.id] = migration;
+	}
+	return {
+		migrations: normalized,
+		ids: normalized.map((migration) => migration.id),
+		byId
+	};
+}
+function detectMigrationDrift(params) {
+	const { migrationSet, appliedState } = params;
+	const issues = [];
+	for (const [migrationId, state] of Object.entries(appliedState)) {
+		if (!state.applied) continue;
+		const migration = migrationSet.byId[migrationId];
+		if (!migration) {
+			issues.push({
+				kind: "missing_from_manifest",
+				migrationId,
+				message: `Applied migration '${migrationId}' is missing from the current migration manifest.`
+			});
+			continue;
+		}
+		if (state.checksum && state.checksum !== migration.checksum) issues.push({
+			kind: "checksum_mismatch",
+			migrationId,
+			expectedChecksum: migration.checksum,
+			actualChecksum: state.checksum,
+			message: `Applied migration '${migrationId}' checksum drift detected.`
+		});
+	}
+	return issues;
+}
+function buildMigrationPlan(params) {
+	const { direction, migrationSet, appliedState, steps, to } = params;
+	if (direction === "up") return {
+		direction,
+		migrations: migrationSet.migrations.filter((migration) => !appliedState[migration.id]?.applied)
+	};
+	if (steps !== void 0 && to !== void 0) throw new Error("Use either down steps or down to, not both.");
+	const appliedInOrder = migrationSet.migrations.filter((migration) => appliedState[migration.id]?.applied);
+	const ensureDownSteps = (selected) => {
+		const missingDown = selected.find((migration) => !migration.down);
+		if (missingDown) throw new Error(`Cannot execute down migration for '${missingDown.id}': missing down migration handler.`);
+		return selected;
+	};
+	if (to) {
+		const targetIndex = migrationSet.ids.indexOf(to);
+		if (targetIndex === -1) throw new Error(`Unknown migration id '${to}' for down --to.`);
+		return {
+			direction,
+			migrations: ensureDownSteps(appliedInOrder.filter((migration) => {
+				return migrationSet.ids.indexOf(migration.id) > targetIndex;
+			})).reverse()
+		};
+	}
+	const resolvedSteps = steps ?? 1;
+	if (!Number.isInteger(resolvedSteps) || resolvedSteps < 1) throw new Error("Down steps must be a positive integer.");
+	return {
+		direction,
+		migrations: ensureDownSteps(appliedInOrder.slice(-resolvedSteps).reverse())
+	};
+}
+function validateMigrationId(id) {
+	if (!id || typeof id !== "string") throw new Error("Migration id must be a non-empty string.");
+	if (!MIGRATION_ID_RE.test(id)) throw new Error(`Migration id '${id}' is invalid. Use alphanumeric characters, '_' ':' or '-'.`);
+}
+function validateMigrationStep(direction, step) {
+	if (!step || typeof step !== "object") throw new Error(`Migration ${direction} step must be an object.`);
+	if (!step.table || typeof step.table !== "string") throw new Error(`Migration ${direction} step.table must be a string.`);
+	if (typeof step.migrateOne !== "function") throw new Error(`Migration ${direction} step.migrateOne must be a function.`);
+	if (step.batchSize !== void 0 && (!Number.isInteger(step.batchSize) || step.batchSize < 1)) throw new Error(`Migration ${direction} step.batchSize must be a positive integer.`);
+	if (step.writeMode !== void 0 && step.writeMode !== "safe_bypass" && step.writeMode !== "normal") throw new Error(`Migration ${direction} step.writeMode must be 'safe_bypass' or 'normal'.`);
+}
+function computeMigrationChecksum(migration) {
+	return simpleStableHash(JSON.stringify({
+		id: migration.id,
+		name: migration.name ?? null,
+		description: migration.description ?? null,
+		up: serializeStep(migration.up),
+		down: migration.down ? serializeStep(migration.down) : null
+	}));
+}
+function serializeStep(step) {
+	return {
+		table: step.table,
+		batchSize: step.batchSize ?? null,
+		writeMode: step.writeMode ?? "safe_bypass",
+		source: normalizeFunctionSource(step.migrateOne)
+	};
+}
+function normalizeFunctionSource(fn) {
+	return fn.toString().replace(FUNCTION_SOURCE_WHITESPACE_RE, " ").replace(FUNCTION_SOURCE_PUNCTUATION_SPACE_RE, "$1").trim();
+}
+function simpleStableHash(value) {
+	let hashA = 2166136261;
+	let hashB = 16777619;
+	for (let i = 0; i < value.length; i += 1) {
+		const code = value.charCodeAt(i);
+		hashA ^= code;
+		hashA = Math.imul(hashA, 16777619);
+		hashB ^= code + i;
+		hashB = Math.imul(hashB, 2246822507);
+	}
+	return `m_${(hashA >>> 0).toString(16).padStart(8, "0")}${(hashB >>> 0).toString(16).padStart(8, "0")}`;
+}
+
+//#endregion
+export { MIGRATION_RUN_TABLE as a, injectMigrationStorageTables as c, boolean as d, detectMigrationDrift as i, migrationExtension as l, defineMigration as n, MIGRATION_STATE_TABLE as o, defineMigrationSet as r, MIGRATION_STORAGE_TABLE_NAMES as s, buildMigrationPlan as t, migrationStorageTables as u };