[Only merge on next major]: Remove deprecations

src/constructors.ts

@@ -144,16 +144,6 @@ function applySchema<ParsedInput, ParsedContext>(
   }
 }
 
-/**
- * @deprecated use `applySchema` instead
- */
-function withSchema<ParsedInput, ParsedContext>(
-  inputSchema?: StandardSchema<unknown, ParsedInput>,
-  contextSchema?: StandardSchema<unknown, ParsedContext>,
-) {
-  return applySchema(inputSchema, contextSchema)
-}
-
 const alwaysUnknownSchema: StandardSchema<unknown, unknown> = {
   '~standard': {
     vendor: 'composable-functions',
@@ -164,4 +154,4 @@ const alwaysUnknownSchema: StandardSchema<unknown, unknown> = {
   },
 }
 
-export { applySchema, composable, failure, fromSuccess, success, withSchema }
+export { applySchema, composable, failure, fromSuccess, success }

src/errors.ts

@@ -19,28 +19,6 @@ class InputError extends Error {
   }
 }
 
-/**
- * @deprecated Use `ContextError` instead
- * A custom error class for context errors.
- *
- * @example
- * const fn = () => {
- *  throw new EnvironmentError('Invalid environment', 'user.name')
- * }
- */
-class EnvironmentError extends Error {
-  /**
-   * Path of context attribute that originated the error.
-   */
-  path: string[]
-
-  constructor(message: string, path: string[] = []) {
-    super(message)
-    this.name = 'EnvironmentError'
-    this.path = path
-  }
-}
-
 /**
  * A custom error class for context errors.
  *
@@ -87,25 +65,11 @@ function isInputError(e: { name: string; message: string }): boolean {
   return e.name === 'InputError'
 }
 
-/**
- * @deprecated Use `isContextError` instead
- * A function to check if an `Error` or a `SerializableError` is a ContextError
- */
-const isEnvironmentError = isContextError
-
 /**
  * A function to check if an `Error` or a `SerializableError` is a ContextError
  */
 function isContextError(e: { name: string; message: string }): boolean {
-  return e.name === 'EnvironmentError' || e.name === 'ContextError'
+  return e.name === 'ContextError'
 }
 
-export {
-  ContextError,
-  EnvironmentError,
-  ErrorList,
-  InputError,
-  isContextError,
-  isEnvironmentError,
-  isInputError,
-}
+export { ContextError, ErrorList, InputError, isContextError, isInputError }

src/index.ts

