better-convex 0.6.3 → 0.7.0

package/dist/{create-schema-orm-DplxTtYj.js → create-schema-orm-69VF4CFV.js}

@@ -1,4 +1,4 @@
-import { indexFields } from "./create-schema-DhWXOhnU.js";
+import { indexFields } from "./create-schema-BdZOL6ns.js";
 
 //#region src/auth/create-schema-orm.ts
 const specialFields = (tables) => Object.fromEntries(Object.entries(tables).map(([key, table]) => {
@@ -16,6 +16,7 @@ const mergedIndexFields = (tables) => Object.fromEntries(Object.entries(tables).
 const VALID_IDENTIFIER_REGEX = /^[$A-Z_][0-9A-Z_$]*$/i;
 const LEADING_DIGIT_REGEX = /^[0-9]/;
 const renderObjectKey = (value) => VALID_IDENTIFIER_REGEX.test(value) ? value : JSON.stringify(value);
+const renderPropertyAccess = (objectName, propertyName) => VALID_IDENTIFIER_REGEX.test(propertyName) ? `${objectName}.${propertyName}` : `${objectName}[${JSON.stringify(propertyName)}]`;
 const toIdentifier = (value) => {
 	const normalized = value.replace(/[^a-zA-Z0-9_$]/g, "_");
 	if (!normalized) return "_table";
@@ -100,7 +101,7 @@ const createSchemaOrm = async ({ file, tables }) => {
 			if (attr.references) {
 				const referencedEntry = findTableEntryByModel(entries, tables, attr.references.model) ?? { varName: toIdentifier(attr.references.model) };
 				const targetField = getReferencedFieldName(tables, entries, attr.references.model, attr.references.field);
-				expression += `.references(() => ${referencedEntry.varName}[${JSON.stringify(targetField)}])`;
+				expression += `.references(() => ${renderPropertyAccess(referencedEntry.varName, targetField)})`;
 			}
 			return `    ${key}: ${expression},`;
 		});
@@ -108,7 +109,7 @@ const createSchemaOrm = async ({ file, tables }) => {
 			const indexArray = Array.isArray(indexSpec) ? [...indexSpec].sort() : [indexSpec];
 			const indexName = indexArray.join("_");
 			state.ormImports.add("index");
-			const fieldsCall = indexArray.map((fieldName) => `${entry.varName}[${JSON.stringify(fieldName)}]`).join(", ");
+			const fieldsCall = indexArray.map((fieldName) => renderPropertyAccess(entry.varName, fieldName)).join(", ");
 			return `index(${JSON.stringify(indexName)}).on(${fieldsCall})`;
 		}) || [];
 		const extraConfig = indexes.length > 0 ? `,\n  (${entry.varName}) => [\n    ${indexes.join(",\n    ")},\n  ]` : "";

package/dist/crpc/index.d.ts

@@ -1,5 +1,5 @@
-import { $ as identityTransformer, G as DataTransformerOptions, H as CombinedDataTransformer, J as dateWireCodec, K as WireCodec, Q as getTransformer, U as DATE_CODEC_TAG, W as DataTransformer, X as defaultCRPCTransformer, Y as decodeWire, Z as encodeWire, a as HttpProcedureCall, c as InferHttpInput, i as HttpErrorCode, l as InferHttpOutput, n as HttpClientError, o as HttpRouteInfo, q as createTaggedTransformer, r as HttpClientFromRouter, s as HttpRouteMap, t as HttpClient, u as isHttpClientError } from "../http-types-BRLY10NX.js";
-import { C as PaginatedFnMeta, D as VanillaMutation, E as VanillaCRPCClient, O as VanillaQuery, S as Meta, T as VanillaAction, _ as ExtractPaginatedItem, a as ConvexInfiniteQueryMeta, b as InfiniteQueryInput, c as ConvexMutationKey, d as ConvexQueryMeta, f as ConvexQueryOptions, g as DecorateQuery, h as DecorateMutation, i as ConvexActionOptions, l as ConvexQueryHookOptions, m as DecorateInfiniteQuery, n as CRPCClient, o as ConvexInfiniteQueryOptions, p as DecorateAction, r as ConvexActionKey, s as ConvexInfiniteQueryOptionsWithRef, t as AuthType, u as ConvexQueryKey, v as FUNC_REF_SYMBOL, w as PaginationOpts, x as InfiniteQueryOptsParam, y as FnMeta } from "../types-o-5rYcTr.js";
+import { $ as identityTransformer, G as DataTransformerOptions, H as CombinedDataTransformer, J as dateWireCodec, K as WireCodec, Q as getTransformer, U as DATE_CODEC_TAG, W as DataTransformer, X as defaultCRPCTransformer, Y as decodeWire, Z as encodeWire, a as HttpProcedureCall, c as InferHttpInput, i as HttpErrorCode, l as InferHttpOutput, n as HttpClientError, o as HttpRouteInfo, q as createTaggedTransformer, r as HttpClientFromRouter, s as HttpRouteMap, t as HttpClient, u as isHttpClientError } from "../http-types-BCf2wCgp.js";
+import { C as PaginatedFnMeta, D as VanillaMutation, E as VanillaCRPCClient, O as VanillaQuery, S as Meta, T as VanillaAction, _ as ExtractPaginatedItem, a as ConvexInfiniteQueryMeta, b as InfiniteQueryInput, c as ConvexMutationKey, d as ConvexQueryMeta, f as ConvexQueryOptions, g as DecorateQuery, h as DecorateMutation, i as ConvexActionOptions, l as ConvexQueryHookOptions, m as DecorateInfiniteQuery, n as CRPCClient, o as ConvexInfiniteQueryOptions, p as DecorateAction, r as ConvexActionKey, s as ConvexInfiniteQueryOptionsWithRef, t as AuthType, u as ConvexQueryKey, v as FUNC_REF_SYMBOL, w as PaginationOpts, x as InfiniteQueryOptsParam, y as FnMeta } from "../types-CIBGEYXq.js";
 import { FunctionArgs, FunctionReference } from "convex/server";
 
 //#region src/crpc/error.d.ts

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-BZUhlhYz.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-CTNSPjwp.js";
-import { n as convexInfiniteQueryOptions, r as convexQuery, t as convexAction } from "../query-options-BL1Q0X7q.js";
+import { a as isCRPCErrorCode, i as isCRPCError, n as defaultIsUnauthorized, r as isCRPCClientError, t as CRPCClientError } from "../error-Be4OcwwD.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-Dh0w2py0.js";
+import { n as convexInfiniteQueryOptions, r as convexQuery, t as convexAction } from "../query-options-B0c1b6pZ.js";
 
 //#region src/crpc/http-types.ts
 /** HTTP client error */

package/dist/{http-types-BRLY10NX.d.ts → http-types-BCf2wCgp.d.ts}

@@ -1,4 +1,4 @@
-import { o as Simplify$1 } from "./types-jftzhhuc.js";
+import { o as Simplify$1 } from "./types-DwGkkq2s.js";
 import { GenericActionCtx, GenericDataModel, HttpRouter } from "convex/server";
 import { z } from "zod";
 import { Context, Hono } from "hono";
@@ -8,8 +8,8 @@ import { Context, Hono } from "hono";
  * Generic transformer contract (mirrors tRPC shape).
  */
 interface DataTransformer {
-  serialize(object: any): any;
   deserialize(object: any): any;
+  serialize(object: any): any;
 }
 /**
  * Separate input/output transformers.
@@ -26,10 +26,10 @@ type DataTransformerOptions = CombinedDataTransformer | DataTransformer;
  * Extensible tagged wire codec.
  */
 interface WireCodec {
-  readonly tag: `$${string}`;
-  isType(value: unknown): boolean;
-  encode(value: unknown): unknown;
   decode(value: unknown): unknown;
+  encode(value: unknown): unknown;
+  isType(value: unknown): boolean;
+  readonly tag: `$${string}`;
 }
 /**
  * Date wire tag (Convex-style reserved key).
@@ -154,8 +154,8 @@ type AnyMiddlewareBuilder = MiddlewareBuilder<any, any, any, any>;
 type ProcedureMeta = object;
 type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
 interface HttpRouteDefinition<TMethod extends HttpMethod = HttpMethod> {
-  path: string;
   method: TMethod;
+  path: string;
   pathParamNames: string[];
   usePathPrefix: boolean;
 }
@@ -168,19 +168,6 @@ type InferHttpInput$1<T> = T extends UnsetMarker ? undefined : T extends z.ZodTy
  * Stores schema types directly (like QueryProcedureBuilder)
  */
 interface HttpProcedureBuilderDef<TCtx, TInput extends UnsetMarker | z.ZodTypeAny, TOutput extends UnsetMarker | z.ZodTypeAny, TParams extends UnsetMarker | z.ZodTypeAny, TQuery extends UnsetMarker | z.ZodTypeAny, TMeta extends ProcedureMeta, TMethod extends HttpMethod = HttpMethod, TForm extends UnsetMarker | z.ZodTypeAny = UnsetMarker> {
-  middlewares: AnyMiddleware[];
-  meta: TMeta;
-  inputSchema?: z.ZodTypeAny;
-  outputSchema?: z.ZodTypeAny;
-  paramsSchema?: z.ZodTypeAny;
-  querySchema?: z.ZodTypeAny;
-  formSchema?: z.ZodTypeAny;
-  route?: HttpRouteDefinition<TMethod>;
-  functionConfig: {
-    base: HttpActionConstructor;
-    createContext: (ctx: GenericActionCtx<GenericDataModel>) => TCtx;
-    transformer: CombinedDataTransformer;
-  };
   /** @internal Phantom types for type inference */
   _types?: {
     input: TInput;
@@ -189,6 +176,19 @@ interface HttpProcedureBuilderDef<TCtx, TInput extends UnsetMarker | z.ZodTypeAn
     query: TQuery;
     form: TForm;
   };
+  formSchema?: z.ZodTypeAny;
+  functionConfig: {
+    base: HttpActionConstructor;
+    createContext: (ctx: GenericActionCtx<GenericDataModel>) => TCtx;
+    transformer: CombinedDataTransformer;
+  };
+  inputSchema?: z.ZodTypeAny;
+  meta: TMeta;
+  middlewares: AnyMiddleware[];
+  outputSchema?: z.ZodTypeAny;
+  paramsSchema?: z.ZodTypeAny;
+  querySchema?: z.ZodTypeAny;
+  route?: HttpRouteDefinition<TMethod>;
 }
 type HttpActionConstructor = (handler: (ctx: GenericActionCtx<GenericDataModel>, request: Request) => Promise<Response>) => HttpActionHandler;
 interface HttpActionHandler {
@@ -230,11 +230,11 @@ type HttpHandlerOpts<TCtx, TInput extends UnsetMarker | z.ZodTypeAny, TParams ex
  * Hono handler with cRPC route metadata attached
  */
 interface CRPCHonoHandler {
-  (c: Context): Promise<Response>;
   _crpcRoute: {
     path: string;
     method: HttpMethod;
   };
+  (c: Context): Promise<Response>;
 }
 //#endregion
 //#region src/server/http-router.d.ts
@@ -248,11 +248,11 @@ interface HttpRouterRecord {
  * Router definition - stores both flat procedures and hierarchical record
  */
 interface HttpRouterDef<TRecord extends HttpRouterRecord> {
-  router: true;
   /** Flat map with dot-notation keys (e.g., "todos.get") for lookup */
   procedures: Record<string, HttpProcedure>;
   /** Hierarchical structure for type inference */
   record: TRecord;
+  router: true;
 }
 /**
  * HTTP Router - like tRPC's BuiltRouter
@@ -284,11 +284,11 @@ declare class HttpRouterWithHono extends HttpRouter {
  * });
  *
  * // In http.ts
- * export const appRouter = router({
+ * export const httpRouter = router({
  *   todos: todosRouter,
  *   health,
  * });
- * export type AppRouter = typeof appRouter;
+ * export type AppRouter = typeof httpRouter;
  * ```
  */
 declare function createHttpRouterFactory(): <TRecord extends HttpRouterRecord>(record: TRecord) => CRPCHttpRouter<TRecord>;
@@ -304,7 +304,7 @@ declare function createHttpRouterFactory(): <TRecord extends HttpRouterRecord>(r
  * const app = new Hono();
  * app.use('/api/*', cors({ origin: process.env.SITE_URL, credentials: true }));
  *
- * export default createHttpRouter(app, appRouter);
+ * export default createHttpRouter(app, httpRouter);
  * ```
  */
 declare function createHttpRouter<TRecord extends HttpRouterRecord>(app: Hono, router: CRPCHttpRouter<TRecord>): HttpRouterWithHono;
@@ -313,7 +313,7 @@ declare function createHttpRouter<TRecord extends HttpRouterRecord>(app: Hono, r
  *
  * @example
  * ```ts
- * export const httpRoutes = extractRouteMap(appRouter._def.procedures);
+ * export const httpRoutes = extractRouteMap(httpRouter._def.procedures);
  * ```
  */
 declare function extractRouteMap<T extends Record<string, HttpProcedure>>(procedures: T): { [K in keyof T]: {

package/dist/meta-utils-DDVYp9Xf.js

@@ -0,0 +1,117 @@
+//#region src/shared/meta-utils.ts
+const metaCache = /* @__PURE__ */ new WeakMap();
+const nonMetaLeafKeys = new Set(["functionRef", "ref"]);
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isFunctionType(value) {
+	return value === "query" || value === "mutation" || value === "action";
+}
+function isMetaScalar(value) {
+	return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function extractLeafMeta(value) {
+	const type = value.type;
+	if (!isFunctionType(type)) return;
+	const result = { type };
+	for (const [key, entry] of Object.entries(value)) {
+		if (key === "type" || nonMetaLeafKeys.has(key) || key.startsWith("_")) continue;
+		if (entry === void 0) continue;
+		if (isMetaScalar(entry)) result[key] = entry;
+	}
+	return result;
+}
+function getHttpRoutes(api) {
+	const routes = api._http;
+	if (!isRecord(routes)) return;
+	const normalized = {};
+	for (const [routeKey, routeValue] of Object.entries(routes)) {
+		if (!isRecord(routeValue)) continue;
+		const routePath = routeValue.path;
+		const routeMethod = routeValue.method;
+		if (typeof routePath === "string" && typeof routeMethod === "string") normalized[routeKey] = {
+			path: routePath,
+			method: routeMethod
+		};
+	}
+	return normalized;
+}
+/**
+* Build a metadata index from merged API leaves.
+* Supports both generated `api` objects and plain metadata fixtures.
+*/
+function buildMetaIndex(api) {
+	const cached = metaCache.get(api);
+	if (cached) return cached;
+	const meta = {};
+	const httpRoutes = getHttpRoutes(api);
+	if (httpRoutes) meta._http = httpRoutes;
+	const walk = (node, path) => {
+		for (const [key, value] of Object.entries(node)) {
+			if (key.startsWith("_")) continue;
+			if (!isRecord(value)) continue;
+			const leafMeta = extractLeafMeta(value);
+			if (leafMeta) {
+				if (path.length === 0) continue;
+				const namespace = path.join("/");
+				meta[namespace] ??= {};
+				meta[namespace][key] = leafMeta;
+				continue;
+			}
+			walk(value, [...path, key]);
+		}
+	};
+	walk(api, []);
+	metaCache.set(api, meta);
+	return meta;
+}
+/**
+* Get a function reference from the API object by traversing the path.
+*/
+function getFuncRef(api, path) {
+	let current = api;
+	for (const key of path) if (current && typeof current === "object") {
+		const next = current[key];
+		if (next === void 0) throw new Error(`Invalid path: ${path.join(".")}`);
+		current = next;
+	} else throw new Error(`Invalid path: ${path.join(".")}`);
+	if (current && typeof current === "object") {
+		const maybeFunctionRef = current.functionRef;
+		if (maybeFunctionRef && typeof maybeFunctionRef === "object") return maybeFunctionRef;
+	}
+	if (!current || typeof current !== "object") throw new Error(`Invalid function reference at path: ${path.join(".")}`);
+	return current;
+}
+/**
+* Get function type from meta using path.
+* Supports nested paths like ['items', 'queries', 'list'] → namespace='items/queries', fn='list'
+*
+* @param path - Path segments like ['todos', 'create'] or ['items', 'queries', 'list']
+* @param meta - The meta object from codegen
+* @returns Function type or 'query' as default
+*/
+function getFunctionType(path, source) {
+	if (path.length < 2) return "query";
+	const meta = buildMetaIndex(source);
+	const fnName = path.at(-1);
+	const fnType = meta[path.slice(0, -1).join("/")]?.[fnName]?.type;
+	if (fnType === "query" || fnType === "mutation" || fnType === "action") return fnType;
+	return "query";
+}
+/**
+* Get function metadata from meta using path.
+* Supports nested paths like ['items', 'queries', 'list'] → namespace='items/queries', fn='list'
+*
+* @param path - Path segments like ['todos', 'create'] or ['items', 'queries', 'list']
+* @param meta - The meta object from codegen
+* @returns Function metadata or undefined
+*/
+function getFunctionMeta(path, source) {
+	if (path.length < 2) return;
+	const meta = buildMetaIndex(source);
+	const fnName = path.at(-1);
+	return meta[path.slice(0, -1).join("/")]?.[fnName];
+}
+
+//#endregion
+export { getFunctionType as i, getFuncRef as n, getFunctionMeta as r, buildMetaIndex as t };