better-convex 0.6.4 → 0.7.0

package/dist/aggregate/index.d.ts

@@ -0,0 +1,388 @@
+import { Ft as ConvexTableWithColumns, J as ConvexTextBuilderInitial, Z as ConvexNumberBuilderInitial, et as ConvexIdBuilderInitial, st as ConvexCustomBuilderInitial } from "../where-clause-compiler-CRP-i1Qa.js";
+import * as convex_values0 from "convex/values";
+import { GenericId, Infer, Value } from "convex/values";
+import { DocumentByName, GenericDataModel, GenericDatabaseReader, GenericDatabaseWriter, TableNamesInDataModel } from "convex/server";
+
+//#region src/aggregate-core/schema.d.ts
+declare const aggregateStorageTables: {
+  readonly aggregate_rank_node: ConvexTableWithColumns<{
+    name: "aggregate_rank_node";
+    columns: {
+      aggregate: ConvexCustomBuilderInitial<"", convex_values0.VObject<{
+        count: number;
+        sum: number;
+      }, {
+        count: convex_values0.VFloat64<number, "required">;
+        sum: convex_values0.VFloat64<number, "required">;
+      }, "required", "count" | "sum">> & {
+        _: {
+          tableName: "aggregate_rank_node";
+        };
+      } & {
+        _: {
+          fieldName: "aggregate";
+        };
+      };
+      items: ConvexCustomBuilderInitial<"", convex_values0.VArray<{
+        k: any;
+        v: any;
+        s: number;
+      }[], convex_values0.VObject<{
+        k: any;
+        v: any;
+        s: number;
+      }, {
+        k: convex_values0.VAny<any, "required", string>;
+        v: convex_values0.VAny<any, "required", string>;
+        s: convex_values0.VFloat64<number, "required">;
+      }, "required", "k" | "v" | "s" | `k.${string}` | `v.${string}`>, "required">> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_rank_node";
+        };
+      } & {
+        _: {
+          fieldName: "items";
+        };
+      };
+      subtrees: ConvexCustomBuilderInitial<"", convex_values0.VArray<string[], convex_values0.VString<string, "required">, "required">> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_rank_node";
+        };
+      } & {
+        _: {
+          fieldName: "subtrees";
+        };
+      };
+    };
+  }, {
+    by_creation_time: ["_creationTime"];
+  }, {}, {}, {}>;
+  readonly aggregate_rank_tree: ConvexTableWithColumns<{
+    name: "aggregate_rank_tree";
+    columns: {
+      aggregateName: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_rank_tree";
+        };
+      } & {
+        _: {
+          fieldName: "aggregateName";
+        };
+      };
+      maxNodeSize: ConvexNumberBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_rank_tree";
+        };
+      } & {
+        _: {
+          fieldName: "maxNodeSize";
+        };
+      };
+      namespace: ConvexCustomBuilderInitial<"", convex_values0.VAny<any, "required", string>> & {
+        _: {
+          tableName: "aggregate_rank_tree";
+        };
+      } & {
+        _: {
+          fieldName: "namespace";
+        };
+      };
+      root: ConvexIdBuilderInitial<"", "aggregate_rank_node"> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_rank_tree";
+        };
+      } & {
+        _: {
+          fieldName: "root";
+        };
+      };
+    };
+  }, {
+    by_creation_time: ["_creationTime"];
+    by_namespace: ["namespace", "_creationTime"];
+    by_aggregate_name: ["aggregateName", "_creationTime"];
+  }, {}, {}, {}>;
+};
+//#endregion
+//#region src/aggregate-core/btree.d.ts
+type Key$2 = Value;
+//#endregion
+//#region src/aggregate-core/positions.d.ts
+type Bound$1<K extends Key$2, ID extends string> = {
+  key: K;
+  id?: ID;
+  inclusive: boolean;
+};
+type SideBounds<K extends Key$2, ID extends string> = {
+  lower?: Bound$1<K, ID>;
+  upper?: Bound$1<K, ID>;
+};
+type TuplePrefix<K extends unknown[], P extends unknown[] = []> = P['length'] extends K['length'] ? P : P | TuplePrefix<K, [...P, K[P['length']]]>;
+type Bounds$1<K extends Key$2, ID extends string> = SideBounds<K, ID> | (K extends unknown[] ? {
+  prefix: TuplePrefix<Extract<K, unknown[]>>;
+} : never) | {
+  eq: K;
+};
+//#endregion
+//#region src/aggregate-core/runtime.d.ts
+type Key = Key$2;
+type Bound<K extends Key, ID extends string> = Bound$1<K, ID>;
+type Bounds<K extends Key, ID extends string> = Bounds$1<K, ID>;
+type AggregateQueryCtx = {
+  db: GenericDatabaseReader<any>;
+  orm: unknown;
+};
+type AggregateMutationCtx = {
+  db: GenericDatabaseWriter<any>;
+  orm: unknown;
+};
+type RunQueryCtx = AggregateQueryCtx;
+type RunMutationCtx = AggregateMutationCtx;
+type Item<K extends Key, ID extends string> = {
+  id: ID;
+  key: K;
+  sumValue: number;
+};
+/**
+ * Write data to be aggregated, and read aggregated data.
+ */
+declare class Aggregate<K extends Key, ID extends string, TNamespace extends Value | undefined = undefined> {
+  protected readonly aggregateName: string;
+  constructor(aggregateName: string);
+  count(ctx: RunQueryCtx, ...opts: NamespacedOpts<{
+    bounds?: Bounds<K, ID>;
+  }, TNamespace>): Promise<number>;
+  countBatch(ctx: RunQueryCtx, queries: NamespacedOptsBatch<{
+    bounds?: Bounds<K, ID>;
+  }, TNamespace>): Promise<number[]>;
+  sum(ctx: RunQueryCtx, ...opts: NamespacedOpts<{
+    bounds?: Bounds<K, ID>;
+  }, TNamespace>): Promise<number>;
+  sumBatch(ctx: RunQueryCtx, queries: NamespacedOptsBatch<{
+    bounds?: Bounds<K, ID>;
+  }, TNamespace>): Promise<number[]>;
+  at(ctx: RunQueryCtx, offset: number, ...opts: NamespacedOpts<{
+    bounds?: Bounds<K, ID>;
+  }, TNamespace>): Promise<Item<K, ID>>;
+  atBatch(ctx: RunQueryCtx, queries: NamespacedOptsBatch<{
+    offset: number;
+    bounds?: Bounds<K, ID>;
+  }, TNamespace>): Promise<Item<K, ID>[]>;
+  indexOf(ctx: RunQueryCtx, key: K, ...opts: NamespacedOpts<{
+    bounds?: Bounds<K, ID>;
+    id?: ID;
+    order?: 'asc' | 'desc';
+  }, TNamespace>): Promise<number>;
+  offsetOf(ctx: RunQueryCtx, key: K, namespace: TNamespace, id?: ID, bounds?: Bounds<K, ID>): Promise<number>;
+  offsetUntil(ctx: RunQueryCtx, key: K, namespace: TNamespace, id?: ID, bounds?: Bounds<K, ID>): Promise<number>;
+  min(ctx: RunQueryCtx, ...opts: NamespacedOpts<{
+    bounds?: Bounds<K, ID>;
+  }, TNamespace>): Promise<Item<K, ID> | null>;
+  max(ctx: RunQueryCtx, ...opts: NamespacedOpts<{
+    bounds?: Bounds<K, ID>;
+  }, TNamespace>): Promise<Item<K, ID> | null>;
+  random(ctx: RunQueryCtx, ...opts: NamespacedOpts<{
+    bounds?: Bounds<K, ID>;
+  }, TNamespace>): Promise<Item<K, ID> | null>;
+  paginate(ctx: RunQueryCtx, ...opts: NamespacedOpts<{
+    bounds?: Bounds<K, ID>;
+    cursor?: string;
+    order?: 'asc' | 'desc';
+    pageSize?: number;
+  }, TNamespace>): Promise<{
+    cursor: string;
+    isDone: boolean;
+    page: Item<K, ID>[];
+  }>;
+  iter(ctx: RunQueryCtx, ...opts: NamespacedOpts<{
+    bounds?: Bounds<K, ID>;
+    order?: 'asc' | 'desc';
+    pageSize?: number;
+  }, TNamespace>): AsyncGenerator<Item<K, ID>, void, undefined>;
+  _insert(ctx: RunMutationCtx, namespace: TNamespace, key: K, id: ID, summand?: number): Promise<void>;
+  _delete(ctx: RunMutationCtx, namespace: TNamespace, key: K, id: ID): Promise<void>;
+  _replace(ctx: RunMutationCtx, currentNamespace: TNamespace, currentKey: K, newNamespace: TNamespace, newKey: K, id: ID, summand?: number): Promise<void>;
+  _insertIfDoesNotExist(ctx: RunMutationCtx, namespace: TNamespace, key: K, id: ID, summand?: number): Promise<void>;
+  _deleteIfExists(ctx: RunMutationCtx, namespace: TNamespace, key: K, id: ID): Promise<void>;
+  _replaceOrInsert(ctx: RunMutationCtx, currentNamespace: TNamespace, currentKey: K, newNamespace: TNamespace, newKey: K, id: ID, summand?: number): Promise<void>;
+  clear(ctx: RunMutationCtx, ...opts: NamespacedOpts<{
+    maxNodeSize?: number;
+    rootLazy?: boolean;
+  }, TNamespace>): Promise<void>;
+  makeRootLazy(ctx: RunMutationCtx, namespace: TNamespace): Promise<void>;
+  paginateNamespaces(ctx: RunQueryCtx, cursor?: string, pageSize?: number): Promise<{
+    cursor: string;
+    isDone: boolean;
+    page: TNamespace[];
+  }>;
+  iterNamespaces(ctx: RunQueryCtx, pageSize?: number): AsyncGenerator<TNamespace, void, undefined>;
+  clearAll(ctx: RunMutationCtx & RunQueryCtx, opts?: {
+    maxNodeSize?: number;
+    rootLazy?: boolean;
+  }): Promise<void>;
+  makeAllRootsLazy(ctx: RunMutationCtx & RunQueryCtx): Promise<void>;
+}
+type DirectAggregateType<K extends Key, ID extends string, TNamespace extends Value | undefined = undefined> = {
+  Key: K;
+  Id: ID;
+  Namespace?: TNamespace;
+};
+type AnyDirectAggregateType$1 = DirectAggregateType<Key, string, Value | undefined>;
+type DirectAggregateNamespace<T extends AnyDirectAggregateType$1> = 'Namespace' extends keyof T ? T['Namespace'] : undefined;
+declare class DirectAggregate$1<T extends AnyDirectAggregateType$1> extends Aggregate<T['Key'], T['Id'], DirectAggregateNamespace<T>> {
+  constructor(config: {
+    name: string;
+  });
+  insert(ctx: RunMutationCtx, args: NamespacedArgs<{
+    id: T['Id'];
+    key: T['Key'];
+    sumValue?: number;
+  }, DirectAggregateNamespace<T>>): Promise<void>;
+  delete(ctx: RunMutationCtx, args: NamespacedArgs<{
+    id: T['Id'];
+    key: T['Key'];
+  }, DirectAggregateNamespace<T>>): Promise<void>;
+  replace(ctx: RunMutationCtx, currentItem: NamespacedArgs<{
+    id: T['Id'];
+    key: T['Key'];
+  }, DirectAggregateNamespace<T>>, newItem: NamespacedArgs<{
+    key: T['Key'];
+    sumValue?: number;
+  }, DirectAggregateNamespace<T>>): Promise<void>;
+  insertIfDoesNotExist(ctx: RunMutationCtx, args: NamespacedArgs<{
+    id: T['Id'];
+    key: T['Key'];
+    sumValue?: number;
+  }, DirectAggregateNamespace<T>>): Promise<void>;
+  deleteIfExists(ctx: RunMutationCtx, args: NamespacedArgs<{
+    id: T['Id'];
+    key: T['Key'];
+  }, DirectAggregateNamespace<T>>): Promise<void>;
+  replaceOrInsert(ctx: RunMutationCtx, currentItem: NamespacedArgs<{
+    id: T['Id'];
+    key: T['Key'];
+  }, DirectAggregateNamespace<T>>, newItem: NamespacedArgs<{
+    key: T['Key'];
+    sumValue?: number;
+  }, DirectAggregateNamespace<T>>): Promise<void>;
+}
+type TableAggregateType<K extends Key, DataModel extends GenericDataModel, TableName extends TableNamesInDataModel<DataModel>, TNamespace extends Value | undefined = undefined> = {
+  DataModel: DataModel;
+  Key: K;
+  Namespace?: TNamespace;
+  TableName: TableName;
+};
+type AnyTableAggregateType$1 = TableAggregateType<Key, GenericDataModel, TableNamesInDataModel<GenericDataModel>, Value | undefined>;
+type TableAggregateNamespace<T extends AnyTableAggregateType$1> = 'Namespace' extends keyof T ? T['Namespace'] : undefined;
+type TableAggregateDocument<T extends AnyTableAggregateType$1> = DocumentByName<T['DataModel'], T['TableName']>;
+type TableAggregateId<T extends AnyTableAggregateType$1> = GenericId<T['TableName']>;
+type TableAggregateTrigger<Ctx, T extends AnyTableAggregateType$1> = Trigger<Ctx, T['DataModel'], T['TableName']>;
+declare class TableAggregate$1<T extends AnyTableAggregateType$1> extends Aggregate<T['Key'], GenericId<T['TableName']>, TableAggregateNamespace<T>> {
+  constructor(options: {
+    name: string;
+    table: T['TableName'];
+    sortKey: (d: TableAggregateDocument<T>) => T['Key'];
+    sumValue?: (d: TableAggregateDocument<T>) => number;
+  } & (undefined extends TableAggregateNamespace<T> ? {
+    namespace?: (d: TableAggregateDocument<T>) => TableAggregateNamespace<T>;
+  } : {
+    namespace: (d: TableAggregateDocument<T>) => TableAggregateNamespace<T>;
+  }));
+  private readonly options;
+  insert(ctx: RunMutationCtx, doc: TableAggregateDocument<T>): Promise<void>;
+  delete(ctx: RunMutationCtx, doc: TableAggregateDocument<T>): Promise<void>;
+  replace(ctx: RunMutationCtx, oldDoc: TableAggregateDocument<T>, newDoc: TableAggregateDocument<T>): Promise<void>;
+  insertIfDoesNotExist(ctx: RunMutationCtx, doc: TableAggregateDocument<T>): Promise<void>;
+  deleteIfExists(ctx: RunMutationCtx, doc: TableAggregateDocument<T>): Promise<void>;
+  replaceOrInsert(ctx: RunMutationCtx, oldDoc: TableAggregateDocument<T>, newDoc: TableAggregateDocument<T>): Promise<void>;
+  indexOfDoc(ctx: RunQueryCtx, doc: TableAggregateDocument<T>, opts?: {
+    id?: TableAggregateId<T>;
+    bounds?: Bounds<T['Key'], TableAggregateId<T>>;
+    order?: 'asc' | 'desc';
+  }): Promise<number>;
+  trigger<Ctx extends RunMutationCtx>(): TableAggregateTrigger<Ctx, T>;
+  idempotentTrigger<Ctx extends RunMutationCtx>(): TableAggregateTrigger<Ctx, T>;
+}
+type Trigger<Ctx, DataModel extends GenericDataModel, TableName extends TableNamesInDataModel<DataModel>> = (ctx: Ctx, change: Change<DataModel, TableName>) => Promise<void>;
+type Change<DataModel extends GenericDataModel, TableName extends TableNamesInDataModel<DataModel>> = {
+  id: GenericId<TableName> | string;
+} & ({
+  operation: 'insert';
+  oldDoc: null;
+  newDoc: DocumentByName<DataModel, TableName>;
+} | {
+  operation: 'update';
+  oldDoc: DocumentByName<DataModel, TableName>;
+  newDoc: DocumentByName<DataModel, TableName>;
+} | {
+  operation: 'delete';
+  oldDoc: DocumentByName<DataModel, TableName>;
+  newDoc: null;
+});
+type NamespacedArgs<Args, TNamespace> = (Args & {
+  namespace: TNamespace;
+}) | (TNamespace extends undefined ? Args : never);
+type NamespacedOpts<Opts, TNamespace> = [{
+  namespace: TNamespace;
+} & Opts] | (undefined extends TNamespace ? [Opts?] : never);
+type NamespacedOptsBatch<Opts, TNamespace> = Array<undefined extends TNamespace ? Opts : {
+  namespace: TNamespace;
+} & Opts>;
+//#endregion
+//#region src/orm/aggregate.d.ts
+type AggregateTriggerFactoryLike = {
+  trigger: () => (ctx: unknown, change: unknown) => Promise<void>;
+};
+type AggregateTriggerCtx<T extends AggregateTriggerFactoryLike> = Parameters<ReturnType<T['trigger']>>[0];
+type AggregateTriggerChange<T extends AggregateTriggerFactoryLike> = Parameters<ReturnType<T['trigger']>>[1];
+type AggregateTriggerOverload<T extends AggregateTriggerFactoryLike> = {
+  (): ReturnType<T['trigger']>;
+  <TChange, TCtx>(change: TChange, ctx: TCtx): Promise<void>;
+};
+type OrmCompatibleAggregate<T extends AggregateTriggerFactoryLike> = Omit<T, 'trigger'> & {
+  trigger: AggregateTriggerOverload<T>;
+};
+//#endregion
+//#region src/aggregate/index.d.ts
+type Key$1 = Key;
+type AnyDirectAggregateType = DirectAggregateType<Key$1, string, Value | undefined>;
+type AnyTableAggregateType = TableAggregateType<Key$1, any, any, Value | undefined>;
+type CoreTrigger<T extends AnyTableAggregateType> = ReturnType<TableAggregate$1<T>['trigger']>;
+type CoreIdempotentTrigger<T extends AnyTableAggregateType> = ReturnType<TableAggregate$1<T>['idempotentTrigger']>;
+declare class TableAggregate<T extends AnyTableAggregateType> extends TableAggregate$1<T> {
+  trigger: {
+    (): CoreTrigger<T>;
+    <TChange, TCtx>(change: TChange, ctx: TCtx): Promise<void>;
+  };
+  idempotentTrigger: {
+    (): CoreIdempotentTrigger<T>;
+    <TChange, TCtx>(change: TChange, ctx: TCtx): Promise<void>;
+  };
+  constructor(...args: ConstructorParameters<typeof TableAggregate$1>);
+}
+declare class DirectAggregate<T extends AnyDirectAggregateType> extends DirectAggregate$1<T> {}
+declare function createDirectAggregate<T extends AnyDirectAggregateType>(config: {
+  name: string;
+}): DirectAggregate<T>;
+//#endregion
+export { type AggregateTriggerChange, type AggregateTriggerCtx, type AggregateTriggerFactoryLike, type Bound, type Bounds, DirectAggregate, type DirectAggregateType, type Item, type Key, type OrmCompatibleAggregate, type RunMutationCtx, type RunQueryCtx, TableAggregate, type TableAggregateType, aggregateStorageTables, createDirectAggregate };

