@orpc/contract 0.0.0-next.e9dc36e → 0.0.0-next.eb37cbe

package/src/builder.test.ts

@@ -1,179 +0,0 @@
-import { z } from 'zod'
-import { type DecoratedContractProcedure, oc } from '.'
-
-describe('define a procedure', () => {
-  it('use route method', () => {
-    const procedure = oc.route({
-      method: 'GET',
-      path: '/users/{id}',
-      deprecated: true,
-      summary: 'Get user',
-      description: 'Get user by id',
-      tags: ['bbbb'],
-    })
-
-    expectTypeOf(procedure).toEqualTypeOf<
-      DecoratedContractProcedure<undefined, undefined>
-    >()
-
-    expect(procedure.zz$cp).toMatchObject({
-      method: 'GET',
-      path: '/users/{id}',
-      deprecated: true,
-      summary: 'Get user',
-      description: 'Get user by id',
-      tags: ['bbbb'],
-    })
-  })
-
-  it('use input method', () => {
-    const schema = z.object({
-      id: z.string(),
-    })
-
-    const procedure = oc.input(schema, { id: '123' })
-
-    expectTypeOf(procedure).toEqualTypeOf<
-      DecoratedContractProcedure<typeof schema, undefined>
-    >()
-
-    expect(procedure.zz$cp).toMatchObject({
-      InputSchema: schema,
-      inputExample: { id: '123' },
-    })
-  })
-
-  it('use output method', () => {
-    const schema = z.object({ id: z.string() })
-
-    const procedure = oc.output(schema, { id: '123' })
-
-    expectTypeOf(procedure).toEqualTypeOf<
-      DecoratedContractProcedure<undefined, typeof schema>
-    >()
-
-    expect(procedure.zz$cp).toMatchObject({
-      OutputSchema: schema,
-      outputExample: { id: '123' },
-    })
-  })
-})
-
-describe('define a router', () => {
-  it('simple', () => {
-    const schema1 = z.string()
-    const schema2 = z.object({ id: z.string() })
-    const ping = oc.output(schema1)
-    const find = oc.output(schema2)
-
-    const router = oc.router({
-      ping,
-      user: {
-        find,
-      },
-      user2: oc.router({
-        find,
-      }),
-    })
-
-    expectTypeOf(router).toMatchTypeOf<{
-      ping: typeof ping
-      user: {
-        find: typeof find
-      }
-      user2: {
-        find: typeof find
-      }
-    }>()
-
-    expect(router).toMatchObject({
-      ping,
-      user: {
-        find,
-      },
-      user2: {
-        find,
-      },
-    })
-  })
-
-  it('with prefix', () => {
-    const schema1 = z.string()
-    const schema2 = z.object({ id: z.string() })
-    const ping = oc.output(schema1)
-    const find = oc.output(schema2)
-
-    const router = oc.router({
-      ping: ping.prefix('/ping'),
-      user: {
-        find,
-      },
-      user2: oc
-        .prefix('/internal')
-        .prefix('/user2')
-        .router({
-          find2: find.prefix('/find2'),
-        }),
-    })
-
-    expectTypeOf(router).toMatchTypeOf<{
-      ping: typeof ping
-      user: {
-        find: typeof find
-      }
-      user2: {
-        find2: typeof find
-      }
-    }>()
-
-    expect(router).toMatchObject({
-      ping: ping.prefix('/ping'),
-      user: {
-        find,
-      },
-      user2: {
-        find2: find.prefix('/internal/user2/find2'),
-      },
-    })
-  })
-
-  it('with tags', () => {
-    const schema1 = z.string()
-    const schema2 = z.object({ id: z.string() })
-    const ping = oc.output(schema1)
-    const find = oc.output(schema2)
-
-    const router = oc.router({
-      ping: ping.prefix('/ping'),
-      user: {
-        find,
-      },
-      user2: oc
-        .tags('user')
-        .tags('internal')
-        .router({
-          find2: find.prefix('/find2'),
-        }),
-    })
-
-    expectTypeOf(router).toMatchTypeOf<{
-      ping: typeof ping
-      user: {
-        find: typeof find
-      }
-      user2: {
-        find2: typeof find
-      }
-    }>()
-
-    expect(router).toMatchObject({
-      ping: ping.prefix('/ping'),
-      user: {
-        find,
-      },
-      user2: {
-        find2: find.addTags('user', 'internal'),
-      },
-    })
-  })
-})

