@atproto/lex-schema 0.0.1 → 0.0.3

package/src/core/types.ts

@@ -6,12 +6,6 @@ export type UnknownString = string & NonNullable<unknown>
 
 export type Simplify<T> = { [K in keyof T]: T[K] } & NonNullable<unknown>
 
-// @NOTE there is no way to express "array containing at least one P", so we use
-// "array that contains P at first or last position" as a workaround.
-export type ArrayContaining<T, Items = unknown> =
-  | readonly [T, ...Items[]]
-  | readonly [...Items[], T]
-
 declare const __restricted: unique symbol
 /**
  * A type that represents a value that cannot be used, with a custom
@@ -20,3 +14,15 @@ declare const __restricted: unique symbol
 export type Restricted<Message extends string> = typeof __restricted & {
   [__restricted]: Message
 }
+
+/**
+ * Converts all properties of `P` that are optional (i.e. may be `undefined`)
+ * into actual optional properties on the resulting type.
+ */
+export type WithOptionalProperties<P> = Simplify<
+  {
+    -readonly [K in keyof P as undefined extends P[K] ? never : K]-?: P[K]
+  } & {
+    -readonly [K in keyof P as undefined extends P[K] ? K : never]?: P[K]
+  }
+>

package/src/external.ts

@@ -1,4 +1,4 @@
-import { $Type, $type, Nsid, RecordKey } from './core.js'
+import { $Type, $TypeOf, $type, LexiconRecordKey, NsidString } from './core.js'
 import {
   ArraySchema,
   ArraySchemaOptions,
@@ -9,25 +9,27 @@ import {
   BytesSchema,
   BytesSchemaOptions,
   CidSchema,
+  CidSchemaOptions,
   CustomAssertion,
   CustomSchema,
   DictSchema,
   DiscriminatedUnionSchema,
-  DiscriminatedUnionSchemaVariants,
+  DiscriminatedUnionVariants,
   EnumSchema,
+  EnumSchemaOptions,
   IntegerSchema,
   IntegerSchemaOptions,
   IntersectionSchema,
-  IntersectionSchemaValidators,
   LiteralSchema,
+  LiteralSchemaOptions,
   NeverSchema,
   NullSchema,
+  NullableSchema,
   ObjectSchema,
-  ObjectSchemaOptions,
-  ObjectSchemaProperties,
+  ObjectSchemaShape,
+  OptionalSchema,
   ParamsSchema,
-  ParamsSchemaOptions,
-  ParamsSchemaProperties,
+  ParamsSchemaShape,
   Payload,
   PayloadBody,
   Permission,
@@ -39,6 +41,7 @@ import {
   RecordSchema,
   RefSchema,
   RefSchemaGetter,
+  RegexpSchema,
   StringSchema,
   StringSchemaOptions,
   Subscription,
@@ -52,6 +55,7 @@ import {
   UnknownObjectOutput,
   UnknownObjectSchema,
   UnknownSchema,
+  refine,
 } from './schema.js'
 import { Infer, PropertyKey, Validator } from './validation.js'
 
@@ -79,42 +83,46 @@ export { _null as null }
 /*@__NO_SIDE_EFFECTS__*/
 export function literal<const V extends null | string | number | boolean>(
   value: V,
+  options?: LiteralSchemaOptions<V>,
 ) {
-  return new LiteralSchema<V>(value)
+  return new LiteralSchema<V>(value, options)
 }
 
 /*@__NO_SIDE_EFFECTS__*/
 export function _enum<const V extends null | string | number | boolean>(
   value: readonly V[],
+  options?: EnumSchemaOptions<V>,
 ) {
-  return new EnumSchema<V>(value)
+  return new EnumSchema<V>(value, options)
 }
 
 // @NOTE "enum" is a reserved keyword in JS/TS
 export { _enum as enum }
 
 /*@__NO_SIDE_EFFECTS__*/
-export function boolean(options: BooleanSchemaOptions = {}) {
+export function boolean(options?: BooleanSchemaOptions) {
   return new BooleanSchema(options)
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-export function integer(options: IntegerSchemaOptions = {}) {
+export function integer(options?: IntegerSchemaOptions) {
   return new IntegerSchema(options)
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-export function cidLink() {
-  return new CidSchema()
+export function cidLink(options?: CidSchemaOptions) {
+  return new CidSchema(options)
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-export function bytes(options: BytesSchemaOptions = {}) {
+export function bytes(options?: BytesSchemaOptions) {
   return new BytesSchema(options)
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-export function blob(options: BlobSchemaOptions = {}) {
+export function blob<O extends BlobSchemaOptions = NonNullable<unknown>>(
+  options: O = {} as O,
+) {
   return new BlobSchema(options)
 }
 
@@ -126,29 +134,36 @@ export function string<
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-export function array<const T>(
-  items: Validator<T>,
-  options: ArraySchemaOptions = {},
-) {
-  return new ArraySchema(items, options)
+export function regexp<T extends string = string>(pattern: RegExp) {
+  return new RegexpSchema<T>(pattern)
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-export function object<
-  const P extends ObjectSchemaProperties,
-  const O extends ObjectSchemaOptions = NonNullable<unknown>,
->(
-  properties: ObjectSchemaProperties & P,
-  options: ObjectSchemaOptions & O = {} as O,
+export function array<const S extends Validator>(
+  items: S,
+  options?: ArraySchemaOptions,
+): ArraySchema<S>
+export function array<T, const S extends Validator<T> = Validator<T>>(
+  items: S,
+  options?: ArraySchemaOptions,
+): ArraySchema<S>
+export function array<const S extends Validator>(
+  items: S,
+  options?: ArraySchemaOptions,
 ) {
-  return new ObjectSchema<P, O>(properties, options)
+  return new ArraySchema<S>(items, options)
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-export function dict<const K extends Validator, const V extends Validator>(
-  key: K,
-  value: V,
-) {
+export function object<const P extends ObjectSchemaShape>(properties: P) {
+  return new ObjectSchema<P>(properties)
+}
+
+/*@__NO_SIDE_EFFECTS__*/
+export function dict<
+  const K extends Validator<string>,
+  const V extends Validator,
+>(key: K, value: V) {
   return new DictSchema<K, V>(key, value)
 }
 
@@ -174,22 +189,35 @@ export function custom<T>(
   return new CustomSchema<T>(assertion, message, path)
 }
 
+/*@__NO_SIDE_EFFECTS__*/
+export function nullable<const S extends Validator>(schema: S) {
+  return new NullableSchema<Infer<S>>(schema)
+}
+
+/*@__NO_SIDE_EFFECTS__*/
+export function optional<const S extends Validator>(schema: S) {
+  return new OptionalSchema<Infer<S>>(schema)
+}
+
 /*@__NO_SIDE_EFFECTS__*/
 export function union<const V extends UnionSchemaValidators>(validators: V) {
   return new UnionSchema<V>(validators)
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-export function intersection<const V extends IntersectionSchemaValidators>(
-  validators: V,
-) {
-  return new IntersectionSchema<V>(validators)
+export function intersection<
+  const Left extends ObjectSchema,
+  const Right extends DictSchema,
+>(left: Left, right: Right) {
+  return new IntersectionSchema<Left, Right>(left, right)
 }
 
+export { refine }
+
 /*@__NO_SIDE_EFFECTS__*/
 export function discriminatedUnion<
   const Discriminator extends string,
-  const Options extends DiscriminatedUnionSchemaVariants<Discriminator>,
+  const Options extends DiscriminatedUnionVariants<Discriminator>,
 >(discriminator: Discriminator, variants: Options) {
   return new DiscriminatedUnionSchema<Discriminator, Options>(
     discriminator,
@@ -198,7 +226,7 @@ export function discriminatedUnion<
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-export function token<const N extends Nsid, const H extends string>(
+export function token<const N extends NsidString, const H extends string>(
   nsid: N,
   hash: H,
 ) {
@@ -232,11 +260,11 @@ export function typedUnion<
  *   schemas that work even if they contain circular references.
  */
 export function typedObject<
-  const N extends Nsid,
+  const N extends NsidString,
   const H extends string,
-  const Schema extends Validator<{ [_ in string]?: unknown }>,
->(nsid: N, hash: H, schema: Schema): TypedObjectSchema<$Type<N, H>, Schema>
-export function typedObject<const V extends { $type?: $Type }>(
+  const S extends Validator<{ [_ in string]?: unknown }>,
+>(nsid: N, hash: H, schema: S): TypedObjectSchema<$Type<N, H>, S>
+export function typedObject<V extends { $type?: $Type }>(
   nsid: V extends { $type?: infer T extends string }
     ? T extends `${infer N}#${string}`
       ? N
@@ -248,14 +276,14 @@ export function typedObject<const V extends { $type?: $Type }>(
       : 'main'
     : never,
   schema: Validator<Omit<V, '$type'>>,
-): TypedObjectSchema<NonNullable<V['$type']>, typeof schema, V>
+): TypedObjectSchema<$TypeOf<V>, Validator<Omit<V, '$type'>>>
 /*@__NO_SIDE_EFFECTS__*/
 export function typedObject<
-  const N extends Nsid,
+  const N extends NsidString,
   const H extends string,
-  const Schema extends Validator<{ [_ in string]?: unknown }>,
->(nsid: N, hash: H, schema: Schema) {
-  return new TypedObjectSchema<$Type<N, H>, Schema>($type(nsid, hash), schema)
+  const S extends Validator<{ [_ in string]?: unknown }>,
+>(nsid: N, hash: H, schema: S) {
+  return new TypedObjectSchema<$Type<N, H>, S>($type(nsid, hash), schema)
 }
 
 /**
@@ -275,37 +303,32 @@ type AsNsid<T> = T extends `${string}#${string}` ? never : T
  *   schemas that work even if they contain circular references.
  */
 export function record<
-  const K extends RecordKey,
-  const T extends Nsid,
+  const K extends LexiconRecordKey,
+  const T extends NsidString,
   const S extends Validator<{ [_ in string]?: unknown }>,
->(
-  key: K,
-  type: AsNsid<T>,
-  schema: S,
-): RecordSchema<K, T, S, Infer<S> & { $type: T }>
+>(key: K, type: AsNsid<T>, schema: S): RecordSchema<K, T, S>
 export function record<
-  const K extends RecordKey,
-  const V extends { $type: Nsid },
+  const K extends LexiconRecordKey,
+  const V extends { $type: NsidString },
 >(
   key: K,
   type: AsNsid<V['$type']>,
   schema: Validator<Omit<V, '$type'>>,
-): RecordSchema<K, V['$type'], typeof schema, V>
+): RecordSchema<K, V['$type'], Validator<Omit<V, '$type'>>>
 /*@__NO_SIDE_EFFECTS__*/
 export function record<
-  const K extends RecordKey,
-  const T extends Nsid,
+  const K extends LexiconRecordKey,
+  const T extends NsidString,
   const S extends Validator<{ [_ in string]?: unknown }>,
 >(key: K, type: T, schema: S) {
-  return new RecordSchema<K, T, S, Infer<S> & { $type: T }>(key, type, schema)
+  return new RecordSchema<K, T, S>(key, type, schema)
 }
 
 /*@__NO_SIDE_EFFECTS__*/
 export function params<
-  const P extends ParamsSchemaProperties = NonNullable<unknown>,
-  const O extends ParamsSchemaOptions = ParamsSchemaOptions,
->(properties: P = {} as P, options: ParamsSchemaOptions & O = {} as O) {
-  return new ParamsSchema<P, O>(properties, options)
+  const P extends ParamsSchemaShape = NonNullable<unknown>,
+>(properties: P = {} as P) {
+  return new ParamsSchema<P>(properties)
 }
 
 /*@__NO_SIDE_EFFECTS__*/
@@ -318,7 +341,7 @@ export function payload<
 
 /*@__NO_SIDE_EFFECTS__*/
 export function query<
-  const N extends Nsid,
+  const N extends NsidString,
   const P extends ParamsSchema,
   const O extends Payload,
   const E extends undefined | readonly string[] = undefined,
@@ -328,7 +351,7 @@ export function query<
 
 /*@__NO_SIDE_EFFECTS__*/
 export function procedure<
-  const N extends Nsid,
+  const N extends NsidString,
   const P extends ParamsSchema,
   const I extends Payload,
   const O extends Payload,
@@ -339,7 +362,7 @@ export function procedure<
 
 /*@__NO_SIDE_EFFECTS__*/
 export function subscription<
-  const N extends string,
+  const N extends NsidString,
   const P extends ParamsSchema,
   const M extends undefined | RefSchema | TypedUnionSchema | ObjectSchema,
   const E extends undefined | readonly string[] = undefined,
@@ -357,9 +380,8 @@ export function permission<
 
 /*@__NO_SIDE_EFFECTS__*/
 export function permissionSet<
-  const N extends string,
+  const N extends NsidString,
   const P extends readonly Permission[],
-  const O extends PermissionSetOptions,
->(nsid: N, permissions: P, options: PermissionSetOptions & O = {} as O) {
-  return new PermissionSet<N, P, O>(nsid, permissions, options)
+>(nsid: N, permissions: P, options?: PermissionSetOptions) {
+  return new PermissionSet<N, P>(nsid, permissions, options)
 }