package/dist/aggregate/index.js

@@ -0,0 +1,37 @@
+import { n as TableAggregate$1, r as aggregateStorageTables, t as DirectAggregate$1 } from "../runtime-B9xQFY8W.js";
+
+//#region src/aggregate/index.ts
+const wrapTriggerFactory = (methodName, factory) => ((...args) => {
+	if (args.length === 0) return factory();
+	if (args.length === 2) {
+		const [change, ctx] = args;
+		return factory()(ctx, change);
+	}
+	throw new Error(`Invalid aggregate.${methodName} invocation. Use ${methodName}() or ${methodName}(change, ctx).`);
+});
+var TableAggregate = class extends TableAggregate$1 {
+	constructor(...args) {
+		super(...args);
+		const triggerFactory = super.trigger.bind(this);
+		const idempotentFactory = super.idempotentTrigger.bind(this);
+		Object.defineProperty(this, "trigger", {
+			configurable: true,
+			enumerable: false,
+			value: wrapTriggerFactory("trigger", triggerFactory),
+			writable: true
+		});
+		Object.defineProperty(this, "idempotentTrigger", {
+			configurable: true,
+			enumerable: false,
+			value: wrapTriggerFactory("idempotentTrigger", idempotentFactory),
+			writable: true
+		});
+	}
+};
+var DirectAggregate = class extends DirectAggregate$1 {};
+function createDirectAggregate(config) {
+	return new DirectAggregate(config);
+}
+
+//#endregion
+export { DirectAggregate, TableAggregate, aggregateStorageTables, createDirectAggregate };

