@jakubmazanec/zod-utils 1.0.0-9029e49

package/src/utils/isPackageJson.ts

@@ -0,0 +1,5 @@
+import {type PackageJson, packageJsonSchema} from '../types.js';
+
+export function isPackageJson(value: unknown): value is PackageJson {
+  return packageJsonSchema.safeParse(value).success;
+}

package/src/utils/isTsconfigJson.ts

@@ -0,0 +1,5 @@
+import {type TsconfigJson, tsconfigJsonSchema} from '../types.js';
+
+export function isTsconfigJson(value: unknown): value is TsconfigJson {
+  return tsconfigJsonSchema.safeParse(value).success;
+}

package/src/utils/readFile.ts

@@ -0,0 +1,40 @@
+import {type If} from '@jakubmazanec/ts-utils';
+import {type PathLike} from 'node:fs';
+import fs from 'node:fs/promises';
+import {type z, type ZodTypeAny, type ZodError} from 'zod';
+
+export interface ReadFileOptions {
+  parser?: (rawString: string) => unknown;
+  throwOnZodError?: boolean;
+}
+
+export async function readFile<
+  S extends ZodTypeAny,
+  O extends ReadFileOptions | undefined = undefined,
+>(
+  path: fs.FileHandle | PathLike,
+  schema: S,
+  options?: O,
+): Promise<
+  O extends undefined
+    ? z.infer<S> | ZodError<z.infer<S>>
+    : If<NonNullable<O>['throwOnZodError'], true, z.infer<S>, z.infer<S> | ZodError<z.infer<S>>>
+>;
+export async function readFile(
+  path: fs.FileHandle | PathLike,
+  schema: ZodTypeAny,
+  options?: ReadFileOptions,
+) {
+  let fileParser = options?.parser ?? JSON.parse;
+  let rawJson = fileParser(await fs.readFile(path, {encoding: 'utf8'})) as unknown;
+
+  if (options?.throwOnZodError) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return -- return type is actually defined via the function overload above
+    return schema.parse(rawJson);
+  }
+
+  let result = schema.safeParse(rawJson);
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return -- return type is actually defined via the function overload above
+  return result.success ? result.data : result.error;
+}

package/src/utils/readJson.ts

@@ -0,0 +1,31 @@
+import {type If} from '@jakubmazanec/ts-utils';
+import {type PathLike} from 'node:fs';
+import type fs from 'node:fs/promises';
+import {type z, type ZodTypeAny, type ZodError} from 'zod';
+
+import {readFile} from './readFile.js';
+
+export interface ReadJsonOptions {
+  throwOnZodError?: boolean;
+}
+
+export async function readJson<
+  S extends ZodTypeAny,
+  O extends ReadJsonOptions | undefined = undefined,
+>(
+  path: fs.FileHandle | PathLike,
+  schema: S,
+  options?: O,
+): Promise<
+  O extends undefined
+    ? z.infer<S> | ZodError<z.infer<S>>
+    : If<NonNullable<O>['throwOnZodError'], true, z.infer<S>, z.infer<S> | ZodError<z.infer<S>>>
+>;
+export async function readJson(
+  path: fs.FileHandle | PathLike,
+  schema: ZodTypeAny,
+  options?: ReadJsonOptions,
+) {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return -- return type is actually defined via the function overload above
+  return readFile(path, schema, options);
+}

package/src/utils/readPackageJson.ts

@@ -0,0 +1,26 @@
+import {type If} from '@jakubmazanec/ts-utils';
+import {type PathLike} from 'node:fs';
+import type fs from 'node:fs/promises';
+import {type ZodError} from 'zod';
+
+import {type PackageJson, packageJsonSchema} from '../types.js';
+import {readFile} from './readFile.js';
+
+export interface ReadPackageJsonOptions {
+  throwOnZodError?: boolean;
+}
+
+export async function readPackageJson<O extends ReadPackageJsonOptions | undefined = undefined>(
+  path: fs.FileHandle | PathLike,
+  options?: O,
+): Promise<
+  O extends undefined
+    ? PackageJson | ZodError<PackageJson>
+    : If<NonNullable<O>['throwOnZodError'], true, PackageJson, PackageJson | ZodError<PackageJson>>
+>;
+export async function readPackageJson(
+  path: fs.FileHandle | PathLike,
+  options?: ReadPackageJsonOptions,
+) {
+  return readFile(path, packageJsonSchema, options);
+}

package/src/utils/zodIssuesToString.ts

@@ -0,0 +1,52 @@
+import * as z from 'zod';
+
+function zodIssuePathToText(zodIssuePath: Array<number | string>): string {
+  return zodIssuePath.length > 0 ? ` at path "${zodIssuePath.join('.')}"` : '';
+}
+
+function zodIssueToString(zodIssue: z.ZodIssue): string {
+  if (zodIssue.code === z.ZodIssueCode.invalid_type) {
+    return `Expected "${zodIssue.expected}" but received "${zodIssue.received}"${zodIssuePathToText(
+      zodIssue.path,
+    )}`;
+  }
+
+  if (zodIssue.code === z.ZodIssueCode.unrecognized_keys) {
+    return `Unrecognized ${zodIssue.keys.length >= 2 ? 'keys' : 'key'} ${zodIssue.keys
+      .map((key) => `"${key}"`)
+      .join(', ')}${zodIssuePathToText(zodIssue.path)}`;
+  }
+
+  if (zodIssue.code === z.ZodIssueCode.invalid_union) {
+    return `Invalid union: ${zodIssue.unionErrors
+      .map((unionError) =>
+        unionError.issues
+          .map((issue) => {
+            let zodIssueString = [...zodIssueToString(issue)];
+
+            zodIssueString[0] &&= zodIssueString[0].toLowerCase();
+
+            return zodIssueString.join('');
+          })
+          .join(', '),
+      )
+      .join('; ')}`;
+  }
+
+  if (zodIssue.code === z.ZodIssueCode.invalid_enum_value) {
+    return `Expected ${
+      zodIssue.options.length === 1
+        ? `"${zodIssue.options[0]}"`
+        : `${zodIssue.options
+            .map((option) => `"${option}"`)
+            .slice(0, -1)
+            .join(', ')} or "${zodIssue.options.at(-1)}"`
+    }${zodIssuePathToText(zodIssue.path)}`;
+  }
+
+  return `${zodIssue.message}${zodIssuePathToText(zodIssue.path)}`;
+}
+
+export function zodIssuesToStrings(zodIssues: z.ZodIssue[]): string[] {
+  return zodIssues.map((zodIssue) => zodIssueToString(zodIssue));
+}

package/src/utils.ts

@@ -0,0 +1,7 @@
+export * from './utils/is.js';
+export * from './utils/isPackageJson.js';
+export * from './utils/isTsconfigJson.js';
+export * from './utils/readFile.js';
+export * from './utils/readJson.js';
+export * from './utils/readPackageJson.js';
+export * from './utils/zodIssuesToString.js';