@sortsys/v2-client 0.1.4 → 0.1.6

package/dist/index.d.ts

@@ -2,6 +2,7 @@
 
 import { EventEmitter } from 'events';
 import * as http from 'http';
+import { Observable as Observable$1 } from 'rxjs';
 import { SendOptions } from 'send';
 
 interface ConnectionStateBase<TError> {
@@ -3728,295 +3729,6 @@ interface Cache$1 {
 	clear(): Promise<void>;
 	keys(): Promise<Set<string>>;
 }
-declare class Subscription implements SubscriptionLike {
-	private initialTeardown?;
-	static EMPTY: Subscription;
-	/**
-	 * A flag to indicate whether this Subscription has already been unsubscribed.
-	 */
-	closed: boolean;
-	private _parentage;
-	/**
-	 * The list of registered finalizers to execute upon unsubscription. Adding and removing from this
-	 * list occurs in the {@link #add} and {@link #remove} methods.
-	 */
-	private _finalizers;
-	/**
-	 * @param initialTeardown A function executed first as part of the finalization
-	 * process that is kicked off when {@link #unsubscribe} is called.
-	 */
-	constructor(initialTeardown?: (() => void) | undefined);
-	/**
-	 * Disposes the resources held by the subscription. May, for instance, cancel
-	 * an ongoing Observable execution or cancel any other type of work that
-	 * started when the Subscription was created.
-	 */
-	unsubscribe(): void;
-	/**
-	 * Adds a finalizer to this subscription, so that finalization will be unsubscribed/called
-	 * when this subscription is unsubscribed. If this subscription is already {@link #closed},
-	 * because it has already been unsubscribed, then whatever finalizer is passed to it
-	 * will automatically be executed (unless the finalizer itself is also a closed subscription).
-	 *
-	 * Closed Subscriptions cannot be added as finalizers to any subscription. Adding a closed
-	 * subscription to a any subscription will result in no operation. (A noop).
-	 *
-	 * Adding a subscription to itself, or adding `null` or `undefined` will not perform any
-	 * operation at all. (A noop).
-	 *
-	 * `Subscription` instances that are added to this instance will automatically remove themselves
-	 * if they are unsubscribed. Functions and {@link Unsubscribable} objects that you wish to remove
-	 * will need to be removed manually with {@link #remove}
-	 *
-	 * @param teardown The finalization logic to add to this subscription.
-	 */
-	add(teardown: TeardownLogic): void;
-	/**
-	 * Checks to see if a this subscription already has a particular parent.
-	 * This will signal that this subscription has already been added to the parent in question.
-	 * @param parent the parent to check for
-	 */
-	private _hasParent;
-	/**
-	 * Adds a parent to this subscription so it can be removed from the parent if it
-	 * unsubscribes on it's own.
-	 *
-	 * NOTE: THIS ASSUMES THAT {@link _hasParent} HAS ALREADY BEEN CHECKED.
-	 * @param parent The parent subscription to add
-	 */
-	private _addParent;
-	/**
-	 * Called on a child when it is removed via {@link #remove}.
-	 * @param parent The parent to remove
-	 */
-	private _removeParent;
-	/**
-	 * Removes a finalizer from this subscription that was previously added with the {@link #add} method.
-	 *
-	 * Note that `Subscription` instances, when unsubscribed, will automatically remove themselves
-	 * from every other `Subscription` they have been added to. This means that using the `remove` method
-	 * is not a common thing and should be used thoughtfully.
-	 *
-	 * If you add the same finalizer instance of a function or an unsubscribable object to a `Subscription` instance
-	 * more than once, you will need to call `remove` the same number of times to remove all instances.
-	 *
-	 * All finalizer instances are removed to free up memory upon unsubscription.
-	 *
-	 * @param teardown The finalizer to remove from this subscription
-	 */
-	remove(teardown: Exclude<TeardownLogic, void>): void;
-}
-declare class Subscriber<T> extends Subscription implements Observer$1<T> {
-	/**
-	 * A static factory for a Subscriber, given a (potentially partial) definition
-	 * of an Observer.
-	 * @param next The `next` callback of an Observer.
-	 * @param error The `error` callback of an
-	 * Observer.
-	 * @param complete The `complete` callback of an
-	 * Observer.
-	 * @return A Subscriber wrapping the (partially defined)
-	 * Observer represented by the given arguments.
-	 * @deprecated Do not use. Will be removed in v8. There is no replacement for this
-	 * method, and there is no reason to be creating instances of `Subscriber` directly.
-	 * If you have a specific use case, please file an issue.
-	 */
-	static create<T>(next?: (x?: T) => void, error?: (e?: any) => void, complete?: () => void): Subscriber<T>;
-	/** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
-	protected isStopped: boolean;
-	/** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
-	protected destination: Subscriber<any> | Observer$1<any>;
-	/**
-	 * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
-	 * There is no reason to directly create an instance of Subscriber. This type is exported for typings reasons.
-	 */
-	constructor(destination?: Subscriber<any> | Observer$1<any>);
-	/**
-	 * The {@link Observer} callback to receive notifications of type `next` from
-	 * the Observable, with a value. The Observable may call this method 0 or more
-	 * times.
-	 * @param value The `next` value.
-	 */
-	next(value: T): void;
-	/**
-	 * The {@link Observer} callback to receive notifications of type `error` from
-	 * the Observable, with an attached `Error`. Notifies the Observer that
-	 * the Observable has experienced an error condition.
-	 * @param err The `error` exception.
-	 */
-	error(err?: any): void;
-	/**
-	 * The {@link Observer} callback to receive a valueless notification of type
-	 * `complete` from the Observable. Notifies the Observer that the Observable
-	 * has finished sending push-based notifications.
-	 */
-	complete(): void;
-	unsubscribe(): void;
-	protected _next(value: T): void;
-	protected _error(err: any): void;
-	protected _complete(): void;
-}
-interface Operator<T, R> {
-	call(subscriber: Subscriber<R>, source: any): TeardownLogic;
-}
-declare class Observable$1<T> implements Subscribable$1<T> {
-	/**
-	 * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
-	 */
-	source: Observable$1<any> | undefined;
-	/**
-	 * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
-	 */
-	operator: Operator<any, T> | undefined;
-	/**
-	 * @param subscribe The function that is called when the Observable is
-	 * initially subscribed to. This function is given a Subscriber, to which new values
-	 * can be `next`ed, or an `error` method can be called to raise an error, or
-	 * `complete` can be called to notify of a successful completion.
-	 */
-	constructor(subscribe?: (this: Observable$1<T>, subscriber: Subscriber<T>) => TeardownLogic);
-	/**
-	 * Creates a new Observable by calling the Observable constructor
-	 * @param subscribe the subscriber function to be passed to the Observable constructor
-	 * @return A new observable.
-	 * @deprecated Use `new Observable()` instead. Will be removed in v8.
-	 */
-	static create: (...args: any[]) => any;
-	/**
-	 * Creates a new Observable, with this Observable instance as the source, and the passed
-	 * operator defined as the new observable's operator.
-	 * @param operator the operator defining the operation to take on the observable
-	 * @return A new observable with the Operator applied.
-	 * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
-	 * If you have implemented an operator using `lift`, it is recommended that you create an
-	 * operator by simply returning `new Observable()` directly. See "Creating new operators from
-	 * scratch" section here: https://rxjs.dev/guide/operators
-	 */
-	lift<R>(operator?: Operator<T, R>): Observable$1<R>;
-	subscribe(observerOrNext?: Partial<Observer$1<T>> | ((value: T) => void)): Subscription;
-	/** @deprecated Instead of passing separate callback arguments, use an observer argument. Signatures taking separate callback arguments will be removed in v8. Details: https://rxjs.dev/deprecations/subscribe-arguments */
-	subscribe(next?: ((value: T) => void) | null, error?: ((error: any) => void) | null, complete?: (() => void) | null): Subscription;
-	/**
-	 * Used as a NON-CANCELLABLE means of subscribing to an observable, for use with
-	 * APIs that expect promises, like `async/await`. You cannot unsubscribe from this.
-	 *
-	 * **WARNING**: Only use this with observables you *know* will complete. If the source
-	 * observable does not complete, you will end up with a promise that is hung up, and
-	 * potentially all of the state of an async function hanging out in memory. To avoid
-	 * this situation, look into adding something like {@link timeout}, {@link take},
-	 * {@link takeWhile}, or {@link takeUntil} amongst others.
-	 *
-	 * #### Example
-	 *
-	 * ```ts
-	 * import { interval, take } from 'rxjs';
-	 *
-	 * const source$ = interval(1000).pipe(take(4));
-	 *
-	 * async function getTotal() {
-	 *   let total = 0;
-	 *
-	 *   await source$.forEach(value => {
-	 *     total += value;
-	 *     console.log('observable -> ' + value);
-	 *   });
-	 *
-	 *   return total;
-	 * }
-	 *
-	 * getTotal().then(
-	 *   total => console.log('Total: ' + total)
-	 * );
-	 *
-	 * // Expected:
-	 * // 'observable -> 0'
-	 * // 'observable -> 1'
-	 * // 'observable -> 2'
-	 * // 'observable -> 3'
-	 * // 'Total: 6'
-	 * ```
-	 *
-	 * @param next A handler for each value emitted by the observable.
-	 * @return A promise that either resolves on observable completion or
-	 * rejects with the handled error.
-	 */
-	forEach(next: (value: T) => void): Promise<void>;
-	/**
-	 * @param next a handler for each value emitted by the observable
-	 * @param promiseCtor a constructor function used to instantiate the Promise
-	 * @return a promise that either resolves on observable completion or
-	 *  rejects with the handled error
-	 * @deprecated Passing a Promise constructor will no longer be available
-	 * in upcoming versions of RxJS. This is because it adds weight to the library, for very
-	 * little benefit. If you need this functionality, it is recommended that you either
-	 * polyfill Promise, or you create an adapter to convert the returned native promise
-	 * to whatever promise implementation you wanted. Will be removed in v8.
-	 */
-	forEach(next: (value: T) => void, promiseCtor: PromiseConstructorLike): Promise<void>;
-	pipe(): Observable$1<T>;
-	pipe<A>(op1: OperatorFunction$1<T, A>): Observable$1<A>;
-	pipe<A, B>(op1: OperatorFunction$1<T, A>, op2: OperatorFunction$1<A, B>): Observable$1<B>;
-	pipe<A, B, C>(op1: OperatorFunction$1<T, A>, op2: OperatorFunction$1<A, B>, op3: OperatorFunction$1<B, C>): Observable$1<C>;
-	pipe<A, B, C, D>(op1: OperatorFunction$1<T, A>, op2: OperatorFunction$1<A, B>, op3: OperatorFunction$1<B, C>, op4: OperatorFunction$1<C, D>): Observable$1<D>;
-	pipe<A, B, C, D, E>(op1: OperatorFunction$1<T, A>, op2: OperatorFunction$1<A, B>, op3: OperatorFunction$1<B, C>, op4: OperatorFunction$1<C, D>, op5: OperatorFunction$1<D, E>): Observable$1<E>;
-	pipe<A, B, C, D, E, F>(op1: OperatorFunction$1<T, A>, op2: OperatorFunction$1<A, B>, op3: OperatorFunction$1<B, C>, op4: OperatorFunction$1<C, D>, op5: OperatorFunction$1<D, E>, op6: OperatorFunction$1<E, F>): Observable$1<F>;
-	pipe<A, B, C, D, E, F, G>(op1: OperatorFunction$1<T, A>, op2: OperatorFunction$1<A, B>, op3: OperatorFunction$1<B, C>, op4: OperatorFunction$1<C, D>, op5: OperatorFunction$1<D, E>, op6: OperatorFunction$1<E, F>, op7: OperatorFunction$1<F, G>): Observable$1<G>;
-	pipe<A, B, C, D, E, F, G, H>(op1: OperatorFunction$1<T, A>, op2: OperatorFunction$1<A, B>, op3: OperatorFunction$1<B, C>, op4: OperatorFunction$1<C, D>, op5: OperatorFunction$1<D, E>, op6: OperatorFunction$1<E, F>, op7: OperatorFunction$1<F, G>, op8: OperatorFunction$1<G, H>): Observable$1<H>;
-	pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction$1<T, A>, op2: OperatorFunction$1<A, B>, op3: OperatorFunction$1<B, C>, op4: OperatorFunction$1<C, D>, op5: OperatorFunction$1<D, E>, op6: OperatorFunction$1<E, F>, op7: OperatorFunction$1<F, G>, op8: OperatorFunction$1<G, H>, op9: OperatorFunction$1<H, I>): Observable$1<I>;
-	pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction$1<T, A>, op2: OperatorFunction$1<A, B>, op3: OperatorFunction$1<B, C>, op4: OperatorFunction$1<C, D>, op5: OperatorFunction$1<D, E>, op6: OperatorFunction$1<E, F>, op7: OperatorFunction$1<F, G>, op8: OperatorFunction$1<G, H>, op9: OperatorFunction$1<H, I>, ...operations: OperatorFunction$1<any, any>[]): Observable$1<unknown>;
-	/** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
-	toPromise(): Promise<T | undefined>;
-	/** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
-	toPromise(PromiseCtor: typeof Promise): Promise<T | undefined>;
-	/** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
-	toPromise(PromiseCtor: PromiseConstructorLike): Promise<T | undefined>;
-}
-interface UnaryFunction$1<T, R> {
-	(source: T): R;
-}
-interface OperatorFunction$1<T, R> extends UnaryFunction$1<Observable$1<T>, Observable$1<R>> {
-}
-interface Unsubscribable$1 {
-	unsubscribe(): void;
-}
-declare type TeardownLogic = Subscription | Unsubscribable$1 | (() => void) | void;
-interface SubscriptionLike extends Unsubscribable$1 {
-	unsubscribe(): void;
-	readonly closed: boolean;
-}
-interface Subscribable$1<T> {
-	subscribe(observer: Partial<Observer$1<T>>): Unsubscribable$1;
-}
-interface Observer$1<T> {
-	/**
-	 * A callback function that gets called by the producer during the subscription when
-	 * the producer "has" the `value`. It won't be called if `error` or `complete` callback
-	 * functions have been called, nor after the consumer has unsubscribed.
-	 *
-	 * For more info, please refer to {@link guide/glossary-and-semantics#next this guide}.
-	 */
-	next: (value: T) => void;
-	/**
-	 * A callback function that gets called by the producer if and when it encountered a
-	 * problem of any kind. The errored value will be provided through the `err` parameter.
-	 * This callback can't be called more than one time, it can't be called if the
-	 * `complete` callback function have been called previously, nor it can't be called if
-	 * the consumer has unsubscribed.
-	 *
-	 * For more info, please refer to {@link guide/glossary-and-semantics#error this guide}.
-	 */
-	error: (err: any) => void;
-	/**
-	 * A callback function that gets called by the producer if and when it has no more
-	 * values to provide (by calling `next` callback function). This means that no error
-	 * has happened. This callback can't be called more than one time, it can't be called
-	 * if the `error` callback function have been called previously, nor it can't be called
-	 * if the consumer has unsubscribed.
-	 *
-	 * For more info, please refer to {@link guide/glossary-and-semantics#complete this guide}.
-	 */
-	complete: () => void;
-}
 /**
  * Streaming/caching modes consistent with your REST client.
  */
