@orpc/contract 0.0.0-next.db1f26d → 0.0.0-next.dbce934

package/dist/index.js

@@ -1,179 +0,0 @@
-// src/procedure.ts
-var ContractProcedure = class {
-  constructor(zz$cp) {
-    this.zz$cp = zz$cp;
-  }
-};
-var DecoratedContractProcedure = class _DecoratedContractProcedure extends ContractProcedure {
-  static decorate(cp) {
-    if (cp instanceof _DecoratedContractProcedure)
-      return cp;
-    return new _DecoratedContractProcedure(cp.zz$cp);
-  }
-  route(opts) {
-    return new _DecoratedContractProcedure({
-      ...this.zz$cp,
-      ...opts,
-      method: opts.method,
-      path: opts.path
-    });
-  }
-  prefix(prefix) {
-    if (!this.zz$cp.path)
-      return this;
-    return new _DecoratedContractProcedure({
-      ...this.zz$cp,
-      path: `${prefix}${this.zz$cp.path}`
-    });
-  }
-  addTags(...tags) {
-    if (!tags.length)
-      return this;
-    return new _DecoratedContractProcedure({
-      ...this.zz$cp,
-      tags: [...this.zz$cp.tags ?? [], ...tags]
-    });
-  }
-  input(schema, example) {
-    return new _DecoratedContractProcedure({
-      ...this.zz$cp,
-      InputSchema: schema,
-      inputExample: example
-    });
-  }
-  output(schema, example) {
-    return new _DecoratedContractProcedure({
-      ...this.zz$cp,
-      OutputSchema: schema,
-      outputExample: example
-    });
-  }
-};
-function isContractProcedure(item) {
-  if (item instanceof ContractProcedure)
-    return true;
-  return (typeof item === "object" || typeof item === "function") && item !== null && "zz$cp" in item && typeof item.zz$cp === "object" && item.zz$cp !== null && "InputSchema" in item.zz$cp && "OutputSchema" in item.zz$cp;
-}
-
-// src/router-builder.ts
-var ContractRouterBuilder = class _ContractRouterBuilder {
-  constructor(zz$crb) {
-    this.zz$crb = zz$crb;
-    if (zz$crb.prefix && zz$crb.prefix.includes("{")) {
-      throw new Error('Prefix cannot contain "{" for dynamic routing');
-    }
-  }
-  prefix(prefix) {
-    return new _ContractRouterBuilder({
-      ...this.zz$crb,
-      prefix: `${this.zz$crb.prefix ?? ""}${prefix}`
-    });
-  }
-  tags(...tags) {
-    if (!tags.length)
-      return this;
-    return new _ContractRouterBuilder({
-      ...this.zz$crb,
-      tags: [...this.zz$crb.tags ?? [], ...tags]
-    });
-  }
-  router(router) {
-    const handled = {};
-    for (const key in router) {
-      const item = router[key];
-      if (isContractProcedure(item)) {
-        const decorated = DecoratedContractProcedure.decorate(item).addTags(
-          ...this.zz$crb.tags ?? []
-        );
-        handled[key] = this.zz$crb.prefix ? decorated.prefix(this.zz$crb.prefix) : decorated;
-      } else {
-        handled[key] = this.router(item);
-      }
-    }
-    return handled;
-  }
-};
-
-// src/builder.ts
-var ContractBuilder = class {
-  prefix(prefix) {
-    return new ContractRouterBuilder({
-      prefix
-    });
-  }
-  tags(...tags) {
-    return new ContractRouterBuilder({
-      tags
-    });
-  }
-  route(opts) {
-    return new DecoratedContractProcedure({
-      InputSchema: void 0,
-      OutputSchema: void 0,
-      ...opts
-    });
-  }
-  input(schema, example) {
-    return new DecoratedContractProcedure({
-      InputSchema: schema,
-      inputExample: example,
-      OutputSchema: void 0
-    });
-  }
-  output(schema, example) {
-    return new DecoratedContractProcedure({
-      InputSchema: void 0,
-      OutputSchema: schema,
-      outputExample: example
-    });
-  }
-  router(router) {
-    return router;
-  }
-};
-
-// src/constants.ts
-var ORPC_HEADER = "x-orpc-transformer";
-var ORPC_HEADER_VALUE = "t";
-
-// src/router.ts
-function eachContractRouterLeaf(router, callback, prefix = []) {
-  for (const key in router) {
-    const item = router[key];
-    if (isContractProcedure(item)) {
-      callback(item, [...prefix, key]);
-    } else {
-      eachContractRouterLeaf(item, callback, [...prefix, key]);
-    }
-  }
-}
-
-// src/utils.ts
-function standardizeHTTPPath(path) {
-  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
-}
-function prefixHTTPPath(prefix, path) {
-  const prefix_ = standardizeHTTPPath(prefix);
-  const path_ = standardizeHTTPPath(path);
-  if (prefix_ === "/")
-    return path_;
-  if (path_ === "/")
-    return prefix_;
-  return `${prefix_}${path_}`;
-}
-
-// src/index.ts
-var oc = new ContractBuilder();
-export {
-  ContractBuilder,
-  ContractProcedure,
-  DecoratedContractProcedure,
-  ORPC_HEADER,
-  ORPC_HEADER_VALUE,
-  eachContractRouterLeaf,
-  isContractProcedure,
-  oc,
-  prefixHTTPPath,
-  standardizeHTTPPath
-};
-//# sourceMappingURL=index.js.map

