@temporary-name/server 1.9.3-alpha.592ae1e02e18c5274906b132313b083116248636 → 1.9.3-alpha.5dc8b200530586870ac736830d4584e0333cfd05

package/dist/shared/server.DkYpsO6W.d.ts

@@ -0,0 +1,251 @@
+import { ErrorMap, ErrorMapItem, InferSchemaInput, Meta, Schemas, ContractProcedureDef, AnyContractRouter, ContractProcedure, InferProcedureClientInputs, InferSchemaOutput, EnhanceRouteOptions, MergedErrorMap, AnyContractProcedure, ContractRouter, AnySchema, ErrorFromErrorMap } from '@temporary-name/contract';
+import { ORPCErrorCode, MaybeOptionalOptions, ORPCErrorOptions, ORPCError, Promisable, StandardLazyRequest, HTTPPath, ClientContext, Interceptor, PromiseWithError, Value, Client } from '@temporary-name/shared';
+
+type Context = Record<PropertyKey, any>;
+type MergedInitialContext<TInitial extends Context, TAdditional extends Context, TCurrent extends Context> = TInitial & Omit<TAdditional, keyof TCurrent>;
+type MergedCurrentContext<T extends Context, U extends Context> = Omit<T, keyof U> & U;
+type BuildContextWithAuth<TContext extends Context, TAuthContext> = MergedCurrentContext<TContext, {
+    auth: TAuthContext | ('auth' extends keyof TContext ? TContext['auth'] : never);
+}>;
+declare function mergeCurrentContext<T extends Context, U extends Context>(context: T, other: U): MergedCurrentContext<T, U>;
+
+type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'defined' | 'status'>;
+type ORPCErrorConstructorMapItem<TCode extends ORPCErrorCode, TInData> = (...rest: MaybeOptionalOptions<ORPCErrorConstructorMapItemOptions<TInData>>) => ORPCError<TCode, TInData>;
+type ORPCErrorConstructorMap<T extends ErrorMap> = {
+    [K in keyof T]: K extends ORPCErrorCode ? T[K] extends ErrorMapItem<infer UInputSchema> ? ORPCErrorConstructorMapItem<K, InferSchemaInput<UInputSchema>> : never : never;
+};
+declare function createORPCErrorConstructorMap<T extends ErrorMap>(errors: T): ORPCErrorConstructorMap<T>;
+
+type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
+    output: TOutput;
+    context: TOutContext;
+}>;
+interface MiddlewareNextFn<TOutput> {
+    <U extends Context = {}>(options?: {
+        context?: U;
+    }): MiddlewareResult<U, TOutput>;
+}
+interface MiddlewareOutputFn<TOutput> {
+    (output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+}
+interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> extends ProcedureHandlerOptions<TInContext, TErrorConstructorMap, TMeta> {
+    next: MiddlewareNextFn<TOutput>;
+}
+/**
+ * A function that represents a middleware.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
+ */
+interface Middleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    (options: MiddlewareOptions<TInContext, TOutput, TErrorConstructorMap, TMeta>, input: TInput, output: MiddlewareOutputFn<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
+}
+type AnyMiddleware = Middleware<any, any, any, any, any, any>;
+interface MapInputMiddleware<TInput, TMappedInput> {
+    (input: TInput): TMappedInput;
+}
+declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+
+type DefaultProcedureHandlerOptions = ProcedureHandlerOptions<Context, ORPCErrorConstructorMap<ErrorMap>, Meta>;
+interface ProcedureHandlerOptions<TCurrentContext extends Context, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    context: TCurrentContext;
+    path: readonly string[];
+    procedure: Procedure<Context, Context, Schemas, ErrorMap, TMeta>;
+    signal?: AbortSignal;
+    request?: StandardLazyRequest;
+    lastEventId: string | undefined;
+    errors: TErrorConstructorMap;
+}
+interface ProcedureHandler<TCurrentContext extends Context, TInput extends {
+    path: any;
+    query: any;
+    body: any;
+}, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    (input: TInput, opt: ProcedureHandlerOptions<TCurrentContext, ORPCErrorConstructorMap<TErrorMap>, TMeta>): Promisable<THandlerOutput>;
+}
+interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TSchemas, TErrorMap, TMeta> {
+    __initialContext?: (type: TInitialContext) => unknown;
+    middlewares: readonly AnyMiddleware[];
+    authConfigs: TypedAuthConfig[];
+    inputValidationIndex: number;
+    outputValidationIndex: number;
+    handler: ProcedureHandler<TCurrentContext, any, any, any, any>;
+}
+/**
+ * This class represents a procedure.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/procedure Procedure Docs}
+ */
+declare class Procedure<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    /**
+     * This property holds the defined options.
+     */
+    '~orpc': ProcedureDef<TInitialContext, TCurrentContext, TSchemas, TErrorMap, TMeta>;
+    constructor(def: ProcedureDef<TInitialContext, TCurrentContext, TSchemas, TErrorMap, TMeta>);
+}
+type AnyProcedure = Procedure<any, any, Schemas, any, any>;
+declare function isProcedure(item: unknown): item is AnyProcedure;
+
+type ValidatedAuthContext = {};
+interface BasicAuthConfig<TAuthContext extends ValidatedAuthContext, TCurrentContext extends Context, TMeta extends Meta> {
+    tokenPrefix?: string;
+    validate: (username: string, password: string, options: ProcedureHandlerOptions<TCurrentContext, ORPCErrorConstructorMap<any>, TMeta>) => Promisable<TAuthContext>;
+}
+interface TokenAuthConfig<TAuthContext extends ValidatedAuthContext, TCurrentContext extends Context, TMeta extends Meta> {
+    tokenPrefix?: string;
+    validate: (token: string, options: ProcedureHandlerOptions<TCurrentContext, ORPCErrorConstructorMap<any>, TMeta>) => Promisable<TAuthContext>;
+}
+interface NamedTokenAuthConfig<TAuthContext extends ValidatedAuthContext, TCurrentContext extends Context, TMeta extends Meta> extends TokenAuthConfig<TAuthContext, TCurrentContext, TMeta> {
+    name: string;
+}
+type AuthType = 'header' | 'query' | 'cookie' | 'bearer' | 'basic' | 'none';
+type AuthConfig<TAuthType extends AuthType, TAuthContext extends ValidatedAuthContext = ValidatedAuthContext, TCurrentContext extends Context = Context, TMeta extends Meta = Meta> = TAuthType extends 'basic' ? BasicAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'bearer' ? TokenAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'header' ? NamedTokenAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'query' ? NamedTokenAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'cookie' ? NamedTokenAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'none' ? {} : never;
+type TypedAuthConfig<TAuthType extends AuthType = AuthType> = {
+    type: TAuthType;
+} & AuthConfig<TAuthType, object>;
+
+/**
+ * Represents a router, which defines a hierarchical structure of procedures.
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.unnoq.com/docs/contract-first/define-contract#contract-router Contract Router Docs}
+ */
+type Router<T extends AnyContractRouter, TInitialContext extends Context> = T extends ContractProcedure<infer USchemas, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, any, USchemas, UErrorMap, UMeta> : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? Lazyable<Router<T[K], TInitialContext>> : never;
+};
+type AnyRouter = Router<any, any>;
+type InferRouterInitialContext<T extends AnyRouter> = T extends Router<any, infer UInitialContext> ? UInitialContext : never;
+/**
+ * Infer all initial context of the router.
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
+ */
+type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, any, any, any> ? UInitialContext : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInitialContexts<U> : never;
+};
+/**
+ * Infer all current context of the router.
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
+ */
+type InferRouterCurrentContexts<T extends AnyRouter> = T extends Procedure<any, infer UCurrentContext, any, any, any> ? UCurrentContext : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterCurrentContexts<U> : never;
+};
+/**
+ * Infer all router inputs
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
+ */
+type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer USchemas, any, any> ? InferProcedureClientInputs<USchemas> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
+};
+/**
+ * Infer all router outputs
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
+ */
+type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, infer USchemas, any, any> ? InferSchemaOutput<USchemas['outputSchema']> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
+};
+
+declare function getRouter<T extends Lazyable<AnyRouter | undefined>>(router: T, path: readonly string[]): T extends Lazy<any> ? Lazy<AnyRouter | undefined> : Lazyable<AnyRouter | undefined>;
+type AccessibleLazyRouter<T extends Lazyable<AnyRouter | undefined>> = T extends Lazy<infer U extends AnyRouter | undefined | Lazy<AnyRouter | undefined>> ? AccessibleLazyRouter<U> : T extends AnyProcedure | undefined ? Lazy<T> : Lazy<T> & {
+    [K in keyof T]: T[K] extends Lazyable<AnyRouter> ? AccessibleLazyRouter<T[K]> : never;
+};
+declare function createAccessibleLazyRouter<T extends Lazy<AnyRouter | undefined>>(lazied: T): AccessibleLazyRouter<T>;
+type EnhancedRouter<T extends Lazyable<AnyRouter>, TInitialContext extends Context, TCurrentContext extends Context, TErrorMap extends ErrorMap> = T extends Lazy<infer U extends AnyRouter> ? AccessibleLazyRouter<EnhancedRouter<U, TInitialContext, TCurrentContext, TErrorMap>> : T extends (Procedure<infer UInitialContext, infer UCurrentContext, infer USchemas, infer UErrorMap, infer UMeta>) ? Procedure<MergedInitialContext<TInitialContext, UInitialContext, TCurrentContext>, UCurrentContext, USchemas, MergedErrorMap<TErrorMap, UErrorMap>, UMeta> : {
+    [K in keyof T]: T[K] extends Lazyable<AnyRouter> ? EnhancedRouter<T[K], TInitialContext, TCurrentContext, TErrorMap> : never;
+};
+interface EnhanceRouterOptions<TErrorMap extends ErrorMap> extends EnhanceRouteOptions {
+    middlewares: readonly AnyMiddleware[];
+    errorMap: TErrorMap;
+    dedupeLeadingMiddlewares: boolean;
+}
+declare function enhanceRouter<T extends Lazyable<AnyRouter>, TInitialContext extends Context, TCurrentContext extends Context, TErrorMap extends ErrorMap>(router: T, options: EnhanceRouterOptions<TErrorMap>): EnhancedRouter<T, TInitialContext, TCurrentContext, TErrorMap>;
+interface TraverseContractProceduresOptions {
+    router: AnyContractRouter | AnyRouter;
+    path: readonly string[];
+}
+interface TraverseContractProcedureCallbackOptions {
+    contract: AnyContractProcedure | AnyProcedure;
+    path: readonly string[];
+}
+/**
+ * @deprecated Use `TraverseContractProcedureCallbackOptions` instead.
+ */
+type ContractProcedureCallbackOptions = TraverseContractProcedureCallbackOptions;
+interface LazyTraverseContractProceduresOptions {
+    router: Lazy<AnyRouter>;
+    path: readonly string[];
+}
+declare function traverseContractProcedures(options: TraverseContractProceduresOptions, callback: (options: TraverseContractProcedureCallbackOptions) => void, lazyOptions?: LazyTraverseContractProceduresOptions[]): LazyTraverseContractProceduresOptions[];
+declare function resolveContractProcedures(options: TraverseContractProceduresOptions, callback: (options: TraverseContractProcedureCallbackOptions) => void): Promise<void>;
+type UnlaziedRouter<T extends AnyRouter> = T extends AnyProcedure ? T : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? UnlaziedRouter<U> : never;
+};
+declare function unlazyRouter<T extends AnyRouter>(router: T): Promise<UnlaziedRouter<T>>;
+
+declare const LAZY_SYMBOL: unique symbol;
+interface LazyMeta {
+    prefix?: HTTPPath;
+}
+interface Lazy<T> {
+    [LAZY_SYMBOL]: {
+        loader: () => Promise<{
+            default: T;
+        }>;
+        meta: LazyMeta;
+    };
+}
+type Lazyable<T> = T | Lazy<T>;
+/**
+ * @internal
+ */
+declare function lazyInternal<T>(loader: () => Promise<{
+    default: T;
+}>, meta?: LazyMeta): Lazy<T>;
+/**
+ * Creates a lazy-loaded item.
+ *
+ * @warning The `prefix` in `meta` only holds metadata and does not apply the prefix to the lazy router, use `os.prefix(...).lazyRoute(...)` instead.
+ */
+declare function lazy<T extends Router<ContractRouter<{}>, any>>(prefix: HTTPPath, loader: () => Promise<{
+    default: T;
+}>): EnhancedRouter<Lazy<T>, {}, {}, {}>;
+declare function isLazy(item: unknown): item is Lazy<any>;
+declare function getLazyMeta(lazied: Lazy<any>): LazyMeta;
+declare function unlazy<T extends Lazyable<any>>(lazied: T): Promise<{
+    default: T extends Lazy<infer U> ? U : T;
+}>;
+
+type ProcedureClient<TClientContext extends ClientContext, TSchemas extends Schemas, TErrorMap extends ErrorMap> = Client<TClientContext, InferProcedureClientInputs<TSchemas>, InferSchemaOutput<TSchemas['outputSchema']>, ErrorFromErrorMap<TErrorMap>>;
+interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TErrorMap extends ErrorMap, TMeta extends Meta> extends ProcedureHandlerOptions<TInitialContext, ORPCErrorConstructorMap<TErrorMap>, TMeta> {
+    input: {
+        path: unknown;
+        query: unknown;
+        body: unknown;
+    };
+}
+type CreateProcedureClientOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext> = {
+    /**
+     * This is helpful for logging and analytics.
+     */
+    path?: readonly string[];
+    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TErrorMap, TMeta>, PromiseWithError<InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>>[];
+} & (Record<never, never> extends TInitialContext ? {
+    context?: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
+} : {
+    context: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
+});
+/**
+ * Create Server-side client from a procedure.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/server-side Server-side Client Docs}
+ */
+declare function createProcedureClient<TInitialContext extends Context, TSchemas extends Schemas, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TSchemas, TErrorMap, TMeta>>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TSchemas['outputSchema'], TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TSchemas, TErrorMap>;
+
+export { enhanceRouter as $, middlewareOutputFn as F, isProcedure as K, Procedure as P, createProcedureClient as Q, getRouter as Y, createAccessibleLazyRouter as _, traverseContractProcedures as a4, resolveContractProcedures as a5, unlazyRouter as a7, mergeCurrentContext as m, createORPCErrorConstructorMap as p, LAZY_SYMBOL as q, lazyInternal as s, lazy as t, isLazy as u, getLazyMeta as v, unlazy as w };
+export type { AuthType as A, BuildContextWithAuth as B, Context as C, MiddlewareOptions as D, EnhanceRouterOptions as E, DefaultProcedureHandlerOptions as G, ProcedureHandlerOptions as H, InferRouterInitialContext as I, ProcedureDef as J, Lazy as L, Middleware as M, ProcedureClientInterceptorOptions as N, ORPCErrorConstructorMap as O, Router as R, InferRouterInitialContexts as S, TypedAuthConfig as T, InferRouterCurrentContexts as U, ValidatedAuthContext as V, InferRouterInputs as W, InferRouterOutputs as X, AccessibleLazyRouter as Z, CreateProcedureClientOptions as a, TraverseContractProceduresOptions as a0, TraverseContractProcedureCallbackOptions as a1, ContractProcedureCallbackOptions as a2, LazyTraverseContractProceduresOptions as a3, UnlaziedRouter as a6, ProcedureClient as b, MergedInitialContext as c, MergedCurrentContext as d, AuthConfig as e, ProcedureHandler as f, EnhancedRouter as g, MapInputMiddleware as h, AnyMiddleware as i, AnyProcedure as j, Lazyable as k, AnyRouter as l, ORPCErrorConstructorMapItemOptions as n, ORPCErrorConstructorMapItem as o, LazyMeta as r, MiddlewareResult as x, MiddlewareNextFn as y, MiddlewareOutputFn as z };