package/src/builder.ts

@@ -1,52 +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 class ContractBuilder {
-  prefix(prefix: HTTPPath): ContractRouterBuilder {
-    return new ContractRouterBuilder({
-      prefix,
-    })
-  }
-
-  tags(...tags: string[]): ContractRouterBuilder {
-    return new ContractRouterBuilder({
-      tags,
-    })
-  }
-
-  route(opts: RouteOptions): DecoratedContractProcedure<undefined, undefined> {
-    return new DecoratedContractProcedure({
-      InputSchema: undefined,
-      OutputSchema: undefined,
-      ...opts,
-    })
-  }
-
-  input<USchema extends Schema>(
-    schema: USchema,
-    example?: SchemaInput<USchema>,
-  ): DecoratedContractProcedure<USchema, undefined> {
-    return new DecoratedContractProcedure({
-      InputSchema: schema,
-      inputExample: example,
-      OutputSchema: undefined,
-    })
-  }
-
-  output<USchema extends Schema>(
-    schema: USchema,
-    example?: SchemaOutput<USchema>,
-  ): DecoratedContractProcedure<undefined, USchema> {
-    return new DecoratedContractProcedure({
-      InputSchema: undefined,
-      OutputSchema: schema,
-      outputExample: example,
-    })
-  }
-
-  router<T extends ContractRouter>(router: T): T {
-    return router
-  }
-}

package/src/constants.ts

@@ -1,2 +0,0 @@
-export const ORPC_HEADER = 'x-orpc-transformer'
-export const ORPC_HEADER_VALUE = 't'

package/src/index.ts

@@ -1,12 +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 const oc = new ContractBuilder()

package/src/procedure.test.ts

@@ -1,99 +0,0 @@
-import type { DecoratedContractProcedure } from './procedure'
-import { z } from 'zod'
-import { isContractProcedure, oc } from '.'
-
-it('prefix method', () => {
-  const os = oc
-  const p1 = os.route({
-    method: 'GET',
-    path: '/ping',
-  })
-  const p2 = os.input(z.object({}))
-
-  expect(p1.prefix('/prefix').zz$cp.path).toEqual('/prefix/ping')
-  expect(p2.prefix('/prefix').zz$cp.path).toEqual(undefined)
-
-  expect(p1.prefix('/1').prefix('/2').zz$cp.path).toEqual('/2/1/ping')
-  expect(p2.prefix('/1').prefix('/2').zz$cp.path).toEqual(undefined)
-})
-
-it('route method', () => {
-  const p = oc
-    .route({
-      method: 'POST',
-    })
-    .route({
-      method: 'GET',
-      path: '/abc',
-      deprecated: true,
-      description: 'abc',
-      summary: 'abc',
-      tags: ['user'],
-    })
-
-  expectTypeOf(p).toEqualTypeOf<
-    DecoratedContractProcedure<undefined, undefined>
-  >()
-
-  expect(p.zz$cp).toMatchObject({
-    method: 'GET',
-    path: '/abc',
-    deprecated: true,
-    description: 'abc',
-    summary: 'abc',
-    tags: ['user'],
-  })
-})
-
-it('input method', () => {
-  const schema = z.string()
-  const p = oc.route({}).input(schema)
-
-  expectTypeOf(p).toEqualTypeOf<
-    DecoratedContractProcedure<typeof schema, undefined>
-  >()
-
-  expect(p.zz$cp).toMatchObject({
-    InputSchema: schema,
-    inputExample: undefined,
-  })
-})
-
-it('output method', () => {
-  const schema = z.string()
-  const p = oc.route({}).output(schema)
-
-  expectTypeOf(p).toEqualTypeOf<
-    DecoratedContractProcedure<undefined, typeof schema>
-  >()
-
-  expect(p.zz$cp).toMatchObject({
-    OutputSchema: schema,
-    outputExample: undefined,
-  })
-})
-
-it('addTags method', () => {
-  const schema = z.string()
-  const p = oc.route({}).output(schema)
-
-  expect(p.zz$cp.tags).toBe(undefined)
-
-  const p2 = p.addTags('foo', 'bar')
-
-  expect(p2.zz$cp.tags).toEqual(['foo', 'bar'])
-
-  const p3 = p2.addTags('baz')
-
-  expect(p3.zz$cp.tags).toEqual(['foo', 'bar', 'baz'])
-})
-
-it('isContractProcedure function', () => {
-  expect(isContractProcedure(oc)).toBe(false)
-  expect(isContractProcedure(oc.router({}))).toBe(false)
-  expect(isContractProcedure(oc.route({}))).toBe(true)
-
-  expect(isContractProcedure(oc.router({ prefix: oc.route({}) }).prefix)).toBe(
-    true,
-  )
-})

