@nkzw/fate 0.1.3 → 1.0.0-rc.0

package/lib/server.d.mts

@@ -1,200 +1,99 @@
-import { W as QueryProcedure, t as AnyRecord } from "./types-HECWvGpd.mjs";
+import { K as AnyProcedure, t as AnyRecord$1 } from "./types-Dz46PXr3.mjs";
+import { C as liveGlobalConnectionTopic, S as liveEntityTopic, _ as LiveEventBus, b as createLiveEventBus, c as FateServer, d as NativeFateAPI, f as createFateFetchHandler, g as LiveConnectionSourceEvent, h as LiveConnectionEventType, l as FateServerManifest, m as createHonoFateHandler, p as createFateServer, s as FateRequestError, t as isRecord, u as InferFateAPI, v as LiveEventType, x as liveConnectionTopic, y as LiveSourceEvent } from "./record-ENh92gyb.mjs";
+import { A as DataViewListOptions, B as dataView, C as connectionArgs, D as CountSelection, E as ComputedSelection, F as FieldSelection, H as list$1, I as ViewPlan, L as computed, M as DataViewOrderDirection, N as DataViewResult, O as CountWhere, P as Entity, R as count, S as ConnectionResult, T as ComputedField, U as resolver, V as field, _ as createSourcePlan, a as resolveSourceConnection, b as ConnectionItem, c as SourceConfig, d as SourceOrderField, f as SourcePlan, g as createNestedSourcePlan, h as SourceRelationConfig, i as resolveSourceByIds, j as DataViewOrderBy, l as SourceDefinition, m as SourceRelation, n as refetchSourceById, p as SourcePlanNode, r as resolveSourceById, s as OrderDirection, t as SourceRegistry, u as SourceOrder, v as getNestedSelection, w as withConnection, x as ConnectionPagination, y as hasNestedSelection, z as createResolver } from "./executor-BqwHdN3n.mjs";
 import { z } from "zod";
 
