ts-fortress 1.0.0

package/src/record/record.mts

@@ -0,0 +1,105 @@
+import { isRecord, Result, tp } from 'ts-data-forge';
+import { type Type, type TypeOf } from '../type.mjs';
+import {
+  createAssertFn,
+  createCastFn,
+  createIsFn,
+  validationErrorMessage,
+} from '../utils/index.mjs';
+
+export const record = <const R extends Record<string, Type<unknown>>>(
+  source: R,
+  options?: Partial<
+    Readonly<{
+      typeName: string;
+    }>
+  >,
+): Type<RecordTypeValue<R>> => {
+  type T = RecordTypeValue<R>;
+
+  const typeNameFilled: string =
+    options?.typeName ??
+    `{ ${Object.entries(source)
+      .map(([k, v]) => `${k}: ${v.typeName}`)
+      .join(', ')} }`;
+
+  const defaultValue: Type<T>['defaultValue'] =
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    Object.fromEntries(
+      Object.entries(source).map(([key, value]) => tp(key, value.defaultValue)),
+    ) as T;
+
+  const validate: Type<T>['validate'] = (a) => {
+    if (!isRecord(a)) {
+      return Result.err([
+        validationErrorMessage(a, 'The value is expected to be a record'),
+      ]);
+    }
+
+    for (const [k, valueType] of Object.entries(source)) {
+      if (!Object.hasOwn(a, k)) {
+        if (source[k]?.optional === true) continue;
+
+        return Result.err([`The record is expected to have the key "${k}".`]);
+      }
+
+      const v = a[k];
+      const res = valueType.validate(v);
+
+      if (Result.isErr(res)) {
+        const message = validationErrorMessage(
+          v,
+          `The value at record key "${k}" is expected to be <${valueType.typeName}>`,
+        );
+
+        return Result.err([message, ...res.value]);
+      }
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return Result.ok(a as T);
+  };
+
+  const fill: Type<T>['fill'] = (a) =>
+    isRecord(a)
+      ? // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        (Object.fromEntries(
+          Object.entries(source).map(([k, v]) =>
+            tp(k, Object.hasOwn(a, k) ? v.fill(a[k]) : v.defaultValue),
+          ),
+        ) as T)
+      : defaultValue;
+
+  return {
+    typeName: typeNameFilled,
+    defaultValue,
+    fill,
+    validate,
+    is: createIsFn(validate),
+    assertIs: createAssertFn(validate),
+    cast: createCastFn(validate),
+  };
+};
+
+type RecordTypeValue<R extends Record<string, Type<unknown>>> =
+  TsFortressInternal.RecordTypeValueImpl<R>;
+
+namespace TsFortressInternal {
+  export type RecordTypeValueImpl<R extends Record<string, Type<unknown>>> =
+    RecordTypeValueImplSub<R, OptionalTypeKeys<R>>;
+
+  type RecordTypeValueImplSub<
+    A extends Record<string, Type<unknown>>,
+    OptionalKeys extends keyof A,
+  > = Readonly<
+    {
+      [key in OptionalKeys]?: TypeOf<A[key]>;
+    } & {
+      [key in Exclude<keyof A, OptionalKeys>]: TypeOf<A[key]>;
+    }
+  >;
+
+  type OptionalTypeKeys<A extends Record<string, Type<unknown>>> = {
+    [K in keyof A]: A[K] extends { optional: true } ? K : never;
+  }[keyof A];
+}

package/src/record/record.test.mts