package/src/procedure.ts

@@ -1,125 +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 class ContractProcedure<
-  TInputSchema extends Schema,
-  TOutputSchema extends Schema,
-> {
-  constructor(
-    public 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 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> {
-    if (cp instanceof DecoratedContractProcedure)
-      return cp
-    return new DecoratedContractProcedure(cp.zz$cp)
-  }
-
-  route(
-    opts: RouteOptions,
-  ): DecoratedContractProcedure<TInputSchema, TOutputSchema> {
-    return new DecoratedContractProcedure({
-      ...this.zz$cp,
-      ...opts,
-      method: opts.method,
-      path: opts.path,
-    })
-  }
-
-  prefix(
-    prefix: HTTPPath,
-  ): DecoratedContractProcedure<TInputSchema, TOutputSchema> {
-    if (!this.zz$cp.path)
-      return this
-
-    return new DecoratedContractProcedure({
-      ...this.zz$cp,
-      path: `${prefix}${this.zz$cp.path}`,
-    })
-  }
-
-  addTags(
-    ...tags: string[]
-  ): DecoratedContractProcedure<TInputSchema, TOutputSchema> {
-    if (!tags.length)
-      return this
-
-    return new DecoratedContractProcedure({
-      ...this.zz$cp,
-      tags: [...(this.zz$cp.tags ?? []), ...tags],
-    })
-  }
-
-  input<USchema extends Schema>(
-    schema: USchema,
-    example?: SchemaInput<USchema>,
-  ): DecoratedContractProcedure<USchema, TOutputSchema> {
-    return new DecoratedContractProcedure({
-      ...this.zz$cp,
-      InputSchema: schema,
-      inputExample: example,
-    })
-  }
-
-  output<USchema extends Schema>(
-    schema: USchema,
-    example?: SchemaOutput<USchema>,
-  ): DecoratedContractProcedure<TInputSchema, USchema> {
-    return new DecoratedContractProcedure({
-      ...this.zz$cp,
-      OutputSchema: schema,
-      outputExample: example,
-    })
-  }
-}
-
-export type WELL_DEFINED_CONTRACT_PROCEDURE = ContractProcedure<Schema, Schema>
-
-export function isContractProcedure(
-  item: unknown,
-): item is WELL_DEFINED_CONTRACT_PROCEDURE {
-  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
-  )
-}

package/src/router-builder.test.ts

@@ -1,70 +0,0 @@
-import { z } from 'zod'
-import { ContractProcedure, DecoratedContractProcedure, oc } from '.'
-import { ContractRouterBuilder } from './router-builder'
-
-it('prefix method', () => {
-  expect(oc.prefix('/1').prefix('/2').zz$crb.prefix).toEqual('/1/2')
-})
-
-it('tags method', () => {
-  expect(oc.tags('1').tags('2').zz$crb.tags).toEqual(['1', '2'])
-})
-
-it('define a router', () => {
-  const ping = oc.route({ method: 'GET', path: '/ping' })
-  const pong = oc.input(z.object({ id: z.string() }))
-
-  const router = oc.router({
-    ping,
-    pong,
-
-    internal: oc
-      .prefix('/internal')
-      .tags('internal')
-      .router({
-        ping,
-        pong,
-
-        nested: {
-          ping,
-        },
-      }),
-  })
-
-  expect(router.ping.zz$cp.path).toEqual('/ping')
-  expect(router.pong.zz$cp.path).toEqual(undefined)
-
-  expect(router.internal.ping.zz$cp.path).toEqual('/internal/ping')
-  expect(router.internal.pong.zz$cp.path).toEqual(undefined)
-  expect(router.internal.nested.ping.zz$cp.path).toEqual('/internal/ping')
-
-  expect(router.internal.ping.zz$cp.tags).toEqual(['internal'])
-  expect(router.internal.pong.zz$cp.tags).toEqual(['internal'])
-  expect(router.internal.nested.ping.zz$cp.tags).toEqual(['internal'])
-})
-
-it('router: decorate items', () => {
-  const builder = new ContractRouterBuilder({})
-
-  const ping = new ContractProcedure({
-    InputSchema: undefined,
-    OutputSchema: undefined,
-  })
-
-  const decorated = new DecoratedContractProcedure({
-    InputSchema: undefined,
-    OutputSchema: undefined,
-    method: 'GET',
-    path: '/ping',
-  })
-
-  const router = builder.router({ ping, nested: { ping } })
-
-  expectTypeOf(router).toEqualTypeOf<{
-    ping: typeof decorated
-    nested: { ping: typeof decorated }
-  }>()
-
-  expect(router.ping).instanceOf(DecoratedContractProcedure)
-  expect(router.nested.ping).instanceOf(DecoratedContractProcedure)
-})