@@ -4,7 +4,6 @@ export {
   failure,
   fromSuccess,
   success,
-  withSchema,
 } from './constructors.ts'
 export {
   all,
@@ -33,11 +32,9 @@ export type {
 export { serialize, serializeError } from './serializer.ts'
 export {
   ContextError,
-  EnvironmentError,
   ErrorList,
   InputError,
   isContextError,
-  isEnvironmentError,
   isInputError,
 } from './errors.ts'
 export type {
@@ -63,6 +60,4 @@ export type {
 } from './types.ts'
 
 // FUNCTIONS WITH CONTEXT
-export { environment } from './context/environment.ts'
-export { context } from './context/context.ts'
 export * as withContext from './context/index.ts'

src/tests/constructors.test.ts

@@ -21,7 +21,6 @@ import {
   fromSuccess,
   InputError,
   success,
-  withSchema,
 } from '../index.ts'
 import { applySchema } from '../index.ts'
 import type { Internal } from '../internal/types.ts'
@@ -172,17 +171,17 @@ describe('fromSuccess', () => {
   })
 })
 
-describe('withSchema', () => {
+describe('applySchema', () => {
   describe('when it has no input', () => {
     it('uses zod parser to create parse the input and call the schema function', async () => {
-      const handler = withSchema()(() => 'no input!')
+      const handler = applySchema()(() => 'no input!')
       type _R = Expect<Equal<typeof handler, ComposableWithSchema<string>>>
 
       assertEquals(await handler(), success('no input!'))
     })
 
     it('defaults non-declared input to unknown', async () => {
-      const handler = withSchema()((args) => args)
+      const handler = applySchema()((args) => args)
       type _R = Expect<Equal<typeof handler, ComposableWithSchema<unknown>>>
 
       assertEquals(await handler('some input'), {
@@ -194,25 +193,16 @@ describe('withSchema', () => {
   })
 
   describe('when it has no context', () => {
-    it('uses zod parser to create parse the input and call the schema function', async () => {
-      const parser = z.object({ id: z.preprocess(Number, z.number()) })
-
-      const handler = withSchema(parser)(({ id }) => id)
-      type _R = Expect<Equal<typeof handler, ComposableWithSchema<number>>>
-
-      assertEquals(await handler({ id: '1' }), success(1))
-    })
-
     it('fails gracefully if gets something other than empty record', async () => {
-      const handler = withSchema()(() => 'no input!')
+      const handler = applySchema()(() => 'no input!')
       type _R = Expect<Equal<typeof handler, ComposableWithSchema<string>>>
 
       assertEquals(await handler(undefined, ''), success('no input!'))
     })
 
     it('returns error when parsing fails', async () => {
       const parser = z.object({ id: z.preprocess(Number, z.number()) })
-      const handler = withSchema(parser)(({ id }) => id)
+      const handler = applySchema(parser)(({ id }) => id)
       type _R = Expect<Equal<typeof handler, ComposableWithSchema<number>>>
 
       assertEquals(
@@ -223,45 +213,12 @@ describe('withSchema', () => {
   })
 
   it('accepts a composable', async () => {
-    const handler = withSchema()(composable(() => 'no input!'))
+    const handler = applySchema()(composable(() => 'no input!'))
     type _R = Expect<Equal<typeof handler, ComposableWithSchema<string>>>
 
     assertEquals(await handler(), success('no input!'))
   })
 
-  it('defaults non-declared input to unknown', async () => {
-    const handler = withSchema()((args) => args)
-    type _R = Expect<Equal<typeof handler, ComposableWithSchema<unknown>>>
-
-    assertEquals(await handler('some input'), {
-      success: true,
-      data: 'some input',
-      errors: [],
-    })
-  })
-
-  it('uses zod parsers to parse the input and context and call the schema function', async () => {
-    const parser = z.object({ id: z.preprocess(Number, z.number()) })
-    const ctxParser = z.object({ uid: z.preprocess(Number, z.number()) })
-
-    const handler = withSchema(
-      parser,
-      ctxParser,
-    )(({ id }, { uid }) => [id, uid] as const)
-    type _R = Expect<
-      Equal<
-        typeof handler,
-        Composable<
-          (input?: unknown, context?: unknown) => readonly [number, number]
-        >
-      >
-    >
-
-    assertEquals(await handler({ id: '1' }, { uid: '2' }), success([1, 2]))
-  })
-})
-
-describe('applySchema', () => {
   it('uses zod parsers to parse the input and context turning it into a schema function', async () => {
     const inputSchema = z.object({ id: z.preprocess(Number, z.number()) })
     const ctxSchema = z.object({ uid: z.preprocess(Number, z.number()) })

src/tests/errors.test.ts

@@ -1,10 +1,8 @@
 import { assertEquals, describe, it } from './prelude.ts'
 import {
   ContextError,
-  EnvironmentError,
   InputError,
   isContextError,
-  isEnvironmentError,
   isInputError,
 } from '../index.ts'
 
@@ -13,7 +11,6 @@ describe('isInputError', () => {
     assertEquals(isInputError(new Error('No')), false)
     assertEquals(isInputError(new InputError('Yes')), true)
     assertEquals(isInputError(new ContextError('No')), false)
-    assertEquals(isInputError(new EnvironmentError('No')), false)
   })
 })
 
@@ -22,13 +19,5 @@ describe('isContextError', () => {
     assertEquals(isContextError(new Error('No')), false)
     assertEquals(isContextError(new InputError('No')), false)
     assertEquals(isContextError(new ContextError('Yes')), true)
-    assertEquals(isContextError(new EnvironmentError('Yes')), true)
-  })
-
-  it('checks if an error is instance of legacy EnvironmentError', () => {
-    assertEquals(isEnvironmentError(new Error('No')), false)
-    assertEquals(isEnvironmentError(new InputError('No')), false)
-    assertEquals(isEnvironmentError(new ContextError('Yes')), true)
-    assertEquals(isEnvironmentError(new EnvironmentError('Yes')), true)
   })
 })