@@ -0,0 +1,253 @@
+import { expectType } from 'ts-data-forge';
+import { number } from '../primitives/index.mjs';
+import { type Type, type TypeOf } from '../type.mjs';
+import { optional } from './optional.mjs';
+import { record } from './record.mjs';
+
+describe('record', () => {
+  const ymd = record({
+    year: number(1900),
+    month: number(1),
+    date: number(1),
+  });
+
+  expectType<
+    typeof ymd,
+    Type<Readonly<{ year: number; month: number; date: number }>>
+  >('=');
+
+  type Ymd = TypeOf<typeof ymd>;
+
+  expectType<Ymd, Readonly<{ year: number; month: number; date: number }>>('=');
+
+  expectType<typeof ymd.defaultValue, Ymd>('=');
+
+  describe('is', () => {
+    test('truthy case', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+        month: 12,
+        date: 12,
+      };
+
+      if (ymd.is(x)) {
+        expectType<typeof x, Ymd>('=');
+      } else {
+        expectType<typeof x, UnknownRecord>('=');
+      }
+
+      expect(ymd.is(x)).toBe(true);
+    });
+
+    test('falsy case', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+        month: 'ab',
+        date: 'cd',
+      };
+
+      if (ymd.is(x)) {
+        expectType<typeof x, Ymd>('=');
+      } else {
+        expectType<typeof x, UnknownRecord>('=');
+      }
+
+      expect(ymd.is(x)).toBe(false);
+    });
+  });
+
+  describe('validate', () => {
+    test('falsy case', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+        month: 'ab',
+        date: 'cd',
+      };
+
+      expect(ymd.validate(x).value).toStrictEqual([
+        `The value at record key "month" is expected to be <number>, but it is actually '"ab"'.`,
+        `The value is expected to be <number>, but it is actually '"ab"'.`,
+      ]);
+    });
+  });
+
+  describe('fill', () => {
+    test('from an empty record', () => {
+      const x: UnknownRecord = {};
+
+      expect(ymd.fill(x)).toStrictEqual({
+        year: 1900,
+        month: 1,
+        date: 1,
+      });
+    });
+
+    test('from a filled record', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+        month: 999,
+        date: 999,
+      };
+
+      expect(ymd.fill(x)).toStrictEqual({
+        year: 2000,
+        month: 999,
+        date: 999,
+      });
+    });
+
+    test('from a partial record', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+      };
+
+      expect(ymd.fill(x)).toStrictEqual({
+        year: 2000,
+        month: 1,
+        date: 1,
+      });
+    });
+
+    test('from a partial record with excess property', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+        aaaaa: 9999,
+      };
+
+      expect(ymd.fill(x)).toStrictEqual({
+        year: 2000,
+        month: 1,
+        date: 1,
+      });
+    });
+  });
+});
+
+describe('partial record', () => {
+  const ymd = record({
+    year: number(1900),
+    month: optional(number(1)),
+    date: optional(number(1)),
+  });
+
+  type Ymd = TypeOf<typeof ymd>;
+
+  expectType<Ymd, Readonly<{ year: number; month?: number; date?: number }>>(
+    '=',
+  );
+
+  expectType<typeof ymd.defaultValue, Ymd>('=');
+
+  describe('is', () => {
+    test('truthy case', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+        month: 12,
+      };
+
+      if (ymd.is(x)) {
+        expectType<typeof x, Ymd>('=');
+      } else {
+        expectType<typeof x, UnknownRecord>('=');
+      }
+
+      expect(ymd.is(x)).toBe(true);
+    });
+
+    test('falsy case 1', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+        month: 'ab',
+        date: 'cd',
+      };
+
+      if (ymd.is(x)) {
+        expectType<typeof x, Ymd>('=');
+      } else {
+        expectType<typeof x, UnknownRecord>('=');
+      }
+
+      expect(ymd.is(x)).toBe(false);
+    });
+
+    test('falsy case 2', () => {
+      const x: UnknownRecord = {
+        date: 'cd',
+      };
+
+      if (ymd.is(x)) {
+        expectType<typeof x, Ymd>('=');
+      } else {
+        expectType<typeof x, UnknownRecord>('=');
+      }
+
+      expect(ymd.is(x)).toBe(false);
+    });
+  });
+
+  describe('validate', () => {
+    test('falsy case', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+        month: 'ab',
+        date: 'cd',
+      };
+
+      expect(ymd.validate(x).value).toStrictEqual([
+        `The value at record key "month" is expected to be <number>, but it is actually '"ab"'.`,
+        `The value is expected to be <number>, but it is actually '"ab"'.`,
+      ]);
+    });
+  });
+
+  describe('fill', () => {
+    test('from an empty record', () => {
+      const x: UnknownRecord = {};
+
+      expect(ymd.fill(x)).toStrictEqual({
+        year: 1900,
+        month: 1,
+        date: 1,
+      });
+    });
+
+    test('from a filled record', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+        month: 999,
+        date: 999,
+      };
+
+      expect(ymd.fill(x)).toStrictEqual({
+        year: 2000,
+        month: 999,
+        date: 999,
+      });
+    });
+
+    test('from a partial record', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+      };
+
+      expect(ymd.fill(x)).toStrictEqual({
+        year: 2000,
+        month: 1,
+        date: 1,
+      });
+    });
+
+    test('from a partial record with excess property', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+        aaaaa: 9999,
+      };
+
+      expect(ymd.fill(x)).toStrictEqual({
+        year: 2000,
+        month: 1,
+        date: 1,
+      });
+    });
+  });
+});

package/src/type.mts

@@ -0,0 +1,30 @@
+import { type Result } from 'ts-data-forge';
+
+/**
+ * - `typeName` : Name for this type
+ * - `is` : Type guard function
+ * - `assertIs` : Type assertion function
+ * - `cast` : Cast function
+ * - `fill` : Default value filling function
+ * - `validate` : A base function to be used in `is` and `assertIs`. `validate`
+ *   returns Result.Ok if the value is of Type A, otherwise returns Result.Err
+ *   with error message stack as the value.
+ */
+export type Type<A> = Readonly<{
+  typeName: string;
+  defaultValue: A;
+  is: (a: unknown) => a is A;
+  assertIs: (a: unknown) => asserts a is A;
+  cast: (a: unknown) => A;
+  fill: (a: unknown) => A;
+  validate: (a: unknown) => Result<A, readonly string[]>;
+
+  /** Used in record type */
+  optional?: true;
+}>;
+
+export type TypeOf<A extends Type<unknown>> = A['defaultValue'];
+
+export type OptionalType<A> = MergeIntersection<
+  Type<A> & Readonly<{ optional: true }>
+>;