package/dist/src/builder.d.ts

@@ -1,13 +0,0 @@
-import type { ContractRouter } from './router';
-import type { HTTPPath, Schema, SchemaInput, SchemaOutput } from './types';
-import { DecoratedContractProcedure, type RouteOptions } from './procedure';
-import { ContractRouterBuilder } from './router-builder';
-export declare class ContractBuilder {
-    prefix(prefix: HTTPPath): ContractRouterBuilder;
-    tags(...tags: string[]): ContractRouterBuilder;
-    route(opts: RouteOptions): DecoratedContractProcedure<undefined, undefined>;
-    input<USchema extends Schema>(schema: USchema, example?: SchemaInput<USchema>): DecoratedContractProcedure<USchema, undefined>;
-    output<USchema extends Schema>(schema: USchema, example?: SchemaOutput<USchema>): DecoratedContractProcedure<undefined, USchema>;
-    router<T extends ContractRouter>(router: T): T;
-}
-//# sourceMappingURL=builder.d.ts.map

package/dist/src/constants.d.ts

@@ -1,3 +0,0 @@
-export declare const ORPC_HEADER = "x-orpc-transformer";
-export declare const ORPC_HEADER_VALUE = "t";
-//# sourceMappingURL=constants.d.ts.map

package/dist/src/index.d.ts

@@ -1,10 +0,0 @@
-/** unnoq */
-import { ContractBuilder } from './builder';
-export * from './builder';
-export * from './constants';
-export * from './procedure';
-export * from './router';
-export * from './types';
-export * from './utils';
-export declare const oc: ContractBuilder;
-//# sourceMappingURL=index.d.ts.map

package/dist/src/procedure.d.ts

@@ -1,47 +0,0 @@
-import type { HTTPMethod, HTTPPath, Schema, SchemaInput, SchemaOutput } from './types';
-export interface RouteOptions {
-    method?: HTTPMethod;
-    path?: HTTPPath;
-    summary?: string;
-    description?: string;
-    deprecated?: boolean;
-    tags?: string[];
-}
-export declare class ContractProcedure<TInputSchema extends Schema, TOutputSchema extends Schema> {
-    zz$cp: {
-        path?: HTTPPath;
-        method?: HTTPMethod;
-        summary?: string;
-        description?: string;
-        deprecated?: boolean;
-        tags?: string[];
-        InputSchema: TInputSchema;
-        inputExample?: SchemaOutput<TInputSchema>;
-        OutputSchema: TOutputSchema;
-        outputExample?: SchemaOutput<TOutputSchema>;
-    };
-    constructor(zz$cp: {
-        path?: HTTPPath;
-        method?: HTTPMethod;
-        summary?: string;
-        description?: string;
-        deprecated?: boolean;
-        tags?: string[];
-        InputSchema: TInputSchema;
-        inputExample?: SchemaOutput<TInputSchema>;
-        OutputSchema: TOutputSchema;
-        outputExample?: SchemaOutput<TOutputSchema>;
-    });
-}
-export type WELL_CONTRACT_PROCEDURE = ContractProcedure<Schema, Schema>;
-export declare class DecoratedContractProcedure<TInputSchema extends Schema, TOutputSchema extends Schema> extends ContractProcedure<TInputSchema, TOutputSchema> {
-    static decorate<TInputSchema extends Schema, TOutputSchema extends Schema>(cp: ContractProcedure<TInputSchema, TOutputSchema>): DecoratedContractProcedure<TInputSchema, TOutputSchema>;
-    route(opts: RouteOptions): DecoratedContractProcedure<TInputSchema, TOutputSchema>;
-    prefix(prefix: HTTPPath): DecoratedContractProcedure<TInputSchema, TOutputSchema>;
-    addTags(...tags: string[]): DecoratedContractProcedure<TInputSchema, TOutputSchema>;
-    input<USchema extends Schema>(schema: USchema, example?: SchemaInput<USchema>): DecoratedContractProcedure<USchema, TOutputSchema>;
-    output<USchema extends Schema>(schema: USchema, example?: SchemaOutput<USchema>): DecoratedContractProcedure<TInputSchema, USchema>;
-}
-export type WELL_DEFINED_CONTRACT_PROCEDURE = ContractProcedure<Schema, Schema>;
-export declare function isContractProcedure(item: unknown): item is WELL_DEFINED_CONTRACT_PROCEDURE;
-//# sourceMappingURL=procedure.d.ts.map

