kitcn/dist/aggregate/index.d.ts

kitcn - React Query integration and CLI tools for Convex

import { C as ConvexNumberBuilderInitial, E as ConvexIdBuilderInitial, N as ConvexCustomBuilderInitial, dn as ConvexTableWithColumns, tr as ConvexTextBuilderInitial } from "../where-clause-compiler-TMppDl9g.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 };