package/src/unknown.mts

@@ -0,0 +1,17 @@
+import { Result } from 'ts-data-forge';
+import { type Type } from './type.mjs';
+import { createAssertFn, createCastFn } from './utils/index.mjs';
+
+export const unknown = (defaultValue?: unknown): Type<unknown> => ({
+  typeName: 'unknown',
+  defaultValue,
+  is,
+  fill: (a) => a,
+  validate,
+  assertIs: createAssertFn(validate),
+  cast: createCastFn(validate),
+});
+
+const validate: Type<unknown>['validate'] = Result.ok;
+
+const is = (_a: unknown): _a is unknown => true;

package/src/utils/create-assert-fn.mts

@@ -0,0 +1,14 @@
+import { Result } from 'ts-data-forge';
+import { type Type } from '../type.mjs';
+
+const validationResultToString = (result: readonly string[]): string =>
+  `\n${result.join(',\n')}`;
+
+export const createAssertFn =
+  <T,>(validate: Type<T>['validate']) =>
+  (a: unknown): asserts a is T => {
+    const res = validate(a);
+    if (Result.isErr(res)) {
+      throw new Error(validationResultToString(res.value));
+    }
+  };

package/src/utils/create-cast-fn.mts

@@ -0,0 +1,15 @@
+import { Result } from 'ts-data-forge';
+import { type Type } from '../type.mjs';
+
+const validationResultToString = (result: readonly string[]): string =>
+  `\n${result.join(',\n')}`;
+
+export const createCastFn =
+  <T,>(validate: Type<T>['validate']) =>
+  (a: unknown): T => {
+    const res = validate(a);
+    if (Result.isErr(res)) {
+      throw new Error(validationResultToString(res.value));
+    }
+    return res.value;
+  };

package/src/utils/create-is-fn.mts

@@ -0,0 +1,7 @@
+import { Result } from 'ts-data-forge';
+import { type Type } from '../type.mjs';
+
+export const createIsFn =
+  <T,>(validate: Type<T>['validate']) =>
+  (a: unknown): a is T =>
+    Result.isOk(validate(a));

package/src/utils/create-primitive-type.mts

@@ -0,0 +1,35 @@
+import { Result } from 'ts-data-forge';
+import { type Type } from '../type.mjs';
+import { createAssertFn } from './create-assert-fn.mjs';
+import { createCastFn } from './create-cast-fn.mjs';
+import { validationErrorMessage } from './validation-error-message.mjs';
+
+export const createPrimitiveType = <A extends Primitive>({
+  typeName,
+  defaultValue,
+  is,
+}: Readonly<{
+  typeName: string;
+  defaultValue: A;
+  is: (value: unknown) => value is A;
+}>): Type<A> => {
+  const validate: Type<A>['validate'] = (a) =>
+    is(a)
+      ? Result.ok(a)
+      : Result.err([
+          validationErrorMessage(
+            a,
+            `The value is expected to be <${typeName}>`,
+          ),
+        ]);
+
+  return {
+    typeName,
+    defaultValue,
+    is,
+    fill: (a) => (is(a) ? a : defaultValue),
+    validate,
+    assertIs: createAssertFn(validate),
+    cast: createCastFn(validate),
+  };
+};

package/src/utils/create-type.mts

@@ -0,0 +1,28 @@
+import { type Type } from '../type.mjs';
+import { createAssertFn } from './create-assert-fn.mjs';
+import { createCastFn } from './create-cast-fn.mjs';
+import { createIsFn } from './create-is-fn.mjs';
+
+export const createType = <A,>({
+  typeName,
+  defaultValue,
+  validate,
+  fill,
+}: Readonly<{
+  typeName: string;
+  defaultValue: A;
+  validate: Type<A>['validate'];
+  fill?: Type<A>['fill'];
+}>): Type<A> => {
+  const is = createIsFn<A>(validate);
+
+  return {
+    typeName,
+    defaultValue,
+    validate,
+    is,
+    assertIs: createAssertFn(validate),
+    fill: fill ?? ((a) => (is(a) ? a : defaultValue)),
+    cast: createCastFn(validate),
+  };
+};

package/src/utils/index.mts

@@ -0,0 +1,6 @@
+export * from './create-assert-fn.mjs';
+export * from './create-cast-fn.mjs';
+export * from './create-is-fn.mjs';
+export * from './create-primitive-type.mjs';
+export * from './create-type.mjs';
+export * from './validation-error-message.mjs';

package/src/utils/validation-error-message.mts

@@ -0,0 +1,17 @@
+import { Json, Result } from 'ts-data-forge';
+
+export const validationErrorMessage = (
+  a: unknown,
+  prefix: string,
+  suffix: (s: string) => string = (s) => `but it is actually '${s}'`,
+): string => {
+  const stringifyResult = Json.stringify(a);
+
+  if (Result.isErr(stringifyResult)) {
+    return `${prefix}, but it isn't (stringification failed).`;
+  }
+
+  const str = stringifyResult.value;
+
+  return `${prefix}, ${suffix(str)}.`;
+};