@@ -4034,6 +3746,8 @@ type TRPCQueryPaths<TClient> = TRPCPaths<TClient, "query">;
 type TRPCMutatePaths<TClient> = TRPCPaths<TClient, "mutate">;
 type QueryPaths = TRPCQueryPaths<MyTRPCClient>;
 type MutatePaths = TRPCMutatePaths<MyTRPCClient>;
+export type QueryResult<PathT extends TRPCQueryPaths<MyTRPCClient>> = Awaited<ReturnType<PathValue<MyTRPCClient, `${PathT}.query`>>>;
+export type MutateResult<PathT extends TRPCQueryPaths<MyTRPCClient>> = Awaited<ReturnType<PathValue<MyTRPCClient, `${PathT}.mutate`>>>;
 type AnyFn = (...args: any[]) => any;
 type FirstParam<F> = F extends AnyFn ? Parameters<F> extends [
 	infer A,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sortsys/v2-client",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "main": "dist/index.js",
   "devDependencies": {
     "dts-bundle-generator": "^9.5.1"
@@ -18,12 +18,13 @@
     "access": "public"
   },
   "scripts": {
-    "build": "rm -rf dist && bun build src/index.ts --production --outfile dist/index.js && bunx dts-bundle-generator -o dist/index.d.ts src/index.ts --no-check --external-inlines=@trpc/server @trpc/client express-serve-static-core rxjs qs range-parser --export-referenced-types=false"
+    "build": "rm -rf dist && bun build src/index.ts --production --outfile dist/index.js && bunx dts-bundle-generator -o dist/index.d.ts src/index.ts --no-check --external-inlines=@trpc/server @trpc/client express-serve-static-core qs range-parser --export-referenced-types=false"
   },
   "type": "module",
   "types": "dist/index.d.ts",
   "dependencies": {
     "@types/node": "^25.0.1",
-    "@types/send": "^1.2.1"
+    "@types/send": "^1.2.1",
+    "rxjs": "^7.8.2"
   }
 }