package/dist/shared/{server.SLLuK6_v.d.ts → server.DwNnHUZP.d.ts}

@@ -1,6 +1,6 @@
 import { HTTPPath } from '@temporary-name/shared';
-import { C as Context } from './server.BKSOrA6h.js';
-import { c as StandardHandleOptions } from './server.CQyYNJ1H.js';
+import { C as Context } from './server.DkYpsO6W.js';
+import { c as StandardHandleOptions } from './server.B-meye9-.js';
 
 type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
     context?: T;

package/dist/shared/{server.BeuTpcmO.d.mts → server.I-tTl_ce.d.mts}

@@ -1,6 +1,6 @@
 import { HTTPPath } from '@temporary-name/shared';
-import { C as Context } from './server.BKSOrA6h.mjs';
-import { c as StandardHandleOptions } from './server.C1fnTLq0.mjs';
+import { C as Context } from './server.DkYpsO6W.mjs';
+import { c as StandardHandleOptions } from './server.vLcMd_kA.mjs';
 
 type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
     context?: T;

package/dist/shared/{server.BEHw7Eyx.mjs → server.JtIZ8YG7.mjs}

@@ -234,14 +234,4 @@ function deserialize(data) {
   return data;
 }
 
-function standardizeHTTPPath(path) {
-  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
-}
-function getDynamicParams(path) {
-  return path ? standardizeHTTPPath(path).match(/\/\{[^}]+\}/g)?.map((v) => ({
-    raw: v,
-    name: v.match(/\{\+?([^}]+)\}/)[1]
-  })) : void 0;
-}
-
-export { standardizeHTTPPath as a, deserialize as d, getDynamicParams as g, jsonSerialize as j, serialize as s };
+export { bracketNotationDeserialize as b, deserialize as d, jsonSerialize as j, serialize as s };