package/dist/{auth-client → auth/client}/index.js

@@ -1,5 +1,5 @@
 'use client';
-import { a as FetchAccessTokenContext, b as CRPCClientError, l as decodeJwtExp, m as useAuthValue, p as useAuthStore, t as AuthProvider, x as defaultIsUnauthorized } from "../auth-store-DHapqI5u.js";
+import { a as FetchAccessTokenContext, b as CRPCClientError, l as decodeJwtExp, m as useAuthValue, p as useAuthStore, t as AuthProvider, x as defaultIsUnauthorized } from "../../auth-store-DHapqI5u.js";
 import { convexClient } from "@convex-dev/better-auth/client/plugins";
 import { c } from "react/compiler-runtime";
 import { ConvexProviderWithAuth, useConvexAuth } from "convex/react";

package/dist/auth/http/index.d.ts

@@ -0,0 +1,63 @@
+import { t as GetAuth } from "../../types-DgwvxKbT.js";
+import { HttpRouter } from "convex/server";
+import { MiddlewareHandler } from "hono";
+
+//#region src/auth/middleware.d.ts
+interface AuthMiddlewareOptions {
+  /** Base path for auth routes (default: '/api/auth') */
+  basePath?: string;
+  /** Log request/response headers for debugging */
+  verbose?: boolean;
+}
+/**
+ * Create auth middleware that handles auth routes and OpenID well-known redirect.
+ *
+ * @example
+ * ```ts
+ * import { Hono } from 'hono';
+ * import { cors } from 'hono/cors';
+ * import { authMiddleware } from 'better-convex/auth/http';
+ * import { createHttpRouter } from 'better-convex/server';
+ *
+ * const app = new Hono();
+ * app.use('/api/*', cors({ origin: process.env.SITE_URL, credentials: true }));
+ * app.use(authMiddleware(getAuth));
+ *
+ * export default createHttpRouter(app, httpRouter);
+ * ```
+ */
+declare function authMiddleware(getAuth: GetAuth<unknown, {
+  handler: (request: Request) => Promise<Response>;
+}>, opts?: AuthMiddlewareOptions): MiddlewareHandler;
+//#endregion
+//#region src/auth/registerRoutes.d.ts
+type AuthRouteContract = {
+  $context: Promise<{
+    options: {
+      trustedOrigins?: string[] | ((request: Request) => Promise<string[]> | string[]);
+    };
+  }>;
+  handler: (request: Request) => Promise<Response>;
+  options: {
+    basePath?: string;
+    baseURL?: string;
+    trustedOrigins?: string[] | ((request: Request) => Promise<string[]> | string[]);
+  };
+};
+declare const registerRoutes: (http: HttpRouter, getAuth: GetAuth<unknown, AuthRouteContract>, opts?: {
+  cors?: {
+    allowedHeaders?: string[];
+    allowedOrigins?: string[];
+    exposedHeaders?: string[];
+  } | boolean;
+  verbose?: boolean;
+}) => void;
+//#endregion
+//#region src/auth-http/index.d.ts
+/**
+ * Install Convex-safe polyfills required by Better Auth's HTTP handling.
+ * This runs automatically when importing `better-convex/auth/http`.
+ */
+declare function installAuthHttpPolyfills(): void;
+//#endregion
+export { authMiddleware, installAuthHttpPolyfills, registerRoutes };