@dungarees/zod 0.11.4

package/json.d.ts

@@ -0,0 +1,10 @@
+import type { JsonObject, JsonType } from '@dungarees/core/type-util.ts';
+import { type ZodType } from 'zod';
+export declare const parseJson: <PARSED>({ json, schema, message, schemaMessage, }: {
+    json: string;
+    schema: ZodType<PARSED>;
+    message?: string;
+    schemaMessage?: string;
+}) => PARSED;
+export declare const jsonSchema: ZodType<JsonType>;
+export declare const jsonObjectSchema: ZodType<JsonObject>;

package/json.js

@@ -0,0 +1,36 @@
+import { createCausedError } from '@dungarees/core/error.ts';
+import { z } from 'zod';
+// Constrained on the parsed type rather than on `ZodSchema`, which zod aliases to
+// `ZodType<any, …>` — that would make `parsed.data` an `any` and lose the whole point.
+// The two ways this fails need not read alike: malformed JSON is best reported with the parser's
+// own complaint appended, while a wrong shape often has a better sentence than zod's issue list.
+export const parseJson = ({ json, schema, message = 'Invalid JSON', schemaMessage, }) => {
+    const parsed = schema.safeParse(jsonTextToValue({ json, message }));
+    if (parsed.success) {
+        return parsed.data;
+    }
+    throw new Error(schemaMessage ?? `${message}: ${describeIssues(parsed.error)}`);
+};
+export const jsonSchema = z.lazy(() => z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.undefined(),
+    z.array(jsonSchema),
+    z.record(jsonSchema),
+]));
+// z.record rejects arrays and null, so this matches the type rather than just `typeof === 'object'`.
+export const jsonObjectSchema = z.record(jsonSchema);
+// JSON.parse is typed `any`; returning `unknown` forces the schema to be what narrows it.
+const jsonTextToValue = ({ json, message }) => {
+    try {
+        return JSON.parse(json);
+    }
+    catch (cause) {
+        throw createCausedError({ message, cause });
+    }
+};
+const describeIssues = (error) => error.issues
+    .map(({ path, message }) => (path.length === 0 ? message : `${path.join('.')}: ${message}`))
+    .join(', ');

package/json.test.d.ts

@@ -0,0 +1 @@
+export {};

package/json.test.js

@@ -0,0 +1,64 @@
+import { jsonObjectSchema, jsonSchema, parseJson } from './json.js';
+import { expect, expectTypeOf, test } from 'vitest';
+import { z } from 'zod';
+test('parseJson returns the value typed by the schema', () => {
+    const parsed = parseJson({
+        json: '{"children":{"Version":"1.2.3"}}',
+        schema: z.object({ children: z.object({ Version: z.string() }) }),
+    });
+    expectTypeOf(parsed).toEqualTypeOf();
+    expect(parsed).toEqual({ children: { Version: '1.2.3' } });
+});
+test('parseJson throws when the JSON parses but does not match the schema', () => {
+    expect(() => parseJson({
+        json: '{"children":{"Version":42}}',
+        schema: z.object({ children: z.object({ Version: z.string() }) }),
+        message: 'Unexpected workspace info',
+    })).toThrow('Unexpected workspace info: children.Version: Expected string, received number');
+});
+test('parseJson throws when the text is not JSON at all, keeping the cause', () => {
+    let thrown;
+    try {
+        parseJson({ json: 'not json', schema: z.string(), message: 'Unexpected output' });
+    }
+    catch (error) {
+        thrown = error;
+    }
+    expect(thrown).toBeInstanceOf(Error);
+    expect(thrown.message).toContain('Unexpected output');
+    expect(thrown.cause).toBeInstanceOf(SyntaxError);
+});
+test('parseJson names the top level when the mismatch has no path', () => {
+    expect(() => parseJson({ json: '42', schema: z.string() })).toThrow('Invalid JSON: Expected string, received number');
+});
+test('parseJson replaces the schema issues with schemaMessage when one is given', () => {
+    expect(() => parseJson({
+        json: '{}',
+        schema: z.object({ version: z.string().min(1) }),
+        message: 'Invalid version.json',
+        schemaMessage: 'Version is required in version.json',
+    })).toThrow('Version is required in version.json');
+});
+test('parseJson still reports the syntax error when schemaMessage is given', () => {
+    expect(() => parseJson({
+        json: 'not json',
+        schema: z.object({ version: z.string().min(1) }),
+        message: 'Invalid version.json',
+        schemaMessage: 'Version is required in version.json',
+    })).toThrow(/^Invalid version\.json: Unexpected token/);
+});
+test('jsonObjectSchema accepts a nested JSON object', () => {
+    const parsed = jsonObjectSchema.parse({ a: 1, b: { c: [1, 'x', null] } });
+    expectTypeOf(parsed).toEqualTypeOf();
+    expect(parsed).toEqual({ a: 1, b: { c: [1, 'x', null] } });
+});
+test('jsonObjectSchema rejects anything that is not a JSON object', () => {
+    for (const value of [[], [1, 2], null, 'str', 42, true]) {
+        expect(jsonObjectSchema.safeParse(value).success).toBe(false);
+    }
+});
+test('jsonSchema accepts any JSON value', () => {
+    const parsed = jsonSchema.parse({ a: [1, 'x', null, { b: true }] });
+    expectTypeOf(parsed).toEqualTypeOf();
+    expect(parsed).toEqual({ a: [1, 'x', null, { b: true }] });
+});

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@dungarees/zod",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "type": "module",
+  "dependencies": {
+    "@dungarees/core": "*",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "vitest": "^3.0.2"
+  },
+  "author": "info@productkind.com",
+  "license": "MIT",
+  "version": "0.11.4",
+  "exports": {
+    "./json.test.ts": {
+      "import": "./json.test.js",
+      "types": "./json.test.d.ts"
+    },
+    "./json.ts": {
+      "import": "./json.js",
+      "types": "./json.d.ts"
+    },
+    "./zod.test.ts": {
+      "import": "./zod.test.js",
+      "types": "./zod.test.d.ts"
+    },
+    "./zod.ts": {
+      "import": "./zod.js",
+      "types": "./zod.d.ts"
+    }
+  }
+}

