Schema: add annotations argument to attachPropertySignature (#679)

Effect-TS · Dec 24, 2023 · 0f8a8f1 · 0f8a8f1
1 parent 6b9585b
commit 0f8a8f1
Show file tree

Hide file tree

Showing 4 changed files with 58 additions and 25 deletions.
diff --git a/.changeset/thin-ways-arrive.md b/.changeset/thin-ways-arrive.md
@@ -0,0 +1,5 @@
+---
+"@effect/schema": patch
+---
+
+Schema: add annotations argument to `attachPropertySignature`
diff --git a/docs/modules/Schema.ts.md b/docs/modules/Schema.ts.md
@@ -1855,12 +1855,14 @@ but rather maps to another schema, for example when you want to add a discrimina
 export declare const attachPropertySignature: {
   <K extends PropertyKey, V extends symbol | AST.LiteralValue>(
     key: K,
-    value: V
+    value: V,
+    options?: DocAnnotations
   ): <I, A extends object>(schema: Schema<I, A>) => Schema<I, Simplify<A & { readonly [k in K]: V }>>
   <I, A, K extends PropertyKey, V extends symbol | AST.LiteralValue>(
     schema: Schema<I, A>,
     key: K,
-    value: V
+    value: V,
+    options?: DocAnnotations
   ): Schema<I, Simplify<A & { readonly [k in K]: V }>>
 }
 ```

diff --git a/src/Schema.ts b/src/Schema.ts
@@ -1481,39 +1481,47 @@ export const transformLiterals = <
 export const attachPropertySignature: {
   <K extends PropertyKey, V extends AST.LiteralValue | symbol>(
     key: K,
-    value: V
+    value: V,
+    options?: DocAnnotations
   ): <I, A extends object>(
     schema: Schema<I, A>
   ) => Schema<I, Simplify<A & { readonly [k in K]: V }>>
   <I, A, K extends PropertyKey, V extends AST.LiteralValue | symbol>(
     schema: Schema<I, A>,
     key: K,
-    value: V
+    value: V,
+    options?: DocAnnotations
   ): Schema<I, Simplify<A & { readonly [k in K]: V }>>
-} = dual(3, <I, A, K extends PropertyKey, V extends AST.LiteralValue | symbol>(
-  schema: Schema<I, A>,
-  key: K,
-  value: V
-): Schema<I, Simplify<A & { readonly [k in K]: V }>> =>
-  make(AST.createTransform(
-    schema.ast,
-    extend(
+} = dual(
+  (args) => isSchema(args[0]),
+  <I, A, K extends PropertyKey, V extends AST.LiteralValue | symbol>(
+    schema: Schema<I, A>,
+    key: K,
+    value: V,
+    options?: DocAnnotations
+  ): Schema<I, Simplify<A & { readonly [k in K]: V }>> => {
+    const attached = extend(
       to(schema),
       struct({ [key]: Predicate.isSymbol(value) ? uniqueSymbol(value) : literal(value) })
-    ).ast,
-    AST.createTypeLiteralTransformation(
-      [
-        AST.createPropertySignatureTransform(
-          key,
-          key,
-          AST.createFinalPropertySignatureTransformation(
-            () => Option.some(value),
-            () => Option.none()
+    ).ast
+    return make(AST.createTransform(
+      schema.ast,
+      options ? AST.mergeAnnotations(attached, toAnnotations(options)) : attached,
+      AST.createTypeLiteralTransformation(
+        [
+          AST.createPropertySignatureTransform(
+            key,
+            key,
+            AST.createFinalPropertySignatureTransformation(
+              () => Option.some(value),
+              () => Option.none()
+            )
           )
-        )
-      ]
-    )
-  )))
+        ]
+      )
+    ))
+  }
+)
 
 const toAnnotations = <A>(
   options?: FilterAnnotations<A>

diff --git a/test/Schema/attachPropertySignature.test.ts b/test/Schema/attachPropertySignature.test.ts
@@ -101,4 +101,22 @@ describe("Schema/attachPropertySignature", () => {
       radius: 10
     })
   })
+
+  it("annotations", async () => {
+    const schema1 = S.struct({
+      a: S.string
+    }).pipe(
+      S.attachPropertySignature("_tag", "a", { identifier: "MyIdentifier" })
+    )
+    await Util.expectEncodeFailure(schema1, null as any, "Expected MyIdentifier, actual null")
+    const schema2 = S.attachPropertySignature(
+      S.struct({
+        a: S.string
+      }),
+      "_tag",
+      "a",
+      { identifier: "MyIdentifier" }
+    )
+    await Util.expectEncodeFailure(schema2, null as any, "Expected MyIdentifier, actual null")
+  })
 })