Codec.assert

Asserts that a given runtime value matches the codec's static type. That is, it's a value that would be valid to return from the Codec.parse method.

For example:

import * as ft from "funtypes";
import * as s from "funtypes-schemas";

export const UserCodec = ft.Object({
  id: ft.Number,
  name: ft.String,
  dateOfBirth: s.ParsedDateTimeString(),
});
// => ft.Codec<{ id: number; name: string; dateOfBirth: Date }>

// ✅ Valid so no error is thrown
UserCodec.assert({
  id: 1,
  name: "Forbes Lindesay",
  dateOfBirth: new Date(
    "1970-01-01T00:00:00.000Z",
  ),
});

// 🚨 Invalid: id should be a number, but here we
//    passed a string instead.
assert.throws(() => {
  UserCodec.assert({
    id: "42",
    name: "Forbes Lindesay",
    dateOfBirth: new Date(
      "1970-01-01T00:00:00.000Z",
    ),
  });
});

// 🚨 Invalid: dateOfBirth is a string, which
//    would be ok if the value was serialized, but
//    the Codec.assert function tests if the value
//    matches the **parsed** Codec
assert.throws(() => {
  UserCodec.assert({
    id: 1,
    name: "Forbes Lindesay",
    dateOfBirth: "1970-01-01T00:00:00.000Z",
  });
});

Note that TypeScript can tell that the type is constrained by the Codec.assert call:

/**
 * TypeScript can infer that this function returns
 * a value of type `string`. The function will
 * throw an error if you give it anything other than
 * a valid User object.
 */
function dangerouslyGetUserName(user: unknown) {
  UserCodec.assert(user);
  return user.name;
}

// ✅ Valid so no error is thrown and the name is
//    returned
assert.deepEqual(
  dangerouslyGetUserName({
    id: 1,
    name: "Forbes Lindesay",
    dateOfBirth: new Date(
      "1970-01-01T00:00:00.000Z",
    ),
  }),
  "Forbes Lindesay",
);

// 🚨 Invalid: even though this object has a
//    "name" prop, It is not a valid User object,
//    so UserCodec.assert will throw an error.
assert.throws(() => {
  dangerouslyGetUserName({
    name: "Forbes Lindesay",
  });
});