kitcn 0.33.1 → 0.33.2

package/dist/caller-factory-C3pcbzo0.d.ts

@@ -1,140 +0,0 @@
-import { i as DataTransformerOptions } from "./transformer-BEkxlnss.js";
-import { FunctionReference, FunctionReturnType } from "convex/server";
-
-//#region src/internal/upstream/index.d.ts
-type EmptyObject = Record<string, never>;
-/**
- * Hack! This type causes TypeScript to simplify how it renders object types.
- *
- * It is functionally the identity for object types, but in practice it can
- * simplify expressions like `A & B`.
- */
-type Expand<ObjectType extends Record<any, any>> = ObjectType extends Record<any, any> ? { [Key in keyof ObjectType]: ObjectType[Key] } : never;
-//#endregion
-//#region src/server/caller.d.ts
-/** Metadata for a single function */
-type FnMeta = {
-  type?: 'query' | 'mutation' | 'action';
-  [key: string]: unknown;
-};
-/** Metadata for all functions in a module */
-type ModuleMeta = Record<string, FnMeta>;
-/** Metadata for all modules - from generated `@convex/api` */
-type CallerMeta = Record<string, ModuleMeta>;
-/** Options for individual caller function calls */
-type CallerOpts = {
-  /** Skip query silently when unauthenticated (returns null instead of throwing) */skipUnauth?: boolean;
-};
-type CallerReturn<T, Opts extends CallerOpts | undefined> = Opts extends {
-  skipUnauth: true;
-} ? T | null : T;
-type FetchFn<T extends 'query' | 'mutation' | 'action'> = <Fn extends FunctionReference<T>>(fn: Fn, args: Fn['_args'], opts?: CallerOpts) => Promise<FunctionReturnType<Fn> | null>;
-type CreateCallerOptions = {
-  fetchQuery: FetchFn<'query'>;
-  fetchMutation: FetchFn<'mutation'>;
-  fetchAction: FetchFn<'action'>;
-  meta: CallerMeta;
-  transformer?: DataTransformerOptions;
-};
-type ServerCallerFn<TApi, K extends keyof TApi> = TApi[K] extends FunctionReference<infer T, 'public'> ? T extends 'query' | 'mutation' | 'action' ? keyof TApi[K]['_args'] extends never ? <Opts extends CallerOpts | undefined = undefined>(args?: EmptyObject, opts?: Opts) => Promise<CallerReturn<FunctionReturnType<TApi[K]>, Opts>> : EmptyObject extends TApi[K]['_args'] ? <Opts extends CallerOpts | undefined = undefined>(args?: TApi[K]['_args'], opts?: Opts) => Promise<CallerReturn<FunctionReturnType<TApi[K]>, Opts>> : <Opts extends CallerOpts | undefined = undefined>(args: TApi[K]['_args'], opts?: Opts) => Promise<CallerReturn<FunctionReturnType<TApi[K]>, Opts>> : never : ServerCaller<TApi[K]>;
-type ServerCaller<TApi> = { [K in keyof TApi as K extends string ? K extends `_${string}` ? never : K extends 'http' ? never : K : K]: ServerCallerFn<TApi, K> };
-/**
- * Create a server caller for direct data fetching without React Query.
- *
- * This is detached from React Query cache - data is NOT available in client components.
- * Use for server-only data that doesn't need to be shared with the client.
- *
- * @example
- * ```tsx
- * // src/lib/convex/rsc.tsx
- * export const caller = createServerCaller(api, {
- *   fetchQuery: fetchAuthQuery,
- *   fetchMutation: fetchAuthMutation,
- * });
- *
- * // app/page.tsx (RSC)
- * const posts = await caller.posts.list();
- * return <div>{posts?.length} posts</div>;
- * ```
- */
-declare function createServerCaller<TApi extends Record<string, unknown>>(api: TApi, opts: CreateCallerOptions): ServerCaller<TApi>;
-//#endregion
-//#region src/server/lazy-caller.d.ts
-type CallerContext<TApi> = {
-  caller: ServerCaller<TApi>;
-  token: string | undefined;
-  isAuthenticated: boolean;
-};
-/**
- * Lazy caller with auth helper methods.
- * Context is created on first procedure invocation, not at definition time.
- */
-type LazyCaller<TApi> = ServerCaller<TApi> & {
-  /** Check if user is authenticated */isAuth: () => Promise<boolean>; /** Check if user is unauthenticated */
-  isUnauth: () => Promise<boolean>; /** Get the auth token (for RSC prefetching) */
-  getToken: () => Promise<string | undefined>;
-};
-/**
- * Create a lazy caller that creates context on each procedure invocation.
- * Matches tRPC's `appRouter.createCaller(createTRPCContext)` pattern.
- *
- * @example
- * ```ts
- * // server.ts
- * const { createContext, createCaller } = createCallerFactory({...});
- *
- * // rsc.tsx
- * const createRSCContext = cache(async () => {
- *   const heads = await headers();
- *   return createContext({ headers: heads });
- * });
- * export const caller = createCaller(createRSCContext);
- *
- * // app/page.tsx - single call! Context created lazily
- * const posts = await caller.posts.list();
- * ```
- */
-declare function createLazyCaller<TApi extends Record<string, unknown>>(api: TApi, createContext: () => Promise<CallerContext<TApi>>): LazyCaller<TApi>;
-//#endregion
-//#region src/server/caller-factory.d.ts
-type TokenResult = {
-  token?: string;
-  isFresh?: boolean;
-};
-type GetTokenFn = (siteUrl: string, headers: Headers, opts?: unknown) => Promise<TokenResult>;
-/** Auth options for server-side calls. */
-type AuthOptions = {
-  /** Function to extract auth token from request headers. */getToken: GetTokenFn;
-  /**
-   * Custom function to detect UNAUTHORIZED errors.
-   * Set this to resolve those errors to `null` instead of throwing.
-   *
-   * Refreshing an expired cached token and retrying does not require this:
-   * that always falls back to `defaultIsUnauthorized`.
-   */
-  isUnauthorized?: (error: unknown) => boolean;
-};
-type CreateCallerFactoryOptions<TApi> = {
-  /** Your Convex API object. */api: TApi; /** Convex site URL (must end in `.convex.site`). */
-  convexSiteUrl: string;
-  /**
-   * Convex deployment URL (must end in `.convex.cloud`).
-   * Defaults to `convexSiteUrl` with the domain swapped.
-   */
-  convexUrl?: string; /** Auth options. Pass to enable authenticated calls with JWT caching. */
-  auth?: AuthOptions; /** Optional wire transformer for request/response payloads (always composed with Date). */
-  transformer?: DataTransformerOptions;
-};
-type ConvexContext<TApi> = {
-  token: string | undefined;
-  isAuthenticated: boolean;
-  caller: ServerCaller<TApi>;
-};
-declare function createCallerFactory<TApi extends Record<string, unknown>>(opts: CreateCallerFactoryOptions<TApi>): {
-  createCaller: (ctxFn: () => Promise<ConvexContext<TApi>>) => LazyCaller<TApi>;
-  createContext: (reqOpts: {
-    headers: Headers;
-  }) => Promise<ConvexContext<TApi>>;
-};
-//#endregion
-export { CallerMeta as a, createServerCaller as c, createLazyCaller as i, EmptyObject as l, createCallerFactory as n, CallerOpts as o, LazyCaller as r, ServerCaller as s, ConvexContext as t, Expand as u };