package/zod.d.ts

@@ -0,0 +1,6 @@
+import type { GetAllPaths, GetGuarded, GetValueByPath, Guard } from '@dungarees/core/type-util.ts';
+import { type ZodSchema, type ZodType } from 'zod';
+export type GetSchemaType<SCHEMA = ZodSchema> = SCHEMA extends ZodSchema<infer TYPE> ? TYPE : never;
+export declare const zodGuard: <GUARD extends Guard>(guard: GUARD, message?: string) => ZodSchema<GetGuarded<GUARD>>;
+export declare const getSchemaByObjectPath: <const SCHEMA extends ZodSchema, const PATH extends (GetAllPaths<GetSchemaType<SCHEMA>> & string) | "">(schema: SCHEMA, path: PATH) => ZodSchema<GetValueByPath<GetSchemaType<SCHEMA>, PATH>>;
+export declare const getSchemaByRuntimePath: (schema: ZodType<unknown>, path: string) => ZodType<unknown>;

package/zod.js

@@ -0,0 +1,29 @@
+import { join, split } from '@dungarees/core/util.ts';
+import { z } from 'zod';
+export const zodGuard = (guard, message) => {
+    return z.custom(guard, message);
+};
+const isObjectSchema = (schema) => 'shape' in schema;
+export const getSchemaByObjectPath = (schema, path) => {
+    return _getSchemaByObjectPathHelper(schema, path);
+};
+// A path only known at runtime cannot be checked against the schema, so the caller gets an
+// untyped schema back rather than a precise one it has not earned.
+export const getSchemaByRuntimePath = (schema, path) => _getSchemaByObjectPathHelper(schema, path);
+// Without the untyped helper it is an infinite loop for typecheking
+const _getSchemaByObjectPathHelper = (schema, path) => {
+    if (path === '') {
+        return schema;
+    }
+    if (!isObjectSchema(schema)) {
+        throw new Error('Not an object schema');
+    }
+    const [firstKey, ...restPath] = split(path, '.');
+    // zod types its own shape entries as `ZodTypeAny`, so this is the one place the library's `any`
+    // is pinned down — otherwise it rides out through the return type to every caller.
+    const subschema = schema.shape[firstKey];
+    if (subschema === undefined) {
+        throw new Error('Path does not exist in schema');
+    }
+    return _getSchemaByObjectPathHelper(subschema, join(restPath, '.'));
+};

package/zod.test.d.ts

@@ -0,0 +1 @@
+export {};

package/zod.test.js

@@ -0,0 +1,43 @@
+import { getSchemaByObjectPath, getSchemaByRuntimePath, zodGuard } from './zod.js';
+import { expect, test } from 'vitest';
+import { z } from 'zod';
+test('zodGuard returns a custom schema based on the guard type', () => {
+    const schema = zodGuard((arg) => arg === 1);
+    const one = schema.parse(1);
+    expect(one).toBe(1);
+});
+test('zodGuard accepts custom error', () => {
+    const schema = zodGuard((arg) => arg === 1, 'it is not 1');
+    const result = schema.safeParse(2);
+    if (!result.success) {
+        expect(result.error.issues[0]?.message).toBe('it is not 1');
+    }
+});
+test('getSchemaByObjectPath gets a single key path', () => {
+    const schema = getSchemaByObjectPath(z.object({ key1: z.literal(1), key2: z.literal(2) }), 'key1');
+    const one = schema.parse(1);
+    expect(one).toBe(1);
+});
+test('getSchemaByObjectPath gets a deep key path', () => {
+    const schema = getSchemaByObjectPath(z.object({ key1: z.object({ key2: z.object({ key3: z.literal(3) }) }) }), 'key1.key2.key3');
+    const three = schema.parse(3);
+    expect(three).toBe(3);
+});
+test('getSchemaByObjectPath gets the full object on empty path', () => {
+    const schema = getSchemaByObjectPath(z.object({ key1: z.literal(1), key2: z.literal(2) }), '');
+    const object = schema.parse({ key1: 1, key2: 2 });
+    expect(object).toEqual({ key1: 1, key2: 2 });
+});
+test('getSchemaByRuntimePath resolves a path that is only known at runtime', () => {
+    const path = 'key1.key2';
+    const schema = getSchemaByRuntimePath(z.object({ key1: z.object({ key2: z.literal(2) }) }), path);
+    expect(schema.parse(2)).toBe(2);
+});
+test('getSchemaByRuntimePath throws on a path that does not exist', () => {
+    const path = 'key1.missing';
+    expect(() => getSchemaByRuntimePath(z.object({ key1: z.object({ key2: z.literal(2) }) }), path)).toThrow('Path does not exist in schema');
+});
+test('getSchemaByRuntimePath throws when the path goes through a non-object schema', () => {
+    const path = 'key1.key2';
+    expect(() => getSchemaByRuntimePath(z.object({ key1: z.literal(1) }), path)).toThrow('Not an object schema');
+});