ZodでJSONのオブジェクトを実行時に都合の良い型に変換する

const userSchema = z.object({
  name: z.string(),
  age: z.coerce.bigint(),
  birth: z.coerce.date(),
});
type User = z.infer<typeof userSchema>;

const src = {
  name: "John",
  age: "9007199254740993",
  birth: "1980-01-01",
};

const user: User = userSchema.parse(src);
console.log(user.age.toString());
// 9007199254740993
// Number.MAX_SAFE_INTEGERより大きくても大丈夫なので
// 9000兆歳を超えるエルフを登録したくなってもOK
console.log(user.birth.toString());
// Tue Jan 01 1980 09:00:00 GMT+0900 (日本標準時)

function convertBase64ToUUID(src: string, ctx: z.RefinementCtx) {
  let base64String: string;
  try {
    base64String = atob(src);
  } catch (error) {
    ctx.addIssue({
      message: "invalid base64 string",
      code: z.ZodIssueCode.custom,
    });
    return "";
  }
  const h = [...base64String].map((c) => c.charCodeAt(0).toString(16).padStart(2, "0"));
  if (h.length !== 16) {
    ctx.addIssue({
      message: "invalid length",
      code: z.ZodIssueCode.custom,
    });
    return "";
  }
  const result = `${h.slice(0, 4).join("")}-${h.slice(4, 6).join("")}-${h.slice(6, 8).join("")}-${h.slice(8, 10).join("")}-${h.slice(10).join("")}`;
  return result;
}

const userSchema = z.object({
  id: z.string().transform(convertBase64ToUUID),
});

const src = {
  id: "QMwh6n0nScyKGCgDc5M74g",
};

const user = userSchema.parse(src);
// 40cc21ea-7d27-49cc-8a18-280373933be2
// いつもの形式の文字列になった！

const originalType = z.array(
  z.object({
    id: z.string(),
    name: z.string(),
  }),
);

const containerSchema = z.object({
  items: z.preprocess(
    (items, ctx) => {
      const result = originalType.safeParse(items);
      if (result.success) {
        const map = new Map<string, string>();
        for (const item of result.data) {
          map.set(item.id, item.name);
        }
        return map;
      } else {
        ctx.addIssue(result.error.errors[0]);
        return new Map();
      }
    },
    z.map(z.string(), z.string()),
  ),
});

const src = {
  items: [
    { id: "1", name: "one" },
    { id: "2", name: "two" },
    { id: "3", name: "three" },
  ],
};

const container = containerSchema.parse(src);
expect(container.items.get("1")).toBe("one");

const originalType = z.object({
  name: z.string(),
});

function arrayToMap<T extends z.ZodRawShape, S extends z.UnknownKeysParam>(valueType: z.ZodObject<T, S>) {
  type Value = z.infer<typeof valueType>;
  const arrayType = z.array(z.object({ id: z.string() }).merge(valueType));

  return [
    // 変換関数
    function (items: unknown, ctx: z.RefinementCtx) {
      console.log(items);
      const result = arrayType.safeParse(items);
      console.log(result);
      if (result.success) {
        const map = new Map<string, Value>();
        for (const item of result.data) {
          const { id, ...data } = item;
          map.set(id, { ...data } as Value);
        }
        return map;
      } else {
        ctx.addIssue(result.error.errors[0]);
        return new Map();
      }
    },
    // このpreprocessの返り値の型
    z.map(z.string(), valueType),
  ] as const;
}

// 型定義に入れてみる
const containerSchema = z.object({
  items: z.preprocess(...arrayToMap(originalType)),
});

// 変換してみる
const src = {
  items: [
    { id: "1", name: "one" },
    { id: "2", name: "two" },
    { id: "3", name: "three" },
  ],
};

const container = containerSchema.parse(src);
expect(container.items.get("1")).toEqual({"name": "one"});