package/dist/transformer-BEkxlnss.d.ts

@@ -1,78 +0,0 @@
-//#region src/crpc/transformer.d.ts
-/**
- * Generic transformer contract (mirrors tRPC shape).
- */
-interface DataTransformer {
-  deserialize(object: any): any;
-  serialize(object: any): any;
-}
-/**
- * Separate input/output transformers.
- */
-interface CombinedDataTransformer {
-  input: DataTransformer;
-  output: DataTransformer;
-}
-/**
- * Transformer config accepted by cRPC.
- */
-type DataTransformerOptions = CombinedDataTransformer | DataTransformer;
-/**
- * Extensible tagged wire codec.
- */
-interface WireCodec {
-  decode(value: unknown): unknown;
-  encode(value: unknown): unknown;
-  isType(value: unknown): boolean;
-  /**
-   * Declares that `isType` only ever claims a value where
-   * `typeof value === 'object' && value !== null` - never a primitive, a
-   * function, `null` or `undefined`.
-   *
-   * Lets `serialize` skip codec dispatch on primitives, which are the majority
-   * of visited nodes. It is opt-in because an arbitrary predicate cannot be
-   * classified by sampling values: a codec that claims, say, one specific
-   * number would be misread as object-only and silently lose its encoding.
-   * Codecs that leave it unset keep full dispatch.
-   */
-  readonly objectsOnly?: boolean;
-  readonly tag: `$${string}`;
-}
-/**
- * Date wire tag (Convex-style reserved key).
- */
-declare const DATE_CODEC_TAG = "$date";
-/**
- * Built-in Date codec.
- */
-declare const dateWireCodec: WireCodec;
-/**
- * Build a recursive tagged transformer from codecs.
- */
-declare const createTaggedTransformer: (codecs: readonly WireCodec[]) => DataTransformer;
-/**
- * Default cRPC transformer (Date-enabled).
- */
-declare const defaultCRPCTransformer: DataTransformer;
-/**
- * Normalize transformer config to split input/output shape.
- * User transformers are additive and always composed with default Date handling.
- *
- * Idempotent: passing a transformer this function already resolved returns it
- * unchanged.
- */
-declare const getTransformer: (transformer?: DataTransformerOptions) => CombinedDataTransformer;
-/**
- * Encode request payloads (input direction).
- */
-declare const encodeWire: (value: unknown, transformer?: DataTransformerOptions) => unknown;
-/**
- * Decode response payloads (output direction).
- */
-declare const decodeWire: (value: unknown, transformer?: DataTransformerOptions) => unknown;
-/**
- * Exposed identity transformer for advanced composition.
- */
-declare const identityTransformer: CombinedDataTransformer;
-//#endregion
-export { WireCodec as a, decodeWire as c, getTransformer as d, identityTransformer as f, DataTransformerOptions as i, defaultCRPCTransformer as l, DATE_CODEC_TAG as n, createTaggedTransformer as o, DataTransformer as r, dateWireCodec as s, CombinedDataTransformer as t, encodeWire as u };