-//#region src/server/dataView.d.ts
-declare const dataViewFieldsKey: unique symbol;
-type ResolverSelect<Context> = AnyRecord | ((options: {
-  args?: AnyRecord;
-  context?: Context;
-}) => AnyRecord | void);
-type Bivariant<Fn extends (...args: Array<any>) => unknown> = {
-  bivariance(...args: Parameters<Fn>): ReturnType<Fn>;
-}['bivariance'];
-type ResolverResolve<Item extends AnyRecord, Result, Context> = Bivariant<(item: Item, context?: Context, args?: AnyRecord) => Promise<Result> | Result>;
-type ResolverAuthorize<Item extends AnyRecord, Context> = Bivariant<(item: Item, context?: Context, args?: AnyRecord) => Promise<boolean> | boolean>;
-/**
- * Field configuration for selecting and resolving a computed value on the backend.
- */
-type ResolverField<Item extends AnyRecord, Result, Context> = {
-  authorize?: ResolverAuthorize<Item, Context>;
-  kind: 'resolver';
-  resolve: ResolverResolve<Item, Result, Context>;
-  select?: ResolverSelect<Context>;
-};
-type DataField<Item extends AnyRecord> = true | DataView<AnyRecord> | ResolverField<Item, any, any>;
-/**
- * Recursively serializes resolver results for transport across the network.
- */
-type Serializable<T> = T extends Date ? string : T extends Array<infer U> ? Array<Serializable<U>> : T extends object ? { [K in keyof T]: Serializable<T[K]> } : T;
-/**
- * Server-side mirror of a view definition describing how to select and resolve
- * fields when fulfilling a client request.
- */
-type DataView<Item extends AnyRecord> = {
-  fields: Record<string, DataField<Item>>;
-  kind?: 'resolver' | 'list';
-  typeName: string;
-};
-/**
- * Convenience type for declaring the fields of a server data view.
- */
-type DataViewConfig<Item extends AnyRecord> = Record<string, DataField<Item>>;
-/**
- * Declares a server data view that exposes an object's available fields to the client.
- *
- * @example
- * const Post = dataView<PostItem>('Post')({
- *   id: true,
- *   title: true,
- * });
- */
-declare function dataView<Item extends AnyRecord>(typeName: string): <Fields extends DataViewConfig<Item>>(fields: Fields) => DataView<Item> & {
-  readonly [dataViewFieldsKey]: Fields;
-};
-/**
- * Marks a data view as a list resolver so the server can respond with
- * connection information.
- */
-declare const list: <Item extends AnyRecord>(view: DataView<Item>) => {
-  kind: "list";
-  fields: Record<string, DataField<Item>>;
-  typeName: string;
-};
-/**
- * Declares a resolver field inside a data view, optionally providing a
- * selection for any data dependencies.
- */
-declare function resolver<Item extends AnyRecord, Result = unknown, Context = unknown>(config: {
-  authorize?: ResolverAuthorize<Item, Context>;
-  resolve: ResolverResolve<Item, Result, Context>;
-  select?: ResolverSelect<Context>;
-}): ResolverField<Item, Result, Context>;
-type NonNullish<T> = Exclude<T, null | undefined>;
-type WithNullish<Original, Value> = null extends Original ? undefined extends Original ? Value | null | undefined : Value | null : undefined extends Original ? Value | undefined : Value;
-type ResolverResult<Field> = Field extends ResolverField<AnyRecord, any, any> ? Field['authorize'] extends ResolverAuthorize<any, any> ? Awaited<ReturnType<Field['resolve']>> | null : Awaited<ReturnType<Field['resolve']>> : never;
-type RelationResult<ItemField, V extends DataView<AnyRecord>> = NonNullish<ItemField> extends Array<unknown> ? WithNullish<ItemField, Array<RawDataViewResult<V>>> : WithNullish<ItemField, RawDataViewResult<V>>;
-type ViewFieldConfig<V extends DataView<AnyRecord>> = V extends {
-  readonly [dataViewFieldsKey]: infer Fields;
-} ? Fields : V['fields'];
-type RawFieldResult<Item extends AnyRecord, Key extends PropertyKey, Field extends DataField<Item>> = Field extends true ? Key extends keyof Item ? Item[Key] : never : Field extends DataView<infer ChildItem> ? Key extends keyof Item ? RelationResult<Item[Key], DataView<ChildItem>> : never : Field extends ResolverField<Item, any, any> ? ResolverResult<Field> : never;
-type RawDataViewResult<V extends DataView<AnyRecord>> = V extends DataView<infer Item> ? { [K in keyof ViewFieldConfig<V>]: RawFieldResult<Item, K, ViewFieldConfig<V>[K]> } : never;
-type DataViewResult<V extends DataView<AnyRecord>> = Serializable<RawDataViewResult<V>>;
-type WithTypename<T, Name extends string> = T & {
-  __typename: Name;
-};
+//#region src/server/input.d.ts
+declare const byIdInput: z.ZodObject<{
+  args: z.ZodOptional<z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>>;
+  ids: z.ZodArray<z.ZodString>;
+  select: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+//#endregion
+//#region src/server/prismaSelect.d.ts
+type AnyRecord = Record<string, unknown>;
 /**
- * Resolved entity type from a data view for client use.
+ * Builds a Prisma `select` object from flattened selection paths and optional
+ * scoped args, always including the `id` field.
  */
-type Entity<TView extends DataView<AnyRecord>, Name extends string, Replacements extends Record<string, unknown> = Record<never, never>> = WithTypename<Omit<DataViewResult<TView>, keyof Replacements> & Replacements, Name>;
+declare function toPrismaSelect<Item extends AnyRecord, Context = unknown>(plan: ViewPlan<Item, Context>): AnyRecord;
+//#endregion
+//#region src/server/queryArgs.d.ts
 /**
- * Builds a resolver that applies a client's selection to a server data view,
- * filtering fields, running nested resolvers, and shaping selects.
+ * Narrows nested args to the slice relevant for a particular selection path.
  */
-declare function createResolver<Item extends AnyRecord, Context = unknown>({
-  args,
-  ctx,
-  select: initialSelect,
-  view
-}: {
-  args?: AnyRecord;
-  ctx?: Context;
-  select: Iterable<string>;
-  view: DataView<Item>;
-}): {
-  resolve: (item: Item) => Promise<AnyRecord>;
-  resolveMany: (items: Array<AnyRecord>) => Promise<Array<AnyRecord>>;
-  select: Record<string, unknown>;
-};
+declare function getScopedArgs(args: AnyRecord$1 | undefined, path: string): AnyRecord$1 | undefined;
 //#endregion
-//#region src/server/connection.d.ts
-type ConnectionInput = z.infer<typeof connectionInput>;
-type AdditionalInputSchema = z.ZodObject<Record<string, z.ZodTypeAny>>;
-type ConnectionInputWithAdditional<TAdditionalInput extends AdditionalInputSchema | undefined> = ConnectionInput & {
-  args?: ConnectionInput['args'] extends infer A ? A & (TAdditionalInput extends AdditionalInputSchema ? z.infer<TAdditionalInput> : object) : never;
+//#region src/server/sourceRouter.d.ts
+type ProcedureLike = {
+  input: (schema: any) => {
+    query: (resolver: (options: any) => unknown) => AnyProcedure;
+  };
 };
-type ConnectionCursor = string;
-/**
- * Connection item including the node and opaque cursor.
- */
-type ConnectionItem<TNode> = {
-  cursor: ConnectionCursor;
-  node: TNode;
+type ConnectionProcedureLike = (options: {
+  defaultSize?: number;
+  query: (options: {
+    ctx: unknown;
+    cursor?: string;
+    direction: 'backward' | 'forward';
+    input: {
+      args?: Record<string, unknown>;
+      select: Array<string>;
+    };
+    skip?: number;
+    take: number;
+  }) => Promise<Array<AnyRecord$1>>;
+}) => AnyProcedure;
+type ListConfig = {
+  defaultSize?: number;
 };
-/**
- * Pagination metadata returned with connection lists.
- */
-type ConnectionPagination = {
-  hasNext: boolean;
-  hasPrevious: boolean;
-  nextCursor?: ConnectionCursor;
-  previousCursor?: ConnectionCursor;
+type SourceProcedureOptions<Context, Item extends AnyRecord$1, Procedure extends ProcedureLike = ProcedureLike, ConnectionProcedure extends ConnectionProcedureLike | undefined = ConnectionProcedureLike | undefined> = {
+  byId?: boolean;
+  createConnectionProcedure?: ConnectionProcedure;
+  list?: boolean | ListConfig;
+  procedure: Procedure;
+  registry: SourceRegistry<Context>;
+  source: SourceDefinition<Item, unknown>;
 };
-/**
- * Connection payload that mirrors what the client expects for list fields.
- */
-type ConnectionResult<TNode> = {
-  items: Array<ConnectionItem<TNode>>;
-  pagination: ConnectionPagination;
+type SourceProcedureFactoryOptions<Item extends AnyRecord$1, ById extends boolean | undefined = boolean | undefined, List extends boolean | ListConfig | undefined = boolean | ListConfig | undefined> = {
+  byId?: ById;
+  list?: List;
+  source: SourceDefinition<Item, unknown>;
 };
-type ProcedureLike = {
-  input: (schema: any) => {
-    query: (resolver: (options: any) => unknown) => unknown;
-  };
+type SourceProcedureFactoryInput<Item extends AnyRecord$1, ById extends boolean | undefined = boolean | undefined, List extends boolean | ListConfig | undefined = boolean | ListConfig | undefined> = SourceDefinition<Item, unknown> | SourceProcedureFactoryOptions<Item, ById, List>;
+type SourceProcedureFactoryDefaults<Context, Procedure extends ProcedureLike, ConnectionProcedure extends ConnectionProcedureLike | undefined> = {
+  createConnectionProcedure?: ConnectionProcedure;
+  procedure: Procedure;
+  registry: SourceRegistry<Context>;
 };
-type ProcedureContext<TProcedure> = TProcedure extends {
-  input: (schema: any) => {
-    query: (resolver: (options: {
-      ctx: infer TContext;
-    }) => unknown) => unknown;
-  };
-} ? TContext : unknown;
-type ConnectionProcedure<TInput, TOutput> = QueryProcedure<{
-  input: TInput;
-  meta: unknown;
-  output: TOutput;
-}>;
-type QueryFn<TContext, TItem, TInput extends ConnectionInput> = (options: {
-  ctx: TContext;
-  cursor?: ConnectionCursor;
-  direction: 'forward' | 'backward';
-  input: TInput;
-  skip?: number;
-  take: number;
-}) => Promise<Array<TItem>>;
-type MapFn<TContext, TItem, TNode, TInput extends ConnectionInput> = (options: {
-  ctx: TContext;
-  input: TInput;
-  items: Array<TItem>;
-}) => Promise<Array<TNode>> | Array<TNode>;
+type ProcedureResult<Procedure extends ProcedureLike> = ReturnType<ReturnType<Procedure['input']>['query']>;
+type ConnectionProcedureResult<ConnectionProcedure extends ConnectionProcedureLike | undefined> = ConnectionProcedure extends ConnectionProcedureLike ? ReturnType<ConnectionProcedure> : never;
+type SourceProcedureResult<ById extends boolean | undefined, List extends boolean | ListConfig | undefined, Procedure extends ProcedureLike, ConnectionProcedure extends ConnectionProcedureLike | undefined> = (ById extends false ? Record<never, never> : {
+  byId: ProcedureResult<Procedure>;
+}) & (List extends false ? Record<never, never> : {
+  list: ConnectionProcedureResult<ConnectionProcedure>;
+});
 /**
- * Zod schema for connection args (`after`, `before`, `first`, `last`, etc.).
- */
-declare const connectionArgs: z.ZodOptional<z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>>;
-declare const connectionInput: z.ZodObject<{
-  args: z.ZodOptional<z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>>;
-  select: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
-/**
- * Converts an array of nodes into a list view connection result the client
- * can normalize.
+ * Creates standard `byId` and `list` procedures for a Fate source.
+ *
+ * Use this when a router also has custom mutations or custom queries and you
+ * want to spread the generated source procedures into that router.
  */
+declare function createSourceProcedures<Context, Item extends AnyRecord$1, Procedure extends ProcedureLike, ConnectionProcedure extends ConnectionProcedureLike | undefined = ConnectionProcedureLike | undefined, ById extends boolean | undefined = undefined, List extends boolean | ListConfig | undefined = undefined>({
+  byId,
+  createConnectionProcedure,
+  list,
+  procedure,
+  registry,
+  source
+}: SourceProcedureOptions<Context, Item, Procedure, ConnectionProcedure> & {
+  byId?: ById;
+  list?: List;
+}): SourceProcedureResult<ById, List, Procedure, ConnectionProcedure>;
 /**
- * Wraps a tRPC procedure to handle cursor-based pagination with consistent
- * connection semantics.
+ * Binds the app-specific tRPC pieces once and returns a compact helper for
+ * source procedures.
  */
-declare function withConnection<TProcedure extends ProcedureLike>(procedure: TProcedure): <TItem, TNode = TItem, TAdditionalInput extends AdditionalInputSchema | undefined = undefined>(options: {
-  defaultSize?: number;
-  getCursor?: (node: TNode) => ConnectionCursor;
-  input?: TAdditionalInput;
-  map?: MapFn<ProcedureContext<TProcedure>, TItem, TNode, ConnectionInputWithAdditional<TAdditionalInput>>;
-  query: QueryFn<ProcedureContext<TProcedure>, TItem, ConnectionInputWithAdditional<TAdditionalInput>>;
-}) => ConnectionProcedure<ConnectionInputWithAdditional<TAdditionalInput>, ConnectionResult<TNode>>;
-//#endregion
-//#region src/server/input.d.ts
-declare const byIdInput: z.ZodObject<{
-  args: z.ZodOptional<z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>>;
-  ids: z.ZodArray<z.ZodString>;
-  select: z.ZodArray<z.ZodString>;
-}, z.core.$strip>;
+declare function bindSourceProcedures<Context, Procedure extends ProcedureLike, ConnectionProcedure extends ConnectionProcedureLike | undefined = ConnectionProcedureLike | undefined>(defaults: SourceProcedureFactoryDefaults<Context, Procedure, ConnectionProcedure>): <Item extends AnyRecord$1, ById extends boolean | undefined = undefined, List extends boolean | ListConfig | undefined = undefined>(input: SourceProcedureFactoryInput<Item, ById, List>) => SourceProcedureResult<ById, List, Procedure, ConnectionProcedure>;
 //#endregion
-export { type Entity, byIdInput, connectionArgs, createResolver, dataView, list, resolver, withConnection };
+export { type ComputedField, type ComputedSelection, type ConnectionItem, type ConnectionPagination, type ConnectionResult, type CountSelection, type CountWhere, type DataViewListOptions, type DataViewOrderBy, type DataViewOrderDirection, type DataViewResult, type Entity, FateRequestError, type FateServer, type FateServerManifest, type FieldSelection, type InferFateAPI, type LiveConnectionEventType, type LiveConnectionSourceEvent, type LiveEventBus, type LiveEventType, type LiveSourceEvent, type NativeFateAPI, type OrderDirection, type SourceConfig, type SourceDefinition, type SourceOrder, type SourceOrderField, type SourcePlan, type SourcePlanNode, type SourceRegistry, type SourceRelation, type SourceRelationConfig, bindSourceProcedures, byIdInput, computed, connectionArgs, count, createFateFetchHandler, createFateServer, createHonoFateHandler, createLiveEventBus, createNestedSourcePlan, createResolver, createSourcePlan, createSourceProcedures, dataView, field, getNestedSelection, getScopedArgs, hasNestedSelection, isRecord, list$1 as list, liveConnectionTopic, liveEntityTopic, liveGlobalConnectionTopic, refetchSourceById, resolveSourceById, resolveSourceByIds, resolveSourceConnection, resolver, toPrismaSelect, withConnection };