feat: try out io-ts and zod tranformers

Author: jozan

bun.lockb

@@ -10,6 +10,16 @@
       "import": "./dist/esm/secret.js",
       "require": "./dist/cjs/secret.js",
       "types": "./dist/dts/secret.d.ts"
+    },
+    "./io-ts": {
+      "import": "./dist/esm/io-ts/secret.js",
+      "require": "./dist/cjs/io-ts/secret.js",
+      "types": "./dist/dts/io-ts/secret.d.ts"
+    },
+    "./zod": {
+      "import": "./dist/esm/zod/secret.js",
+      "require": "./dist/cjs/zod/secret.js",
+      "types": "./dist/dts/zod/secret.d.ts"
     }
   },
   "files": [
@@ -25,7 +35,10 @@
     "@types/bun": "latest",
     "babel-plugin-annotate-pure-calls": "^0.4.0",
     "fast-check": "^3.17.1",
-    "typescript": "^5.4.5"
+    "fp-ts": "^2.16.5",
+    "io-ts": "^2.2.21",
+    "typescript": "^5.4.5",
+    "zod": "^3.22.4"
   },
   "description": "`secret` is a simple utility libraty for managing secrets in a TypeScript app.",
   "repository": {

package.json

@@ -0,0 +1,59 @@
+import * as fc from "fast-check";
+import { expect, describe, test } from "bun:test";
+import * as SecretValue from "../secret";
+import { SecretCodec, StringToSecret, SecretToExposedString } from "./secret";
+import { pipe } from "fp-ts/function";
+import { fold } from "fp-ts/Either";
+
+describe("secret encode/decode io-ts codec", () => {
+  test("should decode a string to secret", () => {
+    fc.assert(
+      fc.property(fc.string({ minLength: 1 }), (input) => {
+        pipe(
+          input,
+          StringToSecret.decode,
+          fold(
+            () => {
+              expect.unreachable("decoding should not fail");
+            },
+            (s) => {
+              expect(SecretValue.isSecret(s)).toBe(true);
+              expect(SecretValue.expose(s)).toEqual(input);
+            }
+          )
+        );
+      })
+    );
+  });
+
+  test("should encode secret to exposed string", () => {
+    fc.assert(
+      fc.property(fc.string({ minLength: 1 }), (input) => {
+        const secret = SecretValue.fromString(input);
+        const encoded = SecretToExposedString.encode(secret);
+
+        expect(encoded).toEqual(input);
+      })
+    );
+  });
+
+  test("should decode a string to secret and back to original", () => {
+    fc.assert(
+      fc.property(fc.string({ minLength: 1 }), (input) => {
+        pipe(
+          input,
+          SecretCodec.decode,
+          fold(
+            () => {
+              expect.unreachable("decoding should not fail");
+            },
+            (s) => {
+              const encoded = SecretCodec.encode(s);
+              expect(encoded).toEqual(input);
+            }
+          )
+        );
+      })
+    );
+  });
+});

src/io-ts/io-st-secret.test.ts

@@ -0,0 +1,39 @@
+import * as SecretInternal from "../secret";
+import { make, type Codec } from "io-ts/Codec";
+import {
+  string as Dstring,
+  parse,
+  success,
+  failure,
+  type Decoder,
+  type TypeOf,
+} from "io-ts/Decoder";
+import { type Encoder as IOTSEncoder, type OutputOf } from "io-ts/Encoder";
+import { pipe } from "fp-ts/function";
+
+export const StringToSecret: Decoder<unknown, SecretInternal.Secret> = pipe(
+  Dstring,
+  parse((s) => {
+    const secret = SecretInternal.fromString(s);
+    return SecretInternal.isSecret(secret)
+      ? success(secret)
+      : failure(
+          s,
+          `cannot decode given value, should be parsable into a secret`
+        );
+  })
+);
+
+export type StringToSecret = TypeOf<typeof StringToSecret>;
+
+export const SecretToExposedString: IOTSEncoder<string, SecretInternal.Secret> =
+  {
+    encode: SecretInternal.expose,
+  };
+
+export type SecretToExposedString = OutputOf<typeof SecretToExposedString>;
+
+export const SecretCodec: Codec<unknown, string, SecretInternal.Secret> = make(
+  StringToSecret,
+  SecretToExposedString
+);

src/io-ts/secret.ts

@@ -0,0 +1,8 @@
+import * as SecretInternal from "../secret";
+import { z } from "zod";
+
+export const Secret = z
+  .string()
+  .transform((str) => SecretInternal.fromString(str));
+
+export type Secret = z.infer<typeof Secret>;

src/zod/secret.ts

@@ -0,0 +1,39 @@
+import * as fc from "fast-check";
+import { expect, describe, test } from "bun:test";
+import * as SecretValue from "../secret";
+import { Secret as SecretSchema } from "./secret";
+import { z } from "zod";
+
+describe("secret encode/decode zod", () => {
+  test("should encode a string to secret and back to original", () => {
+    fc.assert(
+      fc.property(fc.string({ minLength: 1 }), (input) => {
+        const secret = SecretSchema.safeParse(input);
+
+        if (secret.success) {
+          expect(SecretValue.isSecret(secret.data)).toBe(true);
+          const exposed = SecretValue.expose(secret.data);
+          expect(exposed).toEqual(input);
+        }
+      })
+    );
+  });
+
+  test("should encode struct values to secrets", () => {
+    fc.assert(
+      fc.property(fc.string({ minLength: 1 }), (input) => {
+        const struct = z.object({
+          redacted: SecretSchema,
+        });
+
+        const result = struct.safeParse({ redacted: input });
+
+        if (result.success) {
+          expect(SecretValue.isSecret(result.data.redacted)).toBe(true);
+          const exposed = SecretValue.expose(result.data.redacted);
+          expect(exposed).toEqual(input);
+        }
+      })
+    );
+  });
+});