@atproto/lex-builder 0.0.11 → 0.0.12

package/src/lex-def-builder.ts

@@ -434,10 +434,16 @@ export class LexDefBuilder {
     if (hash === 'main' && validationUtils) {
       this.addUtils({
         $assert: markPure(`${ref.varName}.assert.bind(${ref.varName})`),
+        $check: markPure(`${ref.varName}.check.bind(${ref.varName})`),
+        $cast: markPure(`${ref.varName}.cast.bind(${ref.varName})`),
         $ifMatches: markPure(`${ref.varName}.ifMatches.bind(${ref.varName})`),
         $matches: markPure(`${ref.varName}.matches.bind(${ref.varName})`),
         $parse: markPure(`${ref.varName}.parse.bind(${ref.varName})`),
         $safeParse: markPure(`${ref.varName}.safeParse.bind(${ref.varName})`),
+        $validate: markPure(`${ref.varName}.validate.bind(${ref.varName})`),
+        $safeValidate: markPure(
+          `${ref.varName}.safeValidate.bind(${ref.varName})`,
+        ),
       })
     }
 
@@ -474,7 +480,11 @@ export class LexDefBuilder {
     if (!def) return this.pure(`l.params()`)
 
     const properties = await this.compilePropertiesSchemas(def)
-    return this.pure(`l.params({${properties.join(',')}})`)
+    return this.pure(
+      properties.length === 0
+        ? `l.params()`
+        : `l.params({${properties.join(',')}})`,
+    )
   }
 
   private async compileErrors(defs?: readonly LexiconError[]) {
@@ -645,13 +655,24 @@ export class LexDefBuilder {
     return `l.UnknownObject`
   }
 
+  private withDefault(schema: string, defaultValue: unknown) {
+    if (defaultValue === undefined) return schema
+
+    return this.pure(
+      `l.withDefault(${schema}, ${JSON.stringify(defaultValue)})`,
+    )
+  }
+
   private async compileBooleanSchema(def: LexiconBoolean): Promise<string> {
+    const schema = l.boolean()
+
+    if (def.default !== undefined) {
+      schema.check(def.default)
+    }
+
     if (hasConst(def)) return this.compileConstSchema(def)
 
-    const options = stringifyOptions(def, [
-      'default',
-    ] satisfies (keyof l.BooleanSchemaOptions)[])
-    return this.pure(`l.boolean(${options})`)
+    return this.withDefault(this.pure(`l.boolean()`), def.default)
   }
 
   private async compileBooleanType(def: LexiconBoolean): Promise<string> {
@@ -660,25 +681,29 @@ export class LexDefBuilder {
   }
 
   private async compileIntegerSchema(def: LexiconInteger): Promise<string> {
+    const schema = l.integer(def)
+
     if (hasConst(def)) {
-      const schema: l.IntegerSchema = l.integer(def)
-      schema.assert(def.const)
+      schema.check(def.const)
     }
 
     if (hasEnum(def)) {
-      const schema: l.IntegerSchema = l.integer(def)
-      for (const val of def.enum) schema.assert(val)
+      for (const val of def.enum) schema.check(val)
+    }
+
+    if (def.default !== undefined) {
+      schema.check(def.default)
     }
 
     if (hasConst(def)) return this.compileConstSchema(def)
     if (hasEnum(def)) return this.compileEnumSchema(def)
 
     const options = stringifyOptions(def, [
-      'default',
       'maximum',
       'minimum',
     ] satisfies (keyof l.IntegerSchemaOptions)[])
-    return this.pure(`l.integer(${options})`)
+
+    return this.withDefault(this.pure(`l.integer(${options})`), def.default)
   }
 
   private async compileIntegerType(def: LexiconInteger): Promise<string> {
@@ -689,26 +714,32 @@ export class LexDefBuilder {
   }
 
   private async compileStringSchema(def: LexiconString): Promise<string> {
+    const schema = l.string(def)
+
     if (hasConst(def)) {
-      const schema: l.StringSchema = l.string(def)
-      schema.assert(def.const)
-    } else if (hasEnum(def)) {
-      const schema: l.StringSchema = l.string(def)
-      for (const val of def.enum) schema.assert(val)
+      schema.check(def.const)
+    }
+
+    if (hasEnum(def)) {
+      for (const val of def.enum) schema.check(val)
+    }
+
+    if (def.default !== undefined) {
+      schema.check(def.default)
     }
 
     if (hasConst(def)) return this.compileConstSchema(def)
     if (hasEnum(def)) return this.compileEnumSchema(def)
 
     const options = stringifyOptions(def, [
-      'default',
       'format',
       'maxGraphemes',
       'minGraphemes',
       'maxLength',
       'minLength',
     ] satisfies (keyof l.StringSchemaOptions)[])
-    return this.pure(`l.string(${options})`)
+
+    return this.withDefault(this.pure(`l.string(${options})`), def.default)
   }
 
   private async compileStringType(def: LexiconString): Promise<string> {
@@ -783,7 +814,7 @@ export class LexDefBuilder {
   }
 
   private async compileCidLinkSchema(_def: LexiconCid): Promise<string> {
-    return this.pure(`l.cidLink()`)
+    return this.pure(`l.cid()`)
   }
 
   private async compileCidLinkType(_def: LexiconCid): Promise<string> {
@@ -825,10 +856,10 @@ export class LexDefBuilder {
     const types = await Promise.all(
       def.refs.map(async (ref) => {
         const { typeName } = await this.refResolver.resolve(ref)
-        return `l.TypedRef<${typeName}>`
+        return `l.$Typed<${typeName}>`
       }),
     )
-    if (!def.closed) types.push('l.TypedObject')
+    if (!def.closed) types.push('l.Unknown$TypedObject')
     return types.join(' | ') || 'never'
   }
 
@@ -839,10 +870,9 @@ export class LexDefBuilder {
       return this.pure(`l.never()`)
     }
 
-    const options = stringifyOptions(def, [
-      'default',
-    ] satisfies (keyof l.LiteralSchemaOptions<any>)[])
-    return this.pure(`l.literal(${JSON.stringify(def.const)}, ${options})`)
+    const result = this.pure(`l.literal(${JSON.stringify(def.const)})`)
+
+    return this.withDefault(result, def.default)
   }
 
   private async compileConstType<
@@ -861,13 +891,13 @@ export class LexDefBuilder {
     if (def.enum.length === 0) {
       return this.pure(`l.never()`)
     }
-    if (def.enum.length === 1 && def.default === undefined) {
-      return this.pure(`l.literal(${JSON.stringify(def.enum[0])})`)
-    }
-    const options = stringifyOptions(def, [
-      'default',
-    ] satisfies (keyof l.EnumSchemaOptions<any>)[])
-    return this.pure(`l.enum(${JSON.stringify(def.enum)}, ${options})`)
+
+    const result =
+      def.enum.length === 1
+        ? this.pure(`l.literal(${JSON.stringify(def.enum[0])})`)
+        : this.pure(`l.enum(${JSON.stringify(def.enum)})`)
+
+    return this.withDefault(result, def.default)
   }
 
   private async compileEnumType<T extends null | number | string>(def: {