@atproto/lex-schema 0.0.8 → 0.0.10

package/src/schema/params.ts

@@ -1,40 +1,58 @@
 import { isPlainObject } from '@atproto/lex-data'
 import {
   Infer,
+  InferInput,
+  InferOutput,
   Schema,
-  ValidationResult,
+  ValidationContext,
   Validator,
-  ValidatorContext,
   WithOptionalProperties,
 } from '../core.js'
 import { lazyProperty } from '../util/lazy-property.js'
-import { Param, ParamScalar, paramSchema } from './_parameters.js'
-import { StringSchema } from './string.js'
-
-export type ParamsSchemaShape = Record<string, Validator<Param | undefined>>
+import { memoizedOptions } from '../util/memoize.js'
+import { array } from './array.js'
+import { boolean } from './boolean.js'
+import { dict } from './dict.js'
+import { integer } from './integer.js'
+import { optional } from './optional.js'
+import { StringSchema, string } from './string.js'
+import { union } from './union.js'
+
+export type ParamScalar = Infer<typeof paramScalarSchema>
+const paramScalarSchema = union([boolean(), integer(), string()])
+
+export type Param = Infer<typeof paramSchema>
+export const paramSchema = union([paramScalarSchema, array(paramScalarSchema)])
+
+export type Params = Infer<typeof paramsSchema>
+export const paramsSchema = dict(string(), optional(paramSchema))
+
+export type ParamsSchemaShape = {
+  [x: string]: Validator<Param | undefined>
+}
 
-export type ParamsSchemaOutput<Shape extends ParamsSchemaShape> =
+export class ParamsSchema<
+  const TShape extends ParamsSchemaShape = ParamsSchemaShape,
+> extends Schema<
+  WithOptionalProperties<{
+    [K in keyof TShape]: InferInput<TShape[K]>
+  }>,
   WithOptionalProperties<{
-    [K in keyof Shape]: Infer<Shape[K]>
+    [K in keyof TShape]: InferOutput<TShape[K]>
   }>
-
-export class ParamsSchema<
-  const Shape extends ParamsSchemaShape = ParamsSchemaShape,
-> extends Schema<ParamsSchemaOutput<Shape>> {
-  constructor(readonly validators: Shape) {
+> {
+  constructor(readonly shape: TShape) {
     super()
   }
 
-  get validatorsMap(): Map<string, Validator<Param | undefined>> {
-    const map = new Map(Object.entries(this.validators))
+  get shapeValidators(): Map<string, Validator<Param | undefined>> {
+    const map = new Map(Object.entries(this.shape))
 
-    return lazyProperty(this, 'validatorsMap', map)
+    return lazyProperty(this, 'shapeValidators', map)
   }
 
-  validateInContext(
-    input: unknown = {},
-    ctx: ValidatorContext,
-  ): ValidationResult<ParamsSchemaOutput<Shape>> {
+  validateInContext(input: unknown, ctx: ValidationContext) {
+    // @TODO BETTER SUPPORT Input/Output
     if (!isPlainObject(input)) {
       return ctx.issueInvalidType(input, 'object')
     }
@@ -44,18 +62,23 @@ export class ParamsSchema<
 
     // Ensure that non-specified params conform to param schema
     for (const key in input) {
-      if (this.validatorsMap.has(key)) continue
+      if (this.shapeValidators.has(key)) continue
 
       const result = ctx.validateChild(input, key, paramSchema)
       if (!result.success) return result
 
       if (result.value !== input[key]) {
+        if (ctx.options.mode === 'validate') {
+          // In "validate" mode, we can't modify the input, so we issue an error
+          return ctx.issueInvalidPropertyValue(input, key, [result.value])
+        }
+
         copy ??= { ...input }
         copy[key] = result.value
       }
     }
 
-    for (const [key, propDef] of this.validatorsMap) {
+    for (const [key, propDef] of this.shapeValidators) {
       const result = ctx.validateChild(input, key, propDef)
       if (!result.success) {
         if (!(key in input)) {
@@ -71,26 +94,29 @@ export class ParamsSchema<
         continue
       }
 
-      if (result.value !== input[key]) {
+      if (!Object.is(result.value, input[key])) {
+        if (ctx.options.mode === 'validate') {
+          // In "validate" mode, we can't modify the input, so we issue an error
+          return ctx.issueInvalidPropertyValue(input, key, [result.value])
+        }
+
         // Copy on write
         copy ??= { ...input }
         copy[key] = result.value
       }
     }
 
-    return ctx.success((copy ?? input) as ParamsSchemaOutput<Shape>)
+    return ctx.success(copy ?? input)
   }
 
-  fromURLSearchParams(
-    urlSearchParams: URLSearchParams,
-  ): ParamsSchemaOutput<Shape> {
+  fromURLSearchParams(urlSearchParams: URLSearchParams): InferOutput<this> {
     const params: Record<string, Param> = {}
 
     for (const [key, value] of urlSearchParams.entries()) {
-      const validator = this.validatorsMap.get(key)
+      const validator = this.shapeValidators.get(key)
 
       const coerced: ParamScalar =
-        validator != null && validator instanceof StringSchema
+        validator instanceof StringSchema
           ? value
           : value === 'true'
             ? true
@@ -112,21 +138,29 @@ export class ParamsSchema<
     return this.parse(params)
   }
 
-  toURLSearchParams(input: ParamsSchemaOutput<Shape>): URLSearchParams {
+  toURLSearchParams(input: InferInput<this>): URLSearchParams {
     const urlSearchParams = new URLSearchParams()
 
-    if (input !== undefined) {
-      for (const [key, value] of Object.entries(input)) {
-        if (Array.isArray(value)) {
-          for (const v of value) {
-            urlSearchParams.append(key, String(v))
-          }
-        } else if (value !== undefined) {
-          urlSearchParams.append(key, String(value))
+    // @NOTE We apply defaults here to ensure that server with different
+    // defaults still receive all expected parameters.
+    const params = this.parse(input)
+
+    for (const [key, value] of Object.entries(params)) {
+      if (Array.isArray(value)) {
+        for (const v of value) {
+          urlSearchParams.append(key, String(v))
         }
+      } else if (value !== undefined) {
+        urlSearchParams.append(key, String(value))
       }
     }
 
     return urlSearchParams
   }
 }
+
+export const params = /*#__PURE__*/ memoizedOptions(function params<
+  const TShape extends ParamsSchemaShape = NonNullable<unknown>,
+>(properties: TShape = {} as TShape) {
+  return new ParamsSchema<TShape>(properties)
+})