package/dist/src/router-builder.d.ts

@@ -1,16 +0,0 @@
-import type { ContractRouter, HandledContractRouter } from './router';
-import type { HTTPPath } from './types';
-export declare class ContractRouterBuilder {
-    zz$crb: {
-        prefix?: HTTPPath;
-        tags?: string[];
-    };
-    constructor(zz$crb: {
-        prefix?: HTTPPath;
-        tags?: string[];
-    });
-    prefix(prefix: HTTPPath): ContractRouterBuilder;
-    tags(...tags: string[]): ContractRouterBuilder;
-    router<T extends ContractRouter>(router: T): HandledContractRouter<T>;
-}
-//# sourceMappingURL=router-builder.d.ts.map

package/dist/src/router.d.ts

@@ -1,16 +0,0 @@
-import type { SchemaInput, SchemaOutput } from './types';
-import { type ContractProcedure, type DecoratedContractProcedure, type WELL_DEFINED_CONTRACT_PROCEDURE } from './procedure';
-export interface ContractRouter {
-    [k: string]: ContractProcedure<any, any> | ContractRouter;
-}
-export type HandledContractRouter<TContract extends ContractRouter> = {
-    [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? DecoratedContractProcedure<UInputSchema, UOutputSchema> : TContract[K] extends ContractRouter ? HandledContractRouter<TContract[K]> : never;
-};
-export declare function eachContractRouterLeaf(router: ContractRouter, callback: (item: WELL_DEFINED_CONTRACT_PROCEDURE, path: string[]) => void, prefix?: string[]): void;
-export type InferContractRouterInputs<T extends ContractRouter> = {
-    [K in keyof T]: T[K] extends ContractProcedure<infer UInputSchema, any> ? SchemaInput<UInputSchema> : T[K] extends ContractRouter ? InferContractRouterInputs<T[K]> : never;
-};
-export type InferContractRouterOutputs<T extends ContractRouter> = {
-    [K in keyof T]: T[K] extends ContractProcedure<any, infer UOutputSchema> ? SchemaOutput<UOutputSchema> : T[K] extends ContractRouter ? InferContractRouterOutputs<T[K]> : never;
-};
-//# sourceMappingURL=router.d.ts.map

package/dist/src/types.d.ts

@@ -1,8 +0,0 @@
-import type { input, output, ZodType } from 'zod';
-export type HTTPPath = `/${string}`;
-export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-export type HTTPStatus = number;
-export type Schema = ZodType<any, any, any> | undefined;
-export type SchemaInput<TSchema extends Schema, TFallback = unknown> = TSchema extends undefined ? TFallback : TSchema extends ZodType<any, any, any> ? input<TSchema> : TFallback;
-export type SchemaOutput<TSchema extends Schema, TFallback = unknown> = TSchema extends undefined ? TFallback : TSchema extends ZodType<any, any, any> ? output<TSchema> : TFallback;
-//# sourceMappingURL=types.d.ts.map

package/dist/src/utils.d.ts

@@ -1,4 +0,0 @@
-import type { HTTPPath } from './types';
-export declare function standardizeHTTPPath(path: HTTPPath): HTTPPath;
-export declare function prefixHTTPPath(prefix: HTTPPath, path: HTTPPath): HTTPPath;
-//# sourceMappingURL=utils.d.ts.map