package/src/router-builder.ts

@@ -1,46 +0,0 @@
-import type { ContractRouter, HandledContractRouter } from './router'
-import type { HTTPPath } from './types'
-import { DecoratedContractProcedure, isContractProcedure } from './procedure'
-
-export class ContractRouterBuilder {
-  constructor(public zz$crb: { prefix?: HTTPPath, tags?: string[] }) {}
-
-  prefix(prefix: HTTPPath): ContractRouterBuilder {
-    return new ContractRouterBuilder({
-      ...this.zz$crb,
-      prefix: `${this.zz$crb.prefix ?? ''}${prefix}`,
-    })
-  }
-
-  tags(...tags: string[]): ContractRouterBuilder {
-    if (!tags.length)
-      return this
-
-    return new ContractRouterBuilder({
-      ...this.zz$crb,
-      tags: [...(this.zz$crb.tags ?? []), ...tags],
-    })
-  }
-
-  router<T extends ContractRouter>(router: T): HandledContractRouter<T> {
-    const handled: ContractRouter = {}
-
-    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 as ContractRouter)
-      }
-    }
-
-    return handled as HandledContractRouter<T>
-  }
-}

package/src/router.test-d.ts

@@ -1,63 +0,0 @@
-import type { InferContractRouterInputs, InferContractRouterOutputs } from '.'
-import { z } from 'zod'
-import { oc } from '.'
-
-const router = {
-  ping: oc.route({
-    method: 'GET',
-    path: '/ping',
-  })
-    .input(z.object({
-      ping: z.string().transform(() => 1),
-    }))
-    .output(z.object({
-      pong: z.string().transform(() => 1),
-    })),
-  user: {
-    find: oc.route({
-      method: 'GET',
-      path: '/users/{id}',
-    })
-      .input(z.object({
-        find: z.number().transform(() => '1'),
-      }))
-      .output(z.object({
-        user: z.object({
-          id: z.number().transform(() => '1'),
-        }),
-      }))
-    ,
-  },
-}
-
-it('InferContractRouterInputs', () => {
-  type Inputs = InferContractRouterInputs<typeof router>
-
-  expectTypeOf<Inputs>().toEqualTypeOf<{
-    ping: {
-      ping: string
-    }
-    user: {
-      find: {
-        find: number
-      }
-    }
-  }>()
-})
-
-it('InferContractRouterOutputs', () => {
-  type Outputs = InferContractRouterOutputs<typeof router>
-
-  expectTypeOf<Outputs>().toEqualTypeOf<{
-    ping: {
-      pong: number
-    }
-    user: {
-      find: {
-        user: {
-          id: string
-        }
-      }
-    }
-  }>()
-})

package/src/router.test.ts

@@ -1,24 +0,0 @@
-import { eachContractRouterLeaf, oc } from '.'
-
-it('each router leaf', () => {
-  const router = {
-    ping: oc.route({
-      method: 'GET',
-      path: '/ping',
-    }),
-    user: {
-      find: oc.route({
-        method: 'GET',
-        path: '/users/{id}',
-      }),
-    },
-  }
-
-  const calls: string[] = []
-
-  eachContractRouterLeaf(router, (procedure, path) => {
-    calls.push(path.join('.'))
-  })
-
-  expect(calls).toEqual(['ping', 'user.find'])
-})