@bigmistqke/lexicon-to-valibot 0.1.2 → 0.1.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (4) hide show
  1. package/dist/index.d.ts +53 -49
  2. package/dist/index.js +10409 -3
  3. package/dist/index.js.map +1 -1
  4. package/package.json +2 -1
package/dist/index.d.ts CHANGED
@@ -1,5 +1,6 @@
1
1
  import * as v from 'valibot';
2
2
  export { InferOutput } from 'valibot';
3
+ import { BlobRef } from '@atproto/lexicon';
3
4
  export { LexUserType, LexiconDoc } from '@atproto/lexicon';
4
5
 
5
6
  interface QueryValidators {
@@ -19,7 +20,8 @@ interface SubscriptionValidators {
19
20
  type Prettify<T> = {
20
21
  [K in keyof T]: T[K];
21
22
  } & {};
22
- type TypedBlobRef = {
23
+ type BlobFormat = 'sdk' | 'wire';
24
+ type WireBlobRef = {
23
25
  $type: "blob";
24
26
  ref: {
25
27
  $link: string;
@@ -31,12 +33,14 @@ type UntypedBlobRef = {
31
33
  cid: string;
32
34
  mimeType: string;
33
35
  };
34
- type BlobRef = TypedBlobRef | UntypedBlobRef;
36
+ type SdkBlobRef = BlobRef | UntypedBlobRef;
37
+ type WireBlobRefUnion = WireBlobRef | UntypedBlobRef;
38
+ type InferBlobRef<Format extends BlobFormat> = Format extends 'sdk' ? SdkBlobRef : WireBlobRefUnion;
35
39
  type CidLink = {
36
40
  $link: string;
37
41
  };
38
42
  type ExternalRefsMap = Record<string, unknown>;
39
- type InferLexType<T, Defs = {}, ExtRefs extends ExternalRefsMap = {}> = T extends {
43
+ type InferLexType<T, Defs = {}, ExtRefs extends ExternalRefsMap = {}, Format extends BlobFormat = 'sdk'> = T extends {
40
44
  type: "boolean";
41
45
  } ? T extends {
42
46
  const: infer C extends boolean;
@@ -58,34 +62,34 @@ type InferLexType<T, Defs = {}, ExtRefs extends ExternalRefsMap = {}> = T extend
58
62
  type: "bytes";
59
63
  } ? Uint8Array : T extends {
60
64
  type: "blob";
61
- } ? BlobRef : T extends {
65
+ } ? InferBlobRef<Format> : T extends {
62
66
  type: "cid-link";
63
67
  } ? CidLink : T extends {
64
68
  type: "token";
65
69
  } ? string : T extends {
66
70
  type: "array";
67
71
  items: infer Items;
68
- } ? InferLexType<Items, Defs, ExtRefs>[] : T extends {
72
+ } ? InferLexType<Items, Defs, ExtRefs, Format>[] : T extends {
69
73
  type: "object";
70
74
  properties?: infer Props;
71
- } ? InferLexObject<Props, T, Defs, ExtRefs> : T extends {
75
+ } ? InferLexObject<Props, T, Defs, ExtRefs, Format> : T extends {
72
76
  type: "ref";
73
77
  ref: infer R extends string;
74
- } ? InferLexRef<R, Defs, ExtRefs> : T extends {
78
+ } ? InferLexRef<R, Defs, ExtRefs, Format> : T extends {
75
79
  type: "union";
76
80
  refs: infer Refs extends readonly string[];
77
- } ? InferLexUnion<Refs, Defs, ExtRefs> : T extends {
81
+ } ? InferLexUnion<Refs, Defs, ExtRefs, Format> : T extends {
78
82
  type: "record";
79
83
  record: infer Rec;
80
- } ? InferLexType<Rec, Defs, ExtRefs> : unknown;
81
- type InferLexObject<Props, Schema, Defs, ExtRefs extends ExternalRefsMap = {}> = Props extends Record<string, unknown> ? Prettify<{
82
- [K in keyof Props as K extends RequiredKeys<Schema> ? K extends NullableKeys<Schema> ? never : K : never]: InferLexType<Props[K], Defs, ExtRefs>;
84
+ } ? InferLexType<Rec, Defs, ExtRefs, Format> : unknown;
85
+ type InferLexObject<Props, Schema, Defs, ExtRefs extends ExternalRefsMap = {}, Format extends BlobFormat = 'sdk'> = Props extends Record<string, unknown> ? Prettify<{
86
+ [K in keyof Props as K extends RequiredKeys<Schema> ? K extends NullableKeys<Schema> ? never : K : never]: InferLexType<Props[K], Defs, ExtRefs, Format>;
83
87
  } & {
84
- [K in keyof Props as K extends RequiredKeys<Schema> ? K extends NullableKeys<Schema> ? K : never : never]: InferLexType<Props[K], Defs, ExtRefs> | null;
88
+ [K in keyof Props as K extends RequiredKeys<Schema> ? K extends NullableKeys<Schema> ? K : never : never]: InferLexType<Props[K], Defs, ExtRefs, Format> | null;
85
89
  } & {
86
- [K in keyof Props as K extends RequiredKeys<Schema> ? never : K extends NullableKeys<Schema> ? never : K]?: InferLexType<Props[K], Defs, ExtRefs>;
90
+ [K in keyof Props as K extends RequiredKeys<Schema> ? never : K extends NullableKeys<Schema> ? never : K]?: InferLexType<Props[K], Defs, ExtRefs, Format>;
87
91
  } & {
88
- [K in keyof Props as K extends RequiredKeys<Schema> ? never : K extends NullableKeys<Schema> ? K : never]?: InferLexType<Props[K], Defs, ExtRefs> | null;
92
+ [K in keyof Props as K extends RequiredKeys<Schema> ? never : K extends NullableKeys<Schema> ? K : never]?: InferLexType<Props[K], Defs, ExtRefs, Format> | null;
89
93
  }> : {};
90
94
  type RequiredKeys<T> = T extends {
91
95
  required: infer R extends readonly string[];
@@ -93,80 +97,80 @@ type RequiredKeys<T> = T extends {
93
97
  type NullableKeys<T> = T extends {
94
98
  nullable: infer N extends readonly string[];
95
99
  } ? N[number] : never;
96
- type InferLexRef<R extends string, Defs, ExtRefs extends ExternalRefsMap = {}> = R extends `#${infer DefName}` ? DefName extends keyof Defs ? InferLexType<Defs[DefName], Defs, ExtRefs> : unknown : R extends keyof ExtRefs ? ExtRefs[R] : `${R}#main` extends keyof ExtRefs ? ExtRefs[`${R}#main`] : unknown;
97
- type InferLexUnion<Refs extends readonly string[], Defs, ExtRefs extends ExternalRefsMap = {}> = Refs extends readonly [
100
+ type InferLexRef<R extends string, Defs, ExtRefs extends ExternalRefsMap = {}, Format extends BlobFormat = 'sdk'> = R extends `#${infer DefName}` ? DefName extends keyof Defs ? InferLexType<Defs[DefName], Defs, ExtRefs, Format> : unknown : R extends keyof ExtRefs ? ExtRefs[R] : `${R}#main` extends keyof ExtRefs ? ExtRefs[`${R}#main`] : unknown;
101
+ type InferLexUnion<Refs extends readonly string[], Defs, ExtRefs extends ExternalRefsMap = {}, Format extends BlobFormat = 'sdk'> = Refs extends readonly [
98
102
  infer First extends string,
99
103
  ...infer Rest extends readonly string[]
100
- ] ? InferLexRef<First, Defs, ExtRefs> | InferLexUnion<Rest, Defs, ExtRefs> : never;
101
- type InferLexParams<T, Defs, ExtRefs extends ExternalRefsMap = {}> = T extends {
104
+ ] ? InferLexRef<First, Defs, ExtRefs, Format> | InferLexUnion<Rest, Defs, ExtRefs, Format> : never;
105
+ type InferLexParams<T, Defs, ExtRefs extends ExternalRefsMap = {}, Format extends BlobFormat = 'sdk'> = T extends {
102
106
  type: "params";
103
107
  properties?: infer Props;
104
108
  required?: infer R extends readonly string[];
105
109
  } ? Props extends Record<string, unknown> ? Prettify<{
106
- [K in keyof Props as K extends R[number] ? K : never]: InferLexType<Props[K], Defs, ExtRefs>;
110
+ [K in keyof Props as K extends R[number] ? K : never]: InferLexType<Props[K], Defs, ExtRefs, Format>;
107
111
  } & {
108
- [K in keyof Props as K extends R[number] ? never : K]?: InferLexType<Props[K], Defs, ExtRefs>;
112
+ [K in keyof Props as K extends R[number] ? never : K]?: InferLexType<Props[K], Defs, ExtRefs, Format>;
109
113
  }> : {} : {};
110
- type InferLexBody<T, Defs, ExtRefs extends ExternalRefsMap = {}> = T extends {
114
+ type InferLexBody<T, Defs, ExtRefs extends ExternalRefsMap = {}, Format extends BlobFormat = 'sdk'> = T extends {
111
115
  schema: infer S;
112
- } ? InferLexType<S, Defs, ExtRefs> : unknown;
113
- type InferQueryValidators<T, Defs, ExtRefs extends ExternalRefsMap = {}> = T extends {
116
+ } ? InferLexType<S, Defs, ExtRefs, Format> : unknown;
117
+ type InferQueryValidators<T, Defs, ExtRefs extends ExternalRefsMap = {}, Format extends BlobFormat = 'sdk'> = T extends {
114
118
  type: "query";
115
119
  } ? {
116
120
  parameters: v.GenericSchema<InferLexParams<T extends {
117
121
  parameters: infer P;
118
- } ? P : never, Defs, ExtRefs>>;
122
+ } ? P : never, Defs, ExtRefs, Format>>;
119
123
  output: v.GenericSchema<InferLexBody<T extends {
120
124
  output: infer O;
121
- } ? O : never, Defs, ExtRefs>>;
125
+ } ? O : never, Defs, ExtRefs, Format>>;
122
126
  } : never;
123
- type InferProcedureValidators<T, Defs, ExtRefs extends ExternalRefsMap = {}> = T extends {
127
+ type InferProcedureValidators<T, Defs, ExtRefs extends ExternalRefsMap = {}, Format extends BlobFormat = 'sdk'> = T extends {
124
128
  type: "procedure";
125
129
  } ? {
126
130
  parameters: v.GenericSchema<InferLexParams<T extends {
127
131
  parameters: infer P;
128
- } ? P : never, Defs, ExtRefs>>;
132
+ } ? P : never, Defs, ExtRefs, Format>>;
129
133
  input: v.GenericSchema<InferLexBody<T extends {
130
134
  input: infer I;
131
- } ? I : never, Defs, ExtRefs>>;
135
+ } ? I : never, Defs, ExtRefs, Format>>;
132
136
  output: v.GenericSchema<InferLexBody<T extends {
133
137
  output: infer O;
134
- } ? O : never, Defs, ExtRefs>>;
138
+ } ? O : never, Defs, ExtRefs, Format>>;
135
139
  } : never;
136
- type InferSubscriptionValidators<T, Defs, ExtRefs extends ExternalRefsMap = {}> = T extends {
140
+ type InferSubscriptionValidators<T, Defs, ExtRefs extends ExternalRefsMap = {}, Format extends BlobFormat = 'sdk'> = T extends {
137
141
  type: "subscription";
138
142
  } ? {
139
143
  parameters: v.GenericSchema<InferLexParams<T extends {
140
144
  parameters: infer P;
141
- } ? P : never, Defs, ExtRefs>>;
145
+ } ? P : never, Defs, ExtRefs, Format>>;
142
146
  message: v.GenericSchema<InferLexBody<T extends {
143
147
  message: infer M;
144
- } ? M : never, Defs, ExtRefs>>;
148
+ } ? M : never, Defs, ExtRefs, Format>>;
145
149
  } : never;
146
150
  type IsXrpcType<T> = T extends {
147
151
  type: "query" | "procedure" | "subscription";
148
152
  } ? true : false;
149
- type InferSchemaValidator<T, Defs, ExtRefs extends ExternalRefsMap = {}> = v.GenericSchema<InferLexType<T, Defs, ExtRefs>>;
150
- type InferXrpcValidator<T, Defs, ExtRefs extends ExternalRefsMap = {}> = T extends {
153
+ type InferSchemaValidator<T, Defs, ExtRefs extends ExternalRefsMap = {}, Format extends BlobFormat = 'sdk'> = v.GenericSchema<InferLexType<T, Defs, ExtRefs, Format>>;
154
+ type InferXrpcValidator<T, Defs, ExtRefs extends ExternalRefsMap = {}, Format extends BlobFormat = 'sdk'> = T extends {
151
155
  type: "query";
152
- } ? InferQueryValidators<T, Defs, ExtRefs> : T extends {
156
+ } ? InferQueryValidators<T, Defs, ExtRefs, Format> : T extends {
153
157
  type: "procedure";
154
- } ? InferProcedureValidators<T, Defs, ExtRefs> : T extends {
158
+ } ? InferProcedureValidators<T, Defs, ExtRefs, Format> : T extends {
155
159
  type: "subscription";
156
- } ? InferSubscriptionValidators<T, Defs, ExtRefs> : never;
160
+ } ? InferSubscriptionValidators<T, Defs, ExtRefs, Format> : never;
157
161
  type InferLexiconValidators<T extends {
158
162
  defs: Record<string, unknown>;
159
- }, ExtRefs extends ExternalRefsMap = {}> = {
160
- [K in keyof T["defs"] as IsXrpcType<T["defs"][K]> extends true ? never : K]: InferSchemaValidator<T["defs"][K], T["defs"], ExtRefs>;
163
+ }, ExtRefs extends ExternalRefsMap = {}, Format extends BlobFormat = 'sdk'> = {
164
+ [K in keyof T["defs"] as IsXrpcType<T["defs"][K]> extends true ? never : K]: InferSchemaValidator<T["defs"][K], T["defs"], ExtRefs, Format>;
161
165
  };
162
166
  type InferXrpcValidators<T extends {
163
167
  defs: Record<string, unknown>;
164
- }, ExtRefs extends ExternalRefsMap = {}> = {
165
- [K in keyof T["defs"] as IsXrpcType<T["defs"][K]> extends true ? K : never]: InferXrpcValidator<T["defs"][K], T["defs"], ExtRefs>;
168
+ }, ExtRefs extends ExternalRefsMap = {}, Format extends BlobFormat = 'sdk'> = {
169
+ [K in keyof T["defs"] as IsXrpcType<T["defs"][K]> extends true ? K : never]: InferXrpcValidator<T["defs"][K], T["defs"], ExtRefs, Format>;
166
170
  };
167
171
  type InferLexiconOutput<T extends {
168
172
  defs: Record<string, unknown>;
169
- }, K extends keyof T["defs"], ExtRefs extends ExternalRefsMap = {}> = InferLexType<T["defs"][K], T["defs"], ExtRefs>;
173
+ }, K extends keyof T["defs"], ExtRefs extends ExternalRefsMap = {}, Format extends BlobFormat = 'sdk'> = InferLexType<T["defs"][K], T["defs"], ExtRefs, Format>;
170
174
 
171
175
  declare const atprotoRefs: {
172
176
  readonly "com.atproto.repo.strongRef": v.ObjectSchema<{
@@ -209,17 +213,17 @@ type InferSchemaOutputs<T extends Record<string, v.GenericSchema>> = {
209
213
  * Convert a lexicon to valibot schemas for records and objects.
210
214
  * Skips XRPC types (query, procedure, subscription) - use xrpcToValibot for those.
211
215
  */
212
- declare function lexiconToValibot<T extends LexiconInput, ExtRefs extends Record<string, v.GenericSchema> = {}>(lexicon: T, options?: {
216
+ declare function lexiconToValibot<T extends LexiconInput, ExtRefs extends Record<string, v.GenericSchema> = {}, Format extends BlobFormat = 'sdk'>(lexicon: T, options?: {
213
217
  externalRefs?: ExtRefs;
214
- format?: 'sdk' | 'wire';
215
- }): InferLexiconValidators<T, InferSchemaOutputs<ExtRefs>>;
218
+ format?: Format;
219
+ }): InferLexiconValidators<T, InferSchemaOutputs<ExtRefs>, Format>;
216
220
  /**
217
221
  * Convert a lexicon to valibot validators for XRPC endpoints.
218
222
  * Only handles query, procedure, and subscription types.
219
223
  */
220
- declare function xrpcToValibot<T extends LexiconInput, ExtRefs extends Record<string, v.GenericSchema> = {}>(lexicon: T, options?: {
224
+ declare function xrpcToValibot<T extends LexiconInput, ExtRefs extends Record<string, v.GenericSchema> = {}, Format extends BlobFormat = 'sdk'>(lexicon: T, options?: {
221
225
  externalRefs?: ExtRefs;
222
- format?: 'sdk' | 'wire';
223
- }): InferXrpcValidators<T, InferSchemaOutputs<ExtRefs>>;
226
+ format?: Format;
227
+ }): InferXrpcValidators<T, InferSchemaOutputs<ExtRefs>, Format>;
224
228
 
225
- export { type AtprotoRefs, type InferLexType, type InferLexiconOutput, type InferLexiconValidators, type LexiconInput, type LexiconToValibotOptions, type ProcedureValidators, type QueryValidators, type SubscriptionValidators, atprotoRefs, lexiconToValibot, xrpcToValibot };
229
+ export { type AtprotoRefs, type BlobFormat, type InferLexType, type InferLexiconOutput, type InferLexiconValidators, type LexiconInput, type LexiconToValibotOptions, type ProcedureValidators, type QueryValidators, type SubscriptionValidators, atprotoRefs, lexiconToValibot, xrpcToValibot };